LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: newRange
Range* newRange(PKVM* vm, double from, double to) {
  Range* range = ALLOCATE(vm, Range);
  varInitObject(&range->_super, vm, OBJ_RANGE);
  range->from = from;
  range->to = to;
  return range;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x20, %ecx
movq %rdx, %rsi
callq 0x8f90
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x3, %edx
callq 0x3d00
movsd 0x18(%rsp), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movsd 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: scriptAddMain
void scriptAddMain(PKVM* vm, Script* script) {
  ASSERT(script->body == NULL, OOPS);

  const char* fn_name = PK_IMPLICIT_MAIN_NAME;
  script->body = newFunction(vm, fn_name, (int)strlen(fn_name),
                             script, false, NULL/*TODO*/);
  script->body->arity = 0;
  script->initialized = false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x80(%rax)
je 0x48e7
movq 0x2e744(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x25892(%rip), %rsi     # 0x2a150
leaq 0x2599f(%rip), %rdx     # 0x2a264
leaq 0x25a0d(%rip), %rcx     # 0x2a2d9
leaq 0x258c9(%rip), %r8      # 0x2a19c
movl $0x484, %r9d            # imm = 0x484
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x48e9
leaq 0x259f7(%rip), %rax     # 0x2a2e7
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2130
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movl %eax, %edx
movq 0x18(%rsp), %rcx
xorl %r8d, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x4a80
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x80(%rax)
movq 0x18(%rsp), %rax
movq 0x80(%rax), %rax
movl $0x0, 0x20(%rax)
movq 0x18(%rsp), %rax
movb $0x0, 0x88(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: scriptAddGlobal
uint32_t scriptAddGlobal(PKVM* vm, Script* script,
                    const char* name, uint32_t length,
                    Var value) {

  // If already exists update the value.
  int var_ind = scriptGetGlobals(script, name, length);
  if (var_ind != -1) {
    ASSERT(var_ind < (int)script->globals.count, OOPS);
    script->globals.data[var_ind] = value;
    return var_ind;
  }

  // If we're reached here that means we don't already have a variable with
  // that name, create new one and set the value.
  uint32_t name_ind = scriptAddName(script, vm, name, length);
  pkUintBufferWrite(&script->global_names, vm, name_ind);
  pkVarBufferWrite(&script->globals, vm, value);
  return script->globals.count - 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq %r8, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
callq 0x6a40
movl %eax, 0x4(%rsp)
cmpl $-0x1, 0x4(%rsp)
je 0x4a17
jmp 0x49ac
movl 0x4(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x28(%rcx), %eax
jl 0x49f4
movq 0x2e637(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x25785(%rip), %rsi     # 0x2a150
leaq 0x25892(%rip), %rdx     # 0x2a264
leaq 0x258f0(%rip), %rcx     # 0x2a2c9
leaq 0x257bc(%rip), %r8      # 0x2a19c
movl $0x476, %r9d            # imm = 0x476
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x49f6
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x4(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x4(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x4a6f
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl 0x14(%rsp), %ecx
callq 0x4c60
movl %eax, (%rsp)
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
movq 0x28(%rsp), %rsi
movl (%rsp), %edx
callq 0x3020
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
movq 0x28(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x34d0
movq 0x20(%rsp), %rax
movl 0x28(%rax), %eax
subl $0x1, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: scriptAddName
uint32_t scriptAddName(Script* self, PKVM* vm, const char* name,
  uint32_t length) {

  for (uint32_t i = 0; i < self->names.count; i++) {
    String* _name = self->names.data[i];
    if (_name->length == length && strncmp(_name->data, name, length) == 0) {
      // Name already exists in the buffer.
      return i;
    }
  }

  // If we reach here the name doesn't exists in the buffer, so add it and
  // return the index.
  String* new_name = newStringLength(vm, name, length);
  vmPushTempRef(vm, &new_name->_super);
  pkStringBufferWrite(&self->names, vm, new_name);
  vmPopTempRef(vm);
  return self->names.count - 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x68(%rcx), %eax
jae 0x4ce8
movq 0x28(%rsp), %rax
movq 0x60(%rax), %rax
movl 0x10(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x14(%rax), %eax
cmpl 0x14(%rsp), %eax
jne 0x4cd9
movq 0x8(%rsp), %rdi
addq $0x1c, %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %eax
movl %eax, %edx
callq 0x2080
cmpl $0x0, %eax
jne 0x4cd9
movl 0x10(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x4d3d
jmp 0x4cdb
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x4c7f
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
callq 0x2760
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0x9420
movq 0x28(%rsp), %rdi
addq $0x60, %rdi
movq 0x20(%rsp), %rsi
movq (%rsp), %rdx
callq 0x3720
movq 0x20(%rsp), %rdi
callq 0x95c0
movq 0x28(%rsp), %rax
movl 0x68(%rax), %eax
subl $0x1, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: newClass
Class* newClass(PKVM* vm, Script* scr, const char* name, uint32_t length) {
  Class* type = ALLOCATE(vm, Class);
  varInitObject(&type->_super, vm, OBJ_CLASS);

  vmPushTempRef(vm, &type->_super); // type.

  pkClassBufferWrite(&scr->classes, vm, type);
  type->owner = scr;
  type->name = scriptAddName(scr, vm, name, length);
  pkUintBufferInit(&type->field_names);

  // Can't use '$' in string format. (TODO)
  String* ty_name = scr->names.data[type->name];
  String* dollar = newStringLength(vm, "$", 1);
  vmPushTempRef(vm, &dollar->_super); // dollar
  String* ctor_name = stringFormat(vm, "@(Ctor:@)", dollar, ty_name);
  vmPopTempRef(vm); // dollar

  // Constructor.
  vmPushTempRef(vm, &ctor_name->_super); // ctor_name
  type->ctor = newFunction(vm, ctor_name->data, ctor_name->length,
                           scr, false, NULL);
  vmPopTempRef(vm); // ctor_name

  vmPopTempRef(vm); // type.
  return type;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq 0x40(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x38, %ecx
movq %rdx, %rsi
callq 0x8f90
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl $0x7, %edx
callq 0x3d00
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x9420
movq 0x38(%rsp), %rdi
addq $0x50, %rdi
movq 0x40(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x3bc0
movq 0x38(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl 0x2c(%rsp), %ecx
callq 0x4c60
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
callq 0x2e80
movq 0x38(%rsp), %rax
movq 0x60(%rax), %rax
movq 0x20(%rsp), %rcx
movl 0x18(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x270e3(%rip), %rsi     # 0x2bf04
movl $0x1, %edx
callq 0x2760
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x9420
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0x2544a(%rip), %rsi     # 0x2a29f
movb $0x0, %al
callq 0x4ed0
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x95c0
movq 0x40(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x9420
movq 0x40(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x1c, %rsi
movq 0x8(%rsp), %rax
movl 0x14(%rax), %edx
movq 0x38(%rsp), %rcx
xorl %r8d, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x4a80
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x40(%rsp), %rdi
callq 0x95c0
movq 0x40(%rsp), %rdi
callq 0x95c0
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: newInstance
Instance* newInstance(PKVM* vm, Class* ty, bool initialize) {

  Instance* inst = ALLOCATE(vm, Instance);
  varInitObject(&inst->_super, vm, OBJ_INST);

  vmPushTempRef(vm, &inst->_super); // inst.

  ASSERT(ty->name < ty->owner->names.count, OOPS);
  inst->name = ty->owner->names.data[ty->name]->data;
  inst->is_native = false;

  Inst* ins = ALLOCATE(vm, Inst);
  inst->ins = ins;
  ins->type = ty;
  pkVarBufferInit(&ins->fields);

  if (initialize && ty->field_names.count != 0) {
    pkVarBufferFill(&ins->fields, vm, VAR_NULL, ty->field_names.count);
  }

  vmPopTempRef(vm); // inst.

  return inst;
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x28, %ecx
movq %rdx, %rsi
callq 0x8f90
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x8, %edx
callq 0x3d00
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x9420
movq 0x18(%rsp), %rax
movl 0x18(%rax), %eax
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
cmpl 0x68(%rcx), %eax
jb 0x53f4
movq 0x2dc37(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x24d85(%rip), %rsi     # 0x2a150
leaq 0x24e92(%rip), %rdx     # 0x2a264
leaq 0x24ed0(%rip), %rcx     # 0x2a2a9
leaq 0x24dbc(%rip), %r8      # 0x2a19c
movl $0x215, %r9d            # imm = 0x215
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x53f6
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x60(%rax), %rax
movq 0x18(%rsp), %rcx
movl 0x18(%rcx), %ecx
movq (%rax,%rcx,8), %rcx
addq $0x1c, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x18(%rax)
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x18, %ecx
movq %rdx, %rsi
callq 0x8f90
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0x3330
testb $0x1, 0x17(%rsp)
je 0x549b
movq 0x18(%rsp), %rax
cmpl $0x0, 0x30(%rax)
je 0x549b
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rax
movl 0x30(%rax), %ecx
movabsq $0x7ffc000000000000, %rdx # imm = 0x7FFC000000000000
callq 0x3450
movq 0x20(%rsp), %rdi
callq 0x95c0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: rangeAsList
List* rangeAsList(PKVM* vm, Range* self) {
  List* list;
  if (self->from < self->to) {
    list = newList(vm, (uint32_t)(self->to - self->from));
    for (double i = self->from; i < self->to; i++) {
      pkVarBufferWrite(&list->elements, vm, VAR_NUM(i));
    }
    return list;

  } else {
    list = newList(vm, 0);
  }

  return list;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movsd 0x10(%rax), %xmm1
movq 0x20(%rsp), %rax
movsd 0x18(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5580
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movsd 0x10(%rax), %xmm1
movsd 0x18(%rax), %xmm0
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, %esi
callq 0x28f0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm1
movq 0x20(%rsp), %rax
movsd 0x18(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5574
movq 0x18(%rsp), %rax
addq $0x10, %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x45b0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x34d0
movsd 0x24bca(%rip), %xmm0    # 0x2a130
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x5515
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x559b
movq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x28f0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: stringLower
String* stringLower(PKVM* vm, String* self) {
  // If the string itself is already lower, don't allocate new string.
  uint32_t index = 0;
  for (const char* c = self->data; *c != '\0'; c++, index++) {
    if (isupper(*c)) {

      // It contain upper case letters, allocate new lower case string .
      String* lower = newStringLength(vm, self->data, self->length);

      // Start where the first upper case letter found.
      char* _c = lower->data + (c - self->data);
      for (; *_c != '\0'; _c++) *_c = (char)tolower(*_c);

      // Since the string is modified re-hash it.
      lower->hash = utilHashString(lower->data);
      return lower;
    }
  }
  // If we reached here the string itself is lower, return it.
  return self;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x20(%rsp), %rax
addq $0x1c, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x56bd
callq 0x23a0
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x569d
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x1c, %rsi
movq 0x20(%rsp), %rax
movl 0x14(%rax), %edx
callq 0x2760
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x1c, %rax
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rdx
addq $0x1c, %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x5679
movq (%rsp), %rax
movsbl (%rax), %edi
callq 0x22a0
movb %al, %cl
movq (%rsp), %rax
movb %cl, (%rax)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x564b
movq 0x8(%rsp), %rdi
addq $0x1c, %rdi
callq 0x140c0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x56c7
jmp 0x569f
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x55d4
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: stringUpper
String* stringUpper(PKVM* vm, String* self) {
  // If the string itself is already upper don't allocate new string.
  uint32_t index = 0;
  for (const char* c = self->data; *c != '\0'; c++, index++) {
    if (islower(*c)) {
      // It contain lower case letters, allocate new upper case string .
      String* upper = newStringLength(vm, self->data, self->length);

      // Start where the first lower case letter found.
      char* _c = upper->data + (c - self->data);
      for (; *_c != '\0'; _c++) *_c = (char)toupper(*_c);

      // Since the string is modified re-hash it.
      upper->hash = utilHashString(upper->data);
      return upper;
    }
  }
  // If we reached here the string itself is lower, return it.
  return self;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x20(%rsp), %rax
addq $0x1c, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x57ed
callq 0x23a0
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0x57cd
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x1c, %rsi
movq 0x20(%rsp), %rax
movl 0x14(%rax), %edx
callq 0x2760
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x1c, %rax
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rdx
addq $0x1c, %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x57a9
movq (%rsp), %rax
movsbl (%rax), %edi
callq 0x20a0
movb %al, %cl
movq (%rsp), %rax
movb %cl, (%rax)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x577b
movq 0x8(%rsp), %rdi
addq $0x1c, %rdi
callq 0x140c0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x57f7
jmp 0x57cf
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x5704
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: stringStrip
String* stringStrip(PKVM* vm, String* self) {

  // Implementation:
  //
  // "     a string with leading and trailing white space    "
  //  ^start >>                                       << end^
  //
  // These 'start' and 'end' pointers will move respectively right and left
  // while it's a white space and return an allocated string from 'start' with
  // length of (end - start + 1). For already trimmed string it'll not allocate
  // a new string, instead returns the same string provided.

  const char* start = self->data;
  while (*start && isspace(*start)) start++;

  // If we reached the end of the string, it's all white space, return
  // an empty string.
  if (*start == '\0') {
    return newStringLength(vm, NULL, 0);
  }

  const char* end = self->data + self->length - 1;
  while (isspace(*end)) end--;

  // If the string is already trimmed, return the same string.
  if (start == self->data && end == self->data + self->length - 1) {
    return self;
  }

  return newStringLength(vm, start, (uint32_t)(end - start + 1));
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x1c, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
je 0x5865
callq 0x23a0
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x586f
jmp 0x587f
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x582c
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x58a6
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2760
movq %rax, 0x30(%rsp)
jmp 0x595c
movq 0x20(%rsp), %rax
addq $0x1c, %rax
movq 0x20(%rsp), %rcx
movl 0x14(%rcx), %ecx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
callq 0x23a0
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x58f4
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x58c3
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
addq $0x1c, %rcx
cmpq %rcx, %rax
jne 0x5935
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
addq $0x1c, %rcx
movq 0x20(%rsp), %rdx
movl 0x14(%rdx), %edx
addq %rdx, %rcx
addq $-0x1, %rcx
cmpq %rcx, %rax
jne 0x5935
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x595c
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movl %eax, %edx
callq 0x2760
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: stringJoin
String* stringJoin(PKVM* vm, String* str1, String* str2) {

  // Optimize end case.
  if (str1->length == 0) return str2;
  if (str2->length == 0) return str1;

  size_t length = (size_t)str1->length + (size_t)str2->length;
  String* string = _allocateString(vm, length);

  memcpy(string->data, str1->data, str1->length);
  memcpy(string->data + str1->length, str2->data, str2->length);
  // Null byte already existed. From _allocateString.

  string->hash = utilHashString(string->data);
  return string;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x599d
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x5a52
movq 0x18(%rsp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x59b7
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x5a52
movq 0x20(%rsp), %rax
movl 0x14(%rax), %eax
movq 0x18(%rsp), %rcx
movl 0x14(%rcx), %ecx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x45e0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
addq $0x1c, %rdi
movq 0x20(%rsp), %rsi
addq $0x1c, %rsi
movq 0x20(%rsp), %rax
movl 0x14(%rax), %eax
movl %eax, %edx
callq 0x2270
movq 0x8(%rsp), %rdi
addq $0x1c, %rdi
movq 0x20(%rsp), %rax
movl 0x14(%rax), %eax
addq %rax, %rdi
movq 0x18(%rsp), %rsi
addq $0x1c, %rsi
movq 0x18(%rsp), %rax
movl 0x14(%rax), %eax
movl %eax, %edx
callq 0x2270
movq 0x8(%rsp), %rdi
addq $0x1c, %rdi
callq 0x140c0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: listInsert
void listInsert(PKVM* vm, List* self, uint32_t index, Var value) {

  // Add an empty slot at the end of the buffer.
  if (IS_OBJ(value)) vmPushTempRef(vm, AS_OBJ(value));
  pkVarBufferWrite(&self->elements, vm, VAR_NULL);
  if (IS_OBJ(value)) vmPopTempRef(vm);

  // Shift the existing elements down.
  for (uint32_t i = self->elements.count - 1; i > index; i--) {
    self->elements.data[i] = self->elements.data[i - 1];
  }

  // Insert the new element.
  self->elements.data[index] = value;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq %rcx, 0x8(%rsp)
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x8(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x5aae
movq 0x20(%rsp), %rdi
movabsq $0xffffffffffff, %rsi   # imm = 0xFFFFFFFFFFFF
andq 0x8(%rsp), %rsi
callq 0x9420
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
movq 0x20(%rsp), %rsi
movabsq $0x7ffc000000000000, %rdx # imm = 0x7FFC000000000000
callq 0x34d0
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x8(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x5af3
movq 0x20(%rsp), %rdi
callq 0x95c0
movq 0x18(%rsp), %rax
movl 0x18(%rax), %eax
subl $0x1, %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jbe 0x5b40
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x5b02
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x14(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: listRemoveAt
Var listRemoveAt(PKVM* vm, List* self, uint32_t index) {
  Var removed = self->elements.data[index];
  if (IS_OBJ(removed)) vmPushTempRef(vm, AS_OBJ(removed));

  // Shift the rest of the elements up.
  for (uint32_t i = index; i < self->elements.count - 1; i++) {
    self->elements.data[i] = self->elements.data[i + 1];
  }

  // Shrink the size if it's too much excess.
  if (self->elements.capacity / GROW_FACTOR >= self->elements.count) {
    self->elements.data = (Var*)vmRealloc(vm, self->elements.data,
      sizeof(Var) * self->elements.capacity,
      sizeof(Var) * self->elements.capacity / GROW_FACTOR);
    self->elements.capacity /= GROW_FACTOR;
  }

  if (IS_OBJ(removed)) vmPopTempRef(vm);

  self->elements.count--;
  return removed;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x8(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x5bbf
movq 0x20(%rsp), %rdi
movabsq $0xffffffffffff, %rsi   # imm = 0xFFFFFFFFFFFF
andq 0x8(%rsp), %rsi
callq 0x9420
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x18(%rsp), %rcx
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x5c0e
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x5bc7
movq 0x18(%rsp), %rax
movl 0x1c(%rax), %eax
shrl %eax
movq 0x18(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jb 0x5c6d
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rsp), %rax
movl 0x1c(%rax), %eax
movl %eax, %edx
shlq $0x3, %rdx
movq 0x18(%rsp), %rax
movl 0x1c(%rax), %eax
movl %eax, %ecx
shlq $0x3, %rcx
shrq %rcx
callq 0x8f90
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movl 0x1c(%rax), %ecx
shrl %ecx
movl %ecx, 0x1c(%rax)
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x8(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x5c95
movq 0x20(%rsp), %rdi
callq 0x95c0
movq 0x18(%rsp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: listJoin
List* listJoin(PKVM* vm, List* l1, List* l2) {

  // Optimize end case.
  if (l1->elements.count == 0) return l2;
  if (l2->elements.count == 0) return l1;

  uint32_t size = l1->elements.count + l2->elements.count;
  List* list = newList(vm, size);

  vmPushTempRef(vm, &list->_super);
  pkVarBufferConcat(&list->elements, vm, &l1->elements);
  pkVarBufferConcat(&list->elements, vm, &l2->elements);
  vmPopTempRef(vm);

  return list;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x5cdd
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x5d79
movq 0x18(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x5cf7
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x5d79
movq 0x20(%rsp), %rax
movl 0x18(%rax), %eax
movq 0x18(%rsp), %rcx
addl 0x18(%rcx), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x28f0
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x9420
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq $0x10, %rdx
callq 0x3500
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq $0x10, %rdx
callq 0x3500
movq 0x28(%rsp), %rdi
callq 0x95c0
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: hashObject
static uint32_t _hashObject(Object* obj) {

  ASSERT(isObjectHashable(obj->type),
         "Check if it's hashable before calling this method.");

  switch (obj->type) {

    case OBJ_STRING:
      return ((String*)obj)->hash;

    case OBJ_LIST:
    case OBJ_MAP:
      goto L_unhashable;

    case OBJ_RANGE:
    {
      Range* range = (Range*)obj;
      return utilHashNumber(range->from) ^ utilHashNumber(range->to);
    }

    case OBJ_SCRIPT:
    case OBJ_FUNC:
    case OBJ_FIBER:
    case OBJ_CLASS:
    case OBJ_INST:
      TODO;
      UNREACHABLE();

    default:
    L_unhashable:
      UNREACHABLE();
      break;
  }

  UNREACHABLE();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %edi
callq 0x7950
testb $0x1, %al
jne 0x5e43
movq 0x2d1e8(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x24336(%rip), %rsi     # 0x2a150
leaq 0x2454f(%rip), %rdx     # 0x2a370
leaq 0x2457b(%rip), %rcx     # 0x2a3a3
leaq 0x2436d(%rip), %r8      # 0x2a19c
movl $0x317, %r9d            # imm = 0x317
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x5e45
movq 0x18(%rsp), %rax
movl (%rax), %eax
movq %rax, 0x8(%rsp)
subq $0x8, %rax
ja 0x5ef9
movq 0x8(%rsp), %rax
leaq 0x241e5(%rip), %rcx     # 0x2a04c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x5f30
jmp 0x5efb
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsd 0x10(%rax), %xmm0
callq 0x140a0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movsd 0x18(%rax), %xmm0
callq 0x140a0
movl %eax, %ecx
movl 0x4(%rsp), %eax
xorl %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x5f30
jmp 0x5ebf
movq 0x2d132(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x24280(%rip), %rsi     # 0x2a150
leaq 0x244d8(%rip), %rdx     # 0x2a3af
leaq 0x244c5(%rip), %rcx     # 0x2a3a3
leaq 0x242b7(%rip), %r8      # 0x2a19c
movl $0x32d, %r9d            # imm = 0x32D
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x5efb
jmp 0x5efd
movq 0x2d0f4(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x242cc(%rip), %rsi     # 0x2a1da
leaq 0x2448e(%rip), %rdx     # 0x2a3a3
leaq 0x24280(%rip), %rcx     # 0x2a19c
movl $0x332, %r8d            # imm = 0x332
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: mapSet
void mapSet(PKVM* vm, Map* self, Var key, Var value) {

  // If map is about to fill, resize it first.
  if (self->count + 1 > self->capacity * MAP_LOAD_PERCENT / 100) {
    uint32_t capacity = self->capacity * GROW_FACTOR;
    if (capacity < MIN_CAPACITY) capacity = MIN_CAPACITY;
    _mapResize(vm, self, capacity);
  }

  if (_mapInsertEntry(self, key, value)) {
    self->count++; //< A new key added.
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl 0x14(%rax), %eax
addl $0x1, %eax
movl %eax, (%rsp)
movq 0x18(%rsp), %rax
imull $0x4b, 0x10(%rax), %eax
movl $0x64, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jbe 0x6211
movq 0x18(%rsp), %rax
movl 0x10(%rax), %eax
shll %eax
movl %eax, 0x4(%rsp)
cmpl $0x8, 0x4(%rsp)
jae 0x61fe
movl $0x8, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x6240
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x6390
testb $0x1, %al
jne 0x622b
jmp 0x6239
movq 0x18(%rsp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: mapResize
static void _mapResize(PKVM* vm, Map* self, uint32_t capacity) {

  MapEntry* old_entries = self->entries;
  uint32_t old_capacity = self->capacity;

  self->entries = ALLOCATE_ARRAY(vm, MapEntry, capacity);
  self->capacity = capacity;
  for (uint32_t i = 0; i < capacity; i++) {
    self->entries[i].key = VAR_UNDEFINED;
    self->entries[i].value = VAR_FALSE;
  }

  // Insert the old entries to the new entries.
  for (uint32_t i = 0; i < old_capacity; i++) {
    // Skip the empty entries or tombstones.
    if (IS_UNDEF(old_entries[i].key)) continue;

    _mapInsertEntry(self, old_entries[i].key, old_entries[i].value);
  }

  DEALLOCATE(vm, old_entries);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %ecx
shlq $0x4, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x8f90
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0x24(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x10(%rax)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x24(%rsp), %eax
jae 0x6301
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x10(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movabsq $0x7ffd000000000000, %rcx # imm = 0x7FFD000000000000
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x10(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movabsq $0x7ffd000000000002, %rcx # imm = 0x7FFD000000000002
movq %rcx, 0x8(%rax)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x62a7
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x6372
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movabsq $0x7ffd000000000000, %rcx # imm = 0x7FFD000000000000
cmpq %rcx, (%rax)
jne 0x6334
jmp 0x6365
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
callq 0x6390
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x6309
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x8f90
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: mapInsertEntry
static bool _mapInsertEntry(Map* self, Var key, Var value) {

  ASSERT(self->capacity != 0, "Should ensure the capacity before inserting.");

  MapEntry* result;
  if (_mapFindEntry(self, key, &result)) {
    // Key already found, just replace the value.
    result->value = value;
    return false;
  } else {
    result->key = key;
    result->value = value;
    return true;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x63e8
movq 0x2cc43(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x23d91(%rip), %rsi     # 0x2a150
leaq 0x24018(%rip), %rdx     # 0x2a3de
leaq 0x2403e(%rip), %rcx     # 0x2a40b
leaq 0x23dc8(%rip), %r8      # 0x2a19c
movl $0x37f, %r9d            # imm = 0x37F
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x63ea
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rsp, %rdx
callq 0x5fa0
testb $0x1, %al
jne 0x6402
jmp 0x6416
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movb $0x0, 0x27(%rsp)
jmp 0x6434
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: mapClear
void mapClear(PKVM* vm, Map* self) {
  DEALLOCATE(vm, self->entries);
  self->entries = NULL;
  self->capacity = 0;
  self->count = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x8f90
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x14(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: mapRemoveKey
Var mapRemoveKey(PKVM* vm, Map* self, Var key) {
  MapEntry* entry;
  if (!_mapFindEntry(self, key, &entry)) return VAR_NULL;

  // Set the key as VAR_UNDEFINED to mark is as an available slow and set it's
  // value to VAR_TRUE for tombstone.
  Var value = entry->value;
  entry->key = VAR_UNDEFINED;
  entry->value = VAR_TRUE;

  self->count--;

  if (IS_OBJ(value)) vmPushTempRef(vm, AS_OBJ(value));

  if (self->count == 0) {
    // Clear the map if it's empty.
    mapClear(vm, self);

 } else if ((self->capacity > MIN_CAPACITY) &&
             (self->capacity / (GROW_FACTOR * GROW_FACTOR)) >
             ((self->count * 100) / MAP_LOAD_PERCENT)) {

    // We grow the map when it's filled 75% (MAP_LOAD_PERCENT) by 2
    // (GROW_FACTOR) but we're not shrink the map when it's half filled (ie.
    // half of the capacity is 75%). Instead we wait till it'll become 1/4 is
    // filled (1/4 = 1/(GROW_FACTOR*GROW_FACTOR)) to minimize the
    // reallocations and which is more faster.

    uint32_t capacity = self->capacity / (GROW_FACTOR * GROW_FACTOR);
    if (capacity < MIN_CAPACITY) capacity = MIN_CAPACITY;

    _mapResize(vm, self, capacity);
  }

  if (IS_OBJ(value)) vmPopTempRef(vm);

  return value;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x5fa0
testb $0x1, %al
jne 0x64df
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
movq %rax, 0x30(%rsp)
jmp 0x660c
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movabsq $0x7ffd000000000000, %rcx # imm = 0x7FFD000000000000
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movabsq $0x7ffd000000000003, %rcx # imm = 0x7FFD000000000003
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movl 0x14(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rax)
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x8(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x6557
movq 0x28(%rsp), %rdi
movabsq $0xffffffffffff, %rsi   # imm = 0xFFFFFFFFFFFF
andq 0x8(%rsp), %rsi
callq 0x9420
movq 0x20(%rsp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x6573
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x6440
jmp 0x65da
movq 0x20(%rsp), %rax
cmpl $0x8, 0x10(%rax)
jbe 0x65d8
movq 0x20(%rsp), %rax
movl 0x10(%rax), %eax
shrl $0x2, %eax
movl %eax, (%rsp)
movq 0x20(%rsp), %rax
imull $0x64, 0x14(%rax), %eax
movl $0x4b, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jbe 0x65d8
movq 0x20(%rsp), %rax
movl 0x10(%rax), %eax
shrl $0x2, %eax
movl %eax, 0x4(%rsp)
cmpl $0x8, 0x4(%rsp)
jae 0x65c5
movl $0x8, 0x4(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x6240
jmp 0x65da
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x8(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x6602
movq 0x28(%rsp), %rdi
callq 0x95c0
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: scriptGetClass
int scriptGetClass(Script* script, const char* name, uint32_t length) {
  for (uint32_t i = 0; i < script->classes.count; i++) {
    uint32_t name_ind = script->classes.data[i]->name;
    ASSERT(name_ind < script->names.count, OOPS);
    String* ty_name = script->names.data[name_ind];
    if (ty_name->length == length &&
        strncmp(ty_name->data, name, length) == 0) {
      return (int)i;
    }
  }
  return -1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x58(%rcx), %eax
jae 0x698c
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x18(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x18(%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x68(%rcx), %eax
jb 0x692c
movq 0x2c6ff(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x2384d(%rip), %rsi     # 0x2a150
leaq 0x2395a(%rip), %rdx     # 0x2a264
leaq 0x239a9(%rip), %rcx     # 0x2a2ba
leaq 0x23884(%rip), %r8      # 0x2a19c
movl $0x44f, %r9d            # imm = 0x44F
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x692e
movq 0x28(%rsp), %rax
movq 0x60(%rax), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x14(%rax), %eax
cmpl 0x1c(%rsp), %eax
jne 0x697a
movq 0x8(%rsp), %rdi
addq $0x1c, %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %eax
movl %eax, %edx
callq 0x2080
cmpl $0x0, %eax
jne 0x697a
movl 0x18(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x6994
jmp 0x697c
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x68ba
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: scriptGetFunc
int scriptGetFunc(Script* script, const char* name, uint32_t length) {
  for (uint32_t i = 0; i < script->functions.count; i++) {
    const char* fn_name = script->functions.data[i]->name;
    uint32_t fn_length = (uint32_t)strlen(fn_name);
    if (fn_length == length && strncmp(fn_name, name, length) == 0) {
      return (int)i;
    }
  }
  return -1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x48(%rcx), %eax
jae 0x6a2d
movq 0x28(%rsp), %rax
movq 0x40(%rax), %rax
movl 0x18(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2130
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jne 0x6a1e
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %eax
movl %eax, %edx
callq 0x2080
cmpl $0x0, %eax
jne 0x6a1e
movl 0x18(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x6a35
jmp 0x6a20
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x69ba
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: scriptGetGlobals
int scriptGetGlobals(Script* script, const char* name, uint32_t length) {
  for (uint32_t i = 0; i < script->global_names.count; i++) {
    uint32_t name_index = script->global_names.data[i];
    String* g_name = script->names.data[name_index];
    if (g_name->length == length && strncmp(g_name->data, name, length) == 0) {
      return (int)i;
    }
  }
  return -1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x38(%rcx), %eax
jae 0x6ad7
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rax
movl 0x18(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
movq 0x60(%rax), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x14(%rax), %eax
cmpl 0x1c(%rsp), %eax
jne 0x6ac8
movq 0x8(%rsp), %rdi
addq $0x1c, %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %eax
movl %eax, %edx
callq 0x2080
cmpl $0x0, %eax
jne 0x6ac8
movl 0x18(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x6adf
jmp 0x6aca
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x6a5a
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: toRepr
String* toRepr(PKVM* vm, const Var value) {
  pkByteBuffer buff;
  pkByteBufferInit(&buff);
  _toStringInternal(vm, value, &buff, NULL, true);
  String* ret = newStringLength(vm, (const char*)buff.data, buff.count);
  pkByteBufferClear(&buff, vm);
  return ret;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x30d0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movl $0x1, %r8d
callq 0x7a40
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x10(%rsp), %edx
callq 0x2760
movq %rax, (%rsp)
movq 0x20(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x3100
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: getPkVarTypeName
const char* getPkVarTypeName(PkVarType type) {
  switch (type) {
    case PK_NULL:     return "Null";
    case PK_BOOL:     return "Bool";
    case PK_NUMBER:   return "Number";
    case PK_STRING:   return "String";
    case PK_LIST:     return "List";
    case PK_MAP:      return "Map";
    case PK_RANGE:    return "Range";
    case PK_SCRIPT:   return "Script";
    case PK_FUNCTION: return "Function";
    case PK_FIBER:    return "Fiber";
    case PK_CLASS:    return "Class";
    case PK_INST:     return "Inst";
  }

  UNREACHABLE();
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq %rax, (%rsp)
subq $0xb, %rax
ja 0x7448
movq (%rsp), %rax
leaq 0x22d0f(%rip), %rcx     # 0x2a094
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x22f9b(%rip), %rax     # 0x2a330
movq %rax, 0x10(%rsp)
jmp 0x747d
leaq 0x247e0(%rip), %rax     # 0x2bb86
movq %rax, 0x10(%rsp)
jmp 0x747d
leaq 0x247f7(%rip), %rax     # 0x2bbae
movq %rax, 0x10(%rsp)
jmp 0x747d
leaq 0x254ca(%rip), %rax     # 0x2c892
movq %rax, 0x10(%rsp)
jmp 0x747d
leaq 0x256d4(%rip), %rax     # 0x2caad
movq %rax, 0x10(%rsp)
jmp 0x747d
leaq 0x25757(%rip), %rax     # 0x2cb41
movq %rax, 0x10(%rsp)
jmp 0x747d
leaq 0x24719(%rip), %rax     # 0x2bb14
movq %rax, 0x10(%rsp)
jmp 0x747d
leaq 0x2336a(%rip), %rax     # 0x2a773
movq %rax, 0x10(%rsp)
jmp 0x747d
leaq 0x246b1(%rip), %rax     # 0x2bac8
movq %rax, 0x10(%rsp)
jmp 0x747d
leaq 0x23291(%rip), %rax     # 0x2a6b6
movq %rax, 0x10(%rsp)
jmp 0x747d
leaq 0x22e90(%rip), %rax     # 0x2a2c3
movq %rax, 0x10(%rsp)
jmp 0x747d
leaq 0x247c0(%rip), %rax     # 0x2bc01
movq %rax, 0x10(%rsp)
jmp 0x747d
jmp 0x744a
movq 0x2bba7(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x22d7f(%rip), %rsi     # 0x2a1da
leaq 0x22ed3(%rip), %rdx     # 0x2a335
leaq 0x22d33(%rip), %rcx     # 0x2a19c
movl $0x51b, %r8d            # imm = 0x51B
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: getObjectTypeName
const char* getObjectTypeName(ObjectType type) {
  switch (type) {
    case OBJ_STRING:  return "String";
    case OBJ_LIST:    return "List";
    case OBJ_MAP:     return "Map";
    case OBJ_RANGE:   return "Range";
    case OBJ_SCRIPT:  return "Script";
    case OBJ_FUNC:    return "Func";
    case OBJ_FIBER:   return "Fiber";
    case OBJ_CLASS:   return "Class";
    case OBJ_INST:    return "Inst";
  }
  UNREACHABLE();
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq %rax, (%rsp)
subq $0x8, %rax
ja 0x7545
movq (%rsp), %rax
leaq 0x22c0f(%rip), %rcx     # 0x2a0c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x253cd(%rip), %rax     # 0x2c892
movq %rax, 0x10(%rsp)
jmp 0x757a
leaq 0x255d7(%rip), %rax     # 0x2caad
movq %rax, 0x10(%rsp)
jmp 0x757a
leaq 0x2565a(%rip), %rax     # 0x2cb41
movq %rax, 0x10(%rsp)
jmp 0x757a
leaq 0x2461c(%rip), %rax     # 0x2bb14
movq %rax, 0x10(%rsp)
jmp 0x757a
leaq 0x2326d(%rip), %rax     # 0x2a773
movq %rax, 0x10(%rsp)
jmp 0x757a
leaq 0x22e32(%rip), %rax     # 0x2a346
movq %rax, 0x10(%rsp)
jmp 0x757a
leaq 0x23194(%rip), %rax     # 0x2a6b6
movq %rax, 0x10(%rsp)
jmp 0x757a
leaq 0x22d93(%rip), %rax     # 0x2a2c3
movq %rax, 0x10(%rsp)
jmp 0x757a
leaq 0x246c3(%rip), %rax     # 0x2bc01
movq %rax, 0x10(%rsp)
jmp 0x757a
jmp 0x7547
movq 0x2baaa(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x22c82(%rip), %rsi     # 0x2a1da
leaq 0x22dec(%rip), %rdx     # 0x2a34b
leaq 0x22c36(%rip), %rcx     # 0x2a19c
movl $0x52a, %r8d            # imm = 0x52A
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)