LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x19, %esi
callq 0x3200
movq -0x10(%rbp), %rdi
callq 0x3c20
movq -0x10(%rbp), %rax
movsbl 0x58(%rax), %eax
cmpl $0x0, %eax
jle 0x39f0
movw $0x0, -0x2(%rbp)
jmp 0x3a09
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x20, %rsi
callq 0x3250
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x58(%rax), %eax
cmpl $0x0, %eax
jle 0x3a4b
movq -0x8(%rbp), %rdi
callq 0x3d90
jmp 0x3a66
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x32b0
movq -0x8(%rbp), %rdi
movzwl -0xa(%rbp), %esi
callq 0x3140
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x8, 0x20(%rax)
jne 0x3a8c
jmp 0x3ac3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x8, 0x40(%rax)
jne 0x3a9c
jmp 0x3ac3
movq -0x8(%rbp), %rdi
movl $0xb, %esi
callq 0x2c40
testb $0x1, %al
jne 0x3ac3
movq -0x8(%rbp), %rdi
movl $0x30, %esi
leaq 0xa890(%rip), %rdx      # 0xe34e
callq 0x3200
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb 0x58(%rax), %cl
addb $-0x1, %cl
movb %cl, 0x58(%rax)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x40(%rcx)
movb %al, -0x9(%rbp)
jle 0x3bb8
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x40(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsbl 0x20(%rax), %eax
movq -0x8(%rbp), %rcx
movsbl 0x58(%rcx), %ecx
cmpl %ecx, %eax
setg %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x3bc1
jmp 0x3c13
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x40(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
testb $0x1, 0x21(%rax)
je 0x3bf3
movq -0x8(%rbp), %rdi
movl $0x27, %esi
callq 0x32b0
jmp 0x3c01
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x32b0
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x40(%rax)
jmp 0x3b79
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: declareVariable
static void declareVariable(bluCompiler* compiler) {
	// Global variables are implicitly declared.
	if (compiler->scopeDepth == 0) return;

	bluToken* name = &compiler->parser->previous;
	for (int32_t i = compiler->locals.count - 1; i >= 0; i--) {
		bluLocal* local = &compiler->locals.data[i];
		if (local->depth != -1 && local->depth < compiler->scopeDepth) break;
		if (identifiersEqual(name, &local->name)) {
			error(compiler, "Variable with this name already declared in this scope.");
		}
	}

	addLocal(compiler, *name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x58(%rax), %eax
cmpl $0x0, %eax
jne 0x3c3e
jmp 0x3cfa
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x3ccb
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl 0x20(%rax), %eax
cmpl $-0x1, %eax
je 0x3c9b
movq -0x20(%rbp), %rax
movsbl 0x20(%rax), %eax
movq -0x8(%rbp), %rcx
movsbl 0x58(%rcx), %ecx
cmpl %ecx, %eax
jge 0x3c9b
jmp 0x3ccb
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x34a0
testb $0x1, %al
jne 0x3cae
jmp 0x3cbe
movq -0x8(%rbp), %rdi
leaq 0xa637(%rip), %rsi      # 0xe2f0
callq 0x2db0
jmp 0x3cc0
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3c5b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x3d00
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0xfffe, 0x40(%rax)     # imm = 0xFFFE
jne 0x3d33
movq -0x8(%rbp), %rdi
leaq 0xa5fc(%rip), %rsi      # 0xe328
callq 0x2db0
jmp 0x3d85
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movb $-0x1, -0x10(%rbp)
movb $0x0, -0xf(%rbp)
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x30(%rbp), %xmm0
movups -0x20(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x1d10
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %esi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rdx
callq 0x3190
movw %ax, -0x1a(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x32b0
movq -0x18(%rbp), %rdi
movzwl -0x1a(%rbp), %esi
callq 0x3140
movw -0x1a(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
subl -0xc(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: skipNewlines
static void skipNewlines(bluCompiler* compiler) {
	switch (compiler->parser->previous.type) {
	case TOKEN_NEWLINE:
	case TOKEN_LEFT_BRACE:
	case TOKEN_RIGHT_BRACE:
	case TOKEN_SEMICOLON:
	case TOKEN_DOT: consumeNewlines(compiler); break;

	default:
		// Do nothing.
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x20(%rax), %eax
movl %eax, -0xc(%rbp)
addl $-0x4, %eax
subl $0x2, %eax
jb 0x3fd2
jmp 0x3fb4
movl -0xc(%rbp), %eax
subl $0x8, %eax
je 0x3fd2
jmp 0x3fbe
movl -0xc(%rbp), %eax
subl $0xb, %eax
je 0x3fd2
jmp 0x3fc8
movl -0xc(%rbp), %eax
subl $0x30, %eax
jne 0x3fdd
jmp 0x3fd2
movq -0x8(%rbp), %rdi
callq 0x3e20
jmp 0x3fdf
jmp 0x3fdf
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xa4a1(%rip), %rsi      # 0xe4a8
callq 0x39b0
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movl $0xf, %esi
callq 0x2c40
testb $0x1, %al
jne 0x4023
jmp 0x402e
movq -0x8(%rbp), %rdi
callq 0x3450
jmp 0x403c
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x32b0
movq -0x8(%rbp), %rdi
movzbl -0x9(%rbp), %eax
movzwl %ax, %esi
callq 0x3a20
movq -0x8(%rbp), %rdi
callq 0x3a70
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: fnDeclaration
static void fnDeclaration(bluCompiler* compiler) {
	uint16_t name = parseVariable(compiler, "Expect function name.");
	markInitialized(compiler);

	function(compiler, TYPE_FUNCTION);

	defineVariable(compiler, name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xa447(%rip), %rsi      # 0xe4be
callq 0x39b0
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3d90
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x3600
movq -0x8(%rbp), %rdi
movzwl -0xa(%rbp), %esi
callq 0x3a20
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: statement
static void statement(bluCompiler* compiler) {
	if (match(compiler, TOKEN_LEFT_BRACE)) {
		beginScope(compiler);
		block(compiler);
		endScope(compiler);
	} else if (match(compiler, TOKEN_IF)) {
		ifStatement(compiler);
	} else if (match(compiler, TOKEN_WHILE)) {
		whileStatement(compiler);
	} else if (match(compiler, TOKEN_FOR)) {
		forStatement(compiler);
	} else if (match(compiler, TOKEN_RETURN)) {
		returnStatement(compiler);
	} else if (match(compiler, TOKEN_IMPORT)) {
		importStatement(compiler);
	} else if (match(compiler, TOKEN_ECHO)) {
		echoStatement(compiler);
	} else if (match(compiler, TOKEN_ASSERT)) {
		assertStatement(compiler);
	} else {
		expressionStatement(compiler);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x2c40
testb $0x1, %al
jne 0x4520
jmp 0x4540
movq -0x8(%rbp), %rdi
callq 0x3ad0
movq -0x8(%rbp), %rdi
callq 0x3af0
movq -0x8(%rbp), %rdi
callq 0x3b60
jmp 0x4639
movq -0x8(%rbp), %rdi
movl $0x26, %esi
callq 0x2c40
testb $0x1, %al
jne 0x4554
jmp 0x4562
movq -0x8(%rbp), %rdi
callq 0x47f0
jmp 0x4637
movq -0x8(%rbp), %rdi
movl $0x2e, %esi
callq 0x2c40
testb $0x1, %al
jne 0x4576
jmp 0x4584
movq -0x8(%rbp), %rdi
callq 0x4980
jmp 0x4635
movq -0x8(%rbp), %rdi
movl $0x24, %esi
callq 0x2c40
testb $0x1, %al
jne 0x4598
jmp 0x45a6
movq -0x8(%rbp), %rdi
callq 0x4a50
jmp 0x4633
movq -0x8(%rbp), %rdi
movl $0x2a, %esi
callq 0x2c40
testb $0x1, %al
jne 0x45ba
jmp 0x45c5
movq -0x8(%rbp), %rdi
callq 0x4c00
jmp 0x4631
movq -0x8(%rbp), %rdi
movl $0x27, %esi
callq 0x2c40
testb $0x1, %al
jne 0x45d9
jmp 0x45e4
movq -0x8(%rbp), %rdi
callq 0x4cb0
jmp 0x462f
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x2c40
testb $0x1, %al
jne 0x45f8
jmp 0x4603
movq -0x8(%rbp), %rdi
callq 0x4d70
jmp 0x462d
movq -0x8(%rbp), %rdi
movl $0x1d, %esi
callq 0x2c40
testb $0x1, %al
jne 0x4617
jmp 0x4622
movq -0x8(%rbp), %rdi
callq 0x4db0
jmp 0x462b
movq -0x8(%rbp), %rdi
callq 0x4df0
jmp 0x462d
jmp 0x462f
jmp 0x4631
jmp 0x4633
jmp 0x4635
jmp 0x4637
jmp 0x4639
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: synchronize
static void synchronize(bluCompiler* compiler) {
	compiler->panicMode = false;

	while (compiler->parser->current.type != TOKEN_EOF) {
		if (compiler->parser->previous.type == TOKEN_SEMICOLON) return;

		switch (compiler->parser->current.type) {
		case TOKEN_CLASS:
		case TOKEN_FN:
		case TOKEN_VAR:
		case TOKEN_FOR:
		case TOKEN_IF:
		case TOKEN_WHILE:
		case TOKEN_RETURN: return;
		default:; // Do nothing.
		}

		advance(compiler);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x5a(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x2f, 0x40(%rax)
je 0x46c4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xb, 0x20(%rax)
jne 0x4672
jmp 0x46c4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x40(%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x1f, %eax
je 0x46b5
jmp 0x4687
movl -0xc(%rbp), %eax
addl $-0x23, %eax
subl $0x2, %eax
jb 0x46b5
jmp 0x4694
movl -0xc(%rbp), %eax
subl $0x26, %eax
je 0x46b5
jmp 0x469e
movl -0xc(%rbp), %eax
subl $0x2a, %eax
je 0x46b5
jmp 0x46a8
movl -0xc(%rbp), %eax
addl $-0x2d, %eax
subl $0x1, %eax
ja 0x46b7
jmp 0x46b5
jmp 0x46c4
jmp 0x46b9
movq -0x8(%rbp), %rdi
callq 0x2b30
jmp 0x4654
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: method
static void method(bluCompiler* compiler) {
	consume(compiler, TOKEN_IDENTIFIER, "Expect method name.");
	uint16_t name = identifierConstant(compiler, &compiler->parser->previous);

	bluFunctionType type = TYPE_METHOD;
	if (compiler->parser->previous.length == 6 && memcmp(compiler->parser->previous.start, "__init", 6) == 0) {
		type = TYPE_INITIALIZER;
	}

	function(compiler, type);

	emitByte(compiler, OP_METHOD);
	emitShort(compiler, name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x19, %esi
leaq 0x9e94(%rip), %rdx      # 0xe580
callq 0x3200
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x20, %rsi
callq 0x3250
movw %ax, -0xa(%rbp)
movl $0x3, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzbl 0x30(%rax), %eax
cmpl $0x6, %eax
jne 0x474b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rdi
leaq 0x9a8c(%rip), %rsi      # 0xe1c1
movl $0x6, %edx
callq 0x1100
cmpl $0x0, %eax
jne 0x474b
movl $0x4, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x3600
movq -0x8(%rbp), %rdi
movl $0x2b, %esi
callq 0x32b0
movq -0x8(%rbp), %rdi
movzwl -0xa(%rbp), %esi
callq 0x3140
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: staticMethod
static void staticMethod(bluCompiler* compiler) {
	consume(compiler, TOKEN_IDENTIFIER, "Expect method name.");
	uint16_t name = identifierConstant(compiler, &compiler->parser->previous);

	function(compiler, TYPE_FUNCTION);

	emitByte(compiler, OP_METHOD_STATIC);
	emitShort(compiler, name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x19, %esi
leaq 0x9de4(%rip), %rdx      # 0xe580
callq 0x3200
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x20, %rsi
callq 0x3250
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x3600
movq -0x8(%rbp), %rdi
movl $0x2d, %esi
callq 0x32b0
movq -0x8(%rbp), %rdi
movzwl -0xa(%rbp), %esi
callq 0x3140
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3ad0
movq -0x8(%rbp), %rdi
callq 0x3450
movq -0x8(%rbp), %rdi
movl $0x16, %esi
callq 0x3ee0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x32b0
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x2c40
testb $0x1, %al
jne 0x4841
jmp 0x488f
movq -0x8(%rbp), %rdi
callq 0x4500
movq -0x8(%rbp), %rdi
movl $0x15, %esi
callq 0x3ee0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x3f20
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x32b0
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x3f20
movq -0x8(%rbp), %rdi
callq 0x3b60
jmp 0x4977
movq -0x8(%rbp), %rdi
movl $0x5, %esi
leaq 0x9cf5(%rip), %rdx      # 0xe594
callq 0x3200
movq -0x8(%rbp), %rdi
callq 0x3ad0
movq -0x8(%rbp), %rdi
callq 0x3af0
movq -0x8(%rbp), %rdi
callq 0x3b60
movq -0x8(%rbp), %rdi
movl $0x15, %esi
callq 0x3ee0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x3f20
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x32b0
movq -0x8(%rbp), %rdi
movl $0x21, %esi
callq 0x2c40
testb $0x1, %al
jne 0x48fe
jmp 0x4962
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x2c40
testb $0x1, %al
jne 0x4912
jmp 0x492f
movq -0x8(%rbp), %rdi
callq 0x3ad0
movq -0x8(%rbp), %rdi
callq 0x3af0
movq -0x8(%rbp), %rdi
callq 0x3b60
jmp 0x4960
movq -0x8(%rbp), %rdi
movl $0x26, %esi
callq 0x2c40
testb $0x1, %al
jne 0x4943
jmp 0x494e
movq -0x8(%rbp), %rdi
callq 0x47f0
jmp 0x495e
movq -0x8(%rbp), %rdi
leaq 0x9c5a(%rip), %rsi      # 0xe5b3
callq 0x2db0
jmp 0x4960
jmp 0x4962
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3f20
movq -0x8(%rbp), %rdi
callq 0x3b60
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: whileStatement
static void whileStatement(bluCompiler* compiler) {
	beginScope(compiler);

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

	expression(compiler);

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

	if (match(compiler, TOKEN_COLON)) {
		statement(compiler);
	} else {
		consume(compiler, TOKEN_LEFT_BRACE, "Expect '{' after while condition.");

		beginScope(compiler);
		block(compiler);
		endScope(compiler);
	}

	emitLoop(compiler, loopStart);

	patchJump(compiler, exitJump);
	emitByte(compiler, OP_POP);

	endScope(compiler);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3ad0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x40(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3450
movq -0x8(%rbp), %rdi
movl $0x16, %esi
callq 0x3ee0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x32b0
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x2c40
testb $0x1, %al
jne 0x49df
jmp 0x49ea
movq -0x8(%rbp), %rdi
callq 0x4500
jmp 0x4a1a
movq -0x8(%rbp), %rdi
movl $0x5, %esi
leaq 0x9bda(%rip), %rdx      # 0xe5d4
callq 0x3200
movq -0x8(%rbp), %rdi
callq 0x3ad0
movq -0x8(%rbp), %rdi
callq 0x3af0
movq -0x8(%rbp), %rdi
callq 0x3b60
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x4e30
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x3f20
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x32b0
movq -0x8(%rbp), %rdi
callq 0x3b60
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: returnStatement
static void returnStatement(bluCompiler* compiler) {
	if (compiler->type == TYPE_TOP_LEVEL) {
		error(compiler, "Cannot return from top-level code.");
	}

	if (match(compiler, TOKEN_NEWLINE)) {
		emitReturn(compiler);
	} else {
		bool needsNewline = !check(compiler, TOKEN_FN);

		if (compiler->type == TYPE_INITIALIZER) {
			error(compiler, "Cannot return a value from an initializer.");
		}

		expression(compiler);
		emitByte(compiler, OP_RETURN);

		if (needsNewline) expectNewlineOrSemicolon(compiler);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x4c26
movq -0x8(%rbp), %rdi
leaq 0x9a28(%rip), %rsi      # 0xe649
callq 0x2db0
movq -0x8(%rbp), %rdi
movl $0x30, %esi
callq 0x2c40
testb $0x1, %al
jne 0x4c3a
jmp 0x4c45
movq -0x8(%rbp), %rdi
callq 0x4e90
jmp 0x4c9c
movq -0x8(%rbp), %rdi
movl $0x23, %esi
callq 0x2bf0
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x4, 0x30(%rax)
jne 0x4c74
movq -0x8(%rbp), %rdi
leaq 0x99fd(%rip), %rsi      # 0xe66c
callq 0x2db0
movq -0x8(%rbp), %rdi
callq 0x3450
movq -0x8(%rbp), %rdi
movl $0x30, %esi
callq 0x32b0
testb $0x1, -0x9(%rbp)
je 0x4c9a
movq -0x8(%rbp), %rdi
callq 0x3a70
jmp 0x4c9c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: importStatement
static void importStatement(bluCompiler* compiler) {
	emitByte(compiler, OP_IMPORT);

	consume(compiler, TOKEN_STRING, "Expect string after import.");

	bluToken previous = compiler->parser->previous;
	bluObjString* string = bluCopyString(compiler->vm, previous.start + 1, previous.length - 2);
	emitShort(compiler, makeConstant(compiler, OBJ_VAL(string)));

	expectNewlineOrSemicolon(compiler);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2e, %esi
callq 0x32b0
movq -0x8(%rbp), %rdi
movl $0x1b, %esi
leaq 0x99bd(%rip), %rdx      # 0xe697
callq 0x3200
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x28(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x30(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
movzbl -0x18(%rbp), %edx
subl $0x2, %edx
callq 0x75a0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x40(%rbp), %esi
movq -0x38(%rbp), %rdx
callq 0x3190
movq -0x48(%rbp), %rdi
movzwl %ax, %esi
callq 0x3140
movq -0x8(%rbp), %rdi
callq 0x3a70
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x18, %esi
callq 0x32b0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x40(%rax), %eax
subl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x10(%rbp)
cmpl $0xffff, -0x10(%rbp)    # imm = 0xFFFF
jle 0x4e7a
movq -0x8(%rbp), %rdi
leaq 0x9781(%rip), %rsi      # 0xe5f6
callq 0x2db0
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
movzwl %ax, %esi
callq 0x3140
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x4, 0x30(%rax)
jne 0x4ec1
movq -0x8(%rbp), %rdi
movl $0x6, %esi
callq 0x32b0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3140
jmp 0x4ecf
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x32b0
movq -0x8(%rbp), %rdi
movl $0x30, %esi
callq 0x32b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
andl $0xff, %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x14(%rbp), %edx
addl $0x2, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0x16(%rbp)
movq -0x8(%rbp), %rsi
movzwl -0x16(%rbp), %edx
leaq 0x93da(%rip), %rdi      # 0xea2a
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movzwl -0x16(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %edi
movq 0x8(%rax), %rsi
callq 0x94a0
leaq 0x93ba(%rip), %rdi      # 0xea36
movb $0x0, %al
callq 0x10d0
movl -0x14(%rbp), %eax
addl $0x3, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
andl $0xff, %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x14(%rbp), %edx
addl $0x3, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movzwl -0x18(%rbp), %edx
movzbl -0x15(%rbp), %ecx
leaq 0x9239(%rip), %rdi      # 0xea44
movb $0x0, %al
callq 0x10d0
movl -0x14(%rbp), %eax
addl $0x4, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x90d6(%rip), %rdi      # 0xea18
movb $0x0, %al
callq 0x10d0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x596d
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x4ef0
movl %eax, -0xc(%rbp)
jmp 0x5950
leaq 0x86b5(%rip), %rdi      # 0xe029
movb $0x0, %al
callq 0x10d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/lib/core/core.c
// Function: Number_floor
int8_t Number_floor(bluVM* vm, int8_t argCount, bluValue* args) {
	double number = AS_NUMBER(args[0]);

	double floored = (double)((int)number);

	args[0] = NUMBER_VAL(floored);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
cvttsd2si -0x20(%rbp), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl $0x2, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/lib/core/core.c
// Function: Number_ceil
int8_t Number_ceil(bluVM* vm, int8_t argCount, bluValue* args) {
	double number = AS_NUMBER(args[0]);

	double ceiled = (double)((int)number) + 1;

	args[0] = NUMBER_VAL(ceiled);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
cvttsd2si -0x20(%rbp), %eax
cvtsi2sd %eax, %xmm0
movsd 0x8ee7(%rip), %xmm1     # 0xea58
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl $0x2, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jne 0x5c51
movq -0x20(%rbp), %rax
movl 0x24(%rax), %eax
shll %eax
movslq %eax, %rdi
callq 0x18f0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x5c17
movl $0x8, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x20(%rbp), %rax
movslq 0x24(%rax), %rdx
shlq $0x4, %rdx
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
callq 0x6eb0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rdx
movl 0x20(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x20(%rdx)
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/lib/core/core.c
// Function: Array_at
int8_t Array_at(bluVM* vm, int8_t argCount, bluValue* args) {
	bluObjArray* array = AS_ARRAY(args[0]);
	int index = AS_NUMBER(args[1]);

	args[0] = array->data[index];

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cvttsd2si 0x18(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x28(%rcx), %rcx
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x7ad0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq 0x20(%rcx), %rcx
movb $0x0, 0x28(%rax,%rcx)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x5e19
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x20(%rcx), %ecx
subl $0x1, %ecx
subl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
movb 0x28(%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb %dl, 0x28(%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5dde
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x3, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x7bb0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/lib/core/core.c
// Function: String_toNumber
int8_t String_toNumber(bluVM* vm, int8_t argCount, bluValue* args) {
	bluObjString* string = AS_STRING(args[0]);

	double number = atof(string->chars);

	args[0] = NUMBER_VAL(number);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x1080
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl $0x2, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x7740
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x11e0
movq %rax, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rsi
addq $0x28, %rsi
leaq -0x40(%rbp), %rdi
callq 0x1170
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x6015
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x38(%rbp), %rdi
callq 0x10c0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movl %eax, %edx
callq 0x75a0
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x30(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jne 0x5fd1
movq -0x30(%rbp), %rax
movl 0x24(%rax), %eax
shll %eax
movslq %eax, %rdi
callq 0x18f0
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jne 0x5f97
movl $0x8, -0x54(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x30(%rbp), %rax
movslq 0x24(%rax), %rdx
shlq $0x4, %rdx
movslq -0x54(%rbp), %rcx
shlq $0x4, %rcx
callq 0x6eb0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x54(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x30(%rbp), %rdx
movl 0x20(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x20(%rdx)
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x3, -0x68(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
movq -0x60(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x5f15
movq -0x48(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movl $0x3, -0x78(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq -0x78(%rbp), %rcx
movq %rcx, (%rax)
movq -0x70(%rbp), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cvttsd2si 0x18(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x7ad0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb 0x28(%rax,%rcx), %cl
movq -0x30(%rbp), %rax
movb %cl, 0x28(%rax)
movq -0x30(%rbp), %rax
movb $0x0, 0x29(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x3, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x7bb0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/lib/core/core.c
// Function: String_substring
int8_t String_substring(bluVM* vm, int8_t argCount, bluValue* args) {
	bluObjString* string = AS_STRING(args[0]);
	int from = AS_NUMBER(args[1]);
	int length = AS_NUMBER(args[2]);

	bluObjString* str = bluNewString(vm, length);
	memcpy(str->chars, string->chars + from, length);
	str->chars[length] = '\0';

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

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cvttsd2si 0x18(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
cvttsd2si 0x28(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x7ad0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movq -0x20(%rbp), %rsi
addq $0x28, %rsi
movslq -0x24(%rbp), %rax
addq %rax, %rsi
movslq -0x28(%rbp), %rdx
callq 0x1150
movq -0x30(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb $0x0, 0x28(%rax,%rcx)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x3, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x7bb0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x38(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x8f60(%rip), %rsi      # 0xf4c1
movl $0x5, %edx
callq 0x75a0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rax, %rdx
leaq -0x30(%rbp), %rcx
callq 0x8db0
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x8f21(%rip), %rsi      # 0xf4c7
movl $0x5, %edx
callq 0x75a0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
leaq -0x30(%rbp), %rcx
callq 0x8db0
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
movq -0x48(%rbp), %rsi
addq $0x28, %rsi
callq 0x11a0
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x65f2
movb $-0x1, -0x1(%rbp)
jmp 0x6605
movq -0x50(%rbp), %rcx
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x11c0
movq %rax, -0x48(%rbp)
cmpq $-0x1, -0x48(%rbp)
jne 0x671e
movq -0x20(%rbp), %rax
movl $0x1, -0x58(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rdi
callq 0x1030
movb $0x1, -0x1(%rbp)
jmp 0x6794
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x674b
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x48(%rbp)
movb $0x0, -0x1(%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0x3, -0x68(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rax
movl %eax, %edx
callq 0x75a0
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x60(%rbp)
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
movq -0x60(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rdi
callq 0x1030
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq 0xde11(%rip), %rsi      # 0x145c8
leaq 0x8d0f(%rip), %rdx      # 0xf4cd
callq 0x98e0
movq -0x8(%rbp), %rdi
leaq 0x8d08(%rip), %rsi      # 0xf4d6
callq 0xc3a0
movq %rax, -0x10(%rbp)
movl $0x3, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq -0x351(%rip), %rcx      # 0x64a0
movq %rcx, 0x50(%rax)
movl $0x3, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
leaq -0x32f(%rip), %rcx      # 0x64e0
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x8cb9(%rip), %rdx      # 0xf4db
leaq -0x309(%rip), %rcx      # 0x6520
xorl %r8d, %r8d
callq 0xc440
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x8ca0(%rip), %rdx      # 0xf4e0
leaq -0x237(%rip), %rcx      # 0x6610
xorl %r8d, %r8d
callq 0xc440
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x8c88(%rip), %rdx      # 0xf4e6
leaq -0x215(%rip), %rcx      # 0x6650
xorl %r8d, %r8d
callq 0xc440
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x8c71(%rip), %rdx      # 0xf4ed
leaq -0x1f3(%rip), %rcx      # 0x6690
xorl %r8d, %r8d
callq 0xc440
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)