LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jne 0x697d
leaq 0x76b3(%rip), %rdi      # 0xe029
movb $0x0, %al
callq 0x10d0
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jg 0x69c2
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %edi
movq 0x8(%rax), %rsi
callq 0x94a0
leaq 0x7679(%rip), %rdi      # 0xe029
movb $0x0, %al
callq 0x10d0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6984
movb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x7ad0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movq 0xd5d1(%rip), %rax      # 0x13fd8
movq (%rax), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x1110
cmpq $0x0, %rax
jne 0x6a28
leaq 0x7608(%rip), %rdi      # 0xe029
movb $0x0, %al
callq 0x10d0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7bb0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl $0x3, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, -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
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq 0xdae9(%rip), %rsi      # 0x145d0
leaq 0x8bf2(%rip), %rdx      # 0xf6e0
callq 0x98e0
movq -0x8(%rbp), %rdi
leaq 0x8bed(%rip), %rsi      # 0xf6eb
callq 0xc3a0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x8bdc(%rip), %rdx      # 0xf6f2
leaq -0x22d(%rip), %rcx      # 0x68f0
xorl %r8d, %r8d
callq 0xc500
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x8bc4(%rip), %rdx      # 0xf6f8
leaq -0x1eb(%rip), %rcx      # 0x6950
xorl %r8d, %r8d
callq 0xc500
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x8bae(%rip), %rdx      # 0xf700
leaq -0x189(%rip), %rcx      # 0x69d0
xorl %r8d, %r8d
callq 0xc500
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x8b97(%rip), %rdx      # 0xf707
leaq -0x107(%rip), %rcx      # 0x6a70
xorl %r8d, %r8d
callq 0xc500
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x6e19
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x6bc0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
movq 0x10(%rax), %rdx
callq 0x6b90
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6dc7
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
subq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x101890(%rax), %rcx
movq %rcx, 0x101890(%rax)
movq -0x10(%rbp), %rax
movq 0x101890(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x101898(%rcx), %rax
jbe 0x6f05
movq -0x10(%rbp), %rax
movb $0x1, 0x1018a0(%rax)
cmpq $0x0, -0x28(%rbp)
jne 0x6f1f
movq -0x18(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x6f30
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1190
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/memory.c
// Function: tableDeleteWhite
static void tableDeleteWhite(bluVM* vm, bluTable* table) {
	for (int32_t i = 0; i <= table->capacityMask; i++) {
		bluEntry* entry = &table->entries[i];
		if (entry->key != NULL && !entry->key->obj.isDark) {
			bluTableDelete(vm, table, entry->key);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x71f2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x71e5
movq -0x20(%rbp), %rax
movq (%rax), %rax
testb $0x1, 0x10(%rax)
jne 0x71e5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
callq 0x9140
jmp 0x71e7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7197
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x101888(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7435
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7200
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x740b
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x7620
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x101820, %rsi         # imm = 0x101820
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
callq 0x9250
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x75f6
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x760d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
callq 0x7670
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x811c9dc5, -0x10(%rbp) # imm = 0x811C9DC5
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7668
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
xorl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
imull $0x1000193, -0x10(%rbp), %eax # imm = 0x1000193
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7639
movl -0x10(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/object.c
// Function: allocateString
static bluObjString* allocateString(bluVM* vm, const char* chars, int32_t length, int32_t hash) {
	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 = hash;

	strncpy(string->chars, chars, length);

	string->chars[length] = '\0';

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

	return string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
cltq
shlq $0x0, %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x7, %edx
callq 0x77c0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x101868(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x18(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x1040
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, 0x28(%rax,%rcx)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x101820, %rsi         # imm = 0x101820
movq -0x28(%rbp), %rdx
movl $0x1, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x38(%rbp), %ecx
movq -0x30(%rbp), %r8
callq 0x8ef0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x30, %esi
xorl %edx, %edx
callq 0x77c0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x101850(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movslq -0xc(%rbp), %rdi
callq 0x18f0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x24(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq 0x24(%rax), %rsi
shlq $0x4, %rsi
callq 0x6e80
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6e80
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x101888(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x101888(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %esi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x38, %esi
movl $0x1, %edx
callq 0x77c0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x101860(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x60, %esi
movl $0x2, %edx
callq 0x77c0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x101858(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
callq 0x9330
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rsi
callq 0x9330
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x38, %esi
movl $0x3, %edx
callq 0x77c0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x101860(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x7440
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x80, %esi
movl $0x4, %edx
callq 0x77c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x101860(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movw $0x0, 0x22(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x78(%rax)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x1ae0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x38, %esi
movl $0x5, %edx
callq 0x77c0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
callq 0x9330
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movl $0x30, %esi
movl $0x6, %edx
callq 0x77c0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x101860(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
cltq
shlq $0x0, %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x7, %edx
callq 0x77c0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x101868(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x40, %esi
movl $0x8, %edx
callq 0x77c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x1, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x7620
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x101820, %rsi         # imm = 0x101820
movq -0x18(%rbp), %rdx
addq $0x28, %rdx
movq -0x18(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x18(%rbp), %rax
movl 0x24(%rax), %r8d
callq 0x9250
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7c1d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7c53
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x101820, %rsi         # imm = 0x101820
movq -0x18(%rbp), %rdx
movl $0x1, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x30(%rbp), %ecx
movq -0x28(%rbp), %r8
callq 0x8ef0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/parser/parser.c
// Function: bluParserInit
void bluParserInit(bluParser* parser, const char* source) {
	parser->source = source;
	parser->from = 0;
	parser->at = 0;
	parser->lineFrom = 1;
	parser->lineTo = 1;
	parser->columnFrom = 0;
	parser->columnTo = 0;

	// Initialize the token types to something deterministic to prevent compiler optimizations
	parser->current.type = TOKEN_EOF;
	parser->previous.type = TOKEN_EOF;

	parser->emitEOF = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl $0x2f, 0x40(%rax)
movq -0x8(%rbp), %rax
movl $0x2f, 0x20(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x60(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/parser/parser.c
// Function: skipWhitespace
static void skipWhitespace(bluParser* parser) {
	while (true) {
		char c = peek(parser);
		switch (c) {
		case ' ':
		case '\r':
		case '\t': advance(parser); break;
		case '/':
			if (peekNext(parser) == '/') {
				// A comment goes until the end of the line.
				while (peek(parser) != '\n' && !isAtEnd(parser)) {
					advance(parser);
				}
			} else {
				return;
			}
			break;
		default: return;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8800
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
addl $-0x9, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x26, %eax
ja 0x82da
movq -0x18(%rbp), %rax
leaq 0x77b3(%rip), %rcx      # 0xfa28
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x8380
jmp 0x82dc
movq -0x8(%rbp), %rdi
callq 0x8820
movsbl %al, %eax
cmpl $0x2f, %eax
jne 0x82d6
jmp 0x829c
movq -0x8(%rbp), %rdi
callq 0x8800
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x19(%rbp)
je 0x82c0
movq -0x8(%rbp), %rdi
callq 0x82f0
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x82c9
jmp 0x82d4
movq -0x8(%rbp), %rdi
callq 0x8380
jmp 0x829c
jmp 0x82d8
jmp 0x82e1
jmp 0x82dc
jmp 0x82e1
jmp 0x824c
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/parser/parser.c
// Function: eof
static bluToken eof(bluParser* parser) {
	if (parser->emitEOF) {
		return makeToken(parser, TOKEN_EOF);
	}

	parser->emitEOF = true;

	return makeToken(parser, TOKEN_NEWLINE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0x8352
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x2f, %edx
callq 0x8580
jmp 0x836c
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movb $0x1, 0x60(%rax)
movq -0x8(%rbp), %rsi
movl $0x30, %edx
callq 0x8580
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/parser/parser.c
// Function: number
static bluToken number(bluParser* parser) {
	while (isDigit(peek(parser))) {
		advance(parser);
	}

	// Look for a fractional part.
	if (peek(parser) == '.' && isDigit(peekNext(parser))) {
		// Consume the "."
		advance(parser);

		while (isDigit(peek(parser))) {
			advance(parser);
		}
	}

	return makeToken(parser, TOKEN_NUMBER);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8800
movsbl %al, %edi
callq 0x84a0
testb $0x1, %al
jne 0x84fb
jmp 0x8506
movq -0x8(%rbp), %rdi
callq 0x8380
jmp 0x84e4
movq -0x8(%rbp), %rdi
callq 0x8800
movsbl %al, %eax
cmpl $0x2e, %eax
jne 0x855b
movq -0x8(%rbp), %rdi
callq 0x8820
movsbl %al, %edi
callq 0x84a0
testb $0x1, %al
jne 0x852e
jmp 0x855b
movq -0x8(%rbp), %rdi
callq 0x8380
movq -0x8(%rbp), %rdi
callq 0x8800
movsbl %al, %edi
callq 0x84a0
testb $0x1, %al
jne 0x854e
jmp 0x8559
movq -0x8(%rbp), %rdi
callq 0x8380
jmp 0x8537
jmp 0x855b
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x1a, %edx
callq 0x8580
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x2f, %eax
je 0x85c7
jmp 0x85a8
movl -0x10(%rbp), %eax
subl $0x30, %eax
jne 0x85dc
jmp 0x85b2
movq -0x20(%rbp), %rax
leaq 0x75a3(%rip), %rcx      # 0xfb60
movq %rcx, 0x8(%rax)
movb $0x9, 0x10(%rax)
jmp 0x8607
movq -0x20(%rbp), %rax
leaq 0x7598(%rip), %rcx      # 0xfb6a
movq %rcx, 0x8(%rax)
movb $0x5, 0x10(%rax)
jmp 0x8607
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x8(%rbp), %rdx
movslq 0x8(%rdx), %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %ecx
movq -0x8(%rbp), %rdx
subl 0x8(%rdx), %ecx
movb %cl, 0x10(%rax)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rdx
movl 0x10(%rdx), %edx
movl %edx, 0x14(%rcx)
movq -0x8(%rbp), %rdx
movl 0x18(%rdx), %edx
movl %edx, 0x18(%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x82f0
testb $0x1, %al
jne 0x8651
jmp 0x8657
movb $0x0, -0x1(%rbp)
jmp 0x867e
movq -0x10(%rbp), %rdi
callq 0x8800
movsbl %al, %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0x8671
movb $0x0, -0x1(%rbp)
jmp 0x867e
movq -0x10(%rbp), %rdi
callq 0x8380
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/parser/parser.c
// Function: string
static bluToken string(bluParser* parser) {
	while (peek(parser) != '"' && !isAtEnd(parser)) {
		if (peek(parser) == '\n') {
			newline(parser);
		}

		advance(parser);
	}

	if (isAtEnd(parser)) {
		return errorToken(parser, "Unterminated string.");
	}

	// The closing ".
	advance(parser);

	return makeToken(parser, TOKEN_STRING);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8800
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x22, %ecx
movb %al, -0x39(%rbp)
je 0x86c8
movq -0x8(%rbp), %rdi
callq 0x82f0
xorb $-0x1, %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x86d1
jmp 0x86fa
movq -0x8(%rbp), %rdi
callq 0x8800
movsbl %al, %eax
cmpl $0xa, %eax
jne 0x86ef
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x8750
movq -0x8(%rbp), %rdi
callq 0x8380
jmp 0x86a4
movq -0x8(%rbp), %rdi
callq 0x82f0
testb $0x1, %al
jne 0x8709
jmp 0x871f
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x7458(%rip), %rdx      # 0xfb70
callq 0x87a0
jmp 0x873a
movq -0x8(%rbp), %rdi
callq 0x8380
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x1b, %edx
callq 0x8580
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl $0x31, (%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x10(%rbp), %rdi
callq 0x10c0
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x18(%rbp), %rax
movb %cl, 0x10(%rdi)
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x14(%rdi)
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
movl %ecx, 0x18(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x8(%rcx), %eax
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
cmpl %ecx, %eax
jne 0x8d95
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rax
addq %rax, %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x1100
cmpl $0x0, %eax
jne 0x8d95
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8d9c
movl $0x19, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x8dd9
movb $0x0, -0x1(%rbp)
jmp 0x8e20
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x20(%rbp), %rdx
callq 0x8e30
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x8e05
movb $0x0, -0x1(%rbp)
jmp 0x8e20
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/table.c
// Function: findEntry
static bluEntry* findEntry(bluEntry* entries, int32_t capacityMask, bluObjString* key) {
	int32_t index = key->hash & capacityMask;
	bluEntry* tombstone = NULL;

	while (true) {
		bluEntry* entry = &entries[index];

		if (entry->key == NULL) {
			if (IS_NIL(entry->value)) {
				// Empty entry.
				return tombstone != NULL ? tombstone : entry;
			} else {
				// We found a tombstone.
				if (tombstone == NULL) {
					tombstone = entry;
				}
			}
		} else if (entry->key == key) {
			// We found the key.
			return entry;
		}

		index = (index + 1) & capacityMask;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x24(%rax), %eax
andl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x8eb1
movq -0x38(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x8e9e
cmpq $0x0, -0x30(%rbp)
je 0x8e8c
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x8e94
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8edb
cmpq $0x0, -0x30(%rbp)
jne 0x8ead
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x8eaf
jmp 0x8eca
movq -0x38(%rbp), %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x8ec8
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8edb
jmp 0x8eca
movl -0x24(%rbp), %eax
addl $0x1, %eax
andl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x8e54
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/table.c
// Function: bluTableSet
bool bluTableSet(bluVM* vm, bluTable* table, bluObjString* key, bluValue value) {
	if (table->count + 1 > (table->capacityMask + 1) * TABLE_MAX_LOAD) {
		// TODO : Make macro for growing capacity
		int32_t capacityMask = ((table->capacityMask + 1) * 2) - 1;
		if (capacityMask == -1) {
			capacityMask = 63;
		}

		adjustCapacity(vm, table, capacityMask);
	}

	bluEntry* entry = findEntry(table->entries, table->capacityMask, key);

	bool isNewKey = entry->key == NULL;

	// Increase count only if we are inserting into empty bucket, not when replacing tombstone
	if (isNewKey && IS_NIL(entry->value)) table->count++;

	entry->key = key;
	entry->value = value;

	return isNewKey;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %ecx, -0x10(%rbp)
movq %r8, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm1
movsd 0x6c5a(%rip), %xmm2     # 0xfb88
mulsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x8f67
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
addl $0x1, %eax
shll %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x8f57
movl $0x3f, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x8fe0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x28(%rbp), %rdx
callq 0x8e30
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
sete %al
andb $0x1, %al
movb %al, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
je 0x8fae
movq -0x38(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x8fae
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x10(%rax)
movb -0x39(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/table.c
// Function: adjustCapacity
static void adjustCapacity(bluVM* vm, bluTable* table, int32_t capacityMask) {
	bluEntry* entries = bluAllocate(vm, sizeof(bluEntry) * (capacityMask + 1));

	for (int32_t i = 0; i <= capacityMask; i++) {
		entries[i].key = NULL;
		entries[i].value = NIL_VAL;
	}

	table->count = 0;

	for (int32_t i = 0; i <= table->capacityMask; i++) {
		bluEntry* entry = &table->entries[i];
		if (entry->key == NULL) continue;

		bluEntry* dest = findEntry(entries, capacityMask, entry->key);
		dest->key = entry->key;
		dest->value = entry->value;

		table->count++;
	}

	bluDeallocate(vm, table->entries, sizeof(bluEntry) * (table->capacityMask + 1));

	table->entries = entries;
	table->capacityMask = capacityMask;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
cltq
imulq $0x18, %rax, %rsi
callq 0x6e80
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x906a
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x1, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9013
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x9100
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x3c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x90aa
jmp 0x90f2
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x48(%rbp), %rax
movq (%rax), %rdx
callq 0x8e30
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rcx
movq -0x50(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x907b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
addl $0x1, %eax
cltq
imulq $0x18, %rax, %rdx
callq 0x6f40
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/table.c
// Function: bluTableDelete
bool bluTableDelete(bluVM* vm, bluTable* table, bluObjString* key) {
	if (table->count == 0) return false;

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

	// Place a tombstone in the entry.
	entry->key = NULL;
	entry->value = BOOL_VAL(true);

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x9163
movb $0x0, -0x1(%rbp)
jmp 0x91bd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x20(%rbp), %rdx
callq 0x8e30
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x918f
movb $0x0, -0x1(%rbp)
jmp 0x91bd
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
movl $0x0, -0x38(%rbp)
movb $0x1, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/table.c
// Function: bluTableAddAll
void bluTableAddAll(bluVM* vm, bluTable* from, bluTable* to) {
	for (int32_t i = 0; i <= from->capacityMask; i++) {
		bluEntry* entry = &from->entries[i];
		if (entry->key != NULL) {
			bluTableSet(vm, to, entry->key, entry->value);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x9244
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x9237
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
movq 0x10(%rax), %r8
callq 0x8ef0
jmp 0x9239
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x91eb
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/table.c
// Function: bluTableFindString
bluObjString* bluTableFindString(bluVM* vm, bluTable* table, const char* chars, int32_t length, int32_t hash) {
	// If the table is empty, we definitely won't find it.
	if (table->entries == NULL) return NULL;

	int32_t index = hash & table->capacityMask;

	while (true) {
		bluEntry* entry = &table->entries[index];

		if (entry->key == NULL) {
			// Stop if we find an empty non-tombstone entry.
			if (IS_NIL(entry->value)) return NULL;
		} else if (entry->key->length == length && entry->key->hash == hash &&
				   memcmp(entry->key->chars, chars, length) == 0) {
			// We found it.
			return entry->key;
		}

		// Try the next slot.
		index = (index + 1) & table->capacityMask;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x9283
movq $0x0, -0x8(%rbp)
jmp 0x9326
movl -0x28(%rbp), %eax
movq -0x18(%rbp), %rcx
andl 0x4(%rcx), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x92c7
movq -0x38(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x92c5
movq $0x0, -0x8(%rbp)
jmp 0x9326
jmp 0x9311
movq -0x38(%rbp), %rax
movq (%rax), %rax
movl 0x20(%rax), %eax
cmpl -0x24(%rbp), %eax
jne 0x930f
movq -0x38(%rbp), %rax
movq (%rax), %rax
movl 0x24(%rax), %eax
cmpl -0x28(%rbp), %eax
jne 0x930f
movq -0x38(%rbp), %rax
movq (%rax), %rdi
addq $0x28, %rdi
movq -0x20(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x1100
cmpl $0x0, %eax
jne 0x930f
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9326
jmp 0x9311
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movq -0x18(%rbp), %rcx
andl 0x4(%rcx), %eax
movl %eax, -0x2c(%rbp)
jmp 0x9290
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/value.c
// Function: bluValuesEqual
bool bluValuesEqual(bluValue a, bluValue b) {
	if (a.type != b.type) return false;

	switch (a.type) {
	case VAL_BOOL: return AS_BOOL(a) == AS_BOOL(b);
	case VAL_NIL: return true;
	case VAL_NUMBER: return fabs(AS_NUMBER(a) - AS_NUMBER(b)) < __DBL_EPSILON__;
	case VAL_OBJ: return AS_OBJ(a) == AS_OBJ(b);
	}

	__builtin_unreachable();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x28(%rbp), %eax
je 0x93d0
movb $0x0, -0x1(%rbp)
jmp 0x944b
movl -0x18(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
leaq 0x67ce(%rip), %rcx      # 0xfbb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb -0x10(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x20(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x944b
movb $0x1, -0x1(%rbp)
jmp 0x944b
movsd -0x10(%rbp), %xmm1
subsd -0x20(%rbp), %xmm1
movaps 0x6781(%rip), %xmm0     # 0xfba0
pand %xmm0, %xmm1
movsd 0x6765(%rip), %xmm0     # 0xfb90
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x944b
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x944b
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/value.c
// Function: bluPrintValue
void bluPrintValue(bluValue value) {
	switch (value.type) {
	case VAL_BOOL: printf(AS_BOOL(value) ? "true" : "false"); break;
	case VAL_NIL: printf("nil"); break;
	case VAL_NUMBER: {
		if (AS_NUMBER(value) == (int)AS_NUMBER(value)) {
			printf("%d", (int)AS_NUMBER(value));
		} else {
			printf("%g", AS_NUMBER(value));
		}
		break;
	}
	case VAL_OBJ: bluPrintObject(value); break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x9551
movq -0x18(%rbp), %rax
leaq 0x66f5(%rip), %rcx      # 0xfbc0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb -0x8(%rbp), %cl
leaq 0x66f7(%rip), %rdi      # 0xfbd5
leaq 0x66eb(%rip), %rax      # 0xfbd0
testb $0x1, %cl
cmovneq %rax, %rdi
movb $0x0, %al
callq 0x10d0
jmp 0x9551
leaq 0x66df(%rip), %rdi      # 0xfbdb
movb $0x0, %al
callq 0x10d0
jmp 0x9551
movsd -0x8(%rbp), %xmm0
cvttsd2si -0x8(%rbp), %eax
cvtsi2sd %eax, %xmm1
ucomisd %xmm1, %xmm0
jne 0x9530
jp 0x9530
cvttsd2si -0x8(%rbp), %esi
leaq 0x66b8(%rip), %rdi      # 0xfbdf
movb $0x0, %al
callq 0x10d0
jmp 0x9543
movsd -0x8(%rbp), %xmm0
leaq 0x66a6(%rip), %rdi      # 0xfbe2
movb $0x1, %al
callq 0x10d0
jmp 0x9551
movl -0x10(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x7c60
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)