LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/baines[P]MiniGBS/audio.c
// Function: audio_get_notes
void audio_get_notes(uint16_t notes[static 4]){
	for(int i = 0; i < 4; ++i){
		if(chan_muted(chans + i)){
			notes[i] = 0xffff;
		} else {
			notes[i] = chans[i].note;
		}
	}
}

// Assembly:
leaq 0x8167(%rip), %rax      # 0x115b0
xorl %ecx, %ecx
leaq 0x8156(%rip), %rdx      # 0x115a8
movw $0xffff, %si            # imm = 0xFFFF
cmpb $0x0, (%rcx,%rdx)
jne 0x947d
cmpb $0x1, (%rax)
jne 0x947d
cmpb $0x1, 0x1(%rax)
jne 0x947d
cmpb $0x0, 0x2(%rax)
jne 0x9473
cmpb $0x1, 0x3(%rax)
jne 0x947d
cmpl $0x0, 0x4(%rax)
je 0x947d
movzwl 0x1c(%rax), %esi
movw %si, (%rdi,%rcx,2)
incq %rcx
addq $0x70, %rax
cmpq $0x4, %rcx
jne 0x9452
retq
// File: /workspace/github_c_makefile_star2_O3/baines[P]MiniGBS/audio.c
// Function: chan_trigger
void chan_trigger(int i){
	struct chan* c = chans + i;

	if(cfg.debug_mode){
		static const char* cname[] = { "sq1", "sq2", "wave", "noise" };
		debug_msg("Trigger %s", cname[i]);
	}

	chan_enable(i, 1);
	c->volume = c->volume_init;

	// volume envelope
	{
		uint8_t val = mem[0xFF12 + (i*5)];

		c->env.step    = val & 0x07;
		c->env.up      = val & 0x08;
		c->env.inc     = c->env.step ? (64.0f / (float)c->env.step) / FREQ : 8.0f / FREQ;
		c->env.counter = 0.0f;
	}

	// freq sweep
	if(i == 0){
		uint8_t val = mem[0xFF10];

		c->sweep.freq    = c->freq;
		c->sweep.rate    = (val >> 4) & 0x07;
		c->sweep.up      = !(val & 0x08);
		c->sweep.shift   = (val & 0x07);
		c->sweep.inc     = c->sweep.rate ? (128.0f / (float)(c->sweep.rate)) / FREQ : 0;
		c->sweep.counter = nexttowardf(1.0f, 1.1f);
	}

	if(i == 2){ // wave
		c->val = 0;
	} else if(i == 3){ // noise
		c->lfsr_reg = 0xFFFF;
		c->val = -1;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movslq %edi, %r15
imulq $0x70, %r15, %rax
leaq 0x7f52(%rip), %r14      # 0x115b0
addq %rax, %r14
leaq 0x7de0(%rip), %rax      # 0x11448
cmpl $0x0, (%rax)
je 0x9689
leaq 0x3d54(%rip), %rax      # 0xd3c8
movslq (%rax,%r15,4), %rsi
addq %rax, %rsi
leaq 0x3d82(%rip), %rdi      # 0xd404
xorl %eax, %eax
callq 0x8340
movb $0x1, (%r14)
leaq 0x7dac(%rip), %rax      # 0x11440
movq (%rax), %rax
movb 0xff26(%rax), %cl
andb $-0x80, %cl
movb 0x805a(%rip), %dl       # 0x11700
shlb $0x3, %dl
orb %cl, %dl
movb 0x7fdf(%rip), %cl       # 0x11690
shlb $0x2, %cl
orb %dl, %cl
movb 0x7f64(%rip), %dl       # 0x11620
addb %dl, %dl
orb %cl, %dl
orb 0x7eea(%rip), %dl       # 0x115b0
movb %dl, 0xff26(%rax)
movl 0x8(%r14), %ecx
movl %ecx, 0x4(%r14)
leaq (%r15,%r15,4), %rcx
movzbl 0xff12(%rax,%rcx), %edx
movl %edx, %ecx
andl $0x7, %ecx
movl %ecx, 0x30(%r14)
shrb $0x3, %dl
andb $0x1, %dl
movb %dl, 0x34(%r14)
testl %ecx, %ecx
je 0x9711
cvtsi2ss %ecx, %xmm1
movss 0x3bb1(%rip), %xmm0     # 0xd2b4
divss %xmm1, %xmm0
divss 0x3b7d(%rip), %xmm0     # 0xd28c
jmp 0x9719
movss 0x3b9f(%rip), %xmm0     # 0xd2b8
movss %xmm0, 0x3c(%r14)
movl $0x0, 0x38(%r14)
cmpl $0x3, %ebx
je 0x97b9
cmpl $0x2, %ebx
je 0x97af
testl %ebx, %ebx
jne 0x97c8
movzbl 0xff10(%rax), %ecx
movzwl 0xc(%r14), %eax
movw %ax, 0x40(%r14)
movl %ecx, %eax
shrl $0x4, %eax
andl $0x7, %eax
movl %eax, 0x44(%r14)
testb $0x8, %cl
sete 0x48(%r14)
andl $0x7, %ecx
movl %ecx, 0x4c(%r14)
xorps %xmm0, %xmm0
testl %eax, %eax
je 0x978b
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
movss 0x3b3d(%rip), %xmm0     # 0xd2bc
divss %xmm1, %xmm0
divss 0x3b01(%rip), %xmm0     # 0xd28c
movss %xmm0, 0x54(%r14)
flds 0x3b29(%rip)            # 0xd2c0
fstpt (%rsp)
movss 0x28ba(%rip), %xmm0     # 0xc05c
callq 0x5360
movss %xmm0, 0x50(%r14)
jmp 0x97c8
movl $0x0, 0x18(%r14)
jmp 0x97c8
movw $0xffff, 0x64(%r14)     # imm = 0xFFFF
movl $0xffffffff, 0x18(%r14) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/baines[P]MiniGBS/audio.c
// Function: chan_update_len
void chan_update_len(int i) {
	struct chan* c = chans + i;
	int len_max = i == 2 ? 256 : 64;
	c->len.inc = (256.0f / (float)(len_max - c->len.load)) / FREQ;
	c->len.counter = 0.0f;
}

// Assembly:
movslq %edi, %rax
cmpl $0x2, %eax
movl $0x100, %ecx            # imm = 0x100
movl $0x40, %edx
cmovel %ecx, %edx
imulq $0x70, %rax, %rax
leaq 0x7dc0(%rip), %rcx      # 0x115b0
subl 0x20(%rax,%rcx), %edx
cvtsi2ss %edx, %xmm0
movss 0x3ac4(%rip), %xmm1     # 0xd2c4
divss %xmm0, %xmm1
divss 0x3a80(%rip), %xmm1     # 0xd28c
movss %xmm1, 0x2c(%rax,%rcx)
movl $0x0, 0x28(%rax,%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/baines[P]MiniGBS/audio_output.c
// Function: wav_init
static uint16_t wav_init(struct audio_output* out, struct pollfd** fds, int* nfds, float freq) {
	struct audio_wav* wav = (struct audio_wav*)out;
	wav->writer = wav_write_begin(wav->output.filename, freq);
	if(!wav->writer) {
		fprintf(stderr, "Error opening .wav file\n");
		exit(1);
	}

	wav->eventfd = eventfd(1, 0);

	*fds = realloc(*fds, (*nfds + 1) * sizeof(struct pollfd));
	(*fds)[*nfds] = (struct pollfd){
		.fd = wav->eventfd,
		.events = POLLIN,
	};
	*nfds += 1;

	return freq / 60;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x28(%rdi), %rdi
movss %xmm0, 0xc(%rsp)
cvttss2si %xmm0, %rsi
callq 0x9df0
movq %rax, 0x30(%r14)
testq %rax, %rax
je 0x9dd4
movl $0x1, %edi
xorl %esi, %esi
callq 0x5200
movl %eax, 0x38(%r14)
movq (%r15), %rdi
movslq (%rbx), %rax
leaq 0x8(,%rax,8), %rsi
callq 0x5520
movq %rax, (%r15)
movslq (%rbx), %rcx
movl 0x38(%r14), %edx
movl %edx, (%rax,%rcx,8)
movl $0x1, 0x4(%rax,%rcx,8)
leal 0x1(%rcx), %eax
movss 0xc(%rsp), %xmm0
divss 0x36b4(%rip), %xmm0     # 0xd478
movl %eax, (%rbx)
cvttss2si %xmm0, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x568d
// File: /workspace/github_c_makefile_star2_O3/baines[P]MiniGBS/wav_write.c
// Function: wav_write_begin
struct wav_writer* wav_write_begin(const char* filename, uint32_t freq) {
	struct wav_writer* wav = calloc(1, sizeof(struct wav_writer));

	*wav = (struct wav_writer){
		.header = {
			.riff_magic = "RIFF",
			.wave_magic = "WAVE",
			.fmt_magic  = "fmt ",
			.fmt_size   = 16,
			.format     = 3,
			.nchannels  = 2,
			.sample_rate = freq,
			.byte_rate = freq * 2 * sizeof(float),
			.block_align = 2 * sizeof(float),
			.bits_per_sample = sizeof(float) * 8,
			.data_magic = "data",
		},
	};

	wav->file = fopen(filename, "w");
	if(!wav->file) {
		fprintf(stderr, "fopen(%s): %m\n", filename);
		return NULL;
	}

	fwrite(&wav->header, sizeof(wav->header), 1, wav->file);

	return wav;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x1, %edi
movl $0x40, %esi
callq 0x5490
movq %rax, %rbx
movl $0x46464952, (%rax)     # imm = 0x46464952
movabsq $0x20746d6645564157, %rax # imm = 0x20746D6645564157
movq %rax, 0x8(%rbx)
movabsq $0x2000300000010, %rax  # imm = 0x2000300000010
movq %rax, 0x10(%rbx)
movl %ebp, 0x18(%rbx)
shll $0x3, %ebp
movl %ebp, 0x1c(%rbx)
movabsq $0x6174616400200008, %rax # imm = 0x6174616400200008
movq %rax, 0x20(%rbx)
leaq 0x3a44(%rip), %rsi      # 0xd88f
movq %r14, %rdi
callq 0x51d0
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x9e79
movl $0x2c, %esi
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rcx
callq 0x5500
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x7168(%rip), %rax      # 0x10fe8
movq (%rax), %rdi
leaq 0x3613(%rip), %rsi      # 0xd49d
xorl %ebx, %ebx
movq %r14, %rdx
xorl %eax, %eax
callq 0x5570
jmp 0x9e71
// File: /workspace/github_c_makefile_star2_O3/baines[P]MiniGBS/ui.c
// Function: ui_chart_set
void ui_chart_set(uint16_t notes[static 3]){
	if(++col >= &grid[0] + GRID_W){
		col = &grid[0];
	}

	memset(col, 0, sizeof(*col));

	for(int i = 0; i < 3; ++i){
		int n = notes[i] - 5;
		if(n < 0 || n >= GRID_H) continue;
		
		(*col)[n] |= (1 << i);
	}
}

// Assembly:
movq 0x744d(%rip), %rcx      # 0x11398
addq $0x3c, %rcx
leaq 0x787a(%rip), %rax      # 0x117d0
leaq 0x8683(%rip), %rdx      # 0x125e0
cmpq %rdx, %rcx
cmovbq %rcx, %rax
movq %rax, 0x742d(%rip)      # 0x11398
xorps %xmm0, %xmm0
movups %xmm0, 0x2c(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
xorl %ecx, %ecx
movzwl (%rdi,%rcx,2), %edx
leal -0x41(%rdx), %esi
cmpw $-0x3c, %si
jb 0x9f9a
movl $0x1, %esi
shll %cl, %esi
addl $-0x5, %edx
orb %sil, (%rax,%rdx)
incq %rcx
cmpq $0x3, %rcx
jne 0x9f7f
retq
// File: /workspace/github_c_makefile_star2_O3/baines[P]MiniGBS/ui.c
// Function: ui_init
int ui_init(void){
	if(cfg.hide_ui)
		return -1;

	initscr();
	noecho();
	cbreak();
	timeout(0);
	curs_set(0);
	nodelay(stdscr, TRUE);
	keypad(stdscr, TRUE);
	set_escdelay(0);

	if(!cfg.monochrome){
		start_color();

		if(can_change_color() && COLORS > 100){
			init_color(COLOR_BLACK, 91, 91, 102);
		}

		init_pair(1, COLOR_CYAN   , COLOR_BLACK);
		init_pair(2, COLOR_MAGENTA, COLOR_BLACK);
		init_pair(3, COLOR_RED    , COLOR_BLACK);
		init_pair(4, COLOR_YELLOW , COLOR_BLACK);
		init_pair(5, COLOR_BLACK  , COLOR_BLACK);
		init_pair(6, COLOR_GREEN  , COLOR_BLACK);
		init_pair(7, COLOR_WHITE  , COLOR_BLACK);

		init_pair(8 , COLOR_CYAN    , COLOR_MAGENTA);
		init_pair(9 , COLOR_CYAN    , COLOR_RED);
		init_pair(10, COLOR_MAGENTA , COLOR_RED);

		init_pair(11, COLOR_BLACK, COLOR_CYAN);
		init_pair(12, COLOR_BLACK, COLOR_MAGENTA);
		init_pair(13, COLOR_BLACK, COLOR_RED);
		init_pair(14, COLOR_BLACK, COLOR_YELLOW);

		bkgd(COLOR_PAIR(7));
	}

	getmaxyx(stdscr, cfg.win_h, cfg.win_w);

	return x11_init();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x73e4(%rip), %rbx      # 0x11448
cmpb $0x0, 0x5(%rbx)
je 0xa077
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x5320
callq 0x5170
callq 0x54c0
movq 0x6f43(%rip), %r14      # 0x10fd0
movq (%r14), %rdi
xorl %esi, %esi
callq 0x50c0
xorl %edi, %edi
callq 0x51e0
movq (%r14), %rdi
movl $0x1, %esi
callq 0x5040
movq (%r14), %rdi
movl $0x1, %esi
callq 0x5180
xorl %edi, %edi
callq 0x5390
cmpb $0x0, 0x4(%rbx)
jne 0xa1fa
callq 0x5480
callq 0x53c0
testb %al, %al
je 0xa0f9
movq 0x6f02(%rip), %rax      # 0x10fe0
cmpl $0x65, (%rax)
jl 0xa0f9
xorl %edi, %edi
movl $0x5b, %esi
movl $0x5b, %edx
movl $0x66, %ecx
callq 0x5110
movl $0x1, %edi
movl $0x6, %esi
xorl %edx, %edx
callq 0x50a0
movl $0x2, %edi
movl $0x5, %esi
xorl %edx, %edx
callq 0x50a0
movl $0x3, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x50a0
movl $0x4, %edi
movl $0x3, %esi
xorl %edx, %edx
callq 0x50a0
movl $0x5, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x50a0
movl $0x6, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x50a0
movl $0x7, %edi
movl $0x7, %esi
xorl %edx, %edx
callq 0x50a0
movl $0x8, %edi
movl $0x6, %esi
movl $0x5, %edx
callq 0x50a0
movl $0x9, %edi
movl $0x6, %esi
movl $0x1, %edx
callq 0x50a0
movl $0xa, %edi
movl $0x5, %esi
movl $0x1, %edx
callq 0x50a0
movl $0xb, %edi
xorl %esi, %esi
movl $0x6, %edx
callq 0x50a0
movl $0xc, %edi
xorl %esi, %esi
movl $0x5, %edx
callq 0x50a0
movl $0xd, %edi
xorl %esi, %esi
movl $0x1, %edx
callq 0x50a0
movl $0xe, %edi
xorl %esi, %esi
movl $0x3, %edx
callq 0x50a0
movq (%r14), %rdi
movl $0x700, %esi            # imm = 0x700
callq 0x5140
movq (%r14), %rcx
testq %rcx, %rcx
je 0xa210
movswl 0x4(%rcx), %eax
incl %eax
movswl 0x6(%rcx), %ecx
incl %ecx
jmp 0xa21a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %eax, 0x2c(%rbx)
movl %ecx, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb400
// File: /workspace/github_c_makefile_star2_O3/baines[P]MiniGBS/ui.c
// Function: ui_osc_draw
void ui_osc_draw(int chan, float* samples, size_t count){
	struct osc_chan* c = osc_chans + chan;

	count /= 2;

	if(count > OSC_SAMPLES){
		samples += 2 * (count - OSC_SAMPLES);
		count = OSC_SAMPLES;
	}

	size_t copy_count = OSC_SAMPLES - count;
	memmove(c->samples, c->samples + count, copy_count * sizeof(float));

	for(size_t i = 0; i < count; ++i){
		float s = ((samples[i*2] + samples[i*2+1]) / 2.0f);// * 1.2f * height;
		c->samples[copy_count + i] = s;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movslq %edi, %rax
imulq $0x1900, %rax, %rbx     # imm = 0x1900
leaq 0x84eb(%rip), %r14      # 0x12730
leaq (%r14,%rbx), %rdi
movq %rdx, %rax
shrq %rax
movabsq $0x3ffffffffffffffe, %rcx # imm = 0x3FFFFFFFFFFFFFFE
andq %rdx, %rcx
cmpq $0xc82, %rdx            # imm = 0xC82
leaq -0x3200(%rsi,%rcx,4), %r15
movl $0x640, %r12d           # imm = 0x640
cmovbq %rax, %r12
cmovbq %rsi, %r15
movl $0x640, %edx            # imm = 0x640
subl %r12d, %edx
leaq (%rdi,%r12,4), %rsi
shll $0x2, %edx
callq 0x53d0
testq %r12, %r12
je 0xa2d1
leaq (,%r12,4), %rax
subq %rax, %rbx
addq $0x1900, %rbx           # imm = 0x1900
xorl %eax, %eax
movss 0x31fe(%rip), %xmm0     # 0xd4ac
movss (%r15,%rax,8), %xmm1
addss 0x4(%r15,%rax,8), %xmm1
mulss %xmm0, %xmm1
leaq (%rbx,%rax,4), %rcx
movss %xmm1, (%r14,%rcx)
incq %rax
cmpq %rax, %r12
jne 0xa2ae
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/baines[P]MiniGBS/ui.c
// Function: ui_cmd
int ui_cmd(int key){
	int result = -1;

	if(cfg.hide_ui)
		return result;

	switch(key){
		case '\n': {
			if(ui_in_cmd_mode && *input){
				result = atoi(input);
			}
			input_ptr = input;
			*input = 0;
			ui_in_cmd_mode = !ui_in_cmd_mode;
			move(cfg.win_h-1, 0);
			clrtoeol();
		} break;

		case KEY_BACKSPACE: {
			if(input_ptr != input){
				*--input_ptr = 0;
			}
		} break;

		default: {
			if(input_ptr - input < sizeof(input)){
				*input_ptr++ = key;
				*input_ptr = 0;
			}
		} break;
	}

	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x63e7(%rip), %r14      # 0x11448
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpb $0x0, 0x5(%r14)
jne 0xb137
cmpl $0x107, %edi            # imm = 0x107
je 0xb0e7
cmpl $0xa, %edi
jne 0xb10b
movb 0xdaa7(%rip), %bpl      # 0x18b30
cmpb $0x1, %bpl
jne 0xb0a6
cmpb $0x0, 0xdaaa(%rip)      # 0x18b40
je 0xb0a6
leaq 0xdaa1(%rip), %rdi      # 0x18b40
callq 0x53a0
movl %eax, %ebx
leaq 0xda93(%rip), %rax      # 0x18b40
movq %rax, 0x62ec(%rip)      # 0x113a0
movb $0x0, 0xda85(%rip)      # 0x18b40
xorb $0x1, %bpl
movb %bpl, 0xda6a(%rip)      # 0x18b30
movq 0x5f03(%rip), %r15      # 0x10fd0
movq (%r15), %rdi
movl 0x2c(%r14), %esi
decl %esi
xorl %edx, %edx
callq 0x5210
movq (%r15), %rdi
callq 0x5220
jmp 0xb137
movq 0x62b2(%rip), %rax      # 0x113a0
leaq 0xda4b(%rip), %rcx      # 0x18b40
cmpq %rcx, %rax
je 0xb137
leaq -0x1(%rax), %rcx
movq %rcx, 0x629b(%rip)      # 0x113a0
movb $0x0, -0x1(%rax)
jmp 0xb137
movq 0x628e(%rip), %rax      # 0x113a0
leaq 0xda27(%rip), %rcx      # 0x18b40
movq %rax, %rdx
subq %rcx, %rdx
cmpq $0x1f, %rdx
ja 0xb137
leaq 0x1(%rax), %rcx
movq %rcx, 0x6270(%rip)      # 0x113a0
movb %dil, (%rax)
movb $0x0, 0x1(%rax)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/baines[P]MiniGBS/x11.c
// Function: x11_action
int x11_action(bool* have_more_events){
	if(!x11_win || !x11.pending(x11_dpy)){
		*have_more_events = false;
		return -1;
	}

	XEvent ev;
	x11.next_event(x11_dpy, &ev);

	if(ev.type == KeyPress){
		KeySym sym = x11.lookup_key(&ev.xkey, 0);

		switch(sym){
			case XK_Escape:
			case XK_q:
				return 'o';
			case XK_BackSpace:
				return KEY_BACKSPACE;
			case XK_Up:
				return KEY_UP;
			case XK_Down:
				return KEY_DOWN;
			case XK_Left:
				return KEY_LEFT;
			case XK_Right:
				return KEY_RIGHT;
			case XK_Return:
				return '\n';
			case XK_c:
				if(ev.xkey.state & ControlMask){
					return 'q';
				}
			default:
				return sym;
		}
	}

	if(ev.type == ClientMessage && ev.xclient.data.l[0] == x11_atom_wm_delete){
		x11.unmap_window(x11_dpy, x11_win);
		x11_visible = false;
	}

	return -1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
cmpq $0x0, 0xd51c(%rip)      # 0x18c10
je 0xb76b
movq 0xd50b(%rip), %rdi      # 0x18c08
callq *0xd4d5(%rip)           # 0x18bd8
testl %eax, %eax
je 0xb76b
movq 0xd4fa(%rip), %rdi      # 0x18c08
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq *0xd4c4(%rip)           # 0x18be0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl (%r14), %eax
cmpl $0x21, %eax
je 0xb780
cmpl $0x2, %eax
jne 0xb773
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq *0xd4ad(%rip)           # 0x18be8
movl $0x6f, %ebx
cmpq $0xff0c, %rax           # imm = 0xFF0C
jg 0xb7ab
cmpq $0x63, %rax
je 0xb7e1
cmpq $0x71, %rax
je 0xb773
cmpq $0xff08, %rax           # imm = 0xFF08
jne 0xb7ed
movl $0x107, %ebx            # imm = 0x107
jmp 0xb773
movb $0x0, (%rbx)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
movq 0x40(%rsp), %rax
cmpq 0xd4ac(%rip), %rax      # 0x18c38
jne 0xb773
movq 0xd473(%rip), %rdi      # 0x18c08
movq 0xd474(%rip), %rsi      # 0x18c10
callq *0xd3e6(%rip)           # 0x18b88
movb $0x0, 0xd497(%rip)      # 0x18c40
jmp 0xb773
leaq -0xff51(%rax), %rcx
cmpq $0x3, %rcx
ja 0xb7cf
leaq 0x201d(%rip), %rax      # 0xd7dc
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x104, %ebx            # imm = 0x104
jmp 0xb773
cmpq $0xff0d, %rax           # imm = 0xFF0D
je 0xb7f1
cmpq $0xff1b, %rax           # imm = 0xFF1B
je 0xb773
jmp 0xb7ed
movl $0x71, %ebx
testb $0x4, 0x58(%rsp)
jne 0xb773
movl %eax, %ebx
jmp 0xb773
movl $0xa, %ebx
jmp 0xb773
movl $0x105, %ebx            # imm = 0x105
jmp 0xb773
movl $0x102, %ebx            # imm = 0x102
jmp 0xb773
movl $0x103, %ebx            # imm = 0x103
jmp 0xb773
// File: /workspace/github_c_makefile_star2_O3/baines[P]MiniGBS/x11.c
// Function: x11_draw_end
void x11_draw_end(void){
	if(!x11_win || !x11_visible) return;

	struct present_pixmap_req* req = x11.get_request(x11_dpy, x11_present_op, sizeof(*req));
	memset(req->crap, 0, sizeof(req->crap));
	req->subtype = 1;
	req->window = x11_win;
	req->pixmap = x11_pix;

	if(x11_dpy->synchandler)
		x11_dpy->synchandler(x11_dpy);

	x11.flush(x11_dpy);
}

// Assembly:
pushq %rax
cmpq $0x0, 0xd36d(%rip)      # 0x18c10
je 0xb913
cmpb $0x1, 0xd394(%rip)      # 0x18c40
jne 0xb913
movq 0xd353(%rip), %rdi      # 0x18c08
movzbl 0xd35c(%rip), %esi      # 0x18c18
movl $0x48, %edx
callq *0xd339(%rip)           # 0x18c00
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rax)
movups %xmm0, 0x1c(%rax)
movups %xmm0, 0x2c(%rax)
movups %xmm0, 0x38(%rax)
movb $0x1, 0x1(%rax)
movl 0xd32c(%rip), %ecx      # 0x18c10
movl %ecx, 0x4(%rax)
movl 0xd333(%rip), %ecx      # 0x18c20
movl %ecx, 0x8(%rax)
movq 0xd311(%rip), %rdi      # 0x18c08
movq 0xd0(%rdi), %rax
testq %rax, %rax
je 0xb90c
callq *%rax
movq 0xd2fc(%rip), %rdi      # 0x18c08
popq %rax
jmpq *0xd2b5(%rip)           # 0x18bc8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/baines[P]MiniGBS/x11.c
// Function: x11_toggle
void x11_toggle(void){
	if(!x11_win) return;

	if(x11_visible){
		x11.unmap_window(x11_dpy, x11_win);
	} else {
		x11.map_window(x11_dpy, x11_win);
	}

	x11_visible = !x11_visible;
	x11.flush(x11_dpy);
}

// Assembly:
pushq %rax
movq 0xd2f3(%rip), %rsi      # 0x18c10
testq %rsi, %rsi
je 0xb950
movzbl 0xd317(%rip), %eax      # 0x18c40
movq 0xd2d8(%rip), %rdi      # 0x18c08
leaq 0xd239(%rip), %rcx      # 0x18b70
callq *0x10(%rcx,%rax,8)
xorb $0x1, 0xd2fe(%rip)      # 0x18c40
movq 0xd2bf(%rip), %rdi      # 0x18c08
popq %rax
jmpq *0xd278(%rip)           # 0x18bc8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/s3lase[P]v6shell/if.c
// Function: main
int
main(int argc, char **argv)
{
	bool re;		/* return value of expr() */

	setmyerrexit(&ut_errexit);
	setmyname(argv[0]);
	setmypid(getpid());

	ifeuid = geteuid();

	/*
	 * Set-ID execution is not supported.
	 */
	if (ifeuid != getuid() || getegid() != getgid())
		err(FC_ERR, FMT2S, getmyname(), ERR_SETID);

	(void)sasignal(SIGCHLD, SIG_DFL);

	if (argc > 1) {
		ac = argc;
		av = argv;
		ap = 1;
		re = expr();
		if (re && ap < ac)
			doex(!FORKED);
	} else
		re = false;

	return re ? SH_TRUE : SH_FALSE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xd2e(%rip), %rdi       # 0x206a
callq 0x1ff8
movq (%rbx), %rdi
callq 0x2005
callq 0x10d0
movl %eax, %edi
callq 0x2059
callq 0x1140
movl %eax, %r14d
movl %eax, 0x3dd5(%rip)      # 0x5138
callq 0x10f0
cmpl %eax, %r14d
jne 0x137f
callq 0x11d0
movl %eax, %r14d
callq 0x11b0
cmpl %eax, %r14d
je 0x13a1
callq 0x1fd3
leaq 0x1ded(%rip), %rsi      # 0x3178
leaq 0x1dca(%rip), %rcx      # 0x315c
movl $0x7c, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1d8c
movl $0x11, %edi
xorl %esi, %esi
callq 0x259c
movl $0x1, %r14d
cmpl $0x2, %ebp
jl 0x13f3
movl %ebp, 0x3d7e(%rip)      # 0x513c
movq %rbx, 0x3d7b(%rip)      # 0x5140
movl $0x1, 0x3d79(%rip)      # 0x5148
callq 0x13fb
testb %al, %al
je 0x13f3
movl 0x3d6a(%rip), %eax      # 0x5148
xorl %r14d, %r14d
cmpl 0x3d55(%rip), %eax      # 0x513c
jge 0x13f3
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x1453
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/s3lase[P]v6shell/if.c
// Function: expr
static bool
expr(void)
{
	bool re;

	re = e1();
	if (equal(nxtarg(RETERR), "-o"))
		return re | expr();
	ap--;
	return re;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
callq 0x160e
movl %eax, %ebx
movl $0x1, %edi
callq 0x167e
xorl %ebp, %ebp
testq %rax, %rax
je 0x143d
cmpb $0x2d, (%rax)
jne 0x143d
cmpb $0x6f, 0x1(%rax)
jne 0x143d
cmpb $0x0, 0x2(%rax)
jne 0x143d
orb %bl, %bpl
callq 0x160e
movl %eax, %ebx
movl $0x1, %edi
callq 0x167e
jmp 0x1411
decl 0x3d05(%rip)            # 0x5148
orb %bl, %bpl
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/s3lase[P]v6shell/if.c
// Function: doex
static void
doex(bool forked)
{
	char **xap, **xav;

	if (ap < 2 || ap > ac)	/* should never (but can) be true */
		err(FC_ERR, FMT2S, getmyname(), ERR_AVIINVAL);

	xav = xap = &av[ap];
	while (*xap != NULL) {
		if (forked && equal(*xap, "}"))
			break;
		xap++;
	}
	if (forked && xap - xav > 0 && !equal(*xap, "}"))
		err(FC_ERR, FMT3S, getmyname(), av[ap - 1], ERR_BRACE);
	*xap = NULL;
	if (xav[0] == NULL) {
		if (forked)
			err(FC_ERR, FMT3S, getmyname(),av[ap - 1],ERR_COMMAND);
		else
			/* Currently unreachable; do not remove. */
			err(FC_ERR, FMT2S, getmyname(), ERR_COMMAND);
	}

	/* Invoke the ":" or "exit" special command. */
	if (equal(xav[0], ":"))
		EXIT(SH_TRUE);
	if (equal(xav[0], "exit")) {
		(void)lseek(FD0, (off_t)0, SEEK_END);
		EXIT(SH_TRUE);
	}

	(void)err_pexec(xav[0], xav);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
movl 0x3ce9(%rip), %eax      # 0x5148
cmpl $0x2, %eax
jl 0x146c
cmpl 0x3cd2(%rip), %eax      # 0x513c
jle 0x1494
callq 0x1fd3
leaq 0x1d00(%rip), %rsi      # 0x3178
leaq 0x1d8d(%rip), %rcx      # 0x320c
movl $0x7c, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1d8c
movl 0x3cb4(%rip), %eax      # 0x5148
movq 0x3ca5(%rip), %rcx      # 0x5140
cltq
leaq (%rcx,%rax,8), %rbx
movq (%rbx), %rax
movq %rbx, %r14
testq %rax, %rax
je 0x14d6
xorl %ecx, %ecx
testb %bpl, %bpl
je 0x14c2
cmpb $0x7d, (%rax)
jne 0x14c2
cmpb $0x0, 0x1(%rax)
je 0x15ed
movq 0x8(%rbx,%rcx), %rax
addq $0x8, %rcx
testq %rax, %rax
jne 0x14ae
addq %rbx, %rcx
movq %rcx, %r14
movq %r14, %rax
subq %rbx, %rax
testq %rax, %rax
setg %al
testb %bpl, %al
je 0x151c
callq 0x1fd3
movq 0x3c4d(%rip), %rcx      # 0x5140
movslq 0x3c4e(%rip), %rdx      # 0x5148
movq -0x8(%rcx,%rdx,8), %rcx
leaq 0x1c6e(%rip), %rsi      # 0x3174
leaq 0x1d24(%rip), %r8       # 0x3231
movl $0x7c, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1d8c
movq $0x0, (%r14)
movq (%rbx), %r14
testq %r14, %r14
jne 0x158c
callq 0x1fd3
testb %bpl, %bpl
je 0x1567
movq 0x3c04(%rip), %rcx      # 0x5140
movslq 0x3c05(%rip), %rdx      # 0x5148
movq -0x8(%rcx,%rdx,8), %rcx
leaq 0x1c25(%rip), %rsi      # 0x3174
leaq 0x1ce6(%rip), %r8       # 0x323c
movl $0x7c, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1d8c
jmp 0x1584
leaq 0x1c0a(%rip), %rsi      # 0x3178
leaq 0x1cc7(%rip), %rcx      # 0x323c
movl $0x7c, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1d8c
movq (%rbx), %r14
testq %r14, %r14
je 0x15db
movzbl (%r14), %eax
cmpl $0x65, %eax
je 0x15a3
cmpl $0x3a, %eax
jne 0x15de
cmpb $0x0, 0x1(%r14)
jne 0x15de
jmp 0x15c4
leaq 0x1ca3(%rip), %rsi      # 0x324d
movq %r14, %rdi
callq 0x1170
testl %eax, %eax
jne 0x15de
xorl %edi, %edi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1120
callq 0x10d0
movl %eax, %ebx
callq 0x1fe9
xorl %edi, %edi
cmpl %eax, %ebx
jne 0x1609
callq 0x11f0
xorl %r14d, %r14d
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x2389
leaq (%rbx,%rcx), %r14
testq %rcx, %rcx
jle 0x151c
cmpb $0x0, 0x1(%rax)
jne 0x14e7
jmp 0x151c
callq 0x1070
// File: /workspace/github_c_makefile_star2_O3/s3lase[P]v6shell/if.c
// Function: e1
static bool
e1(void)
{
	bool re;

	re = e2();
	if (equal(nxtarg(RETERR), "-a"))
		return re & e1();
	ap--;
	return re;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movb $0x1, %bl
movl $0x1, %edi
callq 0x167e
testq %rax, %rax
je 0x162d
cmpb $0x21, (%rax)
jne 0x162d
cmpb $0x0, 0x1(%rax)
je 0x165f
decl 0x3b15(%rip)            # 0x5148
callq 0x1730
movl %eax, %ebp
movl $0x1, %edi
callq 0x167e
testq %rax, %rax
je 0x166c
cmpb $0x2d, (%rax)
jne 0x166c
cmpb $0x61, 0x1(%rax)
jne 0x166c
cmpb $0x0, 0x2(%rax)
jne 0x166c
andb %bpl, %bl
jmp 0x1613
callq 0x1730
movl %eax, %ebp
xorb $0x1, %bpl
jmp 0x163a
decl 0x3ad6(%rip)            # 0x5148
andb %bpl, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/s3lase[P]v6shell/if.c
// Function: nxtarg
static char *
nxtarg(bool reterr)
{
	char *nap;

	if (ap < 1 || ap > ac)	/* should never (but can) be true */
		err(FC_ERR, FMT2S, getmyname(), ERR_AVIINVAL);

	if (ap == ac) {
		if (reterr) {
			ap++;
			return NULL;
		}
		err(FC_ERR, FMT3S, getmyname(), av[ap - 1], ERR_ARGUMENT);
	}
	nap = av[ap];
	ap++;
	return nap;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl 0x3ac1(%rip), %edx      # 0x5148
testl %edx, %edx
setle %al
movl 0x3aaa(%rip), %ecx      # 0x513c
cmpl %ecx, %edx
setg %sil
orb %al, %sil
cmpb $0x1, %sil
jne 0x16cf
callq 0x1fd3
leaq 0x1acb(%rip), %rsi      # 0x3178
leaq 0x1b58(%rip), %rcx      # 0x320c
movl $0x7c, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1d8c
movl 0x3a7f(%rip), %edx      # 0x5148
movl 0x3a6d(%rip), %ecx      # 0x513c
cmpl %ecx, %edx
jne 0x1716
testb %bl, %bl
je 0x16db
xorl %eax, %eax
jmp 0x1726
callq 0x1fd3
movq 0x3a59(%rip), %rcx      # 0x5140
movslq 0x3a5a(%rip), %rdx      # 0x5148
movq -0x8(%rcx,%rdx,8), %rcx
leaq 0x1a7a(%rip), %rsi      # 0x3174
leaq 0x1b1e(%rip), %r8       # 0x321f
movl $0x7c, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1d8c
movl 0x3a32(%rip), %edx      # 0x5148
movq 0x3a23(%rip), %rax      # 0x5140
movslq %edx, %rcx
movq (%rax,%rcx,8), %rax
movl %edx, %ecx
incl %ecx
movl %ecx, 0x3a1a(%rip)      # 0x5148
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/compile.c
// Function: print_line
static void print_line(){
	char *line_pointer;
	char *line_beginning;

	line_pointer = program_pointer;
	fprintf(stderr, "Line %d in %s:\n", current_line, *current_source_file);
	while(line_pointer != program_beginning && line_pointer[-1] != '\n'){
		line_pointer--;
	}
	while(*line_pointer && line_pointer != program_pointer && (*line_pointer == ' ' || *line_pointer == '\t')){
		line_pointer++;
	}
	line_beginning = line_pointer;
	while(*line_pointer && *line_pointer != '\n'){
		fputc(*line_pointer, stderr);
		line_pointer++;
	}
	fputc('\n', stderr);
	while(line_beginning != program_pointer){
		fputc(' ', stderr);
		line_beginning++;
	}
	fprintf(stderr, "^\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0xc434(%rip), %rbx      # 0xd5f0
movq 0xbe35(%rip), %r14      # 0xcff8
movq (%r14), %rdi
movl 0xc434(%rip), %edx      # 0xd600
movq 0xc57d(%rip), %rax      # 0xd750
movq (%rax), %rcx
leaq 0x8d4d(%rip), %rsi      # 0x9f2a
xorl %eax, %eax
callq 0x1100
movq 0xc40d(%rip), %r15      # 0xd5f8
cmpq %r15, %rbx
je 0x1203
leaq -0x1(%rbx), %rax
cmpb $0xa, -0x1(%rbx)
movq %rax, %rbx
jne 0x11eb
incq %rax
movq %rax, %r15
movq 0xc3e6(%rip), %rcx      # 0xd5f0
movb (%r15), %al
testb %al, %al
sete %dl
cmpq %rcx, %r15
sete %sil
orb %dl, %sil
jne 0x124d
incq %r15
movq %r15, %rdx
cmpb $0x20, %al
je 0x1230
movzbl %al, %esi
cmpl $0x9, %esi
jne 0x1247
movb (%rdx), %al
leaq 0x1(%rdx), %r15
testb %al, %al
je 0x1242
cmpq %rcx, %rdx
movq %r15, %rdx
jne 0x1224
decq %r15
jmp 0x124d
decq %rdx
movq %rdx, %r15
leaq 0x1(%r15), %rbx
testb %al, %al
je 0x126f
movzbl %al, %ecx
cmpl $0xa, %ecx
je 0x126f
movsbl %al, %edi
movq (%r14), %rsi
callq 0x10e0
movb (%rbx), %al
incq %rbx
jmp 0x1251
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x10e0
cmpq 0xc36f(%rip), %r15      # 0xd5f0
je 0x129c
pushq $0x20
popq %rbx
movq (%r14), %rsi
movl %ebx, %edi
callq 0x10e0
incq %r15
cmpq 0xc356(%rip), %r15      # 0xd5f0
jne 0x1286
movq (%r14), %rcx
leaq 0x8c94(%rip), %rdi      # 0x9f3a
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/allocate.c
// Function: allocate
data_entry allocate(unsigned char force_stack){
	data_entry output;

	if(force_stack || register_list.num_allocated >= NUM_REGISTERS){
		output.type = data_stack;
		output.prev_stack_size = stack_size;
		output.stack_pos = stack_size;
		stack_size += 4;
	} else {
		output.type = data_register;
		output.reg = register_list.registers[register_list.num_allocated];
		register_list.num_allocated++;
	}

	if(stack_size > saved_stack_size){
		saved_stack_size = stack_size;
	}

	return output;
}

// Assembly:
testl %edi, %edi
setne %cl
movl 0xbd40(%rip), %eax      # 0xd250
cmpl $0x8, %eax
setae %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x1533
movl 0xbd21(%rip), %edx      # 0xd244
leal 0x4(%rdx), %eax
movl %eax, 0xbd18(%rip)      # 0xd244
movl $0x1, %ecx
jmp 0x1551
movl %eax, %eax
leaq 0xbd14(%rip), %rcx      # 0xd250
movzbl 0x4(%rax,%rcx), %edx
incl %eax
movl %eax, 0xbd07(%rip)      # 0xd250
movl 0xbcf5(%rip), %eax      # 0xd244
xorl %ecx, %ecx
cmpl 0xbcf5(%rip), %eax      # 0xd24c
jle 0x155f
movl %eax, 0xbced(%rip)      # 0xd24c
movq %rdx, %rax
shlq $0x20, %rax
orq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/allocate.c
// Function: push_registers
reg_list push_registers(FILE *output_file){
	reg_list output;
	int i;

	output = register_list;
	for(i = register_list.num_allocated - 1; i >= 0; i--){
		store_register(register_list.registers[i], output_file);
	}
	register_list.num_allocated = 0;

	return output;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0xbc76(%rip), %eax      # 0xd260
movl %eax, 0x10(%rdi)
movups 0xbc5c(%rip), %xmm0     # 0xd250
movups %xmm0, (%rdi)
movl 0xbc53(%rip), %eax      # 0xd250
decl %eax
js 0x166c
movq %rsi, %r14
movl %eax, %r12d
movl 0xbc37(%rip), %eax      # 0xd244
movl 0xbc39(%rip), %ecx      # 0xd24c
leaq 0xbc36(%rip), %r13      # 0xd250
leaq 0x79ff(%rip), %r15      # 0x9020
testq %r14, %r14
je 0x164a
movzbl 0x4(%r12,%r13), %edx
subl %eax, %ecx
addl $-0x4, %ecx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1100
movl 0xbc00(%rip), %eax      # 0xd244
movl 0xbc02(%rip), %ecx      # 0xd24c
addl $0x4, %eax
movl %eax, 0xbbf1(%rip)      # 0xd244
cmpl %ecx, %eax
jle 0x165f
movl %eax, 0xbbef(%rip)      # 0xd24c
movl %eax, %ecx
leaq -0x1(%r12), %rdx
testq %r12, %r12
movq %rdx, %r12
jg 0x1621
movl $0x0, 0xbbda(%rip)      # 0xd250
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/allocate.c
// Function: pull_registers
void pull_registers(reg_list regs, FILE *output_file){
	unsigned int i;

	for(i = 0; i < regs.num_allocated; i++){
		load_register(regs.registers[i], output_file);
	}

	register_list = regs;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x30(%rsp), %r15
movl (%r15), %r12d
testq %r12, %r12
je 0x16fc
movq %rdi, %rbx
movl 0xbb8b(%rip), %eax      # 0xd244
leaq 0x7972(%rip), %r14      # 0x9032
xorl %r13d, %r13d
leal -0x4(%rax), %ecx
movzbl 0x4(%r15,%r13), %edx
movl %ecx, 0xbb72(%rip)      # 0xd244
testq %rbx, %rbx
je 0x16f2
movl 0xbb6f(%rip), %ecx      # 0xd24c
subl %eax, %ecx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1100
movl 0xbb52(%rip), %ecx      # 0xd244
incq %r13
movl %ecx, %eax
cmpq %r13, %r12
jne 0x16c3
movl 0x10(%r15), %eax
movl %eax, 0xbb5a(%rip)      # 0xd260
movups (%r15), %xmm0
movups %xmm0, 0xbb3f(%rip)     # 0xd250
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/expression.c
// Function: fileprint
void fileprint(FILE *fp, const char *format, ...){
	va_list ap;

	if(do_print){
		va_start(ap, format);
		vfprintf(fp, format, ap);
		va_end(ap);
	}
}

// Assembly:
subq $0xd8, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x1772
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)
cmpb $0x0, 0xbaff(%rip)      # 0xd278
je 0x17a5
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
callq 0x1170
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/expression.c
// Function: operation_multiply_func
void operation_multiply_func(char *reg_a, char *reg_b, value *value_a, value *value_b, FILE *output_file, type *output_type){
	if((!types_equal(&(value_a->data_type), &INT_TYPE) && !types_equal(&(value_a->data_type), &CHAR_TYPE)) || (!types_equal(&(value_b->data_type), &INT_TYPE) && !types_equal(&(value_b->data_type), &CHAR_TYPE))){
		snprintf(error_message, sizeof(error_message), "Cannot multiply non-int types");
		do_error(1);
	}
	fileprint(output_file, "mult %s, %s\n", reg_a, reg_b);
	fileprint(output_file, "mflo %s\n", reg_a);
	*output_type = INT_TYPE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, (%rsp)
movq %rdi, %r12
addq $0x10, %r13
leaq 0xb4c2(%rip), %r14      # 0xd180
movq %r13, %rdi
movq %r14, %rsi
callq 0x7aec
testb %al, %al
jne 0x1ce0
leaq 0xb52c(%rip), %rsi      # 0xd200
movq %r13, %rdi
callq 0x7aec
testb %al, %al
je 0x1d0a
addq $0x10, %rbp
leaq 0xb495(%rip), %rsi      # 0xd180
movq %rbp, %rdi
callq 0x7aec
testb %al, %al
jne 0x1d30
leaq 0xb502(%rip), %rsi      # 0xd200
movq %rbp, %rdi
callq 0x7aec
testb %al, %al
jne 0x1d30
movups 0x75ab(%rip), %xmm0     # 0x92bc
leaq 0xb7c8(%rip), %rax      # 0xd4e0
movups %xmm0, 0xe(%rax)
movups 0x758b(%rip), %xmm0     # 0x92ae
movaps %xmm0, (%rax)
movl $0x1, %edi
callq 0x5b10
leaq 0x7595(%rip), %rsi      # 0x92cc
movq %r15, %rdi
movq %r12, %rdx
movq (%rsp), %rcx
xorl %eax, %eax
callq 0x171c
leaq 0x74d4(%rip), %rsi      # 0x9223
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x171c
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/expression.c
// Function: operation_divide_func
void operation_divide_func(char *reg_a, char *reg_b, value *value_a, value *value_b, FILE *output_file, type *output_type){
	if((!types_equal(&(value_a->data_type), &INT_TYPE) && !types_equal(&(value_a->data_type), &CHAR_TYPE)) || (!types_equal(&(value_b->data_type), &INT_TYPE) && !types_equal(&(value_b->data_type), &CHAR_TYPE))){
		snprintf(error_message, sizeof(error_message), "Cannot divide non-int types");
		do_error(1);
	}
	fileprint(output_file, "div %s, %s\n", reg_a, reg_b);
	fileprint(output_file, "mflo %s\n", reg_a);
	*output_type = INT_TYPE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, (%rsp)
movq %rdi, %r12
addq $0x10, %r13
leaq 0xb3ca(%rip), %r14      # 0xd180
movq %r13, %rdi
movq %r14, %rsi
callq 0x7aec
testb %al, %al
jne 0x1dd8
leaq 0xb434(%rip), %rsi      # 0xd200
movq %r13, %rdi
callq 0x7aec
testb %al, %al
je 0x1e02
addq $0x10, %rbp
leaq 0xb39d(%rip), %rsi      # 0xd180
movq %rbp, %rdi
callq 0x7aec
testb %al, %al
jne 0x1e28
leaq 0xb40a(%rip), %rsi      # 0xd200
movq %rbp, %rdi
callq 0x7aec
testb %al, %al
jne 0x1e28
movups 0x74dc(%rip), %xmm0     # 0x92e5
leaq 0xb6d0(%rip), %rax      # 0xd4e0
movups %xmm0, 0xc(%rax)
movups 0x74be(%rip), %xmm0     # 0x92d9
movaps %xmm0, (%rax)
movl $0x1, %edi
callq 0x5b10
leaq 0x74c6(%rip), %rsi      # 0x92f5
movq %r15, %rdi
movq %r12, %rdx
movq (%rsp), %rcx
xorl %eax, %eax
callq 0x171c
leaq 0x73dc(%rip), %rsi      # 0x9223
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x171c
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/expression.c
// Function: operation_modulo_func
void operation_modulo_func(char *reg_a, char *reg_b, value *value_a, value *value_b, FILE *output_file, type *output_type){
	if((!types_equal(&(value_a->data_type), &INT_TYPE) && !types_equal(&(value_a->data_type), &CHAR_TYPE)) || (!types_equal(&(value_b->data_type), &INT_TYPE) && !types_equal(&(value_b->data_type), &CHAR_TYPE))){
		snprintf(error_message, sizeof(error_message), "Cannot modulo non-int types");
		do_error(1);
	}
	fileprint(output_file, "div %s, %s\n", reg_a, reg_b);
	fileprint(output_file, "mfhi %s\n", reg_a);
	*output_type = INT_TYPE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, (%rsp)
movq %rdi, %r12
addq $0x10, %r13
leaq 0xb2d2(%rip), %r14      # 0xd180
movq %r13, %rdi
movq %r14, %rsi
callq 0x7aec
testb %al, %al
jne 0x1ed0
leaq 0xb33c(%rip), %rsi      # 0xd200
movq %r13, %rdi
callq 0x7aec
testb %al, %al
je 0x1efa
addq $0x10, %rbp
leaq 0xb2a5(%rip), %rsi      # 0xd180
movq %rbp, %rdi
callq 0x7aec
testb %al, %al
jne 0x1f20
leaq 0xb312(%rip), %rsi      # 0xd200
movq %rbp, %rdi
callq 0x7aec
testb %al, %al
jne 0x1f20
movups 0x740c(%rip), %xmm0     # 0x930d
leaq 0xb5d8(%rip), %rax      # 0xd4e0
movups %xmm0, 0xc(%rax)
movups 0x73ee(%rip), %xmm0     # 0x9301
movaps %xmm0, (%rax)
movl $0x1, %edi
callq 0x5b10
leaq 0x73ce(%rip), %rsi      # 0x92f5
movq %r15, %rdi
movq %r12, %rdx
movq (%rsp), %rcx
xorl %eax, %eax
callq 0x171c
leaq 0x73de(%rip), %rsi      # 0x931d
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x171c
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/expression.c
// Function: operation_assign_func
void operation_assign_func(char *reg_a, char *reg_b, value *value_a, value *value_b, FILE *output_file, type *output_type){
	if(!value_a->is_reference){
		snprintf(error_message, sizeof(error_message), "Cannot assign to r-value");
		do_error(1);
	}
	pop_type(&(value_a->data_type));
	if(peek_type(&(value_a->data_type)) == type_function){
		snprintf(error_message, sizeof(error_message), "Cannot assign to function");
		do_error(1);
	}
	if(type_size(&(value_a->data_type), 0) == 4){
		fileprint(output_file, "sw %s, 0(%s)\n", reg_b, reg_a);
	} else if(type_size(&(value_a->data_type), 0) == 1){
		fileprint(output_file, "sb %s, 0(%s)\n", reg_b, reg_a);
	}
	fileprint(output_file, "move %s, %s\n", reg_a, reg_b);
	*output_type = value_b->data_type;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %r13
cmpb $0x0, 0x50(%rdx)
jne 0x1fc6
movups 0x7388(%rip), %xmm0     # 0x932f
leaq 0xb532(%rip), %rax      # 0xd4e0
movups %xmm0, 0x9(%rax)
movups 0x736d(%rip), %xmm0     # 0x9326
movaps %xmm0, (%rax)
movl $0x1, %edi
callq 0x5b10
addq $0x10, %rbp
movq %rbp, %rdi
callq 0x7ab4
movq %rbp, %rdi
callq 0x7a9c
cmpl $0x5, %eax
jne 0x2005
movups 0x7363(%rip), %xmm0     # 0x9349
leaq 0xb4f3(%rip), %rax      # 0xd4e0
movups %xmm0, 0xa(%rax)
movups 0x7347(%rip), %xmm0     # 0x933f
movaps %xmm0, (%rax)
movl $0x1, %edi
callq 0x5b10
movq %rbp, %rdi
xorl %esi, %esi
callq 0x1990
cmpl $0x4, %eax
je 0x2022
cmpl $0x1, %eax
jne 0x2039
leaq 0x7347(%rip), %rsi      # 0x9367
jmp 0x2029
leaq 0x7330(%rip), %rsi      # 0x9359
movq %r12, %rdi
movq %r15, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x171c
leaq 0x7335(%rip), %rsi      # 0x9375
movq %r12, %rdi
movq %r13, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x171c
movups 0x10(%r14), %xmm0
movups 0x20(%r14), %xmm1
movups 0x30(%r14), %xmm2
movups 0x40(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/expression.c
// Function: operation_less_than_func
void operation_less_than_func(char *reg_a, char *reg_b, value *value_a, value *value_b, FILE *output_file, type *output_type){
	if((!types_equal(&(value_a->data_type), &INT_TYPE) && !types_equal(&(value_a->data_type), &CHAR_TYPE)) || (!types_equal(&(value_b->data_type), &INT_TYPE) && !types_equal(&(value_b->data_type), &CHAR_TYPE))){
		snprintf(error_message, sizeof(error_message), "Cannot compare non-int types with '<'");
		do_error(1);
	}
	fileprint(output_file, "slt %s, %s, %s\n", reg_a, reg_a, reg_b);
	*output_type = INT_TYPE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r12
movq %rcx, %rbp
movq %rdx, %r15
movq %rsi, (%rsp)
movq %rdi, %r13
addq $0x10, %r15
leaq 0xb0d5(%rip), %r14      # 0xd180
movq %r15, %rdi
movq %r14, %rsi
callq 0x7aec
testb %al, %al
jne 0x20cd
leaq 0xb13f(%rip), %rsi      # 0xd200
movq %r15, %rdi
callq 0x7aec
testb %al, %al
je 0x20f7
addq $0x10, %rbp
leaq 0xb0a8(%rip), %rsi      # 0xd180
movq %rbp, %rdi
callq 0x7aec
testb %al, %al
jne 0x212b
leaq 0xb115(%rip), %rsi      # 0xd200
movq %rbp, %rdi
callq 0x7aec
testb %al, %al
jne 0x212b
movups 0x7294(%rip), %xmm0     # 0x9392
leaq 0xb3db(%rip), %rax      # 0xd4e0
movaps %xmm0, 0x10(%rax)
movups 0x7272(%rip), %xmm0     # 0x9382
movaps %xmm0, (%rax)
movabsq $0x273c2720687469, %rcx # imm = 0x273C2720687469
movq %rcx, 0x1e(%rax)
movl $0x1, %edi
callq 0x5b10
leaq 0x7276(%rip), %rsi      # 0x93a8
movq %r12, %rdi
movq %r13, %rdx
movq %r13, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x171c
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/expression.c
// Function: operation_greater_than_func
void operation_greater_than_func(char *reg_a, char *reg_b, value *value_a, value *value_b, FILE *output_file, type *output_type){
	if((!types_equal(&(value_a->data_type), &INT_TYPE) && !types_equal(&(value_a->data_type), &CHAR_TYPE)) || (!types_equal(&(value_b->data_type), &INT_TYPE) && !types_equal(&(value_b->data_type), &CHAR_TYPE))){
		snprintf(error_message, sizeof(error_message), "Cannot compare non-int types with '>'");
		do_error(1);
	}
	fileprint(output_file, "sgt %s, %s, %s\n", reg_a, reg_a, reg_b);
	*output_type = INT_TYPE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r12
movq %rcx, %rbp
movq %rdx, %r15
movq %rsi, (%rsp)
movq %rdi, %r13
addq $0x10, %r15
leaq 0xafe0(%rip), %r14      # 0xd180
movq %r15, %rdi
movq %r14, %rsi
callq 0x7aec
testb %al, %al
jne 0x21c2
leaq 0xb04a(%rip), %rsi      # 0xd200
movq %r15, %rdi
callq 0x7aec
testb %al, %al
je 0x21ec
addq $0x10, %rbp
leaq 0xafb3(%rip), %rsi      # 0xd180
movq %rbp, %rdi
callq 0x7aec
testb %al, %al
jne 0x2220
leaq 0xb020(%rip), %rsi      # 0xd200
movq %rbp, %rdi
callq 0x7aec
testb %al, %al
jne 0x2220
movups 0x71d5(%rip), %xmm0     # 0x93c8
leaq 0xb2e6(%rip), %rax      # 0xd4e0
movaps %xmm0, 0x10(%rax)
movups 0x71b3(%rip), %xmm0     # 0x93b8
movaps %xmm0, (%rax)
movabsq $0x273e2720687469, %rcx # imm = 0x273E2720687469
movq %rcx, 0x1e(%rax)
movl $0x1, %edi
callq 0x5b10
leaq 0x71b7(%rip), %rsi      # 0x93de
movq %r12, %rdi
movq %r13, %rdx
movq %r13, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x171c
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/expression.c
// Function: operation_less_than_or_equal_func
void operation_less_than_or_equal_func(char *reg_a, char *reg_b, value *value_a, value *value_b, FILE *output_file, type *output_type){
	if((!types_equal(&(value_a->data_type), &INT_TYPE) && !types_equal(&(value_a->data_type), &CHAR_TYPE)) || (!types_equal(&(value_b->data_type), &INT_TYPE) && !types_equal(&(value_b->data_type), &CHAR_TYPE))){
		snprintf(error_message, sizeof(error_message), "Cannot compare non-int types with '<='");
		do_error(1);
	}
	fileprint(output_file, "sgt %s, %s, %s\n", reg_a, reg_a, reg_b);
	fileprint(output_file, "seq %s, %s, $zero\n", reg_a, reg_a);
	*output_type = INT_TYPE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, (%rsp)
movq %rdi, %r12
addq $0x10, %r13
leaq 0xaeeb(%rip), %r14      # 0xd180
movq %r13, %rdi
movq %r14, %rsi
callq 0x7aec
testb %al, %al
jne 0x22b7
leaq 0xaf55(%rip), %rsi      # 0xd200
movq %r13, %rdi
callq 0x7aec
testb %al, %al
je 0x22e1
addq $0x10, %rbp
leaq 0xaebe(%rip), %rsi      # 0xd180
movq %rbp, %rdi
callq 0x7aec
testb %al, %al
jne 0x2315
leaq 0xaf2b(%rip), %rsi      # 0xd200
movq %rbp, %rdi
callq 0x7aec
testb %al, %al
jne 0x2315
movups 0x7116(%rip), %xmm0     # 0x93fe
leaq 0xb1f1(%rip), %rax      # 0xd4e0
movaps %xmm0, 0x10(%rax)
movups 0x70f4(%rip), %xmm0     # 0x93ee
movaps %xmm0, (%rax)
movabsq $0x273d3c27206874, %rcx # imm = 0x273D3C27206874
movq %rcx, 0x1f(%rax)
movl $0x1, %edi
callq 0x5b10
leaq 0x70c2(%rip), %rsi      # 0x93de
movq %r15, %rdi
movq %r12, %rdx
movq %r12, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x171c
leaq 0x70de(%rip), %rsi      # 0x9415
movq %r15, %rdi
movq %r12, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x171c
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq