LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_core.c
// Function: pkModuleAddFunction
void pkModuleAddFunction(PKVM* vm, PkHandle* module, const char* name,
                         pkNativeFn fptr, int arity) {
  __ASSERT(module != NULL, "Argument module was NULL.");
  Var scr = module->value;
  __ASSERT(IS_OBJ_TYPE(scr, OBJ_SCRIPT), "Given handle is not a module");
  moduleAddFunctionInternal(vm, (Script*)AS_OBJ(scr), name, fptr, arity,
                            NULL /*TODO: Public API for function docstring.*/);
}

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0x1333d
movq (%rsi), %rsi
movq %rsi, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x13338
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rax, %rsi
cmpl $0x4, (%rsi)
jne 0x13338
xorl %r9d, %r9d
popq %rax
jmp 0x13342
callq 0x526d
callq 0x52a1
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_core.c
// Function: moduleAddFunctionInternal
static void moduleAddFunctionInternal(PKVM* vm, Script* script,
                                      const char* name, pkNativeFn fptr,
                                      int arity, const char* docstring) {

  // Ensure the name isn't predefined.
  assertModuleNameDef(vm, script, name);

  Function* fn = newFunction(vm, name, (int)strlen(name),
                             script, true, docstring);
  fn->native = fptr;
  fn->arity = arity;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
callq 0x194b5
movq %r15, %rdi
callq 0x2140
movq %r13, %rdi
movq %r15, %rsi
movl %eax, %edx
movq %r12, %rcx
movl $0x1, %r8d
movq %rbx, %r9
callq 0x929e
movq %r14, 0x38(%rax)
movl %ebp, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_core.c
// Function: pkGetFunction
PkHandle* pkGetFunction(PKVM* vm, PkHandle* module,
                                  const char* name) {
  __ASSERT(module != NULL, "Argument module was NULL.");
  Var scr = module->value;
  __ASSERT(IS_OBJ_TYPE(scr, OBJ_SCRIPT), "Given handle is not a module");
  Script* script = (Script*)AS_OBJ(scr);

  for (uint32_t i = 0; i < script->functions.count; i++) {
    const char* fn_name = script->functions.data[i]->name;
    if (strcmp(name, fn_name) == 0) {
      return vmNewHandle(vm, VAR_OBJ(script->functions.data[i]));
    }
  }

  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
testq %rsi, %rsi
je 0x13459
movq (%rsi), %r13
movq %r13, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x13454
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rax, %r13
cmpl $0x4, (%r13)
jne 0x13454
cmpl $0x0, 0x48(%r13)
je 0x1343f
movq %rdx, %rbx
movabsq $-0x4000000000001, %rax # imm = 0xFFFBFFFFFFFFFFFF
incq %rax
movq %rax, 0x8(%rsp)
xorl %r14d, %r14d
movq 0x40(%r13), %rax
movq (%rax,%r14,8), %r12
movq 0x10(%r12), %rsi
movq %rbx, %rdi
callq 0x2230
movl %eax, %ebp
testl %eax, %eax
jne 0x1342f
orq 0x8(%rsp), %r12
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0xb6ca
movq %rax, %r15
testl %ebp, %ebp
je 0x13442
incq %r14
movl 0x48(%r13), %eax
cmpq %rax, %r14
jb 0x133ff
xorl %r15d, %r15d
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x52d5
callq 0x5309
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_core.c
// Function: pkCheckArgcRange
bool pkCheckArgcRange(PKVM* vm, int argc, int min, int max) {
  ASSERT(min <= max, "invalid argc range (min > max).");

  if (argc < min) {
    char buff[STR_INT_BUFF_SIZE]; sprintf(buff, "%d", min);
    VM_SET_ERROR(vm, stringFormat(vm, "Expected at least %s argument(s).",
                                       buff));
    return false;

  } else if (argc > max) {
    char buff[STR_INT_BUFF_SIZE]; sprintf(buff, "%d", max);
    VM_SET_ERROR(vm, stringFormat(vm, "Expected at most %s argument(s).",
                                       buff));
    return false;
  }

  return true;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
cmpl %ecx, %edx
jg 0x13514
movq %rdi, %rbx
cmpl %edx, %esi
jge 0x134be
leaq 0xd552(%rip), %rsi      # 0x209ed
leaq 0xc(%rsp), %rdi
xorl %eax, %eax
callq 0x2360
movq 0x5f0(%rbx), %rax
cmpq $0x0, 0x58(%rax)
jne 0x13519
leaq 0xb4ce(%rip), %rsi      # 0x1e98a
jmp 0x134ef
movb $0x1, %bpl
cmpl %ecx, %esi
jle 0x1350b
leaq 0xd521(%rip), %rsi      # 0x209ed
leaq 0xc(%rsp), %rdi
movl %ecx, %edx
xorl %eax, %eax
callq 0x2360
movq 0x5f0(%rbx), %rax
cmpq $0x0, 0x58(%rax)
jne 0x1351e
leaq 0xb4bd(%rip), %rsi      # 0x1e9ac
xorl %ebp, %ebp
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x95d0
movq 0x5f0(%rbx), %rcx
movq %rax, 0x58(%rcx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
callq 0x53df
callq 0x53a9
callq 0x5373
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_core.c
// Function: pkGetArgBool
bool pkGetArgBool(PKVM* vm, int arg, bool* value) {
  CHECK_GET_ARG_API_ERRORS();

  Var val = ARG(arg);
  *value = toBool(val);
  return true;
}

// Assembly:
pushq %rbx
movq 0x5f0(%rdi), %rax
testq %rax, %rax
je 0x135a1
movq %rdx, %rbx
testl %esi, %esi
je 0x13581
jle 0x1359c
movq 0x30(%rax), %rcx
subq 0x38(%rax), %rcx
shrq $0x3, %rcx
cmpl %esi, %ecx
jle 0x1359c
testq %rbx, %rbx
je 0x135a6
movq 0x38(%rax), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rdi
callq 0xb43d
movb %al, (%rbx)
movb $0x1, %al
popq %rbx
retq
callq 0x5481
callq 0x54ed
callq 0x54b7
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_core.c
// Function: pkGetArgNumber
bool pkGetArgNumber(PKVM* vm, int arg, double* value) {
  CHECK_GET_ARG_API_ERRORS();

  Var val = ARG(arg);
  if (IS_NUM(val)) {
    *value = AS_NUM(val);

  } else if (IS_BOOL(val)) {
    *value = AS_BOOL(val) ? 1 : 0;

  } else {
    ERR_INVALID_ARG_TYPE("number");
    return false;
  }

  return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x5f0(%rdi), %rax
testq %rax, %rax
je 0x136d9
movq %rdx, %r14
movl %esi, %edx
movq %rdi, %rbx
testl %esi, %esi
je 0x135e9
jle 0x136d4
movq 0x30(%rax), %rcx
subq 0x38(%rax), %rcx
shrq $0x3, %rcx
cmpl %edx, %ecx
jle 0x136d4
testq %r14, %r14
je 0x136de
movq 0x38(%rax), %rcx
movslq %edx, %rsi
movq (%rcx,%rsi,8), %rdi
movq %rdi, %rcx
notq %rcx
movabsq $0x7ffc000000000000, %rsi # imm = 0x7FFC000000000000
testq %rsi, %rcx
jne 0x1363e
movq %rdi, %rcx
shrq %rcx
movabsq $0x3ffe800000000001, %rsi # imm = 0x3FFE800000000001
cmpq %rsi, %rcx
jne 0x1364d
movabsq $0x7ffd000000000002, %rax # imm = 0x7FFD000000000002
incq %rax
cmpq %rax, %rdi
je 0x13693
xorps %xmm0, %xmm0
jmp 0x13643
callq 0x9060
movsd %xmm0, (%r14)
movb $0x1, %bpl
jmp 0x136c9
testl %edx, %edx
je 0x1369d
leaq 0xd395(%rip), %rsi      # 0x209ed
leaq 0x4(%rsp), %rdi
xorl %eax, %eax
callq 0x2360
movq 0x5f0(%rbx), %rax
cmpq $0x0, 0x58(%rax)
jne 0x136e3
leaq 0xb3ac(%rip), %rsi      # 0x1ea25
leaq 0xb3c3(%rip), %rdx      # 0x1ea43
xorl %ebp, %ebp
leaq 0x4(%rsp), %rcx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x95d0
jmp 0x136be
movsd 0x9a25(%rip), %xmm0     # 0x1d0c0
jmp 0x13643
cmpq $0x0, 0x58(%rax)
jne 0x136e8
leaq 0xb39f(%rip), %rsi      # 0x1ea4a
leaq 0xb391(%rip), %rdx      # 0x1ea43
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x95d0
movq 0x5f0(%rbx), %rcx
movq %rax, 0x58(%rcx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x5523
callq 0x55fb
callq 0x55c5
callq 0x5559
callq 0x558f
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_core.c
// Function: pkGetArgString
bool pkGetArgString(PKVM* vm, int arg, const char** value, uint32_t* length) {
  CHECK_GET_ARG_API_ERRORS();

  Var val = ARG(arg);
  if (IS_OBJ_TYPE(val, OBJ_STRING)) {
    String* str = (String*)AS_OBJ(val);
    *value = str->data;
    if (length) *length = str->length;

  } else {
    ERR_INVALID_ARG_TYPE("string");
    return false;
  }

  return true;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movl %esi, %eax
movq 0x5f0(%rdi), %rsi
testq %rsi, %rsi
je 0x137f4
movq %rdi, %rbx
testl %eax, %eax
je 0x13726
jle 0x137ef
movq 0x30(%rsi), %rdi
subq 0x38(%rsi), %rdi
shrq $0x3, %rdi
cmpl %eax, %edi
jle 0x137ef
testq %rdx, %rdx
je 0x137f9
movq 0x38(%rsi), %rdi
movslq %eax, %r8
movq (%rdi,%r8,8), %rdi
movq %rdi, %r8
shrq $0x32, %r8
cmpl $0x3fff, %r8d           # imm = 0x3FFF
jb 0x1375c
movabsq $0xffffffffffff, %r8    # imm = 0xFFFFFFFFFFFF
andq %r8, %rdi
cmpl $0x0, (%rdi)
je 0x137d9
testl %eax, %eax
je 0x137a4
leaq 0xd286(%rip), %rsi      # 0x209ed
leaq 0xc(%rsp), %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x2360
movq 0x5f0(%rbx), %rax
cmpq $0x0, 0x58(%rax)
jne 0x137fe
leaq 0xb29b(%rip), %rsi      # 0x1ea25
leaq 0xb3db(%rip), %rdx      # 0x1eb6c
xorl %ebp, %ebp
leaq 0xc(%rsp), %rcx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x95d0
jmp 0x137c5
cmpq $0x0, 0x58(%rsi)
jne 0x13803
leaq 0xb298(%rip), %rsi      # 0x1ea4a
leaq 0xb3b3(%rip), %rdx      # 0x1eb6c
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x95d0
movq 0x5f0(%rbx), %rcx
movq %rax, 0x58(%rcx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1c(%rdi), %rax
movq %rax, (%rdx)
movb $0x1, %bpl
testq %rcx, %rcx
je 0x137d0
movl 0x14(%rdi), %eax
movl %eax, (%rcx)
jmp 0x137d0
callq 0x5631
callq 0x5709
callq 0x56d3
callq 0x5667
callq 0x569d
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_core.c
// Function: pkGetArgInst
bool pkGetArgInst(PKVM* vm, int arg, uint32_t id, void** value) {
  CHECK_GET_ARG_API_ERRORS();

  Var val = ARG(arg);
  bool is_native_instance = false;

  if (IS_OBJ_TYPE(val, OBJ_INST)) {
    Instance* inst = ((Instance*)AS_OBJ(val));
    if (inst->is_native && inst->native_id == id) {
      *value = inst->native;
      is_native_instance = true;
    }
  }

  if (!is_native_instance) {
    const char* ty_name = "$(?)";
    if (vm->config.inst_name_fn != NULL) {
      ty_name = vm->config.inst_name_fn(id);
    }

    ERR_INVALID_ARG_TYPE(ty_name);
    return false;
  }

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0x5f0(%rdi), %rax
testq %rax, %rax
je 0x1393b
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
je 0x13845
jle 0x13936
movq 0x30(%rax), %rsi
subq 0x38(%rax), %rsi
shrq $0x3, %rsi
cmpl %ebp, %esi
jle 0x13936
testq %rcx, %rcx
je 0x13940
movq 0x38(%rax), %rax
movslq %ebp, %rsi
movq (%rax,%rsi,8), %rax
movq %rax, %rsi
shrq $0x32, %rsi
cmpl $0x3fff, %esi           # imm = 0x3FFF
jb 0x13891
movabsq $0xffffffffffff, %rsi   # imm = 0xFFFFFFFFFFFF
andq %rsi, %rax
cmpl $0x8, (%rax)
jne 0x13891
cmpb $0x1, 0x18(%rax)
jne 0x13891
cmpl %edx, 0x1c(%rax)
jne 0x13891
movq 0x20(%rax), %rax
movq %rax, (%rcx)
movb $0x1, %r14b
jmp 0x13894
xorl %r14d, %r14d
testb %r14b, %r14b
jne 0x13928
movq 0xf0(%rbx), %rax
testq %rax, %rax
je 0x138b2
movl %edx, %edi
callq *%rax
movq %rax, %r15
jmp 0x138b9
leaq 0x998c(%rip), %r15      # 0x1d245
testl %ebp, %ebp
je 0x138fb
leaq 0xd129(%rip), %rsi      # 0x209ed
leaq 0xc(%rsp), %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2360
movq 0x5f0(%rbx), %rax
cmpq $0x0, 0x58(%rax)
jne 0x13945
leaq 0xb13e(%rip), %rsi      # 0x1ea25
leaq 0xc(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x95d0
jmp 0x1391d
movq 0x5f0(%rbx), %rax
cmpq $0x0, 0x58(%rax)
jne 0x1394a
leaq 0xb13a(%rip), %rsi      # 0x1ea4a
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x95d0
movq 0x5f0(%rbx), %rcx
movq %rax, 0x58(%rcx)
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x573f
callq 0x5817
callq 0x57e1
callq 0x5775
callq 0x57ab
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_core.c
// Function: pkGetArgValue
bool pkGetArgValue(PKVM* vm, int arg, PkVarType type, PkVar* value) {
  CHECK_GET_ARG_API_ERRORS();

  Var val = ARG(arg);
  if (pkGetValueType((PkVar)&val) != type) {
    char buff[STR_INT_BUFF_SIZE]; sprintf(buff, "%d", arg);
    VM_SET_ERROR(vm, stringFormat(vm, "Expected a $ at argument $.",
                 getPkVarTypeName(type), buff));
    return false;
  }

  *value = (PkVar)&val;
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x5f0(%rdi), %rax
testq %rax, %rax
je 0x13a2f
movq %rcx, %r12
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
testl %esi, %esi
je 0x13995
jle 0x13a2a
movq 0x30(%rax), %rcx
subq 0x38(%rax), %rcx
shrq $0x3, %rcx
cmpl %ebp, %ecx
jle 0x13a2a
testq %r12, %r12
je 0x13a34
movq 0x38(%rax), %rax
movslq %ebp, %rcx
movq (%rax,%rcx,8), %rax
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
movq %r13, %rdi
callq 0x7eec
movl %eax, %r15d
cmpl %ebx, %eax
jne 0x139c7
movq %r13, (%r12)
jmp 0x13a15
leaq 0xd01f(%rip), %rsi      # 0x209ed
leaq 0x4(%rsp), %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2360
movq 0x5f0(%r14), %rax
cmpq $0x0, 0x58(%rax)
jne 0x13a39
movl %ebx, %edi
callq 0xa9e2
leaq 0xb08c(%rip), %rsi      # 0x1ea84
leaq 0x4(%rsp), %rcx
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x95d0
movq 0x5f0(%r14), %rcx
movq %rax, 0x58(%rcx)
cmpl %ebx, %r15d
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x584d
callq 0x58ef
callq 0x58b9
callq 0x5883
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_core.c
// Function: pkFiberGetReturnValue
PkVar pkFiberGetReturnValue(const PkHandle* fiber) {
  __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);
  return (PkVar)_fiber->ret;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x13bb3
movq (%rdi), %rax
movq %rax, %rcx
shrq $0x32, %rcx
cmpl $0x3fff, %ecx           # imm = 0x3FFF
jb 0x13bae
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rax
cmpl $0x6, (%rax)
jne 0x13bae
movq 0x38(%rax), %rax
popq %rcx
retq
callq 0x595b
callq 0x5991
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_core.c
// Function: pkFiberIsDone
bool pkFiberIsDone(const PkHandle* fiber) {
  __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);
  return _fiber->state == FIBER_DONE;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x13bf0
movq (%rdi), %rax
movq %rax, %rcx
shrq $0x32, %rcx
cmpl $0x3fff, %ecx           # imm = 0x3FFF
jb 0x13beb
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rax
cmpl $0x6, (%rax)
jne 0x13beb
cmpl $0x3, 0x10(%rax)
sete %al
popq %rcx
retq
callq 0x59c7
callq 0x59fd
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_core.c
// Function: findBuiltinFunction
int findBuiltinFunction(const PKVM* vm, const char* name, uint32_t length) {
   for (uint32_t i = 0; i < vm->builtins_count; i++) {
     if (length == vm->builtins[i].length &&
       strncmp(name, vm->builtins[i].name, length) == 0) {
       return i;
     }
   }
   return -1;
 }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x5e8(%rdi), %r13d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %r13, %r13
je 0x13c52
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %r12d
addq $0x140, %r15            # imm = 0x140
xorl %ebx, %ebx
cmpl %ebp, (%r15)
jne 0x13c3d
movq -0x8(%r15), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x2090
testl %eax, %eax
je 0x13c50
incq %rbx
addq $0x18, %r15
cmpq %rbx, %r13
jne 0x13c25
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x13c52
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_core.c
// Function: getCoreLib
Script* getCoreLib(const PKVM* vm, String* name) {
  Var lib = mapGet(vm->core_libs, VAR_OBJ(name));
  if (IS_UNDEF(lib)) return NULL;
  ASSERT(IS_OBJ_TYPE(lib, OBJ_SCRIPT), OOPS);
  return (Script*)AS_OBJ(lib);
}

// Assembly:
pushq %rbx
movabsq $-0x4000000000001, %rbx # imm = 0xFFFBFFFFFFFFFFFF
movq 0x130(%rdi), %rdi
leaq 0x1(%rbx), %rax
orq %rax, %rsi
callq 0x9f27
movabsq $0x7ffd000000000000, %rcx # imm = 0x7FFD000000000000
cmpq %rcx, %rax
jne 0x13cce
xorl %eax, %eax
jmp 0x13ce5
cmpq %rbx, %rax
jbe 0x13ce7
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rax
cmpl $0x4, (%rax)
jne 0x13ce7
popq %rbx
retq
callq 0x5a9f
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_core.c
// Function: varSubtract
Var varSubtract(PKVM* vm, Var v1, Var v2) {
  double d1, d2;

  if (isNumeric(v1, &d1)) {
    if (validateNumeric(vm, v2, &d2, RIGHT_OPERAND)) {
      return VAR_NUM(d1 - d2);
    }
    return VAR_NULL;
  }

  UNSUPPORTED_OPERAND_TYPES("-");
  return VAR_NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movabsq $0x7ffc000000000000, %rbx # imm = 0x7FFC000000000000
movq %rsi, %rax
notq %rax
testq %rbx, %rax
jne 0x16e97
movq %r12, %rax
shrq %rax
movabsq $0x3ffe800000000001, %rcx # imm = 0x3FFE800000000001
cmpq %rcx, %rax
jne 0x16ea3
movabsq $0x7ffd000000000002, %rax # imm = 0x7FFD000000000002
incq %rax
cmpq %rax, %r12
je 0x16f5f
xorpd %xmm0, %xmm0
jmp 0x16e9f
movq %r12, %rdi
callq 0x9060
movb $0x1, %al
jmp 0x16ea5
xorl %eax, %eax
testb %al, %al
je 0x16ef2
movq %r15, %rax
notq %rax
testq %rax, %rbx
movsd %xmm0, (%rsp)
jne 0x16f49
movq %r15, %rax
shrq %rax
movabsq $0x3ffe800000000001, %rcx # imm = 0x3FFE800000000001
cmpq %rcx, %rax
jne 0x16f6c
movabsq $0x7ffd000000000002, %rax # imm = 0x7FFD000000000002
incq %rax
cmpq %rax, %r15
je 0x16fd3
xorpd %xmm1, %xmm1
jmp 0x16f5a
movq 0x5f0(%r14), %rax
cmpq $0x0, 0x58(%rax)
jne 0x16fe0
movq %r12, %rdi
callq 0xaa1a
movq %rax, %r12
movq %r15, %rdi
callq 0xaa1a
leaq 0x7d6c(%rip), %rsi      # 0x1ec8a
movq %r14, %rdi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x95d0
movq 0x5f0(%r14), %rcx
movq %rax, 0x58(%rcx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x9060
movapd %xmm0, %xmm1
movsd (%rsp), %xmm0
movb $0x1, %bpl
jmp 0x16f6e
movsd 0x6159(%rip), %xmm0     # 0x1d0c0
jmp 0x16e9f
xorl %ebp, %ebp
testb %bpl, %bpl
jne 0x16fbe
movsd %xmm1, 0x8(%rsp)
movq 0x5f0(%r14), %rax
cmpq $0x0, 0x58(%rax)
jne 0x16fe5
leaq 0x940c(%rip), %rsi      # 0x2039a
leaq 0x7ca1(%rip), %rdx      # 0x1ec36
movq %r14, %rdi
xorl %eax, %eax
callq 0x95d0
movq 0x5f0(%r14), %rcx
movq %rax, 0x58(%rcx)
testb %bpl, %bpl
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
je 0x16f39
subsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x905b
movsd 0x60e5(%rip), %xmm1     # 0x1d0c0
jmp 0x16f5a
callq 0x666f
callq 0x66a5
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_core.c
// Function: varModulo
Var varModulo(PKVM* vm, Var v1, Var v2) {
  double d1, d2;

  if (isNumeric(v1, &d1)) {
    if (validateNumeric(vm, v2, &d2, RIGHT_OPERAND)) {
      return VAR_NUM(fmod(d1, d2));
    }
    return VAR_NULL;
  }

  if (IS_OBJ_TYPE(v1, OBJ_STRING)) {
    //const String* str = (const String*)AS_OBJ(v1);
    TODO; // "fmt" % v2.
  }

  UNSUPPORTED_OPERAND_TYPES("%");
  return VAR_NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movabsq $0x7ffc000000000000, %rbx # imm = 0x7FFC000000000000
movq %rsi, %rax
notq %rax
testq %rbx, %rax
jne 0x173a0
movq %r12, %rax
shrq %rax
movabsq $0x3ffe800000000001, %rcx # imm = 0x3FFE800000000001
cmpq %rcx, %rax
jne 0x173ac
movabsq $0x7ffd000000000002, %rax # imm = 0x7FFD000000000002
incq %rax
cmpq %rax, %r12
je 0x17482
xorps %xmm0, %xmm0
jmp 0x173a8
movq %r12, %rdi
callq 0x9060
movb $0x1, %al
jmp 0x173ae
xorl %eax, %eax
testb %al, %al
je 0x173fd
movq %r15, %rax
notq %rax
testq %rax, %rbx
movsd %xmm0, (%rsp)
jne 0x1746d
movq %r15, %rax
shrq %rax
movabsq $0x3ffe800000000001, %rcx # imm = 0x3FFE800000000001
cmpq %rcx, %rax
jne 0x1748f
movabsq $0x7ffd000000000002, %rax # imm = 0x7FFD000000000002
incq %rax
cmpq %rax, %r15
je 0x17503
xorps %xmm1, %xmm1
jmp 0x1747d
movq %r12, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x17421
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %r12, %rax
cmpl $0x0, (%rax)
je 0x17515
movq 0x5f0(%r14), %rax
cmpq $0x0, 0x58(%rax)
jne 0x17510
movq %r12, %rdi
callq 0xaa1a
movq %rax, %r12
movq %r15, %rdi
callq 0xaa1a
leaq 0x78f6(%rip), %rsi      # 0x1ed43
movq %r14, %rdi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x95d0
movq 0x5f0(%r14), %rcx
movq %rax, 0x58(%rcx)
jmp 0x174f3
movq %r15, %rdi
callq 0x9060
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
movb $0x1, %bpl
jmp 0x17491
movsd 0x5c36(%rip), %xmm0     # 0x1d0c0
jmp 0x173a8
xorl %ebp, %ebp
testb %bpl, %bpl
jne 0x174dd
movsd %xmm1, 0x8(%rsp)
movq 0x5f0(%r14), %rax
cmpq $0x0, 0x58(%rax)
jne 0x1751a
leaq 0x8ee9(%rip), %rsi      # 0x2039a
leaq 0x777e(%rip), %rdx      # 0x1ec36
movq %r14, %rdi
xorl %eax, %eax
callq 0x95d0
movq 0x5f0(%r14), %rcx
movq %rax, 0x58(%rcx)
testb %bpl, %bpl
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
je 0x174f3
callq 0x21d0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x905b
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movsd 0x5bb5(%rip), %xmm1     # 0x1d0c0
jmp 0x1747d
callq 0x67b3
callq 0x67e9
callq 0x681f
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_core.c
// Function: varBitAnd
Var varBitAnd(PKVM* vm, Var v1, Var v2) {
  int64_t i1, i2;

  if (isInteger(v1, &i1)) {
    if (validateInteger(vm, v2, &i2, RIGHT_OPERAND)) {
      return VAR_NUM((double)(i1 & i2));
    }
    return VAR_NULL;
  }

  UNSUPPORTED_OPERAND_TYPES("&");
  return VAR_NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movabsq $0x7ffc000000000000, %rbx # imm = 0x7FFC000000000000
movq %rsi, %rax
notq %rax
testq %rbx, %rax
jne 0x1757c
movq %r12, %rax
shrq %rax
movabsq $0x3ffe800000000001, %rcx # imm = 0x3FFE800000000001
cmpq %rcx, %rax
jne 0x17589
movabsq $0x7ffd000000000002, %rax # imm = 0x7FFD000000000002
incq %rax
cmpq %rax, %r12
je 0x17671
xorpd %xmm0, %xmm0
jmp 0x17584
movq %r12, %rdi
callq 0x9060
movb $0x1, %bpl
jmp 0x1758b
xorl %ebp, %ebp
movapd %xmm0, (%rsp)
callq 0x2330
movapd (%rsp), %xmm2
ucomisd %xmm2, %xmm0
setnp %cl
sete %al
andb %cl, %al
andb %bpl, %al
cmpb $0x1, %al
jne 0x175d0
movapd 0x727b(%rip), %xmm0     # 0x1e830
andpd %xmm2, %xmm0
movsd 0x7257(%rip), %xmm1     # 0x1e818
ucomisd %xmm0, %xmm1
jb 0x1773f
cvttsd2si %xmm2, %r13
testb %al, %al
je 0x17618
movq %r15, %rax
notq %rax
testq %rax, %rbx
jne 0x17664
movq %r15, %rax
shrq %rax
movabsq $0x3ffe800000000001, %rcx # imm = 0x3FFE800000000001
cmpq %rcx, %rax
jne 0x1767e
movabsq $0x7ffd000000000002, %rax # imm = 0x7FFD000000000002
incq %rax
cmpq %rax, %r15
je 0x17732
xorpd %xmm0, %xmm0
jmp 0x1766c
movq 0x5f0(%r14), %rax
cmpq $0x0, 0x58(%rax)
jne 0x17744
movq %r12, %rdi
callq 0xaa1a
movq %rax, %r12
movq %r15, %rdi
callq 0xaa1a
leaq 0x773c(%rip), %rsi      # 0x1ed80
movq %r14, %rdi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x95d0
movq 0x5f0(%r14), %rcx
movq %rax, 0x58(%rcx)
jmp 0x17720
movq %r15, %rdi
callq 0x9060
movb $0x1, %r15b
jmp 0x17681
movsd 0x5a47(%rip), %xmm0     # 0x1d0c0
jmp 0x17584
xorl %r15d, %r15d
movapd %xmm0, (%rsp)
callq 0x2330
movapd (%rsp), %xmm2
ucomisd %xmm2, %xmm0
setnp %al
sete %bpl
andb %al, %bpl
andb %r15b, %bpl
cmpb $0x1, %bpl
jne 0x176cc
movapd 0x7181(%rip), %xmm0     # 0x1e830
andpd %xmm2, %xmm0
movsd 0x715d(%rip), %xmm1     # 0x1e818
ucomisd %xmm0, %xmm1
jb 0x17749
cvttsd2si %xmm2, %rax
jmp 0x176fd
movq 0x5f0(%r14), %rax
cmpq $0x0, 0x58(%rax)
jne 0x1774e
leaq 0x8d26(%rip), %rsi      # 0x20407
leaq 0x754e(%rip), %rdx      # 0x1ec36
movq %r14, %rdi
xorl %eax, %eax
callq 0x95d0
movq 0x5f0(%r14), %rcx
movq %rax, 0x58(%rcx)
testb %bpl, %bpl
je 0x17720
andq %r13, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x905b
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movsd 0x5986(%rip), %xmm0     # 0x1d0c0
jmp 0x1766c
callq 0x68f7
callq 0x6855
callq 0x68c1
callq 0x688b
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_core.c
// Function: varBitLshift
Var varBitLshift(PKVM* vm, Var v1, Var v2) {
  int64_t i1, i2;

  if (isInteger(v1, &i1)) {
    if (validateInteger(vm, v2, &i2, RIGHT_OPERAND)) {
      return VAR_NUM((double)(i1 << i2));
    }
    return VAR_NULL;
  }

  UNSUPPORTED_OPERAND_TYPES("<<");
  return VAR_NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movabsq $0x7ffc000000000000, %rbx # imm = 0x7FFC000000000000
movq %rsi, %rax
notq %rax
testq %rbx, %rax
jne 0x17c18
movq %r12, %rax
shrq %rax
movabsq $0x3ffe800000000001, %rcx # imm = 0x3FFE800000000001
cmpq %rcx, %rax
jne 0x17c25
movabsq $0x7ffd000000000002, %rax # imm = 0x7FFD000000000002
incq %rax
cmpq %rax, %r12
je 0x17d0d
xorpd %xmm0, %xmm0
jmp 0x17c20
movq %r12, %rdi
callq 0x9060
movb $0x1, %bpl
jmp 0x17c27
xorl %ebp, %ebp
movapd %xmm0, (%rsp)
callq 0x2330
movapd (%rsp), %xmm2
ucomisd %xmm2, %xmm0
setnp %cl
sete %al
andb %cl, %al
andb %bpl, %al
cmpb $0x1, %al
jne 0x17c6c
movapd 0x6bdf(%rip), %xmm0     # 0x1e830
andpd %xmm2, %xmm0
movsd 0x6bbb(%rip), %xmm1     # 0x1e818
ucomisd %xmm0, %xmm1
jb 0x17ddb
cvttsd2si %xmm2, %r13
testb %al, %al
je 0x17cb4
movq %r15, %rax
notq %rax
testq %rax, %rbx
jne 0x17d00
movq %r15, %rax
shrq %rax
movabsq $0x3ffe800000000001, %rcx # imm = 0x3FFE800000000001
cmpq %rcx, %rax
jne 0x17d1a
movabsq $0x7ffd000000000002, %rax # imm = 0x7FFD000000000002
incq %rax
cmpq %rax, %r15
je 0x17dce
xorpd %xmm0, %xmm0
jmp 0x17d08
movq 0x5f0(%r14), %rax
cmpq $0x0, 0x58(%rax)
jne 0x17de0
movq %r12, %rdi
callq 0xaa1a
movq %rax, %r12
movq %r15, %rdi
callq 0xaa1a
leaq 0x7159(%rip), %rsi      # 0x1ee39
movq %r14, %rdi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x95d0
movq 0x5f0(%r14), %rcx
movq %rax, 0x58(%rcx)
jmp 0x17dbc
movq %r15, %rdi
callq 0x9060
movb $0x1, %r15b
jmp 0x17d1d
movsd 0x53ab(%rip), %xmm0     # 0x1d0c0
jmp 0x17c20
xorl %r15d, %r15d
movapd %xmm0, (%rsp)
callq 0x2330
movapd (%rsp), %xmm2
ucomisd %xmm2, %xmm0
setnp %al
sete %bpl
andb %al, %bpl
andb %r15b, %bpl
cmpb $0x1, %bpl
jne 0x17d68
movapd 0x6ae5(%rip), %xmm0     # 0x1e830
andpd %xmm2, %xmm0
movsd 0x6ac1(%rip), %xmm1     # 0x1e818
ucomisd %xmm0, %xmm1
jb 0x17de5
cvttsd2si %xmm2, %rcx
jmp 0x17d99
movq 0x5f0(%r14), %rax
cmpq $0x0, 0x58(%rax)
jne 0x17dea
leaq 0x868a(%rip), %rsi      # 0x20407
leaq 0x6eb2(%rip), %rdx      # 0x1ec36
movq %r14, %rdi
xorl %eax, %eax
callq 0x95d0
movq 0x5f0(%r14), %rcx
movq %rax, 0x58(%rcx)
testb %bpl, %bpl
je 0x17dbc
shlq %cl, %r13
xorps %xmm0, %xmm0
cvtsi2sd %r13, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x905b
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movsd 0x52ea(%rip), %xmm0     # 0x1d0c0
jmp 0x17d08
callq 0x6b7f
callq 0x6add
callq 0x6b49
callq 0x6b13
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_core.c
// Function: varGreater
bool varGreater(Var v1, Var v2) {
  double d1, d2;

  if (isNumeric(v1, &d1) && isNumeric(v2, &d2)) {
    return d1 > d2;
  }

  TODO;
  return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movabsq $0x7ffc000000000000, %r14 # imm = 0x7FFC000000000000
movq %rdi, %rax
notq %rax
testq %r14, %rax
jne 0x1818f
movq %rdi, %rax
shrq %rax
movabsq $0x3ffe800000000001, %rcx # imm = 0x3FFE800000000001
cmpq %rcx, %rax
jne 0x1819c
movabsq $0x7ffd000000000002, %rax # imm = 0x7FFD000000000002
incq %rax
cmpq %rax, %rdi
je 0x18205
xorpd %xmm1, %xmm1
jmp 0x18198
callq 0x9060
movapd %xmm0, %xmm1
movb $0x1, %al
jmp 0x1819e
xorl %eax, %eax
testb %al, %al
je 0x18219
movq %rbx, %rax
notq %rax
testq %rax, %r14
jne 0x181da
movq %rbx, %rax
shrq %rax
movabsq $0x3ffe800000000001, %rcx # imm = 0x3FFE800000000001
cmpq %rcx, %rax
jne 0x181f0
movabsq $0x7ffd000000000002, %rax # imm = 0x7FFD000000000002
incq %rax
cmpq %rax, %rbx
je 0x1820f
xorpd %xmm0, %xmm0
jmp 0x181ec
movq %rbx, %rdi
movsd %xmm1, (%rsp)
callq 0x9060
movsd (%rsp), %xmm1
movb $0x1, %al
jmp 0x181f2
xorl %eax, %eax
testb %al, %al
je 0x18219
ucomisd %xmm0, %xmm1
seta %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movsd 0x4eb3(%rip), %xmm1     # 0x1d0c0
jmp 0x18198
movsd 0x4ea9(%rip), %xmm0     # 0x1d0c0
jmp 0x181ec
callq 0x6cf9
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_core.c
// Function: varContains
bool varContains(PKVM* vm, Var elem, Var container) {
  if (!IS_OBJ(container)) {
    VM_SET_ERROR(vm, stringFormat(vm, "'$' is not iterable.",
                 varTypeName(container)));
  }
  Object* obj = AS_OBJ(container);

  switch (obj->type) {
    case OBJ_STRING: {
      if (!IS_OBJ_TYPE(elem, OBJ_STRING)) {
        VM_SET_ERROR(vm, stringFormat(vm, "Expected a string operand."));
        return false;
      }

      String* sub = (String*)AS_OBJ(elem);
      String* str = (String*)AS_OBJ(container);
      if (sub->length > str->length) return false;

      TODO;

    } break;

    case OBJ_LIST: {
      List* list = (List*)AS_OBJ(container);
      for (uint32_t i = 0; i < list->elements.count; i++) {
        if (isValuesEqual(elem, list->elements.data[i])) return true;
      }
      return false;
    } break;

    case OBJ_MAP: {
      Map* map = (Map*)AS_OBJ(container);
      return !IS_UNDEF(mapGet(map, elem));
    } break;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rax
shrq $0x32, %rax
cmpl $0x3ffe, %eax           # imm = 0x3FFE
ja 0x1834d
movq 0x5f0(%r15), %rax
cmpq $0x0, 0x58(%rax)
jne 0x1843a
movq %rbx, %rdi
callq 0xaa1a
leaq 0x6ba8(%rip), %rsi      # 0x1eedd
movq %r15, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x95d0
movq 0x5f0(%r15), %rcx
movq %rax, 0x58(%rcx)
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rax, %rbx
movl (%rbx), %ecx
cmpq $0x8, %rcx
ja 0x1843f
leaq 0x64d3(%rip), %rdx      # 0x1e840
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movabsq $-0x4000000000001, %rcx # imm = 0xFFFBFFFFFFFFFFFF
cmpq %rcx, %r14
ja 0x18390
movq %r14, %rcx
andq %rax, %rcx
cmpl $0x0, (%rcx)
je 0x183fc
andq %rax, %r14
movl 0x14(%r14), %eax
cmpl 0x14(%rbx), %eax
jbe 0x18444
xorl %ebp, %ebp
jmp 0x18428
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9f27
movabsq $0x7ffd000000000000, %rcx # imm = 0x7FFD000000000000
cmpq %rcx, %rax
setne %bpl
jmp 0x18428
cmpl $0x0, 0x18(%rbx)
setne %bpl
je 0x18428
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0xaa90
testb %al, %al
jne 0x183f7
incq %r15
movl 0x18(%rbx), %eax
cmpq %rax, %r15
setb %bpl
jb 0x183d2
jmp 0x18428
movb $0x1, %bpl
jmp 0x18428
movq 0x5f0(%r15), %rax
cmpq $0x0, 0x58(%rax)
jne 0x18449
leaq 0x6ae1(%rip), %rsi      # 0x1eef2
xorl %ebp, %ebp
movq %r15, %rdi
xorl %eax, %eax
callq 0x95d0
movq 0x5f0(%r15), %rcx
movq %rax, 0x58(%rcx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x6d9b
callq 0x6d65
callq 0x6e3d
callq 0x6e07
callq 0x6dd1
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_core.c
// Function: assertModuleNameDef
static inline void assertModuleNameDef(PKVM* vm, Script* script,
                                       const char* name) {
  // Check if function with the same name already exists.
  if (scriptGetFunc(script, name, (uint32_t)strlen(name)) != -1) {
    __ASSERT(false, stringFormat(vm, "A function named '$' already esists "
      "on module '@'", name, script->module)->data);
  }

  // Check if a global variable with the same name already exists.
  if (scriptGetGlobals(script, name, (uint32_t)strlen(name)) != -1) {
    __ASSERT(false, stringFormat(vm, "A global variable named '$' already "
      "esists on module '@'", name, script->module)->data);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rdi
callq 0x2140
movq %r15, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0xa54c
cmpl $-0x1, %eax
jne 0x194fd
movq %rbx, %rdi
callq 0x2140
movq %r15, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0xa5d9
cmpl $-0x1, %eax
jne 0x1950b
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7ac2
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7b10
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/cli/main.c
// Function: errorFunction
void errorFunction(PKVM* vm, PkErrorType type, const char* file, int line,
                   const char* message) {

  VmUserData* ud = (VmUserData*)pkGetUserData(vm);
  bool repl = (ud) ? ud->repl_mode : false;

  if (type == PK_ERROR_COMPILE) {

    if (repl) fprintf(stderr, "Error: %s\n", message);
    else fprintf(stderr, "Error: %s\n       at \"%s\":%i\n",
                 message, file, line);

  } else if (type == PK_ERROR_RUNTIME) {
    fprintf(stderr, "Error: %s\n", message);

  } else if (type == PK_ERROR_STACKTRACE) {
    if (repl) fprintf(stderr, "  %s() [line:%i]\n", message, line);
    else fprintf(stderr, "  %s() [\"%s\":%i]\n", message, file, line);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r15d
callq 0xb6b2
testq %rax, %rax
je 0x1978a
cmpb $0x0, (%rax)
sete %al
jmp 0x1978c
movb $0x1, %al
cmpl $0x2, %r15d
je 0x197b4
cmpl $0x1, %r15d
je 0x197a8
testl %r15d, %r15d
je 0x197cb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x10849(%rip), %rax     # 0x29ff8
movq (%rax), %rdi
jmp 0x197fa
movq 0x1083d(%rip), %rcx     # 0x29ff8
movq (%rcx), %rdi
testb %al, %al
je 0x19815
leaq 0x6cb6(%rip), %rsi      # 0x2047f
jmp 0x197e0
movq 0x10826(%rip), %rcx     # 0x29ff8
movq (%rcx), %rdi
testb %al, %al
je 0x197fa
leaq 0x6c70(%rip), %rsi      # 0x20450
movq %rbx, %rdx
movq %r14, %rcx
movl %ebp, %r8d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2250
leaq 0x6c44(%rip), %rsi      # 0x20445
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2250
leaq 0x6c51(%rip), %rsi      # 0x2046d
movq %rbx, %rdx
movl %ebp, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2250
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/cli/main.c
// Function: readFunction
PkStringPtr readFunction(PKVM* vm) {
  PkStringPtr result;
  result.string = read_line(NULL);
  result.on_done = onResultDone;
  result.user_data = (void*)true;
  return result;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
callq 0x1a8ac
movq %rax, (%rbx)
leaq -0x109(%rip), %rax      # 0x19750
movq %rax, 0x8(%rbx)
movq $0x1, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/cli/main.c
// Function: resolvePath
PkStringPtr resolvePath(PKVM* vm, const char* from, const char* path) {
  PkStringPtr result;
  result.on_done = onResultDone;

  size_t from_dir_len;
  pathGetDirName(from, &from_dir_len);

  // FIXME: Should handle paths with size of more than FILENAME_MAX.

  if (from_dir_len == 0 || pathIsAbsolute(path)) {
    size_t length = strlen(path);

    char* resolved = (char*)malloc(length + 1);
    pathNormalize(path, resolved, length + 1);

    result.string = resolved;
    result.user_data = (void*)true;

  } else {
    char from_dir[FILENAME_MAX];
    strncpy(from_dir, from, from_dir_len);
    from_dir[from_dir_len] = '\0';

    char fullpath[FILENAME_MAX];
    size_t length = pathJoin(from_dir, path, fullpath, sizeof(fullpath));

    char* resolved = (char*)malloc(length + 1);
    pathNormalize(fullpath, resolved, length + 1);

    result.string = resolved;
    result.user_data = (void*)true;
  }

  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2010, %rsp           # imm = 0x2010
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq -0x13a(%rip), %rax      # 0x19750
movq %rax, 0x8(%rdi)
leaq 0x8(%rsp), %r12
movq %rdx, %rdi
movq %r12, %rsi
callq 0x19e58
cmpq $0x0, (%r12)
je 0x198b1
movq %r14, %rdi
callq 0x19e53
testb %al, %al
je 0x198d3
movq %r14, %rdi
callq 0x2140
leaq 0x1(%rax), %r15
movq %r15, %rdi
callq 0x22b0
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
jmp 0x19924
movq 0x8(%rsp), %r12
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2080
movb $0x0, 0x10(%rsp,%r12)
leaq 0x1010(%rsp), %r15
movl $0x1000, %ecx           # imm = 0x1000
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x19e62
leaq 0x1(%rax), %r14
movq %r14, %rdi
callq 0x22b0
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x19e5d
movq %r12, (%rbx)
movq $0x1, 0x10(%rbx)
movq %rbx, %rax
addq $0x2010, %rsp           # imm = 0x2010
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/cli/main.c
// Function: loadScript
PkStringPtr loadScript(PKVM* vm, const char* path) {

  PkStringPtr result;
  result.on_done = onResultDone;

  // Open the file.
  FILE* file = fopen(path, "r");
  if (file == NULL) {
    // Setting .string to NULL to indicate the failure of loading the script.
    result.string = NULL;
    return result;
  }

  // Get the source length.
  fseek(file, 0, SEEK_END);
  long file_size = ftell(file);
  fseek(file, 0, SEEK_SET);

  // Read source to buffer.
  char* buff = (char*)malloc((size_t)(file_size) + 1);
  // Using read instead of file_size is because "\r\n" is read as '\n' in
  // windows.
  size_t read = fread(buff, sizeof(char), file_size, file);
  buff[read] = '\0';
  fclose(file);

  result.string = buff;
  result.user_data = (void*)true;

  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x20a(%rip), %rax      # 0x19750
movq %rax, 0x8(%rdi)
leaq 0x5455(%rip), %rsi      # 0x1edba
movq %rdx, %rdi
callq 0x2310
testq %rax, %rax
je 0x199d4
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x22e0
movq %r14, %rdi
callq 0x2260
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x22e0
leaq 0x1(%r15), %rdi
callq 0x22b0
movq %rax, %r12
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x20c0
movb $0x0, (%r12,%rax)
movq %r14, %rdi
callq 0x2120
movq %r12, (%rbx)
movq $0x1, 0x10(%rbx)
jmp 0x199db
movq $0x0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/cli/modules.c
// Function: objGetAttrib
void objGetAttrib(PKVM* vm, void* instance, uint32_t id, PkStringPtr attrib) {
  Obj* obj = (Obj*)instance;
  ASSERT(obj->type == (ObjType)id, OOPS);

  if (obj->type == OBJ_FILE) {
    File* file = (File*)obj;
    if (strcmp(attrib.string, "closed") == 0) {
      pkReturnBool(vm, file->closed);
      return;
    }
  }

  return; // Attribute not found.
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl (%rsi), %eax
cmpl %edx, %eax
jne 0x19e00
cmpl $0x1, %eax
jne 0x19de4
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rax
movq (%rax), %rdi
leaq 0x68b9(%rip), %rsi      # 0x20694
callq 0x2230
testl %eax, %eax
je 0x19dec
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movzbl 0x14(%r14), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13a57
callq 0x7d27
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/cli/modules.c
// Function: freeObj
void freeObj(PKVM* vm, void* instance, uint32_t id) {
  Obj* obj = (Obj*)instance;
  ASSERT(obj->type == (ObjType)id, OOPS);

  // If the file isn't closed, close it to flush it's buffer.
  if (obj->type == OBJ_FILE) {
    File* file = (File*)obj;
    if (!file->closed) {
      if (fclose(file->fp) != 0) { /* TODO: error! */ }
      file->closed = true;
    }
  }

  FREE_OBJ(obj);
}

// Assembly:
pushq %rbx
movl (%rsi), %eax
cmpl %edx, %eax
jne 0x19e3d
movq %rsi, %rbx
cmpl $0x1, %eax
jne 0x19e34
cmpb $0x0, 0x14(%rbx)
jne 0x19e34
movq 0x8(%rbx), %rdi
callq 0x2120
movb $0x1, 0x14(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x2040
callq 0x7d8f
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/cli/modules.c
// Function: registerModulePath
void registerModulePath(PKVM* vm) {
  PkHandle* path = pkNewModule(vm, "path");

  pkModuleAddFunction(vm, path, "setunix",   _pathSetStyleUnix, 1);
  pkModuleAddFunction(vm, path, "getcwd",    _pathGetCWD,       0);
  pkModuleAddFunction(vm, path, "abspath",   _pathAbspath,      1);
  pkModuleAddFunction(vm, path, "relpath",   _pathRelpath,      2);
  pkModuleAddFunction(vm, path, "join",      _pathJoin,        -1);
  pkModuleAddFunction(vm, path, "normalize", _pathNormalize,    1);
  pkModuleAddFunction(vm, path, "basename",  _pathBaseName,     1);
  pkModuleAddFunction(vm, path, "dirname",   _pathDirName,      1);
  pkModuleAddFunction(vm, path, "isabspath", _pathIsPathAbs,    1);
  pkModuleAddFunction(vm, path, "getext",    _pathGetExtension, 1);
  pkModuleAddFunction(vm, path, "exists",    _pathExists,       1);
  pkModuleAddFunction(vm, path, "isfile",    _pathIsFile,       1);
  pkModuleAddFunction(vm, path, "isdir",     _pathIsDir,        1);

  pkReleaseHandle(vm, path);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x684d(%rip), %rsi      # 0x206c2
callq 0x131a0
movq %rax, %r14
leaq 0x682c(%rip), %rdx      # 0x206b0
leaq 0x194(%rip), %rcx       # 0x1a01f
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %r8d
callq 0x13309
leaq 0x6815(%rip), %rdx      # 0x206b8
leaq 0x195(%rip), %rcx       # 0x1a03f
movq %rbx, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x13309
leaq 0x682a(%rip), %rdx      # 0x206e9
leaq 0x1ac(%rip), %rcx       # 0x1a072
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
callq 0x13309
leaq 0x67e1(%rip), %rdx      # 0x206bf
leaq 0x202(%rip), %rcx       # 0x1a0e7
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %r8d
callq 0x13309
leaq 0x67ca(%rip), %rdx      # 0x206c7
leaq 0x2c3(%rip), %rcx       # 0x1a1c7
movq %rbx, %rdi
movq %r14, %rsi
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x13309
leaq 0x67b0(%rip), %rdx      # 0x206cc
leaq 0x347(%rip), %rcx       # 0x1a26a
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
callq 0x13309
leaq 0x679b(%rip), %rdx      # 0x206d6
leaq 0x37a(%rip), %rcx       # 0x1a2bc
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
callq 0x13309
leaq 0x6785(%rip), %rdx      # 0x206df
leaq 0x3a1(%rip), %rcx       # 0x1a302
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
callq 0x13309
leaq 0x676e(%rip), %rdx      # 0x206e7
leaq 0x3cb(%rip), %rcx       # 0x1a34b
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
callq 0x13309
leaq 0x6759(%rip), %rdx      # 0x206f1
leaq 0x3e4(%rip), %rcx       # 0x1a383
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
callq 0x13309
leaq 0x5039(%rip), %rdx      # 0x1eff0
leaq 0x41b(%rip), %rcx       # 0x1a3d9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
callq 0x13309
leaq 0x6722(%rip), %rdx      # 0x206f8
leaq 0x465(%rip), %rcx       # 0x1a442
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
callq 0x13309
leaq 0x670a(%rip), %rdx      # 0x206ff
leaq 0x499(%rip), %rcx       # 0x1a495
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
callq 0x13309
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb734
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/cli/modules.c
// Function: pathAbspath
static void _pathAbspath(PKVM* vm) {
  const char* path;
  if (!pkGetArgString(vm, 1, &path, NULL)) return;

  char abspath[FILENAME_MAX];
  size_t len = pathAbs(path, abspath, sizeof(abspath));
  pkReturnStringLength(vm, abspath, len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2018, %rsp           # imm = 0x2018
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
xorl %ecx, %ecx
callq 0x136ed
testb %al, %al
je 0x1a0d8
movq 0x8(%rsp), %r14
leaq 0x1010(%rsp), %r15
movl $0x1000, %esi           # imm = 0x1000
movq %r15, %rdi
callq 0x21b0
leaq 0x10(%rsp), %r12
movl $0x1000, %ecx           # imm = 0x1000
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1acc4
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x13adf
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/cli/modules.c
// Function: pathRelpath
static void _pathRelpath(PKVM* vm) {
  const char* from, * path;
  if (!pkGetArgString(vm, 1, &from, NULL)) return;
  if (!pkGetArgString(vm, 2, &path, NULL)) return;

  char abs_from[FILENAME_MAX];
  pathAbs(from, abs_from, sizeof(abs_from));

  char abs_path[FILENAME_MAX];
  pathAbs(path, abs_path, sizeof(abs_path));

  char result[FILENAME_MAX];
  size_t len = cwk_path_get_relative(abs_from, abs_path,
    result, sizeof(result));
  pkReturnStringLength(vm, result, len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3010, %rsp           # imm = 0x3010
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
xorl %ecx, %ecx
callq 0x136ed
testb %al, %al
je 0x1a1b6
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x136ed
testb %al, %al
je 0x1a1b6
movq 0x8(%rsp), %r15
leaq 0x10(%rsp), %r12
movl $0x1000, %esi           # imm = 0x1000
movq %r12, %rdi
callq 0x21b0
leaq 0x2010(%rsp), %r14
movl $0x1000, %ecx           # imm = 0x1000
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1acc4
movq (%rsp), %r15
leaq 0x10(%rsp), %r12
movl $0x1000, %esi           # imm = 0x1000
movq %r12, %rdi
callq 0x21b0
leaq 0x1010(%rsp), %r13
movl $0x1000, %ecx           # imm = 0x1000
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x1acc4
leaq 0x10(%rsp), %r15
movl $0x1000, %ecx           # imm = 0x1000
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x1afb5
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x13adf
addq $0x3010, %rsp           # imm = 0x3010
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/cli/modules.c
// Function: pathJoin
static void _pathJoin(PKVM* vm) {
  const char* paths[MAX_JOIN_PATHS + 1]; // +1 for NULL.
  int argc = pkGetArgc(vm);

  if (argc > MAX_JOIN_PATHS) {
    pkSetRuntimeError(vm, "Cannot join more than " STRINGIFY(MAX_JOIN_PATHS)
                           "paths.");
    return;
  }

  for (int i = 0; i < argc; i++) {
    pkGetArgString(vm, i + 1, &paths[i], NULL);
  }
  paths[argc] = NULL;

  char result[FILENAME_MAX];
  size_t len = cwk_path_join_multiple(paths, result, sizeof(result));
  pkReturnStringLength(vm, result, len);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1050, %rsp           # imm = 0x1050
movq %rdi, %rbx
callq 0x1345e
cmpl $0x8, %eax
jle 0x1a201
leaq 0x652b(%rip), %rsi      # 0x20715
movq %rbx, %rdi
addq $0x1050, %rsp           # imm = 0x1050
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xe3b6
movl %eax, %ebp
testl %eax, %eax
jle 0x1a22c
movq %rsp, %r14
movl %ebp, %r12d
xorl %r15d, %r15d
incq %r15
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x136ed
addq $0x8, %r14
cmpq %r15, %r12
jne 0x1a210
movslq %ebp, %rax
movq $0x0, (%rsp,%rax,8)
movq %rsp, %rdi
leaq 0x50(%rsp), %r14
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rsi
callq 0x1b535
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x13adf
addq $0x1050, %rsp           # imm = 0x1050
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/cli/modules.c
// Function: pathNormalize
static void _pathNormalize(PKVM* vm) {
  const char* path;
  if (!pkGetArgString(vm, 1, &path, NULL)) return;

  char result[FILENAME_MAX];
  size_t len = cwk_path_normalize(path, result, sizeof(result));
  pkReturnStringLength(vm, result, len);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1018, %rsp           # imm = 0x1018
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
xorl %ecx, %ecx
callq 0x136ed
testb %al, %al
je 0x1a2b1
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %r14
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rsi
callq 0x1be20
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x13adf
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r14
retq