#include "validator.h"

#include <iostream>

#include "proto/human.pb.h"
#include "structs.h"
#include "util/identifiers.h"

namespace com::fourisland::lingo2_archipelago {
namespace {

class Validator {
 public:
  explicit Validator(const CollectedInfo& info) : info_(info) {}

  void Validate() const {
    for (const auto& [map_name, map_info] : info_.maps) {
      ValidateMap(map_name, map_info);
    }
    for (const auto& [room_identifier, room_info] : info_.rooms) {
      ValidateRoom(room_identifier, room_info);
    }
    for (const auto& [door_identifier, door_info] : info_.doors) {
      ValidateDoor(door_identifier, door_info);
    }
    for (const auto& [port_identifier, port_info] : info_.ports) {
      ValidatePort(port_identifier, port_info);
    }
    for (const auto& [painting_identifier, painting_info] : info_.paintings) {
      ValidatePainting(painting_identifier, painting_info);
    }
    for (const auto& [panel_identifier, panel_info] : info_.panels) {
      ValidatePanel(panel_identifier, panel_info);
    }
    for (const auto& [keyholder_identifier, keyholder_info] :
         info_.keyholders) {
      ValidateKeyholder(keyholder_identifier, keyholder_info);
    }
    for (const auto& [letter_identifier, letter_info] : info_.letters) {
      ValidateLetter(letter_identifier, letter_info);
    }
    for (const auto& [ending_name, ending_info] : info_.endings) {
      ValidateEnding(ending_name, ending_info);
    }
    for (const auto& [panel_name, panel_info] : info_.panel_names) {
      ValidatePanelName(panel_name, panel_info);
    }
    for (const auto& [prog_name, prog_info] : info_.progressives) {
      ValidateProgressive(prog_name, prog_info);
    }
    for (const auto& [group_name, group_info] : info_.door_groups) {
      ValidateDoorGroup(group_name, group_info);
    }
  }

 private:
  void ValidateMap(const std::string& map_name, const MapInfo& map_info) const {
    for (const auto& [node_path, node_info] : map_info.game_nodes) {
      if (node_info.uses > 1) {
        std::cout << "Map " << map_name << " node " << node_path
                  << " is used in multiple places." << std::endl;
      } else if (node_info.uses == 0) {
        std::cout << "Map " << map_name << " node " << node_path
                  << " is not used." << std::endl;
      }

      if (!node_info.defined) {
        std::cout << "Map " << map_name << " node " << node_path
                  << " is not defined in the game file." << std::endl;
      }
    }
  }

  void ValidateRoom(const RoomIdentifier& room_identifier,
                    const RoomInfo& room_info) const {
    if (room_info.definitions.empty()) {
      std::cout << "Room " << room_identifier.ShortDebugString()
                << " has no definition, but was referenced:" << std::endl;

      for (const DoorIdentifier& door_identifier :
           room_info.doors_referenced_by) {
        std::cout << "    DOOR " << door_identifier.ShortDebugString()
                  << std::endl;
      }

      for (const PanelIdentifier& panel_identifier :
           room_info.panels_referenced_by) {
        std::cout << "    PANEL " << panel_identifier.ShortDebugString()
                  << std::endl;
      }

      for (const HumanConnection& connection :
           room_info.connections_referenced_by) {
        std::cout << "    CONNECTION " << connection.ShortDebugString()
                  << std::endl;
      }
    } else if (room_info.definitions.size() > 1) {
      std::cout << "Room " << room_identifier.ShortDebugString()
                << " was defined multiple times." << std::endl;
    }
  }

  bool DoesDoorNeedLocationName(const HumanDoor& h_door,
                                const std::string& map_name) const {
    if (h_door.type() != DoorType::STANDARD) {
      return false;
    }

    if (h_door.keyholders_size() > 0 || h_door.endings_size() > 0) {
      return true;
    }

    if (h_door.panels_size() > 4) {
      return true;
    }

    std::set<std::string> map_areas;
    for (const PanelIdentifier& pi : h_door.panels()) {
      auto full_pi =
          GetCompletePanelIdentifierWithoutAnswer(pi, map_name, std::nullopt);
      if (full_pi) {
        auto panel_info_it = info_.panels.find(*full_pi);
        if (panel_info_it != info_.panels.end()) {
          const PanelInfo& panel_info = panel_info_it->second;

          map_areas.insert(panel_info.map_area_name);
        }
      }
    }

    if (map_areas.size() > 1) {
      return true;
    }

    return false;
  }

