LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
movaps 0x356e(%rip), %xmm0     # 0xd440
movups %xmm0, (%rax)
movabsq $0x2000300000010, %rax  # imm = 0x2000300000010
movq %rax, 0x10(%rbx)
movl %ebp, 0x18(%rbx)
shll $0x3, %ebp
movl %ebp, 0x1c(%rbx)
movl $0x200008, 0x20(%rbx)   # imm = 0x200008
movq $0x61746164, 0x24(%rbx) # imm = 0x61746164
movq $0x0, 0x30(%rbx)
movl $0x0, 0x38(%rbx)
leaq 0x38be(%rip), %rsi      # 0xd7cf
movq %r14, %rdi
callq 0x51d0
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x9f3f
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 0x70a2(%rip), %rax      # 0x10fe8
movq (%rax), %rdi
leaq 0x3500(%rip), %rsi      # 0xd450
xorl %ebx, %ebx
movq %r14, %rdx
xorl %eax, %eax
callq 0x5570
jmp 0x9f37
// File: /workspace/github_c_makefile_star2_O1/baines[P]MiniGBS/wav_write.c
// Function: wav_write_end
void wav_write_end(struct wav_writer* wav) {

	uint32_t size = 36 + wav->data_size;
	fseek(wav->file, 4, SEEK_SET);
	fwrite(&size, 4, 1, wav->file);

	fseek(wav->file, 40, SEEK_SET);
	fwrite(&wav->data_size, 4, 1, wav->file);

	fflush(wav->file);
	fclose(wav->file);

	free(wav);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
movl 0x38(%rdi), %eax
addl $0x24, %eax
leaq 0xc(%rsp), %r15
movl %eax, (%r15)
movq 0x30(%rdi), %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x5130
movq 0x30(%rbx), %rcx
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
callq 0x5500
movq 0x30(%rbx), %rdi
movl $0x28, %esi
xorl %edx, %edx
callq 0x5130
movq 0x30(%rbx), %rcx
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rdi
callq 0x5500
movq 0x30(%rbx), %rdi
callq 0x55c0
movq 0x30(%rbx), %rdi
callq 0x54b0
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x5250
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x7385(%rip), %rcx      # 0x11398
addq $0x3c, %rcx
leaq 0x77b2(%rip), %rax      # 0x117d0
leaq 0x85bb(%rip), %rdx      # 0x125e0
cmpq %rdx, %rcx
cmovbq %rcx, %rax
movq %rax, 0x7365(%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 0xa062
movl $0x1, %esi
shll %cl, %esi
addl $-0x5, %edx
orb %sil, (%rax,%rdx)
incq %rcx
cmpq $0x3, %rcx
jne 0xa047
retq
// File: /workspace/github_c_makefile_star2_O1/baines[P]MiniGBS/ui.c
// Function: ui_msg_set
void ui_msg_set(const char* fmt, ...){
	va_list va;
	va_start(va, fmt);

	vsnprintf(msg, sizeof(msg), fmt, va);

	msg_timer = 20;
	va_end(va);
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0xa0ca
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %rdi, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rcx)
leaq 0x84ef(%rip), %rdi      # 0x125e0
movl $0x80, %esi
movq %r10, %rdx
callq 0x53f0
movl $0x14, 0x8558(%rip)     # 0x12660
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x731c(%rip), %rbx      # 0x11448
cmpb $0x0, 0x5(%rbx)
je 0xa13f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x5320
callq 0x5170
callq 0x54c0
movq 0x6e7b(%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 0xa2c2
callq 0x5480
callq 0x53c0
testb %al, %al
je 0xa1c1
movq 0x6e3a(%rip), %rax      # 0x10fe0
cmpl $0x65, (%rax)
jl 0xa1c1
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), %rax
testq %rax, %rax
je 0xa2db
movswl 0x4(%rax), %ecx
incl %ecx
movl %ecx, 0x2c(%rbx)
movswl 0x6(%rax), %eax
incl %eax
jmp 0xa2e7
movl $0xffffffff, 0x2c(%rbx) # imm = 0xFFFFFFFF
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb304
// File: /workspace/github_c_makefile_star2_O1/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 0x8421(%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 0xa39b
leaq (,%r12,4), %rax
subq %rax, %rbx
addq $0x1900, %rbx           # imm = 0x1900
xorl %eax, %eax
movss 0x30e8(%rip), %xmm0     # 0xd460
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 0xa378
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x64f5(%rip), %r14      # 0x11448
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpb $0x0, 0x5(%r14)
jne 0xb029
cmpl $0x107, %edi            # imm = 0x107
je 0xafd9
cmpl $0xa, %edi
jne 0xaffd
movb 0xdbb5(%rip), %bpl      # 0x18b30
cmpb $0x1, %bpl
jne 0xaf98
cmpb $0x0, 0xdbb8(%rip)      # 0x18b40
je 0xaf98
leaq 0xdbaf(%rip), %rdi      # 0x18b40
callq 0x53a0
movl %eax, %ebx
leaq 0xdba1(%rip), %rax      # 0x18b40
movq %rax, 0x63fa(%rip)      # 0x113a0
movb $0x0, 0xdb93(%rip)      # 0x18b40
xorb $0x1, %bpl
movb %bpl, 0xdb78(%rip)      # 0x18b30
movq 0x6011(%rip), %r15      # 0x10fd0
movq (%r15), %rdi
movl 0x2c(%r14), %esi
decl %esi
xorl %edx, %edx
callq 0x5210
movq (%r15), %rdi
callq 0x5220
jmp 0xb029
movq 0x63c0(%rip), %rax      # 0x113a0
leaq 0xdb59(%rip), %rcx      # 0x18b40
cmpq %rcx, %rax
je 0xb029
leaq -0x1(%rax), %rcx
movq %rcx, 0x63a9(%rip)      # 0x113a0
movb $0x0, -0x1(%rax)
jmp 0xb029
movq 0x639c(%rip), %rax      # 0x113a0
leaq 0xdb35(%rip), %rcx      # 0x18b40
movq %rax, %rdx
subq %rcx, %rdx
cmpq $0x1f, %rdx
ja 0xb029
leaq 0x1(%rax), %rcx
movq %rcx, 0x637e(%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_O1/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, 0xd5f8(%rip)      # 0x18c10
je 0xb68f
movq 0xd5e7(%rip), %rdi      # 0x18c08
callq *0xd5b1(%rip)           # 0x18bd8
testl %eax, %eax
je 0xb68f
movq 0xd5d6(%rip), %rdi      # 0x18c08
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq *0xd5a0(%rip)           # 0x18be0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl (%r14), %eax
cmpl $0x21, %eax
je 0xb6a4
cmpl $0x2, %eax
jne 0xb697
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq *0xd589(%rip)           # 0x18be8
movl $0x6f, %ebx
cmpq $0xff0c, %rax           # imm = 0xFF0C
jg 0xb6cf
cmpq $0x63, %rax
je 0xb705
cmpq $0x71, %rax
je 0xb697
cmpq $0xff08, %rax           # imm = 0xFF08
jne 0xb711
movl $0x107, %ebx            # imm = 0x107
jmp 0xb697
movb $0x0, (%rbx)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
movq 0x40(%rsp), %rax
cmpq 0xd588(%rip), %rax      # 0x18c38
jne 0xb697
movq 0xd54f(%rip), %rdi      # 0x18c08
movq 0xd550(%rip), %rsi      # 0x18c10
callq *0xd4c2(%rip)           # 0x18b88
movb $0x0, 0xd573(%rip)      # 0x18c40
jmp 0xb697
leaq -0xff51(%rax), %rcx
cmpq $0x3, %rcx
ja 0xb6f3
leaq 0x2039(%rip), %rax      # 0xd71c
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x104, %ebx            # imm = 0x104
jmp 0xb697
cmpq $0xff0d, %rax           # imm = 0xFF0D
je 0xb715
cmpq $0xff1b, %rax           # imm = 0xFF1B
je 0xb697
jmp 0xb711
movl $0x71, %ebx
testb $0x4, 0x58(%rsp)
jne 0xb697
movl %eax, %ebx
jmp 0xb697
movl $0xa, %ebx
jmp 0xb697
movl $0x105, %ebx            # imm = 0x105
jmp 0xb697
movl $0x102, %ebx            # imm = 0x102
jmp 0xb697
movl $0x103, %ebx            # imm = 0x103
jmp 0xb697
// File: /workspace/github_c_makefile_star2_O1/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, 0xd449(%rip)      # 0x18c10
je 0xb837
cmpb $0x1, 0xd470(%rip)      # 0x18c40
jne 0xb837
movq 0xd42f(%rip), %rdi      # 0x18c08
movzbl 0xd438(%rip), %esi      # 0x18c18
movl $0x48, %edx
callq *0xd415(%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 0xd408(%rip), %ecx      # 0x18c10
movl %ecx, 0x4(%rax)
movl 0xd40f(%rip), %ecx      # 0x18c20
movl %ecx, 0x8(%rax)
movq 0xd3ed(%rip), %rdi      # 0x18c08
movq 0xd0(%rdi), %rax
testq %rax, %rax
je 0xb829
callq *%rax
movq 0xd3d8(%rip), %rdi      # 0x18c08
popq %rax
jmpq *0xd391(%rip)           # 0x18bc8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd3cf(%rip), %rsi      # 0x18c10
testq %rsi, %rsi
je 0xb874
movzbl 0xd3f3(%rip), %eax      # 0x18c40
movq 0xd3b4(%rip), %rdi      # 0x18c08
leaq 0xd315(%rip), %rcx      # 0x18b70
callq *0x10(%rcx,%rax,8)
xorb $0x1, 0xd3da(%rip)      # 0x18c40
movq 0xd39b(%rip), %rdi      # 0x18c08
popq %rax
jmpq *0xd354(%rip)           # 0x18bc8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe82(%rip), %rdi       # 0x21be
callq 0x214c
movq (%rbx), %rdi
callq 0x2159
callq 0x10d0
movl %eax, %edi
callq 0x21ad
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 0x2127
leaq 0x1d9e(%rip), %rsi      # 0x3129
leaq 0x1d75(%rip), %rcx      # 0x3107
movl $0x7c, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1ee0
xorl %r14d, %r14d
movl $0x11, %edi
xorl %esi, %esi
callq 0x26b0
cmpl $0x2, %ebp
jl 0x13ed
movl %ebp, 0x3d81(%rip)      # 0x513c
movq %rbx, 0x3d7e(%rip)      # 0x5140
movl $0x1, 0x3d7c(%rip)      # 0x5148
callq 0x13fa
movl %eax, %r14d
testb %al, %al
je 0x13ed
movl 0x3d6a(%rip), %eax      # 0x5148
cmpl 0x3d58(%rip), %eax      # 0x513c
jge 0x13ed
xorl %edi, %edi
callq 0x144b
xorb $0x1, %r14b
movzbl %r14b, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
xorl %r14d, %r14d
leaq 0x1d17(%rip), %rbx      # 0x311f
callq 0x1638
movl %eax, %ebp
movl $0x1, %edi
callq 0x16cb
testq %rax, %rax
je 0x1437
cmpb $0x2d, (%rax)
jne 0x1437
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1170
testl %eax, %eax
jne 0x1437
orb %bpl, %r14b
jmp 0x1408
decl 0x3d0b(%rip)            # 0x5148
orb %r14b, %bpl
andb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movb $0x1, %r15b
leaq 0x1ad9(%rip), %rbx      # 0x3122
leaq 0x1c56(%rip), %r14      # 0x32a6
movl $0x1, %edi
callq 0x16cb
testq %rax, %rax
je 0x1673
cmpb $0x21, (%rax)
jne 0x1673
movq %rax, %rdi
movq %r14, %rsi
callq 0x1170
testl %eax, %eax
je 0x16a8
decl 0x3acf(%rip)            # 0x5148
callq 0x1769
movl %eax, %ebp
movl $0x1, %edi
callq 0x16cb
testq %rax, %rax
je 0x16b5
cmpb $0x2d, (%rax)
jne 0x16b5
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1170
testl %eax, %eax
jne 0x16b5
andb %bpl, %r15b
jmp 0x1650
callq 0x1769
movl %eax, %ebp
xorb $0x1, %bpl
jmp 0x1680
decl 0x3a8d(%rip)            # 0x5148
andb %r15b, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3a74(%rip), %eax      # 0x5148
testl %eax, %eax
jle 0x16e0
cmpl 0x3a5e(%rip), %eax      # 0x513c
jle 0x1702
callq 0x2127
leaq 0x1a3d(%rip), %rsi      # 0x3129
leaq 0x1aee(%rip), %rcx      # 0x31e1
movl $0x7c, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1ee0
movl 0x3a40(%rip), %ecx      # 0x5148
cmpl 0x3a2e(%rip), %ecx      # 0x513c
jne 0x174d
testb %bl, %bl
je 0x1718
xorl %eax, %eax
jmp 0x175f
callq 0x2127
movq 0x3a1c(%rip), %rcx      # 0x5140
movslq 0x3a1d(%rip), %rdx      # 0x5148
movq -0x8(%rcx,%rdx,8), %rcx
leaq 0x19ee(%rip), %rsi      # 0x3125
leaq 0x1ab6(%rip), %r8       # 0x31f4
movl $0x7c, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1ee0
movq 0x39ec(%rip), %rax      # 0x5140
movslq 0x39ed(%rip), %rcx      # 0x5148
movq (%rax,%rcx,8), %rax
incl %ecx
movl %ecx, 0x39e1(%rip)      # 0x5148
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8d59(%rip), %rsi      # 0x9f36
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), %rax      # 0xd5f0
movb (%r15), %cl
testb %cl, %cl
sete %dl
cmpq %rax, %r15
sete %sil
orb %dl, %sil
jne 0x124e
incq %r15
movq %r15, %rdx
cmpb $0x20, %cl
je 0x1231
movzbl %cl, %ecx
cmpl $0x9, %ecx
jne 0x1248
movb (%rdx), %cl
leaq 0x1(%rdx), %r15
testb %cl, %cl
je 0x1243
cmpq %rax, %rdx
movq %r15, %rdx
jne 0x1224
decq %r15
jmp 0x124e
decq %rdx
movq %rdx, %r15
movq %r15, %rbx
movzbl (%rbx), %eax
testl %eax, %eax
je 0x126d
cmpl $0xa, %eax
je 0x126d
movsbl %al, %edi
movq (%r14), %rsi
callq 0x10e0
incq %rbx
jmp 0x1251
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x10e0
cmpq 0xc371(%rip), %r15      # 0xd5f0
je 0x129a
pushq $0x20
popq %rbx
movq (%r14), %rsi
movl %ebx, %edi
callq 0x10e0
incq %r15
cmpq 0xc358(%rip), %r15      # 0xd5f0
jne 0x1284
movq (%r14), %rcx
leaq 0x8ca2(%rip), %rdi      # 0x9f46
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O1/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 0x154b
movl %eax, %eax
leaq 0xbd14(%rip), %rcx      # 0xd250
movzbl 0x4(%rax,%rcx), %edx
incl %eax
movl %eax, 0xbd07(%rip)      # 0xd250
xorl %ecx, %ecx
movl 0xbcf3(%rip), %eax      # 0xd244
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_O1/been-jamming[P]MinimalCC/allocate.c
// Function: deallocate
void deallocate(data_entry entry){
	unsigned int temp;

	if(entry.type == data_register){
		register_list.num_allocated--;
		temp = register_list.registers[register_list.num_allocated];
		register_list.registers[register_list.num_allocated] = entry.reg;
		register_list.registers[register_list.positions[entry.reg]] = temp;
		register_list.positions[temp] = register_list.positions[entry.reg];
		register_list.positions[entry.reg] = register_list.num_allocated;
	} else if(entry.type == data_stack){
		stack_size = entry.prev_stack_size;
	}
}

// Assembly:
cmpl $0x1, %edi
je 0x15b3
testl %edi, %edi
jne 0x15b9
movq %rdi, %rax
shrq $0x20, %rax
leaq 0xbccf(%rip), %rcx      # 0xd250
movl 0xbcc9(%rip), %edx      # 0xd250
decl %edx
movl %edx, 0xbcc1(%rip)      # 0xd250
movzbl 0x4(%rdx,%rcx), %esi
movb %al, 0x4(%rdx,%rcx)
sarq $0x20, %rdi
movzbl 0xc(%rdi,%rcx), %eax
movb %sil, 0x4(%rax,%rcx)
movb 0xc(%rdi,%rcx), %al
movb %al, 0xc(%rsi,%rcx)
movb %dl, 0xc(%rdi,%rcx)
retq
movl %esi, 0xbc8b(%rip)      # 0xd244
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1666
movq %rsi, %r14
movl %eax, %r12d
leaq 0xbc42(%rip), %r13      # 0xd250
leaq 0x7a0b(%rip), %r15      # 0x9020
testq %r14, %r14
je 0x163c
movzbl 0x4(%r12,%r13), %edx
movl 0xbc26(%rip), %ecx      # 0xd24c
subl 0xbc18(%rip), %ecx      # 0xd244
addl $-0x4, %ecx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1100
movl 0xbc02(%rip), %eax      # 0xd244
addl $0x4, %eax
movl %eax, 0xbbf9(%rip)      # 0xd244
cmpl 0xbbfb(%rip), %eax      # 0xd24c
jle 0x1659
movl %eax, 0xbbf3(%rip)      # 0xd24c
leaq -0x1(%r12), %rax
testq %r12, %r12
movq %rax, %r12
jg 0x1615
movl $0x0, 0xbbe0(%rip)      # 0xd250
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16ee
movq %rdi, %rbx
leaq 0x797e(%rip), %r14      # 0x9032
xorl %r13d, %r13d
movl 0xbb87(%rip), %eax      # 0xd244
leal -0x4(%rax), %ecx
movzbl 0x4(%r15,%r13), %edx
movl %ecx, 0xbb78(%rip)      # 0xd244
testq %rbx, %rbx
je 0x16e6
movl 0xbb75(%rip), %ecx      # 0xd24c
subl %eax, %ecx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1100
incq %r13
cmpq %r13, %r12
jne 0x16b7
movl 0x10(%r15), %eax
movl %eax, 0xbb68(%rip)      # 0xd260
movups (%r15), %xmm0
movups %xmm0, 0xbb4d(%rip)     # 0xd250
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x1766
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, 0xbb0b(%rip)      # 0xd278
je 0x1799
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_O1/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 0xb4ce(%rip), %r14      # 0xd180
movq %r13, %rdi
movq %r14, %rsi
callq 0x7ab1
testb %al, %al
jne 0x1cd4
leaq 0xb538(%rip), %rsi      # 0xd200
movq %r13, %rdi
callq 0x7ab1
testb %al, %al
je 0x1cfe
addq $0x10, %rbp
leaq 0xb4a1(%rip), %rsi      # 0xd180
movq %rbp, %rdi
callq 0x7ab1
testb %al, %al
jne 0x1d24
leaq 0xb50e(%rip), %rsi      # 0xd200
movq %rbp, %rdi
callq 0x7ab1
testb %al, %al
jne 0x1d24
movups 0x75b7(%rip), %xmm0     # 0x92bc
leaq 0xb7d4(%rip), %rax      # 0xd4e0
movups %xmm0, 0xe(%rax)
movups 0x7597(%rip), %xmm0     # 0x92ae
movaps %xmm0, (%rax)
movl $0x1, %edi
callq 0x5ae0
leaq 0x75a1(%rip), %rsi      # 0x92cc
movq %r15, %rdi
movq %r12, %rdx
movq (%rsp), %rcx
xorl %eax, %eax
callq 0x1710
leaq 0x74e0(%rip), %rsi      # 0x9223
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1710
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_O1/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 0xb3d6(%rip), %r14      # 0xd180
movq %r13, %rdi
movq %r14, %rsi
callq 0x7ab1
testb %al, %al
jne 0x1dcc
leaq 0xb440(%rip), %rsi      # 0xd200
movq %r13, %rdi
callq 0x7ab1
testb %al, %al
je 0x1df6
addq $0x10, %rbp
leaq 0xb3a9(%rip), %rsi      # 0xd180
movq %rbp, %rdi
callq 0x7ab1
testb %al, %al
jne 0x1e1c
leaq 0xb416(%rip), %rsi      # 0xd200
movq %rbp, %rdi
callq 0x7ab1
testb %al, %al
jne 0x1e1c
movups 0x74e8(%rip), %xmm0     # 0x92e5
leaq 0xb6dc(%rip), %rax      # 0xd4e0
movups %xmm0, 0xc(%rax)
movups 0x74ca(%rip), %xmm0     # 0x92d9
movaps %xmm0, (%rax)
movl $0x1, %edi
callq 0x5ae0
leaq 0x74d2(%rip), %rsi      # 0x92f5
movq %r15, %rdi
movq %r12, %rdx
movq (%rsp), %rcx
xorl %eax, %eax
callq 0x1710
leaq 0x73e8(%rip), %rsi      # 0x9223
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1710
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_O1/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 0xb2de(%rip), %r14      # 0xd180
movq %r13, %rdi
movq %r14, %rsi
callq 0x7ab1
testb %al, %al
jne 0x1ec4
leaq 0xb348(%rip), %rsi      # 0xd200
movq %r13, %rdi
callq 0x7ab1
testb %al, %al
je 0x1eee
addq $0x10, %rbp
leaq 0xb2b1(%rip), %rsi      # 0xd180
movq %rbp, %rdi
callq 0x7ab1
testb %al, %al
jne 0x1f14
leaq 0xb31e(%rip), %rsi      # 0xd200
movq %rbp, %rdi
callq 0x7ab1
testb %al, %al
jne 0x1f14
movups 0x7418(%rip), %xmm0     # 0x930d
leaq 0xb5e4(%rip), %rax      # 0xd4e0
movups %xmm0, 0xc(%rax)
movups 0x73fa(%rip), %xmm0     # 0x9301
movaps %xmm0, (%rax)
movl $0x1, %edi
callq 0x5ae0
leaq 0x73da(%rip), %rsi      # 0x92f5
movq %r15, %rdi
movq %r12, %rdx
movq (%rsp), %rcx
xorl %eax, %eax
callq 0x1710
leaq 0x73ea(%rip), %rsi      # 0x931d
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1710
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_O1/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 0x1fba
movups 0x7394(%rip), %xmm0     # 0x932f
leaq 0xb53e(%rip), %rax      # 0xd4e0
movups %xmm0, 0x9(%rax)
movups 0x7379(%rip), %xmm0     # 0x9326
movaps %xmm0, (%rax)
movl $0x1, %edi
callq 0x5ae0
addq $0x10, %rbp
movq %rbp, %rdi
callq 0x7a79
movq %rbp, %rdi
callq 0x7a61
cmpl $0x5, %eax
jne 0x1ff9
movups 0x736f(%rip), %xmm0     # 0x9349
leaq 0xb4ff(%rip), %rax      # 0xd4e0
movups %xmm0, 0xa(%rax)
movups 0x7353(%rip), %xmm0     # 0x933f
movaps %xmm0, (%rax)
movl $0x1, %edi
callq 0x5ae0
movq %rbp, %rdi
xorl %esi, %esi
callq 0x1984
cmpl $0x4, %eax
je 0x2016
cmpl $0x1, %eax
jne 0x202d
leaq 0x7353(%rip), %rsi      # 0x9367
jmp 0x201d
leaq 0x733c(%rip), %rsi      # 0x9359
movq %r12, %rdi
movq %r15, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x1710
leaq 0x7341(%rip), %rsi      # 0x9375
movq %r12, %rdi
movq %r13, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1710
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_O1/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 0xb0e1(%rip), %r14      # 0xd180
movq %r15, %rdi
movq %r14, %rsi
callq 0x7ab1
testb %al, %al
jne 0x20c1
leaq 0xb14b(%rip), %rsi      # 0xd200
movq %r15, %rdi
callq 0x7ab1
testb %al, %al
je 0x20eb
addq $0x10, %rbp
leaq 0xb0b4(%rip), %rsi      # 0xd180
movq %rbp, %rdi
callq 0x7ab1
testb %al, %al
jne 0x211f
leaq 0xb121(%rip), %rsi      # 0xd200
movq %rbp, %rdi
callq 0x7ab1
testb %al, %al
jne 0x211f
movups 0x72a0(%rip), %xmm0     # 0x9392
leaq 0xb3e7(%rip), %rax      # 0xd4e0
movaps %xmm0, 0x10(%rax)
movups 0x727e(%rip), %xmm0     # 0x9382
movaps %xmm0, (%rax)
movabsq $0x273c2720687469, %rcx # imm = 0x273C2720687469
movq %rcx, 0x1e(%rax)
movl $0x1, %edi
callq 0x5ae0
leaq 0x7282(%rip), %rsi      # 0x93a8
movq %r12, %rdi
movq %r13, %rdx
movq %r13, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x1710
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_O1/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 0xafec(%rip), %r14      # 0xd180
movq %r15, %rdi
movq %r14, %rsi
callq 0x7ab1
testb %al, %al
jne 0x21b6
leaq 0xb056(%rip), %rsi      # 0xd200
movq %r15, %rdi
callq 0x7ab1
testb %al, %al
je 0x21e0
addq $0x10, %rbp
leaq 0xafbf(%rip), %rsi      # 0xd180
movq %rbp, %rdi
callq 0x7ab1
testb %al, %al
jne 0x2214
leaq 0xb02c(%rip), %rsi      # 0xd200
movq %rbp, %rdi
callq 0x7ab1
testb %al, %al
jne 0x2214
movups 0x71e1(%rip), %xmm0     # 0x93c8
leaq 0xb2f2(%rip), %rax      # 0xd4e0
movaps %xmm0, 0x10(%rax)
movups 0x71bf(%rip), %xmm0     # 0x93b8
movaps %xmm0, (%rax)
movabsq $0x273e2720687469, %rcx # imm = 0x273E2720687469
movq %rcx, 0x1e(%rax)
movl $0x1, %edi
callq 0x5ae0
leaq 0x71c3(%rip), %rsi      # 0x93de
movq %r12, %rdi
movq %r13, %rdx
movq %r13, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x1710
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_O1/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 0xaef7(%rip), %r14      # 0xd180
movq %r13, %rdi
movq %r14, %rsi
callq 0x7ab1
testb %al, %al
jne 0x22ab
leaq 0xaf61(%rip), %rsi      # 0xd200
movq %r13, %rdi
callq 0x7ab1
testb %al, %al
je 0x22d5
addq $0x10, %rbp
leaq 0xaeca(%rip), %rsi      # 0xd180
movq %rbp, %rdi
callq 0x7ab1
testb %al, %al
jne 0x2309
leaq 0xaf37(%rip), %rsi      # 0xd200
movq %rbp, %rdi
callq 0x7ab1
testb %al, %al
jne 0x2309
movups 0x7122(%rip), %xmm0     # 0x93fe
leaq 0xb1fd(%rip), %rax      # 0xd4e0
movaps %xmm0, 0x10(%rax)
movups 0x7100(%rip), %xmm0     # 0x93ee
movaps %xmm0, (%rax)
movabsq $0x273d3c27206874, %rcx # imm = 0x273D3C27206874
movq %rcx, 0x1f(%rax)
movl $0x1, %edi
callq 0x5ae0
leaq 0x70ce(%rip), %rsi      # 0x93de
movq %r15, %rdi
movq %r12, %rdx
movq %r12, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x1710
leaq 0x70ea(%rip), %rsi      # 0x9415
movq %r15, %rdi
movq %r12, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x1710
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_O1/been-jamming[P]MinimalCC/expression.c
// Function: operation_greater_than_or_equal_func
void operation_greater_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, "slt %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 0xadeb(%rip), %r14      # 0xd180
movq %r13, %rdi
movq %r14, %rsi
callq 0x7ab1
testb %al, %al
jne 0x23b7
leaq 0xae55(%rip), %rsi      # 0xd200
movq %r13, %rdi
callq 0x7ab1
testb %al, %al
je 0x23e1
addq $0x10, %rbp
leaq 0xadbe(%rip), %rsi      # 0xd180
movq %rbp, %rdi
callq 0x7ab1
testb %al, %al
jne 0x2415
leaq 0xae2b(%rip), %rsi      # 0xd200
movq %rbp, %rdi
callq 0x7ab1
testb %al, %al
jne 0x2415
movups 0x7050(%rip), %xmm0     # 0x9438
leaq 0xb0f1(%rip), %rax      # 0xd4e0
movaps %xmm0, 0x10(%rax)
movups 0x702e(%rip), %xmm0     # 0x9428
movaps %xmm0, (%rax)
movabsq $0x273d3e27206874, %rcx # imm = 0x273D3E27206874
movq %rcx, 0x1f(%rax)
movl $0x1, %edi
callq 0x5ae0
leaq 0x6f8c(%rip), %rsi      # 0x93a8
movq %r15, %rdi
movq %r12, %rdx
movq %r12, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x1710
leaq 0x6fde(%rip), %rsi      # 0x9415
movq %r15, %rdi
movq %r12, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x1710
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_O1/been-jamming[P]MinimalCC/expression.c
// Function: operation_equals_func
void operation_equals_func(char *reg_a, char *reg_b, value *value_a, value *value_b, FILE *output_file, type *output_type){
	if(peek_type(&(value_a->data_type)) == type_function || peek_type(&(value_b->data_type)) == type_function){
		snprintf(error_message, sizeof(error_message), "Cannot compare function types");
		do_error(1);
	}
	if(peek_type(&(value_a->data_type)) == type_pointer){
		if(peek_type(&(value_b->data_type)) == type_pointer){
			pop_type(&(value_a->data_type));
			pop_type(&(value_b->data_type));
			if(!types_equal(&(value_a->data_type), &(value_b->data_type))){
				snprintf(warning_message, sizeof(warning_message), "Comparing incompatible data types");
				do_warning();
			}
			fileprint(output_file, "seq %s, %s, %s\n", reg_a, reg_a, reg_b);
			*output_type = INT_TYPE;
		} else {
			snprintf(warning_message, sizeof(warning_message), "Comparing pointer and non-pointer types");
			do_warning();
			fileprint(output_file, "seq %s, %s, %s\n", reg_a, reg_a, reg_b);
			*output_type = INT_TYPE;
		}
	} else {
		if(peek_type(&(value_b->data_type)) == type_pointer){
			snprintf(warning_message, sizeof(warning_message), "Comparing pointer and non-pointer types");
			do_warning();
		}
		fileprint(output_file, "seq %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, %r15
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, (%rsp)
movq %rdi, %r12
addq $0x10, %rbp
movq %rbp, %rdi
callq 0x7a61
cmpl $0x5, %eax
je 0x24b5
leaq 0x10(%r13), %rdi
callq 0x7a61
cmpl $0x5, %eax
jne 0x24db
movups 0x6fa1(%rip), %xmm0     # 0x945d
leaq 0xb01d(%rip), %rax      # 0xd4e0
movups %xmm0, 0xe(%rax)
movups 0x6f81(%rip), %xmm0     # 0x944f
movaps %xmm0, (%rax)
movl $0x1, %edi
callq 0x5ae0
movq %rbp, %rdi
callq 0x7a61
movl %eax, %r14d
addq $0x10, %r13
movq %r13, %rdi
callq 0x7a61
cmpl $0x4, %r14d
jne 0x2540
cmpl $0x4, %eax
jne 0x2545
movq %rbp, %rdi
callq 0x7a79
movq %r13, %rdi
callq 0x7a79
movq %rbp, %rdi
movq %r13, %rsi
callq 0x7ab1
testb %al, %al
jne 0x2576
movups 0x6f5a(%rip), %xmm0     # 0x947d
leaq 0xaeb6(%rip), %rax      # 0xd3e0
movaps %xmm0, 0x10(%rax)
movups 0x6f38(%rip), %xmm0     # 0x946d
movaps %xmm0, (%rax)
movw $0x73, 0x20(%rax)
jmp 0x256f
cmpl $0x4, %eax
jne 0x2576
movups 0x6f63(%rip), %xmm0     # 0x94af
leaq 0xae8d(%rip), %rax      # 0xd3e0
movaps %xmm0, 0x10(%rax)
movups 0x6f41(%rip), %xmm0     # 0x949f
movaps %xmm0, (%rax)
movabsq $0x73657079742072, %rcx # imm = 0x73657079742072
movq %rcx, 0x20(%rax)
xorl %eax, %eax
callq 0x5ac8
leaq 0x6f12(%rip), %rsi      # 0x948f
movq %r15, %rdi
movq %r12, %rdx
movq %r12, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x1710
leaq 0xabe8(%rip), %rax      # 0xd180
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %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