int EditableLevelPaletteHeaders::load(const Tbyte* data) {
  // Clear existing storage
  primaryStorage_.clear();

  // Count of bytes read
  int byteCount = 0;
  LoadHelper loader(data,
                    byteCount);
                    
  if (loader.version() > 0) {
    throw UnrecognizedVersionException(TALES_SRCANDLINE,
                                       "EditableLevelPaletteHeaders::load("
                                       "const Tbyte*)",
                                       DataChunkIDs::levelPaletteHeaders,
                                       "EditableLevelPaletteHeaders",
                                       loader.version(),
                                       0);
  }
  
  // Get header address
  tableHeaderAddress_ = ByteConversion::fromBytes(
                          data + byteCount,
                          ByteSizes::uint32Size,
                          EndiannessTypes::little,
                          SignednessTypes::nosign);
  byteCount += ByteSizes::uint32Size;
  
  // Get content address
  tableContentAddress_ = ByteConversion::fromBytes(
                          data + byteCount,
                          ByteSizes::uint32Size,
                          EndiannessTypes::little,
                          SignednessTypes::nosign);
  byteCount += ByteSizes::uint32Size;
  
  // Get number of entries
  int numEntries = ByteConversion::fromBytes(
                          data + byteCount,
                          ByteSizes::uint16Size,
                          EndiannessTypes::little,
                          SignednessTypes::nosign);
  byteCount += ByteSizes::uint16Size;
  
  // Read each entry
  for (int i = 0; i < numEntries; i++) {
    LevelPaletteHeader header;
    
    byteCount += header.load(data + byteCount);
    
    primaryStorage_.push_back(header);
  }
  
//  std::cout << "bytecount: " << byteCount << std::endl;
  
  // Read map key table
  byteCount += mapnumToIndex_.readFromData(data + byteCount);
  
  // Return number of bytes read
  return byteCount;
}
int EditableSlopeSpeedValues::load(const Tbyte* data) {
  // Clear existing entries
  speedValues_.clear();
  
  // Count of bytes read
  int byteCount = 0;
  LoadHelper loader(data,
                    byteCount);
                    
  if (loader.version() > 0) {
    throw UnrecognizedVersionException(TALES_SRCANDLINE,
                                       "EditableSlopeSpeedValues::load("
                                       "const Tbyte*)",
                                       DataChunkIDs::slopeSpeedValues,
                                       "EditableSlopeSpeedValues",
                                       loader.version(),
                                       0);
  }
  
  // Get base address
  baseAddress_
    = ByteConversion::fromBytes(data + byteCount,
                                ByteSizes::uint32Size,
                                EndiannessTypes::little,
                                SignednessTypes::nosign);
  byteCount += ByteSizes::uint32Size;
  
  // Get number of entries
  int numEntries
    = ByteConversion::fromBytes(data + byteCount,
                                ByteSizes::uint16Size,
                                EndiannessTypes::little,
                                SignednessTypes::nosign);
  byteCount += ByteSizes::uint16Size;
  
  // Read each entry
  for (int i = 0; i < numEntries; i++) {
    int value
      = ByteConversion::fromBytes(data + byteCount,
                                  ByteSizes::int16Size,
                                  EndiannessTypes::little,
                                  SignednessTypes::sign);
    byteCount += ByteSizes::int16Size;
    
    // TODO: negative saved values are 1 less than they should be
    // probably a bug in toBytes
    if (value < -1) {
//      value += 1;
    }
    
    speedValues_.push_back(value);
  }
  
  return byteCount;
}
int EditablePowerUpData::load(const Tbyte* data) {
  int byteCount = 0;
  LoadHelper loader(data,
                    byteCount);
                    
  if (loader.version() > 0) {
    throw UnrecognizedVersionException(TALES_SRCANDLINE,
                                       "EditablePowerUpData::load("
                                       "const Tbyte*)",
                                       DataChunkIDs::powerUpData,
                                       "EditablePowerUpData",
                                       loader.version(),
                                       0);
  }
  
  powerUpTableAddress_ = ByteConversion::fromBytes(
                          data + byteCount,
                          ByteSizes::uint32Size,
                          EndiannessTypes::little,
                          SignednessTypes::nosign);
  byteCount += ByteSizes::uint32Size;
    
  for (int i = 0; i < numPowerUps_; i++) {
    maxHealthPerPowerup_[i] = ByteConversion::fromBytes(
                            data + byteCount,
                            ByteSizes::uint8Size,
                            EndiannessTypes::little,
                            SignednessTypes::nosign);
    byteCount += ByteSizes::uint8Size;
    
    // Get flight time
    flightTimePerPowerup_[i] = ByteConversion::fromBytes(
                            data + byteCount,
                            ByteSizes::uint16Size,
                            EndiannessTypes::little,
                            SignednessTypes::nosign);
    byteCount += ByteSizes::uint16Size;
  }
  
  return byteCount;
}
/**
 * Loads from a byte array.
 * @param data Byte array to load from.
 * @return The number of bytes read.
 */
