// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x38(%rsi), %rax
movq (%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x40(%rsp)
leaq 0xebd0(%rip), %rdx      # 0x18b20
pushq $0x1e
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3056
movq 0x10(%r12), %r15
movq %r15, %rdi
callq 0x2140
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %eax, %ecx
callq 0x3056
leaq 0xebbd(%rip), %rdx      # 0x18b3f
pushq $0x3
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3056
movq %r12, 0x28(%rsp)
movq 0x18(%r12), %rax
movq 0x18(%rax), %r15
addq $0x1c, %r15
movq %r15, %rdi
callq 0x2140
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %eax, %ecx
callq 0x3056
leaq 0x11631(%rip), %rdx     # 0x1b5f2
pushq $0x2
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3056
leaq 0xeb96(%rip), %r13      # 0x18b6c
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rax
cmpl 0x8(%rax), %r12d
jae 0xa7fb
movq %r12, 0x38(%rsp)
movl %r12d, %ecx
movq 0x40(%rsp), %rax
movq %rcx, 0x30(%rsp)
movl (%rax,%rcx,4), %eax
movq %rbx, %rdi
movq %r14, %rsi
cmpl %r15d, %eax
jne 0xa037
leaq 0xeb51(%rip), %rdx      # 0x18b67
pushq $0x7
popq %rcx
callq 0x3056
movl %r15d, 0xc(%rsp)
pushq $0x2
popq %r15
leaq 0x1c(%rsp), %rbp
movq %r14, %r12
movq %rbx, %r14
pushq $0x4
popq %rbx
jmp 0xa090
movq %r13, %rdx
pushq $0x2
popq %rcx
movl %eax, %r15d
callq 0x3056
leaq 0x1c(%rsp), %rdi
movq %rdi, %rbp
leaq 0xeb0f(%rip), %rsi      # 0x18b63
movq %r14, %r12
movq %rbx, %r14
pushq $0x4
popq %rbx
movl %ebx, %edx
movl %r15d, 0xc(%rsp)
movl %r15d, %ecx
pushq $0x2
popq %r15
xorl %eax, %eax
callq 0x2360
movq %r14, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movl %eax, %ecx
callq 0x3056
movq %r14, %rdi
movq %r12, %rsi
pushq $0x3a
popq %rdx
callq 0x2c3c
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %r15d, %ecx
callq 0x3056
movq %rbp, %rdi
leaq 0xeab8(%rip), %rsi      # 0x18b63
movl %ebx, %edx
movq 0x38(%rsp), %rcx
xorl %eax, %eax
callq 0x2360
movq %r14, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movl %eax, %ecx
callq 0x3056
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %r15d, %ecx
callq 0x3056
xorl %edi, %edi
callq 0x2140
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
movl %r15d, %ecx
callq 0x3056
addl $-0x10, %r15d
movq %r14, %rbx
movq %r12, %r14
pushq $0x20
popq %rbp
testl %r15d, %r15d
je 0xa118
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2c3c
incl %r15d
jmp 0xa101
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq 0x30(%rsp), %rcx
movzbl (%rax,%rcx), %r15d
cmpq $0x4c, %r15
ja 0xa908
movq 0x38(%rsp), %r12
leal 0x1(%r12), %ebp
leaq 0xe8a3(%rip), %rax      # 0x189ec
movslq (%rax,%r15,4), %rcx
addq %rax, %rcx
movl %ebp, %eax
jmpq *%rcx
cmpl $0x15, %r15d
je 0xa17a
pushq $0x5
popq %r13
subl $0x1, %r13d
jb 0xa1b9
pushq $0x20
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c3c
jmp 0xa15e
cmpl $0x1f, %r15d
jne 0xa1bf
addl $0x2, %r12d
movq 0x10(%rsp), %rcx
movzbl (%rcx,%rax), %r15d
leaq 0xe9d4(%rip), %rsi      # 0x18b63
leaq 0x1c(%rsp), %r13
pushq $0x5
popq %rdx
movq %r13, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x2360
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movl %eax, %ecx
callq 0x3056
movl %r12d, %ebp
jmp 0xa1dd
addl $-0xc, %r15d
jmp 0xa1dd
pushq $0x5
popq %r13
subl $0x1, %r13d
jb 0xa1d9
pushq $0x20
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c3c
jmp 0xa1c3
addl $-0x16, %r15d
movq 0x28(%rsp), %rax
cmpl 0x20(%rax), %r15d
jge 0xa74a
leaq 0xe982(%rip), %rdx      # 0x18b75
pushq $0x8
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3056
leaq 0xe95b(%rip), %rsi      # 0x18b63
leaq 0x1c(%rsp), %r13
pushq $0x1
popq %rdx
movq %r13, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x2360
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movl %eax, %ecx
callq 0x3056
leaq 0xe959(%rip), %rdx      # 0x18b8d
pushq $0x2
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0xa398
leal 0x3(%r12), %ecx
movl %ecx, 0x30(%rsp)
movq 0x10(%rsp), %rdx
movzbl (%rdx,%rax), %eax
shll $0x8, %eax
leal 0x2(%r12), %ecx
movzbl (%rdx,%rcx), %r15d
orl %eax, %r15d
leaq 0xe8f8(%rip), %rsi      # 0x18b63
leaq 0x1c(%rsp), %rbp
pushq $0x5
popq %r13
movq %rbp, %rdi
movl %r13d, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x2360
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movl %eax, %ecx
callq 0x3056
leaq 0xe8f5(%rip), %rdx      # 0x18b90
movq %rbx, %rdi
movq %r14, %rsi
movl %r13d, %ecx
callq 0x3056
leal (%r12,%r15), %edx
addl $0x3, %edx
leaq 0x1176a(%rip), %rsi     # 0x1ba21
leaq 0x1c(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x2360
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %eax, %ecx
callq 0x3056
leaq 0xe8b0(%rip), %rdx      # 0x18b8d
pushq $0x2
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3056
movl 0xc(%rsp), %r15d
movl 0x30(%rsp), %eax
movl %eax, %r12d
leaq 0xe86e(%rip), %r13      # 0x18b6c
jmp 0x9fdc
leal 0x3(%r12), %ebp
movq 0x10(%rsp), %rcx
movzbl (%rcx,%rax), %eax
shll $0x8, %eax
addl $0x2, %r12d
movzbl (%rcx,%r12), %ecx
orl %eax, %ecx
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x60(%rax), %rax
movq (%rax,%rcx,8), %r15
leaq 0xe82c(%rip), %rsi      # 0x18b63
leaq 0x1c(%rsp), %r13
pushq $0x5
popq %rdx
movq %r13, %rdi
xorl %eax, %eax
callq 0x2360
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movl %eax, %ecx
callq 0x3056
leaq 0xe7dc(%rip), %rdx      # 0x18b3c
pushq $0x2
popq %r13
movq %rbx, %rdi
movq %r14, %rsi
movl %r13d, %ecx
callq 0x3056
movl 0x14(%r15), %ecx
addq $0x1c, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3056
leaq 0xe7ef(%rip), %rdx      # 0x18b7e
movq %rbx, %rdi
movq %r14, %rsi
movl %r13d, %ecx
callq 0x3056
jmp 0xa758
addl $0x2, %r12d
movq 0x10(%rsp), %rcx
movzbl (%rcx,%rax), %ecx
leaq 0xe7ad(%rip), %rsi      # 0x18b63
leaq 0x1c(%rsp), %r15
pushq $0x5
popq %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x2360
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %eax, %ecx
callq 0x3056
leaq 0xe7a8(%rip), %rdx      # 0x18b87
pushq $0x8
jmp 0xa62c
addl $0x2, %r12d
movq 0x10(%rsp), %rcx
movzbl (%rcx,%rax), %ecx
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x30(%rax), %rdx
movq 0x60(%rax), %rax
movslq (%rdx,%rcx,4), %rdx
movq (%rax,%rdx,8), %r15
leaq 0xe750(%rip), %rsi      # 0x18b63
leaq 0x1c(%rsp), %r13
pushq $0x5
popq %rdx
movq %r13, %rdi
xorl %eax, %eax
callq 0x2360
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movl %eax, %ecx
callq 0x3056
leaq 0xe700(%rip), %rdx      # 0x18b3c
pushq $0x2
popq %rbp
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x3056
movl 0x14(%r15), %ecx
addq $0x1c, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3056
leaq 0xe715(%rip), %rdx      # 0x18b7e
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
jmp 0xa633
movq 0x10(%rsp), %rcx
movzbl (%rcx,%rax), %ecx
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
cmpl %ecx, 0x58(%rax)
jbe 0xa817
movq 0x50(%rax), %rdx
movl %ecx, %esi
movq (%rdx,%rsi,8), %rdx
movl 0x18(%rdx), %edx
cmpl 0x68(%rax), %edx
jb 0xa4d9
jmp 0xa848
movq 0x10(%rsp), %rcx
movzbl (%rcx,%rax), %ecx
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
cmpl %ecx, 0x58(%rax)
jbe 0xa879
movq 0x50(%rax), %rdx
movl %ecx, %esi
movq (%rdx,%rsi,8), %rdx
movl 0x18(%rdx), %edx
cmpl 0x68(%rax), %edx
jae 0xa8a7
addl $0x2, %r12d
movq 0x60(%rax), %rax
movq (%rax,%rdx,8), %r15
leaq 0xe677(%rip), %rsi      # 0x18b63
leaq 0x1c(%rsp), %r13
pushq $0x5
popq %rbp
movq %r13, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2360
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movl %eax, %ecx
callq 0x3056
leaq 0xe658(%rip), %rdx      # 0x18b6f
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x3056
movl 0x14(%r15), %ecx
addq $0x1c, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
jmp 0xa61e
addl $0x2, %r12d
movq 0x10(%rsp), %rcx
movzbl (%rcx,%rax), %ecx
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x40(%rax), %rax
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %r15
leaq 0xe600(%rip), %rsi      # 0x18b63
leaq 0x1c(%rsp), %r13
pushq $0x5
popq %rbp
movq %r13, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2360
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movl %eax, %ecx
callq 0x3056
leaq 0xe5f3(%rip), %rdx      # 0x18b81
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x3056
movq %r15, %rdi
callq 0x2140
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
jmp 0xa61c
addl $0x2, %r12d
movq 0x10(%rsp), %rcx
movzbl (%rcx,%rax), %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0xf777
movq %rax, %r13
leaq 0xe592(%rip), %rsi      # 0x18b63
leaq 0x1c(%rsp), %rdi
pushq $0x5
popq %rbp
movl %ebp, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x2360
movq %rbx, %rdi
movq %r14, %rsi
leaq 0x1c(%rsp), %rdx
movl %eax, %ecx
callq 0x3056
leaq 0xe583(%rip), %rdx      # 0x18b81
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x3056
movq %r13, %rdi
callq 0x2140
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movl %eax, %ecx
callq 0x3056
leaq 0xe59c(%rip), %rdx      # 0x18bc6
pushq $0x2
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3056
movl 0xc(%rsp), %r15d
leaq 0xe528(%rip), %r13      # 0x18b6c
jmp 0x9fdc
leal 0x3(%r12), %ecx
movl %ecx, 0x30(%rsp)
movq 0x10(%rsp), %rcx
movzbl (%rcx,%rax), %eax
shll $0x8, %eax
addl $0x2, %r12d
movzbl (%rcx,%r12), %ebp
orl %eax, %ebp
movl %ebp, %ecx
negl %ecx
leaq 0xe4ef(%rip), %rsi      # 0x18b63
leaq 0x1c(%rsp), %r15
pushq $0x5
popq %r13
movq %r15, %rdi
movl %r13d, %edx
xorl %eax, %eax
callq 0x2360
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %eax, %ecx
callq 0x3056
leaq 0xe4ef(%rip), %rdx      # 0x18b90
movq %rbx, %rdi
movq %r14, %rsi
movl %r13d, %ecx
callq 0x3056
movl 0x30(%rsp), %r12d
movl %r12d, %edx
subl %ebp, %edx
leaq 0x11361(%rip), %rsi     # 0x1ba21
leaq 0x1c(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x2360
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %eax, %ecx
callq 0x3056
leaq 0xe4a7(%rip), %rdx      # 0x18b8d
pushq $0x2
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3056
movl 0xc(%rsp), %r15d
leaq 0xe46c(%rip), %r13      # 0x18b6c
jmp 0x9fdc
leal 0x3(%r12), %ebp
movq 0x10(%rsp), %rcx
movzbl (%rcx,%rax), %eax
shll $0x8, %eax
addl $0x2, %r12d
movzbl (%rcx,%r12), %ecx
orl %eax, %ecx
leaq 0xe43b(%rip), %rsi      # 0x18b63
leaq 0x1c(%rsp), %r15
pushq $0x5
popq %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x2360
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %eax, %ecx
callq 0x3056
pushq $0xa
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c3c
movl 0xc(%rsp), %r15d
movl %ebp, %r12d
leaq 0xe405(%rip), %r13      # 0x18b6c
jmp 0x9fdc
movq 0x10(%rsp), %rdx
movzbl (%rdx,%rax), %eax
shll $0x8, %eax
leal 0x2(%r12), %ecx
movzbl (%rdx,%rcx), %ecx
orl %eax, %ecx
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
cmpl 0x78(%rax), %ecx
jae 0xa8d5
addl $0x3, %r12d
movq 0x70(%rax), %rax
movl %ecx, %edx
movq (%rax,%rdx,8), %r13
leaq 0xe3b9(%rip), %rsi      # 0x18b63
leaq 0x1c(%rsp), %r15
pushq $0x5
popq %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x2360
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %eax, %ecx
callq 0x3056
pushq $0x20
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c3c
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x9edc
pushq $0xa
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c3c
jmp 0xa638
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2c3c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x187da(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0xd8c8(%rip), %rsi      # 0x180f0
leaq 0xda7e(%rip), %rdx      # 0x182ad
leaq 0xe30d(%rip), %rcx      # 0x18b43
leaq 0xe317(%rip), %r8       # 0x18b54
movl $0x83, %r9d
jmp 0xa8ff
movq 0x187a9(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0xd897(%rip), %rsi      # 0x180f0
leaq 0xda4d(%rip), %rdx      # 0x182ad
leaq 0xe2dc(%rip), %rcx      # 0x18b43
leaq 0xe2e6(%rip), %r8       # 0x18b54
movl $0x85, %r9d
jmp 0xa8ff
movq 0x18778(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0xd866(%rip), %rsi      # 0x180f0
leaq 0xda1c(%rip), %rdx      # 0x182ad
leaq 0xe2ab(%rip), %rcx      # 0x18b43
leaq 0xe2b5(%rip), %r8       # 0x18b54
movl $0xf6, %r9d
jmp 0xa8ff
movq 0x1874a(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0xd838(%rip), %rsi      # 0x180f0
leaq 0xd9ee(%rip), %rdx      # 0x182ad
leaq 0xe27d(%rip), %rcx      # 0x18b43
leaq 0xe287(%rip), %r8       # 0x18b54
movl $0xf8, %r9d
jmp 0xa8ff
movq 0x1871c(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0xd80a(%rip), %rsi      # 0x180f0
leaq 0xd9c0(%rip), %rdx      # 0x182ad
leaq 0xe24f(%rip), %rcx      # 0x18b43
leaq 0xe259(%rip), %r8       # 0x18b54
pushq $0x6c
popq %r9
xorl %eax, %eax
callq 0x2250
ud2
movq 0x186e9(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0xd861(%rip), %rsi      # 0x1817a
leaq 0xe223(%rip), %rdx      # 0x18b43
leaq 0xe22d(%rip), %rcx      # 0x18b54
movl $0x179, %r8d            # imm = 0x179
xorl %eax, %eax
callq 0x2250
ud2