// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_debug.c
// Function: dumpFunctionCode
void dumpFunctionCode(PKVM* vm, Function* func, pkByteBuffer* buff) {

#define INDENTATION "  "
#define ADD_CHAR(vm, buff, c) pkByteBufferWrite(buff, vm, c)
#define INT_WIDTH 5
#define ADD_INTEGER(vm, buff, value, width)                          \
  do {                                                               \
    char sbuff[STR_INT_BUFF_SIZE];                                   \
    int length;                                                      \
    if ((width) > 0) length = sprintf(sbuff, "%*d", (width), value); \
    else length = sprintf(sbuff, "%d", value);                       \
    pkByteBufferAddString(buff, vm, sbuff, (uint32_t)length);        \
  } while(false)

  uint32_t i = 0;
  uint8_t* opcodes = func->fn->opcodes.data;
  uint32_t* lines = func->fn->oplines.data;
  uint32_t line = 1, last_line = 0;

  // This will print: Instruction Dump of function 'fn' "path.pk"\n
  pkByteBufferAddString(buff, vm,
                        STR_AND_LEN("Instruction Dump of function '"));
  pkByteBufferAddString(buff, vm, STR_AND_LEN(func->name));
  pkByteBufferAddString(buff, vm, STR_AND_LEN("' \""));
  pkByteBufferAddString(buff, vm, STR_AND_LEN(func->owner->path->data));
  pkByteBufferAddString(buff, vm, STR_AND_LEN("\"\n"));

#define READ_BYTE() (opcodes[i++])
#define READ_SHORT() (i += 2, opcodes[i - 2] << 8 | opcodes[i-1])

#define NO_ARGS() ADD_CHAR(vm, buff, '\n')
#define BYTE_ARG()                                 \
  do {                                             \
    ADD_INTEGER(vm, buff, READ_BYTE(), INT_WIDTH); \
    ADD_CHAR(vm, buff, '\n');                      \
  } while (false)

#define SHORT_ARG()                                 \
  do {                                              \
    ADD_INTEGER(vm, buff, READ_SHORT(), INT_WIDTH); \
    ADD_CHAR(vm, buff, '\n');                       \
  } while (false)

  while (i < func->fn->opcodes.count) {
    ASSERT_INDEX(i, func->fn->opcodes.count);

    // Prints the line number.
    line = lines[i];
    if (line != last_line) {
      last_line = line;
      pkByteBufferAddString(buff, vm, STR_AND_LEN(INDENTATION));
      ADD_INTEGER(vm, buff, line, INT_WIDTH - 1);
      ADD_CHAR(vm, buff, ':');

    } else {
      pkByteBufferAddString(buff, vm, STR_AND_LEN(INDENTATION "     "));
    }

    // Prints: INDENTATION "%4d  %-16s"

    pkByteBufferAddString(buff, vm, STR_AND_LEN(INDENTATION));
    ADD_INTEGER(vm, buff, i, INT_WIDTH - 1);
    pkByteBufferAddString(buff, vm, STR_AND_LEN("  "));

    const char* op_name = op_names[opcodes[i]];
    uint32_t op_length = (uint32_t)strlen(op_name);
    pkByteBufferAddString(buff, vm, op_name, op_length);
    for (uint32_t j = 0; j < 16 - op_length; j++) { // Padding.
      ADD_CHAR(vm, buff, ' ');
    }

    Opcode op = (Opcode)func->fn->opcodes.data[i++];
    switch (op) {
      case OP_PUSH_CONSTANT:
      {
        int index = READ_SHORT();
        ASSERT_INDEX((uint32_t)index, func->owner->literals.count);
        Var value = func->owner->literals.data[index];

        // Prints: %5d [val]\n
        ADD_INTEGER(vm, buff, index, INT_WIDTH);
        ADD_CHAR(vm, buff, ' ');
        dumpValue(vm, value, buff);
        ADD_CHAR(vm, buff, '\n');
        break;
      }

      case OP_PUSH_NULL:
      case OP_PUSH_0:
      case OP_PUSH_TRUE:
      case OP_PUSH_FALSE:
      case OP_SWAP:
        NO_ARGS();
        break;

      case OP_PUSH_LIST:     SHORT_ARG(); break;
      case OP_PUSH_INSTANCE:
      {
        int ty_index = READ_BYTE();
        ASSERT_INDEX((uint32_t)ty_index, func->owner->classes.count);
        uint32_t name_ind = func->owner->classes.data[ty_index]->name;
        ASSERT_INDEX(name_ind, func->owner->names.count);
        String* ty_name = func->owner->names.data[name_ind];

        // Prints: %5d [Ty:%s]\n
        ADD_INTEGER(vm, buff, ty_index, INT_WIDTH);
        pkByteBufferAddString(buff, vm, STR_AND_LEN(" [Ty:"));
        pkByteBufferAddString(buff, vm, ty_name->data, ty_name->length);
        pkByteBufferAddString(buff, vm, STR_AND_LEN("]\n"));
        break;
      }
      case OP_PUSH_MAP:      NO_ARGS();   break;
      case OP_LIST_APPEND:   NO_ARGS();   break;
      case OP_MAP_INSERT:    NO_ARGS();   break;
      case OP_INST_APPEND:   NO_ARGS();   break;

      case OP_PUSH_LOCAL_0:
      case OP_PUSH_LOCAL_1:
      case OP_PUSH_LOCAL_2:
      case OP_PUSH_LOCAL_3:
      case OP_PUSH_LOCAL_4:
      case OP_PUSH_LOCAL_5:
      case OP_PUSH_LOCAL_6:
      case OP_PUSH_LOCAL_7:
      case OP_PUSH_LOCAL_8:
      case OP_PUSH_LOCAL_N:
      {

        int arg;
        if (op == OP_PUSH_LOCAL_N) {
          arg = READ_BYTE();
          ADD_INTEGER(vm, buff, arg, INT_WIDTH);

        } else {
          arg = (int)(op - OP_PUSH_LOCAL_0);
          for (int j = 0; j < INT_WIDTH; j++) ADD_CHAR(vm, buff, ' ');
        }

        if (arg < func->arity) {
          // Prints: (arg:%d)\n
          pkByteBufferAddString(buff, vm, STR_AND_LEN(" (param:"));
          ADD_INTEGER(vm, buff, arg, 1);
          pkByteBufferAddString(buff, vm, STR_AND_LEN(")\n"));

        } else {
          ADD_CHAR(vm, buff, '\n');
        }

      } break;

      case OP_STORE_LOCAL_0:
      case OP_STORE_LOCAL_1:
      case OP_STORE_LOCAL_2:
      case OP_STORE_LOCAL_3:
      case OP_STORE_LOCAL_4:
      case OP_STORE_LOCAL_5:
      case OP_STORE_LOCAL_6:
      case OP_STORE_LOCAL_7:
      case OP_STORE_LOCAL_8:
      case OP_STORE_LOCAL_N:
      {
        int arg;
        if (op == OP_STORE_LOCAL_N) {
          arg = READ_BYTE();
          ADD_INTEGER(vm, buff, arg, INT_WIDTH);

        } else {
          arg = (int)(op - OP_STORE_LOCAL_0);
          for (int j = 0; j < INT_WIDTH; j++) ADD_CHAR(vm, buff, ' ');
        }

        if (arg < func->arity) {
          // Prints: (arg:%d)\n
          pkByteBufferAddString(buff, vm, STR_AND_LEN(" (param:"));
          ADD_INTEGER(vm, buff, arg, 1);
          pkByteBufferAddString(buff, vm, STR_AND_LEN(")\n"));

        } else {
          ADD_CHAR(vm, buff, '\n');
        }

      } break;

      case OP_PUSH_GLOBAL:
      case OP_STORE_GLOBAL:
      {
        int index = READ_BYTE();
        int name_index = func->owner->global_names.data[index];
        String* name = func->owner->names.data[name_index];

        // Prints: %5d '%s'\n
        ADD_INTEGER(vm, buff, index, INT_WIDTH);
        pkByteBufferAddString(buff, vm, STR_AND_LEN(" '"));
        pkByteBufferAddString(buff, vm, name->data, name->length);
        pkByteBufferAddString(buff, vm, STR_AND_LEN("'\n"));
        break;
      }

      case OP_PUSH_FN:
      {
        int fn_index = READ_BYTE();
        const char* name = func->owner->functions.data[fn_index]->name;

        // Prints: %5d [Fn:%s]\n
        ADD_INTEGER(vm, buff, fn_index, INT_WIDTH);
        pkByteBufferAddString(buff, vm, STR_AND_LEN(" [Fn:"));
        pkByteBufferAddString(buff, vm, STR_AND_LEN(name));
        pkByteBufferAddString(buff, vm, STR_AND_LEN("]\n"));
        break;
      }

      case OP_PUSH_TYPE:
      {
        int ty_index = READ_BYTE();
        ASSERT_INDEX((uint32_t)ty_index, func->owner->classes.count);
        uint32_t name_ind = func->owner->classes.data[ty_index]->name;
        ASSERT_INDEX(name_ind, func->owner->names.count);
        String* ty_name = func->owner->names.data[name_ind];

        // Prints: %5d [Ty:%s]\n
        ADD_INTEGER(vm, buff, ty_index, INT_WIDTH);
        pkByteBufferAddString(buff, vm, STR_AND_LEN(" [Ty:"));
        pkByteBufferAddString(buff, vm, ty_name->data, ty_name->length);
        pkByteBufferAddString(buff, vm, STR_AND_LEN("]\n"));

        break;
      }

      case OP_PUSH_BUILTIN_FN:
      {
        int index = READ_BYTE();
        const char* name = getBuiltinFunctionName(vm, index);

        // Prints: %5d [Fn:%s]\n
        ADD_INTEGER(vm, buff, index, INT_WIDTH);
        pkByteBufferAddString(buff, vm, STR_AND_LEN(" [Fn:"));
        pkByteBufferAddString(buff, vm, STR_AND_LEN(name));
        pkByteBufferAddString(buff, vm, STR_AND_LEN("]\n"));
        break;
      }

      case OP_POP:    NO_ARGS(); break;
      case OP_IMPORT:
      {
        int index = READ_SHORT();
        String* name = func->owner->names.data[index];

        // Prints: %5d '%s'\n
        ADD_INTEGER(vm, buff, index, INT_WIDTH);
        pkByteBufferAddString(buff, vm, STR_AND_LEN(" '"));
        pkByteBufferAddString(buff, vm, name->data, name->length);
        pkByteBufferAddString(buff, vm, STR_AND_LEN("'\n"));
        break;
      }

      case OP_CALL:
        // Prints: %5d (argc)\n
        ADD_INTEGER(vm, buff, READ_BYTE(), INT_WIDTH);
        pkByteBufferAddString(buff, vm, STR_AND_LEN(" (argc)\n"));
        break;

      case OP_TAIL_CALL:
        // Prints: %5d (argc)\n
        ADD_INTEGER(vm, buff, READ_BYTE(), INT_WIDTH);
        pkByteBufferAddString(buff, vm, STR_AND_LEN(" (argc)\n"));
        break;

      case OP_ITER_TEST: NO_ARGS(); break;

      case OP_ITER:
      case OP_JUMP:
      case OP_JUMP_IF:
      case OP_JUMP_IF_NOT:
      {
        int offset = READ_SHORT();

        // Prints: %5d (ip:%d)\n
        ADD_INTEGER(vm, buff, offset, INT_WIDTH);
        pkByteBufferAddString(buff, vm, STR_AND_LEN(" (ip:"));
        ADD_INTEGER(vm, buff, i + offset, 0);
        pkByteBufferAddString(buff, vm, STR_AND_LEN(")\n"));
        break;
      }

      case OP_LOOP:
      {
        int offset = READ_SHORT();

        // Prints: %5d (ip:%d)\n
        ADD_INTEGER(vm, buff, -offset, INT_WIDTH);
        pkByteBufferAddString(buff, vm, STR_AND_LEN(" (ip:"));
        ADD_INTEGER(vm, buff, i - offset, 0);
        pkByteBufferAddString(buff, vm, STR_AND_LEN(")\n"));
        break;
      }

      case OP_RETURN: NO_ARGS(); break;

      case OP_GET_ATTRIB:
      case OP_GET_ATTRIB_KEEP:
      case OP_SET_ATTRIB:
      {
        int index = READ_SHORT();
        String* name = func->owner->names.data[index];

        // Prints: %5d '%s'\n
        ADD_INTEGER(vm, buff, index, INT_WIDTH);
        pkByteBufferAddString(buff, vm, STR_AND_LEN(" '"));
        pkByteBufferAddString(buff, vm, name->data, name->length);
        pkByteBufferAddString(buff, vm, STR_AND_LEN("'\n"));
      } break;

      case OP_GET_SUBSCRIPT:
      case OP_GET_SUBSCRIPT_KEEP:
      case OP_SET_SUBSCRIPT:
        NO_ARGS();
        break;

      case OP_NEGATIVE:
      case OP_NOT:
      case OP_BIT_NOT:
      case OP_ADD:
      case OP_SUBTRACT:
      case OP_MULTIPLY:
      case OP_DIVIDE:
      case OP_MOD:
      case OP_BIT_AND:
      case OP_BIT_OR:
      case OP_BIT_XOR:
      case OP_BIT_LSHIFT:
      case OP_BIT_RSHIFT:
      case OP_EQEQ:
      case OP_NOTEQ:
      case OP_LT:
      case OP_LTEQ:
      case OP_GT:
      case OP_GTEQ:
      case OP_RANGE:
      case OP_IN:
      case OP_REPL_PRINT:
      case OP_END:
        NO_ARGS();
        break;

      default:
        UNREACHABLE();
        break;
    }
  }

  ADD_CHAR(vm, buff, '\0');

// Undefin everything defined for this function.
#undef INDENTATION
#undef ADD_CHAR
#undef STR_AND_LEN
#undef READ_BYTE
#undef READ_SHORT
#undef BYTE_ARG
#undef SHORT_ARG

}

// Assembly:
subq $0x298, %rsp            # imm = 0x298
movq %rdi, 0x290(%rsp)
movq %rsi, 0x288(%rsp)
movq %rdx, 0x280(%rsp)
movl $0x0, 0x27c(%rsp)
movq 0x288(%rsp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq %rax, 0x270(%rsp)
movq 0x288(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x268(%rsp)
movl $0x1, 0x264(%rsp)
movl $0x0, 0x260(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x18786(%rip), %rdx     # 0x2ab7c
movl $0x1e, %ecx
callq 0x3c70
movq 0x280(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x290(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x288(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x288(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x2130
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movl %eax, %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x18732(%rip), %rdx     # 0x2ab9b
movl $0x3, %ecx
callq 0x3c70
movq 0x280(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x290(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x288(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
addq $0x1c, %rax
movq %rax, 0x60(%rsp)
movq 0x288(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rdi
addq $0x1c, %rdi
callq 0x2130
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movl %eax, %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x1b31b(%rip), %rdx     # 0x2d807
movl $0x2, %ecx
callq 0x3c70
movl 0x27c(%rsp), %eax
movq 0x288(%rsp), %rcx
movq 0x38(%rcx), %rcx
cmpl 0x8(%rcx), %eax
jae 0x13bd4
jmp 0x12514
cmpl $0x0, 0x27c(%rsp)
jb 0x12536
movl 0x27c(%rsp), %eax
movq 0x288(%rsp), %rcx
movq 0x38(%rcx), %rcx
cmpl 0x8(%rcx), %eax
jb 0x12570
movq 0x20abb(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x17c09(%rip), %rsi     # 0x2a150
leaq 0x17dbf(%rip), %rdx     # 0x2a30d
leaq 0x1864a(%rip), %rcx     # 0x2ab9f
leaq 0x18654(%rip), %r8      # 0x2abb0
movl $0x4c, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x12572
movq 0x268(%rsp), %rax
movl 0x27c(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, 0x264(%rsp)
movl 0x264(%rsp), %eax
cmpl 0x260(%rsp), %eax
je 0x12637
movl 0x264(%rsp), %eax
movl %eax, 0x260(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x18604(%rip), %rdx     # 0x2abc8
movl $0x2, %ecx
callq 0x3c70
leaq 0x254(%rsp), %rdi
movl 0x264(%rsp), %ecx
leaq 0x185db(%rip), %rsi     # 0x2abbf
movl $0x4, %edx
movb $0x0, %al
callq 0x2350
movl %eax, 0x250(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x254(%rsp), %rdx
movl 0x250(%rsp), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movl $0x3a, %edx
callq 0x3270
jmp 0x12658
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x18575(%rip), %rdx     # 0x2abc3
movl $0x7, %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x18559(%rip), %rdx     # 0x2abc8
movl $0x2, %ecx
callq 0x3c70
leaq 0x244(%rsp), %rdi
movl 0x27c(%rsp), %ecx
leaq 0x18530(%rip), %rsi     # 0x2abbf
movl $0x4, %edx
movb $0x0, %al
callq 0x2350
movl %eax, 0x240(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x244(%rsp), %rdx
movl 0x240(%rsp), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x184eb(%rip), %rdx     # 0x2abc8
movl $0x2, %ecx
callq 0x3c70
movq 0x270(%rsp), %rax
movl 0x27c(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x21505(%rip), %rax     # 0x33c08
movq (%rax,%rcx,8), %rax
movq %rax, 0x238(%rsp)
movq 0x238(%rsp), %rdi
callq 0x2130
movl %eax, 0x234(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movq 0x238(%rsp), %rdx
movl 0x234(%rsp), %ecx
callq 0x3c70
movl $0x0, 0x230(%rsp)
movl 0x230(%rsp), %eax
movl $0x10, %ecx
subl 0x234(%rsp), %ecx
cmpl %ecx, %eax
jae 0x12796
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movl $0x20, %edx
callq 0x3270
movl 0x230(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x230(%rsp)
jmp 0x12752
movq 0x288(%rsp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movl 0x27c(%rsp), %ecx
movl %ecx, %edx
incl %edx
movl %edx, 0x27c(%rsp)
movzbl (%rax,%rcx), %eax
movl %eax, 0x22c(%rsp)
movl 0x22c(%rsp), %eax
movq %rax, 0x30(%rsp)
subq $0x4c, %rax
ja 0x13b9a
movq 0x30(%rsp), %rax
leaq 0x18264(%rip), %rcx     # 0x2aa48
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x27c(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x27c(%rsp)
movq 0x270(%rsp), %rax
movl 0x27c(%rsp), %ecx
subl $0x2, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
movq 0x270(%rsp), %rcx
movl 0x27c(%rsp), %edx
subl $0x1, %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movl %eax, 0x228(%rsp)
cmpl $0x0, 0x228(%rsp)
jb 0x1285c
movl 0x228(%rsp), %eax
movq 0x288(%rsp), %rcx
movq 0x18(%rcx), %rcx
cmpl 0x78(%rcx), %eax
jb 0x12896
movq 0x20795(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x178e3(%rip), %rsi     # 0x2a150
leaq 0x17a99(%rip), %rdx     # 0x2a30d
leaq 0x18324(%rip), %rcx     # 0x2ab9f
leaq 0x1832e(%rip), %r8      # 0x2abb0
movl $0x6c, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x12898
movq 0x288(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x70(%rax), %rax
movslq 0x228(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x220(%rsp)
leaq 0x214(%rsp), %rdi
movl 0x228(%rsp), %ecx
leaq 0x182ed(%rip), %rsi     # 0x2abbf
movl $0x5, %edx
movb $0x0, %al
callq 0x2350
movl %eax, 0x210(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x214(%rsp), %rdx
movl 0x210(%rsp), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movl $0x20, %edx
callq 0x3270
movq 0x290(%rsp), %rdi
movq 0x220(%rsp), %rsi
movq 0x280(%rsp), %rdx
callq 0x12300
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movl $0xa, %edx
callq 0x3270
jmp 0x13bcf
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movl $0xa, %edx
callq 0x3270
jmp 0x13bcf
jmp 0x12980
jmp 0x12982
leaq 0x204(%rsp), %rdi
movl 0x27c(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x27c(%rsp)
movq 0x270(%rsp), %rax
movl 0x27c(%rsp), %ecx
subl $0x2, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %ecx
shll $0x8, %ecx
movq 0x270(%rsp), %rax
movl 0x27c(%rsp), %edx
subl $0x1, %edx
movl %edx, %edx
movzbl (%rax,%rdx), %eax
orl %eax, %ecx
leaq 0x181e8(%rip), %rsi     # 0x2abbf
movl $0x5, %edx
movb $0x0, %al
callq 0x2350
movl %eax, 0x200(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x204(%rsp), %rdx
movl 0x200(%rsp), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movl $0xa, %edx
callq 0x3270
jmp 0x13bcf
movq 0x270(%rsp), %rax
movl 0x27c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x27c(%rsp)
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl %eax, 0x1fc(%rsp)
cmpl $0x0, 0x1fc(%rsp)
jb 0x12a77
movl 0x1fc(%rsp), %eax
movq 0x288(%rsp), %rcx
movq 0x18(%rcx), %rcx
cmpl 0x58(%rcx), %eax
jb 0x12ab1
movq 0x2057a(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x176c8(%rip), %rsi     # 0x2a150
leaq 0x1787e(%rip), %rdx     # 0x2a30d
leaq 0x18109(%rip), %rcx     # 0x2ab9f
leaq 0x18113(%rip), %r8      # 0x2abb0
movl $0x83, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x12ab3
movq 0x288(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x50(%rax), %rax
movslq 0x1fc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x18(%rax), %eax
movl %eax, 0x1f8(%rsp)
cmpl $0x0, 0x1f8(%rsp)
jb 0x12afb
movl 0x1f8(%rsp), %eax
movq 0x288(%rsp), %rcx
movq 0x18(%rcx), %rcx
cmpl 0x68(%rcx), %eax
jb 0x12b35
movq 0x204f6(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x17644(%rip), %rsi     # 0x2a150
leaq 0x177fa(%rip), %rdx     # 0x2a30d
leaq 0x18085(%rip), %rcx     # 0x2ab9f
leaq 0x1808f(%rip), %r8      # 0x2abb0
movl $0x85, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x12b37
movq 0x288(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x60(%rax), %rax
movl 0x1f8(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x1f0(%rsp)
leaq 0x1e4(%rsp), %rdi
movl 0x1fc(%rsp), %ecx
leaq 0x1804f(%rip), %rsi     # 0x2abbf
movl $0x5, %edx
movb $0x0, %al
callq 0x2350
movl %eax, 0x1e0(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x1e4(%rsp), %rdx
movl 0x1e0(%rsp), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x1800d(%rip), %rdx     # 0x2abcb
movl $0x5, %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movq 0x1f0(%rsp), %rdx
addq $0x1c, %rdx
movq 0x1f0(%rsp), %rax
movl 0x14(%rax), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x18017(%rip), %rdx     # 0x2ac22
movl $0x2, %ecx
callq 0x3c70
jmp 0x13bcf
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movl $0xa, %edx
callq 0x3270
jmp 0x13bcf
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movl $0xa, %edx
callq 0x3270
jmp 0x13bcf
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movl $0xa, %edx
callq 0x3270
jmp 0x13bcf
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movl $0xa, %edx
callq 0x3270
jmp 0x13bcf
cmpl $0x15, 0x22c(%rsp)
jne 0x12d17
movq 0x270(%rsp), %rax
movl 0x27c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x27c(%rsp)
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl %eax, 0x1dc(%rsp)
leaq 0x1d0(%rsp), %rdi
movl 0x1dc(%rsp), %ecx
leaq 0x17ee1(%rip), %rsi     # 0x2abbf
movl $0x5, %edx
movb $0x0, %al
callq 0x2350
movl %eax, 0x1cc(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x1d0(%rsp), %rdx
movl 0x1cc(%rsp), %ecx
callq 0x3c70
jmp 0x12d6c
movl 0x22c(%rsp), %eax
subl $0xc, %eax
movl %eax, 0x1dc(%rsp)
movl $0x0, 0x1c8(%rsp)
cmpl $0x5, 0x1c8(%rsp)
jge 0x12d6a
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movl $0x20, %edx
callq 0x3270
movl 0x1c8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c8(%rsp)
jmp 0x12d33
jmp 0x12d6c
movl 0x1dc(%rsp), %eax
movq 0x288(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x12e15
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x17e36(%rip), %rdx     # 0x2abd1
movl $0x8, %ecx
callq 0x3c70
leaq 0x1bc(%rsp), %rdi
movl 0x1dc(%rsp), %ecx
leaq 0x17e04(%rip), %rsi     # 0x2abbf
movl $0x1, %edx
movb $0x0, %al
callq 0x2350
movl %eax, 0x1b8(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x1bc(%rsp), %rdx
movl 0x1b8(%rsp), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x17de0(%rip), %rdx     # 0x2abe9
movl $0x2, %ecx
callq 0x3c70
jmp 0x12e2f
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movl $0xa, %edx
callq 0x3270
jmp 0x13bcf
cmpl $0x1f, 0x22c(%rsp)
jne 0x12eb5
movq 0x270(%rsp), %rax
movl 0x27c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x27c(%rsp)
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl %eax, 0x1b4(%rsp)
leaq 0x1a8(%rsp), %rdi
movl 0x1b4(%rsp), %ecx
leaq 0x17d43(%rip), %rsi     # 0x2abbf
movl $0x5, %edx
movb $0x0, %al
callq 0x2350
movl %eax, 0x1a4(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x1a8(%rsp), %rdx
movl 0x1a4(%rsp), %ecx
callq 0x3c70
jmp 0x12f0a
movl 0x22c(%rsp), %eax
subl $0x16, %eax
movl %eax, 0x1b4(%rsp)
movl $0x0, 0x1a0(%rsp)
cmpl $0x5, 0x1a0(%rsp)
jge 0x12f08
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movl $0x20, %edx
callq 0x3270
movl 0x1a0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1a0(%rsp)
jmp 0x12ed1
jmp 0x12f0a
movl 0x1b4(%rsp), %eax
movq 0x288(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x12fb3
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x17c98(%rip), %rdx     # 0x2abd1
movl $0x8, %ecx
callq 0x3c70
leaq 0x194(%rsp), %rdi
movl 0x1b4(%rsp), %ecx
leaq 0x17c66(%rip), %rsi     # 0x2abbf
movl $0x1, %edx
movb $0x0, %al
callq 0x2350
movl %eax, 0x190(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x194(%rsp), %rdx
movl 0x190(%rsp), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x17c42(%rip), %rdx     # 0x2abe9
movl $0x2, %ecx
callq 0x3c70
jmp 0x12fcd
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movl $0xa, %edx
callq 0x3270
jmp 0x13bcf
movq 0x270(%rsp), %rax
movl 0x27c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x27c(%rsp)
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl %eax, 0x18c(%rsp)
movq 0x288(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x30(%rax), %rax
movslq 0x18c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x188(%rsp)
movq 0x288(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x60(%rax), %rax
movslq 0x188(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x180(%rsp)
leaq 0x174(%rsp), %rdi
movl 0x18c(%rsp), %ecx
leaq 0x17b69(%rip), %rsi     # 0x2abbf
movl $0x5, %edx
movb $0x0, %al
callq 0x2350
movl %eax, 0x170(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x174(%rsp), %rdx
movl 0x170(%rsp), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x17af4(%rip), %rdx     # 0x2ab98
movl $0x2, %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movq 0x180(%rsp), %rdx
addq $0x1c, %rdx
movq 0x180(%rsp), %rax
movl 0x14(%rax), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x17ae9(%rip), %rdx     # 0x2abda
movl $0x2, %ecx
callq 0x3c70
jmp 0x13bcf
movq 0x270(%rsp), %rax
movl 0x27c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x27c(%rsp)
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl %eax, 0x16c(%rsp)
movq 0x288(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x40(%rax), %rax
movslq 0x16c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq %rax, 0x160(%rsp)
leaq 0x154(%rsp), %rdi
movl 0x16c(%rsp), %ecx
leaq 0x17a59(%rip), %rsi     # 0x2abbf
movl $0x5, %edx
movb $0x0, %al
callq 0x2350
movl %eax, 0x150(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x154(%rsp), %rdx
movl 0x150(%rsp), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x17a29(%rip), %rdx     # 0x2abdd
movl $0x5, %ecx
callq 0x3c70
movq 0x280(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x290(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x160(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x160(%rsp), %rdi
callq 0x2130
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl %eax, %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x17a03(%rip), %rdx     # 0x2ac22
movl $0x2, %ecx
callq 0x3c70
jmp 0x13bcf
movq 0x270(%rsp), %rax
movl 0x27c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x27c(%rsp)
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl %eax, 0x14c(%rsp)
cmpl $0x0, 0x14c(%rsp)
jb 0x13278
movl 0x14c(%rsp), %eax
movq 0x288(%rsp), %rcx
movq 0x18(%rcx), %rcx
cmpl 0x58(%rcx), %eax
jb 0x132b2
movq 0x1fd79(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x16ec7(%rip), %rsi     # 0x2a150
leaq 0x1707d(%rip), %rdx     # 0x2a30d
leaq 0x17908(%rip), %rcx     # 0x2ab9f
leaq 0x17912(%rip), %r8      # 0x2abb0
movl $0xf6, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x132b4
movq 0x288(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x50(%rax), %rax
movslq 0x14c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x18(%rax), %eax
movl %eax, 0x148(%rsp)
cmpl $0x0, 0x148(%rsp)
jb 0x132fc
movl 0x148(%rsp), %eax
movq 0x288(%rsp), %rcx
movq 0x18(%rcx), %rcx
cmpl 0x68(%rcx), %eax
jb 0x13336
movq 0x1fcf5(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x16e43(%rip), %rsi     # 0x2a150
leaq 0x16ff9(%rip), %rdx     # 0x2a30d
leaq 0x17884(%rip), %rcx     # 0x2ab9f
leaq 0x1788e(%rip), %r8      # 0x2abb0
movl $0xf8, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x13338
movq 0x288(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x60(%rax), %rax
movl 0x148(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x140(%rsp)
leaq 0x134(%rsp), %rdi
movl 0x14c(%rsp), %ecx
leaq 0x1784e(%rip), %rsi     # 0x2abbf
movl $0x5, %edx
movb $0x0, %al
callq 0x2350
movl %eax, 0x130(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x134(%rsp), %rdx
movl 0x130(%rsp), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x1780c(%rip), %rdx     # 0x2abcb
movl $0x5, %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movq 0x140(%rsp), %rdx
addq $0x1c, %rdx
movq 0x140(%rsp), %rax
movl 0x14(%rax), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x17816(%rip), %rdx     # 0x2ac22
movl $0x2, %ecx
callq 0x3c70
jmp 0x13bcf
movq 0x270(%rsp), %rax
movl 0x27c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x27c(%rsp)
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl %eax, 0x12c(%rsp)
movq 0x290(%rsp), %rdi
movl 0x12c(%rsp), %esi
callq 0x1c760
movq %rax, 0x120(%rsp)
leaq 0x114(%rsp), %rdi
movl 0x12c(%rsp), %ecx
leaq 0x1774a(%rip), %rsi     # 0x2abbf
movl $0x5, %edx
movb $0x0, %al
callq 0x2350
movl %eax, 0x110(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x114(%rsp), %rdx
movl 0x110(%rsp), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x1771a(%rip), %rdx     # 0x2abdd
movl $0x5, %ecx
callq 0x3c70
movq 0x280(%rsp), %rax
movq %rax, (%rsp)
movq 0x290(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x120(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x120(%rsp), %rdi
callq 0x2130
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl %eax, %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x176f6(%rip), %rdx     # 0x2ac22
movl $0x2, %ecx
callq 0x3c70
jmp 0x13bcf
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movl $0xa, %edx
callq 0x3270
jmp 0x13bcf
movl 0x27c(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x27c(%rsp)
movq 0x270(%rsp), %rax
movl 0x27c(%rsp), %ecx
subl $0x2, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
movq 0x270(%rsp), %rcx
movl 0x27c(%rsp), %edx
subl $0x1, %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movl %eax, 0x10c(%rsp)
movq 0x288(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x60(%rax), %rax
movslq 0x10c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x100(%rsp)
leaq 0xf4(%rsp), %rdi
movl 0x10c(%rsp), %ecx
leaq 0x175de(%rip), %rsi     # 0x2abbf
movl $0x5, %edx
movb $0x0, %al
callq 0x2350
movl %eax, 0xf0(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0xf4(%rsp), %rdx
movl 0xf0(%rsp), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x17569(%rip), %rdx     # 0x2ab98
movl $0x2, %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movq 0x100(%rsp), %rdx
addq $0x1c, %rdx
movq 0x100(%rsp), %rax
movl 0x14(%rax), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x1755e(%rip), %rdx     # 0x2abda
movl $0x2, %ecx
callq 0x3c70
jmp 0x13bcf
jmp 0x1368d
leaq 0xe4(%rsp), %rdi
movq 0x270(%rsp), %rax
movl 0x27c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x27c(%rsp)
movl %ecx, %ecx
movzbl (%rax,%rcx), %ecx
leaq 0x17502(%rip), %rsi     # 0x2abbf
movl $0x5, %edx
movb $0x0, %al
callq 0x2350
movl %eax, 0xe0(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0xe4(%rsp), %rdx
movl 0xe0(%rsp), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x174d8(%rip), %rdx     # 0x2abe3
movl $0x8, %ecx
callq 0x3c70
jmp 0x13bcf
jmp 0x1371c
leaq 0xd4(%rsp), %rdi
movq 0x270(%rsp), %rax
movl 0x27c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x27c(%rsp)
movl %ecx, %ecx
movzbl (%rax,%rcx), %ecx
leaq 0x17473(%rip), %rsi     # 0x2abbf
movl $0x5, %edx
movb $0x0, %al
callq 0x2350
movl %eax, 0xd0(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0xd4(%rsp), %rdx
movl 0xd0(%rsp), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x17449(%rip), %rdx     # 0x2abe3
movl $0x8, %ecx
callq 0x3c70
jmp 0x13bcf
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movl $0xa, %edx
callq 0x3270
jmp 0x13bcf
movl 0x27c(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x27c(%rsp)
movq 0x270(%rsp), %rax
movl 0x27c(%rsp), %ecx
subl $0x2, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
movq 0x270(%rsp), %rcx
movl 0x27c(%rsp), %edx
subl $0x1, %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movl %eax, 0xcc(%rsp)
leaq 0xc0(%rsp), %rdi
movl 0xcc(%rsp), %ecx
leaq 0x17394(%rip), %rsi     # 0x2abbf
movl $0x5, %edx
movb $0x0, %al
callq 0x2350
movl %eax, 0xbc(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
movl 0xbc(%rsp), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x17373(%rip), %rdx     # 0x2abec
movl $0x5, %ecx
callq 0x3c70
leaq 0xb0(%rsp), %rdi
movl 0x27c(%rsp), %edx
addl 0xcc(%rsp), %edx
leaq 0x1a2d1(%rip), %rsi     # 0x2db71
movb $0x0, %al
callq 0x2350
movl %eax, 0xac(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
movl 0xac(%rsp), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x17300(%rip), %rdx     # 0x2abe9
movl $0x2, %ecx
callq 0x3c70
jmp 0x13bcf
movl 0x27c(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x27c(%rsp)
movq 0x270(%rsp), %rax
movl 0x27c(%rsp), %ecx
subl $0x2, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
movq 0x270(%rsp), %rcx
movl 0x27c(%rsp), %edx
subl $0x1, %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movl %eax, 0xa8(%rsp)
leaq 0x9c(%rsp), %rdi
xorl %ecx, %ecx
subl 0xa8(%rsp), %ecx
leaq 0x17262(%rip), %rsi     # 0x2abbf
movl $0x5, %edx
movb $0x0, %al
callq 0x2350
movl %eax, 0x98(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x9c(%rsp), %rdx
movl 0x98(%rsp), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x17241(%rip), %rdx     # 0x2abec
movl $0x5, %ecx
callq 0x3c70
leaq 0x8c(%rsp), %rdi
movl 0x27c(%rsp), %edx
subl 0xa8(%rsp), %edx
leaq 0x1a19f(%rip), %rsi     # 0x2db71
movb $0x0, %al
callq 0x2350
movl %eax, 0x88(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x8c(%rsp), %rdx
movl 0x88(%rsp), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x171ce(%rip), %rdx     # 0x2abe9
movl $0x2, %ecx
callq 0x3c70
jmp 0x13bcf
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movl $0xa, %edx
callq 0x3270
jmp 0x13bcf
movl 0x27c(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x27c(%rsp)
movq 0x270(%rsp), %rax
movl 0x27c(%rsp), %ecx
subl $0x2, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
movq 0x270(%rsp), %rcx
movl 0x27c(%rsp), %edx
subl $0x1, %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movl %eax, 0x84(%rsp)
movq 0x288(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x60(%rax), %rax
movslq 0x84(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x78(%rsp)
leaq 0x6c(%rsp), %rdi
movl 0x84(%rsp), %ecx
leaq 0x170f5(%rip), %rsi     # 0x2abbf
movl $0x5, %edx
movb $0x0, %al
callq 0x2350
movl %eax, 0x68(%rsp)
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x6c(%rsp), %rdx
movl 0x68(%rsp), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x17089(%rip), %rdx     # 0x2ab98
movl $0x2, %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movq 0x78(%rsp), %rdx
addq $0x1c, %rdx
movq 0x78(%rsp), %rax
movl 0x14(%rax), %ecx
callq 0x3c70
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x17084(%rip), %rdx     # 0x2abda
movl $0x2, %ecx
callq 0x3c70
jmp 0x13bcf
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movl $0xa, %edx
callq 0x3270
jmp 0x13bcf
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
movl $0xa, %edx
callq 0x3270
jmp 0x13bcf
jmp 0x13b9c
movq 0x1f455(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x1662d(%rip), %rsi     # 0x2a1da
leaq 0x16feb(%rip), %rdx     # 0x2ab9f
leaq 0x16ff5(%rip), %rcx     # 0x2abb0
movl $0x179, %r8d            # imm = 0x179
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x124f6
movq 0x280(%rsp), %rdi
movq 0x290(%rsp), %rsi
xorl %edx, %edx
callq 0x3270
addq $0x298, %rsp            # imm = 0x298
retq
nopw %cs:(%rax,%rax)