// File: /workspace/github_c_makefile_star2_O1/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 $0x48, %rsp
movl %r8d, %ebp
testq %rcx, %rcx
sete %al
orb %bpl, %al
je 0xb417
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
cmpq %rax, %rsi
jne 0xac5b
leaq 0x12780(%rip), %rdx     # 0x1d3bd
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4, %ecx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8af2
movq %rcx, %r12
movabsq $0x7ffd000000000000, %r13 # imm = 0x7FFD000000000000
movq %r15, %rcx
andq $-0x2, %rcx
leaq 0x2(%r13), %rdx
cmpq %rdx, %rcx
jne 0xac8e
addq $0x3, %r13
cmpq %r13, %r15
jne 0xadb9
leaq 0x12736(%rip), %rdx     # 0x1d3c2
jmp 0xac3d
movq %r15, %rcx
notq %rcx
testq %rcx, %rax
jne 0xadd0
movq %r15, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0xb41c
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rax, %r15
movl (%r15), %eax
cmpq $0x8, %rax
ja 0xb41c
leaq 0x12378(%rip), %rcx     # 0x1d048
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
testq %r12, %r12
setne %al
orb %bpl, %al
je 0xb2bb
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x85ab
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb $0x22, (%rax,%rcx)
addq $0x1c, %r15
leaq 0x126c8(%rip), %r12     # 0x1d3db
leaq 0x126c4(%rip), %r13     # 0x1d3de
movb (%r15), %bpl
movzbl %bpl, %eax
cmpl $0xc, %eax
jle 0xad40
cmpl $0xd, %eax
je 0xad59
cmpl $0x22, %eax
je 0xad68
cmpl $0x5c, %eax
jne 0xad97
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
jmp 0xad80
cmpl $0x9, %eax
je 0xad73
cmpl $0xa, %eax
jne 0xad8f
movq %rbx, %rdi
movq %r14, %rsi
leaq 0x1268a(%rip), %rdx     # 0x1d3e1
jmp 0xad80
movq %rbx, %rdi
movq %r14, %rsi
leaq 0x1267e(%rip), %rdx     # 0x1d3e4
jmp 0xad80
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
jmp 0xad80
movq %rbx, %rdi
movq %r14, %rsi
leaq 0x12667(%rip), %rdx     # 0x1d3e7
movl $0x2, %ecx
callq 0x8af2
incq %r15
jmp 0xad1a
testl %eax, %eax
je 0xb2d1
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x85ab
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb %bpl, (%rax,%rcx)
jmp 0xad8a
leaq 0x15bc6(%rip), %rdx     # 0x20986
movq %rbx, %rdi
movq %r14, %rsi
movl $0x5, %ecx
jmp 0xac48
movq %r15, %rdi
callq 0xf397
ucomisd %xmm0, %xmm0
jp 0xb421
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jne 0xae11
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xae44
leaq 0x125bf(%rip), %rdx     # 0x1d3cb
jmp 0xac3d
movq %r15, %rdi
callq 0xf397
leaq 0x125b5(%rip), %rsi     # 0x1d3d5
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movb $0x1, %al
callq 0x2360
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %eax, %ecx
callq 0x8af2
jmp 0xb215
leaq 0x12585(%rip), %rdx     # 0x1d3d0
jmp 0xac3d
leaq 0x125b0(%rip), %rdx     # 0x1d407
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8, %ecx
callq 0x8af2
movq 0x10(%r15), %rdx
testq %rdx, %rdx
jne 0xb0da
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x85ab
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 0x8af2
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x85ab
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb %bpl, (%rax,%rcx)
jmp 0xb1f5
cmpq $0x0, 0x18(%r15)
je 0xb3df
testq %r12, %r12
je 0xaefd
movq %r12, %rax
cmpb $0x0, 0x8(%rax)
jne 0xaef5
cmpq %r15, 0x10(%rax)
je 0xb3ff
movq (%rax), %rax
testq %rax, %rax
jne 0xaee5
leaq 0x10(%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 0x85ab
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb $0x7b, (%rax,%rcx)
xorl %r12d, %r12d
movb $0x1, %al
movq %r14, 0x8(%rsp)
movq 0x18(%r15), %rcx
movl %r12d, %edx
shlq $0x4, %rdx
movq (%rcx,%rdx), %rbp
cmpq %r13, %rbp
jne 0xaf54
incl %r12d
cmpl 0x10(%r15), %r12d
jb 0xaf3b
cmpq %r13, %rbp
je 0xafea
testb $0x1, %al
jne 0xaf78
movq %rbx, %rdi
movq %r14, %rsi
leaq 0x12485(%rip), %rdx     # 0x1d3f3
movl $0x2, %ecx
callq 0x8af2
movq 0x18(%r15), %rax
movl %r12d, %r14d
shlq $0x4, %r14
movq (%rax,%r14), %rsi
movq 0x8(%rsp), %rdi
movq %rbx, %rdx
leaq 0x10(%rsp), %rcx
movl $0x1, %r8d
callq 0xabfe
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x85ab
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,%r14), %rsi
movq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
leaq 0x10(%rsp), %rcx
movl $0x1, %r8d
callq 0xabfe
incl %r12d
xorl %eax, %eax
cmpq %r13, %rbp
je 0xaff9
cmpl 0x10(%r15), %r12d
jb 0xaf37
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x85ab
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb $0x7d, (%rax,%rcx)
jmp 0xb215
movsd 0x10(%r15), %xmm0
leaq 0x123aa(%rip), %r13     # 0x1d3d5
leaq 0x10(%rsp), %r12
movl $0x18, %esi
movq %r12, %rdi
movq %r13, %rdx
movb $0x1, %al
callq 0x2160
movl %eax, %ebp
movsd 0x18(%r15), %xmm0
leaq 0x30(%rsp), %r15
movl $0x18, %esi
movq %r15, %rdi
movq %r13, %rdx
movb $0x1, %al
callq 0x2160
movl %eax, %r13d
leaq 0x12394(%rip), %rdx     # 0x1d3ff
movq %rbx, %rdi
movq %r14, %rsi
movl $0x7, %ecx
callq 0x8af2
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebp, %ecx
callq 0x8af2
leaq 0x1541d(%rip), %rdx     # 0x204af
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %ecx
callq 0x8af2
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %r13d, %ecx
jmp 0xb1f0
leaq 0x12365(%rip), %rdx     # 0x1d41f
movq %rbx, %rdi
movq %r14, %rsi
movl $0x7, %ecx
callq 0x8af2
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 0xb1f0
cmpl $0x0, 0x18(%r15)
je 0xb3e8
testq %r12, %r12
je 0xb117
movq %r12, %rax
cmpb $0x1, 0x8(%rax)
jne 0xb10f
cmpq %r15, 0x10(%rax)
je 0xb40b
movq (%rax), %rax
testq %rax, %rax
jne 0xb0ff
movq %r12, 0x10(%rsp)
movb $0x1, 0x18(%rsp)
movq %r15, 0x20(%rsp)
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x85ab
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb $0x5b, (%rax,%rcx)
cmpl $0x0, 0x18(%r15)
je 0xb1f5
xorl %ebp, %ebp
leaq 0x10(%rsp), %r12
leaq 0x12294(%rip), %r13     # 0x1d3f3
testq %rbp, %rbp
je 0xb177
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movl $0x2, %ecx
callq 0x8af2
movq 0x10(%r15), %rax
movq (%rax,%rbp,8), %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %r12, %rcx
movl $0x1, %r8d
callq 0xabfe
incq %rbp
movl 0x18(%r15), %eax
cmpq %rax, %rbp
jb 0xb15f
jmp 0xb1f5
leaq 0x12268(%rip), %rdx     # 0x1d410
movq %rbx, %rdi
movq %r14, %rsi
movl $0x6, %ecx
callq 0x8af2
movq 0x10(%r15), %r15
jmp 0xb1dd
leaq 0x12252(%rip), %rdx     # 0x1d417
movq %rbx, %rdi
movq %r14, %rsi
movl $0x7, %ecx
callq 0x8af2
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 0x8af2
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x85ab
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb $0x5d, (%rax,%rcx)
addq $0x48, %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 0x85ab
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 0x8af2
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x85ab
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb $0x3a, (%rax,%rcx)
cmpb $0x0, 0x18(%r15)
je 0xb2f6
leaq 0x12(%rsp), %rdi
movw $0x7830, -0x2(%rdi)     # imm = 0x7830
movl 0x20(%r15), %ecx
leaq 0x1218a(%rip), %rdx     # 0x1d427
movl $0x12, %esi
xorl %eax, %eax
callq 0x2160
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %ecx
jmp 0xb1f0
movl 0x14(%r15), %ecx
addq $0x1c, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
jmp 0xac48
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x85ab
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb $0x22, (%rax,%rcx)
jmp 0xb215
movq 0x20(%r15), %rax
movq (%rax), %r13
movq %rax, 0x28(%rsp)
movl 0x10(%rax), %eax
cmpl 0x30(%r13), %eax
jne 0xb438
cmpl $0x0, 0x30(%r13)
je 0xb1f5
xorl %r15d, %r15d
movzbl %bpl, %ebp
testq %r15, %r15
je 0xb346
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x85ab
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 0x85ab
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 0x8af2
movl 0x8(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x85ab
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb $0x3d, (%rax,%rcx)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %r12, %rcx
movl %ebp, %r8d
callq 0xabfe
incq %r15
movl 0x30(%r13), %eax
cmpq %rax, %r15
jb 0xb321
jmp 0xb1f5
leaq 0x12010(%rip), %rdx     # 0x1d3f6
jmp 0xb3ef
leaq 0x11ffb(%rip), %rdx     # 0x1d3ea
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %ecx
jmp 0xac48
leaq 0x11ff3(%rip), %rdx     # 0x1d3f9
jmp 0xadc0
leaq 0x11fdb(%rip), %rdx     # 0x1d3ed
jmp 0xadc0
callq 0x2938
callq 0x29a4
leaq 0x11f9f(%rip), %rdx     # 0x1d3c7
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3, %ecx
jmp 0xac48
callq 0x296e