int EditableMetatileHeightMaps::load(const Tbyte* data) {
  // Count of loaded bytes
  int byteCount = 0;
  LoadHelper loader(data,
                    byteCount);
                    
  if (loader.version() > 0) {
    throw UnrecognizedVersionException(TALES_SRCANDLINE,
                                       "EditableMetatileHeightMaps::load("
                                       "const Tbyte*)",
                                       DataChunkIDs::metatileHeightMaps,
                                       "EditableMetatileHeightMaps",
                                       loader.version(),
                                       0);
  }
  
  loadInternal(data,
               byteCount);
  
  return byteCount;
}
int EditableLevelObjectEntryGroups::load(const Tbyte* data) {
  int byteCount = 0;
  LoadHelper loader(data,
                    byteCount);
                    
  if (loader.version() > 0) {
    throw UnrecognizedVersionException(TALES_SRCANDLINE,
                                       "EditableLevelObjectEntryGroups::load("
                                       "const Tbyte*)",
                                       DataChunkIDs::levelObjectEntryGroups,
                                       "EditableLevelObjectEntryGroups",
                                       loader.version(),
                                       0);
  }
  
  movedToNewBank_ = static_cast<bool>(
                      ByteConversion::fromBytes(
                          data + byteCount,
                          ByteSizes::uint8Size,
                          EndiannessTypes::little,
                          SignednessTypes::nosign));
  byteCount += ByteSizes::uint8Size;
  
  tableHeaderSize_ = ByteConversion::fromBytes(
                          data + byteCount,
                          ByteSizes::uint32Size,
                          EndiannessTypes::little,
                          SignednessTypes::nosign);
  byteCount += ByteSizes::uint32Size;
  
  initialTableAddress_ = ByteConversion::fromBytes(
                          data + byteCount,
                          ByteSizes::uint32Size,
                          EndiannessTypes::little,
                          SignednessTypes::nosign);
  byteCount += ByteSizes::uint32Size;
  
  initialTableContentSize_ = ByteConversion::fromBytes(
                          data + byteCount,
                          ByteSizes::uint32Size,
                          EndiannessTypes::little,
                          SignednessTypes::nosign);
  byteCount += ByteSizes::uint32Size;
  
  // Read C1 and C3 code segments
  
  std::memcpy(codeSegmentC1,
              data + byteCount,
              lengthOfC1Segment);
  byteCount += lengthOfC1Segment;
  
  std::memcpy(codeSegmentC3,
              data + byteCount,
              lengthOfC3Segment);
  byteCount += lengthOfC3Segment;
  
//  byteCount
//      += BaseEditableMappedData<LevelObjectEntryGroup>::load(data
//                                                             + byteCount);

  int mainLoadByteCount = 0;
  BaseEditableMappedData<LevelObjectEntryGroup>
            ::loadInternal(data + byteCount,
                           mainLoadByteCount);
  byteCount += mainLoadByteCount;
      
  return byteCount;
}