LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x12323
leaq 0xe953(%rip), %rdx      # 0x1e36c
movq %rbx, %rdi
movl $0xc, %esi
callq 0x11171
movl $0x33, %ebp
cmpb $0x1, 0x38cd(%rbx)
jne 0xfa8f
movq %rbx, %rdi
callq 0x12445
testb %al, %al
je 0xfa8f
movq %rbx, %rdi
callq 0x11e66
movl 0x30(%rbx), %ebp
movq %rbx, %rdi
cmpl $0x1a, %ebp
jne 0xfa5f
movl $0x1, %esi
callq 0x12323
jmp 0xfa8a
movl $0x34, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movq %rbx, %rdi
movl $0x1, %esi
callq 0x12323
movq %rbx, %rdi
movl %ebp, %esi
callq 0x124f5
movl $0x35, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movb $0x0, 0x38ce(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x7, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movq %rbx, %rdi
callq 0x11e66
cmpl $0xe, 0x50(%rbx)
je 0xfb46
leaq 0xe826(%rip), %r14      # 0x1e307
movq %rbx, %rdi
movl $0x1, %esi
callq 0x12323
movq %rbx, %rdi
movl $0x6, %esi
movq %r14, %rdx
callq 0x11171
movq %rbx, %rdi
movl $0x1, %esi
callq 0x12323
movq %rbx, %rdi
movl $0xa, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movq %rbx, %rdi
callq 0x11e66
cmpl $0x5, 0x50(%rbx)
jne 0xfb46
movq %rbx, %rdi
callq 0x10b76
movq %rbx, %rdi
callq 0x11e66
cmpl $0xe, 0x50(%rbx)
jne 0xfae1
movq %rbx, %rdi
callq 0x11e66
leaq 0xe7d0(%rip), %rdx      # 0x1e325
movq %rbx, %rdi
movl $0xe, %esi
callq 0x11171
movb $0x0, 0x38ce(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x30(%rdi), %ebp
callq 0x11e66
movq %rbx, %rdi
movl $0xf, %esi
callq 0x12323
cmpl $0x10, %ebp
je 0xfba9
cmpl $0x3a, %ebp
je 0xfba2
cmpl $0x16, %ebp
jne 0xfbce
movl $0x36, %esi
jmp 0xfbae
movl $0x37, %esi
jmp 0xfbae
movl $0x38, %esi
movq %rbx, %rdi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movb $0x0, 0x38ce(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x4aa5
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x11e66
movq %rbx, %rdi
movl $0x10, %esi
callq 0x12323
movq %rbx, %rdi
movl $0x5, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movl $0x1, %ebp
cmpl $0xd, 0x50(%rbx)
jne 0xfc8a
movq %rbx, %rdi
callq 0x10b76
cmpl $0xe, 0x50(%rbx)
jne 0xfc25
movq %rbx, %rdi
callq 0x10b76
jmp 0xfc8a
movq %rbx, %rdi
callq 0x11e66
movq %rbx, %rdi
movl $0x1, %esi
callq 0x12323
movq %rbx, %rdi
callq 0x11e66
movl $0x2, %ebp
cmpl $0x5, 0x50(%rbx)
jne 0xfc76
movq %rbx, %rdi
callq 0x10b76
movq %rbx, %rdi
callq 0x11e66
movq %rbx, %rdi
movl $0x1, %esi
callq 0x12323
movq %rbx, %rdi
callq 0x11e66
incl %ebp
jmp 0xfc47
leaq 0xe602(%rip), %rdx      # 0x1e27f
movq %rbx, %rdi
movl $0xe, %esi
callq 0x11171
movq %rbx, %rdi
movl $0x27, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1135b
movb $0x0, 0x38ce(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2, %esi
callq 0x113e6
movl %eax, %ebp
movq %rbx, %rdi
movl $0x22, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1135b
movb $0x0, 0x38ce(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movq %rdi, %rbx
movl 0x30(%rdi), %eax
cmpl $0x36, %eax
je 0xfd1e
cmpl $0x3c, %eax
je 0xfd17
cmpl $0x3b, %eax
jne 0xfd3e
movl $0x3, %esi
jmp 0xfd23
movl $0x4, %esi
jmp 0xfd23
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movb $0x0, 0x38ce(%rbx)
popq %rbx
retq
callq 0x4ad4
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2e, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1135b
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1135b
leal -0x1(%rax), %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12323
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1135b
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1135b
leal -0x1(%rax), %r14d
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movq %rbx, %rdi
movl $0x2b, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1135b
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1135b
leal -0x1(%rax), %r15d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x123a2
movq %rbx, %rdi
movl %r14d, %esi
callq 0x123a2
movq %rbx, %rdi
movl $0x4, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movq %rbx, %rdi
movl %r15d, %esi
callq 0x123a2
movb $0x0, 0x38ce(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2d, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1135b
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1135b
leal -0x1(%rax), %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12323
movq %rbx, %rdi
movl $0x2d, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1135b
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1135b
leal -0x1(%rax), %r14d
movq %rbx, %rdi
movl $0x4, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movq %rbx, %rdi
movl $0x2b, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1135b
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1135b
leal -0x1(%rax), %r15d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x123a2
movq %rbx, %rdi
movl %r14d, %esi
callq 0x123a2
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movq %rbx, %rdi
movl %r15d, %esi
callq 0x123a2
movb $0x0, 0x38ce(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %r15
movq 0x18b0(%rdi), %r13
leaq 0x70(%r13), %r12
cmpl $0x0, 0x78(%r13)
je 0x101ff
xorl %r14d, %r14d
movq (%r12), %rax
movq (%rax,%r14,8), %rdi
movq %r15, %rsi
callq 0xaa89
testb %al, %al
jne 0x10236
incq %r14
movl 0x78(%r13), %eax
cmpq %rax, %r14
jb 0x101df
cmpl $0xffff, 0x78(%r13)     # imm = 0xFFFF
ja 0x10219
movq (%rbx), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x8736
jmp 0x1022f
leaq 0xdc56(%rip), %rsi      # 0x1de76
movq %rbx, %rdi
movl $0x10000, %edx          # imm = 0x10000
xorl %eax, %eax
callq 0x110cb
movl 0x78(%r13), %r14d
decl %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movl %r14d, %esi
shrl $0x8, %esi
movl $0xff, %ebp
andl %ebp, %esi
movq %rbx, %rdi
callq 0x1135b
andl %ebp, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1135b
movb $0x0, 0x38ce(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_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 $0xd8, %rsp
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x11112
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
cmpl $0x0, 0x30(%rdi)
je 0x11169
movq %rsi, %r10
leaq 0x20(%rsp), %rax
movq %rsp, %r8
movq %rax, 0x10(%r8)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%r8)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r8)
movq 0x18b0(%rdi), %rax
movq 0x18(%rax), %rsi
addq $0x1c, %rsi
movl 0x44(%rdi), %edx
movq %r10, %rcx
callq 0x12aaa
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x10b76
cmpl %ebp, 0x30(%rbx)
je 0x111ac
leaq 0xf7cd(%rip), %rsi      # 0x2095b
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x110cb
cmpl %ebp, 0x50(%rbx)
jne 0x111ac
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x10b76
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_compiler.c
// Function: emitFunctionEnd
static void emitFunctionEnd(Compiler* compiler) {

  // Don't use emitOpcode(compiler, OP_RETURN); Because it'll recude the stack
  // size by -1, (return value will be popped). We really don't have to pop the
  // return value of the function, when returning from the end of the function,
  // because there'll always be a null value at the base of the current call
  // frame as the return value of the function.
  emitByte(compiler, OP_RETURN);

  emitOpcode(compiler, OP_END);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2f, %esi
callq 0x1135b
movq %rbx, %rdi
movl $0x4c, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x113b1
// File: /workspace/github_c_makefile_star2_O1/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 $0xd8, %rsp
movl %esi, %edx
leaq 0x20(%rsp), %rsi
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x1124d
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r8
movq %rsi, 0x10(%r8)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%r8)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%r8)
movq 0x18b0(%rdi), %rax
movq 0x18(%rax), %rsi
addq $0x1c, %rsi
leaq 0xcb7e(%rip), %rcx      # 0x1de01
callq 0x12aaa
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
testq %rsi, %rsi
je 0x11305
movq (%rsi), %rsi
movq %rsi, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x11300
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rax, %rsi
cmpl $0x4, (%rsi)
jne 0x11300
movq %rdx, %rcx
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movq (%r14), %rdx
callq 0x10283
movl %eax, %ebp
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x112f5
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq *%rax
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x4ba5
callq 0x4bdb
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18b0(%rbx), %rsi
movq %r14, %rdi
callq 0x8b42
movq 0x68(%rbx), %rsi
movq %r14, %rdi
callq 0x8ba0
movq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0x8ba0
movq 0x88(%rbx), %rsi
movq %r14, %rdi
callq 0x8ba0
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x11314
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movq %rdi, %rbx
movq 0x18c0(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rdi
movq (%rbx), %rax
movzbl %sil, %edx
movq %rax, %rsi
callq 0x8624
movq 0x18c0(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rdi
addq $0x10, %rdi
movq (%rbx), %rsi
movl 0x44(%rbx), %edx
callq 0x851b
movq 0x18c0(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
movl 0x8(%rax), %eax
decl %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
addl 0x18ac(%rdi), %esi
movl %esi, 0x18ac(%rdi)
setns %al
orb 0x90(%rdi), %al
je 0x113e0
movq 0x18c0(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
cmpl 0x20(%rax), %esi
jle 0x113df
movl %esi, 0x20(%rax)
retq
pushq %rax
callq 0x4c11
// File: /workspace/github_c_makefile_star2_O1/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:
movl %edx, %r9d
movq %rsi, %rdx
movl 0xa0(%rdi), %esi
cmpl $-0x1, %esi
je 0x11878
cmpl $0x100, 0x18a8(%rdi)    # imm = 0x100
setge %al
leaq 0xc780(%rip), %r10      # 0x1dfeb
leaq 0xd8ea(%rip), %r8       # 0x1f15c
cmovgeq %r10, %r8
jmp 0x1189b
movq 0x18b0(%rdi), %rax
cmpl $0x100, 0x28(%rax)      # imm = 0x100
setae %al
leaq 0xc753(%rip), %r10      # 0x1dfe3
leaq 0xd8c5(%rip), %r8       # 0x1f15c
cmovaeq %r10, %r8
testb %al, %al
je 0x118c0
pushq %rax
leaq 0xc74b(%rip), %rsi      # 0x1dff2
movl $0x100, %edx            # imm = 0x100
movq %r8, %rcx
xorl %eax, %eax
callq 0x110cb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
retq
cmpl $-0x1, %esi
je 0x118fa
movslq 0x18a8(%rdi), %rax
leaq (%rax,%rax,2), %r8
movq %rdx, 0xa8(%rdi,%r8,8)
movl %r9d, 0xb0(%rdi,%r8,8)
movl %esi, 0xb4(%rdi,%r8,8)
movl %ecx, 0xb8(%rdi,%r8,8)
leal 0x1(%rax), %ecx
movl %ecx, 0x18a8(%rdi)
retq
movq (%rdi), %rax
movq 0x18b0(%rdi), %rsi
movabsq $0x7ffc000000000000, %r8 # imm = 0x7FFC000000000000
movq %rax, %rdi
movl %r9d, %ecx
jmp 0x91fa
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
incl 0xa0(%rdi)
movl %esi, %ebp
movl $0x3e, %esi
cmpl $0x2, %ebp
je 0x1193f
testl %ebp, %ebp
je 0x11947
movl $0x3d, %esi
cmpl $0x3, %ebp
je 0x11947
movq %rbx, %rdi
callq 0x119b2
movq %rbx, %rdi
callq 0x11e66
xorl $0x2, %ebp
movl 0x50(%rbx), %eax
cmpl $0x1, %eax
je 0x1197b
cmpl $0x35, %eax
je 0x1197b
andl $-0x2, %eax
xorl $0x42, %eax
orl %ebp, %eax
je 0x1197b
movq %rbx, %rdi
callq 0x11a11
movq %rbx, %rdi
callq 0x11e66
jmp 0x11952
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x11986
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movl 0xa0(%rdi), %esi
testl %esi, %esi
js 0x119ad
movq %rdi, %rbx
callq 0x11eb9
subl %eax, 0x18a8(%rbx)
subl %eax, 0x18ac(%rbx)
decl 0xa0(%rbx)
popq %rbx
retq
callq 0x4d1f
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leal -0x3d(%r14), %eax
cmpl $0x1, %eax
ja 0x119d9
cmpl %r14d, 0x50(%rbx)
sete %bpl
jne 0x119db
movq %rbx, %rdi
callq 0x10b76
jmp 0x119db
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x11e66
orb %bpl, %al
je 0x119ed
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x3d, %r14d
leaq 0xc621(%rip), %rax      # 0x1e019
leaq 0xc645(%rip), %rsi      # 0x1e044
cmoveq %rax, %rsi
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x110cb
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x50(%rdi), %ebp
cmpl $0x2, %ebp
jne 0x11e84
cmpl $0x2, 0x50(%rbx)
jne 0x11e84
movq %rbx, %rdi
callq 0x10b76
jmp 0x11e74
movq 0x98(%rbx), %rax
testq %rax, %rax
je 0x11eac
cmpb $0x1, 0x1(%rax)
jne 0x11eac
cmpb $0x0, 0x90(%rbx)
jne 0x11eac
cmpl $0x1, 0x50(%rbx)
jne 0x11eac
movb $0x1, 0x91(%rbx)
cmpl $0x2, %ebp
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x11f1e
movq %rdi, %rbx
movslq 0x18a8(%rdi), %r14
testq %r14, %r14
jle 0x11f0a
movl %esi, %ebp
leaq (%r14,%r14,2), %rax
leaq (%rbx,%rax,8), %r15
addq $0x9c, %r15
cmpl %ebp, (%r15)
jl 0x11f0a
decq %r14
movq %rbx, %rdi
movl $0x25, %esi
callq 0x1135b
leaq 0x1(%r14), %rax
addq $-0x18, %r15
cmpq $0x1, %rax
jg 0x11ee4
xorl %r14d, %r14d
movl 0x18a8(%rbx), %eax
subl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x4df7
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movq %rdi, %rbx
cmpl $0x7, 0x50(%rdi)
jne 0x11fa1
movq %rbx, %rdi
callq 0x10b76
movq %rbx, %rdi
callq 0x11e66
movb $0x1, %al
jmp 0x11fcd
movq %rbx, %rdi
callq 0x11e66
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x11fcd
movl 0x50(%rbx), %ecx
leal -0x35(%rcx), %edx
cmpl $0xe, %edx
ja 0x11fc6
movl $0x6001, %esi           # imm = 0x6001
btl %edx, %esi
jb 0x11fcd
cmpl $0x1, %ecx
je 0x11fcd
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x11e66
movq %rbx, %rdi
movl $0x1, %esi
callq 0x12323
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1135b
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1135b
movl %eax, %r14d
decl %r14d
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11919
cmpl $0x42, 0x50(%rbx)
jne 0x1209e
movq %rbx, %rdi
callq 0x10b76
movq %rbx, %rdi
movl $0x2b, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1135b
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1135b
movl %eax, %r15d
decl %r15d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x123a2
incl 0xa0(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x11fcf
movq %rbx, %rdi
callq 0x11986
jmp 0x120fb
cmpl $0x43, 0x50(%rbx)
jne 0x120fe
movq %rbx, %rdi
callq 0x10b76
movq %rbx, %rdi
movl $0x2b, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1135b
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1135b
movl %eax, %r15d
decl %r15d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x123a2
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11919
movl %r15d, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x123a2
testb %bpl, %bpl
je 0x12119
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x11e66
leaq 0xc030(%rip), %rdx      # 0x1e158
movq %rbx, %rdi
movl $0x35, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11171
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x10b76
movslq 0x30(%rbx), %rax
leaq (%rax,%rax,2), %rax
leaq 0x17ec0(%rip), %r14     # 0x2a200
movq (%r14,%rax,8), %rax
testq %rax, %rax
je 0x1238d
movb $0x0, 0x38ce(%rbx)
cmpl $0x2, %ebp
setb 0x38cd(%rbx)
movq %rbx, %rdi
callq *%rax
movslq 0x50(%rbx), %rax
leaq (%rax,%rax,2), %rax
cmpl %ebp, 0x10(%r14,%rax,8)
jb 0x12388
movq %rbx, %rdi
callq 0x10b76
movslq 0x30(%rbx), %rax
leaq (%rax,%rax,2), %rax
movq %rbx, %rdi
callq *0x8(%r14,%rax,8)
jmp 0x1235f
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xbdac(%rip), %rsi      # 0x1e140
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x110cb
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x18c0(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rcx
movl 0x8(%rcx), %eax
subl %esi, %eax
addl $-0x2, %eax
cmpl $0x10000, %eax          # imm = 0x10000
jge 0x123e0
movq (%rcx), %rcx
movslq %esi, %rdx
movb %ah, (%rcx,%rdx)
movq 0x18c0(%rdi), %rcx
movq 0x8(%rcx), %rcx
movq 0x38(%rcx), %rcx
movq (%rcx), %rcx
movb %al, 0x1(%rcx,%rdx)
retq
pushq %rax
callq 0x4e2d
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testl %edx, %edx
je 0x123fc
movq %rbx, %rdi
movl $0x21, %esi
jmp 0x12426
cmpl $0x8, %ebp
jg 0x1241e
addl $0x16, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x113b1
movq %rbx, %rdi
movl $0x1f, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1135b
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testl %edx, %edx
je 0x124ac
movq %rbx, %rdi
movl $0x20, %esi
jmp 0x124d6
cmpl $0x8, %ebp
jg 0x124ce
addl $0xc, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x113b1
movq %rbx, %rdi
movl $0x15, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1135b
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
addl $-0x21, %esi
cmpl $0xc, %esi
jae 0x12527
movl $0xcff, %eax            # imm = 0xCFF
btl %esi, %eax
jae 0x12527
movq %rdi, %rbx
movl %esi, %eax
leaq 0xb85c(%rip), %rcx      # 0x1dd70
movl (%rcx,%rax,4), %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x113b1
callq 0x4e63
// File: /workspace/github_c_makefile_star2_O1/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 $0xd8, %rsp
movq %rsi, %r10
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x12a68
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r8
movq %rsi, 0x10(%r8)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%r8)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r8)
movq 0x18b0(%rdi), %rax
movq 0x18(%rax), %rsi
addq $0x1c, %rsi
movl 0x28(%rdi), %edx
movq %r10, %rcx
callq 0x12aaa
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movl %edx, %ebx
movq %rsi, %r14
movq 0x98(%rdi), %rax
testq %rax, %rax
je 0x12ad6
cmpb $0x1, 0x1(%rax)
jne 0x12ad6
cmpb $0x0, 0x90(%rdi)
jne 0x12b2e
movb $0x1, 0x90(%rdi)
cmpb $0x1, 0x91(%rdi)
jne 0x12af6
testq %rax, %rax
je 0x12af1
cmpb $0x0, 0x1(%rax)
jne 0x12b2e
callq 0x4ec8
movq (%rdi), %r15
cmpq $0x0, 0xd0(%r15)
je 0x12b2e
movq %rsp, %rdi
movl $0x200, %esi            # imm = 0x200
movq %rcx, %rdx
movq %r8, %rcx
callq 0x20d0
testl %eax, %eax
js 0x12b3b
movq %rsp, %r8
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movl %ebx, %ecx
callq *0xd0(%r15)
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
callq 0x4e92
// File: /workspace/github_c_makefile_star2_O1/atomlang[P]atomlang/src/pk_compiler.c
// Function: compilerImportAll
static void compilerImportAll(Compiler* compiler, Script* script) {

  ASSERT(script != NULL, OOPS);
  ASSERT(compiler->scope_depth == DEPTH_GLOBAL, OOPS);

  // Import all types.
  for (uint32_t i = 0; i < script->classes.count; i++) {
    uint32_t name_ind = script->classes.data[i]->name;
    String* name = script->names.data[name_ind];
    compilerImportSingleEntry(compiler, name->data, name->length);
  }

  // Import all functions.
  for (uint32_t i = 0; i < script->functions.count; i++) {
    const char* name = script->functions.data[i]->name;
    uint32_t length = (uint32_t)strlen(name);
    compilerImportSingleEntry(compiler, name, length);
  }

  // Import all globals.
  for (uint32_t i = 0; i < script->globals.count; i++) {
    ASSERT(i < script->global_names.count, OOPS);
    ASSERT(script->global_names.data[i] < script->names.count, OOPS);
    const String* name = script->names.data[script->global_names.data[i]];

    compilerImportSingleEntry(compiler, name->data, name->length);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $-0x1, 0xa0(%rdi)
jne 0x13051
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x58(%rsi)
je 0x12fca
xorl %r15d, %r15d
movq 0x50(%rbx), %rax
movq 0x60(%rbx), %rcx
movq (%rax,%r15,8), %rax
movl 0x18(%rax), %eax
movq (%rcx,%rax,8), %rsi
movl 0x14(%rsi), %edx
addq $0x1c, %rsi
movq %r14, %rdi
callq 0x130e5
incq %r15
movl 0x58(%rbx), %eax
cmpq %rax, %r15
jb 0x12f9d
cmpl $0x0, 0x48(%rbx)
je 0x12fff
xorl %r12d, %r12d
movq 0x40(%rbx), %rax
movq (%rax,%r12,8), %rax
movq 0x10(%rax), %r15
movq %r15, %rdi
callq 0x2140
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x130e5
incq %r12
movl 0x48(%rbx), %eax
cmpq %rax, %r12
jb 0x12fd3
cmpl $0x0, 0x28(%rbx)
je 0x1303b
xorl %r15d, %r15d
cmpl 0x38(%rbx), %r15d
jae 0x1304c
movq 0x30(%rbx), %rax
movl (%rax,%r15,4), %eax
cmpl 0x68(%rbx), %eax
jae 0x13047
movq 0x60(%rbx), %rcx
movq (%rcx,%rax,8), %rsi
movl 0x14(%rsi), %edx
addq $0x1c, %rsi
movq %r14, %rdi
callq 0x130e5
incq %r15
cmpl 0x28(%rbx), %r15d
jb 0x13008
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x50ae
callq 0x5078
callq 0x5042
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $-0x1, 0xa0(%rdi)
jne 0x130d6
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq %rdx, %rsi
movl %ecx, %edx
callq 0x116bc
cmpl $0x5, %eax
ja 0x130e0
movl %eax, %ecx
leaq 0xacd0(%rip), %rdx      # 0x1dd58
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0xae41(%rip), %rsi      # 0x1ded9
movq %r15, %rdi
movl %ebx, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x110cb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x130b2
shrq $0x20, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11846
callq 0x50e4
callq 0x511a
callq 0x5149
// File: /workspace/github_c_makefile_star2_O1/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:
cmpb $0x24, (%rsi)
jne 0x130eb
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x44(%rdi), %r15d
movq 0x18b0(%rdi), %rdi
movq (%rbx), %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x93bb
movl %eax, %r12d
movq %rbx, %rdi
movl $0x31, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x113b1
movl %r12d, %esi
shrl $0x8, %esi
movl $0xff, %r13d
andl %r13d, %esi
movq %rbx, %rdi
callq 0x1135b
andl %r13d, %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x1135b
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x13056
cmpl $-0x1, %eax
je 0x13179
movq %rbx, %rdi
movl %eax, %esi
movl $0x1, %edx
callq 0x123e6
movq %rbx, %rdi
movl $0x25, %esi
callq 0x1135b
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x113b1
nop
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
testq %rsi, %rsi
je 0x131e0
movq %r15, %rdi
callq 0x2140
movq %rax, %rdx
jmp 0x131e2
xorl %edx, %edx
movabsq $-0x4000000000000, %r14 # imm = 0xFFFC000000000000
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7fc8
movq %rax, %r13
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb8d6
movq 0x130(%rbx), %rdi
movq %r13, %r12
orq %r14, %r12
movq %r12, %rsi
callq 0x9f27
movabsq $0x7ffd000000000000, %rcx # imm = 0x7FFD000000000000
cmpq %rcx, %rax
jne 0x1327c
movq %rbx, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x90b5
movq %rax, %r15
movq %rbx, %rdi
callq 0xb949
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb8d6
movq 0x130(%rbx), %rsi
orq %r15, %r14
movq %rbx, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0xa060
movq %rbx, %rdi
callq 0xb949
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5178
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rax
testq %rsi, %rsi
je 0x132c0
testq %rcx, %rcx
je 0x132c5
movq (%rsi), %rsi
movq %rsi, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x132bb
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rax, %rsi
cmpl $0x4, (%rsi)
jne 0x132bb
movq (%rcx), %rcx
popq %rax
jmp 0x132ca
callq 0x51d1
callq 0x5239
callq 0x5205