// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x570, %rsp            # imm = 0x570
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x570(%rbp)
movaps %xmm0, -0x580(%rbp)
leaq 0x9189(%rip), %rax      # 0x2e7ea
movq %rax, -0x568(%rbp)
leaq 0x91a3(%rip), %rax      # 0x2e812
movq %rax, -0x570(%rbp)
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1f11d(%rip), %rsi     # 0x447a2
leaq 0x1f120(%rip), %rdx     # 0x447ac
leaq -0x30(%rbp), %rdi
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x580(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x256c9
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x570(%rbp), %rax
testq %rax, %rax
je 0x256e6
leaq -0x580(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1f0ae(%rip), %rsi     # 0x447a2
leaq 0x1f0b1(%rip), %rdx     # 0x447ac
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
subq $-0x80, %rax
leaq -0x31(%rbp), %rsi
movq %rax, %rdi
callq 0x2e69a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x25731
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
xorps %xmm0, %xmm0
movaps %xmm0, -0x550(%rbp)
movaps %xmm0, -0x560(%rbp)
leaq 0xb67d(%rip), %rax      # 0x30dc6
movq %rax, -0x548(%rbp)
leaq 0xb68b(%rip), %rax      # 0x30de2
movq %rax, -0x550(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1f071(%rip), %rsi     # 0x447dd
leaq 0x1f074(%rip), %rdx     # 0x447e7
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x560(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x257ac
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x550(%rbp), %rax
testq %rax, %rax
je 0x257c9
leaq -0x560(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x530(%rbp)
movaps %xmm0, -0x540(%rbp)
leaq 0xb8c9(%rip), %rax      # 0x310aa
movq %rax, -0x528(%rbp)
leaq 0xb8d7(%rip), %rax      # 0x310c6
movq %rax, -0x530(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1effb(%rip), %rsi     # 0x447ff
leaq 0x1effc(%rip), %rdx     # 0x44807
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x540(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x25844
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x530(%rbp), %rax
testq %rax, %rax
je 0x25861
leaq -0x540(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x510(%rbp)
movaps %xmm0, -0x520(%rbp)
leaq 0xbbe9(%rip), %rax      # 0x31462
movq %rax, -0x508(%rbp)
leaq 0xbbf7(%rip), %rax      # 0x3147e
movq %rax, -0x510(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1ef76(%rip), %rsi     # 0x44812
leaq 0x1ef75(%rip), %rdx     # 0x44818
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x520(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x258dc
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x510(%rbp), %rax
testq %rax, %rax
je 0x258f9
leaq -0x520(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x4f0(%rbp)
movaps %xmm0, -0x500(%rbp)
leaq 0xbf53(%rip), %rax      # 0x31864
movq %rax, -0x4e8(%rbp)
leaq 0xbf63(%rip), %rax      # 0x31882
movq %rax, -0x4f0(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1eeed(%rip), %rsi     # 0x44821
leaq 0x1eef5(%rip), %rdx     # 0x44830
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x500(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x25974
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x4f0(%rbp), %rax
testq %rax, %rax
je 0x25991
leaq -0x500(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x4d0(%rbp)
movaps %xmm0, -0x4e0(%rbp)
leaq 0xc7c7(%rip), %rax      # 0x32170
movq %rax, -0x4c8(%rbp)
leaq 0xc7d5(%rip), %rax      # 0x3218c
movq %rax, -0x4d0(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1ee65(%rip), %rsi     # 0x44831
leaq 0x1ee64(%rip), %rdx     # 0x44837
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x4e0(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x25a0c
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x4d0(%rbp), %rax
testq %rax, %rax
je 0x25a29
leaq -0x4e0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x4b0(%rbp)
movaps %xmm0, -0x4c0(%rbp)
leaq 0xcaf3(%rip), %rax      # 0x32534
movq %rax, -0x4a8(%rbp)
leaq 0xcb01(%rip), %rax      # 0x32550
movq %rax, -0x4b0(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1ede2(%rip), %rsi     # 0x44846
leaq 0x1eddf(%rip), %rdx     # 0x4484a
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x4c0(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x25aa4
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x4b0(%rbp), %rax
testq %rax, %rax
je 0x25ac1
leaq -0x4c0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x490(%rbp)
movaps %xmm0, -0x4a0(%rbp)
leaq 0xcc13(%rip), %rax      # 0x326ec
movq %rax, -0x488(%rbp)
leaq 0xcc23(%rip), %rax      # 0x3270a
movq %rax, -0x490(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1ed42(%rip), %rsi     # 0x4483e
leaq 0x1ed42(%rip), %rdx     # 0x44845
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x4a0(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x25b3c
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x490(%rbp), %rax
testq %rax, %rax
je 0x25b59
leaq -0x4a0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x470(%rbp)
movaps %xmm0, -0x480(%rbp)
leaq 0xddbd(%rip), %rax      # 0x3392e
movq %rax, -0x468(%rbp)
leaq 0xddcb(%rip), %rax      # 0x3394a
movq %rax, -0x470(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1ec2a(%rip), %rsi     # 0x447be
leaq 0x1ec2c(%rip), %rdx     # 0x447c7
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x480(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x25bd4
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x470(%rbp), %rax
testq %rax, %rax
je 0x25bf1
leaq -0x480(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x450(%rbp)
movaps %xmm0, -0x460(%rbp)
leaq 0xde81(%rip), %rax      # 0x33a8a
movq %rax, -0x448(%rbp)
leaq 0xde8f(%rip), %rax      # 0x33aa6
movq %rax, -0x450(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1ec8f(%rip), %rsi     # 0x448bb
leaq 0x1ec92(%rip), %rdx     # 0x448c5
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x460(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x25c6c
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x450(%rbp), %rax
testq %rax, %rax
je 0x25c89
leaq -0x460(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x430(%rbp)
movaps %xmm0, -0x440(%rbp)
leaq 0xe8c9(%rip), %rax      # 0x3456a
movq %rax, -0x428(%rbp)
leaq 0xe8d7(%rip), %rax      # 0x34586
movq %rax, -0x430(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1ebe2(%rip), %rsi     # 0x448a6
leaq 0x1ebe6(%rip), %rdx     # 0x448b1
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x440(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x25d04
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x430(%rbp), %rax
testq %rax, %rax
je 0x25d21
leaq -0x440(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x410(%rbp)
movaps %xmm0, -0x420(%rbp)
leaq 0xe93b(%rip), %rax      # 0x34674
movq %rax, -0x408(%rbp)
leaq 0xe949(%rip), %rax      # 0x34690
movq %rax, -0x410(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1eb6a(%rip), %rsi     # 0x448c6
leaq 0x1eb6a(%rip), %rdx     # 0x448cd
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x420(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x25d9c
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x410(%rbp), %rax
testq %rax, %rax
je 0x25db9
leaq -0x420(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x3f0(%rbp)
movaps %xmm0, -0x400(%rbp)
leaq 0xee35(%rip), %rax      # 0x34c06
movq %rax, -0x3e8(%rbp)
leaq 0xee43(%rip), %rax      # 0x34c22
movq %rax, -0x3f0(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1eabe(%rip), %rsi     # 0x448b2
leaq 0x1eabf(%rip), %rdx     # 0x448ba
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x400(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x25e34
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x3f0(%rbp), %rax
testq %rax, %rax
je 0x25e51
leaq -0x400(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x3d0(%rbp)
movaps %xmm0, -0x3e0(%rbp)
leaq 0xeec9(%rip), %rax      # 0x34d32
movq %rax, -0x3c8(%rbp)
leaq 0xeed7(%rip), %rax      # 0x34d4e
movq %rax, -0x3d0(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1ea8b(%rip), %rsi     # 0x44917
leaq 0x1ea8c(%rip), %rdx     # 0x4491f
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x3e0(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x25ecc
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x3d0(%rbp), %rax
testq %rax, %rax
je 0x25ee9
leaq -0x3e0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x3b0(%rbp)
movaps %xmm0, -0x3c0(%rbp)
leaq 0xef29(%rip), %rax      # 0x34e2a
movq %rax, -0x3a8(%rbp)
leaq 0xef37(%rip), %rax      # 0x34e46
movq %rax, -0x3b0(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1ea01(%rip), %rsi     # 0x44925
leaq 0x1ea03(%rip), %rdx     # 0x4492e
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x3c0(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x25f64
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x3b0(%rbp), %rax
testq %rax, %rax
je 0x25f81
leaq -0x3c0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x390(%rbp)
movaps %xmm0, -0x3a0(%rbp)
leaq 0xef89(%rip), %rax      # 0x34f22
movq %rax, -0x388(%rbp)
leaq 0xef97(%rip), %rax      # 0x34f3e
movq %rax, -0x390(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1e927(%rip), %rsi     # 0x448e3
leaq 0x1e925(%rip), %rdx     # 0x448e8
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x3a0(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x25ffc
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x390(%rbp), %rax
testq %rax, %rax
je 0x26019
leaq -0x3a0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x370(%rbp)
movaps %xmm0, -0x380(%rbp)
leaq 0xf185(%rip), %rax      # 0x351b6
movq %rax, -0x368(%rbp)
leaq 0xf193(%rip), %rax      # 0x351d2
movq %rax, -0x370(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1e881(%rip), %rsi     # 0x448d5
leaq 0x1e880(%rip), %rdx     # 0x448db
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x380(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x26094
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x370(%rbp), %rax
testq %rax, %rax
je 0x260b1
leaq -0x380(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x350(%rbp)
movaps %xmm0, -0x360(%rbp)
leaq 0xf217(%rip), %rax      # 0x352e0
movq %rax, -0x348(%rbp)
leaq 0xf225(%rip), %rax      # 0x352fc
movq %rax, -0x350(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1e7f0(%rip), %rsi     # 0x448dc
leaq 0x1e7f5(%rip), %rdx     # 0x448e8
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x360(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x2612c
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x350(%rbp), %rax
testq %rax, %rax
je 0x26149
leaq -0x360(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x330(%rbp)
movaps %xmm0, -0x340(%rbp)
leaq 0xf2a9(%rip), %rax      # 0x3540a
movq %rax, -0x328(%rbp)
leaq 0xf2b7(%rip), %rax      # 0x35426
movq %rax, -0x330(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1e74a(%rip), %rsi     # 0x448ce
leaq 0x1e750(%rip), %rdx     # 0x448db
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x340(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x261c4
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x330(%rbp), %rax
testq %rax, %rax
je 0x261e1
leaq -0x340(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x310(%rbp)
movaps %xmm0, -0x320(%rbp)
leaq 0xf33b(%rip), %rax      # 0x35534
movq %rax, -0x308(%rbp)
leaq 0xf35b(%rip), %rax      # 0x35562
movq %rax, -0x310(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1e765(%rip), %rsi     # 0x44981
leaq 0x1e763(%rip), %rdx     # 0x44986
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x320(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x2625c
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x310(%rbp), %rax
testq %rax, %rax
je 0x26279
leaq -0x320(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x2f0(%rbp)
movaps %xmm0, -0x300(%rbp)
leaq 0xfa5b(%rip), %rax      # 0x35cec
movq %rax, -0x2e8(%rbp)
leaq 0xfa69(%rip), %rax      # 0x35d08
movq %rax, -0x2f0(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1e67b(%rip), %rsi     # 0x4492f
leaq 0x1e678(%rip), %rdx     # 0x44933
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x300(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x262f4
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x2f0(%rbp), %rax
testq %rax, %rax
je 0x26311
leaq -0x300(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x2d0(%rbp)
movaps %xmm0, -0x2e0(%rbp)
leaq 0xfab7(%rip), %rax      # 0x35de0
movq %rax, -0x2c8(%rbp)
leaq 0xfafd(%rip), %rax      # 0x35e34
movq %rax, -0x2d0(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1e62b(%rip), %rsi     # 0x44977
leaq 0x1e633(%rip), %rdx     # 0x44986
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x2e0(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x2638c
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x2d0(%rbp), %rax
testq %rax, %rax
je 0x263a9
leaq -0x2e0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x2b0(%rbp)
movaps %xmm0, -0x2c0(%rbp)
leaq 0xfbed(%rip), %rax      # 0x35fae
movq %rax, -0x2a8(%rbp)
leaq 0xfbfb(%rip), %rax      # 0x35fca
movq %rax, -0x2b0(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1e5ae(%rip), %rsi     # 0x44992
leaq 0x1e5ad(%rip), %rdx     # 0x44998
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x2c0(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x26424
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x2b0(%rbp), %rax
testq %rax, %rax
je 0x26441
leaq -0x2c0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1e561(%rip), %rsi     # 0x449b0
leaq 0x1e562(%rip), %rdx     # 0x449b8
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
subq $-0x80, %rax
leaq -0x31(%rbp), %rsi
movq %rax, %rdi
callq 0x2e70a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x2648c
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1e516(%rip), %rsi     # 0x449b0
leaq 0x1e517(%rip), %rdx     # 0x449b8
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0xa0, %rax
leaq -0x31(%rbp), %rsi
movq %rax, %rdi
callq 0x2e77a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x264d9
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
xorps %xmm0, %xmm0
movaps %xmm0, -0x290(%rbp)
movaps %xmm0, -0x2a0(%rbp)
leaq 0x10103(%rip), %rax     # 0x365f4
movq %rax, -0x288(%rbp)
leaq 0x10119(%rip), %rax     # 0x36618
movq %rax, -0x290(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1e305(%rip), %rsi     # 0x44819
leaq 0x1e301(%rip), %rdx     # 0x4481c
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x2a0(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x26554
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x290(%rbp), %rax
testq %rax, %rax
je 0x26571
leaq -0x2a0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x270(%rbp)
movaps %xmm0, -0x280(%rbp)
leaq 0x100bb(%rip), %rax     # 0x36644
movq %rax, -0x268(%rbp)
leaq 0x100d1(%rip), %rax     # 0x36668
movq %rax, -0x270(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1e271(%rip), %rsi     # 0x4481d
leaq 0x1e26d(%rip), %rdx     # 0x44820
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x280(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x265ec
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x270(%rbp), %rax
testq %rax, %rax
je 0x26609
leaq -0x280(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x250(%rbp)
movaps %xmm0, -0x260(%rbp)
leaq 0x10073(%rip), %rax     # 0x36694
movq %rax, -0x248(%rbp)
leaq 0x10089(%rip), %rax     # 0x366b8
movq %rax, -0x250(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1e207(%rip), %rsi     # 0x4484b
leaq 0x1e208(%rip), %rdx     # 0x44853
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x260(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x26684
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x250(%rbp), %rax
testq %rax, %rax
je 0x266a1
leaq -0x260(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x230(%rbp)
movaps %xmm0, -0x240(%rbp)
leaq 0x1002b(%rip), %rax     # 0x366e4
movq %rax, -0x228(%rbp)
leaq 0x10041(%rip), %rax     # 0x36708
movq %rax, -0x230(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1e178(%rip), %rsi     # 0x44854
leaq 0x1e175(%rip), %rdx     # 0x44858
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x240(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x2671c
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x230(%rbp), %rax
testq %rax, %rax
je 0x26739
leaq -0x240(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x210(%rbp)
movaps %xmm0, -0x220(%rbp)
leaq 0xffe3(%rip), %rax      # 0x36734
movq %rax, -0x208(%rbp)
leaq 0xfff9(%rip), %rax      # 0x36758
movq %rax, -0x210(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1e0e5(%rip), %rsi     # 0x44859
leaq 0x1e0e2(%rip), %rdx     # 0x4485d
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x220(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x267b4
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x210(%rbp), %rax
testq %rax, %rax
je 0x267d1
leaq -0x220(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x1f0(%rbp)
movaps %xmm0, -0x200(%rbp)
leaq 0xff9b(%rip), %rax      # 0x36784
movq %rax, -0x1e8(%rbp)
leaq 0xffa9(%rip), %rax      # 0x367a0
movq %rax, -0x1f0(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1e0dd(%rip), %rsi     # 0x448e9
leaq 0x1e0d9(%rip), %rdx     # 0x448ec
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x200(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x2684c
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x1f0(%rbp), %rax
testq %rax, %rax
je 0x26869
leaq -0x200(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x1d0(%rbp)
movaps %xmm0, -0x1e0(%rbp)
leaq 0xffbf(%rip), %rax      # 0x36840
movq %rax, -0x1c8(%rbp)
leaq 0xffcd(%rip), %rax      # 0x3685c
movq %rax, -0x1d0(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1df6a(%rip), %rsi     # 0x4480e
leaq 0x1df66(%rip), %rdx     # 0x44811
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x1e0(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x268e4
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x1d0(%rbp), %rax
testq %rax, %rax
je 0x26901
leaq -0x1e0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x1b0(%rbp)
movaps %xmm0, -0x1c0(%rbp)
leaq 0x10103(%rip), %rax     # 0x36a1c
movq %rax, -0x1a8(%rbp)
leaq 0x10147(%rip), %rax     # 0x36a6e
movq %rax, -0x1b0(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1df52(%rip), %rsi     # 0x4488e
leaq 0x1df53(%rip), %rdx     # 0x44896
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x1c0(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x2697c
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x1b0(%rbp), %rax
testq %rax, %rax
je 0x26999
leaq -0x1c0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x190(%rbp)
movaps %xmm0, -0x1a0(%rbp)
leaq 0x100e9(%rip), %rax     # 0x36a9a
movq %rax, -0x188(%rbp)
leaq 0x100f9(%rip), %rax     # 0x36ab8
movq %rax, -0x190(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1deca(%rip), %rsi     # 0x4489e
leaq 0x1deca(%rip), %rdx     # 0x448a5
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x1a0(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x26a14
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x190(%rbp), %rax
testq %rax, %rax
je 0x26a31
leaq -0x1a0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x170(%rbp)
movaps %xmm0, -0x180(%rbp)
leaq 0x106d5(%rip), %rax     # 0x3711e
movq %rax, -0x168(%rbp)
leaq 0x106ed(%rip), %rax     # 0x37144
movq %rax, -0x170(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1dd4b(%rip), %rsi     # 0x447b7
leaq 0x1dd4a(%rip), %rdx     # 0x447bd
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x180(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x26aac
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x170(%rbp), %rax
testq %rax, %rax
je 0x26ac9
leaq -0x180(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x150(%rbp)
movaps %xmm0, -0x160(%rbp)
leaq 0x1068f(%rip), %rax     # 0x37170
movq %rax, -0x148(%rbp)
leaq 0x1069d(%rip), %rax     # 0x3718c
movq %rax, -0x150(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1dcc4(%rip), %rsi     # 0x447c8
leaq 0x1dcc7(%rip), %rdx     # 0x447d2
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x160(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x26b44
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x150(%rbp), %rax
testq %rax, %rax
je 0x26b61
leaq -0x160(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x130(%rbp)
movaps %xmm0, -0x140(%rbp)
leaq 0x106c7(%rip), %rax     # 0x37240
movq %rax, -0x128(%rbp)
leaq 0x106d5(%rip), %rax     # 0x3725c
movq %rax, -0x130(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1dccd(%rip), %rsi     # 0x44869
leaq 0x1dccf(%rip), %rdx     # 0x44872
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x140(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x26bdc
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x130(%rbp), %rax
testq %rax, %rax
je 0x26bf9
leaq -0x140(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x110(%rbp)
movaps %xmm0, -0x120(%rbp)
leaq 0x107e7(%rip), %rax     # 0x373f8
movq %rax, -0x108(%rbp)
leaq 0x107f5(%rip), %rax     # 0x37414
movq %rax, -0x110(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1ddd7(%rip), %rsi     # 0x44a0b
leaq 0x1dde2(%rip), %rdx     # 0x44a1d
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x120(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x26c74
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x110(%rbp), %rax
testq %rax, %rax
je 0x26c91
leaq -0x120(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0xf0(%rbp)
movaps %xmm0, -0x100(%rbp)
leaq 0x1155d(%rip), %rax     # 0x38206
movq %rax, -0xe8(%rbp)
leaq 0x1156b(%rip), %rax     # 0x38222
movq %rax, -0xf0(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1dd87(%rip), %rsi     # 0x44a53
leaq 0x1dd8e(%rip), %rdx     # 0x44a61
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x100(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x26d0c
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0xf0(%rbp), %rax
testq %rax, %rax
je 0x26d29
leaq -0x100(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0xd0(%rbp)
movaps %xmm0, -0xe0(%rbp)
leaq 0x11665(%rip), %rax     # 0x383a6
movq %rax, -0xc8(%rbp)
leaq 0x116a9(%rip), %rax     # 0x383f8
movq %rax, -0xd0(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1dd0e(%rip), %rsi     # 0x44a72
leaq 0x1dd14(%rip), %rdx     # 0x44a7f
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0xe0(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x26da4
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0xd0(%rbp), %rax
testq %rax, %rax
je 0x26dc1
leaq -0xe0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0xb0(%rbp)
movaps %xmm0, -0xc0(%rbp)
leaq 0x1164b(%rip), %rax     # 0x38424
movq %rax, -0xa8(%rbp)
leaq 0x1168f(%rip), %rax     # 0x38476
movq %rax, -0xb0(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1dc66(%rip), %rsi     # 0x44a62
leaq 0x1dc6e(%rip), %rdx     # 0x44a71
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0xc0(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x26e3c
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0xb0(%rbp), %rax
testq %rax, %rax
je 0x26e59
leaq -0xc0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x90(%rbp)
movaps %xmm0, -0xa0(%rbp)
leaq 0x11631(%rip), %rax     # 0x384a2
movq %rax, -0x88(%rbp)
leaq 0x1163f(%rip), %rax     # 0x384be
movq %rax, -0x90(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1db8a(%rip), %rsi     # 0x44a1e
leaq 0x1db8f(%rip), %rdx     # 0x44a2a
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0xa0(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x26ed4
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x90(%rbp), %rax
testq %rax, %rax
je 0x26ef1
leaq -0xa0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
leaq 0x117d3(%rip), %rax     # 0x386d6
movq %rax, -0x68(%rbp)
leaq 0x117e4(%rip), %rax     # 0x386f2
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1db0b(%rip), %rsi     # 0x44a2b
leaq 0x1db0c(%rip), %rdx     # 0x44a33
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x80(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x26f5d
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x70(%rbp), %rax
testq %rax, %rax
je 0x26f74
leaq -0x80(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
leaq 0x1186c(%rip), %rax     # 0x387f2
movq %rax, -0x48(%rbp)
leaq 0x1187d(%rip), %rax     # 0x3880e
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1d845(%rip), %rsi     # 0x447e8
leaq 0x1d849(%rip), %rdx     # 0x447f3
callq 0x12846
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2af0e
addq $0x60, %rax
leaq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0x30c1a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x26fe0
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x26ff7
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x570, %rsp            # imm = 0x570
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
jmp 0x27d3e
movq %rax, %rbx
jmp 0x2727a
movq %rax, %rbx
jmp 0x272b7
movq %rax, %rbx
jmp 0x272f4
movq %rax, %rbx
jmp 0x27337
movq %rax, %rbx
jmp 0x2737a
movq %rax, %rbx
jmp 0x273bd
movq %rax, %rbx
jmp 0x27400
movq %rax, %rbx
jmp 0x27443
movq %rax, %rbx
jmp 0x27486
movq %rax, %rbx
jmp 0x274c9
movq %rax, %rbx
jmp 0x2750c
movq %rax, %rbx
jmp 0x2754f
movq %rax, %rbx
jmp 0x27592
movq %rax, %rbx
jmp 0x275d5
movq %rax, %rbx
jmp 0x27618
movq %rax, %rbx
jmp 0x2765b
movq %rax, %rbx
jmp 0x2769e
movq %rax, %rbx
jmp 0x276e1
movq %rax, %rbx
jmp 0x27724
jmp 0x27231
jmp 0x27252
jmp 0x27231
jmp 0x27252
movq %rax, %rbx
jmp 0x27767
movq %rax, %rbx
jmp 0x277aa
movq %rax, %rbx
jmp 0x277ed
movq %rax, %rbx
jmp 0x27830
movq %rax, %rbx
jmp 0x27873
movq %rax, %rbx
jmp 0x278b6
movq %rax, %rbx
jmp 0x278f9
movq %rax, %rbx
jmp 0x2793c
movq %rax, %rbx
jmp 0x2797f
movq %rax, %rbx
jmp 0x279c2
movq %rax, %rbx
jmp 0x27a05
movq %rax, %rbx
jmp 0x27a48
movq %rax, %rbx
jmp 0x27a8b
movq %rax, %rbx
jmp 0x27ace
movq %rax, %rbx
jmp 0x27b11
movq %rax, %rbx
jmp 0x27b54
movq %rax, %rbx
jmp 0x27b97
movq %rax, %rbx
jmp 0x27bda
movq %rax, %rbx
jmp 0x27c1d
movq %rax, %rbx
jmp 0x27c60
movq %rax, %rbx
jmp 0x27ca3
movq %rax, %rbx
jmp 0x27ce0
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27d36
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
jmp 0x27d36
movq %rax, %rbx
jmp 0x27d36
movq %rax, %rbx
jmp 0x27d19
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x2727a
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x272b7
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x70(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x80(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x272f4
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x90(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0xa0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27337
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0xb0(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0xc0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x2737a
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0xd0(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0xe0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x273bd
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0xf0(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x100(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27400
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x110(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x120(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27443
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x130(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x140(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27486
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x150(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x160(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x274c9
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x170(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x180(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x2750c
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x190(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x1a0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x2754f
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x1b0(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x1c0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27592
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x1d0(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x1e0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x275d5
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x1f0(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x200(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27618
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x210(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x220(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x2765b
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x230(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x240(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x2769e
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x250(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x260(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x276e1
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x270(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x280(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27724
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x290(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x2a0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27767
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x2b0(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x2c0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x277aa
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x2d0(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x2e0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x277ed
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x2f0(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x300(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27830
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x310(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x320(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27873
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x330(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x340(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x278b6
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x350(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x360(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x278f9
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x370(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x380(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x2793c
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x390(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x3a0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x2797f
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x3b0(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x3c0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x279c2
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x3d0(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x3e0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27a05
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x3f0(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x400(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27a48
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x410(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x420(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27a8b
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x430(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x440(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27ace
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x450(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x460(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27b11
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x470(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x480(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27b54
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x490(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x4a0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27b97
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x4b0(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x4c0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27bda
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x4d0(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x4e0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27c1d
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x4f0(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x500(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27c60
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x510(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x520(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27ca3
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x530(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x540(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27ce0
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x550(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x560(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x27d36
jmp 0x27d3e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x27d19
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x92b0
movq -0x570(%rbp), %rax
testq %rax, %rax
je 0x27d36
leaq -0x580(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x9420
movq %rax, %rdi
callq 0xf084