  void ValidateDoor(const DoorIdentifier& door_identifier,
                    const DoorInfo& door_info) const {
    if (door_info.definitions.empty()) {
      std::cout << "Door " << door_identifier.ShortDebugString()
                << " has no definition, but was referenced:" << std::endl;

      for (const DoorIdentifier& other_door_identifier :
           door_info.doors_referenced_by) {
        std::cout << "    DOOR " << other_door_identifier.ShortDebugString()
                  << std::endl;
      }

      for (const PanelIdentifier& panel_identifier :
           door_info.panels_referenced_by) {
        std::cout << "    PANEL " << panel_identifier.ShortDebugString()
                  << std::endl;
      }

      for (const PaintingIdentifier& painting_identifier :
           door_info.paintings_referenced_by) {
        std::cout << "    PAINTING " << painting_identifier.ShortDebugString()
                  << std::endl;
      }

      for (const PortIdentifier& port_identifier :
           door_info.ports_referenced_by) {
        std::cout << "    PORT " << port_identifier.ShortDebugString()
                  << std::endl;
      }

      for (const HumanConnection& connection :
           door_info.connections_referenced_by) {
        std::cout << "    CONNECTION " << connection.ShortDebugString()
                  << std::endl;
      }

      for (const std::string& prog_name :
           door_info.progressives_referenced_by) {
        std::cout << "    PROGRESSIVE " << prog_name << std::endl;
      }

      for (const std::string& group_name :
           door_info.door_groups_referenced_by) {
        std::cout << "    DOOR GROUP " << group_name << std::endl;
      }

      if (door_info.has_id) {
        std::cout << "    An AP ID is present." << std::endl;
      }
    } else if (door_info.definitions.size() > 1) {
      std::cout << "Door " << door_identifier.ShortDebugString()
                << " was defined multiple times." << std::endl;
    }

    if (door_info.malformed_identifiers.HasAny()) {
      std::cout << "Door " << door_identifier.ShortDebugString()
                << " has malformed identifiers:" << std::endl;

      for (const PaintingIdentifier& painting_identifier :
           door_info.malformed_identifiers.paintings) {
        std::cout << "    PAINTING " << painting_identifier.ShortDebugString()
                  << std::endl;
      }

      for (const PanelIdentifier& panel_identifier :
           door_info.malformed_identifiers.panels) {
        std::cout << "    PANEL " << panel_identifier.ShortDebugString()
                  << std::endl;
      }

      for (const KeyholderIdentifier& keyholder_identifier :
           door_info.malformed_identifiers.keyholders) {
        std::cout << "    KEYHOLDER " << keyholder_identifier.ShortDebugString()
                  << std::endl;
      }
    }

    for (const HumanDoor& h_door : door_info.definitions) {
      if (DoesDoorNeedLocationName(h_door, door_identifier.map()) &&
          !h_door.has_location_name()) {
        std::cout << "Door " << door_identifier.ShortDebugString()
                  << " needs an explicit location name." << std::endl;
      }

      if (h_door.double_letters() &&
          (h_door.type() == DoorType::STANDARD ||
           h_door.type() == DoorType::LOCATION_ONLY ||
           h_door.type() == DoorType::GRAVESTONE)) {
        std::cout << "Door " << door_identifier.ShortDebugString()
                  << " is a location that depends on double_letters."
                  << std::endl;
      }

      bool needs_id = (h_door.type() != DoorType::EVENT);
      if (door_info.has_id != needs_id) {
        if (needs_id) {
          std::cout << "Door " << door_identifier.ShortDebugString()
                    << " is missing an AP ID." << std::endl;
        } else {
          std::cout << "Door " << door_identifier.ShortDebugString()
                    << " should not have an AP ID." << std::endl;
        }
      }
    }
  }

  void ValidatePort(const PortIdentifier& port_identifier,
                    const PortInfo& port_info) const {
    if (port_info.definitions.empty()) {
      std::cout << "Port " << port_identifier.ShortDebugString()
                << " has no definition, but was referenced:" << std::endl;

      for (const HumanConnection& connection :
           port_info.connections_referenced_by) {
        std::cout << "    CONNECTION " << connection.ShortDebugString()
                  << std::endl;
      }
    } else if (port_info.definitions.size() > 1) {
      std::cout << "Port " << port_identifier.ShortDebugString()
                << " was defined multiple times." << std::endl;
    }
  }

  void ValidatePainting(const PaintingIdentifier& painting_identifier,
                        const PaintingInfo& painting_info) const {
    if (painting_info.definitions.empty()) {
      std::cout << "Painting " << painting_identifier.ShortDebugString()
                << " has no definition, but was referenced:" << std::endl;

      for (const DoorIdentifier& door_identifier :
           painting_info.doors_referenced_by) {
        std::cout << "    DOOR " << door_identifier.ShortDebugString()
                  << std::endl;
      }

      for (const HumanConnection& connection :
           painting_info.connections_referenced_by) {
        std::cout << "    CONNECTION " << connection.ShortDebugString()
                  << std::endl;
      }
    } else if (painting_info.definitions.size() > 1) {
      std::cout << "Painting " << painting_identifier.ShortDebugString()
                << " was defined multiple times." << std::endl;
    }
  }

  void ValidatePanel(const PanelIdentifier& panel_identifier,
                     const PanelInfo& panel_info) const {
    if (panel_identifier.name().empty()) {
      std::cout << "Panel " << panel_identifier.ShortDebugString()
                << " has no name." << std::endl;
    }

    if (panel_info.definitions.empty()) {
      std::cout << "Panel " << panel_identifier.ShortDebugString()
                << " has no definition, but was referenced:" << std::endl;

      for (const DoorIdentifier& door_identifier :
           panel_info.doors_referenced_by) {
        std::cout << "    DOOR " << door_identifier.ShortDebugString()
                  << std::endl;
      }

      for (const HumanConnection& connection :
           panel_info.connections_referenced_by) {
        std::cout << "    CONNECTION " << connection.ShortDebugString()
                  << std::endl;
      }

      if (panel_info.has_id) {
        std::cout << "    An AP ID is present." << std::endl;
      }
    } else if (panel_info.definitions.size() > 1) {
      std::cout << "Panel " << panel_identifier.ShortDebugString()
                << " was defined multiple times." << std::endl;
    }

    for (const auto& [answer, proxy_info] : panel_info.proxies) {
      if (proxy_info.definitions.empty()) {
        std::cout << "Panel " << panel_identifier.ShortDebugString()
                  << " with answer \"" << answer
                  << "\" has no definition, but was referenced:" << std::endl;

        for (const DoorIdentifier& door_identifier :
             proxy_info.doors_referenced_by) {
          std::cout << "    DOOR " << door_identifier.ShortDebugString()
                    << std::endl;
        }

        for (const HumanConnection& connection :
             proxy_info.connections_referenced_by) {
          std::cout << "    CONNECTION " << connection.ShortDebugString()
                    << std::endl;
        }
      } else if (proxy_info.definitions.size() > 1) {
        std::cout << "Panel " << panel_identifier.ShortDebugString()
                  << " with answer \"" << answer
                  << "\" was defined multiple times." << std::endl;
      }
    }

    if (!panel_info.has_id) {
      std::cout << "Panel " << panel_identifier.ShortDebugString()
                << " is missing an AP ID." << std::endl;
    }
  }

  void ValidateKeyholder(const KeyholderIdentifier& keyholder_identifier,
                         const KeyholderInfo& keyholder_info) const {
    if (keyholder_info.definitions.empty()) {
      std::cout << "Keyholder " << keyholder_identifier.ShortDebugString()
                << " has no definition, but was referenced:" << std::endl;

      for (const DoorIdentifier& door_identifier :
           keyholder_info.doors_referenced_by) {
        std::cout << "    DOOR " << door_identifier.ShortDebugString()
                  << std::endl;
      }

      if (keyholder_info.has_id) {
        std::cout << "    An AP ID is present." << std::endl;
      }
    } else if (keyholder_info.definitions.size() > 1) {
      std::cout << "Keyholder " << keyholder_identifier.ShortDebugString()
                << " was defined multiple times." << std::endl;
    }

    for (const HumanKeyholder& h_keyholder : keyholder_info.definitions) {
      bool needs_id = (h_keyholder.has_key());

      if (needs_id != keyholder_info.has_id) {
        if (needs_id) {
          std::cout << "Keyholder " << keyholder_identifier.ShortDebugString()
                    << " is missing an AP ID." << std::endl;
        } else {
          std::cout << "Keyholder " << keyholder_identifier.ShortDebugString()
                    << " should not have an AP ID." << std::endl;
        }
      }
    }
  }

  void ValidateLetter(const LetterIdentifier& letter_identifier,
                      const LetterInfo& letter_info) const {
    std::string letter_name = std::string(1, std::get<0>(letter_identifier)) +
                              (std::get<1>(letter_identifier) ? "2" : "1");

    if (letter_info.defined_in.empty()) {
      std::cout << "Letter " << letter_name
                << " has no definition, but was referenced:" << std::endl;

      if (letter_info.has_id) {
        std::cout << "    An AP ID is present." << std::endl;
      }
    } else if (letter_info.defined_in.size() > 1) {
      std::cout << "Letter " << letter_name
                << " was defined in multiple places:" << std::endl;

      for (const RoomIdentifier& room_identifier : letter_info.defined_in) {
        std::cout << "    " << room_identifier.ShortDebugString() << std::endl;
      }
    }

    if (!letter_info.has_id) {
      std::cout << "Letter " << letter_name << " is missing an AP ID."
                << std::endl;
    }
  }

  void ValidateEnding(const std::string& ending_name,
                      const EndingInfo& ending_info) const {
    if (ending_info.defined_in.empty()) {
      std::cout << "Ending " << ending_name
                << " has no definition, but was referenced:" << std::endl;

      for (const DoorIdentifier& door_identifier :
           ending_info.doors_referenced_by) {
        std::cout << "    DOOR " << door_identifier.ShortDebugString()
                  << std::endl;
      }

      if (ending_info.has_id) {
        std::cout << "    An AP ID is present." << std::endl;
      }
    } else if (ending_info.defined_in.size() > 1) {
      std::cout << "Ending " << ending_name
                << " was defined in multiple places:" << std::endl;

      for (const RoomIdentifier& room_identifier : ending_info.defined_in) {
        std::cout << "    " << room_identifier.ShortDebugString() << std::endl;
      }
    }

    if (!ending_info.has_id) {
      std::cout << "Ending " << ending_name << " is missing an AP ID."
                << std::endl;
    }
  }

  void ValidatePanelName(const std::string& panel_name,
                         const PanelNameInfo& panel_info) const {
    if (panel_info.panels_used_by.size() > 1) {
      std::cout << "The location name \"" << panel_name
                << "\" is used by multiple panels:" << std::endl;

      for (const PanelIdentifier& panel_identifier :
           panel_info.panels_used_by) {
        std::cout << "    PANEL " << panel_identifier.ShortDebugString()
                  << std::endl;
      }
    }
  }

  void ValidateProgressive(const std::string& prog_name,
                           const ProgressiveInfo& prog_info) const {
    if (prog_info.definitions.empty()) {
      std::cout << "Progressive \"" << prog_name
                << "\" has no definition, but was referenced:" << std::endl;

      if (prog_info.has_id) {
        std::cout << "    An AP ID is present." << std::endl;
      }
    } else if (prog_info.definitions.size() > 1) {
      std::cout << "Progressive \"" << prog_name
                << "\" has multiple definitions." << std::endl;
    }

    if (!prog_info.has_id) {
      std::cout << "Progressive \"" << prog_name << "\" is missing an AP ID."
                << std::endl;
    }
  }

  void ValidateDoorGroup(const std::string& group_name,
                         const DoorGroupInfo& group_info) const {
    if (group_info.definitions.empty()) {
      std::cout << "Door group \"" << group_name
                << "\" has no definition, but was referenced:" << std::endl;

      if (group_info.has_id) {
        std::cout << "    An AP ID is present." << std::endl;
      }
    } else if (group_info.definitions.size() > 1) {
      std::cout << "Door group \"" << group_name
                << "\" has multiple definitions." << std::endl;
    }

    if (!group_info.has_id) {
      std::cout << "Door group \"" << group_name << "\" is missing an AP ID."
                << std::endl;
    }
  }

