LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mabdi[P]bunney/bunny-trace.c
// Function: handle_kill
static void handle_kill(int sig) {
  _u32 i;
  shmctl(shmid, IPC_RMID, 0);
  if (orig_pid > 0) kill(orig_pid,SIGKILL);
  for (i=0;i<proc_cnt;i++) kill(procs[i].pid,SIGKILL);
  fflush(outfile);
  debug("--- Tracer exiting on signal %d ---\n",sig);
  exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
movl 0x3144(%rip), %edi      # 0x5128
xorl %esi, %esi
xorl %edx, %edx
callq 0x10c0
movl 0x3145(%rip), %edi      # 0x5138
testl %edi, %edi
jle 0x2001
movl $0x9, %esi
callq 0x1160
cmpl $0x0, 0x3134(%rip)      # 0x513c
je 0x2037
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x3129(%rip), %rax      # 0x5140
movl (%rax,%r14), %edi
movl $0x9, %esi
callq 0x1160
incq %r15
movl 0x310e(%rip), %eax      # 0x513c
addq $0x28, %r14
cmpq %rax, %r15
jb 0x2010
movq 0x30e2(%rip), %rdi      # 0x5120
callq 0x1110
movq 0x2f96(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x11bd(%rip), %rsi      # 0x3211
movl %ebx, %edx
xorl %eax, %eax
callq 0x1170
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O1/mabdi[P]bunney/bunny-trace.c
// Function: report_kids
static _u8 report_kids(void) {
  _s32 rno;
  _u32 i;

  static _s32 pid;
  static _u32 st;

  if (pid >= 0) {
    pid = waitpid(orig_pid,&st,WNOHANG);
    /* Process still running or just done? */
    if (pid >= 0) return 0;
  }

  /* Process gone at least a round ago... */

  rno = get_procentry(orig_pid,0);

  if (rno < 0) {

    if (WIFEXITED(st))     
      outf("--- Untraced process %u exited (code=%u) ---\n",orig_pid,WEXITSTATUS(st));
    else 
      outf("--- Untraced process %u killed (signal %u) ---\n",orig_pid,WTERMSIG(st));

  } else {

    if (WIFEXITED(st)) 
      outf("--- Process %u exited (code=%u) ---\n",orig_pid,WEXITSTATUS(st));
    else 
      outf("--- Process %u killed (signal %u) ---\n",orig_pid,WTERMSIG(st));

  }

  if (shmreg->child_crash)
    outf("--- (Child process %u crashed) ---\n",shmreg->child_crash);

  for (i=0;i<proc_cnt;i++) kill(procs[i].pid,SIGKILL);
    
  return 1;
  
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x0, 0x2fd2(%rip)      # 0x5148
js 0x21a0
movl 0x2fba(%rip), %edi      # 0x5138
leaq 0x2fc7(%rip), %rsi      # 0x514c
movl $0x1, %edx
callq 0x1090
movl %eax, 0x2fb3(%rip)      # 0x5148
testl %eax, %eax
js 0x21a0
xorl %ebx, %ebx
jmp 0x2287
movl 0x2f92(%rip), %edx      # 0x5138
movl 0x2f90(%rip), %ecx      # 0x513c
testq %rcx, %rcx
je 0x21f0
movq 0x2f88(%rip), %rsi      # 0x5140
xorl %eax, %eax
cmpl %edx, (%rsi)
je 0x21cf
incq %rax
addq $0x28, %rsi
cmpq %rax, %rcx
jne 0x21ba
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x21f0
movl 0x2f73(%rip), %eax      # 0x514c
movl %eax, %ecx
movq 0x2f3e(%rip), %rdi      # 0x5120
andl $0x7f, %ecx
je 0x2219
leaq 0x123a(%rip), %rsi      # 0x3428
jmp 0x2223
movl 0x2f56(%rip), %eax      # 0x514c
movl %eax, %ecx
movq 0x2f21(%rip), %rdi      # 0x5120
andl $0x7f, %ecx
je 0x220d
leaq 0x11c8(%rip), %rsi      # 0x33d3
jmp 0x2223
movzbl %ah, %ecx
leaq 0x118e(%rip), %rsi      # 0x33a5
jmp 0x2223
movzbl %ah, %ecx
leaq 0x11e0(%rip), %rsi      # 0x3403
xorl %eax, %eax
callq 0x1170
movq 0x2eff(%rip), %rax      # 0x5130
cmpl $0x0, 0x10(%rax)
je 0x224f
movq 0x2ee2(%rip), %rdi      # 0x5120
movl 0x10(%rax), %edx
leaq 0x1207(%rip), %rsi      # 0x344f
xorl %eax, %eax
callq 0x1170
movb $0x1, %bl
cmpl $0x0, 0x2ee4(%rip)      # 0x513c
je 0x2287
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x2ed9(%rip), %rax      # 0x5140
movl (%rax,%r14), %edi
movl $0x9, %esi
callq 0x1160
incq %r15
movl 0x2ebe(%rip), %eax      # 0x513c
addq $0x28, %r14
cmpq %rax, %r15
jb 0x2260
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mabdi[P]bunney/bunny-trace.c
// Function: do_indent
static void do_indent(_u32 pid,_s32 level,_s8 cor) {
  _s32 i;

  if (level < 0) {  
    outf("[%05u] %+02d < ", pid,level);
  } else {
    outf("[%05u] %03d ", pid,level);
    for (i=0;i<level+cor;i++) outf("| ");
  }

}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %ebx
movl %edi, %edx
movq 0x2de5(%rip), %rdi      # 0x5120
testl %esi, %esi
js 0x2382
leaq 0x11c7(%rip), %rsi      # 0x350d
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1170
movsbl %bpl, %ebp
addl %ebx, %ebp
jle 0x237b
leaq 0x11bc(%rip), %rbx      # 0x351a
movq 0x2dbb(%rip), %rcx      # 0x5120
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x11e0
decl %ebp
jne 0x235e
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1174(%rip), %rsi      # 0x34fd
movl %ebx, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1170
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/vm.c
// Function: runtimeError
static void runtimeError(bluVM* vm, const char* format, ...) {
	va_list args;
	va_start(args, format);
	vfprintf(stderr, format, args);
	va_end(args);
	fputs("\n", stderr);

	for (int i = vm->frameCount - 1; i >= 0; i--) {
		bluCallFrame* frame = &vm->frames[i];
		bluObjFunction* function = frame->closure->function;

		// -1 because the IP is sitting on the next instruction to be executed.
		size_t instruction = frame->ip - function->chunk.code.data - 1;

		fprintf(stderr, "[line %d] in ", function->chunk.lines.data[instruction]);
		fprintf(stderr, "%s\n", function->chunk.name);
	}

	resetStack(vm);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x2294
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq 0xdd3d(%rip), %r12      # 0xfff8
movq (%r12), %rdi
callq 0x21d0
movq (%r12), %rsi
leaq 0x9a57(%rip), %rdi      # 0xbd26
callq 0x2110
movslq 0x101808(%rbx), %r13
testq %r13, %r13
jle 0x2348
imulq $0x18, %r13, %rax
incq %r13
leaq (%rax,%rbx), %rbp
addq $0xffff8, %rbp          # imm = 0xFFFF8
leaq 0x81b6(%rip), %r15      # 0xa4af
movq -0x8(%rbp), %rax
movq (%rbp), %rcx
movq 0x20(%rax), %r14
movq 0x38(%r14), %rax
notq %rax
movq (%r12), %rdi
shlq $0x2, %rax
addq 0x48(%r14), %rax
movl (%rax,%rcx,4), %edx
leaq 0x7f03(%rip), %rsi      # 0xa225
xorl %eax, %eax
callq 0x2140
movq (%r12), %rdi
movq 0x30(%r14), %rdx
movq %r15, %rsi
xorl %eax, %eax
callq 0x2140
decq %r13
addq $-0x18, %rbp
cmpq $0x1, %r13
jg 0x22f9
movq %rbx, 0x100000(%rbx)
andl $0x0, 0x101808(%rbx)
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/table.c
// Function: bluTableGet
bool bluTableGet(bluVM* vm, bluTable* table, bluObjString* key, bluValue* value) {
	if (table->entries == NULL) return false;

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

	*value = entry->value;

	return true;
}

// Assembly:
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x2598
pushq %rbx
movq %rcx, %rbx
movl 0x4(%rsi), %esi
callq 0x259b
movq %rax, %rcx
cmpq $0x0, (%rax)
setne %al
je 0x2596
movups 0x8(%rcx), %xmm0
movups %xmm0, (%rbx)
movb $0x1, %al
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl 0x24(%rdx), %ecx
andl %esi, %ecx
xorl %r8d, %r8d
movslq %ecx, %r9
leaq (%r9,%r9,2), %r9
leaq (%rdi,%r9,8), %r10
movq (%r10), %r9
testq %r9, %r9
je 0x25c3
cmpq %rdx, %r9
jne 0x25df
xorl %r9d, %r9d
movq %r10, %rax
jmp 0x25e6
testq %r8, %r8
movq %r8, %r11
cmoveq %r10, %r11
cmpl $0x1, 0x8(%r10)
jne 0x25dc
xorl %r9d, %r9d
movq %r11, %rax
jmp 0x25e6
movq %r11, %r8
incl %ecx
andl %esi, %ecx
movb $0x1, %r9b
testb %r9b, %r9b
jne 0x25a3
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r15
movl (%rsi), %eax
incl %eax
cvtsi2sd %eax, %xmm0
movl 0x4(%rsi), %eax
incl %eax
cvtsi2sd %eax, %xmm1
mulsd 0x79ea(%rip), %xmm1     # 0xa008
ucomisd %xmm1, %xmm0
jbe 0x2738
movq %rdi, %r13
movq %r14, 0x10(%rsp)
leal -0x1(,%rax,2), %ecx
testl %eax, %eax
movl $0x3f, %r14d
cmovnel %ecx, %r14d
movslq %r14d, %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
addq $0x18, %rsi
callq 0x7fbf
movq %rax, %rbx
movq %r14, (%rsp)
testl %r14d, %r14d
js 0x2691
movq (%rsp), %rax
incl %eax
movl %eax, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rax
xorl %ecx, %ecx
xorl %edx, %edx
movq %rcx, (%rbx,%rdx)
movl $0x1, 0x8(%rbx,%rdx)
movq %rcx, 0x10(%rbx,%rdx)
addq $0x18, %rdx
cmpq %rdx, %rax
jne 0x2677
movl $0x0, (%r15)
movl 0x4(%r15), %eax
testl %eax, %eax
movq 0x10(%rsp), %r14
js 0x2712
movq %r13, 0x18(%rsp)
movq %r12, 0x20(%rsp)
movl %ebp, 0xc(%rsp)
movq $-0x1, %r12
movl $0x8, %r14d
movq 0x8(%r15), %r13
movq -0x8(%r13,%r14), %rbp
testq %rbp, %rbp
je 0x26ef
movq %rbx, %rdi
movq (%rsp), %rsi
movq %rbp, %rdx
callq 0x259b
movq %rbp, (%rax)
movupd (%r13,%r14), %xmm0
movupd %xmm0, 0x8(%rax)
incl (%r15)
movslq 0x4(%r15), %rax
incq %r12
addq $0x18, %r14
cmpq %rax, %r12
jl 0x26c0
movq 0x10(%rsp), %r14
movl 0xc(%rsp), %ebp
movq 0x20(%rsp), %r12
movq 0x18(%rsp), %r13
movq 0x8(%r15), %rsi
cltq
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
addq $0x18, %rdx
movq %r13, %rdi
callq 0x800c
movq %rbx, 0x8(%r15)
movq (%rsp), %rax
movl %eax, 0x4(%r15)
movq 0x8(%r15), %rdi
movl 0x4(%r15), %esi
movq %r12, %rdx
callq 0x259b
movq (%rax), %rcx
testq %rcx, %rcx
jne 0x2759
cmpl $0x1, 0x8(%rax)
jne 0x2759
incl (%r15)
testq %rcx, %rcx
sete %cl
movq %r12, (%rax)
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
movl %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x0, (%rsi)
je 0x27b1
pushq %rax
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
callq 0x259b
movq %rax, %rcx
cmpq $0x0, (%rax)
setne %al
je 0x27ac
movq $0x0, (%rcx)
movl $0x0, 0x8(%rcx)
movb $0x1, 0x10(%rcx)
movb $0x1, %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x0, 0x4(%rsi)
js 0x2814
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $-0x1, %r12
movl $0x10, %r13d
movq 0x8(%r14), %rax
movq -0x10(%rax,%r13), %rdx
testq %rdx, %rdx
je 0x27fb
movl -0x8(%rax,%r13), %ecx
movq (%rax,%r13), %r8
movq %r15, %rdi
movq %rbx, %rsi
callq 0x25ec
movslq 0x4(%r14), %rax
incq %r12
addq $0x18, %r13
cmpq %rax, %r12
jl 0x27d9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq 0x8(%rsi), %r13
testq %r13, %r13
je 0x28b5
movl %r8d, %ebp
movl 0x4(%rsi), %r14d
movl %r14d, %r15d
andl %r8d, %r15d
movslq %ecx, %rax
movq %rax, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
movslq %r15d, %rax
leaq (%rax,%rax,2), %rax
movq (%r13,%rax,8), %r12
testq %r12, %r12
je 0x2890
cmpl %ecx, 0x20(%r12)
jne 0x28a7
cmpl %ebp, 0x24(%r12)
jne 0x28a7
leaq 0x28(%r12), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2190
movl 0x4(%rsp), %ecx
testl %eax, %eax
jne 0x28a7
xorl %eax, %eax
movq %r12, %rbx
jmp 0x28af
leaq (,%rax,8), %rax
addq %r13, %rax
cmpl $0x1, 0x8(%rax)
jne 0x28a7
xorl %ebx, %ebx
xorl %eax, %eax
jmp 0x28af
incl %r15d
andl %r14d, %r15d
movb $0x1, %al
testb %al, %al
jne 0x284e
jmp 0x28b7
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rsi, -0x8(%rsp)
movq %rcx, -0x10(%rsp)
cmpl %edx, %edi
jne 0x2930
movl %edi, %eax
leaq 0x770d(%rip), %rdx      # 0xa028
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movb -0x10(%rsp), %al
xorb -0x8(%rsp), %al
testb $0x1, %al
jmp 0x2963
xorl %eax, %eax
retq
movq %rsi, %xmm0
movq %rcx, %xmm1
subsd %xmm1, %xmm0
andpd 0x76c7(%rip), %xmm0     # 0xa010
movsd 0x76cf(%rip), %xmm1     # 0xa020
ucomisd %xmm0, %xmm1
seta %al
retq
movq -0x8(%rsp), %rax
cmpq -0x10(%rsp), %rax
sete %al
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x3, %edi
ja 0x29ef
movl %edi, %eax
leaq 0x76a9(%rip), %rcx      # 0xa038
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x76a9(%rip), %rax      # 0xa048
leaq 0x76a7(%rip), %rdi      # 0xa04d
testb $0x1, %sil
cmovneq %rax, %rdi
jmp 0x29e8
movq %rsi, %xmm0
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x29f0
jp 0x29f0
cvttsd2si %xmm0, %esi
leaq 0x7687(%rip), %rdi      # 0xa057
xorl %eax, %eax
jmp 0x20f0
movl $0x3, %edi
jmp 0x88cd
leaq 0x766b(%rip), %rdi      # 0xa053
xorl %eax, %eax
jmp 0x20f0
retq
leaq 0x7663(%rip), %rdi      # 0xa05a
movb $0x1, %al
jmp 0x20f0
nop
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/vm.c
// Function: bluNewVM
bluVM* bluNewVM() {
	bluVM* vm = malloc(sizeof(bluVM));

	resetStack(vm);

	vm->frameCount = 0;
	vm->frameCountStart = 0;

	vm->openUpvalues = NULL;
	vm->objects = NULL;

	vm->bytesAllocated = 0;
	vm->nextGC = 1024 * 1024;
	vm->shouldGC = false;
	vm->timeGC = 0;

	bluTableInit(vm, &vm->globals);
	bluTableInit(vm, &vm->strings);

	bluModuleBufferInit(&vm->modules);

	vm->stringInitializer = bluCopyString(vm, "__init", 6);

	bluInitStd(vm);

	return vm;
}

// Assembly:
pushq %rbx
movl $0x1018b0, %edi         # imm = 0x1018B0
callq 0x2170
movq %rax, %rbx
movq %rax, 0x100000(%rax)
xorl %eax, %eax
movq %rax, 0x101808(%rbx)
movq %rax, 0x101830(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x101888(%rbx)
movq $0x100000, 0x101898(%rbx) # imm = 0x100000
movb $0x0, 0x1018a0(%rbx)
movq %rax, 0x1018a8(%rbx)
leaq 0x101810(%rbx), %rsi
movq %rbx, %rdi
callq 0x28c9
leaq 0x101820(%rbx), %rsi
movq %rbx, %rdi
callq 0x28c9
xorps %xmm0, %xmm0
movups %xmm0, 0x101878(%rbx)
leaq 0x766c(%rip), %rsi      # 0xa1a0
movq %rbx, %rdi
movl $0x6, %edx
callq 0x8411
movq %rax, 0x101870(%rbx)
movq %rbx, %rdi
callq 0x7b38
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/vm.c
// Function: bluFreeVM
void bluFreeVM(bluVM* vm) {
	bluCollectMemory(vm);

	bluTableFree(vm, &vm->globals);
	bluTableFree(vm, &vm->strings);

	for (int32_t i = 0; i < vm->modules.count; i++) {
		if (vm->modules.data[i].source != NULL) {
			free(vm->modules.data[i].source);
		}
	}

	bluModuleBufferFree(&vm->modules);

#ifdef DEBUG
	assert(vm->bytesAllocated == 0);
#endif

	free(vm);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x833f
leaq 0x101810(%rbx), %rsi
movq %rbx, %rdi
callq 0x28df
leaq 0x101820(%rbx), %rsi
movq %rbx, %rdi
callq 0x28df
leaq 0x101878(%rbx), %r14
cmpl $0x0, 0x101880(%rbx)
jle 0x2bc0
movl $0x10, %r15d
xorl %r12d, %r12d
movq (%r14), %rax
movq (%rax,%r15), %rdi
testq %rdi, %rdi
je 0x2bad
callq 0x2030
incq %r12
movslq 0x101880(%rbx), %rax
addq $0x20, %r15
cmpq %rax, %r12
jl 0x2b9c
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2bcd
callq 0x2030
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/vm.c
// Function: bluGetClass
bluObjClass* bluGetClass(bluVM* vm, bluValue value) {
	switch (value.type) {
	case VAL_NIL: return vm->nilClass;
	case VAL_BOOL: return vm->boolClass;
	case VAL_NUMBER: return vm->numberClass;
	case VAL_OBJ:
		if (IS_CLASS(value)) {
			// Core class were created before Class so they don't have a reference to it.
			return vm->classClass;
		} else if (IS_STRING(value)) {
			// String class can be defiend after some string instances have been already allocated so they have
			// incorrect pointer to String class.
			return vm->stringClass;
		} else {
			return AS_OBJ(value)->class;
		}
	}

	__builtin_unreachable();
}

// Assembly:
movq %rdx, -0x8(%rsp)
movl %esi, %eax
leaq 0x5b4b(%rip), %rcx      # 0xa190
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x101840, %rdi         # imm = 0x101840
jmp 0x4675
addq $0x101848, %rdi         # imm = 0x101848
jmp 0x4675
cmpl $0x2, (%rdx)
jne 0x4679
addq $0x101858, %rdi         # imm = 0x101858
jmp 0x4675
addq $0x101838, %rdi         # imm = 0x101838
movq (%rdi), %rax
retq
cmpl $0x7, (%rdx)
jne 0x4687
addq $0x101868, %rdi         # imm = 0x101868
jmp 0x4675
movq -0x8(%rsp), %rdi
addq $0x8, %rdi
jmp 0x4675
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/vm.c
// Function: bluGetGlobal
bluObj* bluGetGlobal(bluVM* vm, const char* name) {
	bluValue value;
	if (!bluTableGet(vm, &vm->globals, bluCopyString(vm, name, strlen(name)), &value)) {
		return NULL;
	}

	if (!IS_OBJ(value)) {
		return NULL;
	}

	return AS_OBJ(value);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x101810(%rdi), %r15
movq %rsi, %rdi
callq 0x20e0
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0x8411
movq %rsp, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x256c
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x3, (%rbx)
movl $0x0, %edx
jne 0x46e4
movq 0x8(%rsp), %rdx
testb %cl, %cl
cmovneq %rdx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/vm.c
// Function: bluRegisterModule
void bluRegisterModule(bluVM* vm, const char* name, bluModuleLoader loader) {
	bluModule module;
	module.name = bluCopyString(vm, name, strlen(name));
	module.loader = loader;
	module.loaded = false;
	module.source = NULL;

	bluModuleBufferWrite(&vm->modules, module);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x20e0
movq %r15, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x8411
addq $0x101878, %r15         # imm = 0x101878
movq %rax, 0x20(%rsp)
movq %rbx, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movb $0x0, 0x38(%rsp)
movups 0x20(%rsp), %xmm0
movups 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
movl $0x1, %esi
callq 0x2a20
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/vm.c
// Function: call
static bool call(bluVM* vm, bluObjClosure* closure, int8_t argCount) {
	if (argCount < closure->function->arity) {
		runtimeError(vm, "Expected %d arguments but got %d.", closure->function->arity, argCount);
		return false;
	}

	if (vm->frameCount == FRAMES_MAX) {
		runtimeError(vm, "Stack overflow.");
		return false;
	}

	bluCallFrame* frame = &vm->frames[vm->frameCount++];
	frame->closure = closure;
	frame->ip = closure->function->chunk.code.data;

	// +1 to include either the called function or the receiver.
	frame->slots = vm->stackTop - (argCount + 1);

	return true;
}

// Assembly:
pushq %rbx
movl %edx, %ecx
movq 0x20(%rsi), %rax
movsbl 0x20(%rax), %edx
cmpb %cl, %dl
jg 0x4888
movslq 0x101808(%rdi), %rdx
cmpq $0x100, %rdx            # imm = 0x100
je 0x489a
leal 0x1(%rdx), %r8d
movl %r8d, 0x101808(%rdi)
leaq (%rdx,%rdx,2), %rdx
movq %rsi, 0x100008(%rdi,%rdx,8)
movq 0x38(%rax), %rax
movq %rax, 0x100010(%rdi,%rdx,8)
notl %ecx
movslq %ecx, %rax
shlq $0x4, %rax
addq 0x100000(%rdi), %rax
movq %rax, 0x100018(%rdi,%rdx,8)
movb $0x1, %bl
movl %ebx, %eax
popq %rbx
retq
leaq 0x595e(%rip), %rsi      # 0xa1ed
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2230
jmp 0x4884
leaq 0x5992(%rip), %rsi      # 0xa233
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2230
jmp 0x4884
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/vm.c
// Function: bindMethod
static bool bindMethod(bluVM* vm, bluObjClass* class, bluObjString* name) {
	bluValue method;
	if (!bluTableGet(vm, &class->methods, name, &method)) {
		runtimeError(vm, "Undefined property '%s'.", name->chars);
		return false;
	}

	bluObjBoundMethod* bound = bluNewBoundMethod(vm, bluPop(vm), AS_CLOSURE(method));
	bluPush(vm, OBJ_VAL(bound));

	return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
addq $0x30, %rsi
movq %rsp, %rcx
callq 0x256c
movl %eax, %ebp
testb %al, %al
je 0x4919
movq 0x100000(%rbx), %rax
leaq -0x10(%rax), %rcx
movq %rcx, 0x100000(%rbx)
movl -0x10(%rax), %esi
movq -0x8(%rax), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x8579
movq 0x100000(%rbx), %rcx
leaq 0x10(%rcx), %rdx
movq %rdx, 0x100000(%rbx)
movl $0x3, (%rcx)
movq %rax, 0x8(%rcx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
addq $0x28, %r14
leaq 0x5b00(%rip), %rsi      # 0xa424
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2230
jmp 0x490e
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/vm.c
// Function: invokeFromClass
static bool invokeFromClass(bluVM* vm, bluObjClass* class, bluObjString* name, int8_t argCount) {
	// Look for the method.
	bluValue method;
	if (!bluTableGet(vm, &class->methods, name, &method)) {
		if (class->superclass != NULL && invokeFromClass(vm, class->superclass, name, argCount)) {
			return true;
		} else {
			runtimeError(vm, "Undefined property '%s'.", name->chars);
			return false;
		}
	}

	if (IS_NATIVE(method)) {
		return callValue(vm, method, argCount);
	}

	return call(vm, AS_CLOSURE(method), argCount);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x30, %rsi
movq %rsp, %rcx
callq 0x256c
testb %al, %al
je 0x4982
movl (%rsp), %esi
movq 0x8(%rsp), %rdx
movq %rdx, 0x10(%rsp)
cmpl $0x3, %esi
jne 0x49bd
movq 0x10(%rsp), %rax
cmpl $0x6, (%rax)
jne 0x49bd
movsbl %bpl, %ecx
movq %rbx, %rdi
callq 0x446a
jmp 0x49ce
movq 0x28(%r15), %rsi
testq %rsi, %rsi
je 0x49a1
movsbl %bpl, %ecx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4933
movb $0x1, %bpl
testb %al, %al
jne 0x49d0
addq $0x28, %r14
leaq 0x5a78(%rip), %rsi      # 0xa424
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2230
jmp 0x49d0
movq 0x8(%rsp), %rsi
movsbl %bpl, %edx
movq %rbx, %rdi
callq 0x4828
movl %eax, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/util/utils.c
// Function: bluPowerOf2Ceil
int64_t bluPowerOf2Ceil(int64_t n) {
	n--;
	n |= n >> 1;
	n |= n >> 2;
	n |= n >> 4;
	n |= n >> 8;
	n |= n >> 16;
	n++;

	return n;
}

// Assembly:
leaq -0x1(%rdi), %rax
movq %rax, %rcx
sarq %rcx
orq %rax, %rcx
movq %rcx, %rax
sarq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
sarq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rdx
sarq $0x8, %rdx
orq %rcx, %rdx
movq %rdx, %rax
sarq $0x10, %rax
orq %rdx, %rax
incq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/compiler/chunk.c
// Function: bluChunkInit
void bluChunkInit(bluChunk* chunk) {
	chunk->file = NULL;
	chunk->name = NULL;

	ByteBufferInit(&chunk->code);
	IntBufferInit(&chunk->lines);
	IntBufferInit(&chunk->columns);

	bluValueBufferInit(&chunk->constants);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
callq 0x94c4
leaq 0x20(%rbx), %rdi
callq 0x9556
leaq 0x30(%rbx), %rdi
callq 0x9556
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/compiler/chunk.c
// Function: bluChunkFree
void bluChunkFree(bluChunk* chunk) {
	ByteBufferFree(&chunk->code);
	IntBufferFree(&chunk->lines);
	IntBufferFree(&chunk->columns);

	bluValueBufferFree(&chunk->constants);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rdi
callq 0x94cb
leaq 0x20(%rbx), %rdi
callq 0x955d
leaq 0x30(%rbx), %rdi
callq 0x955d
movq 0x40(%rbx), %rdi
addq $0x40, %rbx
testq %rdi, %rdi
je 0x4b1b
callq 0x2030
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: at
static void at(bluCompiler* compiler, bool canAssign) {
	if (compiler->classCompiler == NULL) {
		error(compiler, "Cannot use '@' outside of a class.");
		return;
	}

	variable(compiler, false);
	if (check(compiler, TOKEN_IDENTIFIER)) {
		dot(compiler, canAssign);
	}
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
addq $0x20, %rsi
cmpq $0x0, 0x18(%rdi)
je 0x4d0f
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5b35
movq 0x8(%rbx), %rax
cmpl $0x19, 0x40(%rax)
jne 0x4d24
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %rbp
jmp 0x4fc8
leaq 0x5742(%rip), %rdx      # 0xa458
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %rbp
jmp 0x5b1c
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: binary
static void binary(bluCompiler* compiler, bool canAssign) {
	bluTokenType operatorType = compiler->parser->previous.type;

	ParseRule* rule = getRule(operatorType);
	parsePrecedence(compiler, (Precedence)(rule->precedence + 1));

	switch (operatorType) {
	case TOKEN_EQUAL_EQUAL: emitByte(compiler, OP_EQUAL); break;
	case TOKEN_BANG_EQUAL: emitByte(compiler, OP_NOT_EQUAL); break;
	case TOKEN_GREATER: emitByte(compiler, OP_GREATER); break;
	case TOKEN_GREATER_EQUAL: emitByte(compiler, OP_GREATER_EQUAL); break;
	case TOKEN_LESS: emitByte(compiler, OP_LESS); break;
	case TOKEN_LESS_EQUAL: emitByte(compiler, OP_LESS_EQUAL); break;
	case TOKEN_MINUS: emitByte(compiler, OP_SUBTRACT); break;
	case TOKEN_PERCENT: emitByte(compiler, OP_REMINDER); break;
	case TOKEN_PLUS: emitByte(compiler, OP_ADD); break;
	case TOKEN_SLASH: emitByte(compiler, OP_DIVIDE); break;
	case TOKEN_STAR: emitByte(compiler, OP_MULTIPLY); break;
	case TOKEN_CARET: emitByte(compiler, OP_POWER); break;
	default: return;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl 0x20(%rax), %r14d
leaq (%r14,%r14,2), %rax
leaq 0xb1a9(%rip), %rcx      # 0x10120
movl 0x10(%rcx,%rax,8), %esi
incl %esi
callq 0x6144
leal -0x1(%r14), %eax
cmpl $0x17, %eax
ja 0x4fc0
movl $0xffa801, %ecx         # imm = 0xFFA801
btl %eax, %ecx
jae 0x4fc0
movl %eax, %eax
leaq 0x5a53(%rip), %rcx      # 0xa9f1
movzbl (%rax,%rcx), %esi
movq 0x8(%rbx), %rax
movq 0x28(%rbx), %rdi
addq $0x28, %rdi
movl 0x54(%rax), %edx
movl 0x58(%rax), %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4b23
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: dot
static void dot(bluCompiler* compiler, bool canAssign) {
	consume(compiler, TOKEN_IDENTIFIER, "Expect property name after '.'.");
	uint16_t name = identifierConstant(compiler, &compiler->parser->previous);

	if (canAssign && match(compiler, TOKEN_EQUAL)) {
		expression(compiler);
		emitByte(compiler, OP_SET_PROPERTY);
		emitShort(compiler, name);
	} else if (match(compiler, TOKEN_LEFT_PAREN)) {
		uint8_t argCount = argumentList(compiler);
		emitBytes(compiler, OP_INVOKE, argCount);
		emitShort(compiler, name);
	} else {
		emitByte(compiler, OP_GET_PROPERTY);
		emitShort(compiler, name);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x5773(%rip), %rdx      # 0xa74c
movl $0x19, %esi
callq 0x5d2c
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
movq 0x28(%rax), %rsi
movzbl 0x30(%rax), %edx
callq 0x8411
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x5cf9
movl %eax, %ebp
testl %r14d, %r14d
je 0x5041
movq 0x8(%rbx), %rax
cmpl $0xf, 0x40(%rax)
jne 0x5041
movq %rbx, %rdi
callq 0x553e
movq %rbx, %rdi
callq 0x5e4c
movq 0x8(%rbx), %rax
movq 0x28(%rbx), %rdi
addq $0x28, %rdi
movl 0x54(%rax), %edx
movl 0x58(%rax), %ecx
movl $0xe, %esi
jmp 0x5084
movq 0x8(%rbx), %rax
cmpl $0x7, 0x40(%rax)
jne 0x506d
movq %rbx, %rdi
callq 0x553e
movq %rbx, %rdi
callq 0x5c05
movzbl %al, %edx
movq %rbx, %rdi
movl $0x13, %esi
callq 0x5c75
jmp 0x5089
movq 0x8(%rbx), %rax
movq 0x28(%rbx), %rdi
addq $0x28, %rdi
movl 0x54(%rax), %edx
movl 0x58(%rax), %ecx
movl $0xd, %esi
callq 0x4b23
movzwl %bp, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5cb5
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: array
static void array(bluCompiler* compiler, bool canAssign) {
	uint16_t len = 0;

	consumeNewlines(compiler);

	while (!check(compiler, TOKEN_RIGHT_BRACKET) && !check(compiler, TOKEN_EOF)) {
		if (len > 0) {
			consume(compiler, TOKEN_COMMA, "Expect ',' between expressions.");
			consumeNewlines(compiler);
		}

		expression(compiler);
		consumeNewlines(compiler);

		len++;
	}

	consume(compiler, TOKEN_RIGHT_BRACKET, "Expect ']' after array.");

	emitByte(compiler, OP_ARRAY);
	emitShort(compiler, len);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x64a9
xorl %ebp, %ebp
leaq 0x56bf(%rip), %r14      # 0xa76c
movq 0x8(%rbx), %rax
movl 0x40(%rax), %eax
cmpl $0x9, %eax
je 0x50ef
cmpl $0x2f, %eax
je 0x50ef
testw %bp, %bp
je 0x50db
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rdx
callq 0x5d2c
movq %rbx, %rdi
callq 0x64a9
movq %rbx, %rdi
callq 0x5e4c
movq %rbx, %rdi
callq 0x64a9
incl %ebp
jmp 0x50ad
leaq 0x5696(%rip), %rdx      # 0xa78c
movq %rbx, %rdi
movl $0x9, %esi
callq 0x5d2c
movq 0x8(%rbx), %rax
movq 0x28(%rbx), %rdi
addq $0x28, %rdi
movl 0x54(%rax), %edx
movl 0x58(%rax), %ecx
movl $0x4, %esi
callq 0x4b23
movzwl %bp, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5cb5
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: subscript
static void subscript(bluCompiler* compiler, bool canAssign) {
	expression(compiler);
	consume(compiler, TOKEN_RIGHT_BRACKET, "Expect ']' after subscript operator.");

	if (canAssign && match(compiler, TOKEN_EQUAL)) {
		expression(compiler);
		emitByte(compiler, OP_SUBSCRIPT_SET);
	} else {
		emitByte(compiler, OP_SUBSCRIPT_GET);
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x5e4c
leaq 0x5662(%rip), %rdx      # 0xa7a4
movq %rbx, %rdi
movl $0x9, %esi
callq 0x5d2c
testl %ebp, %ebp
je 0x5186
movq 0x8(%rbx), %rax
cmpl $0xf, 0x40(%rax)
jne 0x5186
movq %rbx, %rdi
callq 0x553e
movq %rbx, %rdi
callq 0x5e4c
movq 0x8(%rbx), %rax
movq 0x28(%rbx), %rdi
addq $0x28, %rdi
movl 0x54(%rax), %edx
movl 0x58(%rax), %ecx
movl $0x11, %esi
jmp 0x519d
movq 0x8(%rbx), %rax
movq 0x28(%rbx), %rdi
addq $0x28, %rdi
movl 0x54(%rax), %edx
movl 0x58(%rax), %ecx
movl $0x10, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4b23
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: unary
static void unary(bluCompiler* compiler, bool canAssing) {
	bluTokenType operatorType = compiler->parser->previous.type;

	parsePrecedence(compiler, PREC_UNARY);

	switch (operatorType) {
	case TOKEN_BANG: emitByte(compiler, OP_NOT); break;
	case TOKEN_MINUS: emitByte(compiler, OP_NEGATE); break;
	default: __builtin_unreachable();
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl 0x20(%rax), %ebp
movl $0x9, %esi
callq 0x6144
movq 0x8(%rbx), %rax
movq 0x28(%rbx), %rdi
addq $0x28, %rdi
xorl %esi, %esi
cmpl $0xd, %ebp
movl 0x54(%rax), %edx
movl 0x58(%rax), %ecx
setne %sil
addl $0x25, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4b23
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: and
static void and (bluCompiler * compiler, bool canAssign) {
	int32_t endJump = emitJump(compiler, OP_JUMP_IF_FALSE);
	emitByte(compiler, OP_POP);

	parsePrecedence(compiler, PREC_AND);

	patchJump(compiler, endJump);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x16, %esi
callq 0x652f
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x28(%rbx), %rdi
addq $0x28, %rdi
movl 0x54(%rax), %edx
movl 0x58(%rax), %ecx
movl $0x5, %esi
callq 0x4b23
movq %rbx, %rdi
movl $0x3, %esi
callq 0x6144
movq 0x28(%rbx), %rcx
movl 0x40(%rcx), %eax
subl %ebp, %eax
addl $-0x2, %eax
movq 0x38(%rcx), %rdx
movslq %ebp, %rsi
movb %ah, (%rdx,%rsi)
movq 0x38(%rcx), %rcx
movb %al, 0x1(%rcx,%rsi)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: literal
static void literal(bluCompiler* compiler, bool canAssign) {
	switch (compiler->parser->previous.type) {
	case TOKEN_FALSE: emitByte(compiler, OP_FALSE); break;
	case TOKEN_NIL: emitByte(compiler, OP_NIL); break;
	case TOKEN_TRUE: emitByte(compiler, OP_TRUE); break;
	default: __builtin_unreachable();
	}
}

// Assembly:
movq 0x8(%rdi), %rcx
movq 0x28(%rdi), %rdi
movl 0x20(%rcx), %eax
movl 0x54(%rcx), %edx
movl 0x58(%rcx), %ecx
cmpl $0x22, %eax
je 0x5317
cmpl $0x2c, %eax
jne 0x531b
movb $0x3, %al
jmp 0x531d
movb $0x1, %al
jmp 0x531d
movb $0x2, %al
addq $0x28, %rdi
movzbl %al, %esi
jmp 0x4b23
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: bluCompile
bluObjFunction* bluCompile(bluVM* vm, const char* source, const char* file) {
	bluParser parser;
	bluParserInit(&parser, source);

	bluCompiler compiler;
	compiler.vm = vm;
	compiler.parser = &parser;
	compiler.classCompiler = NULL;
	compiler.file = file;
	initCompiler(&compiler, NULL, 0, TYPE_TOP_LEVEL);

	do {
		advance(&compiler);
	} while (check(&compiler, TOKEN_NEWLINE));

	while (!match(&compiler, TOKEN_EOF)) {
		declaration(&compiler);
	}

	bluObjFunction* function = endCompiler(&compiler);
	function->chunk.file = file;
	function->chunk.name = "__main";

#ifdef DEBUG_COMPILER_DISASSEMBLE
	bluDisassembleChunk(&function->chunk);
#endif

	freeCompiler(&compiler);

	return compiler.hadError ? NULL : function;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x60(%rsp), %r12
movq %r12, %rdi
callq 0x8a10
movq %rsp, %r14
movq %r15, (%r14)
movq %r12, 0x8(%r14)
movq $0x0, 0x18(%r14)
movq %rbx, 0x20(%r14)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x544f
movq %r14, %rdi
callq 0x553e
movq 0x8(%rsp), %rax
cmpl $0x8, 0x20(%rax)
je 0x53ce
cmpl $0x30, 0x40(%rax)
je 0x53ce
movq 0x8(%rsp), %rax
cmpl $0x2f, 0x40(%rax)
je 0x5408
movq %rsp, %r14
movq %r14, %rdi
callq 0x55fb
movq 0x8(%rsp), %rax
cmpl $0x2f, 0x40(%rax)
jne 0x53f5
movq %rsp, %r14
movq %r14, %rdi
callq 0x553e
movq %r14, %rdi
callq 0x5ab2
movq %rax, %r15
movq %rbx, 0x28(%rax)
leaq 0x5028(%rip), %rax      # 0xa451
movq %rax, 0x30(%r15)
movq %r14, %rdi
callq 0x5adc
xorl %eax, %eax
cmpb $0x0, 0x59(%r14)
cmoveq %r15, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: initCompiler
static void initCompiler(bluCompiler* compiler, bluCompiler* enclosing, int8_t scopeDepth, bluFunctionType type) {
	if (enclosing != NULL) {
		compiler->vm = enclosing->vm;
		compiler->parser = enclosing->parser;

		compiler->classCompiler = enclosing->classCompiler;

		compiler->file = enclosing->file;
	}

	compiler->enclosing = enclosing;
	compiler->scopeDepth = scopeDepth;
	compiler->type = type;
	compiler->function = bluNewFunction(compiler->vm);

	compiler->hadError = false;
	compiler->panicMode = false;

	bluLocalBufferInit(&compiler->locals);
	bluUpvalueBufferInit(&compiler->upvalues);

	switch (type) {

	case TYPE_FUNCTION:
	case TYPE_METHOD:
	case TYPE_INITIALIZER: {
		bluToken previous = compiler->parser->previous;
		compiler->function->name = bluCopyString(compiler->vm, previous.start, previous.length);
		break;
	}

	case TYPE_ANONYMOUS:
	case TYPE_TOP_LEVEL: {
		compiler->function->name = NULL;
		break;
	}
	}

	bluLocal local;
	local.depth = compiler->scopeDepth;
	local.isUpvalue = false;

	if (type == TYPE_METHOD || type == TYPE_INITIALIZER) {
		// In a method, it holds the receiver, "@".
		local.name.start = "@";
		local.name.length = 1;
	} else {
		// In a function, it holds the function, but cannot be references, so has no name.
		local.name.start = "";
		local.name.length = 0;
	}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %ecx, %ebx
movq %rdi, %r14
testq %rsi, %rsi
je 0x5480
movq (%rsi), %rax
movq %rax, (%r14)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%r14)
movq 0x18(%rsi), %rax
movq %rax, 0x18(%r14)
movq 0x20(%rsi), %rax
movq %rax, 0x20(%r14)
movq %rsi, 0x10(%r14)
movb %dl, 0x58(%r14)
movl %ebx, 0x30(%r14)
movq (%r14), %rdi
callq 0x86a7
movq %rax, 0x28(%r14)
movw $0x0, 0x59(%r14)
leaq 0x38(%r14), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
xorl %ecx, %ecx
movl $0x1a, %edx
btl %ebx, %edx
jae 0x54d7
movq (%r14), %rdi
movq 0x8(%r14), %rax
movq 0x28(%rax), %rsi
movzbl 0x30(%rax), %edx
callq 0x8411
movq %rax, %rcx
movq 0x28(%r14), %rax
movq %rcx, 0x78(%rax)
movb 0x58(%r14), %al
addl $-0x3, %ebx
cmpl $0x2, %ebx
leaq 0x5018(%rip), %rcx      # 0xa504
leaq 0x6834(%rip), %rdx      # 0xbd27
cmovbq %rcx, %rdx
movq %rdx, 0x30(%rsp)
setb 0x38(%rsp)
movb %al, 0x48(%rsp)
movb $0x0, 0x49(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
movl $0x1, %esi
callq 0x4b74
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: advance
static void advance(bluCompiler* compiler) {
	compiler->parser->previous = compiler->parser->current;

	while (true) {
		compiler->parser->current = bluParserNextToken(compiler->parser);
		if (compiler->parser->current.type != TOKEN_ERROR) break;

		errorAtCurrent(compiler, compiler->parser->current.start);
	}

	skipNewlines(compiler);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movups 0x40(%rax), %xmm0
movups 0x50(%rax), %xmm1
movups %xmm1, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movq 0x8(%rdi), %r14
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x8a36
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x50(%r14)
movups %xmm0, 0x40(%r14)
movq 0x8(%rbx), %rax
cmpl $0x31, 0x40(%rax)
jne 0x55d0
leaq 0x40(%rax), %rsi
movq %rsp, %r14
movq 0x48(%rax), %rdx
movq %rbx, %rdi
callq 0x5b1c
movq 0x8(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x8a36
movups (%rsp), %xmm0
movups 0x10(%rsp), %xmm1
movups %xmm1, 0x50(%r15)
movups %xmm0, 0x40(%r15)
movq 0x8(%rbx), %rax
leaq 0x40(%rax), %rsi
cmpl $0x31, 0x40(%rax)
je 0x5594
movl 0x20(%rax), %eax
cmpq $0x30, %rax
ja 0x55f1
movabsq $0x1000000000930, %rcx  # imm = 0x1000000000930
btq %rax, %rcx
jae 0x55f1
movq %rbx, %rdi
callq 0x64a9
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: endCompiler
static bluObjFunction* endCompiler(bluCompiler* compiler) {
	if (compiler->function->chunk.code.count == 0) {
		// We need to emit return when chunk is empty.
		emitReturn(compiler);
	} else if (compiler->function->chunk.code.data[compiler->function->chunk.code.count - 1] != OP_RETURN) {
		// We need to emit return when last opcode of a chunk isn't a return.
		emitReturn(compiler);
	}

	return compiler->function;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movslq 0x40(%rax), %rcx
testq %rcx, %rcx
je 0x5ace
movq 0x38(%rax), %rax
cmpb $0x30, -0x1(%rax,%rcx)
je 0x5ad6
movq %rbx, %rdi
callq 0x6ce3
movq 0x28(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: namedVariable
static void namedVariable(bluCompiler* compiler, bluToken name, bool canAssign) {
	uint8_t getOp, setOp;

	int32_t arg = resolveLocal(compiler, &name);

	if (arg != -1) {
		getOp = OP_GET_LOCAL;
		setOp = OP_SET_LOCAL;
	} else if ((arg = resolveUpvalue(compiler, &name)) != -1) {
		getOp = OP_GET_UPVALUE;
		setOp = OP_SET_UPVALUE;
	} else {
		arg = identifierConstant(compiler, &name);
		getOp = OP_GET_GLOBAL;
		setOp = OP_SET_GLOBAL;
	}

	if (canAssign && match(compiler, TOKEN_EQUAL)) {
		expression(compiler);
		emitByte(compiler, setOp);
		emitShort(compiler, (uint16_t)arg);
	} else {
		emitByte(compiler, getOp);
		emitShort(compiler, (uint16_t)arg);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, %rsi
callq 0x5d5a
cmpl $-0x1, %eax
je 0x5b5d
movl %eax, %ebp
movb $0x7, %r15b
movb $0x6, %al
jmp 0x5b9f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5deb
cmpl $-0x1, %eax
je 0x5b76
movl %eax, %ebp
movb $0xc, %r15b
movb $0xb, %al
jmp 0x5b9f
movq (%rbx), %rdi
movq 0x8(%r15), %rsi
movzbl 0x10(%r15), %edx
callq 0x8411
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x5cf9
movzwl %ax, %ebp
movb $0xa, %r15b
movb $0x9, %al
testb %r14b, %r14b
je 0x5bd6
movq 0x8(%rbx), %rcx
cmpl $0xf, 0x40(%rcx)
jne 0x5bd6
movq %rbx, %rdi
callq 0x553e
movq %rbx, %rdi
callq 0x5e4c
movq 0x8(%rbx), %rax
movq 0x28(%rbx), %rdi
addq $0x28, %rdi
movl 0x54(%rax), %edx
movl 0x58(%rax), %ecx
movzbl %r15b, %esi
jmp 0x5beb
movq 0x8(%rbx), %rcx
movq 0x28(%rbx), %rdi
addq $0x28, %rdi
movl 0x54(%rcx), %edx
movl 0x58(%rcx), %ecx
movzbl %al, %esi
callq 0x4b23
movzwl %bp, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5cb5
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: argumentList
static uint8_t argumentList(bluCompiler* compiler) {
	uint8_t argCount = 0;

	if (!check(compiler, TOKEN_RIGHT_PAREN)) {
		do {
			expression(compiler);
			argCount++;

			if (argCount > 16) {
				error(compiler, "Cannot have more than 16 arguments.");
			}
		} while (match(compiler, TOKEN_COMMA));
	}

	consume(compiler, TOKEN_RIGHT_PAREN, "Expect ')' after arguments.");

	return argCount;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpl $0xa, 0x40(%rax)
jne 0x5c33
xorl %ebp, %ebp
leaq 0x4aee(%rip), %rdx      # 0xa70d
movq %rbx, %rdi
movl $0xa, %esi
callq 0x5d2c
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %bpl
leaq 0x4aac(%rip), %r14      # 0xa6e9
movq %rbx, %rdi
callq 0x5e4c
cmpb $0x11, %bpl
jb 0x5c5e
movq 0x8(%rbx), %rsi
addq $0x20, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5b1c
movq 0x8(%rbx), %rax
cmpl $0x3, 0x40(%rax)
jne 0x5c18
movq %rbx, %rdi
callq 0x553e
incb %bpl
jmp 0x5c3d
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: makeConstant
static uint16_t makeConstant(bluCompiler* compiler, bluValue value) {
	int32_t constant = bluValueBufferWrite(&compiler->function->chunk.constants, value);
	if (constant > LOCALS_MAX) {
		error(compiler, "Too many constants in one chunk.");
		return 0;
	}

	return (uint16_t)constant;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
addq $0x68, %rdi
callq 0x4aa7
cmpl $0xffff, %eax           # imm = 0xFFFF
jl 0x5d2a
movq 0x8(%rbx), %rsi
addq $0x20, %rsi
leaq 0x4a0b(%rip), %rdx      # 0xa72b
movq %rbx, %rdi
callq 0x5b1c
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: consume
static void consume(bluCompiler* compiler, bluTokenType type, const char* message) {
	if (check(compiler, type)) {
		advance(compiler);
		return;
	}

	errorAtCurrent(compiler, message);
}

// Assembly:
cmpl $0x30, %esi
jne 0x5d3f
movq 0x8(%rdi), %rax
cmpl $0x8, 0x20(%rax)
je 0x553e
movq 0x8(%rdi), %rax
cmpl %esi, 0x40(%rax)
jne 0x5d4d
jmp 0x553e
movq 0x8(%rdi), %rsi
addq $0x40, %rsi
jmp 0x5b1c
// File: /workspace/github_c_makefile_star2_O1/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: resolveLocal
static int32_t resolveLocal(bluCompiler* compiler, bluToken* name) {
	for (int32_t i = compiler->locals.count - 1; i >= 0; i--) {
		bluLocal* local = &compiler->locals.data[i];
		if (identifiersEqual(name, &local->name)) {
			if (local->depth == -1) {
				error(compiler, "Cannot read local variable in its own initializer.");
			}

			return i;
		}
	}

	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x40(%rdi), %r12d
testl %r12d, %r12d
jle 0x5dd5
decq %r12
movq 0x38(%r14), %rax
movl %r12d, %ecx
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,8), %r15
movzbl 0x10(%rbx), %edx
cmpb 0x10(%r15), %dl
jne 0x5da5
movq 0x8(%rbx), %rdi
movq 0x8(%r15), %rsi
callq 0x2190
testl %eax, %eax
sete %r13b
jmp 0x5da8
xorl %r13d, %r13d
testb %r13b, %r13b
je 0x5dce
cmpb $-0x1, 0x20(%r15)
jne 0x5dcb
movq 0x8(%r14), %rsi
addq $0x20, %rsi
movq %r14, %rdi
leaq 0x475f(%rip), %rdx      # 0xa525
callq 0x5b1c
movl %r12d, %ebp
testb %r13b, %r13b
je 0x5d6f
jmp 0x5dda
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq