LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x3727(%rip), %edi      # 0x5128
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x10c0
cmpl $0x0, 0x3725(%rip)      # 0x5138
jle 0x1a25
movl 0x371d(%rip), %edi      # 0x5138
movl $0x9, %esi
callq 0x1160
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x3707(%rip), %eax      # 0x513c
jae 0x1a5f
movq 0x3702(%rip), %rax      # 0x5140
movl -0x8(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %edi
movl $0x9, %esi
callq 0x1160
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1a2c
movq 0x36ba(%rip), %rdi      # 0x5120
callq 0x1110
movq 0x356e(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0x1782(%rip), %rsi      # 0x3201
movb $0x0, %al
callq 0x1170
movl $0x1, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-trace.c
// Function: register_return
static void register_return(_u32 pid,_u32 val) {
  _s32 rno = get_procentry(pid,1);
  
  if (procs[rno].func_name)
    fatal("out of sequence MESSAGE_LEAVE for PID %u",pid);

  procs[rno].nest--;
  
  do_indent(pid,procs[rno].nest,0);
    
  outf("`- = %s\n",process_val(val));
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl $0x1, %esi
callq 0x2780
movl %eax, -0xc(%rbp)
movq 0x2deb(%rip), %rax      # 0x5140
movslq -0xc(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x23ba
jmp 0x2369
movq 0x2c70(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0x1235(%rip), %rsi      # 0x35b2
movb $0x0, %al
callq 0x1170
movq 0x2c55(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0xd0e(%rip), %rsi       # 0x30a3
leaq 0x1256(%rip), %rdx      # 0x35f2
leaq 0xd15(%rip), %rcx       # 0x30b8
movl $0xb9, %r8d
movb $0x0, %al
callq 0x1170
movl $0x1, %edi
callq 0x1140
movq 0x2d7f(%rip), %rax      # 0x5140
movslq -0xc(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movl -0x4(%rbp), %edi
movq 0x2d61(%rip), %rax      # 0x5140
movslq -0xc(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %esi
xorl %edx, %edx
callq 0x28d0
movq 0x2d25(%rip), %rax      # 0x5120
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %edi
callq 0x2960
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0x11ed(%rip), %rsi      # 0x3602
movb $0x0, %al
callq 0x1170
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-trace.c
// Function: register_spot
static void register_spot(_u32 pid,_u32 val) {
  _u32 rno;
  
  for (rno=0;rno<proc_cnt;rno++) 
    if (procs[rno].pid == pid) break;
  
  if (rno == proc_cnt) fatal("MESSAGE_SPOT for non-existent PID %u",pid);
  
  if (procs[rno].func_name || !procs[rno].nest)
    fatal("out of sequence MESSAGE_SPOT for PID %u",pid);

  do_indent(pid,procs[rno].nest,-1);
    
  outf("+--- %s\n",process_val(val));
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x2cee(%rip), %eax      # 0x513c
jae 0x2477
movq 0x2ce9(%rip), %rax      # 0x5140
movl -0xc(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x246a
jmp 0x2477
jmp 0x246c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2445
movl -0xc(%rbp), %eax
cmpl 0x2cbc(%rip), %eax      # 0x513c
jne 0x24d5
jmp 0x2484
movq 0x2b55(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0x1173(%rip), %rsi      # 0x360b
movb $0x0, %al
callq 0x1170
movq 0x2b3a(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0xbf3(%rip), %rsi       # 0x30a3
leaq 0x1190(%rip), %rdx      # 0x3647
leaq 0xbfa(%rip), %rcx       # 0x30b8
movl $0xcb, %r8d
movb $0x0, %al
callq 0x1170
movl $0x1, %edi
callq 0x1140
movq 0x2c64(%rip), %rax      # 0x5140
movl -0xc(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
jne 0x2504
movq 0x2c4c(%rip), %rax      # 0x5140
movl -0xc(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
jne 0x2557
jmp 0x2506
movq 0x2ad3(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0x113b(%rip), %rsi      # 0x3655
movb $0x0, %al
callq 0x1170
movq 0x2ab8(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0xb71(%rip), %rsi       # 0x30a3
leaq 0x110e(%rip), %rdx      # 0x3647
leaq 0xb78(%rip), %rcx       # 0x30b8
movl $0xce, %r8d
movb $0x0, %al
callq 0x1170
movl $0x1, %edi
callq 0x1140
movl -0x4(%rbp), %edi
movq 0x2bdf(%rip), %rax      # 0x5140
movl -0xc(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x28d0
movq 0x2ba1(%rip), %rax      # 0x5120
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %edi
callq 0x2960
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0x10fb(%rip), %rsi      # 0x3694
movb $0x0, %al
callq 0x1170
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movb %dl, %al
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movb %al, -0x9(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x2906
movq 0x2830(%rip), %rdi      # 0x5120
movl -0x4(%rbp), %edx
movl -0x8(%rbp), %ecx
leaq 0xbf0(%rip), %rsi       # 0x34ed
movb $0x0, %al
callq 0x1170
jmp 0x295a
movq 0x2813(%rip), %rdi      # 0x5120
movl -0x4(%rbp), %edx
movl -0x8(%rbp), %ecx
leaq 0xbe3(%rip), %rsi       # 0x34fd
movb $0x0, %al
callq 0x1170
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0x8(%rbp), %ecx
movsbl -0x9(%rbp), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jge 0x2958
movq 0x27e1(%rip), %rdi      # 0x5120
leaq 0xbc4(%rip), %rsi       # 0x350a
movb $0x0, %al
callq 0x1170
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2928
jmp 0x295a
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-trace.c
// Function: process_val
static _u8* process_val(_s32 val) {
  static _u8 buf[32];
  /* Some heuristics */
  if (val > -1000000 && val < 1000000)
    sprintf(buf,"%d",val);
  else sprintf(buf,"0x%08x",val);
  return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0xfff0bdc0, -0x4(%rbp) # imm = 0xFFF0BDC0
jle 0x2997
cmpl $0xf4240, -0x4(%rbp)    # imm = 0xF4240
jge 0x2997
movl -0x4(%rbp), %edx
leaq 0x27c9(%rip), %rdi      # 0x5150
leaq 0xc1a(%rip), %rsi       # 0x35a8
movb $0x0, %al
callq 0x1030
jmp 0x29af
movl -0x4(%rbp), %edx
leaq 0x27af(%rip), %rdi      # 0x5150
leaq 0xc03(%rip), %rsi       # 0x35ab
movb $0x0, %al
callq 0x1030
leaq 0x279a(%rip), %rax      # 0x5150
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/cmd/blu.c
// Function: main
int main(int argc, const char* argv[]) {
	if (argc == 1) {
		repl();
	} else if (argc == 2) {
		if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-h") == 0) {
			help();
		} else if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-v") == 0) {
			version();
		} else {
			runFile(argv[1]);
		}
	} else {
		help();
		exit(64);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x1316
callq 0x1440
jmp 0x13b4
cmpl $0x2, -0x8(%rbp)
jne 0x13a3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xccd5(%rip), %rsi      # 0xe004
callq 0x1120
cmpl $0x0, %eax
je 0x1352
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xccc3(%rip), %rsi      # 0xe00b
callq 0x1120
cmpl $0x0, %eax
jne 0x1359
callq 0x14d0
jmp 0x13a1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xcca6(%rip), %rsi      # 0xe00e
callq 0x1120
cmpl $0x0, %eax
je 0x138b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xcc97(%rip), %rsi      # 0xe018
callq 0x1120
cmpl $0x0, %eax
jne 0x1392
callq 0x1500
jmp 0x139f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x13c0
jmp 0x13a1
jmp 0x13b2
callq 0x14d0
movl $0x40, %edi
callq 0x11d0
jmp 0x13b4
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/cmd/blu.c
// Function: runFile
static void runFile(const char* path) {
	bluVM* vm = bluNewVM();
	char* source = readFile(path);

	bluInterpretResult result = bluInterpret(vm, source, path);

	free(source);
	bluFreeVM(vm);

	if (result == INTERPRET_COMPILE_ERROR) exit(65);
	if (result == INTERPRET_RUNTIME_ERROR) exit(70);
	if (result == INTERPRET_ASSERTION_ERROR) exit(75);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, %al
callq 0x96f0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1520
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x98e0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
callq 0x9820
cmpl $0x1, -0x1c(%rbp)
jne 0x141a
movl $0x41, %edi
callq 0x11d0
cmpl $0x2, -0x1c(%rbp)
jne 0x142a
movl $0x46, %edi
callq 0x11d0
cmpl $0x3, -0x1c(%rbp)
jne 0x143a
movl $0x4b, %edi
callq 0x11d0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/cmd/blu.c
// Function: repl
static void repl() {
	char line[1024];

	bluVM* vm = bluNewVM();

	while (true) {
		printf("> ");

		if (!fgets(line, sizeof(line), stdin)) {
			printf("\n");
			break;
		}

		bluInterpret(vm, line, "REPL");
	}

	bluFreeVM(vm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movb $0x0, %al
callq 0x96f0
movq %rax, -0x408(%rbp)
leaq 0xcbbb(%rip), %rdi      # 0xe01b
movb $0x0, %al
callq 0x10d0
leaq -0x400(%rbp), %rdi
movq 0x12b63(%rip), %rax     # 0x13fd8
movq (%rax), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x1110
cmpq $0x0, %rax
jne 0x1498
leaq 0xcb9a(%rip), %rdi      # 0xe029
movb $0x0, %al
callq 0x10d0
jmp 0x14b4
movq -0x408(%rbp), %rdi
leaq -0x400(%rbp), %rsi
leaq 0xcb71(%rip), %rdx      # 0xe01e
callq 0x98e0
jmp 0x1459
movq -0x408(%rbp), %rdi
callq 0x9820
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/cmd/blu.c
// Function: readFile
static char* readFile(const char* path) {
	FILE* file = fopen(path, "rb");
	if (file == NULL) {
		fprintf(stderr, "Could not open file \"%s\".\n", path);
		exit(74);
	}

	fseek(file, 0L, SEEK_END);
	size_t fileSize = ftell(file);
	rewind(file);

	char* buffer = (char*)malloc(fileSize + 1);
	if (buffer == NULL) {
		fprintf(stderr, "Not enough memory to read \"%s\".\n", path);
		exit(74);
	}

	size_t bytesRead = fread(buffer, sizeof(char), fileSize, file);
	if (bytesRead < fileSize) {
		fprintf(stderr, "Could not read file \"%s\".\n", path);
		exit(74);
	}

	buffer[bytesRead] = '\0';

	fclose(file);
	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xcb1b(%rip), %rsi      # 0xe052
callq 0x11a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x156d
movq 0x12aaa(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xcaf9(%rip), %rsi      # 0xe055
movb $0x0, %al
callq 0x1130
movl $0x4a, %edi
callq 0x11d0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1180
movq -0x10(%rbp), %rdi
callq 0x1140
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10e0
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x1160
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x15d3
movq 0x12a44(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xcaae(%rip), %rsi      # 0xe070
movb $0x0, %al
callq 0x1130
movl $0x4a, %edi
callq 0x11d0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x1060
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x161d
movq 0x129fa(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xca85(%rip), %rsi      # 0xe091
movb $0x0, %al
callq 0x1130
movl $0x4a, %edi
callq 0x11d0
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
callq 0x10b0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
sarq %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
sarq $0x2, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
sarq $0x4, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
sarq $0x8, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
sarq $0x10, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x1640
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x17a0
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x17a0
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
callq 0x1970
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x1670
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x17d0
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x17d0
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
callq 0x19a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: 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
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1ee1
movq -0x8(%rbp), %rdi
leaq 0xc239(%rip), %rsi      # 0xe113
callq 0x2db0
jmp 0x1f11
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x25e0
movq -0x8(%rbp), %rdi
movl $0x19, %esi
callq 0x2bf0
testb $0x1, %al
jne 0x1f00
jmp 0x1f11
movq -0x8(%rbp), %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x22a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x20(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edi
callq 0x3dd0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %esi
incl %esi
callq 0x38b0
movl -0x10(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x17, %eax
ja 0x2294
movq -0x20(%rbp), %rax
leaq 0xbeed(%rip), %rcx      # 0xe0ac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movl $0x19, %esi
callq 0x32b0
jmp 0x2296
movq -0x8(%rbp), %rdi
movl $0x1a, %esi
callq 0x32b0
jmp 0x2296
movq -0x8(%rbp), %rdi
movl $0x1b, %esi
callq 0x32b0
jmp 0x2296
movq -0x8(%rbp), %rdi
movl $0x1c, %esi
callq 0x32b0
jmp 0x2296
movq -0x8(%rbp), %rdi
movl $0x1d, %esi
callq 0x32b0
jmp 0x2296
movq -0x8(%rbp), %rdi
movl $0x1e, %esi
callq 0x32b0
jmp 0x2296
movq -0x8(%rbp), %rdi
movl $0x22, %esi
callq 0x32b0
jmp 0x2296
movq -0x8(%rbp), %rdi
movl $0x21, %esi
callq 0x32b0
jmp 0x2296
movq -0x8(%rbp), %rdi
movl $0x1f, %esi
callq 0x32b0
jmp 0x2296
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x32b0
jmp 0x2296
movq -0x8(%rbp), %rdi
movl $0x23, %esi
callq 0x32b0
jmp 0x2296
movq -0x8(%rbp), %rdi
movl $0x24, %esi
callq 0x32b0
jmp 0x2296
jmp 0x2296
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movl $0x19, %esi
leaq 0xc14a(%rip), %rdx      # 0xe40e
callq 0x3200
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x20, %rsi
callq 0x3250
movw %ax, -0xc(%rbp)
testb $0x1, -0x9(%rbp)
je 0x2322
movq -0x8(%rbp), %rdi
movl $0xf, %esi
callq 0x2c40
testb $0x1, %al
jne 0x22fc
jmp 0x2322
movq -0x8(%rbp), %rdi
callq 0x3450
movq -0x8(%rbp), %rdi
movl $0xe, %esi
callq 0x32b0
movq -0x8(%rbp), %rdi
movzwl -0xc(%rbp), %esi
callq 0x3140
jmp 0x2380
movq -0x8(%rbp), %rdi
movl $0x7, %esi
callq 0x2c40
testb $0x1, %al
jne 0x2336
jmp 0x2363
movq -0x8(%rbp), %rdi
callq 0x3000
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rdi
movl $0x13, %esi
movzbl -0xd(%rbp), %edx
callq 0x3100
movq -0x8(%rbp), %rdi
movzwl -0xc(%rbp), %esi
callq 0x3140
jmp 0x237e
movq -0x8(%rbp), %rdi
movl $0xd, %esi
callq 0x32b0
movq -0x8(%rbp), %rdi
movzwl -0xc(%rbp), %esi
callq 0x3140
jmp 0x2380
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: 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
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movw $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3e20
movq -0x8(%rbp), %rdi
movl $0x9, %esi
callq 0x2bf0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xd(%rbp)
jne 0x23e0
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x2bf0
xorb $-0x1, %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x23e9
jmp 0x2430
movzwl -0xc(%rbp), %eax
cmpl $0x0, %eax
jle 0x2410
movq -0x8(%rbp), %rdi
movl $0x3, %esi
leaq 0xc02c(%rip), %rdx      # 0xe42e
callq 0x3200
movq -0x8(%rbp), %rdi
callq 0x3e20
movq -0x8(%rbp), %rdi
callq 0x3450
movq -0x8(%rbp), %rdi
callq 0x3e20
movw -0xc(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xc(%rbp)
jmp 0x23b3
movq -0x8(%rbp), %rdi
movl $0x9, %esi
leaq 0xc00e(%rip), %rdx      # 0xe44e
callq 0x3200
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x32b0
movq -0x8(%rbp), %rdi
movzwl -0xc(%rbp), %esi
callq 0x3140
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: 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
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3450
movq -0x8(%rbp), %rdi
movl $0x9, %esi
leaq 0xbfc9(%rip), %rdx      # 0xe466
callq 0x3200
testb $0x1, -0x9(%rbp)
je 0x24d5
movq -0x8(%rbp), %rdi
movl $0xf, %esi
callq 0x2c40
testb $0x1, %al
jne 0x24bc
jmp 0x24d5
movq -0x8(%rbp), %rdi
callq 0x3450
movq -0x8(%rbp), %rdi
movl $0x11, %esi
callq 0x32b0
jmp 0x24e3
movq -0x8(%rbp), %rdi
movl $0x10, %esi
callq 0x32b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x20(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x9, %esi
callq 0x38b0
movl -0x10(%rbp), %eax
subl $0xd, %eax
je 0x25ac
jmp 0x25aa
jmp 0x25bc
movq -0x8(%rbp), %rdi
movl $0x25, %esi
callq 0x32b0
jmp 0x25cc
movq -0x8(%rbp), %rdi
movl $0x26, %esi
callq 0x32b0
jmp 0x25cc
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: 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
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movl $0x16, %esi
callq 0x3ee0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x32b0
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x38b0
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x3f20
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x20(%rax), %eax
movl %eax, -0x10(%rbp)
subl $0x22, %eax
je 0x27b5
jmp 0x27a9
movl -0x10(%rbp), %eax
subl $0x28, %eax
je 0x27c5
jmp 0x27b3
jmp 0x27d5
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x32b0
jmp 0x27e5
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x32b0
jmp 0x27e5
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x32b0
jmp 0x27e5
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: or
static void or (bluCompiler * compiler, bool canAssign) {
	int32_t endJump = emitJump(compiler, OP_JUMP_IF_TRUE);
	emitByte(compiler, OP_POP);

	parsePrecedence(compiler, PREC_OR);

	patchJump(compiler, endJump);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movl $0x17, %esi
callq 0x3ee0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x32b0
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x38b0
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x3f20
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x7e30
movq -0x8(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0x80(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq $0x0, -0xc8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0xe0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x2970
leaq -0xe0(%rbp), %rdi
callq 0x2b30
leaq -0xe0(%rbp), %rdi
movl $0x30, %esi
callq 0x2bf0
testb $0x1, %al
jne 0x28b4
jmp 0x28d7
leaq -0xe0(%rbp), %rdi
movl $0x2f, %esi
callq 0x2c40
xorb $-0x1, %al
testb $0x1, %al
jne 0x28f0
jmp 0x28fe
leaq -0xe0(%rbp), %rdi
callq 0x2c80
jmp 0x28d7
leaq -0xe0(%rbp), %rdi
callq 0x2d10
movq %rax, -0xe8(%rbp)
movq -0x18(%rbp), %rcx
movq -0xe8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0xe8(%rbp), %rax
leaq 0xb7de(%rip), %rcx      # 0xe10c
movq %rcx, 0x30(%rax)
leaq -0xe0(%rbp), %rdi
callq 0x2d80
testb $0x1, -0x87(%rbp)
je 0x2952
xorl %eax, %eax
movq %rax, -0xf0(%rbp)
jmp 0x2960
movq -0xe8(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0xf0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq 0x40(%rcx), %rdx
movq %rdx, 0x20(%rax)
movq 0x48(%rcx), %rdx
movq %rdx, 0x28(%rax)
movq 0x50(%rcx), %rdx
movq %rdx, 0x30(%rax)
movq 0x58(%rcx), %rcx
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x7eb0
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x31, 0x40(%rax)
je 0x2bbd
jmp 0x2bd4
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rsi
callq 0x3df0
jmp 0x2b6c
movq -0x8(%rbp), %rdi
callq 0x3f90
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: declaration
static void declaration(bluCompiler* compiler) {
	if (match(compiler, TOKEN_VAR)) {
		varDeclaration(compiler);
	} else if (match(compiler, TOKEN_FN)) {
		fnDeclaration(compiler);
	} else if (match(compiler, TOKEN_CLASS)) {
		classDeclaration(compiler);
	} else {
		statement(compiler);
	}

	if (compiler->panicMode) synchronize(compiler);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2d, %esi
callq 0x2c40
testb $0x1, %al
jne 0x2ca0
jmp 0x2cab
movq -0x8(%rbp), %rdi
callq 0x3ff0
jmp 0x2cf6
movq -0x8(%rbp), %rdi
movl $0x23, %esi
callq 0x2c40
testb $0x1, %al
jne 0x2cbf
jmp 0x2cca
movq -0x8(%rbp), %rdi
callq 0x4060
jmp 0x2cf4
movq -0x8(%rbp), %rdi
movl $0x1f, %esi
callq 0x2c40
testb $0x1, %al
jne 0x2cde
jmp 0x2ce9
movq -0x8(%rbp), %rdi
callq 0x40b0
jmp 0x2cf2
movq -0x8(%rbp), %rdi
callq 0x4500
jmp 0x2cf4
jmp 0x2cf6
movq -0x8(%rbp), %rax
testb $0x1, 0x5a(%rax)
je 0x2d09
movq -0x8(%rbp), %rdi
callq 0x4640
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $0x0, 0x40(%rax)
jne 0x2d35
movq -0x8(%rbp), %rdi
callq 0x4e90
jmp 0x2d66
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movl 0x40(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x30, %eax
je 0x2d64
movq -0x8(%rbp), %rdi
callq 0x4e90
jmp 0x2d66
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: errorAt
static void errorAt(bluCompiler* compiler, bluToken* token, const char* message) {
	if (compiler->panicMode) return;
	compiler->panicMode = true;

	fprintf(stderr, "[line %d:%d] Error", token->line, token->column);

	if (token->type == TOKEN_EOF) {
		fprintf(stderr, " at end");
	} else if (token->type == TOKEN_NEWLINE) {
		fprintf(stderr, " at newline");
	} else if (token->type == TOKEN_ERROR) {
		// Nothing.
	} else {
		fprintf(stderr, " at '%.*s'", token->length, token->start);
	}

	fprintf(stderr, ": %s\n", message);

	compiler->hadError = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x5a(%rax)
je 0x2e03
jmp 0x2ed2
movq -0x8(%rbp), %rax
movb $0x1, 0x5a(%rax)
movq 0x111e6(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
leaq 0xb30c(%rip), %rsi      # 0xe136
movb $0x0, %al
callq 0x1130
movq -0x10(%rbp), %rax
cmpl $0x2f, (%rax)
jne 0x2e54
movq 0x111b7(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
leaq 0xb2fe(%rip), %rsi      # 0xe149
movb $0x0, %al
callq 0x1130
jmp 0x2eae
movq -0x10(%rbp), %rax
cmpl $0x30, (%rax)
jne 0x2e77
movq 0x11194(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
leaq 0xb2e3(%rip), %rsi      # 0xe151
movb $0x0, %al
callq 0x1130
jmp 0x2eac
movq -0x10(%rbp), %rax
cmpl $0x31, (%rax)
jne 0x2e82
jmp 0x2eaa
movq 0x1116f(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0xb2ba(%rip), %rsi      # 0xe15d
movb $0x0, %al
callq 0x1130
jmp 0x2eac
jmp 0x2eae
movq 0x11143(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0xb2a5(%rip), %rsi      # 0xe168
movb $0x0, %al
callq 0x1130
movq -0x8(%rbp), %rax
movb $0x1, 0x59(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
leaq 0x10(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3300
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0x10(%rbp)
je 0x2f18
movb $0x6, -0xa(%rbp)
movb $0x7, -0xb(%rbp)
jmp 0x2f54
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x3390
movl %eax, -0x10(%rbp)
cmpl $-0x1, %eax
je 0x2f37
movb $0xb, -0xa(%rbp)
movb $0xc, -0xb(%rbp)
jmp 0x2f52
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x3250
movzwl %ax, %eax
movl %eax, -0x10(%rbp)
movb $0x9, -0xa(%rbp)
movb $0xa, -0xb(%rbp)
jmp 0x2f54
testb $0x1, -0x9(%rbp)
je 0x2f95
movq -0x8(%rbp), %rdi
movl $0xf, %esi
callq 0x2c40
testb $0x1, %al
jne 0x2f6e
jmp 0x2f95
movq -0x8(%rbp), %rdi
callq 0x3450
movq -0x8(%rbp), %rdi
movzbl -0xb(%rbp), %esi
callq 0x32b0
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
movzwl %ax, %esi
callq 0x3140
jmp 0x2fb1
movq -0x8(%rbp), %rdi
movzbl -0xa(%rbp), %esi
callq 0x32b0
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
movzwl %ax, %esi
callq 0x3140
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: syntheticToken
static bluToken syntheticToken(bluCompiler* compiler, const char* text) {
	bluToken token;
	token.start = text;
	token.length = (uint8_t)strlen(text);

	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)
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)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movl $0xa, %esi
callq 0x2bf0
testb $0x1, %al
jne 0x3064
jmp 0x3024
movq -0x8(%rbp), %rdi
callq 0x3450
movb -0x9(%rbp), %al
addb $0x1, %al
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0x10, %eax
jle 0x304e
movq -0x8(%rbp), %rdi
leaq 0xb362(%rip), %rsi      # 0xe3ab
callq 0x2db0
jmp 0x3050
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x2c40
testb $0x1, %al
jne 0x3024
jmp 0x3064
movq -0x8(%rbp), %rdi
movl $0xa, %esi
leaq 0xb35b(%rip), %rdx      # 0xe3cf
callq 0x3200
movb -0x9(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %esi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
addq $0x28, %rdi
addq $0x40, %rdi
movl -0x18(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x1aa0
movl %eax, -0x24(%rbp)
cmpl $0xfffe, -0x24(%rbp)    # imm = 0xFFFE
jle 0x31e3
movq -0x20(%rbp), %rdi
leaq 0xb217(%rip), %rsi      # 0xe3ed
callq 0x2db0
movw $0x0, -0x2(%rbp)
jmp 0x31ea
movl -0x24(%rbp), %eax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2bf0
testb $0x1, %al
jne 0x3225
jmp 0x3230
movq -0x8(%rbp), %rdi
callq 0x2b30
jmp 0x323d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3df0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x337f
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x34a0
testb $0x1, %al
jne 0x334d
jmp 0x3372
movq -0x28(%rbp), %rax
movsbl 0x20(%rax), %eax
cmpl $-0x1, %eax
jne 0x336a
movq -0x10(%rbp), %rdi
leaq 0xae82(%rip), %rsi      # 0xe1e7
callq 0x2db0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3386
jmp 0x3374
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x331d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: resolveUpvalue
static int32_t resolveUpvalue(bluCompiler* compiler, bluToken* name) {
	// If we are at the top level, we didn't find it.
	if (compiler->enclosing == NULL) return -1;

	// See if it's a local variable in the immediately enclosing function.
	int32_t local = resolveLocal(compiler->enclosing, name);
	if (local != -1) {
		// Mark the local as an upvalue so we know to close it when it goes out of scope.
		compiler->enclosing->locals.data[local].isUpvalue = true;
		return addUpvalue(compiler, (uint16_t)local, true);
	}

	// See if it's an upvalue in the immediately enclosing function. In other words, if it's a local variable in a
	// non-immediately enclosing function. This "flattens" closures automatically: it adds upvalues to all of the
	// intermediate functions to get from the function where a local is declared all the way into the possibly deeply
	// nested function that is closing over it.
	int32_t upvalue = resolveUpvalue(compiler->enclosing, name);
	if (upvalue != -1) {
		return addUpvalue(compiler, (uint16_t)upvalue, false);
	}

	// If we got here, we walked all the way up the parent chain and
	// couldn't find it.
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x33b7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x343c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3300
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
je 0x3405
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movb $0x1, 0x21(%rax)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl $0x1, %edx
movzwl %ax, %esi
callq 0x3500
movl %eax, -0x4(%rbp)
jmp 0x343c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3390
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
je 0x3435
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %eax
xorl %edx, %edx
movzwl %ax, %esi
callq 0x3500
movl %eax, -0x4(%rbp)
jmp 0x343c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: expression
static void expression(bluCompiler* compiler) {
	if (match(compiler, TOKEN_FN)) {
		function(compiler, TYPE_ANONYMOUS);
	} else {
		parsePrecedence(compiler, PREC_ASSIGNMENT);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x23, %esi
callq 0x2c40
testb $0x1, %al
jne 0x3470
jmp 0x3480
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x3600
jmp 0x348e
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x38b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: addUpvalue
static int32_t addUpvalue(bluCompiler* compiler, uint16_t index, bool isLocal) {
	// Look for an existing one.
	uint16_t upvalueCount = compiler->function->upvalueCount;
	for (uint16_t i = 0; i < upvalueCount; i++) {
		bluUpvalue* upvalue = &compiler->upvalues.data[i];
		if (upvalue->index == index && upvalue->isLocal == isLocal) {
			return i;
		}
	}

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movw %si, %cx
movq %rdi, -0x10(%rbp)
movw %cx, -0x12(%rbp)
andb $0x1, %al
movb %al, -0x13(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movw 0x22(%rax), %ax
movw %ax, -0x16(%rbp)
movw $0x0, -0x18(%rbp)
movzwl -0x18(%rbp), %eax
movzwl -0x16(%rbp), %ecx
cmpl %ecx, %eax
jge 0x3594
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movzwl -0x18(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzwl (%rax), %eax
movzwl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3584
movq -0x20(%rbp), %rax
movb 0x2(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x13(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x3584
movzwl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x35f5
jmp 0x3586
movw -0x18(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x18(%rbp)
jmp 0x3530
movzwl -0x16(%rbp), %eax
cmpl $0xfffe, %eax           # imm = 0xFFFE
jne 0x35b8
movq -0x10(%rbp), %rdi
leaq 0xac70(%rip), %rsi      # 0xe21a
callq 0x2db0
movl $0x0, -0x4(%rbp)
jmp 0x35f5
movb -0x13(%rbp), %al
andb $0x1, %al
movb %al, -0x22(%rbp)
movw -0x12(%rbp), %ax
movw %ax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
movl -0x24(%rbp), %esi
callq 0x1e80
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movw 0x22(%rcx), %ax
movw %ax, %dx
addw $0x1, %dx
movw %dx, 0x22(%rcx)
movzwl %ax, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/compiler/compiler.c
// Function: parsePrecedence
static void parsePrecedence(bluCompiler* compiler, Precedence precedence) {
	advance(compiler);

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2b30
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x20(%rax), %edi
callq 0x3dd0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x38fb
movq -0x8(%rbp), %rdi
leaq 0xaa8c(%rip), %rsi      # 0xe37d
callq 0x2db0
jmp 0x39a6
cmpl $0x1, -0xc(%rbp)
setbe %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
movb -0x19(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %esi
callq *%rax
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x40(%rax), %edi
callq 0x3dd0
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl 0x10(%rcx), %eax
ja 0x3971
movq -0x8(%rbp), %rdi
callq 0x2b30
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x20(%rax), %edi
callq 0x3dd0
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rdi
movb -0x19(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %esi
callq *%rax
jmp 0x391a
testb $0x1, -0x19(%rbp)
je 0x39a6
movq -0x8(%rbp), %rdi
movl $0xf, %esi
callq 0x2c40
testb $0x1, %al
jne 0x398b
jmp 0x39a4
movq -0x8(%rbp), %rdi
leaq 0xa9fa(%rip), %rsi      # 0xe390
callq 0x2db0
movq -0x8(%rbp), %rdi
callq 0x3450
jmp 0x39a6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)