  const CollectedInfo& info_;
};

}  // namespace

void ValidateCollectedInfo(const CollectedInfo& info) {
  Validator validator(info);
  validator.Validate();
}

}  // namespace com::fourisland::lingo2_archipelago
435</a>
<a id='n436' href='#n436'>436</a>
<a id='n437' href='#n437'>437</a>
<a id='n438' href='#n438'>438</a>
<a id='n439' href='#n439'>439</a>
<a id='n440' href='#n440'>440</a>
<a id='n441' href='#n441'>441</a>
<a id='n442' href='#n442'>442</a>
<a id='n443' href='#n443'>443</a>
<a id='n444' href='#n444'>444</a>
<a id='n445' href='#n445'>445</a>
<a id='n446' href='#n446'>446</a>
<a id='n447' href='#n447'>447</a>
<a id='n448' href='#n448'>448</a>
<a id='n449' href='#n449'>449</a>
<a id='n450' href='#n450'>450</a>
<a id='n451' href='#n451'>451</a>
<a id='n452' href='#n452'>452</a>
<a id='n453' href='#n453'>453</a>
<a id='n454' href='#n454'>454</a>
<a id='n455' href='#n455'>455</a>
<a id='n456' href='#n456'>456</a>
<a id='n457' href='#n457'>457</a>
<a id='n458' href='#n458'>458</a>
<a id='n459' href='#n459'>459</a>
<a id='n460' href='#n460'>460</a>
<a id='n461' href='#n461'>461</a>
<a id='n462' href='#n462'>462</a>
<a id='n463' href='#n463'>463</a>
<a id='n464' href='#n464'>464</a>
<a id='n465' href='#n465'>465</a>
<a id='n466' href='#n466'>466</a>
<a id='n467' href='#n467'>467</a>
<a id='n468' href='#n468'>468</a>
<a id='n469' href='#n469'>469</a>
<a id='n470' href='#n470'>470</a>
<a id='n471' href='#n471'>471</a>
<a id='n472' href='#n472'>472</a>
<a id='n473' href='#n473'>473</a>
<a id='n474' href='#n474'>474</a>
<a id='n475' href='#n475'>475</a>
<a id='n476' href='#n476'>476</a>
<a id='n477' href='#n477'>477</a>
<a id='n478' href='#n478'>478</a>
<a id='n479' href='#n479'>479</a>
<a id='n480' href='#n480'>480</a>
<a id='n481' href='#n481'>481</a>
<a id='n482' href='#n482'>482</a>
<a id='n483' href='#n483'>483</a>
<a id='n484' href='#n484'>484</a>
<a id='n485' href='#n485'>485</a>
<a id='n486' href='#n486'>486</a>
<a id='n487' href='#n487'>487</a>
<a id='n488' href='#n488'>488</a>
<a id='n489' href='#n489'>489</a>
<a id='n490' href='#n490'>490</a>
<a id='n491' href='#n491'>491</a>
<a id='n492' href='#n492'>492</a>
<a id='n493' href='#n493'>493</a>
<a id='n494' href='#n494'>494</a>
<a id='n495' href='#n495'>495</a>
<a id='n496' href='#n496'>496</a>
<a id='n497' href='#n497'>497</a>
<a id='n498' href='#n498'>498</a>
<a id='n499' href='#n499'>499</a>
<a id='n500' href='#n500'>500</a>
<a id='n501' href='#n501'>501</a>
<a id='n502' href='#n502'>502</a>
<a id='n503' href='#n503'>503</a>
<a id='n504' href='#n504'>504</a>
<a id='n505' href='#n505'>505</a>
<a id='n506' href='#n506'>506</a>
<a id='n507' href='#n507'>507</a>
<a id='n508' href='#n508'>508</a>
<a id='n509' href='#n509'>509</a>
<a id='n510' href='#n510'>510</a>
<a id='n511' href='#n511'>511</a>
<a id='n512' href='#n512'>512</a>
<a id='n513' href='#n513'>513</a>
<a id='n514' href='#n514'>514</a>
<a id='n515' href='#n515'>515</a>
<a id='n516' href='#n516'>516</a>
<a id='n517' href='#n517'>517</a>
<a id='n518' href='#n518'>518</a>
<a id='n519' href='#n519'>519</a>
<a id='n520' href='#n520'>520</a>
<a id='n521' href='#n521'>521</a>
<a id='n522' href='#n522'>522</a>
<a id='n523' href='#n523'>523</a>
<a id='n524' href='#n524'>524</a>
<a id='n525' href='#n525'>525</a>
<a id='n526' href='#n526'>526</a>
<a id='n527' href='#n527'>527</a>
<a id='n528' href='#n528'>528</a>
<a id='n529' href='#n529'>529</a>
<a id='n530' href='#n530'>530</a>
<a id='n531' href='#n531'>531</a>
<a id='n532' href='#n532'>532</a>
<a id='n533' href='#n533'>533</a>
<a id='n534' href='#n534'>534</a>
<a id='n535' href='#n535'>535</a>
<a id='n536' href='#n536'>536</a>
<a id='n537' href='#n537'>537</a>
<a id='n538' href='#n538'>538</a>
<a id='n539' href='#n539'>539</a>
<a id='n540' href='#n540'>540</a>
<a id='n541' href='#n541'>541</a>
<a id='n542' href='#n542'>542</a>
<a id='n543' href='#n543'>543</a>
<a id='n544' href='#n544'>544</a>
<a id='n545' href='#n545'>545</a>
<a id='n546' href='#n546'>546</a>
<a id='n547' href='#n547'>547</a>
<a id='n548' href='#n548'>548</a>
<a id='n549' href='#n549'>549</a>
<a id='n550' href='#n550'>550</a>
<a id='n551' href='#n551'>551</a>
<a id='n552' href='#n552'>552</a>
<a id='n553' href='#n553'>553</a>
<a id='n554' href='#n554'>554</a>
<a id='n555' href='#n555'>555</a>
<a id='n556' href='#n556'>556</a>
<a id='n557' href='#n557'>557</a>
<a id='n558' href='#n558'>558</a>
<a id='n559' href='#n559'>559</a>
<a id='n560' href='#n560'>560</a>
<a id='n561' href='#n561'>561</a>
<a id='n562' href='#n562'>562</a>
<a id='n563' href='#n563'>563</a>
<a id='n564' href='#n564'>564</a>
<a id='n565' href='#n565'>565</a>
<a id='n566' href='#n566'>566</a>
<a id='n567' href='#n567'>567</a>
<a id='n568' href='#n568'>568</a>
<a id='n569' href='#n569'>569</a>
<a id='n570' href='#n570'>570</a>
<a id='n571' href='#n571'>571</a>
<a id='n572' href='#n572'>572</a>
<a id='n573' href='#n573'>573</a>
<a id='n574' href='#n574'>574</a>
<a id='n575' href='#n575'>575</a>
<a id='n576' href='#n576'>576</a>
<a id='n577' href='#n577'>577</a>
<a id='n578' href='#n578'>578</a>
<a id='n579' href='#n579'>579</a>
<a id='n580' href='#n580'>580</a>
<a id='n581' href='#n581'>581</a>
<a id='n582' href='#n582'>582</a>
<a id='n583' href='#n583'>583</a>
<a id='n584' href='#n584'>584</a>
<a id='n585' href='#n585'>585</a>
<a id='n586' href='#n586'>586</a>
<a id='n587' href='#n587'>587</a>
<a id='n588' href='#n588'>588</a>
<a id='n589' href='#n589'>589</a>
<a id='n590' href='#n590'>590</a>
<a id='n591' href='#n591'>591</a>
<a id='n592' href='#n592'>592</a>
<a id='n593' href='#n593'>593</a>
<a id='n594' href='#n594'>594</a>
<a id='n595' href='#n595'>595</a>
<a id='n596' href='#n596'>596</a>
<a id='n597' href='#n597'>597</a>
<a id='n598' href='#n598'>598</a>
<a id='n599' href='#n599'>599</a>
<a id='n600' href='#n600'>600</a>
<a id='n601' href='#n601'>601</a>
<a id='n602' href='#n602'>602</a>
<a id='n603' href='#n603'>603</a>
<a id='n604' href='#n604'>604</a>
<a id='n605' href='#n605'>605</a>
<a id='n606' href='#n606'>606</a>
<a id='n607' href='#n607'>607</a>
<a id='n608' href='#n608'>608</a>
<a id='n609' href='#n609'>609</a>
<a id='n610' href='#n610'>610</a>
<a id='n611' href='#n611'>611</a>
<a id='n612' href='#n612'>612</a>
<a id='n613' href='#n613'>613</a>
<a id='n614' href='#n614'>614</a>
<a id='n615' href='#n615'>615</a>
<a id='n616' href='#n616'>616</a>
<a id='n617' href='#n617'>617</a>
<a id='n618' href='#n618'>618</a>
<a id='n619' href='#n619'>619</a>
<a id='n620' href='#n620'>620</a>
<a id='n621' href='#n621'>621</a>
<a id='n622' href='#n622'>622</a>
</pre></td>
<td class='lines'><pre><code>