LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: parsePrecedence
static void parsePrecedence(Compiler* compiler, Precedence precedence) {
  lexToken(compiler);
  GrammarFn prefix = getRule(compiler->previous.type)->prefix;

  if (prefix == NULL) {
    parseError(compiler, "Expected an expression.");
    return;
  }

  // Reset to false and this will set to true by the exprCall() function,
  // If the next infix is call '('.
  compiler->is_last_call = false;
  compiler->l_value = precedence <= PREC_LOWEST;

  prefix(compiler);

  while (getRule(compiler->current.type)->precedence >= precedence) {
    lexToken(compiler);
    GrammarFn infix = getRule(compiler->previous.type)->infix;
    infix(compiler);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
callq 0x15990
movq 0x20(%rsp), %rax
movl 0x30(%rax), %edi
callq 0x18250
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x181d9
movq 0x20(%rsp), %rdi
leaq 0x13100(%rip), %rsi     # 0x2b2d0
movb $0x0, %al
callq 0x15f90
jmp 0x1824b
movq 0x20(%rsp), %rax
movb $0x0, 0x38ce(%rax)
cmpl $0x1, 0x1c(%rsp)
setbe %cl
movq 0x20(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x38cd(%rax)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rdi
callq *%rax
movq 0x20(%rsp), %rax
movl 0x50(%rax), %edi
callq 0x18250
movl 0x10(%rax), %eax
cmpl 0x1c(%rsp), %eax
jb 0x1824b
movq 0x20(%rsp), %rdi
callq 0x15990
movq 0x20(%rsp), %rax
movl 0x30(%rax), %edi
callq 0x18250
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rdi
callq *%rax
jmp 0x18207
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: patchJump
static void patchJump(Compiler* compiler, int addr_index) {
  int offset = (int)_FN->opcodes.count - (addr_index + 2 /*bytes index*/);
  ASSERT(offset < MAX_JUMP, "Too large address offset to jump to.");

  _FN->opcodes.data[addr_index] = (offset >> 8) & 0xff;
  _FN->opcodes.data[addr_index + 1] = offset & 0xff;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x18c0(%rax), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
movl 0x8(%rax), %eax
movl 0xc(%rsp), %ecx
addl $0x2, %ecx
subl %ecx, %eax
movl %eax, 0x8(%rsp)
cmpl $0x10000, 0x8(%rsp)     # imm = 0x10000
jl 0x182e5
movq 0x1ad46(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x11e94(%rip), %rsi     # 0x2a150
leaq 0x13049(%rip), %rdx     # 0x2b30c
leaq 0x13067(%rip), %rcx     # 0x2b331
leaq 0x12d06(%rip), %r8      # 0x2afd7
movl $0x77a, %r9d            # imm = 0x77A
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x182e7
movl 0x8(%rsp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, %dl
movq 0x10(%rsp), %rax
movq 0x18c0(%rax), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x8(%rsp), %eax
andl $0xff, %eax
movb %al, %dl
movq 0x10(%rsp), %rax
movq 0x18c0(%rax), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movl 0xc(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: emitStoreVariable
static void emitStoreVariable(Compiler* compiler, int index, bool global) {
  if (global) {
    emitOpcode(compiler, OP_STORE_GLOBAL);
    emitByte(compiler, index);

  } else {
    if (index < 9) { //< 0..8 locals have single opcode.
      emitOpcode(compiler, (Opcode)(OP_STORE_LOCAL_0 + index));
    } else {
      emitOpcode(compiler, OP_STORE_LOCAL_N);
      emitByte(compiler, index);
    }
  }
}

// Assembly:
subq $0x18, %rsp
movb %dl, %al
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
andb $0x1, %al
movb %al, 0xb(%rsp)
testb $0x1, 0xb(%rsp)
je 0x1838b
movq 0x10(%rsp), %rdi
movl $0x21, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x166d0
jmp 0x183c4
cmpl $0x9, 0xc(%rsp)
jge 0x183a5
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
addl $0x16, %esi
callq 0x16650
jmp 0x183c2
movq 0x10(%rsp), %rdi
movl $0x1f, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x166d0
jmp 0x183c4
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: compilerAddForward
static void compilerAddForward(Compiler* compiler, int instruction, Fn* fn,
                               const char* name, int length, int line) {
  if (compiler->forwards_count == MAX_FORWARD_NAMES) {
    parseError(compiler, "A script should contain at most %d implicit forward "
               "function declarations.", MAX_FORWARD_NAMES);
    return;
  }

  ForwardName* forward = &compiler->forwards[compiler->forwards_count++];
  forward->instruction = instruction;
  forward->func = fn;
  forward->name = name;
  forward->length = length;
  forward->line = line;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movl %r9d, 0x10(%rsp)
movq 0x30(%rsp), %rax
cmpl $0x100, 0x38c8(%rax)    # imm = 0x100
jne 0x1841c
movq 0x30(%rsp), %rdi
leaq 0x12fb0(%rip), %rsi     # 0x2b3be
movl $0x100, %edx            # imm = 0x100
movb $0x0, %al
callq 0x15f90
jmp 0x1848b
movq 0x30(%rsp), %rax
addq $0x18c8, %rax           # imm = 0x18C8
movq 0x30(%rsp), %rdx
movl 0x38c8(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x38c8(%rdx)
movslq %ecx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x18(%rax)
movl 0x10(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x1c(%rax)
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: matchAssignment
static bool matchAssignment(Compiler* compiler) {
  if (match(compiler, TK_EQ))       return true;
  if (match(compiler, TK_PLUSEQ))   return true;
  if (match(compiler, TK_MINUSEQ))  return true;
  if (match(compiler, TK_STAREQ))   return true;
  if (match(compiler, TK_DIVEQ))    return true;
  if (match(compiler, TK_MODEQ))    return true;
  if (match(compiler, TK_ANDEQ))    return true;
  if (match(compiler, TK_OREQ))     return true;
  if (match(compiler, TK_XOREQ))    return true;
  if (match(compiler, TK_SRIGHTEQ)) return true;
  if (match(compiler, TK_SLEFTEQ))  return true;

  return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1a, %esi
callq 0x15f50
testb $0x1, %al
jne 0x184ae
jmp 0x184b8
movb $0x1, 0x17(%rsp)
jmp 0x185e4
movq 0x8(%rsp), %rdi
movl $0x21, %esi
callq 0x15f50
testb $0x1, %al
jne 0x184cd
jmp 0x184d7
movb $0x1, 0x17(%rsp)
jmp 0x185e4
movq 0x8(%rsp), %rdi
movl $0x22, %esi
callq 0x15f50
testb $0x1, %al
jne 0x184ec
jmp 0x184f6
movb $0x1, 0x17(%rsp)
jmp 0x185e4
movq 0x8(%rsp), %rdi
movl $0x23, %esi
callq 0x15f50
testb $0x1, %al
jne 0x1850b
jmp 0x18515
movb $0x1, 0x17(%rsp)
jmp 0x185e4
movq 0x8(%rsp), %rdi
movl $0x24, %esi
callq 0x15f50
testb $0x1, %al
jne 0x1852a
jmp 0x18534
movb $0x1, 0x17(%rsp)
jmp 0x185e4
movq 0x8(%rsp), %rdi
movl $0x25, %esi
callq 0x15f50
testb $0x1, %al
jne 0x18549
jmp 0x18553
movb $0x1, 0x17(%rsp)
jmp 0x185e4
movq 0x8(%rsp), %rdi
movl $0x26, %esi
callq 0x15f50
testb $0x1, %al
jne 0x18568
jmp 0x1856f
movb $0x1, 0x17(%rsp)
jmp 0x185e4
movq 0x8(%rsp), %rdi
movl $0x27, %esi
callq 0x15f50
testb $0x1, %al
jne 0x18584
jmp 0x1858b
movb $0x1, 0x17(%rsp)
jmp 0x185e4
movq 0x8(%rsp), %rdi
movl $0x28, %esi
callq 0x15f50
testb $0x1, %al
jne 0x185a0
jmp 0x185a7
movb $0x1, 0x17(%rsp)
jmp 0x185e4
movq 0x8(%rsp), %rdi
movl $0x2b, %esi
callq 0x15f50
testb $0x1, %al
jne 0x185bc
jmp 0x185c3
movb $0x1, 0x17(%rsp)
jmp 0x185e4
movq 0x8(%rsp), %rdi
movl $0x2c, %esi
callq 0x15f50
testb $0x1, %al
jne 0x185d8
jmp 0x185df
movb $0x1, 0x17(%rsp)
jmp 0x185e4
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: emitPushVariable
static void emitPushVariable(Compiler* compiler, int index, bool global) {
  if (global) {
    emitOpcode(compiler, OP_PUSH_GLOBAL);
    emitByte(compiler, index);

  } else {
    if (index < 9) { //< 0..8 locals have single opcode.
      emitOpcode(compiler, (Opcode)(OP_PUSH_LOCAL_0 + index));
    } else {
      emitOpcode(compiler, OP_PUSH_LOCAL_N);
      emitByte(compiler, index);
    }
  }
}

// Assembly:
subq $0x18, %rsp
movb %dl, %al
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
andb $0x1, %al
movb %al, 0xb(%rsp)
testb $0x1, 0xb(%rsp)
je 0x1862b
movq 0x10(%rsp), %rdi
movl $0x20, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x166d0
jmp 0x18664
cmpl $0x9, 0xc(%rsp)
jge 0x18645
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
addl $0xc, %esi
callq 0x16650
jmp 0x18662
movq 0x10(%rsp), %rdi
movl $0x15, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x166d0
jmp 0x18664
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: emitAssignment
static void emitAssignment(Compiler* compiler, TokenType assignment) {
  switch (assignment) {
    case TK_PLUSEQ:   emitOpcode(compiler, OP_ADD);        break;
    case TK_MINUSEQ:  emitOpcode(compiler, OP_SUBTRACT);   break;
    case TK_STAREQ:   emitOpcode(compiler, OP_MULTIPLY);   break;
    case TK_DIVEQ:    emitOpcode(compiler, OP_DIVIDE);     break;
    case TK_MODEQ:    emitOpcode(compiler, OP_MOD);        break;
    case TK_ANDEQ:    emitOpcode(compiler, OP_BIT_AND);    break;
    case TK_OREQ:     emitOpcode(compiler, OP_BIT_OR);     break;
    case TK_XOREQ:    emitOpcode(compiler, OP_BIT_XOR);    break;
    case TK_SRIGHTEQ: emitOpcode(compiler, OP_BIT_RSHIFT); break;
    case TK_SLEFTEQ:  emitOpcode(compiler, OP_BIT_LSHIFT); break;
    default:
      UNREACHABLE();
      break;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %eax
addl $-0x21, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0xb, %eax
ja 0x18760
movq (%rsp), %rax
leaq 0x1284a(%rip), %rcx     # 0x2aee8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rdi
movl $0x39, %esi
callq 0x16650
jmp 0x18795
movq 0x10(%rsp), %rdi
movl $0x3a, %esi
callq 0x16650
jmp 0x18795
movq 0x10(%rsp), %rdi
movl $0x3b, %esi
callq 0x16650
jmp 0x18795
movq 0x10(%rsp), %rdi
movl $0x3c, %esi
callq 0x16650
jmp 0x18795
movq 0x10(%rsp), %rdi
movl $0x3d, %esi
callq 0x16650
jmp 0x18795
movq 0x10(%rsp), %rdi
movl $0x3e, %esi
callq 0x16650
jmp 0x18795
movq 0x10(%rsp), %rdi
movl $0x3f, %esi
callq 0x16650
jmp 0x18795
movq 0x10(%rsp), %rdi
movl $0x40, %esi
callq 0x16650
jmp 0x18795
movq 0x10(%rsp), %rdi
movl $0x42, %esi
callq 0x16650
jmp 0x18795
movq 0x10(%rsp), %rdi
movl $0x41, %esi
callq 0x16650
jmp 0x18795
jmp 0x18762
movq 0x1a88f(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x11a67(%rip), %rsi     # 0x2a1da
leaq 0x12c8f(%rip), %rdx     # 0x2b409
leaq 0x12856(%rip), %rcx     # 0x2afd7
movl $0x766, %r8d            # imm = 0x766
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: eatChar
static char eatChar(Compiler* compiler) {
  char c = peekChar(compiler);
  compiler->current_char++;
  if (c == '\n') compiler->current_line++;
  return c;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x187a0
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movsbl 0xf(%rsp), %eax
cmpl $0xa, %eax
jne 0x18800
movq 0x10(%rsp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movb 0xf(%rsp), %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: setNextToken
static void setNextToken(Compiler* compiler, TokenType type) {
  Token* next = &compiler->next;
  next->type = type;
  next->start = compiler->token_start;
  next->length = (int)(compiler->current_char - compiler->token_start);
  next->line = compiler->current_line - ((type == TK_LINE) ? 1 : 0);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
addq $0x70, %rax
movq %rax, -0x18(%rsp)
movl -0xc(%rsp), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x18(%rsp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rsp), %rax
movl 0x28(%rax), %ecx
movl -0xc(%rsp), %esi
xorl %eax, %eax
movl $0x1, %edx
cmpl $0x2, %esi
cmovel %edx, %eax
subl %eax, %ecx
movq -0x18(%rsp), %rax
movl %ecx, 0x14(%rax)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: skipLineComment
static void skipLineComment(Compiler* compiler) {
  char c;
  while ((c = peekChar(compiler)) != '\0') {
    // Don't eat new line it's not part of the comment.
    if (c == '\n') return;
    eatChar(compiler);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x187a0
movb %al, 0xf(%rsp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x188c7
movsbl 0xf(%rsp), %eax
cmpl $0xa, %eax
jne 0x188bb
jmp 0x188c7
movq 0x10(%rsp), %rdi
callq 0x187c0
jmp 0x18899
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: setNextTwoCharToken
static void setNextTwoCharToken(Compiler* compiler, char c, TokenType one,
  TokenType two) {
  if (matchChar(compiler, c)) {
    setNextToken(compiler, two);
  } else {
    setNextToken(compiler, one);
  }
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movl %edx, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movsbl 0xf(%rsp), %esi
callq 0x18920
testb $0x1, %al
jne 0x188fd
jmp 0x1890d
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x18810
jmp 0x1891b
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x18810
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: eatName
static void eatName(Compiler* compiler) {

  char c = peekChar(compiler);
  while (utilIsName(c) || utilIsDigit(c)) {
    eatChar(compiler);
    c = peekChar(compiler);
  }

  const char* name_start = compiler->token_start;

  TokenType type = TK_NAME;

  int length = (int)(compiler->current_char - name_start);
  for (int i = 0; _keywords[i].identifier != NULL; i++) {
    if (_keywords[i].length == length &&
      strncmp(name_start, _keywords[i].identifier, length) == 0) {
      type = _keywords[i].tk_type;
      break;
    }
  }

  setNextToken(compiler, type);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x187a0
movb %al, 0x1f(%rsp)
movsbl 0x1f(%rsp), %edi
callq 0x13f30
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x3(%rsp)
jne 0x1908c
movsbl 0x1f(%rsp), %edi
callq 0x13f90
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0x19096
jmp 0x190b0
movq 0x20(%rsp), %rdi
callq 0x187c0
movq 0x20(%rsp), %rdi
callq 0x187a0
movb %al, 0x1f(%rsp)
jmp 0x19067
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x47, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rsp), %rcx
subq %rcx, %rax
movl %eax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movslq 0x4(%rsp), %rcx
leaq 0x1a7f1(%rip), %rax     # 0x338e0
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x19170
movslq 0x4(%rsp), %rcx
leaq 0x1a7d8(%rip), %rax     # 0x338e0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl 0x8(%rsp), %eax
jne 0x1915e
movq 0x10(%rsp), %rdi
movslq 0x4(%rsp), %rcx
leaq 0x1a7b7(%rip), %rax     # 0x338e0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movslq 0x8(%rsp), %rdx
callq 0x2080
cmpl $0x0, %eax
jne 0x1915e
movslq 0x4(%rsp), %rcx
leaq 0x1a792(%rip), %rax     # 0x338e0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x19170
jmp 0x19160
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x190e3
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x18810
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: lexError
static void lexError(Compiler* compiler, const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);
  const char* path = compiler->script->path->data;
  reportError(compiler, path, compiler->current_line, fmt, args);
  va_end(args);
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0x191cc
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rsp, %rax
movq %rax, 0xd0(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0xc8(%rsp)
movl $0x30, 0xc4(%rsp)
movl $0x10, 0xc0(%rsp)
movq 0xe0(%rsp), %rax
movq 0x18b0(%rax), %rax
movq 0x18(%rax), %rax
addq $0x1c, %rax
movq %rax, 0xb8(%rsp)
movq 0xe0(%rsp), %rdi
movq 0xb8(%rsp), %rsi
movl 0x28(%rdi), %edx
movq 0xd8(%rsp), %rcx
leaq 0xc0(%rsp), %r8
callq 0x192f0
addq $0xe8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: reportError
static void reportError(Compiler* compiler, const char* file, int line,
                        const char* fmt, va_list args) {

  // On REPL mode only the first error is reported.
  if (compiler->options && compiler->options->repl_mode &&
      compiler->has_errors) {
    return;
  }

  compiler->has_errors = true;

  // If the source is incomplete we're not printing an error message,
  // instead return PK_RESULT_UNEXPECTED_EOF to the host.
  if (compiler->need_more_lines) {
    ASSERT(compiler->options && compiler->options->repl_mode, OOPS);
    return;
  }

  PKVM* vm = compiler->vm;
  if (vm->config.error_fn == NULL) return;

  // TODO: fix the buffer size. A non terminated large string could cause this
  // crash.

  char message[ERROR_MESSAGE_SIZE];
  int length = vsnprintf(message, sizeof(message), fmt, args);
  __ASSERT(length >= 0, "Error message buffer failed at vsnprintf().");
  vm->config.error_fn(vm, PK_ERROR_COMPILE, file, line, message);
}

// Assembly:
subq $0x248, %rsp            # imm = 0x248
movq %rdi, 0x240(%rsp)
movq %rsi, 0x238(%rsp)
movl %edx, 0x234(%rsp)
movq %rcx, 0x228(%rsp)
movq %r8, 0x220(%rsp)
movq 0x240(%rsp), %rax
cmpq $0x0, 0x98(%rax)
je 0x1935b
movq 0x240(%rsp), %rax
movq 0x98(%rax), %rax
testb $0x1, 0x1(%rax)
je 0x1935b
movq 0x240(%rsp), %rax
testb $0x1, 0x90(%rax)
je 0x1935b
jmp 0x194a4
movq 0x240(%rsp), %rax
movb $0x1, 0x90(%rax)
movq 0x240(%rsp), %rax
testb $0x1, 0x91(%rax)
je 0x193e5
jmp 0x1937d
movq 0x240(%rsp), %rax
cmpq $0x0, 0x98(%rax)
je 0x193a4
movq 0x240(%rsp), %rax
movq 0x98(%rax), %rax
testb $0x1, 0x1(%rax)
jne 0x193de
movq 0x19c4d(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x10d9b(%rip), %rsi     # 0x2a150
leaq 0x10ea8(%rip), %rdx     # 0x2a264
leaq 0x11619(%rip), %rcx     # 0x2a9dc
leaq 0x11c0d(%rip), %r8      # 0x2afd7
movl $0x19e, %r9d            # imm = 0x19E
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x193e0
jmp 0x194a4
movq 0x240(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x218(%rsp)
movq 0x218(%rsp), %rax
cmpq $0x0, 0xd0(%rax)
jne 0x1940f
jmp 0x194a4
leaq 0x10(%rsp), %rdi
movq 0x228(%rsp), %rdx
movq 0x220(%rsp), %rcx
movl $0x200, %esi            # imm = 0x200
callq 0x20c0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x19473
movq 0x19bb8(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x10d06(%rip), %rsi     # 0x2a150
leaq 0x12235(%rip), %rdx     # 0x2b686
leaq 0x11584(%rip), %rcx     # 0x2a9dc
leaq 0x11b78(%rip), %r8      # 0x2afd7
movl $0x1aa, %r9d            # imm = 0x1AA
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x19475
movq 0x218(%rsp), %rax
movq 0xd0(%rax), %rax
movq 0x218(%rsp), %rdi
movq 0x238(%rsp), %rdx
movl 0x234(%rsp), %ecx
leaq 0x10(%rsp), %r8
xorl %esi, %esi
callq *%rax
addq $0x248, %rsp            # imm = 0x248
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: compilerImport
static inline Script* compilerImport(Compiler* compiler) {
  ASSERT(compiler->scope_depth == DEPTH_GLOBAL, OOPS);

  // Get the script (from core libs or vm's cache or compile new one).
  // And push it on the stack.
  if (match(compiler, TK_NAME)) { //< Core library.
    return importCoreLib(compiler, compiler->previous.start,
                         compiler->previous.length);

  } else if (match(compiler, TK_STRING)) { //< Local library.
    Var var_path = compiler->previous.value;
    ASSERT(IS_OBJ_TYPE(var_path, OBJ_STRING), OOPS);
    String* path = (String*)AS_OBJ(var_path);
    return importFile(compiler, path->data);
  }

  // Invalid token after import/from keyword.
  parseError(compiler, "Expected a module name or path to import.");
  return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpl $-0x1, 0xa0(%rax)
je 0x19d91
movq 0x1929a(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x103e8(%rip), %rsi     # 0x2a150
leaq 0x104f5(%rip), %rdx     # 0x2a264
leaq 0x11acb(%rip), %rcx     # 0x2b841
leaq 0x1125a(%rip), %r8      # 0x2afd7
movl $0x8e2, %r9d            # imm = 0x8E2
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x19d93
movq 0x18(%rsp), %rdi
movl $0x47, %esi
callq 0x15f50
testb $0x1, %al
jne 0x19da8
jmp 0x19dcd
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x18(%rsp), %rax
movl 0x40(%rax), %edx
callq 0x1a2c0
movq %rax, 0x20(%rsp)
jmp 0x19ead
movq 0x18(%rsp), %rdi
movl $0x49, %esi
callq 0x15f50
testb $0x1, %al
jne 0x19de5
jmp 0x19e8f
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x10(%rsp)
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x10(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x19e25
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
je 0x19e5f
movq 0x191cc(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x1031a(%rip), %rsi     # 0x2a150
leaq 0x10427(%rip), %rdx     # 0x2a264
leaq 0x119fd(%rip), %rcx     # 0x2b841
leaq 0x1118c(%rip), %r8      # 0x2afd7
movl $0x8ec, %r9d            # imm = 0x8EC
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x19e61
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x1c, %rsi
callq 0x1a460
movq %rax, 0x20(%rsp)
jmp 0x19ead
jmp 0x19e91
movq 0x18(%rsp), %rdi
leaq 0x119b3(%rip), %rsi     # 0x2b850
movb $0x0, %al
callq 0x15f90
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: compilerImportName
static int compilerImportName(Compiler* compiler, int line,
                              const char* name, uint32_t length) {
  ASSERT(compiler->scope_depth == DEPTH_GLOBAL, OOPS);

  NameSearchResult result = compilerSearchName(compiler, name, length);
  switch (result.type) {
    case NAME_NOT_DEFINED:
      return compilerAddVariable(compiler, name, length, line);

    case NAME_LOCAL_VAR:
      UNREACHABLE();

    case NAME_GLOBAL_VAR:
      return result.index;

    case NAME_FUNCTION:
    case NAME_CLASS:
    case NAME_BUILTIN:
      parseError(compiler, "Name '%.*s' already exists.", length, name);
      return -1;
  }

  UNREACHABLE();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq 0x38(%rsp), %rax
cmpl $-0x1, 0xa0(%rax)
je 0x1a19e
movq 0x18e8d(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xffdb(%rip), %rsi      # 0x2a150
leaq 0x100e8(%rip), %rdx     # 0x2a264
leaq 0x117fb(%rip), %rcx     # 0x2b97e
leaq 0x10e4d(%rip), %r8      # 0x2afd7
movl $0x8fc, %r9d            # imm = 0x8FC
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1a1a0
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
callq 0x16dd0
movl %edx, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq %rax, (%rsp)
subq $0x5, %rax
ja 0x1a279
movq (%rsp), %rax
leaq 0x10d2d(%rip), %rcx     # 0x2af18
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
movl 0x34(%rsp), %ecx
callq 0x17070
movl %eax, 0x44(%rsp)
jmp 0x1a2ae
jmp 0x1a216
movq 0x18ddb(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xffb3(%rip), %rsi      # 0x2a1da
leaq 0x11750(%rip), %rdx     # 0x2b97e
leaq 0x10da2(%rip), %rcx     # 0x2afd7
movl $0x904, %r8d            # imm = 0x904
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
movl 0x1c(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x1a2ae
movq 0x38(%rsp), %rdi
movl 0x24(%rsp), %edx
movq 0x28(%rsp), %rcx
leaq 0x10e01(%rip), %rsi     # 0x2b069
movb $0x0, %al
callq 0x15f90
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x1a2ae
jmp 0x1a27b
movq 0x18d76(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xff4e(%rip), %rsi      # 0x2a1da
leaq 0x116eb(%rip), %rdx     # 0x2b97e
leaq 0x10d3d(%rip), %rcx     # 0x2afd7
movl $0x910, %r8d            # imm = 0x910
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: importCoreLib
static Script* importCoreLib(Compiler* compiler, const char* name_start,
                             int name_length) {
  ASSERT(compiler->scope_depth == DEPTH_GLOBAL, OOPS);

  // Add the name to the script's name buffer, we need it as a key to the
  // vm's script cache.
  int index = (int)scriptAddName(compiler->script, compiler->vm,
                                 name_start, name_length);
  String* module = compiler->script->names.data[index];

  Var entry = mapGet(compiler->vm->core_libs, VAR_OBJ(module));
  if (IS_UNDEF(entry)) {
    parseError(compiler, "No module named '%s' exists.", module->data);
    return NULL;
  }

  // Push the script on the stack.
  emitOpcode(compiler, OP_IMPORT);
  emitShort(compiler, index);

  ASSERT(AS_OBJ(entry)->type == OBJ_SCRIPT, OOPS);
  return (Script*)AS_OBJ(entry);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
cmpl $-0x1, 0xa0(%rax)
je 0x1a31a
movq 0x18d11(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xfe5f(%rip), %rsi      # 0x2a150
leaq 0xff6c(%rip), %rdx      # 0x2a264
leaq 0x1157b(%rip), %rcx     # 0x2b87a
leaq 0x10cd1(%rip), %r8      # 0x2afd7
movl $0x8c9, %r9d            # imm = 0x8C9
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1a31c
movq 0x28(%rsp), %rax
movq 0x18b0(%rax), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rsi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ecx
callq 0x4c60
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x18b0(%rax), %rax
movq 0x60(%rax), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %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 0x1a3c6
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rdx
addq $0x1c, %rdx
leaq 0x114d7(%rip), %rsi     # 0x2b888
movb $0x0, %al
callq 0x15f90
movq $0x0, 0x30(%rsp)
jmp 0x1a447
movq 0x28(%rsp), %rdi
movl $0x26, %esi
callq 0x16650
movq 0x28(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x16690
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x8(%rsp), %rax
cmpl $0x4, (%rax)
je 0x1a431
movq 0x18bfa(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xfd48(%rip), %rsi      # 0x2a150
leaq 0xfe55(%rip), %rdx      # 0x2a264
leaq 0x11464(%rip), %rcx     # 0x2b87a
leaq 0x10bba(%rip), %r8      # 0x2afd7
movl $0x8db, %r9d            # imm = 0x8DB
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1a433
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: compilerImportSingleEntry
static void compilerImportSingleEntry(Compiler* compiler,
                                      const char* name, uint32_t length) {

  // Special names are begins with '$' like function body (only for now).
  // Skip them.
  if (name[0] == '$') return;

  // Line number of the variables which will be bind to the imported symbol.
  int line = compiler->previous.line;

  // Add the name to the **current** script's name buffer.
  int name_index = (int)scriptAddName(compiler->script, compiler->vm,
                                      name, length);

  // Get the function from the script.
  emitOpcode(compiler, OP_GET_ATTRIB_KEEP);
  emitShort(compiler, name_index);

  int index = compilerImportName(compiler, line, name, length);
  if (index != -1) emitStoreVariable(compiler, index, true);
  emitOpcode(compiler, OP_POP);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x24, %eax
jne 0x1a9a4
jmp 0x1aa37
movq 0x20(%rsp), %rax
movl 0x44(%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x18b0(%rax), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rdx
movl 0x14(%rsp), %ecx
callq 0x4c60
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl $0x31, %esi
callq 0x16650
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x16690
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
movq 0x18(%rsp), %rdx
movl 0x14(%rsp), %ecx
callq 0x1a140
movl %eax, 0x8(%rsp)
cmpl $-0x1, 0x8(%rsp)
je 0x1aa28
movq 0x20(%rsp), %rdi
movl 0x8(%rsp), %esi
movl $0x1, %edx
callq 0x18350
movq 0x20(%rsp), %rdi
movl $0x25, %esi
callq 0x16650
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_core.c
// Function: newModuleInternal
static Script* newModuleInternal(PKVM* vm, const char* name) {

  // Create a new Script for the module.
  String* _name = newString(vm, name);
  vmPushTempRef(vm, &_name->_super);

  // Check if any module with the same name already exists and assert to the
  // hosting application.
  if (!IS_UNDEF(mapGet(vm->core_libs, VAR_OBJ(_name)))) {
    vmPopTempRef(vm); // _name
    __ASSERT(false, stringFormat(vm,
             "A module named '$' already exists", name)->data);
  }

  Script* scr = newScript(vm, _name, true);
  vmPopTempRef(vm); // _name

  // Add the script to core_libs.
  vmPushTempRef(vm, &scr->_super);
  mapSet(vm, vm->core_libs, VAR_OBJ(_name), VAR_OBJ(scr));
  vmPopTempRef(vm);

  return scr;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x1aac2
xorl %eax, %eax
movl %eax, 0x14(%rsp)
jmp 0x1aad0
movq 0x38(%rsp), %rdi
callq 0x2130
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %edx
callq 0x2760
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x9420
movq 0x40(%rsp), %rax
movq 0x130(%rax), %rdi
movq 0x30(%rsp), %rsi
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %rsi
callq 0x5f40
movabsq $0x7ffd000000000000, %rcx # imm = 0x7FFD000000000000
cmpq %rcx, %rax
je 0x1ab8f
movq 0x40(%rsp), %rdi
callq 0x95c0
movq 0x184be(%rip), %rax     # 0x32ff8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rdx
leaq 0x11662(%rip), %rsi     # 0x2c1b5
movb $0x0, %al
callq 0x4ed0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
addq $0x1c, %rdx
leaq 0xf5e3(%rip), %rsi      # 0x2a150
leaq 0x11663(%rip), %rcx     # 0x2c1d7
leaq 0x10f1b(%rip), %r8      # 0x2ba96
movl $0x2f5, %r9d            # imm = 0x2F5
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl $0x1, %edx
callq 0x46d0
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0x95c0
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x9420
movq 0x40(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x130(%rax), %rsi
movq 0x30(%rsp), %rdx
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %rdx
movq 0x28(%rsp), %rcx
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %rcx
callq 0x61a0
movq 0x40(%rsp), %rdi
callq 0x95c0
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_core.c
// Function: pkModuleAddGlobal
PK_PUBLIC void pkModuleAddGlobal(PKVM* vm, PkHandle* module,
                                 const char* name, PkHandle* value) {
  __ASSERT(module != NULL, "Argument module was NULL.");
  __ASSERT(value != NULL, "Argument value was NULL.");
  Var scr = module->value;
  __ASSERT(IS_OBJ_TYPE(scr, OBJ_SCRIPT), "Given handle is not a module");

  moduleAddGlobalInternal(vm, (Script*)AS_OBJ(scr), name, value->value);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x1ac6a
movq 0x183c1(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xf50f(%rip), %rsi      # 0x2a150
leaq 0x10365(%rip), %rdx     # 0x2afad
leaq 0x10e35(%rip), %rcx     # 0x2ba84
leaq 0x10e40(%rip), %r8      # 0x2ba96
movl $0x3d, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1ac6c
jmp 0x1ac6e
cmpq $0x0, 0x8(%rsp)
jne 0x1acb0
movq 0x1837b(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xf4c9(%rip), %rsi      # 0x2a150
leaq 0x10e16(%rip), %rdx     # 0x2baa4
leaq 0x10def(%rip), %rcx     # 0x2ba84
leaq 0x10dfa(%rip), %r8      # 0x2ba96
movl $0x3e, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1acb2
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq (%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x1acee
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq (%rsp), %rax
cmpl $0x4, (%rax)
je 0x1ad28
movq 0x18303(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xf451(%rip), %rsi      # 0x2a150
leaq 0x102e3(%rip), %rdx     # 0x2afe9
leaq 0x10d77(%rip), %rcx     # 0x2ba84
leaq 0x10d82(%rip), %r8      # 0x2ba96
movl $0x40, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1ad2a
movq 0x20(%rsp), %rdi
movabsq $0xffffffffffff, %rsi   # imm = 0xFFFFFFFFFFFF
andq (%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rax
movq (%rax), %rcx
callq 0x1ad60
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x1ae3f
movq 0x181ec(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xf33a(%rip), %rsi      # 0x2a150
leaq 0x10190(%rip), %rdx     # 0x2afad
leaq 0x10c99(%rip), %rcx     # 0x2babd
leaq 0x10c6b(%rip), %r8      # 0x2ba96
movl $0x48, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1ae41
movq 0x28(%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 0x1ae80
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x8(%rsp), %rax
cmpl $0x4, (%rax)
je 0x1aeba
movq 0x18171(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xf2bf(%rip), %rsi      # 0x2a150
leaq 0x10151(%rip), %rdx     # 0x2afe9
leaq 0x10c1e(%rip), %rcx     # 0x2babd
leaq 0x10bf0(%rip), %r8      # 0x2ba96
movl $0x4a, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1aebc
movq 0x30(%rsp), %rdi
movabsq $0xffffffffffff, %rsi   # imm = 0xFFFFFFFFFFFF
andq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl 0x14(%rsp), %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x1aef0
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x239e0
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x2130
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movl %eax, %edx
movq 0x38(%rsp), %rcx
movq 0x18(%rsp), %r9
movl $0x1, %r8d
callq 0x4a80
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%rax)
movl 0x24(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x1afe5
movq 0x18046(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xf194(%rip), %rsi      # 0x2a150
leaq 0xffea(%rip), %rdx      # 0x2afad
leaq 0x10b07(%rip), %rcx     # 0x2bad1
leaq 0x10ac5(%rip), %r8      # 0x2ba96
movl $0x51, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1afe7
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x20(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x1b026
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x20(%rsp), %rax
cmpl $0x4, (%rax)
je 0x1b060
movq 0x17fcb(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xf119(%rip), %rsi      # 0x2a150
leaq 0xffab(%rip), %rdx      # 0x2afe9
leaq 0x10a8c(%rip), %rcx     # 0x2bad1
leaq 0x10a4a(%rip), %r8      # 0x2ba96
movl $0x53, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1b062
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x48(%rcx), %eax
jae 0x1b0f8
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2220
cmpl $0x0, %eax
jne 0x1b0e9
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %rsi
callq 0x9080
movq %rax, 0x40(%rsp)
jmp 0x1b101
jmp 0x1b0eb
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1b07e
movq $0x0, 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: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jle 0x1b1e9
movq 0x17e42(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xef90(%rip), %rsi      # 0x2a150
leaq 0x10922(%rip), %rdx     # 0x2bae9
leaq 0x1093b(%rip), %rcx     # 0x2bb09
leaq 0x108c1(%rip), %r8      # 0x2ba96
movl $0x94, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1b1eb
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x1b296
leaq 0x10(%rsp), %rdi
movl 0x20(%rsp), %edx
leaq 0x12968(%rip), %rsi     # 0x2db71
movb $0x0, %al
callq 0x2350
jmp 0x1b212
movq 0x28(%rsp), %rax
movq 0x5f0(%rax), %rax
cmpq $0x0, 0x58(%rax)
je 0x1b25f
movq 0x17dcc(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xef1a(%rip), %rsi      # 0x2a150
leaq 0xf027(%rip), %rdx      # 0x2a264
leaq 0x108c5(%rip), %rcx     # 0x2bb09
leaq 0x1084b(%rip), %r8      # 0x2ba96
movl $0x99, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1b261
movq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rdx
leaq 0x108a8(%rip), %rsi     # 0x2bb1a
movb $0x0, %al
callq 0x4ed0
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq 0x5f0(%rax), %rax
movq %rcx, 0x58(%rax)
movb $0x0, 0x37(%rsp)
jmp 0x1b345
movl 0x24(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jle 0x1b33e
leaq 0x4(%rsp), %rdi
movl 0x1c(%rsp), %edx
leaq 0x128bd(%rip), %rsi     # 0x2db71
movb $0x0, %al
callq 0x2350
jmp 0x1b2bd
movq 0x28(%rsp), %rax
movq 0x5f0(%rax), %rax
cmpq $0x0, 0x58(%rax)
je 0x1b30a
movq 0x17d21(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xee6f(%rip), %rsi      # 0x2a150
leaq 0xef7c(%rip), %rdx      # 0x2a264
leaq 0x1081a(%rip), %rcx     # 0x2bb09
leaq 0x107a0(%rip), %r8      # 0x2ba96
movl $0x9f, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1b30c
movq 0x28(%rsp), %rdi
leaq 0x4(%rsp), %rdx
leaq 0x1081f(%rip), %rsi     # 0x2bb3c
movb $0x0, %al
callq 0x4ed0
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq 0x5f0(%rax), %rax
movq %rcx, 0x58(%rax)
movb $0x0, 0x37(%rsp)
jmp 0x1b345
jmp 0x1b340
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
jmp 0x1b454
movq 0x20(%rsp), %rax
cmpq $0x0, 0x5f0(%rax)
jne 0x1b49d
movq 0x17b8e(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xecdc(%rip), %rsi      # 0x2a150
leaq 0xf241(%rip), %rdx      # 0x2a6bc
leaq 0x106fc(%rip), %rcx     # 0x2bb7e
leaq 0x1060d(%rip), %r8      # 0x2ba96
movl $0xb0, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1b49f
cmpl $0x0, 0x1c(%rsp)
je 0x1b51f
jmp 0x1b4a8
cmpl $0x0, 0x1c(%rsp)
jle 0x1b4e1
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
movq 0x5f0(%rcx), %rcx
movq 0x30(%rcx), %rcx
movq 0x20(%rsp), %rdx
movq 0x5f0(%rdx), %rdx
movq 0x38(%rdx), %rdx
subq %rdx, %rcx
sarq $0x3, %rcx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x1b51b
movq 0x17b10(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xec5e(%rip), %rsi      # 0x2a150
leaq 0x1066d(%rip), %rdx     # 0x2bb66
leaq 0x1067e(%rip), %rcx     # 0x2bb7e
leaq 0x1058f(%rip), %r8      # 0x2ba96
movl $0xb0, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1b51d
jmp 0x1b51f
jmp 0x1b521
cmpq $0x0, 0x10(%rsp)
jne 0x1b563
movq 0x17ac8(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xec16(%rip), %rsi      # 0x2a150
leaq 0x1064a(%rip), %rdx     # 0x2bb8b
leaq 0x10636(%rip), %rcx     # 0x2bb7e
leaq 0x10547(%rip), %r8      # 0x2ba96
movl $0xb0, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1b565
jmp 0x1b567
movq 0x20(%rsp), %rax
movq 0x5f0(%rax), %rax
movq 0x38(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x8af0
movb %al, %cl
movq 0x10(%rsp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movb $0x1, %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: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movl %edx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
jmp 0x1bf48
movq 0x38(%rsp), %rax
cmpq $0x0, 0x5f0(%rax)
jne 0x1bf91
movq 0x1709a(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xe1e8(%rip), %rsi      # 0x2a150
leaq 0xe74d(%rip), %rdx      # 0x2a6bc
leaq 0xfc90(%rip), %rcx      # 0x2bc06
leaq 0xfb19(%rip), %r8       # 0x2ba96
movl $0xfa, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1bf93
cmpl $0x0, 0x34(%rsp)
je 0x1c013
jmp 0x1bf9c
cmpl $0x0, 0x34(%rsp)
jle 0x1bfd5
movl 0x34(%rsp), %eax
movq 0x38(%rsp), %rcx
movq 0x5f0(%rcx), %rcx
movq 0x30(%rcx), %rcx
movq 0x38(%rsp), %rdx
movq 0x5f0(%rdx), %rdx
movq 0x38(%rdx), %rdx
subq %rdx, %rcx
sarq $0x3, %rcx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x1c00f
movq 0x1701c(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xe16a(%rip), %rsi      # 0x2a150
leaq 0xfb79(%rip), %rdx      # 0x2bb66
leaq 0xfc12(%rip), %rcx      # 0x2bc06
leaq 0xfa9b(%rip), %r8       # 0x2ba96
movl $0xfa, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1c011
jmp 0x1c013
jmp 0x1c015
cmpq $0x0, 0x28(%rsp)
jne 0x1c057
movq 0x16fd4(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xe122(%rip), %rsi      # 0x2a150
leaq 0xfb56(%rip), %rdx      # 0x2bb8b
leaq 0xfbca(%rip), %rcx      # 0x2bc06
leaq 0xfa53(%rip), %r8       # 0x2ba96
movl $0xfa, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1c059
jmp 0x1c05b
movq 0x38(%rsp), %rax
movq 0x5f0(%rax), %rax
movq 0x38(%rax), %rax
movslq 0x34(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x24b0
cmpl 0x30(%rsp), %eax
je 0x1c13d
leaq 0x14(%rsp), %rdi
movl 0x34(%rsp), %edx
leaq 0x11ad4(%rip), %rsi     # 0x2db71
movb $0x0, %al
callq 0x2350
jmp 0x1c0a6
movq 0x38(%rsp), %rax
movq 0x5f0(%rax), %rax
cmpq $0x0, 0x58(%rax)
je 0x1c0f3
movq 0x16f38(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0xe086(%rip), %rsi      # 0x2a150
leaq 0xe193(%rip), %rdx      # 0x2a264
leaq 0xfb2e(%rip), %rcx      # 0x2bc06
leaq 0xf9b7(%rip), %r8       # 0x2ba96
movl $0x100, %r9d            # imm = 0x100
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1c0f5
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x30(%rsp), %edi
callq 0x7360
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x14(%rsp), %rcx
leaq 0xfaf8(%rip), %rsi      # 0x2bc14
movb $0x0, %al
callq 0x4ed0
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq 0x5f0(%rax), %rax
movq %rcx, 0x58(%rax)
movb $0x0, 0x47(%rsp)
jmp 0x1c14f
movq 0x28(%rsp), %rax
leaq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw (%rax,%rax)