LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: addUpvalue
static int32_t addUpvalue(bluCompiler* compiler, uint16_t index, bool isLocal) {
	// Look for an existing one.
	uint16_t upvalueCount = compiler->function->upvalueCount;
	for (uint16_t i = 0; i < upvalueCount; i++) {
		bluUpvalue* upvalue = &compiler->upvalues.data[i];
		if (upvalue->index == index && upvalue->isLocal == isLocal) {
			return i;
		}
	}

	// If we got here, it's a new upvalue.
	if (upvalueCount == LOCALS_MAX) {
		error(compiler, "Too many closure variables in function.");
		return 0;
	}

	bluUpvalue upvalue;
	upvalue.isLocal = isLocal;
	upvalue.index = index;
	bluUpvalueBufferWrite(&compiler->upvalues, upvalue);

	return compiler->function->upvalueCount++;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movzwl 0x22(%rax), %ecx
addq $0x48, %rdi
xorl %eax, %eax
cmpq %rax, %rcx
je 0x391a
movq (%rdi), %r8
cmpw %si, (%r8,%rax,4)
jne 0x3915
cmpb %dl, 0x2(%r8,%rax,4)
je 0x3955
incq %rax
jmp 0x38ff
cmpl $0xfffe, %ecx           # imm = 0xFFFE
jne 0x3935
leaq 0x58a5(%rip), %rsi      # 0x91ce
movq %rbx, %rdi
callq 0x350f
xorl %eax, %eax
jmp 0x3955
movzbl %dl, %eax
shll $0x10, %eax
movzwl %si, %esi
orl %eax, %esi
callq 0x295a
movq 0x28(%rbx), %rcx
movzwl 0x22(%rcx), %eax
movl %eax, %edx
incl %edx
movw %dx, 0x22(%rcx)
movzwl %ax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: parsePrecedence
static void parsePrecedence(bluCompiler* compiler, Precedence precedence) {
	advance(compiler);

	ParseFn prefixRule = getRule(compiler->parser->previous.type)->prefix;
	if (prefixRule == NULL) {
		error(compiler, "Expect expression.");
		return;
	}

	bool canAssign = precedence <= PREC_ASSIGNMENT;
	prefixRule(compiler, canAssign);

	while (precedence <= getRule(compiler->parser->current.type)->precedence) {
		advance(compiler);

		ParseFn infixRule = getRule(compiler->parser->previous.type)->infix;
		infixRule(compiler, canAssign);
	}

	if (canAssign) {
		if (match(compiler, TOKEN_EQUAL)) {
			error(compiler, "Invalid assignment target.");

			// Parse the expression so compiler prints propper error messages.
			expression(compiler);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x301d
movq 0x8(%rbx), %rax
movl 0x20(%rax), %eax
imulq $0x18, %rax, %rax
leaq 0xb5c9(%rip), %r14      # 0xf120
movq (%rax,%r14), %rax
testq %rax, %rax
je 0x3bce
xorl %esi, %esi
cmpl $0x2, %ebp
setb %sil
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rax
movl 0x40(%rax), %eax
imulq $0x18, %rax, %rax
cmpl %ebp, 0x10(%rax,%r14)
jb 0x3b9a
movq %rbx, %rdi
callq 0x301d
movq 0x8(%rbx), %rax
movl 0x20(%rax), %eax
imulq $0x18, %rax, %rax
movq 0x8(%rax,%r14), %rax
jmp 0x3b60
cmpl $0x1, %ebp
ja 0x3bc9
pushq $0xf
popq %rsi
movq %rbx, %rdi
callq 0x30a5
testb %al, %al
je 0x3bc9
leaq 0x578f(%rip), %rsi      # 0x9344
movq %rbx, %rdi
callq 0x350f
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x38a1
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x575c(%rip), %rsi      # 0x9331
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x350f
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: parseVariable
static uint16_t parseVariable(bluCompiler* compiler, const char* errorMessage) {
	consume(compiler, TOKEN_IDENTIFIER, errorMessage);

	declareVariable(compiler);
	if (compiler->scopeDepth > 0) {
		return 0;
	}

	return identifierConstant(compiler, &compiler->parser->previous);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
pushq $0x19
popq %rsi
callq 0x377a
cmpb $0x0, 0x58(%rbx)
je 0x3c8b
movq 0x8(%rbx), %r14
addq $0x20, %r14
movl 0x40(%rbx), %r12d
imulq $0x28, %r12, %r13
addq $-0x28, %r13
leaq 0x5683(%rip), %r15      # 0x92a4
testl %r12d, %r12d
jle 0x3c5b
movq 0x38(%rbx), %rsi
movb 0x20(%rsi,%r13), %al
cmpb $-0x1, %al
je 0x3c38
cmpb 0x58(%rbx), %al
jl 0x3c5b
addq %r13, %rsi
movq %r14, %rdi
callq 0x38c9
testb %al, %al
je 0x3c52
movq %rbx, %rdi
movq %r15, %rsi
callq 0x350f
decl %r12d
addq $-0x28, %r13
jmp 0x3c21
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x3da1
cmpb $0x0, 0x58(%rbx)
jle 0x3c8b
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rsi
addq $0x20, %rsi
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x379f
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: defineVariable
static void defineVariable(bluCompiler* compiler, uint16_t index) {
	if (compiler->scopeDepth > 0) {
		markInitialized(compiler);
		return;
	}

	emitByte(compiler, OP_DEFINE_GLOBAL);
	emitShort(compiler, index);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x58(%rdi), %al
testb %al, %al
jle 0x3ccc
movq 0x38(%rbx), %rcx
movslq 0x40(%rbx), %rdx
imulq $0x28, %rdx, %rdx
movb %al, -0x8(%rcx,%rdx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %esi, %ebp
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x37c2
movzwl %bp, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x372f
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: expectNewlineOrSemicolon
static void expectNewlineOrSemicolon(bluCompiler* compiler) {
	// TODO : Improve consuming of newlines
	// If previous token is TOKEN_RIGHT_BRACE then all newlines were already consumed
	if (compiler->parser->previous.type == TOKEN_RIGHT_BRACE) return;

	// If current token is TOKEN_RIGHT_BRACE then we don't need newline nor semicolon
	if (compiler->parser->current.type == TOKEN_RIGHT_BRACE) return;

	if (!match(compiler, TOKEN_SEMICOLON)) {
		consume(compiler, TOKEN_NEWLINE, "Expect newline or ';'.");
	}
}

// Assembly:
pushq %rbx
movq 0x8(%rdi), %rax
cmpl $0x8, 0x20(%rax)
je 0x3d0a
cmpl $0x8, 0x40(%rax)
je 0x3d0a
movq %rdi, %rbx
pushq $0xb
popq %rsi
callq 0x30a5
testb %al, %al
je 0x3d0c
popq %rbx
retq
leaq 0x55ef(%rip), %rdx      # 0x9302
pushq $0x30
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x377a
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: endScope
static void endScope(bluCompiler* compiler) {
	compiler->scopeDepth--;

	while (compiler->locals.count > 0 &&
		   compiler->locals.data[compiler->locals.count - 1].depth > compiler->scopeDepth) {
		if (compiler->locals.data[compiler->locals.count - 1].isUpvalue) {
			emitByte(compiler, OP_CLOSE_OPVALUE);
		} else {
			emitByte(compiler, OP_POP);
		}

		compiler->locals.count--;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
decb 0x58(%rdi)
movl 0x40(%rdi), %eax
pushq $0x27
popq %rbp
pushq $0x5
popq %r14
testl %eax, %eax
jle 0x3d9c
movq 0x38(%rbx), %rcx
movl %eax, %eax
imulq $0x28, %rax, %rax
movb -0x8(%rcx,%rax), %dl
cmpb 0x58(%rbx), %dl
jle 0x3d9c
addq %rax, %rcx
cmpb $0x0, -0x7(%rcx)
movl %ebp, %esi
jne 0x3d8a
movl %r14d, %esi
movq %rbx, %rdi
callq 0x37c2
movl 0x40(%rbx), %eax
decl %eax
movl %eax, 0x40(%rbx)
jmp 0x3d65
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: addLocal
static void addLocal(bluCompiler* compiler, bluToken name) {
	if (compiler->locals.count == LOCALS_MAX) {
		error(compiler, "Too many local variables in function.");
		return;
	}

	bluLocal local;
	local.name = name;
	local.depth = -1;
	local.isUpvalue = false;

	bluLocalBufferWrite(&compiler->locals, local);
}

// Assembly:
cmpl $0xfffe, 0x40(%rdi)     # imm = 0xFFFE
jne 0x3db6
leaq 0x552b(%rip), %rsi      # 0x92dc
jmp 0x350f
subq $0x58, %rsp
leaq 0x60(%rsp), %rax
addq $0x38, %rdi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movaps %xmm1, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movw $0xff, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movaps 0x30(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x1
popq %rsi
callq 0x282b
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: emitConstant
static uint16_t emitConstant(bluCompiler* compiler, bluValue value) {
	uint16_t constant = makeConstant(compiler, value);

	emitByte(compiler, OP_CONSTANT);
	emitShort(compiler, constant);

	return constant;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x374f
movl %eax, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x37c2
movzwl %bp, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x372f
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: patchJump
static void patchJump(bluCompiler* compiler, int32_t jump) {
	bluChunk* currentChunk = &compiler->function->chunk;

	int32_t length = currentChunk->code.count - jump - 2;

	currentChunk->code.data[jump] = (length >> 8) & 0xff;
	currentChunk->code.data[jump + 1] = length & 0xff;
}

// Assembly:
movq 0x28(%rdi), %rcx
movl 0x40(%rcx), %eax
subl %esi, %eax
addl $-0x2, %eax
movq 0x38(%rcx), %rdx
movslq %esi, %rsi
movb %ah, (%rdx,%rsi)
movq 0x38(%rcx), %rcx
movb %al, 0x1(%rcx,%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: varDeclaration
static void varDeclaration(bluCompiler* compiler) {
	uint8_t name = parseVariable(compiler, "Expect variable name.");

	if (match(compiler, TOKEN_EQUAL)) {
		expression(compiler);
	} else {
		emitByte(compiler, OP_NIL);
	}

	defineVariable(compiler, name);

	expectNewlineOrSemicolon(compiler);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x558d(%rip), %rsi      # 0x945c
callq 0x3be1
movl %eax, %ebp
pushq $0xf
popq %rsi
movq %rbx, %rdi
callq 0x30a5
testb %al, %al
je 0x3eef
movq %rbx, %rdi
callq 0x38a1
jmp 0x3efa
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x37c2
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x3ca8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3cea
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: ifStatement
static void ifStatement(bluCompiler* compiler) {
	beginScope(compiler);

	expression(compiler);
	int32_t ifJump = emitJump(compiler, OP_JUMP_IF_FALSE);
	emitByte(compiler, OP_POP); // Condition

	// One-line if notation
	if (match(compiler, TOKEN_COLON)) {
		statement(compiler);

		int32_t elseJump = emitJump(compiler, OP_JUMP);
		patchJump(compiler, ifJump);
		emitByte(compiler, OP_POP); // Condition
		patchJump(compiler, elseJump);
		endScope(compiler);
		return;
	}

	consume(compiler, TOKEN_LEFT_BRACE, "Expect '{' after if condition.");
	beginScope(compiler);
	block(compiler);
	endScope(compiler);

	int32_t elseJump = emitJump(compiler, OP_JUMP);
	patchJump(compiler, ifJump);
	emitByte(compiler, OP_POP); // Condition

	if (match(compiler, TOKEN_ELSE)) {
		if (match(compiler, TOKEN_LEFT_BRACE)) {
			beginScope(compiler);
			block(compiler);
			endScope(compiler);
		} else if (match(compiler, TOKEN_IF)) {
			ifStatement(compiler);
		} else {
			error(compiler, "Expect 'if' or '{' after 'else.'");
		}
	}

	patchJump(compiler, elseJump);

	endScope(compiler);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
incb 0x58(%rdi)
callq 0x38a1
pushq $0x16
popq %rsi
movq %rbx, %rdi
callq 0x3e80
movl %eax, %r14d
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x37c2
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x30a5
testb %al, %al
je 0x42f3
movq %rbx, %rdi
callq 0x3f14
pushq $0x15
popq %rsi
movq %rbx, %rdi
callq 0x3e80
movl %eax, %ebp
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3ea3
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x37c2
jmp 0x439a
leaq 0x524e(%rip), %rdx      # 0x9548
pushq $0x5
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x377a
incb 0x58(%rbx)
movq %rbx, %rdi
callq 0x3d1f
movq %rbx, %rdi
callq 0x3d51
pushq $0x15
popq %rsi
movq %rbx, %rdi
callq 0x3e80
movl %eax, %ebp
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3ea3
movq %rbx, %rdi
movl %r15d, %esi
callq 0x37c2
pushq $0x21
popq %rsi
movq %rbx, %rdi
callq 0x30a5
testb %al, %al
je 0x439a
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x30a5
testb %al, %al
je 0x4372
incb 0x58(%rbx)
movq %rbx, %rdi
callq 0x3d1f
movq %rbx, %rdi
callq 0x3d51
jmp 0x439a
pushq $0x26
popq %rsi
movq %rbx, %rdi
callq 0x30a5
testb %al, %al
je 0x438b
movq %rbx, %rdi
callq 0x4289
jmp 0x439a
leaq 0x51d5(%rip), %rsi      # 0x9567
movq %rbx, %rdi
callq 0x350f
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3ea3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3d51
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: emitLoop
static void emitLoop(bluCompiler* compiler, int32_t loopStart) {
	emitByte(compiler, OP_LOOP);

	int32_t offset = compiler->function->chunk.code.count - loopStart + 2;

	if (offset > UINT16_MAX) error(compiler, "Loop body too large.");

	emitShort(compiler, offset);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x18
popq %rsi
callq 0x37c2
movq 0x28(%rbx), %rax
movl 0x40(%rax), %r14d
subl %ebp, %r14d
cmpl $0xfffe, %r14d          # imm = 0xFFFE
jl 0x4407
leaq 0x51ab(%rip), %rsi      # 0x95aa
movq %rbx, %rdi
callq 0x350f
addl $0x2, %r14d
movzwl %r14w, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x372f
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: emitReturn
static void emitReturn(bluCompiler* compiler) {
	// An initializer automatically returns "@".
	if (compiler->type == TYPE_INITIALIZER) {
		emitByte(compiler, OP_GET_LOCAL);
		emitShort(compiler, 0);
	} else {
		emitByte(compiler, OP_NIL);
	}

	emitByte(compiler, OP_RETURN);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x4, 0x30(%rdi)
jne 0x443c
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x37c2
movq %rbx, %rdi
xorl %esi, %esi
callq 0x372f
jmp 0x4447
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x37c2
pushq $0x30
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x37c2
nop
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/debug/debug.c
// Function: constantInstruction
static int32_t constantInstruction(const char* name, bluChunk* chunk, int32_t offset) {
	uint16_t slot = ((chunk->code.data[offset + 1] << 8) & 0xff) | (chunk->code.data[offset + 2] & 0xff);
	printf("%-16s %6d '", name, slot);
	bluPrintValue(chunk->constants.data[slot]);
	printf("'\n");
	return offset + 3;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rsi
movq 0x10(%r14), %rax
movslq %edx, %rbx
movzbl 0x2(%rax,%rbx), %r15d
leaq 0x5196(%rip), %rdi      # 0x99f6
movl %r15d, %edx
xorl %eax, %eax
callq 0x20f0
movq 0x40(%r14), %rax
shll $0x4, %r15d
movl (%rax,%r15), %edi
movq 0x8(%rax,%r15), %rsi
callq 0x6797
leaq 0x5179(%rip), %rdi      # 0x9a00
callq 0x2070
addl $0x3, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/debug/debug.c
// Function: invokeInstruction
static int32_t invokeInstruction(const char* name, bluChunk* chunk, int32_t offset) {
	uint8_t argCount = chunk->code.data[offset + 1];
	uint16_t slot = ((chunk->code.data[offset + 2] << 8) & 0xff) | (chunk->code.data[offset + 3] & 0xff);
	printf("%-16s %6d (%d)\n", name, slot, argCount);
	return offset + 4;
}

// Assembly:
pushq %rbx
movq %rdi, %rax
movq 0x10(%rsi), %rsi
movslq %edx, %rbx
movzbl 0x1(%rsi,%rbx), %ecx
movzbl 0x3(%rsi,%rbx), %edx
leaq 0x5132(%rip), %rdi      # 0x9a0d
movq %rax, %rsi
xorl %eax, %eax
callq 0x20f0
addl $0x4, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/debug/debug.c
// Function: bluDisassembleChunk
void bluDisassembleChunk(bluChunk* chunk) {
	printf("========= %s::%s\n", chunk->file, chunk->name);

	int32_t offset = 0;
	while (offset < chunk->code.count) {
		offset = bluDisassembleInstruction(chunk, offset);
	}

	printf("\n");
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
leaq 0x50b4(%rip), %rdi      # 0x99e4
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x20f0
cmpl 0x18(%rbx), %ebp
jge 0x494c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4454
movl %eax, %ebp
jmp 0x4939
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2040
nop
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/lib/core/core.c
// Function: Array_push
int8_t Array_push(bluVM* vm, int8_t argCount, bluValue* args) {
	bluObjArray* array = AS_ARRAY(args[0]);
	bluValue value = args[1];

	if (array->len == array->cap) {
		int32_t newCap = bluPowerOf2Ceil(array->cap * 2);

		if (newCap == 0) newCap = 8;

		array->data = bluReallocate(vm, array->data, (sizeof(bluValue) * array->cap), (sizeof(bluValue) * newCap));
		array->cap = newCap;
	}

	array->data[array->len++] = value;

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x8(%rdx), %r14
movups 0x10(%rdx), %xmm0
movaps %xmm0, (%rsp)
movl 0x20(%r14), %ecx
cmpl 0x24(%r14), %ecx
jne 0x4a4b
movq %rdi, %rbx
movslq %ecx, %rdi
addq %rdi, %rdi
callq 0x26a4
testl %eax, %eax
pushq $0x8
popq %rcx
cmovnel %eax, %ecx
movq 0x28(%r14), %rsi
movslq 0x24(%r14), %rdx
shlq $0x4, %rdx
movslq %ecx, %r15
movq %r15, %rcx
shlq $0x4, %rcx
movq %rbx, %rdi
callq 0x558b
movq %rax, 0x28(%r14)
movl %r15d, 0x24(%r14)
movl 0x20(%r14), %ecx
jmp 0x4a4f
movq 0x28(%r14), %rax
leal 0x1(%rcx), %edx
movl %edx, 0x20(%r14)
movslq %ecx, %rcx
shlq $0x4, %rcx
movaps (%rsp), %xmm0
movups %xmm0, (%rax,%rcx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/lib/core/core.c
// Function: String_reverse
int8_t String_reverse(bluVM* vm, int8_t argCount, bluValue* args) {
	bluObjString* string = AS_STRING(args[0]);

	bluObjString* reversed = bluNewString(vm, string->length);

	reversed->chars[string->length] = '\0';
	for (int32_t i = 0; i < string->length; i++) {
		reversed->chars[i] = string->chars[string->length - 1 - i];
	}

	args[0] = OBJ_VAL(bluTakeString(vm, reversed));

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdx), %r15
movl 0x20(%r15), %esi
callq 0x5bb7
movslq 0x20(%r15), %rcx
movb $0x0, 0x28(%rax,%rcx)
pushq $-0x1
popq %rcx
xorl %edx, %edx
movslq 0x20(%r15), %rsi
cmpq %rsi, %rdx
jge 0x4b01
addl %ecx, %esi
movslq %esi, %rsi
movb 0x28(%r15,%rsi), %sil
movb %sil, 0x28(%rax,%rdx)
incq %rdx
decl %ecx
jmp 0x4ae2
movq %r14, %rdi
movq %rax, %rsi
callq 0x5c0b
movl $0x3, (%rbx)
movq %rax, 0x8(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/lib/core/core.c
// Function: String_split
int8_t String_split(bluVM* vm, int8_t argCount, bluValue* args) {
	bluObjString* string = AS_STRING(args[0]);
	bluObjString* delimeter = AS_STRING(args[1]);

	bluObjArray* array = bluNewArray(vm, 0);

	char *token, *str, *tofree;
	tofree = str = strdup(string->chars);

	while ((token = strsep(&str, delimeter->chars)) != NULL) {
		bluObjString* part = bluCopyString(vm, token, strlen(token));

		if (array->len == array->cap) {
			int32_t newCap = bluPowerOf2Ceil(array->cap * 2);

			if (newCap == 0) newCap = 8;

			array->data = bluReallocate(vm, array->data, (sizeof(bluValue) * array->cap), (sizeof(bluValue) * newCap));
			array->cap = newCap;
		}

		array->data[array->len++] = OBJ_VAL(part);
	}

	free(tofree);

	args[0] = OBJ_VAL(array);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x8(%rdx), %r13
movq %rdx, 0x8(%rsp)
movq 0x18(%rdx), %r12
xorl %esi, %esi
callq 0x59bf
movq %rax, %r15
addq $0x28, %r13
movq %r13, %rdi
callq 0x2210
leaq 0x10(%rsp), %rbp
movq %rax, (%rsp)
movq %rax, (%rbp)
addq $0x28, %r12
movq %rbp, %rdi
movq %r12, %rsi
callq 0x2180
testq %rax, %rax
je 0x4c1e
movq %rax, %r13
movq %rax, %rdi
callq 0x20e0
movq %r14, %rdi
movq %r13, %rsi
movl %eax, %edx
callq 0x58eb
movq %rax, %r13
movl 0x20(%r15), %ecx
cmpl 0x24(%r15), %ecx
jne 0x4bfb
movslq %ecx, %rdi
addq %rdi, %rdi
callq 0x26a4
testl %eax, %eax
pushq $0x8
popq %rcx
cmovel %ecx, %eax
movq 0x28(%r15), %rsi
movslq 0x24(%r15), %rdx
shlq $0x4, %rdx
movslq %eax, %rbx
movq %rbx, %rcx
shlq $0x4, %rcx
movq %r14, %rdi
callq 0x558b
movq %rax, 0x28(%r15)
movl %ebx, 0x24(%r15)
movl 0x20(%r15), %ecx
jmp 0x4bff
movq 0x28(%r15), %rax
leal 0x1(%rcx), %edx
movl %edx, 0x20(%r15)
movslq %ecx, %rcx
shlq $0x4, %rcx
movl $0x3, (%rax,%rcx)
movq %r13, 0x8(%rax,%rcx)
jmp 0x4b83
movq (%rsp), %rdi
callq 0x2030
movq 0x8(%rsp), %rax
movl $0x3, (%rax)
movq %r15, 0x8(%rax)
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/lib/core/core.c
// Function: String_at
int8_t String_at(bluVM* vm, int8_t argCount, bluValue* args) {
	bluObjString* string = AS_STRING(args[0]);
	int index = AS_NUMBER(args[1]);

	bluObjString* str = bluNewString(vm, 1);
	str->chars[0] = string->chars[index];
	str->chars[1] = '\0';

	args[0] = OBJ_VAL(bluTakeString(vm, str));

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdx), %r15
cvttsd2si 0x18(%rdx), %ebp
pushq $0x1
popq %rsi
callq 0x5bb7
movslq %ebp, %rcx
movb 0x28(%r15,%rcx), %cl
movb %cl, 0x28(%rax)
movb $0x0, 0x29(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x5c0b
movl $0x3, (%rbx)
movq %rax, 0x8(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/lib/file/file.c
// Function: File_open
int8_t File_open(bluVM* vm, int8_t argCount, bluValue* args) {
	bluValue value;
	bluObjInstance* receiver = AS_INSTANCE(args[0]);

	bluTableGet(vm, &receiver->fields, bluCopyString(vm, "_name", strlen("_name")), &value);
	bluObjString* name = AS_STRING(value);

	bluTableGet(vm, &receiver->fields, bluCopyString(vm, "_mode", strlen("_mode")), &value);
	bluObjString* mode = AS_STRING(value);

	FILE* file = fopen(name->chars, mode->chars);
	if (file == NULL) return -1;

	((FileData*)receiver->data)->fd = file;

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdx), %r13
leaq 0x20(%r13), %r14
leaq 0x54bb(%rip), %rsi      # 0xa489
pushq $0x5
popq %rbp
movl %ebp, %edx
callq 0x58eb
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x641c
movq 0x8(%r15), %r12
leaq 0x5496(%rip), %rsi      # 0xa48f
movq %rbx, %rdi
movl %ebp, %edx
callq 0x58eb
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x641c
movq 0x8(%r15), %rsi
addq $0x28, %r12
addq $0x28, %rsi
movq %r12, %rdi
callq 0x21c0
testq %rax, %rax
je 0x5038
movq 0x30(%r13), %rcx
movq %rax, (%rcx)
movb $0x1, %al
jmp 0x503a
movb $-0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/lib/file/file.c
// Function: File_readLine
int8_t File_readLine(bluVM* vm, int8_t argCount, bluValue* args) {
	bluObjInstance* receiver = AS_INSTANCE(args[0]);

	FILE* file = ((FileData*)receiver->data)->fd;

	char* buffer = NULL;
	size_t len = 0;

	ssize_t read = getline(&buffer, &len, file);
	if (read == -1) {
		args[0] = NIL_VAL;
		free(buffer);
		return 1;
	}

	if (buffer[read - 1] == '\n') {
		buffer[--read] = '\0';
	}

	args[0] = OBJ_VAL(bluCopyString(vm, buffer, read));

	free(buffer);

	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdx), %rax
movq 0x30(%rax), %rax
movq (%rax), %rdx
leaq 0x8(%rsp), %rdi
andq $0x0, (%rdi)
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
callq 0x21e0
cmpq $-0x1, %rax
je 0x50d7
movq 0x8(%rsp), %rsi
cmpb $0xa, -0x1(%rsi,%rax)
jne 0x50c1
movb $0x0, -0x1(%rsi,%rax)
decq %rax
movq 0x8(%rsp), %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0x58eb
movl $0x3, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x50e2
movl $0x1, (%rbx)
andq $0x0, 0x8(%rbx)
movq 0x8(%rsp), %rdi
callq 0x2030
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/lib/file/file.c
// Function: bluInitFile
void bluInitFile(bluVM* vm) {
	bluInterpret(vm, fileSource, "__FILE__");

	bluObj* fileClass = bluGetGlobal(vm, "File");

	AS_CLASS(OBJ_VAL(fileClass))->construct = construct;
	AS_CLASS(OBJ_VAL(fileClass))->destruct = destruct;

	bluDefineMethod(vm, fileClass, "open", File_open, 0);
	bluDefineMethod(vm, fileClass, "close", File_close, 0);
	bluDefineMethod(vm, fileClass, "rewind", File_rewind, 0);
	bluDefineMethod(vm, fileClass, "readLine", File_readLine, 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x53ba(%rip), %rsi      # 0xa4be
leaq 0x538a(%rip), %rdx      # 0xa495
callq 0x69db
leaq 0x5387(%rip), %rsi      # 0xa49e
movq %rbx, %rdi
callq 0x7f66
movq %rax, %r14
leaq -0x1bd(%rip), %rax      # 0x4f6c
movq %rax, 0x50(%r14)
leaq -0x1b2(%rip), %rax      # 0x4f82
movq %rax, 0x58(%r14)
leaq 0x5364(%rip), %rdx      # 0xa4a3
leaq -0x198(%rip), %rcx      # 0x4fae
movq %rbx, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x7fc8
leaq 0x534d(%rip), %rdx      # 0xa4a8
leaq -0x119(%rip), %rcx      # 0x5049
movq %rbx, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x7fc8
leaq 0x5337(%rip), %rdx      # 0xa4ae
leaq -0x120(%rip), %rcx      # 0x505e
movq %rbx, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x7fc8
leaq 0x5322(%rip), %rdx      # 0xa4b5
leaq -0x127(%rip), %rcx      # 0x5073
movq %rbx, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7fc8
nop
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/lib/system/system.c
// Function: System__println
int8_t System__println(bluVM* vm, int8_t argCount, bluValue* args) {
	if (argCount == 0) {
		printf("\n");
	}

	for (int32_t i = 1; i <= argCount; i++) {
		bluPrintValue(args[i]);
		printf("\n");
	}

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
testb %bpl, %bpl
jne 0x5235
pushq $0xa
popq %rdi
callq 0x2040
movsbq %bpl, %r14
addq $0x18, %rbx
pushq $0x1
popq %r15
pushq $0xa
popq %rbp
cmpq %r14, %r15
jg 0x5264
movl -0x8(%rbx), %edi
movq (%rbx), %rsi
callq 0x6797
movl %ebp, %edi
callq 0x2040
incq %r15
addq $0x10, %rbx
jmp 0x5244
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/lib/system/system.c
// Function: System__readln
int8_t System__readln(bluVM* vm, int8_t argCount, bluValue* args) {
	bluObjString* line = bluNewString(vm, 1024);

	if (!fgets(line->chars, 1024, stdin)) {
		printf("\n");
	}

	bluObjString* string = bluTakeString(vm, line);

	args[0] = OBJ_VAL(string);

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movl $0x400, %esi            # imm = 0x400
callq 0x5bb7
movq %rax, %r15
leaq 0x28(%rax), %rdi
movq 0x9d44(%rip), %rax      # 0xefd8
movq (%rax), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x2120
testq %rax, %rax
jne 0x52ae
pushq $0xa
popq %rdi
callq 0x2040
movq %r14, %rdi
movq %r15, %rsi
callq 0x5c0b
movl $0x3, (%rbx)
movq %rax, 0x8(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/lib/system/system.c
// Function: bluInitSystem
void bluInitSystem(bluVM* vm) {
	bluInterpret(vm, systemSource, "__SYSTEM__");

	bluObj* systemClass = bluGetGlobal(vm, "System");
	bluDefineStaticMethod(vm, systemClass, "print", System__print, 0);
	bluDefineStaticMethod(vm, systemClass, "println", System__println, 0);
	bluDefineStaticMethod(vm, systemClass, "readln", System__readln, 0);
	bluDefineStaticMethod(vm, systemClass, "clock", System__clock, 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x53d7(%rip), %rsi      # 0xa6d5
leaq 0x53a3(%rip), %rdx      # 0xa6a8
callq 0x69db
leaq 0x53a2(%rip), %rsi      # 0xa6b3
movq %rbx, %rdi
callq 0x7f66
movq %rax, %r14
leaq 0x5397(%rip), %rdx      # 0xa6ba
leaq -0x142(%rip), %rcx      # 0x51e8
movq %rbx, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
callq 0x8028
leaq 0x5381(%rip), %rdx      # 0xa6c0
leaq -0x12a(%rip), %rcx      # 0x521c
movq %rbx, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x8028
leaq 0x536d(%rip), %rdx      # 0xa6c8
leaq -0xf1(%rip), %rcx       # 0x5271
movq %rbx, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x8028
leaq 0x5358(%rip), %rdx      # 0xa6cf
leaq -0xb3(%rip), %rcx       # 0x52cb
movq %rbx, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8028
nop
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/memory.c
// Function: bluGrayTable
void bluGrayTable(bluVM* vm, bluTable* table) {
	for (int32_t i = 0; i < table->capacityMask; i++) {
		bluEntry* entry = &table->entries[i];
		bluGrayObject(vm, (bluObj*)entry->key);
		bluGrayValue(vm, entry->value);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %r15
xorl %r12d, %r12d
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jge 0x552e
movq 0x8(%rbx), %r13
movq -0x10(%r13,%r15), %rsi
movq %r14, %rdi
callq 0x53a2
movl -0x8(%r13,%r15), %esi
movq (%r13,%r15), %rdx
movq %r14, %rdi
callq 0x5394
incq %r12
addq $0x18, %r15
jmp 0x54f9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/memory.c
// Function: bluReallocate
void* bluReallocate(bluVM* vm, void* previous, size_t oldSize, size_t newSize) {
	vm->bytesAllocated += newSize - oldSize;

#ifdef DEBUG_GC_STRESS
	vm->shouldGC = true;
#endif

	if (vm->bytesAllocated > vm->nextGC) {
		vm->shouldGC = true;
	}

	if (newSize == 0) {
		free(previous);
		return NULL;
	}

	return realloc(previous, newSize);
}

// Assembly:
movq %rdi, %rax
movq %rcx, %r8
subq %rdx, %r8
addq 0x101890(%rdi), %r8
movq %rsi, %rdi
movq %r8, 0x101890(%rax)
cmpq 0x101898(%rax), %r8
jbe 0x55b5
movb $0x1, 0x1018a0(%rax)
testq %rcx, %rcx
je 0x55c2
movq %rcx, %rsi
jmp 0x21b0
pushq %rax
callq 0x2030
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/memory.c
// Function: bluCollectMemory
void bluCollectMemory(bluVM* vm) {
	bluObj* object = vm->objects;
	while (object != NULL) {
		bluObj* next = object->next;
		freeObject(vm, object);
		object = next;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x101888(%rdi), %rsi
testq %rsi, %rsi
je 0x584a
movq 0x18(%rsi), %r14
movq %rbx, %rdi
callq 0x5766
movq %r14, %rsi
jmp 0x5834
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/object.c
// Function: bluCopyString
bluObjString* bluCopyString(bluVM* vm, const char* chars, int32_t length) {
	int32_t hash = hashString(chars, length);

	bluObjString* interned = bluTableFindString(vm, &vm->strings, chars, length, hash);
	if (interned != NULL) return interned;

	return allocateString(vm, chars, length, hash);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
callq 0x599c
movl %eax, %r13d
leaq 0x101820(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movl %eax, %r8d
callq 0x666c
movq %rax, %r12
testq %rax, %rax
jne 0x598a
movslq %ebp, %rax
movq %rax, (%rsp)
leaq 0x29(%rax), %rsi
pushq $0x7
popq %rdx
movq %rbx, %rdi
callq 0x5a10
movq %rax, %r12
movq 0x101868(%rbx), %rax
movq %rax, 0x8(%r12)
movl %ebp, 0x20(%r12)
movl %r13d, 0x24(%r12)
leaq 0x28(%r12), %rdi
movq %r15, %rsi
movq (%rsp), %r15
movq %r15, %rdx
callq 0x2050
movb $0x0, 0x28(%r12,%r15)
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
xorl %r8d, %r8d
callq 0x6481
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/object.c
// Function: hashString
static int32_t hashString(const char* key, int32_t length) {
	int32_t hash = 2166136261u;

	for (int32_t i = 0; i < length; i++) {
		hash ^= key[i];
		hash *= 16777619;
	}

	return hash;
}

// Assembly:
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
cmpq %rcx, %rsi
je 0x59be
movsbl (%rdi,%rcx), %edx
xorl %edx, %eax
imull $0x1000193, %eax, %eax  # imm = 0x1000193
incq %rcx
jmp 0x59a8
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/object.c
// Function: bluNewArray
bluObjArray* bluNewArray(bluVM* vm, int32_t len) {
	bluObjArray* array = (bluObjArray*)allocateObject(vm, sizeof(bluObjArray), OBJ_ARRAY);
	array->obj.class = vm->arrayClass;
	array->cap = bluPowerOf2Ceil(len);
	array->len = len;
	array->data = bluAllocate(vm, (sizeof(bluValue) * array->cap));

	return array;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
pushq $0x30
popq %rsi
xorl %edx, %edx
callq 0x5a10
movq %rax, %r15
movq 0x101850(%r14), %rax
movq %rax, 0x8(%r15)
movslq %ebx, %rbx
movq %rbx, %rdi
callq 0x26a4
movl %eax, 0x24(%r15)
movl %ebx, 0x20(%r15)
movslq %eax, %rsi
shlq $0x4, %rsi
movq %r14, %rdi
callq 0x557f
movq %rax, 0x28(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/object.c
// Function: allocateObject
static bluObj* allocateObject(bluVM* vm, size_t size, bluObjType type) {
	bluObj* object = (bluObj*)bluAllocate(vm, size);
	object->type = type;
	object->class = NULL;
	object->isDark = false;
	object->next = vm->objects;

	vm->objects = object;

	return object;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
callq 0x557f
movl %ebx, (%rax)
andq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x101888(%r14), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x101888(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/object.c
// Function: bluNewBoundMethod
bluObjBoundMethod* bluNewBoundMethod(bluVM* vm, bluValue receiver, bluObjClosure* closure) {
	bluObjBoundMethod* method = (bluObjBoundMethod*)allocateObject(vm, sizeof(bluObjBoundMethod), OBJ_BOUND_METHOD);
	method->obj.class = vm->functionClass;
	method->receiver = receiver;
	method->closure = closure;

	return method;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
pushq $0x38
popq %rsi
pushq $0x1
popq %rdx
callq 0x5a10
movq 0x101860(%r15), %rcx
movq %rcx, 0x8(%rax)
movl %ebp, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/object.c
// Function: bluNewClass
bluObjClass* bluNewClass(bluVM* vm, bluObjString* name) {
	bluObjClass* class = (bluObjClass*)allocateObject(vm, sizeof(bluObjClass), OBJ_CLASS);
	class->obj.class = vm->classClass;
	class->superclass = NULL;
	class->name = name;
	class->construct = NULL;
	class->destruct = NULL;

	bluTableInit(vm, &class->methods);
	bluTableInit(vm, &class->fields);

	return class;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x60
popq %rsi
pushq $0x2
popq %rdx
callq 0x5a10
movq %rax, %r15
movq 0x101858(%r14), %rax
movq %rax, 0x8(%r15)
andq $0x0, 0x28(%r15)
movq %rbx, 0x20(%r15)
leaq 0x30(%r15), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r15)
movq %r14, %rdi
callq 0x66fe
leaq 0x40(%r15), %rsi
movq %r14, %rdi
callq 0x66fe
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/object.c
// Function: newClosure
bluObjClosure* newClosure(bluVM* vm, bluObjFunction* function) {
	bluObjClosure* closure = (bluObjClosure*)allocateObject(vm, sizeof(bluObjClosure), OBJ_CLOSURE);
	closure->obj.class = vm->functionClass;
	closure->function = function;

	bluObjUpvalueBufferInit(&closure->upvalues);

	return closure;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x38
popq %rsi
pushq $0x3
popq %rdx
callq 0x5a10
movq 0x101860(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rbx, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/object.c
// Function: bluNewFunction
bluObjFunction* bluNewFunction(bluVM* vm) {
	bluObjFunction* function = (bluObjFunction*)allocateObject(vm, sizeof(bluObjFunction), OBJ_FUNCTION);
	function->obj.class = vm->functionClass;
	function->arity = 0;
	function->upvalueCount = 0;
	function->name = NULL;

	bluChunkInit(&function->chunk);

	return function;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x4
popq %rdx
movl $0x80, %esi
callq 0x5a10
movq %rax, %r14
movq 0x101860(%rbx), %rax
movq %rax, 0x8(%r14)
movb $0x0, 0x20(%r14)
andw $0x0, 0x22(%r14)
andq $0x0, 0x78(%r14)
leaq 0x28(%r14), %rdi
callq 0x2782
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/object.c
// Function: bluNewInstance
bluObjInstance* bluNewInstance(bluVM* vm, bluObjClass* class) {
	bluObjInstance* instance = (bluObjInstance*)allocateObject(vm, sizeof(bluObjInstance), OBJ_INSTANCE);
	instance->obj.class = class;
	instance->data = NULL;

	bluTableInit(vm, &instance->fields);

	return instance;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x38
popq %rsi
pushq $0x5
popq %rdx
callq 0x5a10
movq %rax, %r15
movq %rbx, 0x8(%rax)
andq $0x0, 0x30(%rax)
leaq 0x20(%rax), %rsi
movq %r14, %rdi
callq 0x66fe
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/object.c
// Function: bluNewNative
bluObjNative* bluNewNative(bluVM* vm, bluNativeFn function, int8_t arity) {
	bluObjNative* native = (bluObjNative*)allocateObject(vm, sizeof(bluObjNative), OBJ_NATIVE);
	native->obj.class = vm->functionClass;
	native->function = function;
	native->arity = arity;

	return native;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x30
popq %rsi
pushq $0x6
popq %rdx
callq 0x5a10
movq 0x101860(%r15), %rcx
movq %rcx, 0x8(%rax)
movq %r14, 0x28(%rax)
movb %bl, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/object.c
// Function: bluNewString
bluObjString* bluNewString(bluVM* vm, int32_t length) {
	size_t totalSize = sizeof(bluObjString) + (sizeof(char) * (length + 1));

	bluObjString* string = (bluObjString*)allocateObject(vm, totalSize, OBJ_STRING);
	string->obj.class = vm->stringClass;
	string->length = length;
	string->hash = 0;

	return string;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r14
leaq 0x29(%r14), %rsi
pushq $0x7
popq %rdx
callq 0x5a10
movq 0x101868(%rbx), %rcx
movq %rcx, 0x8(%rax)
movl %r14d, 0x20(%rax)
andl $0x0, 0x24(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/object.c
// Function: bluNewUpvalue
bluObjUpvalue* bluNewUpvalue(bluVM* vm, bluValue* slot) {
	bluObjUpvalue* upvalue = (bluObjUpvalue*)allocateObject(vm, sizeof(bluObjUpvalue), OBJ_UPVALUE);
	// TODO : This should not be needed.
	// upvalue->obj.class = bluGetClass(vm, *slot);
	upvalue->closed = NIL_VAL;
	upvalue->value = slot;
	upvalue->next = NULL;

	return upvalue;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
pushq $0x40
popq %rsi
pushq $0x8
popq %rdx
callq 0x5a10
movl $0x1, 0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movq %rbx, 0x20(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/object.c
// Function: bluTakeString
bluObjString* bluTakeString(bluVM* vm, bluObjString* string) {
	string->hash = hashString(string->chars, string->length);

	bluObjString* interned = bluTableFindString(vm, &vm->strings, string->chars, string->length, string->hash);
	if (interned != NULL) {
		return interned;
	}

	bluTableSet(vm, &vm->strings, string, NIL_VAL);

	return string;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsi), %r12
movl 0x20(%rsi), %ebp
movq %r12, %rdi
movl %ebp, %esi
callq 0x599c
movl %eax, 0x24(%rbx)
leaq 0x101820(%r14), %r15
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %ebp, %ecx
movl %eax, %r8d
callq 0x666c
testq %rax, %rax
jne 0x5c63
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
xorl %r8d, %r8d
callq 0x6481
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/object.c
// Function: bluPrintObject
void bluPrintObject(bluValue value) {

	switch (OBJ_TYPE(value)) {

	case OBJ_ARRAY: {
		bluObjArray* array = AS_ARRAY(value);

		printf("[");
		for (int32_t i = 0; i < array->len; i++) {
			if (i > 0) {
				printf(", ");
			}

			bluPrintValue(array->data[i]);
		}
		printf("]");
		break;
	}

	case OBJ_BOUND_METHOD: {
		printf("<method %s>", AS_BOUND_METHOD(value)->closure->function->name->chars);
		break;
	}

	case OBJ_CLASS: {
		printf("<class %s>", AS_CLASS(value)->name->chars);
		break;
	}

	case OBJ_CLOSURE:
		if (AS_CLOSURE(value)->function->name == NULL) {
			printf("<anonymous fn>");
		} else {
			printf("<fn %s>", AS_CLOSURE(value)->function->name->chars);
		}
		break;

	case OBJ_FUNCTION: {
		if (AS_FUNCTION(value)->name == NULL) {
			printf("<anonymous fn>");
		} else {
			printf("<fn %s>", AS_FUNCTION(value)->name->chars);
		}
		break;
	}

	case OBJ_INSTANCE: {
		printf("<instance of %s>", AS_INSTANCE(value)->obj.class->name->chars);
		break;
	}

	case OBJ_NATIVE: {
		printf("<native fn>");
		break;
	}

	case OBJ_UPVALUE: {
		printf("upvalue");
		break;
	}

	case OBJ_STRING: {
		printf("%s", AS_CSTRING(value));
		break;
	}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl (%rsi), %eax
cmpq $0x8, %rax
ja 0x5d87
movq %rsi, %rbx
leaq 0x4b1a(%rip), %rcx      # 0xa7a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x5b
popq %rdi
callq 0x2040
leaq 0x4b26(%rip), %r14      # 0xa7c8
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x20(%rbx), %rax
cmpq %rax, %r12
jge 0x5d3d
testq %r15, %r15
je 0x5cc4
movq %r14, %rdi
xorl %eax, %eax
callq 0x20f0
movq 0x28(%rbx), %rax
movl (%rax,%r15), %edi
movq 0x8(%rax,%r15), %rsi
callq 0x6797
incq %r12
addq $0x10, %r15
jmp 0x5ca8
movq 0x78(%rbx), %rsi
jmp 0x5cfe
movq 0x20(%rbx), %rsi
addq $0x28, %rsi
leaq 0x4ae3(%rip), %rdi      # 0xa7d7
jmp 0x5d63
movq 0x20(%rbx), %rax
movq 0x78(%rax), %rsi
testq %rsi, %rsi
je 0x5d93
addq $0x28, %rsi
leaq 0x4adf(%rip), %rdi      # 0xa7f1
jmp 0x5d63
addq $0x28, %rbx
leaq 0x4af7(%rip), %rdi      # 0xa816
movq %rbx, %rsi
jmp 0x5d63
movq 0x30(%rbx), %rax
movq 0x20(%rax), %rax
movq 0x78(%rax), %rsi
addq $0x28, %rsi
leaq 0x4a90(%rip), %rdi      # 0xa7cb
jmp 0x5d63
pushq $0x5d
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2040
movq 0x8(%rbx), %rax
movq 0x20(%rax), %rsi
addq $0x28, %rsi
leaq 0x4a96(%rip), %rdi      # 0xa7f9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20f0
leaq 0x4a8e(%rip), %rdi      # 0xa80a
jmp 0x5d9a
leaq 0x3bdd(%rip), %rdi      # 0x9962
jmp 0x5d9a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4a48(%rip), %rdi      # 0xa7e2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/parser/parser.c
// Function: makeToken
static bluToken makeToken(bluParser* parser, bluTokenType type) {
	bluToken token;
	token.type = type;

	switch (type) {
	case TOKEN_NEWLINE:
		token.start = "<NEWLINE>";
		token.length = 9;
		break;

	case TOKEN_EOF:
		token.start = "<EOF>";
		token.length = 5;
		break;

	default:
		token.start = parser->source + parser->from;
		token.length = parser->at - parser->from;
		break;
	}

	token.line = parser->lineFrom;
	token.column = parser->columnFrom;

	return token;
}

// Assembly:
movq %rdi, %rax
movl %edx, (%rdi)
cmpl $0x2f, %edx
je 0x635e
cmpl $0x30, %edx
jne 0x636d
leaq 0x45f6(%rip), %rcx      # 0xa94c
movq %rcx, 0x8(%rax)
movb $0x9, %cl
jmp 0x6380
leaq 0x45f1(%rip), %rcx      # 0xa956
movq %rcx, 0x8(%rax)
movb $0x5, %cl
jmp 0x6380
movslq 0x8(%rsi), %rdx
movq %rdx, %rcx
addq (%rsi), %rcx
movq %rcx, 0x8(%rax)
movl 0xc(%rsi), %ecx
subl %edx, %ecx
movb %cl, 0x10(%rax)
movl 0x10(%rsi), %ecx
movl %ecx, 0x14(%rax)
movl 0x18(%rsi), %ecx
movl %ecx, 0x18(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/parser/parser.c
// Function: match
static bool match(bluParser* parser, char expected) {
	if (isAtEnd(parser)) return false;
	if (peek(parser) != expected) return false;

	advance(parser);

	return true;
}

// Assembly:
pushq %rbx
movq (%rdi), %rax
movslq 0xc(%rdi), %rcx
movb (%rax,%rcx), %bl
cmpb $0x3d, %bl
jne 0x63a5
callq 0x632c
cmpb $0x3d, %bl
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/parser/parser.c
// Function: errorToken
static bluToken errorToken(bluParser* parser, const char* message) {
	bluToken token;
	token.type = TOKEN_ERROR;
	token.start = message;
	token.length = strlen(message);
	token.line = parser->lineFrom;
	token.column = parser->columnFrom;

	return token;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x31, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rdx, %rdi
callq 0x20e0
movb %al, 0x10(%r14)
movl 0x10(%rbx), %eax
movl %eax, 0x14(%r14)
movl 0x18(%rbx), %eax
movl %eax, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/parser/parser.c
// Function: checkKeyword
static bluTokenType checkKeyword(bluParser* parser, int32_t start, int32_t length, const char* rest,
								 bluTokenType type) {
	if (parser->at - parser->from == start + length &&
		memcmp(parser->source + parser->from + start, rest, length) == 0) {
		return type;
	}

	return TOKEN_IDENTIFIER;
}

// Assembly:
pushq %rbx
movl %r8d, %ebx
movl 0xc(%rdi), %r8d
movslq 0x8(%rdi), %rax
subl %eax, %r8d
leal (%rdx,%rsi), %r9d
cmpl %r9d, %r8d
jne 0x6414
addq (%rdi), %rax
movl %esi, %edi
addq %rax, %rdi
movl %edx, %edx
movq %rcx, %rsi
callq 0x2190
testl %eax, %eax
je 0x6417
pushq $0x19
popq %rbx
movl %ebx, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/adamjedlicka[P]blu/src/vm/table.c
// Function: bluTableGet
bool bluTableGet(bluVM* vm, bluTable* table, bluObjString* key, bluValue* value) {
	if (table->entries == NULL) return false;

	bluEntry* entry = findEntry(table->entries, table->capacityMask, key);
	if (entry->key == NULL) return false;

	*value = entry->value;

	return true;
}

// Assembly:
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x6442
pushq %rbx
movq %rcx, %rbx
movl 0x4(%rsi), %esi
callq 0x6449
cmpq $0x0, (%rax)
je 0x6445
movups 0x8(%rax), %xmm0
movups %xmm0, (%rbx)
movb $0x1, %al
jmp 0x6447
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
retq