LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: varTypeName
const char* varTypeName(Var v) {
  if (IS_NULL(v)) return "Null";
  if (IS_BOOL(v)) return "Bool";
  if (IS_NUM(v))  return "Number";

  ASSERT(IS_OBJ(v), OOPS);
  Object* obj = AS_OBJ(v);
  return getObjectTypeName(obj->type);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
cmpq %rax, 0x8(%rsp)
jne 0x75bb
leaq 0x22d7f(%rip), %rax     # 0x2a330
movq %rax, 0x10(%rsp)
jmp 0x7699
movabsq $0x7ffd000000000003, %rax # imm = 0x7FFD000000000003
cmpq %rax, 0x8(%rsp)
je 0x75dd
movabsq $0x7ffd000000000002, %rax # imm = 0x7FFD000000000002
cmpq %rax, 0x8(%rsp)
jne 0x75ee
leaq 0x245a2(%rip), %rax     # 0x2bb86
movq %rax, 0x10(%rsp)
jmp 0x7699
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
andq 0x8(%rsp), %rax
movabsq $0x7ffc000000000000, %rcx # imm = 0x7FFC000000000000
cmpq %rcx, %rax
je 0x761a
leaq 0x2459b(%rip), %rax     # 0x2bbae
movq %rax, 0x10(%rsp)
jmp 0x7699
jmp 0x761c
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x8(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
je 0x7674
movq 0x2b9b7(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x22b05(%rip), %rsi     # 0x2a150
leaq 0x22c12(%rip), %rdx     # 0x2a264
leaq 0x22d04(%rip), %rcx     # 0x2a35d
leaq 0x22b3c(%rip), %r8      # 0x2a19c
movl $0x532, %r9d            # imm = 0x532
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x7676
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movl (%rax), %edi
callq 0x7490
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_var.c
// Function: toString
String* toString(PKVM* vm, const Var value) {

  // If it's already a string don't allocate a new string.
  if (IS_OBJ_TYPE(value, OBJ_STRING)) {
    return (String*)AS_OBJ(value);
  }

  pkByteBuffer buff;
  pkByteBufferInit(&buff);
  _toStringInternal(vm, value, &buff, NULL, false);
  String* ret = newStringLength(vm, (const char*)buff.data, buff.count);
  pkByteBufferClear(&buff, vm);
  return ret;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x20(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x79d6
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x20(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x79d6
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x7a2c
leaq 0x10(%rsp), %rdi
callq 0x30d0
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x7a40
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x18(%rsp), %edx
callq 0x2760
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x3100
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: toBool
bool toBool(Var v) {

  if (IS_BOOL(v)) return AS_BOOL(v);
  if (IS_NULL(v)) return false;
  if (IS_NUM(v)) return AS_NUM(v) != 0;

  ASSERT(IS_OBJ(v), OOPS);
  Object* o = AS_OBJ(v);
  switch (o->type) {
    case OBJ_STRING: return ((String*)o)->length != 0;
    case OBJ_LIST:   return ((List*)o)->elements.count != 0;
    case OBJ_MAP:    return ((Map*)o)->count != 0;
    case OBJ_RANGE: // [[FALLTHROUGH]]
    case OBJ_SCRIPT:
    case OBJ_FUNC:
    case OBJ_FIBER:
    case OBJ_CLASS:
    case OBJ_INST:
      return true;
  }

  UNREACHABLE();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movabsq $0x7ffd000000000003, %rax # imm = 0x7FFD000000000003
cmpq %rax, 0x18(%rsp)
je 0x8b1b
movabsq $0x7ffd000000000002, %rax # imm = 0x7FFD000000000002
cmpq %rax, 0x18(%rsp)
jne 0x8b38
movabsq $0x7ffd000000000003, %rax # imm = 0x7FFD000000000003
cmpq %rax, 0x18(%rsp)
sete %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x8ca7
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
cmpq %rax, 0x18(%rsp)
jne 0x8b53
movb $0x0, 0x27(%rsp)
jmp 0x8ca7
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
andq 0x18(%rsp), %rax
movabsq $0x7ffc000000000000, %rcx # imm = 0x7FFC000000000000
cmpq %rcx, %rax
je 0x8b95
movq 0x18(%rsp), %rdi
callq 0x45d0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x8ca7
jmp 0x8b97
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x18(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
je 0x8bef
movq 0x2a43c(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x2158a(%rip), %rsi     # 0x2a150
leaq 0x21697(%rip), %rdx     # 0x2a264
leaq 0x21795(%rip), %rcx     # 0x2a369
leaq 0x215c1(%rip), %r8      # 0x2a19c
movl $0x693, %r9d            # imm = 0x693
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x8bf1
movq 0x18(%rsp), %rax
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movq %rax, 0x8(%rsp)
subq $0x8, %rax
ja 0x8c72
movq 0x8(%rsp), %rax
leaq 0x214e6(%rip), %rcx     # 0x2a10c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rax
cmpl $0x0, 0x14(%rax)
setne %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x8ca7
movq 0x10(%rsp), %rax
cmpl $0x0, 0x18(%rax)
setne %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x8ca7
movq 0x10(%rsp), %rax
cmpl $0x0, 0x14(%rax)
setne %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x8ca7
movb $0x1, 0x27(%rsp)
jmp 0x8ca7
jmp 0x8c74
movq 0x2a37d(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x21555(%rip), %rsi     # 0x2a1da
leaq 0x216dd(%rip), %rdx     # 0x2a369
leaq 0x21509(%rip), %rcx     # 0x2a19c
movl $0x6a2, %r8d            # imm = 0x6A2
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_vm.c
// Function: defaultRealloc
static void* defaultRealloc(void* memory, size_t new_size, void* user_data) {
  if (new_size == 0) {
    free(memory);
    return NULL;
  }
  return realloc(memory, new_size);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x8d50
movq 0x18(%rsp), %rdi
callq 0x2030
movq $0x0, 0x20(%rsp)
jmp 0x8d64
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x22e0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_vm.c
// Function: pkNewVM
PKVM* pkNewVM(PkConfiguration* config) {

  PkConfiguration default_config = pkNewConfiguration();

  if (config == NULL) config = &default_config;

  PKVM* vm = (PKVM*)config->realloc_fn(NULL, sizeof(PKVM), config->user_data);
  memset(vm, 0, sizeof(PKVM));

  vm->config = *config;
  vm->working_set_count = 0;
  vm->working_set_capacity = MIN_CAPACITY;
  vm->working_set = (Object**)vm->config.realloc_fn(
                       NULL, sizeof(Object*) * vm->working_set_capacity, NULL);
  vm->next_gc = INITIAL_GC_SIZE;
  vm->min_heap_size = MIN_HEAP_SIZE;
  vm->heap_fill_percent = HEAP_FILL_PERCENT;

  vm->scripts = newMap(vm);
  vm->core_libs = newMap(vm);
  vm->builtins_count = 0;

  initializeCore(vm);
  return vm;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x8cc0
cmpq $0x0, 0x60(%rsp)
jne 0x8da5
leaq 0x8(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rax
movq 0x60(%rsp), %rcx
movq 0x50(%rcx), %rdx
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x5f8, %esi            # imm = 0x5F8
callq *%rax
movq %rax, (%rsp)
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x5f8, %edx            # imm = 0x5F8
callq 0x2180
movq (%rsp), %rdi
addq $0xc8, %rdi
movq 0x60(%rsp), %rsi
movl $0x58, %edx
callq 0x2270
movq (%rsp), %rax
movl $0x0, 0x30(%rax)
movq (%rsp), %rax
movl $0x8, 0x34(%rax)
movq (%rsp), %rax
movq 0xc8(%rax), %rax
movq (%rsp), %rcx
movslq 0x34(%rcx), %rsi
shlq $0x3, %rsi
xorl %ecx, %ecx
movl %ecx, %edx
movq %rdx, %rdi
callq *%rax
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
movq $0xa00000, 0x10(%rax)   # imm = 0xA00000
movq (%rsp), %rax
movq $0x100000, 0x18(%rax)   # imm = 0x100000
movq (%rsp), %rax
movl $0x4b, 0x20(%rax)
movq (%rsp), %rdi
callq 0x29f0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x128(%rax)
movq (%rsp), %rdi
callq 0x29f0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x130(%rax)
movq (%rsp), %rax
movl $0x0, 0x5e8(%rax)
movq (%rsp), %rdi
callq 0x1c8d0
movq (%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_vm.c
// Function: pkFreeVM
void pkFreeVM(PKVM* vm) {

  Object* obj = vm->first;
  while (obj != NULL) {
    Object* next = obj->next;
    freeObject(vm, obj);
    obj = next;
  }

  vm->working_set = (Object**)vm->config.realloc_fn(
    vm->working_set, 0, vm->config.user_data);

  // Tell the host application that it forget to release all of it's handles
  // before freeing the VM.
  __ASSERT(vm->handles == NULL, "Not all handles were released.");

  DEALLOCATE(vm, vm);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x8ef5
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x6640
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x8ec6
movq 0x10(%rsp), %rax
movq 0xc8(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x28(%rcx), %rdi
movq 0x10(%rsp), %rcx
movq 0x118(%rcx), %rdx
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0xc0(%rax)
je 0x8f71
movq 0x2a0ba(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x21208(%rip), %rsi     # 0x2a150
leaq 0x216c5(%rip), %rdx     # 0x2a614
leaq 0x216dd(%rip), %rcx     # 0x2a633
leaq 0x216df(%rip), %r8      # 0x2a63c
movl $0x5f, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x8f73
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x8f90
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_vm.c
// Function: vmRealloc
void* vmRealloc(PKVM* vm, void* memory, size_t old_size, size_t new_size) {

  // TODO: Debug trace allocations here.

  // Track the total allocated memory of the VM to trigger the GC.
  // if vmRealloc is called for freeing, the old_size would be 0 since
  // deallocated bytes are traced by garbage collector.
  vm->bytes_allocated += new_size - old_size;

  if (new_size > 0 && vm->bytes_allocated > vm->next_gc) {
    vmCollectGarbage(vm);
  }

  return vm->config.realloc_fn(memory, new_size, vm->config.user_data);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x8(%rsp), %rcx
subq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rsp)
jbe 0x8fe5
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x8fe5
movq 0x20(%rsp), %rdi
callq 0x11770
movq 0x20(%rsp), %rax
movq 0xc8(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rcx
movq 0x118(%rcx), %rdx
callq *%rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_vm.c
// Function: vmNewHandle
PkHandle* vmNewHandle(PKVM* vm, Var value) {
  PkHandle* handle = (PkHandle*)ALLOCATE(vm, PkHandle);
  handle->value = value;
  handle->prev = NULL;
  handle->next = vm->handles;
  if (handle->next != NULL) handle->next->prev = handle;
  vm->handles = handle;
  return handle;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x18, %ecx
movq %rdx, %rsi
callq 0x8f90
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0xc0(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x90ef
movq (%rsp), %rcx
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0xc0(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_vm.c
// Function: pkReleaseHandle
void pkReleaseHandle(PKVM* vm, PkHandle* handle) {
  __ASSERT(handle != NULL, "Given handle was NULL.");

  // If the handle is the head of the vm's handle chain set it to the next one.
  if (handle == vm->handles) {
    vm->handles = handle->next;
  }

  // Remove the handle from the chain by connecting the both ends together.
  if (handle->next) handle->next->prev = handle->prev;
  if (handle->prev) handle->prev->next = handle->next;

  // Free the handle.
  DEALLOCATE(vm, handle);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x9170
movq 0x29ebb(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x21009(%rip), %rsi     # 0x2a150
leaq 0x214fa(%rip), %rdx     # 0x2a648
leaq 0x2150a(%rip), %rcx     # 0x2a65f
leaq 0x214e0(%rip), %r8      # 0x2a63c
movl $0x75, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x9172
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0xc0(%rcx), %rax
jne 0x919a
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0xc0(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x91bc
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x91de
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x8f90
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_vm.c
// Function: vmPushTempRef
void vmPushTempRef(PKVM* vm, Object* obj) {
  ASSERT(obj != NULL, "Cannot reference to NULL.");
  ASSERT(vm->temp_reference_count < MAX_TEMP_REFERENCE,
    "Too many temp references");
  vm->temp_reference[vm->temp_reference_count++] = obj;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x9470
movq 0x29bbb(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x20d09(%rip), %rsi     # 0x2a150
leaq 0x212ad(%rip), %rdx     # 0x2a6fb
leaq 0x212c0(%rip), %rcx     # 0x2a715
leaq 0x211e0(%rip), %r8      # 0x2a63c
movl $0xea, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x9472
jmp 0x9474
movq 0x10(%rsp), %rax
cmpl $0x10, 0xb8(%rax)
jl 0x94bc
movq 0x29b6f(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x20cbd(%rip), %rsi     # 0x2a150
leaq 0x21289(%rip), %rdx     # 0x2a723
leaq 0x21274(%rip), %rcx     # 0x2a715
leaq 0x21194(%rip), %r8      # 0x2a63c
movl $0xec, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x94be
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x10(%rsp), %rsi
movl 0xb8(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0xb8(%rsi)
movslq %ecx, %rcx
movq %rdx, 0x38(%rax,%rcx,8)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_vm.c
// Function: vmGetScript
Script* vmGetScript(PKVM* vm, String* path) {
  Var scr = mapGet(vm->scripts, VAR_OBJ(path));
  if (IS_UNDEF(scr)) return NULL;
  ASSERT(AS_OBJ(scr)->type == OBJ_SCRIPT, OOPS);
  return (Script*)AS_OBJ(scr);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x128(%rax), %rdi
movq 0x10(%rsp), %rsi
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %rsi
callq 0x5f40
movq %rax, 0x8(%rsp)
movabsq $0x7ffd000000000000, %rax # imm = 0x7FFD000000000000
cmpq %rax, 0x8(%rsp)
jne 0x9542
movq $0x0, 0x20(%rsp)
jmp 0x95a8
jmp 0x9544
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x8(%rsp), %rax
cmpl $0x4, (%rax)
je 0x9592
movq 0x29a99(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x20be7(%rip), %rsi     # 0x2a150
leaq 0x20cf4(%rip), %rdx     # 0x2a264
leaq 0x211f7(%rip), %rcx     # 0x2a76e
leaq 0x210be(%rip), %r8      # 0x2a63c
movl $0xf9, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x9594
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_vm.c
// Function: pkRunFiber
PkResult pkRunFiber(PKVM* vm, PkHandle* fiber,
                    int argc, PkHandle** argv) {
  __ASSERT(fiber != NULL, "Handle fiber was NULL.");
  Var fb = fiber->value;
  __ASSERT(IS_OBJ_TYPE(fb, OBJ_FIBER), "Given handle is not a fiber.");
  Fiber* _fiber = (Fiber*)AS_OBJ(fb);

  Var* args[MAX_ARGC];
  for (int i = 0; i < argc; i++) {
    args[i] = &(argv[i]->value);
  }

  if (!vmPrepareFiber(vm, _fiber, argc, args)) {
    return PK_RESULT_RUNTIME_ERROR;
  }

  ASSERT(_fiber->frame_count == 1, OOPS);
  return runFiber(vm, _fiber);
}

// Assembly:
subq $0x148, %rsp            # imm = 0x148
movq %rdi, 0x138(%rsp)
movq %rsi, 0x130(%rsp)
movl %edx, 0x12c(%rsp)
movq %rcx, 0x120(%rsp)
cmpq $0x0, 0x130(%rsp)
jne 0x109db
movq 0x22650(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x1979e(%rip), %rsi     # 0x2a150
leaq 0x19cb6(%rip), %rdx     # 0x2a66f
leaq 0x19cc6(%rip), %rcx     # 0x2a686
leaq 0x19c75(%rip), %r8      # 0x2a63c
movl $0xa7, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x109dd
movq 0x130(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x118(%rsp)
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x118(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x10a28
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x118(%rsp), %rax
cmpl $0x6, (%rax)
je 0x10a62
movq 0x225c9(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x19717(%rip), %rsi     # 0x2a150
leaq 0x19c51(%rip), %rdx     # 0x2a691
leaq 0x19c3f(%rip), %rcx     # 0x2a686
leaq 0x19bee(%rip), %r8      # 0x2a63c
movl $0xa9, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x10a64
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x118(%rsp), %rax
movq %rax, 0x110(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x12c(%rsp), %eax
jge 0x10abb
movq 0x120(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movslq 0xc(%rsp), %rax
movq %rcx, 0x10(%rsp,%rax,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x10a86
movq 0x138(%rsp), %rdi
movq 0x110(%rsp), %rsi
movl 0x12c(%rsp), %edx
leaq 0x10(%rsp), %rcx
callq 0x10b70
testb $0x1, %al
jne 0x10aed
movl $0x3, 0x144(%rsp)
jmp 0x10b55
jmp 0x10aef
movq 0x110(%rsp), %rax
cmpl $0x1, 0x4c(%rax)
je 0x10b37
movq 0x224f4(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x19642(%rip), %rsi     # 0x2a150
leaq 0x1974f(%rip), %rdx     # 0x2a264
leaq 0x19b6a(%rip), %rcx     # 0x2a686
leaq 0x19b19(%rip), %r8      # 0x2a63c
movl $0xb5, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x10b39
movq 0x138(%rsp), %rdi
movq 0x110(%rsp), %rsi
callq 0x9630
movl %eax, 0x144(%rsp)
movl 0x144(%rsp), %eax
addq $0x148, %rsp            # imm = 0x148
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_vm.c
// Function: pkResumeFiber
PkResult pkResumeFiber(PKVM* vm, PkHandle* fiber, PkVar value) {
  __ASSERT(fiber != NULL, "Handle fiber was NULL.");
  Var fb = fiber->value;
  __ASSERT(IS_OBJ_TYPE(fb, OBJ_FIBER), "Given handle is not a fiber.");
  Fiber* _fiber = (Fiber*)AS_OBJ(fb);

  if (!vmSwitchFiber(vm, _fiber, (Var*)value)) {
    return PK_RESULT_RUNTIME_ERROR;
  }

  return runFiber(vm, _fiber);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x111d5
movq 0x21e56(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x18fa4(%rip), %rsi     # 0x2a150
leaq 0x194bc(%rip), %rdx     # 0x2a66f
leaq 0x194f4(%rip), %rcx     # 0x2a6ae
leaq 0x1947b(%rip), %r8      # 0x2a63c
movl $0xba, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x111d7
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x10(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x11216
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x10(%rsp), %rax
cmpl $0x6, (%rax)
je 0x11250
movq 0x21ddb(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x18f29(%rip), %rsi     # 0x2a150
leaq 0x19463(%rip), %rdx     # 0x2a691
leaq 0x19479(%rip), %rcx     # 0x2a6ae
leaq 0x19400(%rip), %r8      # 0x2a63c
movl $0xbc, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x11252
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x112b0
testb $0x1, %al
jne 0x11288
movl $0x3, 0x34(%rsp)
jmp 0x1129b
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x9630
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_vm.c
// Function: vmYieldFiber
void vmYieldFiber(PKVM* vm, Var* value) {

  Fiber* caller = vm->fiber->caller;

  // Return the yield value to the caller fiber.
  if (caller != NULL) {
    if (value == NULL) *caller->ret = VAR_NULL;
    else *caller->ret = *value;
  }

  // Can be resumed by another caller fiber.
  vm->fiber->caller = NULL;
  vm->fiber->state = FIBER_YIELDED;
  vm->fiber = caller;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x5f0(%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0x119fd
cmpq $0x0, -0x10(%rsp)
jne 0x119e7
movq -0x18(%rsp), %rax
movq 0x38(%rax), %rax
movabsq $0x7ffc000000000000, %rcx # imm = 0x7FFC000000000000
movq %rcx, (%rax)
jmp 0x119fb
movq -0x10(%rsp), %rax
movq (%rax), %rcx
movq -0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq %rcx, (%rax)
jmp 0x119fd
movq -0x8(%rsp), %rax
movq 0x5f0(%rax), %rax
movq $0x0, 0x50(%rax)
movq -0x8(%rsp), %rax
movq 0x5f0(%rax), %rax
movl $0x2, 0x10(%rax)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x5f0(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_vm.c
// Function: reportError
static void reportError(PKVM* vm) {
  ASSERT(VM_HAS_ERROR(vm), "runtimeError() should be called after an error.");
  // TODO: pass the error to the caller of the fiber.

  // Print the Error message and stack trace.
  if (vm->config.error_fn == NULL) return;
  Fiber* fiber = vm->fiber;
  vm->config.error_fn(vm, PK_ERROR_RUNTIME, NULL, -1, fiber->error->data);
  for (int i = fiber->frame_count - 1; i >= 0; i--) {
    CallFrame* frame = &fiber->frames[i];
    const Function* fn = frame->fn;
    ASSERT(!fn->is_native, OOPS);
    int line = fn->fn->oplines.data[frame->ip - fn->fn->opcodes.data - 1];
    vm->config.error_fn(vm, PK_ERROR_STACKTRACE, fn->owner->path->data, line,
                        fn->name);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x5f0(%rax), %rax
cmpq $0x0, 0x58(%rax)
jne 0x11a96
movq 0x21595(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x186e3(%rip), %rsi     # 0x2a150
leaq 0x18f38(%rip), %rdx     # 0x2a9ac
leaq 0x18f61(%rip), %rcx     # 0x2a9dc
leaq 0x18bba(%rip), %r8      # 0x2a63c
movl $0x24a, %r9d            # imm = 0x24A
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x11a98
movq 0x30(%rsp), %rax
cmpq $0x0, 0xd0(%rax)
jne 0x11aac
jmp 0x11be9
movq 0x30(%rsp), %rax
movq 0x5f0(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0xd0(%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rcx
movq 0x58(%rcx), %r8
addq $0x1c, %r8
movl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq *%rax
movq 0x28(%rsp), %rax
movl 0x4c(%rax), %eax
subl $0x1, %eax
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jl 0x11be9
movq 0x28(%rsp), %rax
movq 0x40(%rax), %rax
movslq 0x24(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x30(%rax)
je 0x11b72
movq 0x214b9(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x18607(%rip), %rsi     # 0x2a150
leaq 0x18714(%rip), %rdx     # 0x2a264
leaq 0x18e85(%rip), %rcx     # 0x2a9dc
leaq 0x18ade(%rip), %r8      # 0x2a63c
movl $0x254, %r9d            # imm = 0x254
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x11b74
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movq 0x10(%rsp), %rdx
movq 0x38(%rdx), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
subq $0x1, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rax
movq 0xd0(%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq 0x18(%rcx), %rdx
addq $0x1c, %rdx
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rsi
movq 0x10(%rsi), %r8
movl $0x2, %esi
callq *%rax
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x11afa
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_vm.c
// Function: importScript
static inline Var importScript(PKVM* vm, String* path_name) {

  // Check in the core libs.
  Script* scr = getCoreLib(vm, path_name);
  if (scr != NULL) return VAR_OBJ(scr);

  // Check in the scripts cache.
  Var entry = mapGet(vm->scripts, VAR_OBJ(path_name));
  if (!IS_UNDEF(entry)) {
    ASSERT(AS_OBJ(entry)->type == OBJ_SCRIPT, OOPS);
    return entry;
  }

  // Imported scripts were resolved at compile time.
  UNREACHABLE();

  return VAR_NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1c7e0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x11c36
movq 0x8(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
orq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0x11cfe
movq 0x18(%rsp), %rax
movq 0x128(%rax), %rdi
movq 0x10(%rsp), %rsi
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %rsi
callq 0x5f40
movq %rax, (%rsp)
movabsq $0x7ffd000000000000, %rax # imm = 0x7FFD000000000000
cmpq %rax, (%rsp)
je 0x11cc9
jmp 0x11c6f
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq (%rsp), %rax
cmpl $0x4, (%rax)
je 0x11cbc
movq 0x2136f(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x184bd(%rip), %rsi     # 0x2a150
leaq 0x185ca(%rip), %rdx     # 0x2a264
leaq 0x18d47(%rip), %rcx     # 0x2a9e8
leaq 0x18994(%rip), %r8      # 0x2a63c
movl $0x1df, %r9d            # imm = 0x1DF
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x11cbe
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x11cfe
jmp 0x11ccb
movq 0x21326(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x184fe(%rip), %rsi     # 0x2a1da
leaq 0x18d05(%rip), %rdx     # 0x2a9e8
leaq 0x18952(%rip), %rcx     # 0x2a63c
movl $0x1e4, %r8d            # imm = 0x1E4
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_vm.c
// Function: pushCallFrame
static inline void pushCallFrame(PKVM* vm, const Function* fn, Var* rbp) {
  ASSERT(!fn->is_native, "Native function shouldn't use call frames.");

  // Grow the stack frame if needed.
  if (vm->fiber->frame_count + 1 > vm->fiber->frame_capacity) {
    int new_capacity = vm->fiber->frame_capacity << 1;
    vm->fiber->frames = (CallFrame*)vmRealloc(vm, vm->fiber->frames,
                           sizeof(CallFrame) * vm->fiber->frame_capacity,
                           sizeof(CallFrame) * new_capacity);
    vm->fiber->frame_capacity = new_capacity;
  }

  // Grow the stack if needed.
  int needed = fn->fn->stack_size + (int)(vm->fiber->sp - vm->fiber->stack);
  if (vm->fiber->stack_size <= needed) growStack(vm, needed);

  CallFrame* frame = vm->fiber->frames + vm->fiber->frame_count++;
  frame->rbp = rbp;
  frame->fn = fn;
  frame->ip = fn->fn->opcodes.data;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
testb $0x1, 0x30(%rax)
je 0x11d68
movq 0x212c3(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x18411(%rip), %rsi     # 0x2a150
leaq 0x18caf(%rip), %rdx     # 0x2a9f5
leaq 0x18cd3(%rip), %rcx     # 0x2aa20
leaq 0x188e8(%rip), %r8      # 0x2a63c
movl $0x217, %r9d            # imm = 0x217
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x11d6a
movq 0x20(%rsp), %rax
movq 0x5f0(%rax), %rax
movl 0x4c(%rax), %eax
addl $0x1, %eax
movq 0x20(%rsp), %rcx
movq 0x5f0(%rcx), %rcx
cmpl 0x48(%rcx), %eax
jle 0x11dff
movq 0x20(%rsp), %rax
movq 0x5f0(%rax), %rax
movl 0x48(%rax), %eax
shll %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x5f0(%rax), %rax
movq 0x40(%rax), %rsi
movq 0x20(%rsp), %rax
movq 0x5f0(%rax), %rax
movslq 0x48(%rax), %rax
imulq $0x18, %rax, %rdx
movslq 0xc(%rsp), %rax
imulq $0x18, %rax, %rcx
callq 0x8f90
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq 0x5f0(%rax), %rax
movq %rcx, 0x40(%rax)
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rax
movq 0x5f0(%rax), %rax
movl %ecx, 0x48(%rax)
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movl 0x20(%rax), %eax
movq 0x20(%rsp), %rcx
movq 0x5f0(%rcx), %rcx
movq 0x30(%rcx), %rcx
movq 0x20(%rsp), %rdx
movq 0x5f0(%rdx), %rdx
movq 0x20(%rdx), %rdx
subq %rdx, %rcx
sarq $0x3, %rcx
addl %ecx, %eax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x5f0(%rax), %rax
movl 0x28(%rax), %eax
cmpl 0x8(%rsp), %eax
jg 0x11e5b
movq 0x20(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x12150
movq 0x20(%rsp), %rax
movq 0x5f0(%rax), %rax
movq 0x40(%rax), %rax
movq 0x20(%rsp), %rcx
movq 0x5f0(%rcx), %rdx
movl 0x4c(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x4c(%rdx)
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_debug.c
// Function: dumpValue
void dumpValue(PKVM* vm, Var value, pkByteBuffer* buff) {
  String* repr = toRepr(vm, value);
  vmPushTempRef(vm, &repr->_super);
  pkByteBufferAddString(buff, vm, repr->data, repr->length);
  vmPopTempRef(vm);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x6fc0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x9420
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
addq $0x1c, %rdx
movq 0x8(%rsp), %rax
movl 0x14(%rax), %ecx
callq 0x3c70
movq 0x20(%rsp), %rdi
callq 0x95c0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_debug.c
// Function: dumpGlobalValues
void dumpGlobalValues(PKVM* vm) {
  Fiber* fiber = vm->fiber;
  int frame_ind = fiber->frame_count - 1;
  ASSERT(frame_ind >= 0, OOPS);
  CallFrame* frame = &fiber->frames[frame_ind];
  Script* scr = frame->fn->owner;

  for (uint32_t i = 0; i < scr->global_names.count; i++) {
    String* name = scr->names.data[scr->global_names.data[i]];
    Var value = scr->globals.data[i];
    printf("%10s = ", name->data);

    // Dump value. TODO: refactor.
    pkByteBuffer buff;
    pkByteBufferInit(&buff);
    dumpValue(vm, value, &buff);
    pkByteBufferWrite(&buff, vm, '\0');
    printf("%s", (const char*)buff.data);
    pkByteBufferClear(&buff, vm);

    printf("\n");
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq 0x5f0(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movl 0x4c(%rax), %eax
subl $0x1, %eax
movl %eax, 0x44(%rsp)
cmpl $0x0, 0x44(%rsp)
jge 0x13c6a
movq 0x1f3c1(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x1650f(%rip), %rsi     # 0x2a150
leaq 0x1661c(%rip), %rdx     # 0x2a264
leaq 0x16fa3(%rip), %rcx     # 0x2abf2
leaq 0x16f5a(%rip), %r8      # 0x2abb0
movl $0x19e, %r9d            # imm = 0x19E
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x13c6c
movq 0x48(%rsp), %rax
movq 0x40(%rax), %rax
movslq 0x44(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0x38(%rcx), %eax
jae 0x13d70
movq 0x30(%rsp), %rax
movq 0x60(%rax), %rax
movq 0x30(%rsp), %rcx
movq 0x30(%rcx), %rcx
movl 0x2c(%rsp), %edx
movl (%rcx,%rdx,4), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x2c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rsi
addq $0x1c, %rsi
leaq 0x16f09(%rip), %rdi     # 0x2ac03
movb $0x0, %al
callq 0x2140
leaq 0x8(%rsp), %rdi
callq 0x30d0
movq 0x50(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x12300
movq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x3270
movq 0x8(%rsp), %rsi
leaq 0x19da3(%rip), %rdi     # 0x2dadf
movb $0x0, %al
callq 0x2140
movq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x3100
leaq 0x18592(%rip), %rdi     # 0x2c2eb
movb $0x0, %al
callq 0x2140
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x13ca0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_debug.c
// Function: dumpStackFrame
void dumpStackFrame(PKVM* vm) {
  Fiber* fiber = vm->fiber;
  int frame_ind = fiber->frame_count - 1;
  ASSERT(frame_ind >= 0, OOPS);
  CallFrame* frame = &fiber->frames[frame_ind];
  Var* sp = fiber->sp - 1;

  printf("Frame[%d]\n", frame_ind);
  for (; sp >= frame->rbp; sp--) {
    printf("       ");

    // Dump value. TODO: refactor.
    pkByteBuffer buff;
    pkByteBufferInit(&buff);
    dumpValue(vm, *sp, &buff);
    pkByteBufferWrite(&buff, vm, '\0');
    printf("%s", (const char*)buff.data);
    pkByteBufferClear(&buff, vm);

    printf("\n");
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x5f0(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movl 0x4c(%rax), %eax
subl $0x1, %eax
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jge 0x13dea
movq 0x1f241(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x1638f(%rip), %rsi     # 0x2a150
leaq 0x1649c(%rip), %rdx     # 0x2a264
leaq 0x16e3c(%rip), %rcx     # 0x2ac0b
leaq 0x16dda(%rip), %r8      # 0x2abb0
movl $0x1b6, %r9d            # imm = 0x1B6
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x13dec
movq 0x28(%rsp), %rax
movq 0x40(%rax), %rax
movslq 0x24(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rax
addq $-0x8, %rax
movq %rax, 0x10(%rsp)
movl 0x24(%rsp), %esi
leaq 0x16df7(%rip), %rdi     # 0x2ac1a
movb $0x0, %al
callq 0x2140
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x13eb4
leaq 0x16d82(%rip), %rdi     # 0x2abc3
movb $0x0, %al
callq 0x2140
movq %rsp, %rdi
callq 0x30d0
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq %rsp, %rdx
callq 0x12300
movq 0x30(%rsp), %rsi
movq %rsp, %rdi
xorl %edx, %edx
callq 0x3270
movq (%rsp), %rsi
leaq 0x19c60(%rip), %rdi     # 0x2dadf
movb $0x0, %al
callq 0x2140
movq 0x30(%rsp), %rsi
movq %rsp, %rdi
callq 0x3100
leaq 0x18451(%rip), %rdi     # 0x2c2eb
movb $0x0, %al
callq 0x2140
movq 0x10(%rsp), %rax
addq $-0x8, %rax
movq %rax, 0x10(%rsp)
jmp 0x13e2a
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_utils.c
// Function: utilPowerOf2Ceil
int utilPowerOf2Ceil(int n) {
  n--;
  n |= n >> 1;
  n |= n >> 2;
  n |= n >> 4;
  n |= n >> 8;
  n |= n >> 16;
  n++;

  return n;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
sarl %eax
orl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
sarl $0x2, %eax
orl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
sarl $0x4, %eax
orl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
sarl $0x8, %eax
orl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
sarl $0x10, %eax
orl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_utils.c
// Function: utilHashBits
uint32_t utilHashBits(uint64_t hash) {
  // From v8's ComputeLongHash() which in turn cites:
  // Thomas Wang, Integer Hash Functions.
  // http://www.concentric.net/~Ttwang/tech/inthash.htm
  hash = ~hash + (hash << 18);
  hash = hash ^ (hash >> 31);
  hash = hash * 21;
  hash = hash ^ (hash >> 11);
  hash = hash + (hash << 6);
  hash = hash ^ (hash >> 22);
  return (uint32_t)(hash & 0x3fffffff);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
xorq $-0x1, %rax
movq -0x8(%rsp), %rcx
shlq $0x12, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq -0x8(%rsp), %rcx
shrq $0x1f, %rcx
xorq %rcx, %rax
movq %rax, -0x8(%rsp)
imulq $0x15, -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq -0x8(%rsp), %rcx
shrq $0xb, %rcx
xorq %rcx, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq -0x8(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq -0x8(%rsp), %rcx
shrq $0x16, %rcx
xorq %rcx, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
andq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
retq
nop
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_utils.c
// Function: utilHashString
uint32_t utilHashString(const char* string) {
  // FNV-1a hash. See: http://www.isthe.com/chongo/tech/comp/fnv/

#define FNV_prime_32_bit 16777619u
#define FNV_offset_basis_32_bit 2166136261u

  uint32_t hash = FNV_offset_basis_32_bit;

  for (const char* c = string; *c != '\0'; c++) {
    hash ^= *c;
    hash *= FNV_prime_32_bit;
  }

  return hash;

#undef FNV_prime_32_bit
#undef FNV_offset_basis_32_bit
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x811c9dc5, -0xc(%rsp) # imm = 0x811C9DC5
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x14110
movq -0x18(%rsp), %rax
movsbl (%rax), %eax
xorl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
imull $0x1000193, -0xc(%rsp), %eax # imm = 0x1000193
movl %eax, -0xc(%rsp)
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x140d7
movl -0xc(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_utils.c
// Function: utf8_encodeBytesCount
int utf8_encodeBytesCount(int value) {
  if (value <= 0x7f) return 1;
  if (value <= 0x7ff) return 2;
  if (value <= 0xffff) return 3;
  if (value <= 0x10ffff) return 4;

  // if we're here means it's an invalid leading byte
  return 0;
}

// Assembly:
movl %edi, -0x8(%rsp)
cmpl $0x7f, -0x8(%rsp)
jg 0x14135
movl $0x1, -0x4(%rsp)
jmp 0x14179
cmpl $0x7ff, -0x8(%rsp)      # imm = 0x7FF
jg 0x14149
movl $0x2, -0x4(%rsp)
jmp 0x14179
cmpl $0xffff, -0x8(%rsp)     # imm = 0xFFFF
jg 0x1415d
movl $0x3, -0x4(%rsp)
jmp 0x14179
cmpl $0x10ffff, -0x8(%rsp)   # imm = 0x10FFFF
jg 0x14171
movl $0x4, -0x4(%rsp)
jmp 0x14179
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_utils.c
// Function: utf8_decodeBytesCount
int utf8_decodeBytesCount(uint8_t byte) {

  if ((byte >> 7) == 0b0) return 1;
  if ((byte >> 6) == 0b10) return 1; //< continuation byte
  if ((byte >> 5) == 0b110) return 2;
  if ((byte >> 4) == 0b1110) return 3;
  if ((byte >> 3) == 0b11110) return 4;

  // if we're here means it's an invalid utf8 byte
  return 1;
}

// Assembly:
movb %dil, %al
movb %al, -0x5(%rsp)
movzbl -0x5(%rsp), %eax
sarl $0x7, %eax
cmpl $0x0, %eax
jne 0x1419e
movl $0x1, -0x4(%rsp)
jmp 0x14202
movzbl -0x5(%rsp), %eax
sarl $0x6, %eax
cmpl $0x2, %eax
jne 0x141b5
movl $0x1, -0x4(%rsp)
jmp 0x14202
movzbl -0x5(%rsp), %eax
sarl $0x5, %eax
cmpl $0x6, %eax
jne 0x141cc
movl $0x2, -0x4(%rsp)
jmp 0x14202
movzbl -0x5(%rsp), %eax
sarl $0x4, %eax
cmpl $0xe, %eax
jne 0x141e3
movl $0x3, -0x4(%rsp)
jmp 0x14202
movzbl -0x5(%rsp), %eax
sarl $0x3, %eax
cmpl $0x1e, %eax
jne 0x141fa
movl $0x4, -0x4(%rsp)
jmp 0x14202
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_utils.c
// Function: utf8_decodeBytes
int utf8_decodeBytes(uint8_t* bytes, int* value) {

  int continue_bytes = 0;
  int byte_count = 1;
  int _value = 0;

  if ((*bytes & 0b11000000) == 0b10000000) {
    *value = *bytes;
    return byte_count;
  }

  else if ((*bytes & 0b11100000) == 0b11000000) {
    continue_bytes = 1;
    _value = (*bytes & 0b11111);
  }

  else if ((*bytes & 0b11110000) == 0b11100000) {
    continue_bytes = 2;
    _value = (*bytes & 0b1111);
  }

  else if ((*bytes & 0b11111000) == 0b11110000) {
    continue_bytes = 3;
    _value = (*bytes & 0b111);
  }

  else {
    // Invalid leading byte
    return -1;
  }

  // now add the continuation bytes to the _value
  while (continue_bytes--) {
    bytes++, byte_count++;

    if ((*bytes & 0b11000000) != 0b10000000) return -1;

    _value = (_value << 6) | (*bytes & 0b00111111);
  }

  *value = _value;
  return byte_count;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl $0x1, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
andl $0xc0, %eax
cmpl $0x80, %eax
jne 0x14412
movq -0x10(%rsp), %rax
movzbl (%rax), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movl -0x20(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x14521
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0x1443f
movl $0x1, -0x1c(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
andl $0x1f, %eax
movl %eax, -0x24(%rsp)
jmp 0x144a7
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0x1446c
movl $0x2, -0x1c(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
andl $0xf, %eax
movl %eax, -0x24(%rsp)
jmp 0x144a5
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
andl $0xf8, %eax
cmpl $0xf0, %eax
jne 0x14499
movl $0x3, -0x1c(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
andl $0x7, %eax
movl %eax, -0x24(%rsp)
jmp 0x144a3
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x14521
jmp 0x144a5
jmp 0x144a7
jmp 0x144a9
jmp 0x144ab
movl -0x1c(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rsp)
cmpl $0x0, %eax
je 0x1450e
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
andl $0xc0, %eax
cmpl $0x80, %eax
je 0x144f4
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x14521
movl -0x24(%rsp), %eax
shll $0x6, %eax
movq -0x10(%rsp), %rcx
movzbl (%rcx), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movl %eax, -0x24(%rsp)
jmp 0x144ab
movl -0x24(%rsp), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movl -0x20(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: exprAttrib
static void exprAttrib(Compiler* compiler) {
  consume(compiler, TK_NAME, "Expected an attribute name after '.'.");
  const char* name = compiler->previous.start;
  int length = compiler->previous.length;

  // Store the name in script's names.
  int index = scriptAddName(compiler->script, compiler->vm, name, length);

  if (compiler->l_value && matchAssignment(compiler)) {
    skipNewLines(compiler);

    TokenType assignment = compiler->previous.type;
    if (assignment != TK_EQ) {
      emitOpcode(compiler, OP_GET_ATTRIB_KEEP);
      emitShort(compiler, index);
      compileExpression(compiler);
      emitAssignment(compiler, assignment);
    } else {
      compileExpression(compiler);
    }

    emitOpcode(compiler, OP_SET_ATTRIB);
    emitShort(compiler, index);

  } else {
    emitOpcode(compiler, OP_GET_ATTRIB);
    emitShort(compiler, index);
  }

  compiler->is_last_call = false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x47, %esi
leaq 0x16f95(%rip), %rdx     # 0x2b4df
callq 0x160a0
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movl 0x40(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq 0x18b0(%rax), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rdx
movl 0x14(%rsp), %ecx
callq 0x4c60
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x38cd(%rax)
je 0x1462e
movq 0x20(%rsp), %rdi
callq 0x18490
testb $0x1, %al
jne 0x145b1
jmp 0x1462e
movq 0x20(%rsp), %rdi
callq 0x15f40
movq 0x20(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0xc(%rsp)
cmpl $0x1a, 0xc(%rsp)
je 0x14605
movq 0x20(%rsp), %rdi
movl $0x31, %esi
callq 0x16650
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x16690
movq 0x20(%rsp), %rdi
callq 0x17be0
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x18670
jmp 0x1460f
movq 0x20(%rsp), %rdi
callq 0x17be0
movq 0x20(%rsp), %rdi
movl $0x32, %esi
callq 0x16650
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x16690
jmp 0x1464b
movq 0x20(%rsp), %rdi
movl $0x30, %esi
callq 0x16650
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x16690
movq 0x20(%rsp), %rax
movb $0x0, 0x38ce(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: exprGrouping
static void exprGrouping(Compiler* compiler) {
  skipNewLines(compiler);
  compileExpression(compiler);
  skipNewLines(compiler);
  consume(compiler, TK_RPARAN, "Expected ')' after expression.");

  compiler->is_last_call = false;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x15f40
movq (%rsp), %rdi
callq 0x17be0
movq (%rsp), %rdi
callq 0x15f40
movq (%rsp), %rdi
movl $0xa, %esi
leaq 0x16bbf(%rip), %rdx     # 0x2b45f
callq 0x160a0
movq (%rsp), %rax
movb $0x0, 0x38ce(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: exprCall
static void exprCall(Compiler* compiler) {

  // Compile parameters.
  int argc = 0;
  if (!match(compiler, TK_RPARAN)) {
    do {
      skipNewLines(compiler);
      compileExpression(compiler);
      skipNewLines(compiler);
      argc++;
    } while (match(compiler, TK_COMMA));
    consume(compiler, TK_RPARAN, "Expected ')' after parameter list.");
  }

  emitOpcode(compiler, OP_CALL);
  emitByte(compiler, argc);

  compiler->is_last_call = true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0xa, %esi
callq 0x15f50
testb $0x1, %al
jne 0x14938
jmp 0x148e6
movq 0x10(%rsp), %rdi
callq 0x15f40
movq 0x10(%rsp), %rdi
callq 0x17be0
movq 0x10(%rsp), %rdi
callq 0x15f40
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x5, %esi
callq 0x15f50
testb $0x1, %al
jne 0x148e6
movq 0x10(%rsp), %rdi
movl $0xa, %esi
leaq 0x167cc(%rip), %rdx     # 0x2b0ff
callq 0x160a0
movq 0x10(%rsp), %rdi
movl $0x27, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x166d0
movq 0x10(%rsp), %rax
movb $0x1, 0x38ce(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)