LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1c48b
movq 0x16ba0(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xdcee(%rip), %rsi      # 0x2a150
leaq 0xe206(%rip), %rdx      # 0x2a66f
leaq 0xf7f0(%rip), %rcx      # 0x2bc60
leaq 0xf61f(%rip), %r8       # 0x2ba96
movl $0x137, %r9d            # imm = 0x137
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1c48d
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x8(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x1c4cc
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x8(%rsp), %rax
cmpl $0x6, (%rax)
je 0x1c506
movq 0x16b25(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xdc73(%rip), %rsi      # 0x2a150
leaq 0xf792(%rip), %rdx      # 0x2bc76
leaq 0xf775(%rip), %rcx      # 0x2bc60
leaq 0xf5a4(%rip), %r8       # 0x2ba96
movl $0x139, %r9d            # imm = 0x139
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1c508
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x38(%rax), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1c57b
movq 0x16ab0(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xdbfe(%rip), %rsi      # 0x2a150
leaq 0xe116(%rip), %rdx      # 0x2a66f
leaq 0xf732(%rip), %rcx      # 0x2bc92
leaq 0xf52f(%rip), %r8       # 0x2ba96
movl $0x13f, %r9d            # imm = 0x13F
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1c57d
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x8(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x1c5bc
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x8(%rsp), %rax
cmpl $0x6, (%rax)
je 0x1c5f6
movq 0x16a35(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xdb83(%rip), %rsi      # 0x2a150
leaq 0xf6a2(%rip), %rdx      # 0x2bc76
leaq 0xf6b7(%rip), %rcx      # 0x2bc92
leaq 0xf4b4(%rip), %r8       # 0x2ba96
movl $0x141, %r9d            # imm = 0x141
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1c5f8
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x3, 0x10(%rax)
sete %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x5e8(%rcx), %eax
jae 0x1c6b2
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
addq $0x138, %rcx            # imm = 0x138
movl 0x8(%rsp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jne 0x1c6a3
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
addq $0x138, %rax            # imm = 0x138
movl 0x8(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movl 0xc(%rsp), %eax
movl %eax, %edx
callq 0x2080
cmpl $0x0, %eax
jne 0x1c6a3
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x1c6ba
jmp 0x1c6a5
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x1c63a
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x130(%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 0x1c835
movq $0x0, 0x20(%rsp)
jmp 0x1c8b9
jmp 0x1c837
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x8(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x1c869
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x8(%rsp), %rax
cmpl $0x4, (%rax)
je 0x1c8a3
movq 0x16788(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xd8d6(%rip), %rsi      # 0x2a150
leaq 0xd9e3(%rip), %rdx      # 0x2a264
leaq 0xf442(%rip), %rcx      # 0x2bcca
leaq 0xf207(%rip), %r8       # 0x2ba96
movl $0x1b7, %r9d            # imm = 0x1B7
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1c8a5
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_core.c
// Function: initializeBuiltinFN
static void initializeBuiltinFN(PKVM* vm, BuiltinFn* bfn, const char* name,
                                int length, int arity, pkNativeFn ptr,
                                const char* docstring) {
  bfn->name = name;
  bfn->length = length;

  bfn->fn = newFunction(vm, name, length, NULL, true, docstring);
  bfn->fn->arity = arity;
  bfn->fn->native = ptr;
}

// Assembly:
subq $0x28, %rsp
movq 0x30(%rsp), %rax
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl %r8d, 0x8(%rsp)
movq %r9, (%rsp)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
movq 0x30(%rsp), %r9
xorl %eax, %eax
movl %eax, %ecx
movl $0x1, %r8d
callq 0x4a80
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0x8(%rsp), %ecx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movl %ecx, 0x20(%rax)
movq (%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x38(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_core.c
// Function: isNumeric
static inline bool isNumeric(Var var, double* value) {
  if (IS_NUM(var)) {
    *value = AS_NUM(var);
    return true;
  }
  if (IS_BOOL(var)) {
    *value = AS_BOOL(var);
    return true;
  }
  return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
andq 0x8(%rsp), %rax
movabsq $0x7ffc000000000000, %rcx # imm = 0x7FFC000000000000
cmpq %rcx, %rax
je 0x1fcd4
movq 0x8(%rsp), %rdi
callq 0x45d0
movq (%rsp), %rax
movsd %xmm0, (%rax)
movb $0x1, 0x17(%rsp)
jmp 0x1fd25
movabsq $0x7ffd000000000003, %rax # imm = 0x7FFD000000000003
cmpq %rax, 0x8(%rsp)
je 0x1fcf6
movabsq $0x7ffd000000000002, %rax # imm = 0x7FFD000000000002
cmpq %rax, 0x8(%rsp)
jne 0x1fd20
movabsq $0x7ffd000000000003, %rax # imm = 0x7FFD000000000003
cmpq %rax, 0x8(%rsp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cvtsi2sd %eax, %xmm0
movq (%rsp), %rax
movsd %xmm0, (%rax)
movb $0x1, 0x17(%rsp)
jmp 0x1fd25
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1fc90
testb $0x1, %al
jne 0x1fe28
jmp 0x1fe78
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0xbf88(%rip), %rcx      # 0x2bdc6
callq 0x1fd30
testb $0x1, %al
jne 0x1fe49
jmp 0x1fe64
movsd 0x20(%rsp), %xmm0
subsd 0x18(%rsp), %xmm0
callq 0x45b0
movq %rax, 0x40(%rsp)
jmp 0x1ff2b
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
movq %rax, 0x40(%rsp)
jmp 0x1ff2b
jmp 0x1fe7a
jmp 0x1fe7c
movq 0x38(%rsp), %rax
movq 0x5f0(%rax), %rax
cmpq $0x0, 0x58(%rax)
je 0x1fec9
movq 0x13162(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xa2b0(%rip), %rsi      # 0x2a150
leaq 0xa3bd(%rip), %rdx      # 0x2a264
leaq 0xbf60(%rip), %rcx      # 0x2be0e
leaq 0xbbe1(%rip), %r8       # 0x2ba96
movl $0x50b, %r9d            # imm = 0x50B
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1fecb
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x7590
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x7590
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0xbf18(%rip), %rsi      # 0x2be1a
movb $0x0, %al
callq 0x4ed0
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq 0x5f0(%rax), %rax
movq %rcx, 0x58(%rax)
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1fc90
testb $0x1, %al
jne 0x201e8
jmp 0x2023d
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0xbbc8(%rip), %rcx      # 0x2bdc6
callq 0x1fd30
testb $0x1, %al
jne 0x20209
jmp 0x20229
movsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x21b0
callq 0x45b0
movq %rax, 0x40(%rsp)
jmp 0x2035e
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
movq %rax, 0x40(%rsp)
jmp 0x2035e
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x30(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x202ab
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x30(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x202ab
jmp 0x20271
movq 0x12d80(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x9ece(%rip), %rsi      # 0x2a150
leaq 0xa126(%rip), %rdx      # 0x2a3af
leaq 0xbc39(%rip), %rcx      # 0x2bec9
leaq 0xb7ff(%rip), %r8       # 0x2ba96
movl $0x537, %r9d            # imm = 0x537
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x202ad
jmp 0x202af
movq 0x38(%rsp), %rax
movq 0x5f0(%rax), %rax
cmpq $0x0, 0x58(%rax)
je 0x202fc
movq 0x12d2f(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x9e7d(%rip), %rsi      # 0x2a150
leaq 0x9f8a(%rip), %rdx      # 0x2a264
leaq 0xbbe8(%rip), %rcx      # 0x2bec9
leaq 0xb7ae(%rip), %r8       # 0x2ba96
movl $0x53a, %r9d            # imm = 0x53A
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x202fe
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x7590
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x7590
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0xbb9e(%rip), %rsi      # 0x2bed3
movb $0x0, %al
callq 0x4ed0
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq 0x5f0(%rax), %rax
movq %rcx, 0x58(%rax)
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x204b0
testb $0x1, %al
jne 0x20398
jmp 0x203eb
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0xba18(%rip), %rcx      # 0x2bdc6
callq 0x20580
testb $0x1, %al
jne 0x203b9
jmp 0x203d7
movq 0x20(%rsp), %rax
andq 0x18(%rsp), %rax
cvtsi2sd %rax, %xmm0
callq 0x45b0
movq %rax, 0x40(%rsp)
jmp 0x2049e
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
movq %rax, 0x40(%rsp)
jmp 0x2049e
jmp 0x203ed
jmp 0x203ef
movq 0x38(%rsp), %rax
movq 0x5f0(%rax), %rax
cmpq $0x0, 0x58(%rax)
je 0x2043c
movq 0x12bef(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x9d3d(%rip), %rsi      # 0x2a150
leaq 0x9e4a(%rip), %rdx      # 0x2a264
leaq 0xbae5(%rip), %rcx      # 0x2bf06
leaq 0xb66e(%rip), %r8       # 0x2ba96
movl $0x548, %r9d            # imm = 0x548
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x2043e
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x7590
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x7590
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0xba9b(%rip), %rsi      # 0x2bf10
movb $0x0, %al
callq 0x4ed0
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq 0x5f0(%rax), %rax
movq %rcx, 0x58(%rax)
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_core.c
// Function: isInteger
static inline bool isInteger(Var var, int64_t* value) {
  double number;
  if (isNumeric(var, &number)) {
    // TODO: check if the number is larger for a 64 bit integer.
    if (floor(number) == number) {
      ASSERT(INT64_MIN <= number && number <= INT64_MAX,
        "TODO: Large numbers haven't handled yet. Please report!");
      *value = (int64_t)(number);
      return true;
    }
  }
  return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1fc90
testb $0x1, %al
jne 0x204d6
jmp 0x20565
movsd 0x8(%rsp), %xmm0
callq 0x2320
ucomisd 0x8(%rsp), %xmm0
jne 0x20563
jp 0x20563
jmp 0x204ed
movsd 0x8(%rsp), %xmm0
movsd 0xb4c5(%rip), %xmm1     # 0x2b9c0
ucomisd %xmm1, %xmm0
jb 0x20511
movsd 0xb4bf(%rip), %xmm0     # 0x2b9c8
ucomisd 0x8(%rsp), %xmm0
jae 0x2054b
movq 0x12ae0(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x9c2e(%rip), %rsi      # 0x2a150
leaq 0xd01c(%rip), %rdx      # 0x2d545
leaq 0xd04d(%rip), %rcx      # 0x2d57d
leaq 0xb55f(%rip), %r8       # 0x2ba96
movl $0x161, %r9d            # imm = 0x161
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x2054d
cvttsd2si 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x27(%rsp)
jmp 0x2056a
jmp 0x20565
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x204b0
testb $0x1, %al
jne 0x208f8
jmp 0x2094e
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0xb4b8(%rip), %rcx      # 0x2bdc6
callq 0x20580
testb $0x1, %al
jne 0x20919
jmp 0x2093a
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
shlq %cl, %rax
cvtsi2sd %rax, %xmm0
callq 0x45b0
movq %rax, 0x40(%rsp)
jmp 0x20a01
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
movq %rax, 0x40(%rsp)
jmp 0x20a01
jmp 0x20950
jmp 0x20952
movq 0x38(%rsp), %rax
movq 0x5f0(%rax), %rax
cmpq $0x0, 0x58(%rax)
je 0x2099f
movq 0x1268c(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x97da(%rip), %rsi      # 0x2a150
leaq 0x98e7(%rip), %rdx      # 0x2a264
leaq 0xb638(%rip), %rcx      # 0x2bfbc
leaq 0xb10b(%rip), %r8       # 0x2ba96
movl $0x572, %r9d            # imm = 0x572
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x209a1
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x7590
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x7590
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0xb5f1(%rip), %rsi      # 0x2bfc9
movb $0x0, %al
callq 0x4ed0
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq 0x5f0(%rax), %rax
movq %rcx, 0x58(%rax)
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1fc90
testb $0x1, %al
jne 0x20bd3
jmp 0x20bfc
movq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x1fc90
testb $0x1, %al
jne 0x20be6
jmp 0x20bfc
movsd 0x8(%rsp), %xmm0
ucomisd (%rsp), %xmm0
seta %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x20c38
jmp 0x20bfe
movq 0x123f3(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x9541(%rip), %rsi      # 0x2a150
leaq 0x9799(%rip), %rdx      # 0x2a3af
leaq 0xb42f(%rip), %rcx      # 0x2c04c
leaq 0xae72(%rip), %r8       # 0x2ba96
movl $0x591, %r9d            # imm = 0x591
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_core.c
// Function: validateIndex
static inline bool validateIndex(PKVM* vm, int64_t index, uint32_t size,
                                 const char* container) {
  if (index < 0 || size <= index) {
    VM_SET_ERROR(vm, stringFormat(vm, "$ index out of bound.", container));
    return false;
  }
  return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq %rcx, (%rsp)
cmpq $0x0, 0x10(%rsp)
jl 0x235cd
movl 0xc(%rsp), %eax
cmpq 0x10(%rsp), %rax
jg 0x23651
jmp 0x235cf
jmp 0x235d1
movq 0x18(%rsp), %rax
movq 0x5f0(%rax), %rax
cmpq $0x0, 0x58(%rax)
je 0x2361e
movq 0xfa0d(%rip), %rax      # 0x32ff8
movq (%rax), %rdi
leaq 0x6b5b(%rip), %rsi      # 0x2a150
leaq 0x6c68(%rip), %rdx      # 0x2a264
leaq 0x9fae(%rip), %rcx      # 0x2d5b1
leaq 0x848c(%rip), %r8       # 0x2ba96
movl $0x17e, %r9d            # imm = 0x17E
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x23620
movq 0x18(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x9f8f(%rip), %rsi      # 0x2d5bf
movb $0x0, %al
callq 0x4ed0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq 0x5f0(%rax), %rax
movq %rcx, 0x58(%rax)
movb $0x0, 0x27(%rsp)
jmp 0x23656
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x2130
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl %eax, %edx
callq 0x69a0
cmpl $-0x1, %eax
je 0x23a8e
jmp 0x23a29
movq 0xf5c8(%rip), %rax      # 0x32ff8
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rcx
leaq 0x8797(%rip), %rsi      # 0x2c1e9
movb $0x0, %al
callq 0x4ed0
movq 0x18(%rsp), %rdi
movq %rax, %rdx
addq $0x1c, %rdx
leaq 0x66e4(%rip), %rsi      # 0x2a150
leaq 0x87a8(%rip), %rcx      # 0x2c21b
leaq 0x801c(%rip), %r8       # 0x2ba96
movl $0x30a, %r9d            # imm = 0x30A
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x2130
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl %eax, %edx
callq 0x6a40
cmpl $-0x1, %eax
je 0x23b27
jmp 0x23ac4
movq 0xf52d(%rip), %rax      # 0x32ff8
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rcx
leaq 0x8743(%rip), %rsi      # 0x2c22f
movb $0x0, %al
callq 0x4ed0
movq (%rsp), %rdi
movq %rax, %rdx
addq $0x1c, %rdx
leaq 0x664b(%rip), %rsi      # 0x2a150
leaq 0x870f(%rip), %rcx      # 0x2c21b
leaq 0x7f83(%rip), %r8       # 0x2ba96
movl $0x310, %r9d            # imm = 0x310
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x9010
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x243c3
movq 0x8(%rsp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, (%rsp)
jmp 0x243ca
xorl %eax, %eax
movl %eax, (%rsp)
jmp 0x243ca
movl (%rsp), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x7(%rsp)
cmpl $0x0, 0x2c(%rsp)
jne 0x24432
testb $0x1, 0x7(%rsp)
je 0x24406
movq 0xec0a(%rip), %rax      # 0x32ff8
movq (%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x91d8(%rip), %rsi      # 0x2d5d5
movb $0x0, %al
callq 0x2240
jmp 0x2442d
movq 0xebeb(%rip), %rax      # 0x32ff8
movq (%rax), %rdi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl 0x1c(%rsp), %r8d
leaq 0x91ba(%rip), %rsi      # 0x2d5e0
movb $0x0, %al
callq 0x2240
jmp 0x244b6
cmpl $0x1, 0x2c(%rsp)
jne 0x24458
movq 0xebb8(%rip), %rax      # 0x32ff8
movq (%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x9186(%rip), %rsi      # 0x2d5d5
movb $0x0, %al
callq 0x2240
jmp 0x244b4
cmpl $0x2, 0x2c(%rsp)
jne 0x244b2
testb $0x1, 0x7(%rsp)
je 0x24489
movq 0xeb8b(%rip), %rax      # 0x32ff8
movq (%rax), %rdi
movq 0x10(%rsp), %rdx
movl 0x1c(%rsp), %ecx
leaq 0x917d(%rip), %rsi      # 0x2d5fd
movb $0x0, %al
callq 0x2240
jmp 0x244b0
movq 0xeb68(%rip), %rax      # 0x32ff8
movq (%rax), %rdi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl 0x1c(%rsp), %r8d
leaq 0x9166(%rip), %rsi      # 0x2d60f
movb $0x0, %al
callq 0x2240
jmp 0x244b2
jmp 0x244b4
jmp 0x244b6
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, (%rsp)
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x25f70
movq (%rsp), %rdi
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rdi)
leaq -0x1d1(%rip), %rcx      # 0x24350
movq %rcx, 0x8(%rdi)
movl $0x1, %ecx
movq %rcx, 0x10(%rdi)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x2058, %rsp           # imm = 0x2058
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rsi, 0x2050(%rsp)
movq %rdx, 0x2048(%rsp)
movq %rcx, 0x2040(%rsp)
leaq -0x222(%rip), %rax      # 0x24350
movq %rax, 0x8(%rdi)
movq 0x2048(%rsp), %rdi
leaq 0x2038(%rsp), %rsi
callq 0x25110
cmpq $0x0, 0x2038(%rsp)
je 0x245a9
movq 0x2040(%rsp), %rdi
callq 0x250f0
testb $0x1, %al
jne 0x245a9
jmp 0x24615
movq 0x2040(%rsp), %rdi
callq 0x2130
movq %rax, 0x2030(%rsp)
movq 0x2030(%rsp), %rdi
addq $0x1, %rdi
callq 0x22b0
movq %rax, 0x2028(%rsp)
movq 0x2040(%rsp), %rdi
movq 0x2028(%rsp), %rsi
movq 0x2030(%rsp), %rdx
addq $0x1, %rdx
callq 0x25140
movq (%rsp), %rax
movq 0x2028(%rsp), %rcx
movq %rcx, (%rax)
movl $0x1, %ecx
movq %rcx, 0x10(%rax)
jmp 0x246a6
leaq 0x1020(%rsp), %rdi
movq 0x2048(%rsp), %rsi
movq 0x2038(%rsp), %rdx
callq 0x2070
movq 0x2038(%rsp), %rax
movb $0x0, 0x1020(%rsp,%rax)
leaq 0x1020(%rsp), %rdi
movq 0x2040(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movl $0x1000, %ecx           # imm = 0x1000
callq 0x25170
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
addq $0x1, %rdi
callq 0x22b0
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq $0x1, %rdx
callq 0x25140
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movl $0x1, %ecx
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x2058, %rsp           # imm = 0x2058
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
leaq -0x392(%rip), %rax      # 0x24350
movq %rax, 0x8(%rdi)
movq 0x38(%rsp), %rdi
leaq 0x7858(%rip), %rsi      # 0x2bf4a
callq 0x2300
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x24715
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
jmp 0x247a6
movq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x22d0
movq 0x30(%rsp), %rdi
callq 0x2250
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x22d0
movq 0x28(%rsp), %rdi
addq $0x1, %rdi
callq 0x22b0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
movl $0x1, %esi
callq 0x20b0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x30(%rsp), %rdi
callq 0x2110
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movl $0x1, %ecx
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/main.c
// Function: intializeatomlangVM
static PKVM* intializeatomlangVM() {
  PkConfiguration config = pkNewConfiguration();
  config.error_fn = errorFunction;
  config.write_fn = writeFunction;
  config.read_fn = readFunction;

  config.inst_free_fn = freeObj;
  config.inst_name_fn = getObjName;
  config.inst_get_attrib_fn = objGetAttrib;
  config.inst_set_attrib_fn = objSetAttrib;

  config.load_script_fn = loadScript;
  config.resolve_path_fn = resolvePath;

  return pkNewVM(&config);
}

// Assembly:
subq $0x58, %rsp
movq %rsp, %rdi
callq 0x8cc0
leaq -0xaa3(%rip), %rax      # 0x24380
movq %rax, 0x8(%rsp)
leaq -0x96f(%rip), %rax      # 0x244c0
movq %rax, 0x10(%rsp)
leaq -0x94b(%rip), %rax      # 0x244f0
movq %rax, 0x18(%rsp)
leaq 0x1c9(%rip), %rax       # 0x25010
movq %rax, 0x20(%rsp)
leaq 0x26d(%rip), %rax       # 0x250c0
movq %rax, 0x28(%rsp)
leaq 0x61(%rip), %rax        # 0x24ec0
movq %rax, 0x30(%rsp)
leaq 0x115(%rip), %rax       # 0x24f80
movq %rax, 0x38(%rsp)
leaq -0x7b7(%rip), %rax      # 0x246c0
movq %rax, 0x48(%rsp)
leaq -0x943(%rip), %rax      # 0x24540
movq %rax, 0x40(%rsp)
movq %rsp, %rdi
callq 0x8d80
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
leaq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
cmpl 0x24(%rsp), %eax
je 0x24f2d
movq 0xe0fe(%rip), %rax      # 0x32ff8
movq (%rax), %rdi
leaq 0x524c(%rip), %rsi      # 0x2a150
leaq 0x5359(%rip), %rdx      # 0x2a264
leaq 0x88f8(%rip), %rcx      # 0x2d80a
leaq 0x88fe(%rip), %r8       # 0x2d817
movl $0x18, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x24f2f
movq 0x18(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x24f77
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rdi
leaq 0x88d3(%rip), %rsi      # 0x2d825
callq 0x2220
cmpl $0x0, %eax
jne 0x24f75
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rax
movb 0x14(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x1c190
jmp 0x24f79
jmp 0x24f77
jmp 0x24f79
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/modules.c
// Function: objSetAttrib
bool objSetAttrib(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;
    // Nothing to change.
  }

  return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
cmpl 0x14(%rsp), %eax
je 0x24fe3
movq 0xe048(%rip), %rax      # 0x32ff8
movq (%rax), %rdi
leaq 0x5196(%rip), %rsi      # 0x2a150
leaq 0x52a3(%rip), %rdx      # 0x2a264
leaq 0x8864(%rip), %rcx      # 0x2d82c
leaq 0x8848(%rip), %r8       # 0x2d817
movl $0x27, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x24fe5
movq 0x8(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x24ff8
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
xorl %eax, %eax
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
cmpl 0x14(%rsp), %eax
je 0x25073
movq 0xdfb8(%rip), %rax      # 0x32ff8
movq (%rax), %rdi
leaq 0x5106(%rip), %rsi      # 0x2a150
leaq 0x5213(%rip), %rdx      # 0x2a264
leaq 0x87e1(%rip), %rcx      # 0x2d839
leaq 0x87b8(%rip), %r8       # 0x2d817
movl $0x33, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x25075
movq 0x8(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x250b0
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
testb $0x1, 0x14(%rax)
jne 0x250ae
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2110
cmpl $0x0, %eax
je 0x250a6
jmp 0x250a6
movq (%rsp), %rax
movb $0x1, 0x14(%rax)
jmp 0x250b0
movq 0x8(%rsp), %rdi
callq 0x2030
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x1028, %rsp           # imm = 0x1028
movq %rdi, 0x1020(%rsp)
movq 0x1020(%rsp), %rdi
movl $0x1, %esi
leaq 0x1018(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x1b8d0
testb $0x1, %al
jne 0x25463
jmp 0x25496
movq 0x1018(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x25e30
movq %rax, 0x8(%rsp)
movq 0x1020(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1c2a0
addq $0x1028, %rsp           # imm = 0x1028
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x3028, %rsp           # imm = 0x3028
movq %rdi, 0x3020(%rsp)
movq 0x3020(%rsp), %rdi
movl $0x1, %esi
leaq 0x3018(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x1b8d0
testb $0x1, %al
jne 0x254d6
jmp 0x25569
movq 0x3020(%rsp), %rdi
movl $0x2, %esi
leaq 0x3010(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x1b8d0
testb $0x1, %al
jne 0x254fa
jmp 0x25569
movq 0x3018(%rsp), %rdi
leaq 0x2010(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x25e30
movq 0x3010(%rsp), %rdi
leaq 0x1010(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x25e30
leaq 0x2010(%rsp), %rdi
leaq 0x1010(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movl $0x1000, %ecx           # imm = 0x1000
callq 0x26950
movq %rax, 0x8(%rsp)
movq 0x3020(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1c2a0
addq $0x3028, %rsp           # imm = 0x3028
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x1078, %rsp           # imm = 0x1078
movq %rdi, 0x1070(%rsp)
movq 0x1070(%rsp), %rdi
callq 0x1b110
movl %eax, 0x101c(%rsp)
cmpl $0x8, 0x101c(%rsp)
jle 0x255c6
movq 0x1070(%rsp), %rdi
leaq 0x82ea(%rip), %rsi      # 0x2d8a6
callq 0x11660
jmp 0x2566d
movl $0x0, 0x1018(%rsp)
movl 0x1018(%rsp), %eax
cmpl 0x101c(%rsp), %eax
jge 0x25626
movq 0x1070(%rsp), %rdi
movl 0x1018(%rsp), %esi
addl $0x1, %esi
movslq 0x1018(%rsp), %rax
leaq 0x1020(%rsp), %rdx
shlq $0x3, %rax
addq %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x1b8d0
movl 0x1018(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1018(%rsp)
jmp 0x255d1
movslq 0x101c(%rsp), %rax
movq $0x0, 0x1020(%rsp,%rax,8)
leaq 0x1020(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x27340
movq %rax, 0x8(%rsp)
movq 0x1070(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1c2a0
addq $0x1078, %rsp           # imm = 0x1078
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x1028, %rsp           # imm = 0x1028
movq %rdi, 0x1020(%rsp)
movq 0x1020(%rsp), %rdi
movl $0x1, %esi
leaq 0x1018(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x1b8d0
testb $0x1, %al
jne 0x256b3
jmp 0x256e6
movq 0x1018(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x27e00
movq %rax, 0x8(%rsp)
movq 0x1020(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1c2a0
addq $0x1028, %rsp           # imm = 0x1028
retq
nop
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/modules.c
// Function: pathBaseName
static void _pathBaseName(PKVM* vm) {
  const char* path;
  if (!pkGetArgString(vm, 1, &path, NULL)) return;

  const char* base_name;
  size_t length;
  cwk_path_get_basename(path, &base_name, &length);
  pkReturnString(vm, base_name);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x1b8d0
testb $0x1, %al
jne 0x25717
jmp 0x2573a
movq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x27650
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1c220
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/modules.c
// Function: pathDirName
static void _pathDirName(PKVM* vm) {
  const char* path;
  if (!pkGetArgString(vm, 1, &path, NULL)) return;

  size_t length;
  cwk_path_get_dirname(path, &length);
  pkReturnStringLength(vm, path, length);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x8(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x1b8d0
testb $0x1, %al
jne 0x25767
jmp 0x25787
movq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x27a30
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x1c2a0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/modules.c
// Function: pathGetExtension
static void _pathGetExtension(PKVM* vm) {
  const char* path;
  if (!pkGetArgString(vm, 1, &path, NULL)) return;

  const char* ext;
  size_t length;
  if (cwk_path_get_extension(path, &ext, &length)) {
    pkReturnStringLength(vm, ext, length);
  } else {
    pkReturnStringLength(vm, NULL, 0);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x1b8d0
testb $0x1, %al
jne 0x25807
jmp 0x25848
movq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x27a80
testb $0x1, %al
jne 0x25821
jmp 0x25837
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1c2a0
jmp 0x25848
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x1c2a0
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/modules.c
// Function: registerModuleFile
void registerModuleFile(PKVM* vm) {
  PkHandle* file = pkNewModule(vm, "File");

  pkModuleAddFunction(vm, file, "open",  _fileOpen, -1);
  pkModuleAddFunction(vm, file, "read",  _fileRead,  1);
  pkModuleAddFunction(vm, file, "write", _fileWrite, 2);
  pkModuleAddFunction(vm, file, "close", _fileClose, 1);

  pkReleaseHandle(vm, file);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x5f56(%rip), %rsi      # 0x2b8ab
callq 0x1aa40
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x7f26(%rip), %rdx      # 0x2d896
leaq 0x89(%rip), %rcx        # 0x25a00
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x1ade0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x7f08(%rip), %rdx      # 0x2d89b
leaq 0x266(%rip), %rcx       # 0x25c00
movl $0x1, %r8d
callq 0x1ade0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x639e(%rip), %rdx      # 0x2bd54
leaq 0x313(%rip), %rcx       # 0x25cd0
movl $0x2, %r8d
callq 0x1ade0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x7ec7(%rip), %rdx      # 0x2d8a0
leaq 0x3b0(%rip), %rcx       # 0x25d90
movl $0x1, %r8d
callq 0x1ade0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x9120
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/modules.c
// Function: fileRead
static void _fileRead(PKVM* vm) {
  File* file;
  if (!pkGetArgInst(vm, 1, OBJ_FILE, (void**)&file)) return;

  if (file->closed) {
    pkSetRuntimeError(vm, "Cannot read from a closed file.");
    return;
  }

  if ((file->mode != FMODE_READ) && ((_FMODE_EXT & file->mode) == 0)) {
    pkSetRuntimeError(vm, "File is not readable.");
    return;
  }

  // TODO: this is temproary.
  char buff[2048];
  fread((void*)buff, sizeof(char), sizeof(buff), file->fp);
  pkReturnString(vm, (const char*)buff);
}

// Assembly:
subq $0x818, %rsp            # imm = 0x818
movq %rdi, 0x810(%rsp)
movq 0x810(%rsp), %rdi
movl $0x1, %edx
leaq 0x808(%rsp), %rcx
movl %edx, %esi
callq 0x1bbe0
testb $0x1, %al
jne 0x25c34
jmp 0x25cbd
movq 0x808(%rsp), %rax
testb $0x1, 0x14(%rax)
je 0x25c58
movq 0x810(%rsp), %rdi
leaq 0x7c91(%rip), %rsi      # 0x2d8e2
callq 0x11660
jmp 0x25cbd
movq 0x808(%rsp), %rax
cmpl $0x1, 0x10(%rax)
je 0x25c8f
movq 0x808(%rsp), %rax
movl 0x10(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x25c8f
movq 0x810(%rsp), %rdi
leaq 0x7c7a(%rip), %rsi      # 0x2d902
callq 0x11660
jmp 0x25cbd
movq %rsp, %rdi
movq 0x808(%rsp), %rax
movq 0x8(%rax), %rcx
movl $0x1, %esi
movl $0x800, %edx            # imm = 0x800
callq 0x20b0
movq 0x810(%rsp), %rdi
movq %rsp, %rsi
callq 0x1c220
addq $0x818, %rsp            # imm = 0x818
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/modules.c
// Function: fileWrite
static void _fileWrite(PKVM* vm) {
  File* file;
  const char* text; uint32_t length;
  if (!pkGetArgInst(vm, 1, OBJ_FILE, (void**)&file)) return;
  if (!pkGetArgString(vm, 2, &text, &length)) return;

  if (file->closed) {
    pkSetRuntimeError(vm, "Cannot write to a closed file.");
    return;
  }

  if ((file->mode != FMODE_WRITE) && ((_FMODE_EXT & file->mode) == 0)) {
    pkSetRuntimeError(vm, "File is not writable.");
    return;
  }

  fwrite(text, sizeof(char), (size_t)length, file->fp);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %edx
leaq 0x18(%rsp), %rcx
movl %edx, %esi
callq 0x1bbe0
testb $0x1, %al
jne 0x25cf8
jmp 0x25d81
movq 0x20(%rsp), %rdi
movl $0x2, %esi
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
callq 0x1b8d0
testb $0x1, %al
jne 0x25d17
jmp 0x25d81
movq 0x18(%rsp), %rax
testb $0x1, 0x14(%rax)
je 0x25d35
movq 0x20(%rsp), %rdi
leaq 0x7bea(%rip), %rsi      # 0x2d918
callq 0x11660
jmp 0x25d81
movq 0x18(%rsp), %rax
cmpl $0x2, 0x10(%rax)
je 0x25d63
movq 0x18(%rsp), %rax
movl 0x10(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x25d63
movq 0x20(%rsp), %rdi
leaq 0x7bdb(%rip), %rsi      # 0x2d937
callq 0x11660
jmp 0x25d81
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, %edx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movl $0x1, %esi
callq 0x2370
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/modules.c
// Function: fileClose
static void _fileClose(PKVM* vm) {
  File* file;
  if (!pkGetArgInst(vm, 1, OBJ_FILE, (void**)&file)) return;

  if (file->closed) {
    pkSetRuntimeError(vm, "File already closed.");
    return;
  }

  if (fclose(file->fp) != 0) {
    pkSetRuntimeError(vm, "fclose() failed!\n"                     \
                      "  at " __FILE__ ":" STRINGIFY(__LINE__) ".");
  }
  file->closed = true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %edx
leaq 0x8(%rsp), %rcx
movl %edx, %esi
callq 0x1bbe0
testb $0x1, %al
jne 0x25db5
jmp 0x25e00
movq 0x8(%rsp), %rax
testb $0x1, 0x14(%rax)
je 0x25dd3
movq 0x10(%rsp), %rdi
leaq 0x7b81(%rip), %rsi      # 0x2d94d
callq 0x11660
jmp 0x25e00
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2110
cmpl $0x0, %eax
je 0x25df7
movq 0x10(%rsp), %rdi
leaq 0x7b70(%rip), %rsi      # 0x2d962
callq 0x11660
movq 0x8(%rsp), %rax
movb $0x1, 0x14(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/modules.c
// Function: pathIsFileExists
static inline bool pathIsFileExists(const char* path) {
  FILE* file = fopen(path, "r");
  if (file != NULL) {
    fclose(file);
    return true;
  }
  return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x6065(%rip), %rsi      # 0x2bf4a
callq 0x2300
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x25f05
movq (%rsp), %rdi
callq 0x2110
movb $0x1, 0x17(%rsp)
jmp 0x25f0a
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/modules.c
// Function: pathIsDirectoryExists
static inline bool pathIsDirectoryExists(const char* path) {
  DIR* dir = opendir(path);
  if (dir) { /* Directory exists. */
    closedir(dir);
    return true;
  } else if (errno == ENOENT) { /* Directory does not exist. */
  } else { /* opendir() failed for some other reason. */
  }

  return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x2120
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x25f4e
movq (%rsp), %rdi
callq 0x21c0
movb $0x1, 0x17(%rsp)
jmp 0x25f63
callq 0x2050
cmpl $0x2, (%rax)
jne 0x25f5a
jmp 0x25f5c
jmp 0x25f5c
jmp 0x25f5e
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop