// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x1e8, %rsp            # imm = 0x1E8
movb %r8b, %al
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq %rdx, 0x1d0(%rsp)
movq %rcx, 0x1c8(%rsp)
andb $0x1, %al
movb %al, 0x1c7(%rsp)
cmpq $0x0, 0x1c8(%rsp)
je 0x7ac2
testb $0x1, 0x1c7(%rsp)
jne 0x7ac2
movq 0x2b569(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x226b7(%rip), %rsi     # 0x2a150
leaq 0x227c4(%rip), %rdx     # 0x2a264
leaq 0x22974(%rip), %rcx     # 0x2a41b
leaq 0x226ee(%rip), %r8      # 0x2a19c
movl $0x581, %r9d            # imm = 0x581
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x7ac4
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
cmpq %rax, 0x1d8(%rsp)
jne 0x7afe
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x2293e(%rip), %rdx     # 0x2a42d
movl $0x4, %ecx
callq 0x3c70
jmp 0x8adc
movabsq $0x7ffd000000000003, %rax # imm = 0x7FFD000000000003
cmpq %rax, 0x1d8(%rsp)
je 0x7b26
movabsq $0x7ffd000000000002, %rax # imm = 0x7FFD000000000002
cmpq %rax, 0x1d8(%rsp)
jne 0x7b83
movabsq $0x7ffd000000000003, %rax # imm = 0x7FFD000000000003
cmpq %rax, 0x1d8(%rsp)
jne 0x7b5d
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x228e1(%rip), %rdx     # 0x2a432
movl $0x4, %ecx
callq 0x3c70
jmp 0x7b7e
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x25f96(%rip), %rdx     # 0x2db0a
movl $0x5, %ecx
callq 0x3c70
jmp 0x8adc
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
andq 0x1d8(%rsp), %rax
movabsq $0x7ffc000000000000, %rcx # imm = 0x7FFC000000000000
cmpq %rcx, %rax
je 0x7cfe
movq 0x1d8(%rsp), %rdi
callq 0x45d0
movsd %xmm0, 0x1b8(%rsp)
movsd 0x1b8(%rsp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x7bd4
jmp 0x7bfa
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x2284c(%rip), %rdx     # 0x2a437
movl $0x3, %ecx
callq 0x3c70
jmp 0x7cf9
movsd 0x1b8(%rsp), %xmm1
movaps %xmm1, %xmm0
movaps 0x22533(%rip), %xmm2    # 0x2a140
pand %xmm2, %xmm0
movq %xmm1, %rdx
movl $0x1, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovll %eax, %ecx
movsd 0x22509(%rip), %xmm1    # 0x2a138
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setnp %sil
sete %dl
testb %sil, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
je 0x7c9f
movsd 0x1b8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x7c7c
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x227cb(%rip), %rdx     # 0x2a43b
movl $0x4, %ecx
callq 0x3c70
jmp 0x7c9d
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x227ad(%rip), %rdx     # 0x2a440
movl $0x4, %ecx
callq 0x3c70
jmp 0x7cf7
leaq 0x1a0(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x1d8(%rsp), %rdi
callq 0x45d0
movq 0x58(%rsp), %rdi
leaq 0x22780(%rip), %rsi     # 0x2a445
movb $0x1, %al
callq 0x2350
movl %eax, 0x19c(%rsp)
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x1a0(%rsp), %rdx
movl 0x19c(%rsp), %ecx
callq 0x3c70
jmp 0x7cf9
jmp 0x8adc
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x1d8(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x8aa1
movq 0x1d8(%rsp), %rax
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rax
movq %rax, 0x190(%rsp)
movq 0x190(%rsp), %rax
movl (%rax), %eax
movq %rax, 0x50(%rsp)
subq $0x8, %rax
ja 0x8a9f
movq 0x50(%rsp), %rax
leaq 0x22383(%rip), %rcx     # 0x2a0e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x190(%rsp), %rax
movq %rax, 0x188(%rsp)
cmpq $0x0, 0x1c8(%rsp)
jne 0x7dc4
testb $0x1, 0x1c7(%rsp)
jne 0x7dc4
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movq 0x188(%rsp), %rdx
addq $0x1c, %rdx
movq 0x188(%rsp), %rax
movl 0x14(%rax), %ecx
callq 0x3c70
jmp 0x8adc
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movl $0x22, %edx
callq 0x3270
movq 0x188(%rsp), %rax
addq $0x1c, %rax
movq %rax, 0x180(%rsp)
movq 0x180(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x7f43
movq 0x180(%rsp), %rax
movsbl (%rax), %eax
movl %eax, 0x4c(%rsp)
subl $0x9, %eax
je 0x7ee5
jmp 0x7e20
movl 0x4c(%rsp), %eax
subl $0xa, %eax
je 0x7e9f
jmp 0x7e2b
movl 0x4c(%rsp), %eax
subl $0xd, %eax
je 0x7ec2
jmp 0x7e3a
movl 0x4c(%rsp), %eax
subl $0x22, %eax
je 0x7e53
jmp 0x7e45
movl 0x4c(%rsp), %eax
subl $0x5c, %eax
je 0x7e79
jmp 0x7f08
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x225e1(%rip), %rdx     # 0x2a44b
movl $0x2, %ecx
callq 0x3c70
jmp 0x7f28
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x225be(%rip), %rdx     # 0x2a44e
movl $0x2, %ecx
callq 0x3c70
jmp 0x7f28
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x2259b(%rip), %rdx     # 0x2a451
movl $0x2, %ecx
callq 0x3c70
jmp 0x7f28
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x2257b(%rip), %rdx     # 0x2a454
movl $0x2, %ecx
callq 0x3c70
jmp 0x7f28
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x2255b(%rip), %rdx     # 0x2a457
movl $0x2, %ecx
callq 0x3c70
jmp 0x7f28
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movq 0x180(%rsp), %rax
movzbl (%rax), %edx
callq 0x3270
jmp 0x7f2a
movq 0x180(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x180(%rsp)
jmp 0x7df2
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movl $0x22, %edx
callq 0x3270
jmp 0x8adc
movq 0x190(%rsp), %rax
movq %rax, 0x178(%rsp)
movq 0x178(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x7fa6
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x224c3(%rip), %rdx     # 0x2a45a
movl $0x2, %ecx
callq 0x3c70
jmp 0x8adc
movq 0x1c8(%rsp), %rax
movq %rax, 0x170(%rsp)
cmpq $0x0, 0x170(%rsp)
je 0x8020
movq 0x170(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0x800b
movq 0x170(%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x178(%rsp), %rax
jne 0x800b
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x22461(%rip), %rdx     # 0x2a45d
movl $0x5, %ecx
callq 0x3c70
jmp 0x8adc
movq 0x170(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x170(%rsp)
jmp 0x7fb6
movq 0x1c8(%rsp), %rax
movq %rax, 0x158(%rsp)
movb $0x1, 0x160(%rsp)
movq 0x178(%rsp), %rax
movq %rax, 0x168(%rsp)
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movl $0x5b, %edx
callq 0x3270
movl $0x0, 0x154(%rsp)
movl 0x154(%rsp), %eax
movq 0x178(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x80fc
cmpl $0x0, 0x154(%rsp)
je 0x80ac
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x223c1(%rip), %rdx     # 0x2a463
movl $0x2, %ecx
callq 0x3c70
movq 0x1e0(%rsp), %rdi
movq 0x178(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x154(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
movq 0x1d0(%rsp), %rdx
leaq 0x158(%rsp), %rcx
movl $0x1, %r8d
callq 0x7a40
movl 0x154(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x154(%rsp)
jmp 0x806d
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movl $0x5d, %edx
callq 0x3270
jmp 0x8adc
movq 0x190(%rsp), %rax
movq %rax, 0x148(%rsp)
movq 0x148(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x8160
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x22315(%rip), %rdx     # 0x2a466
movl $0x2, %ecx
callq 0x3c70
jmp 0x8adc
movq 0x1c8(%rsp), %rax
movq %rax, 0x140(%rsp)
cmpq $0x0, 0x140(%rsp)
je 0x81da
movq 0x140(%rsp), %rax
testb $0x1, 0x8(%rax)
jne 0x81c5
movq 0x140(%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x148(%rsp), %rax
jne 0x81c5
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x222b3(%rip), %rdx     # 0x2a469
movl $0x5, %ecx
callq 0x3c70
jmp 0x8adc
movq 0x140(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x140(%rsp)
jmp 0x8170
movq 0x1c8(%rsp), %rax
movq %rax, 0x128(%rsp)
movb $0x0, 0x130(%rsp)
movq 0x148(%rsp), %rax
movq %rax, 0x138(%rsp)
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movl $0x7b, %edx
callq 0x3270
movl $0x0, 0x124(%rsp)
movb $0x1, 0x123(%rsp)
movb $0x0, 0x122(%rsp)
movq 0x148(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x124(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movabsq $0x7ffd000000000000, %rcx # imm = 0x7FFD000000000000
cmpq %rcx, (%rax)
jne 0x828a
movl 0x124(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x124(%rsp)
movq 0x148(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jb 0x8288
movb $0x1, 0x122(%rsp)
jmp 0x828a
jmp 0x8237
testb $0x1, 0x122(%rsp)
je 0x8299
jmp 0x8390
testb $0x1, 0x123(%rsp)
jne 0x82c4
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x221a9(%rip), %rdx     # 0x2a463
movl $0x2, %ecx
callq 0x3c70
movq 0x1e0(%rsp), %rdi
movq 0x148(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x124(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq 0x1d0(%rsp), %rdx
leaq 0x128(%rsp), %rcx
movl $0x1, %r8d
callq 0x7a40
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movl $0x3a, %edx
callq 0x3270
movq 0x1e0(%rsp), %rdi
movq 0x148(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x124(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
movq 0x1d0(%rsp), %rdx
leaq 0x128(%rsp), %rcx
movl $0x1, %r8d
callq 0x7a40
movl 0x124(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x124(%rsp)
movb $0x0, 0x123(%rsp)
movl 0x124(%rsp), %eax
movq 0x148(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jb 0x822f
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movl $0x7d, %edx
callq 0x3270
jmp 0x8adc
movq 0x190(%rsp), %rax
movq %rax, 0x118(%rsp)
leaq 0x100(%rsp), %rdi
movq 0x118(%rsp), %rax
movsd 0x10(%rax), %xmm0
movl $0x18, %esi
leaq 0x22065(%rip), %rdx     # 0x2a445
movb $0x1, %al
callq 0x2150
movl %eax, 0xfc(%rsp)
leaq 0xe0(%rsp), %rdi
movq 0x118(%rsp), %rax
movsd 0x18(%rax), %xmm0
movl $0x18, %esi
leaq 0x22036(%rip), %rdx     # 0x2a445
movb $0x1, %al
callq 0x2150
movl %eax, 0xdc(%rsp)
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x2203b(%rip), %rdx     # 0x2a46f
movl $0x7, %ecx
callq 0x3c70
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x100(%rsp), %rdx
movl 0xfc(%rsp), %ecx
callq 0x3c70
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x251c6(%rip), %rdx     # 0x2d63f
movl $0x2, %ecx
callq 0x3c70
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0xe0(%rsp), %rdx
movl 0xdc(%rsp), %ecx
callq 0x3c70
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movl $0x5d, %edx
callq 0x3270
jmp 0x8adc
movq 0x190(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x21f8a(%rip), %rdx     # 0x2a477
movl $0x8, %ecx
callq 0x3c70
movq 0xd0(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x853c
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movq 0xd0(%rsp), %rax
movq 0x10(%rax), %rdx
addq $0x1c, %rdx
movq 0xd0(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x14(%rax), %ecx
callq 0x3c70
jmp 0x85a4
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movl $0x22, %edx
callq 0x3270
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movq 0xd0(%rsp), %rax
movq 0x18(%rax), %rdx
addq $0x1c, %rdx
movq 0xd0(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x14(%rax), %ecx
callq 0x3c70
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movl $0x22, %edx
callq 0x3270
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movl $0x5d, %edx
callq 0x3270
jmp 0x8adc
movq 0x190(%rsp), %rax
movq %rax, 0xc8(%rsp)
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x21e96(%rip), %rdx     # 0x2a480
movl $0x6, %ecx
callq 0x3c70
movq 0x1d0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0xc8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0xc8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x2130
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
movl %eax, %ecx
callq 0x3c70
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movl $0x5d, %edx
callq 0x3270
jmp 0x8adc
movq 0x190(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x21dfb(%rip), %rdx     # 0x2a487
movl $0x7, %ecx
callq 0x3c70
movq 0x1d0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xc0(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0xc0(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x2130
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl %eax, %ecx
callq 0x3c70
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movl $0x5d, %edx
callq 0x3270
jmp 0x8adc
movq 0x190(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x21d59(%rip), %rdx     # 0x2a48f
movl $0x7, %ecx
callq 0x3c70
movq 0xb8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x60(%rax), %rax
movq 0xb8(%rsp), %rcx
movl 0x18(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0xb0(%rsp)
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movq 0xb0(%rsp), %rdx
addq $0x1c, %rdx
movq 0xb0(%rsp), %rax
movl 0x14(%rax), %ecx
callq 0x3c70
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movl $0x5d, %edx
callq 0x3270
jmp 0x8adc
movq 0x190(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movl $0x5b, %edx
callq 0x3270
movq 0x1d0(%rsp), %rax
movq %rax, (%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xa8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0xa8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x2130
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl %eax, %ecx
callq 0x3c70
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movl $0x3a, %edx
callq 0x3270
movq 0xa8(%rsp), %rax
testb $0x1, 0x18(%rax)
jne 0x8a09
movq 0xa8(%rsp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, 0xa0(%rsp)
movq 0xa8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rax
movl 0x10(%rax), %eax
movq 0xa0(%rsp), %rcx
cmpl 0x30(%rcx), %eax
je 0x88d5
movq 0x2a756(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x218a4(%rip), %rsi     # 0x2a150
leaq 0x219b1(%rip), %rdx     # 0x2a264
leaq 0x21b61(%rip), %rcx     # 0x2a41b
leaq 0x218db(%rip), %r8      # 0x2a19c
movl $0x656, %r9d            # imm = 0x656
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x88d7
movl $0x0, 0x94(%rsp)
movl 0x94(%rsp), %eax
movq 0xa0(%rsp), %rcx
cmpl 0x30(%rcx), %eax
jae 0x8a07
cmpl $0x0, 0x94(%rsp)
je 0x891e
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movl $0x2c, %edx
callq 0x3270
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movl $0x20, %edx
callq 0x3270
movq 0xa0(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x60(%rax), %rax
movq 0xa0(%rsp), %rcx
movq 0x28(%rcx), %rcx
movl 0x94(%rsp), %edx
movl (%rcx,%rdx,4), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x88(%rsp)
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movq 0x88(%rsp), %rdx
addq $0x1c, %rdx
movq 0x88(%rsp), %rax
movl 0x14(%rax), %ecx
callq 0x3c70
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movl $0x3d, %edx
callq 0x3270
movq 0x1e0(%rsp), %rdi
movq 0x98(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x94(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
movq 0x1d0(%rsp), %rdx
movq 0x1c8(%rsp), %rcx
movb 0x1c7(%rsp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x7a40
movl 0x94(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x94(%rsp)
jmp 0x88e2
jmp 0x8a83
leaq 0x70(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rsp)
movb $0x30, (%rax)
movq 0x68(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rsp)
movb $0x78, (%rax)
movq 0x68(%rsp), %rdi
movq 0xa8(%rsp), %rax
movq 0x20(%rax), %rax
movl %eax, %ecx
movl $0x12, %esi
leaq 0x21a3d(%rip), %rdx     # 0x2a497
movb $0x0, %al
callq 0x2150
movl %eax, 0x64(%rsp)
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
leaq 0x70(%rsp), %rdx
movl 0x64(%rsp), %ecx
callq 0x3c70
movq 0x1d0(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movl $0x5d, %edx
callq 0x3270
jmp 0x8adc
jmp 0x8aa1
jmp 0x8aa3
jmp 0x8aa5
jmp 0x8aa7
jmp 0x8aa9
movq 0x2a548(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x21720(%rip), %rsi     # 0x2a1da
leaq 0x2195a(%rip), %rdx     # 0x2a41b
leaq 0x216d4(%rip), %rcx     # 0x2a19c
movl $0x671, %r8d            # imm = 0x671
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
addq $0x1e8, %rsp            # imm = 0x1E8
retq
nopw %cs:(%rax,%rax)