LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: exprList
static void exprList(Compiler* compiler) {

  emitOpcode(compiler, OP_PUSH_LIST);
  int size_index = emitShort(compiler, 0);

  int size = 0;
  do {
    skipNewLines(compiler);
    if (peek(compiler) == TK_RBRACKET) break;

    compileExpression(compiler);
    emitOpcode(compiler, OP_LIST_APPEND);
    size++;

    skipNewLines(compiler);
  } while (match(compiler, TK_COMMA));

  skipNewLines(compiler);
  consume(compiler, TK_RBRACKET, "Expected ']' after list elements.");

  _FN->opcodes.data[size_index] = (size >> 8) & 0xff;
  _FN->opcodes.data[size_index + 1] = size & 0xff;

  compiler->is_last_call = false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x6, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x16690
movl %eax, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x15f40
movq 0x10(%rsp), %rdi
callq 0x17480
cmpl $0xc, %eax
jne 0x149bb
jmp 0x149fc
movq 0x10(%rsp), %rdi
callq 0x17be0
movq 0x10(%rsp), %rdi
movl $0x9, %esi
callq 0x16650
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x15f40
movq 0x10(%rsp), %rdi
movl $0x5, %esi
callq 0x15f50
testb $0x1, %al
jne 0x149a0
movq 0x10(%rsp), %rdi
callq 0x15f40
movq 0x10(%rsp), %rdi
movl $0xc, %esi
leaq 0x16a67(%rip), %rdx     # 0x2b47e
callq 0x160a0
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)
movq 0x10(%rsp), %rax
movb $0x0, 0x38ce(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: exprSubscript
static void exprSubscript(Compiler* compiler) {
  compileExpression(compiler);
  consume(compiler, TK_RBRACKET, "Expected ']' after subscription ends.");

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

    TokenType assignment = compiler->previous.type;
    if (assignment != TK_EQ) {
      emitOpcode(compiler, OP_GET_SUBSCRIPT_KEEP);
      compileExpression(compiler);
      emitAssignment(compiler, assignment);

    } else {
      compileExpression(compiler);
    }

    emitOpcode(compiler, OP_SET_SUBSCRIPT);

  } else {
    emitOpcode(compiler, OP_GET_SUBSCRIPT);
  }
  compiler->is_last_call = false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x17be0
movq 0x10(%rsp), %rdi
movl $0xc, %esi
leaq 0x16a51(%rip), %rdx     # 0x2b505
callq 0x160a0
movq 0x10(%rsp), %rax
testb $0x1, 0x38cd(%rax)
je 0x14b38
movq 0x10(%rsp), %rdi
callq 0x18490
testb $0x1, %al
jne 0x14ad7
jmp 0x14b38
movq 0x10(%rsp), %rdi
callq 0x15f40
movq 0x10(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0xc(%rsp)
cmpl $0x1a, 0xc(%rsp)
je 0x14b1d
movq 0x10(%rsp), %rdi
movl $0x34, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
callq 0x17be0
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x18670
jmp 0x14b27
movq 0x10(%rsp), %rdi
callq 0x17be0
movq 0x10(%rsp), %rdi
movl $0x35, %esi
callq 0x16650
jmp 0x14b47
movq 0x10(%rsp), %rdi
movl $0x33, %esi
callq 0x16650
movq 0x10(%rsp), %rax
movb $0x0, 0x38ce(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: exprMap
static void exprMap(Compiler* compiler) {
  emitOpcode(compiler, OP_PUSH_MAP);

  do {
    skipNewLines(compiler);
    if (peek(compiler) == TK_RBRACE) break;

    compileExpression(compiler);
    consume(compiler, TK_COLLON, "Expected ':' after map's key.");
    compileExpression(compiler);

    emitOpcode(compiler, OP_MAP_INSERT);

    skipNewLines(compiler);
  } while (match(compiler, TK_COMMA));

  skipNewLines(compiler);
  consume(compiler, TK_RBRACE, "Expected '}' after map elements.");

  compiler->is_last_call = false;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movl $0x7, %esi
callq 0x16650
movq (%rsp), %rdi
callq 0x15f40
movq (%rsp), %rdi
callq 0x17480
cmpl $0xe, %eax
jne 0x14b8c
jmp 0x14bdc
movq (%rsp), %rdi
callq 0x17be0
movq (%rsp), %rdi
movl $0x6, %esi
leaq 0x168fb(%rip), %rdx     # 0x2b4a0
callq 0x160a0
movq (%rsp), %rdi
callq 0x17be0
movq (%rsp), %rdi
movl $0xa, %esi
callq 0x16650
movq (%rsp), %rdi
callq 0x15f40
movq (%rsp), %rdi
movl $0x5, %esi
callq 0x15f50
testb $0x1, %al
jne 0x14b73
movq (%rsp), %rdi
callq 0x15f40
movq (%rsp), %rdi
movl $0xe, %esi
leaq 0x168c9(%rip), %rdx     # 0x2b4be
callq 0x160a0
movq (%rsp), %rax
movb $0x0, 0x38ce(%rax)
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: exprUnaryOp
static void exprUnaryOp(Compiler* compiler) {
  TokenType op = compiler->previous.type;
  skipNewLines(compiler);
  parsePrecedence(compiler, (Precedence)(PREC_UNARY + 1));

  switch (op) {
    case TK_TILD:  emitOpcode(compiler, OP_BIT_NOT); break;
    case TK_MINUS: emitOpcode(compiler, OP_NEGATIVE); break;
    case TK_NOT:   emitOpcode(compiler, OP_NOT); break;
    default:
      UNREACHABLE();
  }

  compiler->is_last_call = false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x15f40
movq 0x10(%rsp), %rdi
movl $0xf, %esi
callq 0x18190
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
subl $0x10, %eax
je 0x14c63
jmp 0x14c4d
movl 0x8(%rsp), %eax
subl $0x16, %eax
je 0x14c74
jmp 0x14c58
movl 0x8(%rsp), %eax
subl $0x3a, %eax
je 0x14c85
jmp 0x14c96
movq 0x10(%rsp), %rdi
movl $0x38, %esi
callq 0x16650
jmp 0x14ccb
movq 0x10(%rsp), %rdi
movl $0x36, %esi
callq 0x16650
jmp 0x14ccb
movq 0x10(%rsp), %rdi
movl $0x37, %esi
callq 0x16650
jmp 0x14ccb
jmp 0x14c98
movq 0x1e359(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x15531(%rip), %rsi     # 0x2a1da
leaq 0x167a3(%rip), %rdx     # 0x2b453
leaq 0x16320(%rip), %rcx     # 0x2afd7
movl $0x5cf, %r8d            # imm = 0x5CF
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
movq 0x10(%rsp), %rax
movb $0x0, 0x38ce(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: exprChainCall
static void exprChainCall(Compiler* compiler) {
  skipNewLines(compiler);
  parsePrecedence(compiler, (Precedence)(PREC_CHAIN_CALL + 1));
  emitOpcode(compiler, OP_SWAP); // Swap the data with the function.

  int argc = 1; // The initial data.

  if (match(compiler, TK_LBRACE)) {
    if (!match(compiler, TK_RBRACE)) {
      do {
        skipNewLines(compiler);
        compileExpression(compiler);
        skipNewLines(compiler);
        argc++;
      } while (match(compiler, TK_COMMA));
      consume(compiler, TK_RBRACE, "Expected '}' after chain call "
                                   "parameter list.");
    }
  }

  // TODO: ensure argc < 256 (MAX_ARGC) 1byte.

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

  compiler->is_last_call = false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x15f40
movq 0x10(%rsp), %rdi
movl $0x10, %esi
callq 0x18190
movq 0x10(%rsp), %rdi
movl $0x5, %esi
callq 0x16650
movl $0x1, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0xd, %esi
callq 0x15f50
testb $0x1, %al
jne 0x14d2e
jmp 0x14d97
movq 0x10(%rsp), %rdi
movl $0xe, %esi
callq 0x15f50
testb $0x1, %al
jne 0x14d95
jmp 0x14d43
movq 0x10(%rsp), %rdi
callq 0x15f40
movq 0x10(%rsp), %rdi
callq 0x17be0
movq 0x10(%rsp), %rdi
callq 0x15f40
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x5, %esi
callq 0x15f50
testb $0x1, %al
jne 0x14d43
movq 0x10(%rsp), %rdi
movl $0xe, %esi
leaq 0x16688(%rip), %rdx     # 0x2b418
callq 0x160a0
jmp 0x14d97
movq 0x10(%rsp), %rdi
movl $0x27, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x166d0
movq 0x10(%rsp), %rax
movb $0x0, 0x38ce(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: exprFunc
static void exprFunc(Compiler* compiler) {
  int fn_index = compileFunction(compiler, FN_LITERAL);
  emitOpcode(compiler, OP_PUSH_FN);
  emitByte(compiler, fn_index);

  compiler->is_last_call = false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x16830
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x22, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x166d0
movq 0x10(%rsp), %rax
movb $0x0, 0x38ce(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: exprValue
static void exprValue(Compiler* compiler) {
  TokenType op = compiler->previous.type;
  switch (op) {
    case TK_NULL:  emitOpcode(compiler, OP_PUSH_NULL);  break;
    case TK_TRUE:  emitOpcode(compiler, OP_PUSH_TRUE);  break;
    case TK_FALSE: emitOpcode(compiler, OP_PUSH_FALSE); break;
    default:
      UNREACHABLE();
  }

  compiler->is_last_call = false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
subl $0x36, %eax
je 0x14e5a
jmp 0x14e44
movl 0x8(%rsp), %eax
subl $0x3b, %eax
je 0x14e6b
jmp 0x14e4f
movl 0x8(%rsp), %eax
subl $0x3c, %eax
je 0x14e7c
jmp 0x14e8d
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x16650
jmp 0x14ec2
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x16650
jmp 0x14ec2
movq 0x10(%rsp), %rdi
movl $0x4, %esi
callq 0x16650
jmp 0x14ec2
jmp 0x14e8f
movq 0x1e162(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x1533a(%rip), %rsi     # 0x2a1da
leaq 0x16684(%rip), %rdx     # 0x2b52b
leaq 0x16129(%rip), %rcx     # 0x2afd7
movl $0x662, %r8d            # imm = 0x662
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
movq 0x10(%rsp), %rax
movb $0x0, 0x38ce(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: exprAnd
void exprAnd(Compiler* compiler) {
  emitOpcode(compiler, OP_JUMP_IF_NOT);
  int false_offset_a = emitShort(compiler, 0xffff); //< Will be patched.

  parsePrecedence(compiler, PREC_LOGICAL_AND);
  emitOpcode(compiler, OP_JUMP_IF_NOT);
  int false_offset_b = emitShort(compiler, 0xffff); //< Will be patched.

  emitOpcode(compiler, OP_PUSH_TRUE);
  emitOpcode(compiler, OP_JUMP);
  int end_offset = emitShort(compiler, 0xffff); //< Will be patched.

  patchJump(compiler, false_offset_a);
  patchJump(compiler, false_offset_b);
  emitOpcode(compiler, OP_PUSH_FALSE);

  patchJump(compiler, end_offset);

  compiler->is_last_call = false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2e, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x16690
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x18190
movq 0x10(%rsp), %rdi
movl $0x2e, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x16690
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
movl $0x2b, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x16690
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x18270
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x18270
movq 0x10(%rsp), %rdi
movl $0x4, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x18270
movq 0x10(%rsp), %rax
movb $0x0, 0x38ce(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: exprOr
void exprOr(Compiler* compiler) {
  emitOpcode(compiler, OP_JUMP_IF);
  int true_offset_a = emitShort(compiler, 0xffff); //< Will be patched.

  parsePrecedence(compiler, PREC_LOGICAL_OR);
  emitOpcode(compiler, OP_JUMP_IF);
  int true_offset_b = emitShort(compiler, 0xffff); //< Will be patched.

  emitOpcode(compiler, OP_PUSH_FALSE);
  emitOpcode(compiler, OP_JUMP);
  int end_offset = emitShort(compiler, 0xffff); //< Will be patched.

  patchJump(compiler, true_offset_a);
  patchJump(compiler, true_offset_b);
  emitOpcode(compiler, OP_PUSH_TRUE);

  patchJump(compiler, end_offset);

  compiler->is_last_call = false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2d, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x16690
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x18190
movq 0x10(%rsp), %rdi
movl $0x2d, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x16690
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x4, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
movl $0x2b, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x16690
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x18270
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x18270
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x18270
movq 0x10(%rsp), %rax
movb $0x0, 0x38ce(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: exprLiteral
static void exprLiteral(Compiler* compiler) {
  Token* value = &compiler->previous;
  int index = compilerAddConstant(compiler, value->value);
  emitOpcode(compiler, OP_PUSH_CONSTANT);
  emitShort(compiler, index);

  compiler->is_last_call = false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x16580
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x16690
movq 0x10(%rsp), %rax
movb $0x0, 0x38ce(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: compilerInit
static void compilerInit(Compiler* compiler, PKVM* vm, const char* source,
                         Script* script, const PkCompileOptions* options) {

  compiler->vm = vm;
  compiler->next_compiler = NULL;

  compiler->source = source;
  compiler->script = script;
  compiler->token_start = source;
  compiler->has_errors = false;
  compiler->need_more_lines = false;
  compiler->options = options;

  compiler->current_char = source;
  compiler->current_line = 1;
  compiler->next.type = TK_ERROR;
  compiler->next.start = NULL;
  compiler->next.length = 0;
  compiler->next.line = 1;
  compiler->next.value = VAR_UNDEFINED;

  compiler->scope_depth = DEPTH_GLOBAL;
  compiler->local_count = 0;
  compiler->stack_size = 0;

  compiler->loop = NULL;
  compiler->func = NULL;

  compiler->forwards_count = 0;
  compiler->new_local = false;
  compiler->is_last_call = false;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x18b0(%rax)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x90(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x91(%rax)
movq -0x28(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x98(%rax)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rsp), %rax
movl $0x1, 0x28(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x70(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x78(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x80(%rax)
movq -0x8(%rsp), %rax
movl $0x1, 0x84(%rax)
movq -0x8(%rsp), %rax
movabsq $0x7ffd000000000000, %rcx # imm = 0x7FFD000000000000
movq %rcx, 0x88(%rax)
movq -0x8(%rsp), %rax
movl $0xffffffff, 0xa0(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rsp), %rax
movl $0x0, 0x18a8(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x18ac(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18b8(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18c0(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x38c8(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x38cc(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x38ce(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: parseError
static void parseError(Compiler* compiler, const char* fmt, ...) {

  Token* token = &compiler->previous;

  // Lex errors would repored earlier by lexError and lexed a TK_ERROR token.
  if (token->type == TK_ERROR) return;

  va_list args;
  va_start(args, fmt);
  const char* path = compiler->script->path->data;
  reportError(compiler, path, token->line, fmt, args);
  va_end(args);
}

// Assembly:
subq $0xf8, %rsp
testb %al, %al
je 0x15fcc
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, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq 0xf0(%rsp), %rax
addq $0x30, %rax
movq %rax, 0xe0(%rsp)
movq 0xe0(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x16013
jmp 0x16092
leaq 0xc0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0x100(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0xf0(%rsp), %rax
movq 0x18b0(%rax), %rax
movq 0x18(%rax), %rax
addq $0x1c, %rax
movq %rax, 0xb8(%rsp)
movq 0xf0(%rsp), %rdi
movq 0xb8(%rsp), %rsi
movq 0xe0(%rsp), %rax
movl 0x14(%rax), %edx
movq 0xe8(%rsp), %rcx
leaq 0xc0(%rsp), %r8
callq 0x192f0
leaq 0xc0(%rsp), %rax
addq $0xf8, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: consume
static void consume(Compiler* self, TokenType expected, const char* err_msg) {

  lexToken(self);
  if (self->previous.type != expected) {
    parseError(self, "%s", err_msg);

    // If the next token is expected discard the current to minimize
    // cascaded errors and continue parsing.
    if (peek(self) == expected) {
      lexToken(self);
    }
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x15990
movq 0x10(%rsp), %rax
movl 0x30(%rax), %eax
cmpl 0xc(%rsp), %eax
je 0x160fc
movq 0x10(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x17a06(%rip), %rsi     # 0x2dadf
movb $0x0, %al
callq 0x15f90
movq 0x10(%rsp), %rdi
callq 0x17480
cmpl 0xc(%rsp), %eax
jne 0x160fa
movq 0x10(%rsp), %rdi
callq 0x15990
jmp 0x160fc
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: compileTopLevelStatement
static void compileTopLevelStatement(Compiler* compiler) {

  // If the statement is call, this will be set to true.
  compiler->is_last_call = false;

  if (match(compiler, TK_CLASS)) {
    compileType(compiler);

  } else if (match(compiler, TK_NATIVE)) {
    compileFunction(compiler, FN_NATIVE);

  } else if (match(compiler, TK_DEF)) {
    compileFunction(compiler, FN_SCRIPT);

  } else if (match(compiler, TK_FROM)) {
    compileFromImport(compiler);

  } else if (match(compiler, TK_IMPORT)) {
    compileRegularImport(compiler);

  } else if (match(compiler, TK_MODULE)) {
    parseError(compiler, "Module name must be the first statement "
                          "of the script.");

  } else {
    compileStatement(compiler);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movb $0x0, 0x38ce(%rax)
movq (%rsp), %rdi
movl $0x2e, %esi
callq 0x15f50
testb $0x1, %al
jne 0x16164
jmp 0x16172
movq (%rsp), %rdi
callq 0x194b0
jmp 0x16233
movq (%rsp), %rdi
movl $0x33, %esi
callq 0x15f50
testb $0x1, %al
jne 0x16186
jmp 0x16196
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x16830
jmp 0x16231
movq (%rsp), %rdi
movl $0x32, %esi
callq 0x15f50
testb $0x1, %al
jne 0x161aa
jmp 0x161ba
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x16830
jmp 0x1622f
movq (%rsp), %rdi
movl $0x2f, %esi
callq 0x15f50
testb $0x1, %al
jne 0x161ce
jmp 0x161d9
movq (%rsp), %rdi
callq 0x19940
jmp 0x1622d
movq (%rsp), %rdi
movl $0x30, %esi
callq 0x15f50
testb $0x1, %al
jne 0x161ed
jmp 0x161f8
movq (%rsp), %rdi
callq 0x19b60
jmp 0x1622b
movq (%rsp), %rdi
movl $0x2d, %esi
callq 0x15f50
testb $0x1, %al
jne 0x1620c
jmp 0x16220
movq (%rsp), %rdi
leaq 0x154c4(%rip), %rsi     # 0x2b6db
movb $0x0, %al
callq 0x15f90
jmp 0x16229
movq (%rsp), %rdi
callq 0x17490
jmp 0x1622b
jmp 0x1622d
jmp 0x1622f
jmp 0x16231
jmp 0x16233
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: resolveError
static void resolveError(Compiler* compiler, int line, const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);
  const char* path = compiler->script->path->data;
  reportError(compiler, path, line, fmt, args);
  va_end(args);
}

// Assembly:
subq $0xf8, %rsp
testb %al, %al
je 0x162dc
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 %rdi, 0xf0(%rsp)
movl %esi, 0xec(%rsp)
movq %rdx, 0xe0(%rsp)
movq %rsp, %rax
movq %rax, 0xd0(%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0xc8(%rsp)
movl $0x30, 0xc4(%rsp)
movl $0x18, 0xc0(%rsp)
movq 0xf0(%rsp), %rax
movq 0x18b0(%rax), %rax
movq 0x18(%rax), %rax
addq $0x1c, %rax
movq %rax, 0xb8(%rsp)
movq 0xf0(%rsp), %rdi
movq 0xb8(%rsp), %rsi
movl 0xec(%rsp), %edx
movq 0xe0(%rsp), %rcx
leaq 0xc0(%rsp), %r8
callq 0x192f0
addq $0xf8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: pkCompileModule
PkResult pkCompileModule(PKVM* vm, PkHandle* module, PkStringPtr source,
                         const PkCompileOptions* options) {
  __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);

  PkResult result = compile(vm, script, source.string, options);
  if (source.on_done) source.on_done(vm, source);
  return result;
}

// Assembly:
subq $0x58, %rsp
leaq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
cmpq $0x0, 0x48(%rsp)
jne 0x163ef
movq 0x1cc3c(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x13d8a(%rip), %rsi     # 0x2a150
leaq 0x14be0(%rip), %rdx     # 0x2afad
leaq 0x14bf3(%rip), %rcx     # 0x2afc7
leaq 0x14bfc(%rip), %r8      # 0x2afd7
movl $0xb43, %r9d            # imm = 0xB43
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x163f1
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x38(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x16430
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x38(%rsp), %rax
cmpl $0x4, (%rax)
je 0x1646a
movq 0x1cbc1(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x13d0f(%rip), %rsi     # 0x2a150
leaq 0x14ba1(%rip), %rdx     # 0x2afe9
leaq 0x14b78(%rip), %rcx     # 0x2afc7
leaq 0x14b81(%rip), %r8      # 0x2afd7
movl $0xb45, %r9d            # imm = 0xB45
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x1646c
movq 0x20(%rsp), %rax
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq 0x38(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movq 0x50(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq (%rax), %rdx
movq 0x40(%rsp), %rcx
callq 0x15420
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x2c(%rsp)
cmpq $0x0, 0x8(%rax)
je 0x164e0
movq 0x20(%rsp), %rcx
movq 0x8(%rcx), %rax
movq 0x50(%rsp), %rdi
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rsp)
callq *%rax
movl 0x2c(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: compilerMarkObjects
void compilerMarkObjects(PKVM* vm, Compiler* compiler) {

  // Mark the script which is currently being compiled.
  markObject(vm, &compiler->script->_super);

  // Mark the string literals (they haven't added to the script's literal
  // buffer yet).
  markValue(vm, compiler->current.value);
  markValue(vm, compiler->previous.value);
  markValue(vm, compiler->next.value);

  if (compiler->next_compiler != NULL) {
    compilerMarkObjects(vm, compiler->next_compiler);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18b0(%rax), %rsi
callq 0x3d50
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rsi
callq 0x3e10
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rsi
callq 0x3e10
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x88(%rax), %rsi
callq 0x3e10
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1656f
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x164f0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: compilerAddConstant
static int compilerAddConstant(Compiler* compiler, Var value) {
  pkVarBuffer* literals = &compiler->script->literals;

  for (uint32_t i = 0; i < literals->count; i++) {
    if (isValuesSame(literals->data[i], value)) {
      return i;
    }
  }

  // Add new constant to script.
  if (literals->count < MAX_CONSTANTS) {
    pkVarBufferWrite(literals, compiler->vm, value);
  } else {
    parseError(compiler, "A script should contain at most %d "
               "unique constants.", MAX_CONSTANTS);
  }
  return (int)literals->count - 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x18b0(%rax), %rax
addq $0x70, %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x165f2
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl 0x4(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rsi
callq 0x76b0
testb $0x1, %al
jne 0x165d9
jmp 0x165e3
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x16640
jmp 0x165e5
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x165ab
movq 0x8(%rsp), %rax
cmpl $0x10000, 0x8(%rax)     # imm = 0x10000
jae 0x16619
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rsp), %rdx
callq 0x34d0
jmp 0x16631
movq 0x18(%rsp), %rdi
leaq 0x149e1(%rip), %rsi     # 0x2b006
movl $0x10000, %edx          # imm = 0x10000
movb $0x0, %al
callq 0x15f90
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: emitByte
static int emitByte(Compiler* compiler, int byte) {

  pkByteBufferWrite(&_FN->opcodes, compiler->vm,
                    (uint8_t)byte);
  pkUintBufferWrite(&_FN->oplines, compiler->vm,
                   compiler->previous.line);
  return (int)_FN->opcodes.count - 1;
}

// 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), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movl 0xc(%rsp), %eax
movzbl %al, %edx
callq 0x3270
movq 0x10(%rsp), %rax
movq 0x18c0(%rax), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rdi
addq $0x10, %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rsp), %rax
movl 0x44(%rax), %edx
callq 0x3020
movq 0x10(%rsp), %rax
movq 0x18c0(%rax), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: compilerChangeStack
static void compilerChangeStack(Compiler* compiler, int num) {
  compiler->stack_size += num;

  // If the compiler has error (such as undefined name, that will not popped
  // because of the semantic error but it'll be popped once the expression
  // parsing is done.
  if (!compiler->has_errors) ASSERT(compiler->stack_size >= 0, OOPS);

  if (compiler->stack_size > _FN->stack_size) {
    _FN->stack_size = compiler->stack_size;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
addl 0x18ac(%rax), %ecx
movl %ecx, 0x18ac(%rax)
movq 0x10(%rsp), %rax
testb $0x1, 0x90(%rax)
jne 0x167de
jmp 0x16792
movq 0x10(%rsp), %rax
cmpl $0x0, 0x18ac(%rax)
jge 0x167da
movq 0x1c851(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x1399f(%rip), %rsi     # 0x2a150
leaq 0x13aac(%rip), %rdx     # 0x2a264
leaq 0x1487c(%rip), %rcx     # 0x2b03b
leaq 0x14811(%rip), %r8      # 0x2afd7
movl $0x701, %r9d            # imm = 0x701
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x167dc
jmp 0x167de
movq 0x10(%rsp), %rax
movl 0x18ac(%rax), %eax
movq 0x10(%rsp), %rcx
movq 0x18c0(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq 0x38(%rcx), %rcx
cmpl 0x20(%rcx), %eax
jle 0x16824
movq 0x10(%rsp), %rax
movl 0x18ac(%rax), %ecx
movq 0x10(%rsp), %rax
movq 0x18c0(%rax), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
movl %ecx, 0x20(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: compilerPushFunc
static void compilerPushFunc(Compiler* compiler, Func* fn,
                             Function* func, int index) {
  fn->outer_func = compiler->func;
  fn->ptr = func;
  fn->depth = compiler->scope_depth;
  fn->index = index;
  compiler->func = fn;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movq 0x18c0(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movl 0xa0(%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
movl -0x1c(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x18c0(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: compilerAddVariable
static int compilerAddVariable(Compiler* compiler, const char* name,
                                uint32_t length, int line) {

  // TODO: should I validate the name for pre-defined, etc?

  // Check if maximum variable count is reached.
  bool max_vars_reached = false;
  const char* var_type = ""; // For max variables reached error message.
  if (compiler->scope_depth == DEPTH_GLOBAL) {
    if (compiler->script->globals.count >= MAX_VARIABLES) {
      max_vars_reached = true;
      var_type = "globals";
    }
  } else {
    if (compiler->local_count >= MAX_VARIABLES) {
      max_vars_reached = true;
      var_type = "locals";
    }
  }
  if (max_vars_reached) {
    parseError(compiler, "A script should contain at most %d %s.",
               MAX_VARIABLES, var_type);
    return -1;
  }

  // Add the variable and return it's index.

  if (compiler->scope_depth == DEPTH_GLOBAL) {
    return (int)scriptAddGlobal(compiler->vm, compiler->script,
                                name, length, VAR_NULL);
  } else {
    Local* local = &compiler->locals [compiler->local_count];
    local->name = name;
    local->length = length;
    local->depth = compiler->scope_depth;
    local->line = line;
    return compiler->local_count++;
  }

  UNREACHABLE();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl %ecx, 0x18(%rsp)
movb $0x0, 0x17(%rsp)
leaq 0x1525a(%rip), %rax     # 0x2c2ec
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
cmpl $-0x1, 0xa0(%rax)
jne 0x170cd
movq 0x28(%rsp), %rax
movq 0x18b0(%rax), %rax
cmpl $0x100, 0x28(%rax)      # imm = 0x100
jb 0x170cb
movb $0x1, 0x17(%rsp)
leaq 0x140ad(%rip), %rax     # 0x2b173
movq %rax, 0x8(%rsp)
jmp 0x170f1
movq 0x28(%rsp), %rax
cmpl $0x100, 0x18a8(%rax)    # imm = 0x100
jl 0x170ef
movb $0x1, 0x17(%rsp)
leaq 0x14091(%rip), %rax     # 0x2b17b
movq %rax, 0x8(%rsp)
jmp 0x170f1
testb $0x1, 0x17(%rsp)
je 0x17122
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rcx
leaq 0x14079(%rip), %rsi     # 0x2b182
movl $0x100, %edx            # imm = 0x100
movb $0x0, %al
callq 0x15f90
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x171d2
movq 0x28(%rsp), %rax
cmpl $-0x1, 0xa0(%rax)
jne 0x17162
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x18b0(%rax), %rsi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ecx
movabsq $0x7ffc000000000000, %r8 # imm = 0x7FFC000000000000
callq 0x4970
movl %eax, 0x34(%rsp)
jmp 0x171d2
movq 0x28(%rsp), %rax
addq $0xa8, %rax
movq 0x28(%rsp), %rcx
movslq 0x18a8(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movl 0x1c(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rax
movl 0xa0(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0xc(%rax)
movl 0x18(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x28(%rsp), %rcx
movl 0x18a8(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x18a8(%rcx)
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: compileBlockBody
static void compileBlockBody(Compiler* compiler, BlockType type) {

  compilerEnterBlock(compiler);

  if (type == BLOCK_IF) {
    consumeStartBlock(compiler, TK_THEN);
    skipNewLines(compiler);

  } else if (type == BLOCK_ELSE) {
    skipNewLines(compiler);

  } else if (type == BLOCK_FUNC) {
    // Function body doesn't require a 'do' or 'then' delimiter to enter.
    skipNewLines(compiler);

  } else {
    // For/While loop block body delimiter is 'do'.
    consumeStartBlock(compiler, TK_DO);
    skipNewLines(compiler);
  }

  TokenType next = peek(compiler);
  while (!(next == TK_END || next == TK_EOF || (
    (type == BLOCK_IF) && (next == TK_ELSE || next == TK_ELSIF)))) {

    compileStatement(compiler);
    skipNewLines(compiler);

    next = peek(compiler);
  }

  compilerExitBlock(compiler);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x17050
cmpl $0x2, 0xc(%rsp)
jne 0x17219
movq 0x10(%rsp), %rdi
movl $0x3e, %esi
callq 0x173f0
movq 0x10(%rsp), %rdi
callq 0x15f40
jmp 0x1725c
cmpl $0x3, 0xc(%rsp)
jne 0x1722c
movq 0x10(%rsp), %rdi
callq 0x15f40
jmp 0x1725a
cmpl $0x0, 0xc(%rsp)
jne 0x1723f
movq 0x10(%rsp), %rdi
callq 0x15f40
jmp 0x17258
movq 0x10(%rsp), %rdi
movl $0x3d, %esi
callq 0x173f0
movq 0x10(%rsp), %rdi
callq 0x15f40
jmp 0x1725a
jmp 0x1725c
movq 0x10(%rsp), %rdi
callq 0x17480
movl %eax, 0x8(%rsp)
movb $0x1, %al
cmpl $0x35, 0x8(%rsp)
movb %al, 0x7(%rsp)
je 0x172ba
movb $0x1, %al
cmpl $0x1, 0x8(%rsp)
movb %al, 0x7(%rsp)
je 0x172ba
xorl %eax, %eax
cmpl $0x2, 0xc(%rsp)
movb %al, 0x6(%rsp)
jne 0x172b2
movb $0x1, %al
cmpl $0x43, 0x8(%rsp)
movb %al, 0x5(%rsp)
je 0x172aa
cmpl $0x42, 0x8(%rsp)
sete %al
movb %al, 0x5(%rsp)
movb 0x5(%rsp), %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x172c6
jmp 0x172ea
movq 0x10(%rsp), %rdi
callq 0x17490
movq 0x10(%rsp), %rdi
callq 0x15f40
movq 0x10(%rsp), %rdi
callq 0x17480
movl %eax, 0x8(%rsp)
jmp 0x1726a
movq 0x10(%rsp), %rdi
callq 0x17300
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: compilerExitBlock
static void compilerExitBlock(Compiler* compiler) {
  ASSERT(compiler->scope_depth > (int)DEPTH_GLOBAL, "Cannot exit toplevel.");

  // Discard all the locals at the current scope.
  int popped = compilerPopLocals(compiler, compiler->scope_depth);
  compiler->local_count -= popped;
  compiler->stack_size -= popped;
  compiler->scope_depth--;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $-0x1, 0xa0(%rax)
jg 0x17351
movq 0x1bcda(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x12e28(%rip), %rsi     # 0x2a150
leaq 0x1405e(%rip), %rdx     # 0x2b38d
leaq 0x1406d(%rip), %rcx     # 0x2b3a3
leaq 0x13c9a(%rip), %r8      # 0x2afd7
movl $0x721, %r9d            # imm = 0x721
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x17353
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0xa0(%rax), %esi
callq 0x17a00
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edx
movq 0x10(%rsp), %rax
movl 0x18a8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x18a8(%rax)
movl 0xc(%rsp), %edx
movq 0x10(%rsp), %rax
movl 0x18ac(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x18ac(%rax)
movq 0x10(%rsp), %rax
movl 0xa0(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xa0(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: consumeStartBlock
static void consumeStartBlock(Compiler* compiler, TokenType delimiter) {
  bool consumed = false;

  // Match optional "do" or "then".
  if (delimiter == TK_DO || delimiter == TK_THEN) {
    if (match(compiler, delimiter))
      consumed = true;
  }

  if (matchLine(compiler))
    consumed = true;

  if (!consumed) {
    const char* msg;
    if (delimiter == TK_DO) msg = "Expected enter block with newline or 'do'.";
    else msg = "Expected enter block with newline or 'then'.";
    parseError(compiler, msg);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movb $0x0, 0xb(%rsp)
cmpl $0x3d, 0xc(%rsp)
je 0x17410
cmpl $0x3e, 0xc(%rsp)
jne 0x1742b
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x15f50
testb $0x1, %al
jne 0x17424
jmp 0x17429
movb $0x1, 0xb(%rsp)
jmp 0x1742b
movq 0x10(%rsp), %rdi
callq 0x17960
testb $0x1, %al
jne 0x1743b
jmp 0x17440
movb $0x1, 0xb(%rsp)
testb $0x1, 0xb(%rsp)
jne 0x17476
cmpl $0x3d, 0xc(%rsp)
jne 0x1745b
leaq 0x13d54(%rip), %rax     # 0x2b1a9
movq %rax, (%rsp)
jmp 0x17466
leaq 0x13d72(%rip), %rax     # 0x2b1d4
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movb $0x0, %al
callq 0x15f90
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: matchLine
static bool matchLine(Compiler* compiler) {

  bool consumed = false;

  if (peek(compiler) == TK_LINE) {
    while (peek(compiler) == TK_LINE)
      lexToken(compiler);
    consumed = true;
  }

  // If we're running on REPL mode, at the EOF and compile time error occurred,
  // signal the host to get more lines and try re-compiling it.
  if (compiler->options && compiler->options->repl_mode &&
    !compiler->has_errors) {
    if (peek(compiler) == TK_EOF) {
      compiler->need_more_lines = true;
    }
  }

  return consumed;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movb $0x0, 0xf(%rsp)
movq 0x10(%rsp), %rdi
callq 0x17480
cmpl $0x2, %eax
jne 0x1799f
jmp 0x1797f
movq 0x10(%rsp), %rdi
callq 0x17480
cmpl $0x2, %eax
jne 0x1799a
movq 0x10(%rsp), %rdi
callq 0x15990
jmp 0x1797f
movb $0x1, 0xf(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x98(%rax)
je 0x179eb
movq 0x10(%rsp), %rax
movq 0x98(%rax), %rax
testb $0x1, 0x1(%rax)
je 0x179eb
movq 0x10(%rsp), %rax
testb $0x1, 0x90(%rax)
jne 0x179eb
movq 0x10(%rsp), %rdi
callq 0x17480
cmpl $0x1, %eax
jne 0x179e9
movq 0x10(%rsp), %rax
movb $0x1, 0x91(%rax)
jmp 0x179eb
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: compilerPopLocals
static int compilerPopLocals(Compiler* compiler, int depth) {
  ASSERT(depth > (int)DEPTH_GLOBAL, "Cannot pop global variables.");

  int local = compiler->local_count - 1;
  while (local >= 0 && compiler->locals[local].depth >= depth) {

    // Note: Do not use emitOpcode(compiler, OP_POP);
    // Because this function is called at the middle of a scope (break,
    // continue). So we need the pop instruction here but we still need the
    // locals to continue parsing the next statements in the scope. They'll be
    // popped once the scope is ended.
    emitByte(compiler, OP_POP);

    local--;
  }
  return (compiler->local_count - 1) - local;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpl $-0x1, 0xc(%rsp)
jg 0x17a4e
movq 0x1b5dd(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x1272b(%rip), %rsi     # 0x2a150
leaq 0x13875(%rip), %rdx     # 0x2b2a1
leaq 0x1388b(%rip), %rcx     # 0x2b2be
leaq 0x1359d(%rip), %r8      # 0x2afd7
movl $0x70e, %r9d            # imm = 0x70E
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x17a50
movq 0x10(%rsp), %rax
movl 0x18a8(%rax), %eax
subl $0x1, %eax
movl %eax, 0x8(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x8(%rsp)
movb %al, 0x7(%rsp)
jl 0x17a94
movq 0x10(%rsp), %rax
addq $0xa8, %rax
movslq 0x8(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
cmpl 0xc(%rsp), %eax
setge %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x17a9e
jmp 0x17aba
movq 0x10(%rsp), %rdi
movl $0x25, %esi
callq 0x166d0
movl 0x8(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x17a62
movq 0x10(%rsp), %rax
movl 0x18a8(%rax), %eax
subl $0x1, %eax
subl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: matchEndStatement
static bool matchEndStatement(Compiler* compiler) {
  if (match(compiler, TK_SEMICOLLON)) {
    skipNewLines(compiler);
    return true;
  }
  if (matchLine(compiler) || peek(compiler) == TK_EOF)
    return true;

  // In the below statement we don't require any new lines or semicolons.
  // 'if cond then stmnt1 elsif cond2 then stmnt2 else stmnt3 end'
  if (peek(compiler) == TK_END || peek(compiler) == TK_ELSE ||
      peek(compiler) == TK_ELSIF)
    return true;

  return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x7, %esi
callq 0x15f50
testb $0x1, %al
jne 0x17b5e
jmp 0x17b6f
movq 0x8(%rsp), %rdi
callq 0x15f40
movb $0x1, 0x17(%rsp)
jmp 0x17bcc
movq 0x8(%rsp), %rdi
callq 0x17960
testb $0x1, %al
jne 0x17b8c
movq 0x8(%rsp), %rdi
callq 0x17480
cmpl $0x1, %eax
jne 0x17b93
movb $0x1, 0x17(%rsp)
jmp 0x17bcc
movq 0x8(%rsp), %rdi
callq 0x17480
cmpl $0x35, %eax
je 0x17bc0
movq 0x8(%rsp), %rdi
callq 0x17480
cmpl $0x43, %eax
je 0x17bc0
movq 0x8(%rsp), %rdi
callq 0x17480
cmpl $0x42, %eax
jne 0x17bc7
movb $0x1, 0x17(%rsp)
jmp 0x17bcc
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: compileIfStatement
static void compileIfStatement(Compiler* compiler, bool elsif) {

  skipNewLines(compiler);
  compileExpression(compiler); //< Condition.
  emitOpcode(compiler, OP_JUMP_IF_NOT);
  int ifpatch = emitShort(compiler, 0xffff); //< Will be patched.

  compileBlockBody(compiler, BLOCK_IF);

  if (match(compiler, TK_ELSIF)) {

    // Jump pass else.
    emitOpcode(compiler, OP_JUMP);
    int exit_jump = emitShort(compiler, 0xffff); //< Will be patched.

    // if (false) jump here.
    patchJump(compiler, ifpatch);

    compilerEnterBlock(compiler);
    compileIfStatement(compiler, true);
    compilerExitBlock(compiler);

    patchJump(compiler, exit_jump);

  } else if (match(compiler, TK_ELSE)) {

    // Jump pass else.
    emitOpcode(compiler, OP_JUMP);
    int exit_jump = emitShort(compiler, 0xffff); //< Will be patched.

    patchJump(compiler, ifpatch);
    compileBlockBody(compiler, BLOCK_ELSE);
    patchJump(compiler, exit_jump);

  } else {
    patchJump(compiler, ifpatch);
  }

  // elsif will not consume the 'end' keyword as it'll be leaved to be consumed
  // by it's 'if'.
  if (!elsif) {
    skipNewLines(compiler);
    consume(compiler, TK_END, "Expected 'end' after statement end.");
  }
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rdi
callq 0x15f40
movq 0x10(%rsp), %rdi
callq 0x17be0
movq 0x10(%rsp), %rdi
movl $0x2e, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x16690
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x171e0
movq 0x10(%rsp), %rdi
movl $0x42, %esi
callq 0x15f50
testb $0x1, %al
jne 0x17c6c
jmp 0x17ccf
movq 0x10(%rsp), %rdi
movl $0x2b, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x16690
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x18270
movq 0x10(%rsp), %rdi
callq 0x17050
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x17c00
movq 0x10(%rsp), %rdi
callq 0x17300
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x18270
jmp 0x17d41
movq 0x10(%rsp), %rdi
movl $0x43, %esi
callq 0x15f50
testb $0x1, %al
jne 0x17ce4
jmp 0x17d31
movq 0x10(%rsp), %rdi
movl $0x2b, %esi
callq 0x16650
movq 0x10(%rsp), %rdi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x16690
movl %eax, (%rsp)
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x18270
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x171e0
movq 0x10(%rsp), %rdi
movl (%rsp), %esi
callq 0x18270
jmp 0x17d3f
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x18270
jmp 0x17d41
testb $0x1, 0xf(%rsp)
jne 0x17d68
movq 0x10(%rsp), %rdi
callq 0x15f40
movq 0x10(%rsp), %rdi
movl $0x35, %esi
leaq 0x13585(%rip), %rdx     # 0x2b2e8
callq 0x160a0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/src/pk_compiler.c
// Function: compileWhileStatement
static void compileWhileStatement(Compiler* compiler) {
  Loop loop;
  loop.start = (int)_FN->opcodes.count;
  loop.patch_count = 0;
  loop.outer_loop = compiler->loop;
  loop.depth = compiler->scope_depth;
  compiler->loop = &loop;

  compileExpression(compiler); //< Condition.
  emitOpcode(compiler, OP_JUMP_IF_NOT);
  int whilepatch = emitShort(compiler, 0xffff); //< Will be patched.

  compileBlockBody(compiler, BLOCK_LOOP);

  emitLoopJump(compiler);
  patchJump(compiler, whilepatch);

  // Patch break statement.
  for (int i = 0; i < compiler->loop->patch_count; i++) {
    patchJump(compiler, compiler->loop->patches[i]);
  }
  compiler->loop = loop.outer_loop;

  skipNewLines(compiler);
  consume(compiler, TK_END, "Expected 'end' after statement end.");
}

// Assembly:
subq $0x438, %rsp            # imm = 0x438
movq %rdi, 0x430(%rsp)
movq 0x430(%rsp), %rax
movq 0x18c0(%rax), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, 0x10(%rsp)
movl $0x0, 0x418(%rsp)
movq 0x430(%rsp), %rax
movq 0x18b8(%rax), %rax
movq %rax, 0x420(%rsp)
movq 0x430(%rsp), %rax
movl 0xa0(%rax), %eax
movl %eax, 0x428(%rsp)
movq 0x430(%rsp), %rax
leaq 0x10(%rsp), %rcx
movq %rcx, 0x18b8(%rax)
movq 0x430(%rsp), %rdi
callq 0x17be0
movq 0x430(%rsp), %rdi
movl $0x2e, %esi
callq 0x16650
movq 0x430(%rsp), %rdi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x16690
movl %eax, 0xc(%rsp)
movq 0x430(%rsp), %rdi
movl $0x1, %esi
callq 0x171e0
movq 0x430(%rsp), %rdi
callq 0x17ae0
movq 0x430(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x18270
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x430(%rsp), %rcx
movq 0x18b8(%rcx), %rcx
cmpl 0x408(%rcx), %eax
jge 0x17ea2
movq 0x430(%rsp), %rdi
movq 0x430(%rsp), %rax
movq 0x18b8(%rax), %rax
movslq 0x8(%rsp), %rcx
movl 0x8(%rax,%rcx,4), %esi
callq 0x18270
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x17e55
movq 0x420(%rsp), %rcx
movq 0x430(%rsp), %rax
movq %rcx, 0x18b8(%rax)
movq 0x430(%rsp), %rdi
callq 0x15f40
movq 0x430(%rsp), %rdi
movl $0x35, %esi
leaq 0x1340e(%rip), %rdx     # 0x2b2e8
callq 0x160a0
addq $0x438, %rsp            # imm = 0x438
retq
nopw (%rax,%rax)