// File: /workspace/github_c_makefile_star2_O3/atomlang[P]atomlang/src/pk_var.c
// Function: toStringInternal
static void _toStringInternal(PKVM* vm, const Var v, pkByteBuffer* buff,
                              OuterSequence* outer, bool repr) {
  ASSERT(outer == NULL || repr, OOPS);

  if (IS_NULL(v)) {
    pkByteBufferAddString(buff, vm, "null", 4);
    return;

  } else if (IS_BOOL(v)) {
    if (AS_BOOL(v)) pkByteBufferAddString(buff, vm, "true", 4);
    else pkByteBufferAddString(buff, vm, "false", 5);
    return;

  } else if (IS_NUM(v)) {
    double value = AS_NUM(v);

    if (isnan(value)) {
      pkByteBufferAddString(buff, vm, "nan", 3);

    } else if (isinf(value)) {
      if (value > 0.0) {
        pkByteBufferAddString(buff, vm, "+inf", 4);
      } else {
        pkByteBufferAddString(buff, vm, "-inf", 4);
      }

    } else {
      char num_buff[STR_DBL_BUFF_SIZE];
      int length = sprintf(num_buff, DOUBLE_FMT, AS_NUM(v));
      pkByteBufferAddString(buff, vm, num_buff, length);
    }

    return;

  } else if (IS_OBJ(v)) {

    const Object* obj = AS_OBJ(v);
    switch (obj->type) {

      case OBJ_STRING:
      {
        const String* str = (const String*)obj;
        if (outer == NULL && !repr) {
          pkByteBufferAddString(buff, vm, str->data, str->length);
          return;
        } else {
          // If recursive return with quotes (ex: [42, "hello", 0..10]).
          pkByteBufferWrite(buff, vm, '"');
          for (const char* c = str->data; *c != '\0'; c++) {
            switch (*c) {
              case '"': pkByteBufferAddString(buff, vm, "\\\"", 2); break;
              case '\\': pkByteBufferAddString(buff, vm, "\\\\", 2); break;
              case '\n': pkByteBufferAddString(buff, vm, "\\n", 2); break;
              case '\r': pkByteBufferAddString(buff, vm, "\\r", 2); break;
              case '\t': pkByteBufferAddString(buff, vm, "\\t", 2); break;

              default:
                pkByteBufferWrite(buff, vm, *c);
                break;
            }
          }
          pkByteBufferWrite(buff, vm, '"');
          return;
        }
        UNREACHABLE();
      }

      case OBJ_LIST:
      {
        const List* list = (const List*)obj;
        if (list->elements.count == 0) {
          pkByteBufferAddString(buff, vm, "[]", 2);
          return;
        }

        // Check if the list is recursive.
        OuterSequence* seq = outer;
        while (seq != NULL) {
          if (seq->is_list && seq->list == list) {
            pkByteBufferAddString(buff, vm, "[...]", 5);
            return;
          }
          seq = seq->outer;
        }
        OuterSequence seq_list;
        seq_list.outer = outer; seq_list.is_list = true; seq_list.list = list;

        pkByteBufferWrite(buff, vm, '[');
        for (uint32_t i = 0; i < list->elements.count; i++) {
          if (i != 0) pkByteBufferAddString(buff, vm, ", ", 2);
          _toStringInternal(vm, list->elements.data[i], buff, &seq_list, true);
        }
        pkByteBufferWrite(buff, vm, ']');
        return;
      }

      case OBJ_MAP:
      {
        const Map* map = (const Map*)obj;
        if (map->entries == NULL) {
          pkByteBufferAddString(buff, vm, "{}", 2);
          return;
        }

        // Check if the map is recursive.
        OuterSequence* seq = outer;
        while (seq != NULL) {
          if (!seq->is_list && seq->map == map) {
            pkByteBufferAddString(buff, vm, "{...}", 5);
            return;
          }
          seq = seq->outer;
        }
        OuterSequence seq_map;
        seq_map.outer = outer; seq_map.is_list = false; seq_map.map = map;

        pkByteBufferWrite(buff, vm, '{');
        uint32_t i = 0;     // Index of the current entry to iterate.
        bool _first = true; // For first element no ',' required.
        do {

          // Get the next valid key index.
          bool _done = false;
          while (IS_UNDEF(map->entries[i].key)) {
            if (++i >= map->capacity) {
              _done = true;
              break;
            }
          }
          if (_done) break;

          if (!_first) pkByteBufferAddString(buff, vm, ", ", 2);

          _toStringInternal(vm, map->entries[i].key, buff, &seq_map, true);
          pkByteBufferWrite(buff, vm, ':');
          _toStringInternal(vm, map->entries[i].value, buff, &seq_map, true);

          i++; _first = false;
        } while (i < map->capacity);

        pkByteBufferWrite(buff, vm, '}');
        return;
      }

      case OBJ_RANGE:
      {
        const Range* range = (const Range*)obj;

        char buff_from[STR_DBL_BUFF_SIZE];
        const int len_from = snprintf(buff_from, sizeof(buff_from),
                                      DOUBLE_FMT, range->from);
        char buff_to[STR_DBL_BUFF_SIZE];
        const int len_to = snprintf(buff_to, sizeof(buff_to),
                                    DOUBLE_FMT, range->to);

        pkByteBufferAddString(buff, vm, "[Range:", 7);
        pkByteBufferAddString(buff, vm, buff_from, len_from);
        pkByteBufferAddString(buff, vm, "..", 2);
        pkByteBufferAddString(buff, vm, buff_to, len_to);
        pkByteBufferWrite(buff, vm, ']');
        return;
      }

      case OBJ_SCRIPT: {
        const Script* scr = (const Script*)obj;
        pkByteBufferAddString(buff, vm, "[Module:", 8);
        if (scr->module != NULL) {
          pkByteBufferAddString(buff, vm, scr->module->data,
                              scr->module->length);
        } else {
          pkByteBufferWrite(buff, vm, '"');
          pkByteBufferAddString(buff, vm, scr->path->data, scr->path->length);
          pkByteBufferWrite(buff, vm, '"');
        }
        pkByteBufferWrite(buff, vm, ']');
        return;
      }

      case OBJ_FUNC: {
        const Function* fn = (const Function*)obj;
        pkByteBufferAddString(buff, vm, "[Func:", 6);
        pkByteBufferAddString(buff, vm, fn->name, (uint32_t)strlen(fn->name));
        pkByteBufferWrite(buff, vm, ']');
        return;
      }

      case OBJ_FIBER: {
        const Fiber* fb = (const Fiber*)obj;
        pkByteBufferAddString(buff, vm, "[Fiber:", 7);
        pkByteBufferAddString(buff, vm, fb->func->name,
                            (uint32_t)strlen(fb->func->name));
        pkByteBufferWrite(buff, vm, ']');
        return;
      }

      case OBJ_CLASS: {
        const Class* ty = (const Class*)obj;
        pkByteBufferAddString(buff, vm, "[Class:", 7);
        String* ty_name = ty->owner->names.data[ty->name];
        pkByteBufferAddString(buff, vm, ty_name->data, ty_name->length);
        pkByteBufferWrite(buff, vm, ']');
        return;
      }

      case OBJ_INST:
      {
        const Instance* inst = (const Instance*)obj;
        pkByteBufferWrite(buff, vm, '[');
        pkByteBufferAddString(buff, vm, inst->name,
                              (uint32_t)strlen(inst->name));
        pkByteBufferWrite(buff, vm, ':');

        if (!inst->is_native) {
          const Class* ty = inst->ins->type;
          const Inst* ins = inst->ins;
          ASSERT(ins->fields.count == ty->field_names.count, OOPS);

          for (uint32_t i = 0; i < ty->field_names.count; i++) {
            if (i != 0) pkByteBufferWrite(buff, vm, ',');

            pkByteBufferWrite(buff, vm, ' ');
            String* f_name = ty->owner->names.data[ty->field_names.data[i]];
            pkByteBufferAddString(buff, vm, f_name->data, f_name->length);
            pkByteBufferWrite(buff, vm, '=');
            _toStringInternal(vm, ins->fields.data[i], buff, outer, repr);
          }
        } else {

          char buff_addr[STR_HEX_BUFF_SIZE];
          char* ptr = (char*)buff_addr;
          (*ptr++) = '0'; (*ptr++) = 'x';
          const int len = snprintf(ptr, sizeof(buff_addr) - 2,
                                "%08x", (unsigned int)(uintptr_t)inst->native);
          pkByteBufferAddString(buff, vm, buff_addr, (uint32_t)len);
        }

        pkByteBufferWrite(buff, vm, ']');
        return;
      }
    }

  }
  UNREACHABLE();
  return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, %ebp
testq %rcx, %rcx
sete %al
orb %bpl, %al
je 0xb26a
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
cmpq %rax, %rsi
jne 0xaadf
leaq 0x118fc(%rip), %rdx     # 0x1c3bd
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4, %ecx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8a34
movq %rcx, %r12
movabsq $0x7ffd000000000000, %r13 # imm = 0x7FFD000000000000
movq %r15, %rcx
andq $-0x2, %rcx
leaq 0x2(%r13), %rdx
cmpq %rdx, %rcx
jne 0xab12
addq $0x3, %r13
cmpq %r13, %r15
jne 0xac3d
leaq 0x118b2(%rip), %rdx     # 0x1c3c2
jmp 0xaac1
movq %r15, %rcx
notq %rcx
testq %rcx, %rax
jne 0xac54
movq %r15, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0xb26f
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rax, %r15
movl (%r15), %eax
cmpq $0x8, %rax
ja 0xb26f
leaq 0x114f4(%rip), %rcx     # 0x1c048
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
testq %r12, %r12
setne %al
orb %bpl, %al
je 0xb111
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84e9
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb $0x22, (%rax,%rcx)
addq $0x1c, %r15
leaq 0x11844(%rip), %r12     # 0x1c3db
leaq 0x11840(%rip), %r13     # 0x1c3de
movb (%r15), %bpl
movzbl %bpl, %eax
cmpl $0xc, %eax
jle 0xabc4
cmpl $0xd, %eax
je 0xabdd
cmpl $0x22, %eax
je 0xabec
cmpl $0x5c, %eax
jne 0xac1b
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
jmp 0xac04
cmpl $0x9, %eax
je 0xabf7
cmpl $0xa, %eax
jne 0xac13
movq %rbx, %rdi
movq %r14, %rsi
leaq 0x11806(%rip), %rdx     # 0x1c3e1
jmp 0xac04
movq %rbx, %rdi
movq %r14, %rsi
leaq 0x117fa(%rip), %rdx     # 0x1c3e4
jmp 0xac04
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
jmp 0xac04
movq %rbx, %rdi
movq %r14, %rsi
leaq 0x117e3(%rip), %rdx     # 0x1c3e7
movl $0x2, %ecx
callq 0x8a34
incq %r15
jmp 0xab9e
testl %eax, %eax
je 0xb127
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84e9
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb %bpl, (%rax,%rcx)
jmp 0xac0e
leaq 0x14d76(%rip), %rdx     # 0x1f9ba
movq %rbx, %rdi
movq %r14, %rsi
movl $0x5, %ecx
jmp 0xaacc
movq %r15, %rdi
callq 0xef2f
ucomisd %xmm0, %xmm0
jp 0xb274
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jne 0xac95
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xacc6
leaq 0x1173b(%rip), %rdx     # 0x1c3cb
jmp 0xaac1
movq %r15, %rdi
callq 0xef2f
leaq 0x11731(%rip), %rsi     # 0x1c3d5
movq %rsp, %r15
movq %r15, %rdi
movb $0x1, %al
callq 0x2360
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %eax, %ecx
callq 0x8a34
jmp 0xb06d
leaq 0x11703(%rip), %rdx     # 0x1c3d0
jmp 0xaac1
leaq 0x1172e(%rip), %rdx     # 0x1c407
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8, %ecx
callq 0x8a34
movq 0x10(%r15), %rdx
testq %rdx, %rdx
jne 0xaf35
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84e9
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb $0x22, %bpl
movb %bpl, (%rax,%rcx)
movq 0x18(%r15), %rdx
movl 0x14(%rdx), %ecx
addq $0x1c, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8a34
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84e9
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb %bpl, (%rax,%rcx)
jmp 0xb04d
cmpq $0x0, 0x18(%r15)
je 0xb232
testq %r12, %r12
je 0xad7f
movq %r12, %rax
cmpb $0x0, 0x8(%rax)
jne 0xad77
cmpq %r15, 0x10(%rax)
je 0xb252
movq (%rax), %rax
testq %rax, %rax
jne 0xad67
movq %rsp, %rax
movq %r12, (%rax)
movb $0x0, 0x8(%rax)
movq %r15, 0x10(%rax)
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84e9
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb $0x7b, (%rax,%rcx)
xorl %ebp, %ebp
movb $0x1, %al
movq 0x18(%r15), %rcx
movl %ebp, %ebp
movq %rbp, %r12
shlq $0x4, %r12
movq (%rcx,%r12), %rsi
cmpq %r13, %rsi
jne 0xadd4
incl %ebp
cmpl 0x10(%r15), %ebp
jb 0xadb5
jmp 0xae56
testb $0x1, %al
jne 0xadf7
movq %rbx, %rdi
movq %r14, %rsi
leaq 0x1160e(%rip), %rdx     # 0x1c3f3
movl $0x2, %ecx
callq 0x8a34
movq 0x18(%r15), %rax
movq (%rax,%r12), %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %rsp, %rcx
movl $0x1, %r8d
callq 0xaa82
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84e9
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb $0x3a, (%rax,%rcx)
movq 0x18(%r15), %rax
movq 0x8(%rax,%r12), %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %rsp, %rcx
movl $0x1, %r8d
callq 0xaa82
incl %ebp
xorl %eax, %eax
cmpl 0x10(%r15), %ebp
jb 0xadb1
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84e9
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb $0x7d, (%rax,%rcx)
jmp 0xb06d
movsd 0x10(%r15), %xmm0
leaq 0x1154d(%rip), %r13     # 0x1c3d5
movq %rsp, %r12
movl $0x18, %esi
movq %r12, %rdi
movq %r13, %rdx
movb $0x1, %al
callq 0x2160
movl %eax, %ebp
movsd 0x18(%r15), %xmm0
leaq 0x20(%rsp), %r15
movl $0x18, %esi
movq %r15, %rdi
movq %r13, %rdx
movb $0x1, %al
callq 0x2160
movl %eax, %r13d
leaq 0x11539(%rip), %rdx     # 0x1c3ff
movq %rbx, %rdi
movq %r14, %rsi
movl $0x7, %ecx
callq 0x8a34
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebp, %ecx
callq 0x8a34
leaq 0x14602(%rip), %rdx     # 0x1f4ef
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %ecx
callq 0x8a34
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %r13d, %ecx
jmp 0xb048
leaq 0x1150a(%rip), %rdx     # 0x1c41f
movq %rbx, %rdi
movq %r14, %rsi
movl $0x7, %ecx
callq 0x8a34
movq 0x10(%r15), %rax
movq 0x60(%rax), %rax
movl 0x18(%r15), %ecx
movq (%rax,%rcx,8), %rdx
movl 0x14(%rdx), %ecx
addq $0x1c, %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0xb048
cmpl $0x0, 0x18(%r15)
je 0xb23b
testq %r12, %r12
je 0xaf72
movq %r12, %rax
cmpb $0x1, 0x8(%rax)
jne 0xaf6a
cmpq %r15, 0x10(%rax)
je 0xb25e
movq (%rax), %rax
testq %rax, %rax
jne 0xaf5a
movq %r12, (%rsp)
movb $0x1, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84e9
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb $0x5b, (%rax,%rcx)
cmpl $0x0, 0x18(%r15)
je 0xb04d
xorl %ebp, %ebp
movq %rsp, %r12
leaq 0x1143c(%rip), %r13     # 0x1c3f3
testq %rbp, %rbp
je 0xafcf
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movl $0x2, %ecx
callq 0x8a34
movq 0x10(%r15), %rax
movq (%rax,%rbp,8), %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %r12, %rcx
movl $0x1, %r8d
callq 0xaa82
incq %rbp
movl 0x18(%r15), %eax
cmpq %rax, %rbp
jb 0xafb7
jmp 0xb04d
leaq 0x11410(%rip), %rdx     # 0x1c410
movq %rbx, %rdi
movq %r14, %rsi
movl $0x6, %ecx
callq 0x8a34
movq 0x10(%r15), %r15
jmp 0xb035
leaq 0x113fa(%rip), %rdx     # 0x1c417
movq %rbx, %rdi
movq %r14, %rsi
movl $0x7, %ecx
callq 0x8a34
movq 0x18(%r15), %rax
movq 0x10(%rax), %r15
movq %r15, %rdi
callq 0x2140
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %eax, %ecx
callq 0x8a34
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84e9
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb $0x5d, (%rax,%rcx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84e9
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb $0x5b, (%rax,%rcx)
movq 0x10(%r15), %r13
movq %r13, %rdi
callq 0x2140
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movl %eax, %ecx
callq 0x8a34
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84e9
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb $0x3a, (%rax,%rcx)
cmpb $0x0, 0x18(%r15)
je 0xb14c
leaq 0x2(%rsp), %rdi
movw $0x7830, -0x2(%rdi)     # imm = 0x7830
movl 0x20(%r15), %ecx
leaq 0x11332(%rip), %rdx     # 0x1c427
movl $0x12, %esi
xorl %eax, %eax
callq 0x2160
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %ecx
jmp 0xb048
movl 0x14(%r15), %ecx
addq $0x1c, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
jmp 0xaacc
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84e9
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb $0x22, (%rax,%rcx)
jmp 0xb06d
movq 0x20(%r15), %rax
movq (%rax), %r13
movq %rax, 0x18(%rsp)
movl 0x10(%rax), %eax
cmpl 0x30(%r13), %eax
jne 0xb28b
testl %eax, %eax
je 0xb04d
xorl %r15d, %r15d
movzbl %bpl, %ebp
testq %r15, %r15
je 0xb199
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84e9
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb $0x2c, (%rax,%rcx)
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84e9
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb $0x20, (%rax,%rcx)
movq 0x10(%r13), %rax
movq 0x28(%r13), %rcx
movq 0x60(%rax), %rax
movl (%rcx,%r15,4), %ecx
movq (%rax,%rcx,8), %rdx
movl 0x14(%rdx), %ecx
addq $0x1c, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8a34
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84e9
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb $0x3d, (%rax,%rcx)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %r12, %rcx
movl %ebp, %r8d
callq 0xaa82
incq %r15
movl 0x30(%r13), %eax
cmpq %rax, %r15
jb 0xb174
jmp 0xb04d
leaq 0x111bd(%rip), %rdx     # 0x1c3f6
jmp 0xb242
leaq 0x111a8(%rip), %rdx     # 0x1c3ea
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %ecx
jmp 0xaacc
leaq 0x111a0(%rip), %rdx     # 0x1c3f9
jmp 0xac44
leaq 0x11188(%rip), %rdx     # 0x1c3ed
jmp 0xac44
callq 0x2938
callq 0x29a4
leaq 0x1114c(%rip), %rdx     # 0x1c3c7
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3, %ecx
jmp 0xaacc
callq 0x296e