// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::ParserGenerator::setup_actions()
void setup_actions() {
    g["Definition"] = [&](const SemanticValues &vs, std::any &dt) {
      auto &data = *std::any_cast<Data *>(dt);

      auto is_macro = vs.choice() == 0;
      auto ignore = std::any_cast<bool>(vs[0]);
      auto name = std::any_cast<std::string>(vs[1]);

      std::vector<std::string> params;
      std::shared_ptr<Ope> ope;
      auto has_instructions = false;

      if (is_macro) {
        params = std::any_cast<std::vector<std::string>>(vs[2]);
        ope = std::any_cast<std::shared_ptr<Ope>>(vs[4]);
        if (vs.size() == 6) { has_instructions = true; }
      } else {
        ope = std::any_cast<std::shared_ptr<Ope>>(vs[3]);
        if (vs.size() == 5) { has_instructions = true; }
      }

      if (has_instructions) {
        auto index = is_macro ? 5 : 4;
        std::unordered_set<std::string> types;
        for (const auto &instruction :
             std::any_cast<std::vector<Instruction>>(vs[index])) {
          const auto &type = instruction.type;
          if (types.find(type) == types.end()) {
            data.instructions[name].push_back(instruction);
            types.insert(instruction.type);
            if (type == "declare_symbol" || type == "check_symbol") {
              if (!TokenChecker::is_token(*ope)) { ope = tok(ope); }
            }
          } else {
            data.duplicates_of_instruction.emplace_back(type,
                                                        instruction.sv.data());
          }
        }
      }

      auto &grammar = *data.grammar;
      if (!grammar.count(name)) {
        auto &rule = grammar[name];
        rule <= ope;
        rule.name = name;
        rule.s_ = vs.sv().data();
        rule.line_ = line_info(vs.ss, rule.s_);
        rule.ignoreSemanticValue = ignore;
        rule.is_macro = is_macro;
        rule.params = params;

        if (data.start.empty()) {
          data.start = rule.name;
          data.start_pos = rule.s_;
        }
      } else {
        data.duplicates_of_definition.emplace_back(name, vs.sv().data());
      }
    };

    g["Definition"].enter = [](const Context & /*c*/, const char * /*s*/,
                               size_t /*n*/, std::any &dt) {
      auto &data = *std::any_cast<Data *>(dt);
      data.captures_in_current_definition.clear();
    };

    g["Expression"] = [&](const SemanticValues &vs) {
      if (vs.size() == 1) {
        return std::any_cast<std::shared_ptr<Ope>>(vs[0]);
      } else {
        std::vector<std::shared_ptr<Ope>> opes;
        for (auto i = 0u; i < vs.size(); i++) {
          opes.emplace_back(std::any_cast<std::shared_ptr<Ope>>(vs[i]));
        }
        const std::shared_ptr<Ope> ope =
            std::make_shared<PrioritizedChoice>(opes);
        return ope;
      }
    };

    g["Sequence"] = [&](const SemanticValues &vs) {
      if (vs.empty()) {
        return npd(lit(""));
      } else if (vs.size() == 1) {
        return std::any_cast<std::shared_ptr<Ope>>(vs[0]);
      } else {
        std::vector<std::shared_ptr<Ope>> opes;
        for (const auto &x : vs) {
          opes.emplace_back(std::any_cast<std::shared_ptr<Ope>>(x));
        }
        const std::shared_ptr<Ope> ope = std::make_shared<Sequence>(opes);
        return ope;
      }
    };

    g["Prefix"] = [&](const SemanticValues &vs) {
      std::shared_ptr<Ope> ope;
      if (vs.size() == 1) {
        ope = std::any_cast<std::shared_ptr<Ope>>(vs[0]);
      } else {
        assert(vs.size() == 2);
        auto tok = std::any_cast<char>(vs[0]);
        ope = std::any_cast<std::shared_ptr<Ope>>(vs[1]);
        if (tok == '&') {
          ope = apd(ope);
        } else { // '!'
          ope = npd(ope);
        }
      }
      return ope;
    };

    g["SuffixWithLabel"] = [&](const SemanticValues &vs, std::any &dt) {
      auto ope = std::any_cast<std::shared_ptr<Ope>>(vs[0]);
      if (vs.size() == 1) {
        return ope;
      } else {
        assert(vs.size() == 2);
        auto &data = *std::any_cast<Data *>(dt);
        const auto &ident = std::any_cast<std::string>(vs[1]);
        auto label = ref(*data.grammar, ident, vs.sv().data(), false, {});
        auto recovery = rec(ref(*data.grammar, RECOVER_DEFINITION_NAME,
                                vs.sv().data(), true, {label}));
        return cho4label_(ope, recovery);
      }
    };

    struct Loop {
      enum class Type { opt = 0, zom, oom, rep };
      Type type;
      std::pair<size_t, size_t> range;
    };

    g["Suffix"] = [&](const SemanticValues &vs) {
      auto ope = std::any_cast<std::shared_ptr<Ope>>(vs[0]);
      if (vs.size() == 1) {
        return ope;
      } else {
        assert(vs.size() == 2);
        auto loop = std::any_cast<Loop>(vs[1]);
        switch (loop.type) {
        case Loop::Type::opt: return opt(ope);
        case Loop::Type::zom: return zom(ope);
        case Loop::Type::oom: return oom(ope);
        default: // Regex-like repetition
          return rep(ope, loop.range.first, loop.range.second);
        }
      }
    };

    g["Loop"] = [&](const SemanticValues &vs) {
      switch (vs.choice()) {
      case 0: // Option
        return Loop{Loop::Type::opt, std::pair<size_t, size_t>()};
      case 1: // Zero or More
        return Loop{Loop::Type::zom, std::pair<size_t, size_t>()};
      case 2: // One or More
        return Loop{Loop::Type::oom, std::pair<size_t, size_t>()};
      default: // Regex-like repetition
        return Loop{Loop::Type::rep,
                    std::any_cast<std::pair<size_t, size_t>>(vs[0])};
      }
    };

    g["Primary"] = [&](const SemanticValues &vs, std::any &dt) {
      auto &data = *std::any_cast<Data *>(dt);

      switch (vs.choice()) {
      case 0:   // Macro Reference
      case 1: { // Reference
        auto is_macro = vs.choice() == 0;
        auto ignore = std::any_cast<bool>(vs[0]);
        const auto &ident = std::any_cast<std::string>(vs[1]);

        std::vector<std::shared_ptr<Ope>> args;
        if (is_macro) {
          args = std::any_cast<std::vector<std::shared_ptr<Ope>>>(vs[2]);
        }

        auto ope = ref(*data.grammar, ident, vs.sv().data(), is_macro, args);
        if (ident == RECOVER_DEFINITION_NAME) { ope = rec(ope); }

        if (ignore) {
          return ign(ope);
        } else {
          return ope;
        }
      }
      case 2: { // (Expression)
        return std::any_cast<std::shared_ptr<Ope>>(vs[0]);
      }
      case 3: { // TokenBoundary
        return tok(std::any_cast<std::shared_ptr<Ope>>(vs[0]));
      }
      case 4: { // CaptureScope
        return csc(std::any_cast<std::shared_ptr<Ope>>(vs[0]));
      }
      case 5: { // Capture
        const auto &name = std::any_cast<std::string_view>(vs[0]);
        auto ope = std::any_cast<std::shared_ptr<Ope>>(vs[1]);

        data.captures_stack.back().insert(name);
        data.captures_in_current_definition.insert(name);

        return cap(ope, [name](const char *a_s, size_t a_n, Context &c) {
          auto &cs = c.capture_scope_stack[c.capture_scope_stack_size - 1];
          cs[name] = std::string(a_s, a_n);
        });
      }
      default: {
        return std::any_cast<std::shared_ptr<Ope>>(vs[0]);
      }
      }
    };

    g["IdentCont"] = [](const SemanticValues &vs) {
      return std::string(vs.sv().data(), vs.sv().length());
    };

    g["Dictionary"] = [](const SemanticValues &vs) {
      auto items = vs.transform<std::string>();
      return dic(items, false);
    };
    g["DictionaryI"] = [](const SemanticValues &vs) {
      auto items = vs.transform<std::string>();
      return dic(items, true);
    };

    g["Literal"] = [](const SemanticValues &vs) {
      const auto &tok = vs.tokens.front();
      return lit(resolve_escape_sequence(tok.data(), tok.size()));
    };
    g["LiteralI"] = [](const SemanticValues &vs) {
      const auto &tok = vs.tokens.front();
      return liti(resolve_escape_sequence(tok.data(), tok.size()));
    };
    g["LiteralD"] = [](const SemanticValues &vs) {
      auto &tok = vs.tokens.front();
      return resolve_escape_sequence(tok.data(), tok.size());
    };
    g["LiteralID"] = [](const SemanticValues &vs) {
      auto &tok = vs.tokens.front();
      return resolve_escape_sequence(tok.data(), tok.size());
    };

    g["Class"] = [](const SemanticValues &vs) {
      auto ranges = vs.transform<std::pair<char32_t, char32_t>>();
      return cls(ranges);
    };
    g["ClassI"] = [](const SemanticValues &vs) {
      auto ranges = vs.transform<std::pair<char32_t, char32_t>>();
      return cls(ranges, true);
    };
    g["NegatedClass"] = [](const SemanticValues &vs) {
      auto ranges = vs.transform<std::pair<char32_t, char32_t>>();
      return ncls(ranges);
    };
    g["NegatedClassI"] = [](const SemanticValues &vs) {
      auto ranges = vs.transform<std::pair<char32_t, char32_t>>();
      return ncls(ranges, true);
    };
    g["Range"] = [](const SemanticValues &vs) {
      switch (vs.choice()) {
      case 0: {
        auto s1 = std::any_cast<std::string>(vs[0]);
        auto s2 = std::any_cast<std::string>(vs[1]);
        auto cp1 = decode_codepoint(s1.data(), s1.length());
        auto cp2 = decode_codepoint(s2.data(), s2.length());
        if (cp1 > cp2) {
          throw SyntaxErrorException("characer range is out of order...",
                                     vs.line_info());
        }
        return std::pair(cp1, cp2);
      }
      case 1: {
        auto s = std::any_cast<std::string>(vs[0]);
        auto cp = decode_codepoint(s.data(), s.length());
        return std::pair(cp, cp);
      }
      }
      return std::pair<char32_t, char32_t>(0, 0);
    };
    g["Char"] = [](const SemanticValues &vs) {
      return resolve_escape_sequence(vs.sv().data(), vs.sv().length());
    };

    g["RepetitionRange"] = [&](const SemanticValues &vs) {
      switch (vs.choice()) {
      case 0: { // Number COMMA Number
        auto min = std::any_cast<size_t>(vs[0]);
        auto max = std::any_cast<size_t>(vs[1]);
        return std::pair(min, max);
      }
      case 1: // Number COMMA
        return std::pair(std::any_cast<size_t>(vs[0]),
                         std::numeric_limits<size_t>::max());
      case 2: { // Number
        auto n = std::any_cast<size_t>(vs[0]);
        return std::pair(n, n);
      }
      default: // COMMA Number
        return std::pair(std::numeric_limits<size_t>::min(),
                         std::any_cast<size_t>(vs[0]));
      }
    };
    g["Number"] = [&](const SemanticValues &vs) {
      return vs.token_to_number<size_t>();
    };

    g["CapScope"].enter = [](const Context & /*c*/, const char * /*s*/,
                             size_t /*n*/, std::any &dt) {
      auto &data = *std::any_cast<Data *>(dt);
      data.captures_stack.emplace_back();
    };
    g["CapScope"].leave = [](const Context & /*c*/, const char * /*s*/,
                             size_t /*n*/, size_t /*matchlen*/,
                             std::any & /*value*/, std::any &dt) {
      auto &data = *std::any_cast<Data *>(dt);
      data.captures_stack.pop_back();
    };

    g["AND"] = [](const SemanticValues &vs) { return *vs.sv().data(); };
    g["NOT"] = [](const SemanticValues &vs) { return *vs.sv().data(); };
    g["QUESTION"] = [](const SemanticValues &vs) { return *vs.sv().data(); };
    g["STAR"] = [](const SemanticValues &vs) { return *vs.sv().data(); };
    g["PLUS"] = [](const SemanticValues &vs) { return *vs.sv().data(); };

    g["DOT"] = [](const SemanticValues & /*vs*/) { return dot(); };

    g["CUT"] = [](const SemanticValues & /*vs*/) { return cut(); };

    g["BeginCap"] = [](const SemanticValues &vs) { return vs.token(); };

    g["BackRef"] = [&](const SemanticValues &vs, std::any &dt) {
      auto &data = *std::any_cast<Data *>(dt);

      // Undefined back reference check
      {
        auto found = false;
        auto it = data.captures_stack.rbegin();
        while (it != data.captures_stack.rend()) {
          if (it->find(vs.token()) != it->end()) {
            found = true;
            break;
          }
          ++it;
        }
        if (!found) {
          auto ptr = vs.token().data() - 1; // include '$' symbol
          data.undefined_back_references.emplace_back(vs.token(), ptr);
        }
      }

      // NOTE: Disable packrat parsing if a back reference is not defined in
      // captures in the current definition rule.
      if (data.captures_in_current_definition.find(vs.token()) ==
          data.captures_in_current_definition.end()) {
        data.enablePackratParsing = false;
      }

      return bkr(vs.token_to_string());
    };

    g["Ignore"] = [](const SemanticValues &vs) { return vs.size() > 0; };

    g["Parameters"] = [](const SemanticValues &vs) {
      return vs.transform<std::string>();
    };

    g["Arguments"] = [](const SemanticValues &vs) {
      return vs.transform<std::shared_ptr<Ope>>();
    };

    g["PrecedenceClimbing"] = [](const SemanticValues &vs) {
      PrecedenceClimbing::BinOpeInfo binOpeInfo;
      size_t level = 1;
      for (auto v : vs) {
        auto tokens = std::any_cast<std::vector<std::string_view>>(v);
        auto assoc = tokens[0][0];
        for (size_t i = 1; i < tokens.size(); i++) {
          binOpeInfo[tokens[i]] = std::pair(level, assoc);
        }
        level++;
      }
      Instruction instruction;
      instruction.type = "precedence";
      instruction.data = binOpeInfo;
      instruction.sv = vs.sv();
      return instruction;
    };
    g["PrecedenceInfo"] = [](const SemanticValues &vs) {
      return vs.transform<std::string_view>();
    };
    g["PrecedenceOpe"] = [](const SemanticValues &vs) { return vs.token(); };
    g["PrecedenceAssoc"] = [](const SemanticValues &vs) { return vs.token(); };

    g["ErrorMessage"] = [](const SemanticValues &vs) {
      Instruction instruction;
      instruction.type = "error_message";
      instruction.data = std::any_cast<std::string>(vs[0]);
      instruction.sv = vs.sv();
      return instruction;
    };

    g["NoAstOpt"] = [](const SemanticValues &vs) {
      Instruction instruction;
      instruction.type = "no_ast_opt";
      instruction.sv = vs.sv();
      return instruction;
    };

    g["Instruction"] = [](const SemanticValues &vs) {
      return vs.transform<Instruction>();
    };
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x578, %rsp            # imm = 0x578
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x580(%rbp)
leaq 0x7db6(%rip), %rax      # 0x23e30
movq %rax, -0x568(%rbp)
leaq 0x7dc6(%rip), %rax      # 0x23e4e
movq %rax, -0x570(%rbp)
leaq 0x1d70c(%rip), %rsi     # 0x397a2
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x580(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x580(%rbp), %rdi
callq 0x3209c
leaq 0x1d6c4(%rip), %rsi     # 0x397a2
leaq -0x30(%rbp), %rdi
leaq -0x31(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
subq $-0x80, %rax
leaq -0x9(%rbp), %rsi
movq %rax, %rdi
callq 0x23d3a
leaq -0x30(%rbp), %rdi
callq 0x9140
xorps %xmm0, %xmm0
movaps %xmm0, -0x560(%rbp)
leaq 0x9f49(%rip), %rax      # 0x2606a
movq %rax, -0x548(%rbp)
leaq 0x9f57(%rip), %rax      # 0x26086
movq %rax, -0x550(%rbp)
leaq 0x1d6a0(%rip), %rsi     # 0x397dd
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x560(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x560(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x540(%rbp)
leaq 0xa1ff(%rip), %rax      # 0x2638e
movq %rax, -0x528(%rbp)
leaq 0xa20d(%rip), %rax      # 0x263aa
movq %rax, -0x530(%rbp)
leaq 0x1d654(%rip), %rsi     # 0x397ff
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x540(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x540(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x520(%rbp)
leaq 0xa4ab(%rip), %rax      # 0x266a8
movq %rax, -0x508(%rbp)
leaq 0xa4b9(%rip), %rax      # 0x266c4
movq %rax, -0x510(%rbp)
leaq 0x1d5f9(%rip), %rsi     # 0x39812
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x520(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x520(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x500(%rbp)
leaq 0xa8f7(%rip), %rax      # 0x26b62
movq %rax, -0x4e8(%rbp)
leaq 0xa907(%rip), %rax      # 0x26b80
movq %rax, -0x4f0(%rbp)
leaq 0x1d59a(%rip), %rsi     # 0x39821
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x500(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x500(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x4e0(%rbp)
leaq 0xb1f3(%rip), %rax      # 0x274cc
movq %rax, -0x4c8(%rbp)
leaq 0xb201(%rip), %rax      # 0x274e8
movq %rax, -0x4d0(%rbp)
leaq 0x1d53c(%rip), %rsi     # 0x39831
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x4e0(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x4e0(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x4c0(%rbp)
leaq 0xb46b(%rip), %rax      # 0x277b2
movq %rax, -0x4a8(%rbp)
leaq 0xb479(%rip), %rax      # 0x277ce
movq %rax, -0x4b0(%rbp)
leaq 0x1d4e3(%rip), %rsi     # 0x39846
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x4c0(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x4c0(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x4a0(%rbp)
leaq 0xb659(%rip), %rax      # 0x27a0e
movq %rax, -0x488(%rbp)
leaq 0xb669(%rip), %rax      # 0x27a2c
movq %rax, -0x490(%rbp)
leaq 0x1d46d(%rip), %rsi     # 0x3983e
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x4a0(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x4a0(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x480(%rbp)
leaq 0xc83d(%rip), %rax      # 0x28c60
movq %rax, -0x468(%rbp)
leaq 0xc84b(%rip), %rax      # 0x28c7c
movq %rax, -0x470(%rbp)
leaq 0x1d37f(%rip), %rsi     # 0x397be
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x480(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x480(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x460(%rbp)
leaq 0xc90f(%rip), %rax      # 0x28da0
movq %rax, -0x448(%rbp)
leaq 0xc91d(%rip), %rax      # 0x28dbc
movq %rax, -0x450(%rbp)
leaq 0x1d40e(%rip), %rsi     # 0x398bb
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x460(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x460(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x440(%rbp)
leaq 0xd32f(%rip), %rax      # 0x2982e
movq %rax, -0x428(%rbp)
leaq 0xd33d(%rip), %rax      # 0x2984a
movq %rax, -0x430(%rbp)
leaq 0x1d38b(%rip), %rsi     # 0x398a6
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x440(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x440(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x420(%rbp)
leaq 0xd3df(%rip), %rax      # 0x2994c
movq %rax, -0x408(%rbp)
leaq 0xd3ed(%rip), %rax      # 0x29968
movq %rax, -0x410(%rbp)
leaq 0x1d33d(%rip), %rsi     # 0x398c6
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x420(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x420(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x400(%rbp)
leaq 0xd861(%rip), %rax      # 0x29e3c
movq %rax, -0x3e8(%rbp)
leaq 0xd86f(%rip), %rax      # 0x29e58
movq %rax, -0x3f0(%rbp)
leaq 0x1d2bb(%rip), %rsi     # 0x398b2
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x400(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x400(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x3e0(%rbp)
leaq 0xd95d(%rip), %rax      # 0x29fa6
movq %rax, -0x3c8(%rbp)
leaq 0xd96b(%rip), %rax      # 0x29fc2
movq %rax, -0x3d0(%rbp)
leaq 0x1d2b2(%rip), %rsi     # 0x39917
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x3e0(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x3e0(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x3c0(%rbp)
leaq 0xd9d7(%rip), %rax      # 0x2a08e
movq %rax, -0x3a8(%rbp)
leaq 0xd9e5(%rip), %rax      # 0x2a0aa
movq %rax, -0x3b0(%rbp)
leaq 0x1d252(%rip), %rsi     # 0x39925
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x3c0(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x3c0(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x3a0(%rbp)
leaq 0xda51(%rip), %rax      # 0x2a176
movq %rax, -0x388(%rbp)
leaq 0xda5f(%rip), %rax      # 0x2a192
movq %rax, -0x390(%rbp)
leaq 0x1d1a2(%rip), %rsi     # 0x398e3
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x3a0(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x3a0(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x380(%rbp)
leaq 0xdc5f(%rip), %rax      # 0x2a3f2
movq %rax, -0x368(%rbp)
leaq 0xdc6d(%rip), %rax      # 0x2a40e
movq %rax, -0x370(%rbp)
leaq 0x1d126(%rip), %rsi     # 0x398d5
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x380(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x380(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x360(%rbp)
leaq 0xdd0f(%rip), %rax      # 0x2a510
movq %rax, -0x348(%rbp)
leaq 0xdd1d(%rip), %rax      # 0x2a52c
movq %rax, -0x350(%rbp)
leaq 0x1d0bf(%rip), %rsi     # 0x398dc
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x360(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x360(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x340(%rbp)
leaq 0xde0f(%rip), %rax      # 0x2a67e
movq %rax, -0x328(%rbp)
leaq 0xde1d(%rip), %rax      # 0x2a69a
movq %rax, -0x330(%rbp)
leaq 0x1d043(%rip), %rsi     # 0x398ce
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x340(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x340(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x320(%rbp)
leaq 0xdebf(%rip), %rax      # 0x2a79c
movq %rax, -0x308(%rbp)
leaq 0xdecd(%rip), %rax      # 0x2a7b8
movq %rax, -0x310(%rbp)
leaq 0x1d088(%rip), %rsi     # 0x39981
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x320(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x320(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x300(%rbp)
leaq 0xe363(%rip), %rax      # 0x2acae
movq %rax, -0x2e8(%rbp)
leaq 0xe371(%rip), %rax      # 0x2acca
movq %rax, -0x2f0(%rbp)
leaq 0x1cfc8(%rip), %rsi     # 0x3992f
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x300(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x300(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x2e0(%rbp)
leaq 0xe3dd(%rip), %rax      # 0x2ad96
movq %rax, -0x2c8(%rbp)
leaq 0xe3eb(%rip), %rax      # 0x2adb2
movq %rax, -0x2d0(%rbp)
leaq 0x1cfa2(%rip), %rsi     # 0x39977
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x2e0(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x2e0(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x2c0(%rbp)
leaq 0xe58b(%rip), %rax      # 0x2afb2
movq %rax, -0x2a8(%rbp)
leaq 0xe599(%rip), %rax      # 0x2afce
movq %rax, -0x2b0(%rbp)
leaq 0x1cf4f(%rip), %rsi     # 0x39992
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x2c0(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x2c0(%rbp), %rdi
callq 0x3209c
leaq 0x1cf25(%rip), %rsi     # 0x399b0
leaq -0x30(%rbp), %rdi
leaq -0x31(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
subq $-0x80, %rax
leaq -0x9(%rbp), %rsi
movq %rax, %rdi
callq 0x23d8c
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq 0x1ceec(%rip), %rsi     # 0x399b0
leaq -0x30(%rbp), %rdi
leaq -0x31(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0xa0, %rax
leaq -0x9(%rbp), %rsi
movq %rax, %rdi
callq 0x23dde
leaq -0x30(%rbp), %rdi
callq 0x9140
xorps %xmm0, %xmm0
movaps %xmm0, -0x2a0(%rbp)
leaq 0xeb3d(%rip), %rax      # 0x2b646
movq %rax, -0x288(%rbp)
leaq 0xeb51(%rip), %rax      # 0x2b668
movq %rax, -0x290(%rbp)
leaq 0x1ccf4(%rip), %rsi     # 0x39819
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x2a0(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x2a0(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x280(%rbp)
leaq 0xeb45(%rip), %rax      # 0x2b6bc
movq %rax, -0x268(%rbp)
leaq 0xeb59(%rip), %rax      # 0x2b6de
movq %rax, -0x270(%rbp)
leaq 0x1cc8a(%rip), %rsi     # 0x3981d
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x280(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x280(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x260(%rbp)
leaq 0xeb4d(%rip), %rax      # 0x2b732
movq %rax, -0x248(%rbp)
leaq 0xeb61(%rip), %rax      # 0x2b754
movq %rax, -0x250(%rbp)
leaq 0x1cc4a(%rip), %rsi     # 0x3984b
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x260(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x260(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x240(%rbp)
leaq 0xeb55(%rip), %rax      # 0x2b7a8
movq %rax, -0x228(%rbp)
leaq 0xeb69(%rip), %rax      # 0x2b7ca
movq %rax, -0x230(%rbp)
leaq 0x1cbe5(%rip), %rsi     # 0x39854
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x240(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x240(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x220(%rbp)
leaq 0xeb5d(%rip), %rax      # 0x2b81e
movq %rax, -0x208(%rbp)
leaq 0xeb71(%rip), %rax      # 0x2b840
movq %rax, -0x210(%rbp)
leaq 0x1cb7c(%rip), %rsi     # 0x39859
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x220(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x220(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x200(%rbp)
leaq 0xeb65(%rip), %rax      # 0x2b894
movq %rax, -0x1e8(%rbp)
leaq 0xeb73(%rip), %rax      # 0x2b8b0
movq %rax, -0x1f0(%rbp)
leaq 0x1cb9e(%rip), %rsi     # 0x398e9
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x200(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x200(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x1e0(%rbp)
leaq 0xebb5(%rip), %rax      # 0x2b952
movq %rax, -0x1c8(%rbp)
leaq 0xebc3(%rip), %rax      # 0x2b96e
movq %rax, -0x1d0(%rbp)
leaq 0x1ca55(%rip), %rsi     # 0x3980e
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x1e0(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x1e0(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x1c0(%rbp)
leaq 0xee37(%rip), %rax      # 0x2bc42
movq %rax, -0x1a8(%rbp)
leaq 0xee45(%rip), %rax      # 0x2bc5e
movq %rax, -0x1b0(%rbp)
leaq 0x1ca67(%rip), %rsi     # 0x3988e
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x1c0(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x1c0(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x1a0(%rbp)
leaq 0xeead(%rip), %rax      # 0x2bd26
movq %rax, -0x188(%rbp)
leaq 0xeebd(%rip), %rax      # 0x2bd44
movq %rax, -0x190(%rbp)
leaq 0x1ca09(%rip), %rsi     # 0x3989e
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x1a0(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x1a0(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x180(%rbp)
leaq 0xf4c7(%rip), %rax      # 0x2c3ae
movq %rax, -0x168(%rbp)
leaq 0xf4df(%rip), %rax      # 0x2c3d4
movq %rax, -0x170(%rbp)
leaq 0x1c8b4(%rip), %rsi     # 0x397b7
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x180(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x180(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x160(%rbp)
leaq 0xf4d3(%rip), %rax      # 0x2c428
movq %rax, -0x148(%rbp)
leaq 0xf4e1(%rip), %rax      # 0x2c444
movq %rax, -0x150(%rbp)
leaq 0x1c857(%rip), %rsi     # 0x397c8
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x160(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x160(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x140(%rbp)
leaq 0xf5a5(%rip), %rax      # 0x2c568
movq %rax, -0x128(%rbp)
leaq 0xf5b3(%rip), %rax      # 0x2c584
movq %rax, -0x130(%rbp)
leaq 0x1c88a(%rip), %rsi     # 0x39869
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x140(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x140(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x120(%rbp)
leaq 0xf721(%rip), %rax      # 0x2c752
movq %rax, -0x108(%rbp)
leaq 0xf72f(%rip), %rax      # 0x2c76e
movq %rax, -0x110(%rbp)
leaq 0x1c9be(%rip), %rsi     # 0x39a0b
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x120(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x120(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x100(%rbp)
leaq 0x103e3(%rip), %rax     # 0x2d482
movq %rax, -0xe8(%rbp)
leaq 0x103f1(%rip), %rax     # 0x2d49e
movq %rax, -0xf0(%rbp)
leaq 0x1c998(%rip), %rsi     # 0x39a53
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x100(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x100(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0xe0(%rbp)
leaq 0x10545(%rip), %rax     # 0x2d652
movq %rax, -0xc8(%rbp)
leaq 0x10553(%rip), %rax     # 0x2d66e
movq %rax, -0xd0(%rbp)
leaq 0x1c949(%rip), %rsi     # 0x39a72
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0xe0(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0xe0(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0xc0(%rbp)
leaq 0x10579(%rip), %rax     # 0x2d6f4
movq %rax, -0xa8(%rbp)
leaq 0x10587(%rip), %rax     # 0x2d710
movq %rax, -0xb0(%rbp)
leaq 0x1c8cb(%rip), %rsi     # 0x39a62
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0xc0(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0xc0(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0xa0(%rbp)
leaq 0x105ad(%rip), %rax     # 0x2d796
movq %rax, -0x88(%rbp)
leaq 0x105bb(%rip), %rax     # 0x2d7b2
movq %rax, -0x90(%rbp)
leaq 0x1c819(%rip), %rsi     # 0x39a1e
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0xa0(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0xa0(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x80(%rbp)
leaq 0x106d2(%rip), %rax     # 0x2d926
movq %rax, -0x68(%rbp)
leaq 0x106e3(%rip), %rax     # 0x2d942
movq %rax, -0x70(%rbp)
leaq 0x1c7c1(%rip), %rsi     # 0x39a2b
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x80(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x80(%rbp), %rdi
callq 0x3209c
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
leaq 0x1078f(%rip), %rax     # 0x2da42
movq %rax, -0x48(%rbp)
leaq 0x107a0(%rip), %rax     # 0x2da5e
movq %rax, -0x50(%rbp)
leaq 0x1c51f(%rip), %rsi     # 0x397e8
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xff44
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1f982
addq $0x60, %rax
leaq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0x25eee
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x60(%rbp), %rdi
callq 0x3209c
addq $0x578, %rsp            # imm = 0x578
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x1d497
movq %rax, %rbx
jmp 0x1d4ac
movq %rax, %rbx
jmp 0x1d4c1
movq %rax, %rbx
jmp 0x1d4d9
movq %rax, %rbx
jmp 0x1d4f1
movq %rax, %rbx
jmp 0x1d509
movq %rax, %rbx
jmp 0x1d521
movq %rax, %rbx
jmp 0x1d539
movq %rax, %rbx
jmp 0x1d551
movq %rax, %rbx
jmp 0x1d569
movq %rax, %rbx
jmp 0x1d581
movq %rax, %rbx
jmp 0x1d599
movq %rax, %rbx
jmp 0x1d5b1
movq %rax, %rbx
jmp 0x1d5c9
movq %rax, %rbx
jmp 0x1d5e1
movq %rax, %rbx
jmp 0x1d5f9
movq %rax, %rbx
jmp 0x1d611
movq %rax, %rbx
jmp 0x1d629
movq %rax, %rbx
jmp 0x1d641
jmp 0x1d46a
jmp 0x1d47b
jmp 0x1d46a
jmp 0x1d47b
movq %rax, %rbx
jmp 0x1d659
movq %rax, %rbx
jmp 0x1d671
movq %rax, %rbx
jmp 0x1d689
movq %rax, %rbx
jmp 0x1d6a1
movq %rax, %rbx
jmp 0x1d6b9
movq %rax, %rbx
jmp 0x1d6d1
movq %rax, %rbx
jmp 0x1d6e9
movq %rax, %rbx
jmp 0x1d701
movq %rax, %rbx
jmp 0x1d719
movq %rax, %rbx
jmp 0x1d731
movq %rax, %rbx
jmp 0x1d749
movq %rax, %rbx
jmp 0x1d761
movq %rax, %rbx
jmp 0x1d779
movq %rax, %rbx
jmp 0x1d791
movq %rax, %rbx
jmp 0x1d7a9
movq %rax, %rbx
jmp 0x1d7c1
movq %rax, %rbx
jmp 0x1d7d9
movq %rax, %rbx
jmp 0x1d7ee
movq %rax, %rbx
jmp 0x1d803
movq %rax, %rbx
jmp 0x1d818
movq %rax, %rbx
jmp 0x1d82d
movq %rax, %rbx
jmp 0x1d842
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
jmp 0x1d863
movq %rax, %rbx
jmp 0x1d863
movq %rax, %rbx
jmp 0x1d857
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x60(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x80(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0xa0(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0xc0(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0xe0(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x100(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x120(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x140(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x160(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x180(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x1a0(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x1c0(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x1e0(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x200(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x220(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x240(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x260(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x280(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x2a0(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x2c0(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x2e0(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x300(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x320(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x340(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x360(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x380(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x3a0(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x3c0(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x3e0(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x400(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x420(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x440(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x460(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x480(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x4a0(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x4c0(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x4e0(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x500(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x520(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x540(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x560(%rbp), %rdi
jmp 0x1d85e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x9140
leaq -0x580(%rbp), %rdi
callq 0x3209c
movq %rbx, %rdi
callq 0x9430
nop