LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/adelciotto[P]scg/examples/image.c
// Function: main
int main(int arcg, char *argv[]) {
    scg_config_t config = scg_config_new_default();
    config.video.title = "SCG Example: Image";

    scg_app_t app;
    scg_app_init(&app, config);

    scg_image_t *image = scg_image_new_from_bmp("assets/ball.bmp");
    if (image == NULL) {
        return -1;
    }

    while (scg_app_process_events(&app)) {
        draw(app.draw_target, image);

        scg_app_present(&app);
    }

    scg_image_free(image);
    scg_app_free(&app);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movabsq $0x1e000000280, %rax    # imm = 0x1E000000280
movq %rax, 0x48(%rsp)
movl $0x1, 0x58(%rsp)
xorl %eax, %eax
movb %al, 0x5c(%rsp)
movl $0x1010101, 0x5d(%rsp)  # imm = 0x1010101
movb %al, 0x64(%rsp)
movl $0x40, 0x68(%rsp)
leaq 0x1499(%rip), %rax      # 0x65ac
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x48(%rsp), %xmm0
movups 0x58(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x70(%rsp), %rdi
callq 0x3dc3
leaq 0x1479(%rip), %rdi      # 0x65bf
callq 0x2911
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x52c2
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0x4858
testb %al, %al
je 0x52aa
movq 0xa8(%rsp), %r13
movl (%r13), %eax
movl 0x4(%r13), %ecx
movq 0x28(%rsp), %rdx
movl (%rdx), %ebp
movl 0x4(%rdx), %edi
movq %rdi, 0x38(%rsp)
cltd
pushq $0x2
popq %rsi
idivl %esi
movl %eax, %r12d
movq %r12, 0x40(%rsp)
movl %ebp, %eax
cltd
idivl %esi
movl %eax, %ebx
subl %eax, %r12d
movl %ecx, %eax
cltd
idivl %esi
movl %eax, %r15d
movl %edi, %eax
cltd
pushq $-0x2
popq %rcx
idivl %ecx
addl %eax, %r15d
movl %r12d, %r14d
subl %ebp, %r14d
leal -0x20(%r14), %eax
movl %eax, 0x30(%rsp)
leal (%r12,%rbp), %eax
addl $0x20, %eax
movl %eax, 0x34(%rsp)
movq %r13, %rdi
movl $0xff008080, %esi       # imm = 0xFF008080
callq 0x2c56
leal (%r14,%rbx), %edx
addl $-0x20, %edx
movq 0x38(%rsp), %rax
leal 0x10(%rax,%r15), %ebx
movq %r13, %rdi
leaq 0x1fc9(%rip), %rsi      # 0x71c2
movl %ebx, %ecx
pushq $0x1
popq %r8
pushq $-0x1
popq %r9
callq 0x38fd
movq %r13, %rdi
leaq 0x1fb5(%rip), %rsi      # 0x71c7
movq 0x40(%rsp), %r14
movl %r14d, %edx
movl %ebx, %ecx
pushq $0x1
popq %r8
pushq $-0x1
popq %r9
callq 0x38fd
leal (%r14,%rbp), %edx
addl $0x20, %edx
movq %r13, %rdi
leaq 0x1f93(%rip), %rsi      # 0x71cd
movl %ebx, %ecx
leaq 0x70(%rsp), %rbx
pushq $0x1
popq %r8
pushq $-0x1
popq %r9
callq 0x38fd
andl $0x0, 0x18(%r13)
movq %r13, %rdi
movq 0x28(%rsp), %r14
movq %r14, %rsi
movl 0x30(%rsp), %edx
movl %r15d, %ecx
callq 0x2c75
movl $0x2, 0x18(%r13)
movq %r13, %rdi
movq %r14, %rsi
movl %r12d, %edx
movl %r15d, %ecx
callq 0x2c75
movl $0x1, 0x18(%r13)
movq %r13, %rdi
movq %r14, %rsi
movl 0x34(%rsp), %edx
movl %r15d, %ecx
callq 0x2c75
movq %rbx, %rdi
callq 0x491f
jmp 0x515e
movq 0x28(%rsp), %rdi
callq 0x3bb8
leaq 0x70(%rsp), %rdi
callq 0x4bf7
xorl %eax, %eax
jmp 0x52c5
pushq $-0x1
popq %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/allocate.c
// Function: initialize_register_list
void initialize_register_list(){
	unsigned int i;

	register_list.num_allocated = 0;

	for(i = 0; i < NUM_REGISTERS; i++){
		register_list.registers[i] = i;
		register_list.positions[i] = i;
	}
}

// Assembly:
andl $0x0, 0xaf8d(%rip)      # 0xc250
xorl %eax, %eax
leaq 0xaf84(%rip), %rcx      # 0xc250
cmpq $0x8, %rax
je 0x12df
movb %al, 0x4(%rax,%rcx)
movb %al, 0xc(%rax,%rcx)
incq %rax
jmp 0x12cc
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xaf65(%rip), %eax      # 0xc250
cmpl $0x8, %eax
setae %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x130c
movl 0xaf46(%rip), %edx      # 0xc244
leal 0x4(%rdx), %eax
movl %eax, 0xaf3d(%rip)      # 0xc244
pushq $0x1
popq %rcx
jmp 0x132a
movl %eax, %eax
leaq 0xaf3b(%rip), %rcx      # 0xc250
movzbl 0x4(%rax,%rcx), %edx
incl %eax
movl %eax, 0xaf2e(%rip)      # 0xc250
movl 0xaf1c(%rip), %eax      # 0xc244
xorl %ecx, %ecx
cmpl 0xaf1c(%rip), %eax      # 0xc24c
jle 0x1338
movl %eax, 0xaf14(%rip)      # 0xc24c
movq %rdx, %rax
shlq $0x20, %rax
orq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x138c
testl %edi, %edi
jne 0x1392
movq %rdi, %rax
shrq $0x20, %rax
leaq 0xaef6(%rip), %rcx      # 0xc250
movl 0xaef0(%rip), %edx      # 0xc250
decl %edx
movl %edx, 0xaee8(%rip)      # 0xc250
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, 0xaeb2(%rip)      # 0xc244
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %rbx
movl 0xae9c(%rip), %eax      # 0xc260
movl %eax, 0x10(%rdi)
movups 0xae82(%rip), %xmm0     # 0xc250
movups %xmm0, (%rdi)
movl 0xae78(%rip), %r12d     # 0xc250
decq %r12
leaq 0xae6e(%rip), %r13      # 0xc250
leaq 0x6c1b(%rip), %r15      # 0x8004
testl %r12d, %r12d
js 0x1444
movl 0xae50(%rip), %eax      # 0xc244
movl 0xae52(%rip), %ecx      # 0xc24c
testq %r14, %r14
je 0x142c
movl %r12d, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movzbl 0x4(%rdx,%r13), %edx
subl %eax, %ecx
addl $-0x4, %ecx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1100
movl 0xae1e(%rip), %eax      # 0xc244
movl 0xae20(%rip), %ecx      # 0xc24c
addl $0x4, %eax
movl %eax, 0xae0f(%rip)      # 0xc244
cmpl %ecx, %eax
jle 0x143f
movl %eax, 0xae0d(%rip)      # 0xc24c
decq %r12
jmp 0x13e9
andl $0x0, 0xae05(%rip)      # 0xc250
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movl (%r15), %r12d
leaq 0x6b8c(%rip), %r14      # 0x8016
xorl %r13d, %r13d
cmpq %r12, %r13
jae 0x14c6
movl 0xadac(%rip), %eax      # 0xc244
leal -0x4(%rax), %ecx
movzbl 0x4(%r15,%r13), %edx
movl %ecx, 0xad9d(%rip)      # 0xc244
testq %rbx, %rbx
je 0x14c1
movl 0xad9a(%rip), %ecx      # 0xc24c
subl %eax, %ecx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1100
incq %r13
jmp 0x148d
movl 0x10(%r15), %eax
movl %eax, 0xad90(%rip)      # 0xc260
movups (%r15), %xmm0
movups %xmm0, 0xad75(%rip)     # 0xc250
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x153e
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, 0xad33(%rip)      # 0xc278
je 0x1571
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_O2/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 0xa705(%rip), %r14      # 0xc180
movq %r13, %rdi
movq %r14, %rsi
callq 0x7653
testb %al, %al
jne 0x1a9d
leaq 0xa76f(%rip), %rsi      # 0xc200
movq %r13, %rdi
callq 0x7653
testb %al, %al
je 0x1ac7
addq $0x10, %rbp
leaq 0xa6d8(%rip), %rsi      # 0xc180
movq %rbp, %rdi
callq 0x7653
testb %al, %al
jne 0x1aeb
leaq 0xa745(%rip), %rsi      # 0xc200
movq %rbp, %rdi
callq 0x7653
testb %al, %al
jne 0x1aeb
movups 0x67ce(%rip), %xmm0     # 0x829c
leaq 0xaa0b(%rip), %rax      # 0xc4e0
movups %xmm0, 0xe(%rax)
movups 0x67ae(%rip), %xmm0     # 0x828e
movaps %xmm0, (%rax)
pushq $0x1
popq %rdi
callq 0x56c5
leaq 0x67ba(%rip), %rsi      # 0x82ac
movq %r15, %rdi
movq %r12, %rdx
movq (%rsp), %rcx
xorl %eax, %eax
callq 0x14e8
leaq 0x66f9(%rip), %rsi      # 0x8203
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x14e8
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_O2/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 0xa60f(%rip), %r14      # 0xc180
movq %r13, %rdi
movq %r14, %rsi
callq 0x7653
testb %al, %al
jne 0x1b93
leaq 0xa679(%rip), %rsi      # 0xc200
movq %r13, %rdi
callq 0x7653
testb %al, %al
je 0x1bbd
addq $0x10, %rbp
leaq 0xa5e2(%rip), %rsi      # 0xc180
movq %rbp, %rdi
callq 0x7653
testb %al, %al
jne 0x1be1
leaq 0xa64f(%rip), %rsi      # 0xc200
movq %rbp, %rdi
callq 0x7653
testb %al, %al
jne 0x1be1
movups 0x6701(%rip), %xmm0     # 0x82c5
leaq 0xa915(%rip), %rax      # 0xc4e0
movups %xmm0, 0xc(%rax)
movups 0x66e3(%rip), %xmm0     # 0x82b9
movaps %xmm0, (%rax)
pushq $0x1
popq %rdi
callq 0x56c5
leaq 0x66ed(%rip), %rsi      # 0x82d5
movq %r15, %rdi
movq %r12, %rdx
movq (%rsp), %rcx
xorl %eax, %eax
callq 0x14e8
leaq 0x6603(%rip), %rsi      # 0x8203
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x14e8
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_O2/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 0xa519(%rip), %r14      # 0xc180
movq %r13, %rdi
movq %r14, %rsi
callq 0x7653
testb %al, %al
jne 0x1c89
leaq 0xa583(%rip), %rsi      # 0xc200
movq %r13, %rdi
callq 0x7653
testb %al, %al
je 0x1cb3
addq $0x10, %rbp
leaq 0xa4ec(%rip), %rsi      # 0xc180
movq %rbp, %rdi
callq 0x7653
testb %al, %al
jne 0x1cd7
leaq 0xa559(%rip), %rsi      # 0xc200
movq %rbp, %rdi
callq 0x7653
testb %al, %al
jne 0x1cd7
movups 0x6633(%rip), %xmm0     # 0x82ed
leaq 0xa81f(%rip), %rax      # 0xc4e0
movups %xmm0, 0xc(%rax)
movups 0x6615(%rip), %xmm0     # 0x82e1
movaps %xmm0, (%rax)
pushq $0x1
popq %rdi
callq 0x56c5
leaq 0x65f7(%rip), %rsi      # 0x82d5
movq %r15, %rdi
movq %r12, %rdx
movq (%rsp), %rcx
xorl %eax, %eax
callq 0x14e8
leaq 0x6607(%rip), %rsi      # 0x82fd
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x14e8
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_O2/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 0x1d7b
movups 0x65b1(%rip), %xmm0     # 0x830f
leaq 0xa77b(%rip), %rax      # 0xc4e0
movups %xmm0, 0x9(%rax)
movups 0x6596(%rip), %xmm0     # 0x8306
movaps %xmm0, (%rax)
pushq $0x1
popq %rdi
callq 0x56c5
addq $0x10, %rbp
movq %rbp, %rdi
callq 0x761b
movq %rbp, %rdi
callq 0x7603
cmpl $0x5, %eax
jne 0x1db8
movups 0x658e(%rip), %xmm0     # 0x8329
leaq 0xa73e(%rip), %rax      # 0xc4e0
movups %xmm0, 0xa(%rax)
movups 0x6572(%rip), %xmm0     # 0x831f
movaps %xmm0, (%rax)
pushq $0x1
popq %rdi
callq 0x56c5
movq %rbp, %rdi
xorl %esi, %esi
callq 0x1756
cmpl $0x4, %eax
je 0x1dd5
cmpl $0x1, %eax
jne 0x1dec
leaq 0x6574(%rip), %rsi      # 0x8347
jmp 0x1ddc
leaq 0x655d(%rip), %rsi      # 0x8339
movq %r12, %rdi
movq %r15, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x14e8
leaq 0x6562(%rip), %rsi      # 0x8355
movq %r12, %rdi
movq %r13, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x14e8
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_O2/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 0xa322(%rip), %r14      # 0xc180
movq %r15, %rdi
movq %r14, %rsi
callq 0x7653
testb %al, %al
jne 0x1e80
leaq 0xa38c(%rip), %rsi      # 0xc200
movq %r15, %rdi
callq 0x7653
testb %al, %al
je 0x1eaa
addq $0x10, %rbp
leaq 0xa2f5(%rip), %rsi      # 0xc180
movq %rbp, %rdi
callq 0x7653
testb %al, %al
jne 0x1edc
leaq 0xa362(%rip), %rsi      # 0xc200
movq %rbp, %rdi
callq 0x7653
testb %al, %al
jne 0x1edc
movups 0x64c1(%rip), %xmm0     # 0x8372
leaq 0xa628(%rip), %rax      # 0xc4e0
movaps %xmm0, 0x10(%rax)
movups 0x649f(%rip), %xmm0     # 0x8362
movaps %xmm0, (%rax)
movabsq $0x273c2720687469, %rcx # imm = 0x273C2720687469
movq %rcx, 0x1e(%rax)
pushq $0x1
popq %rdi
callq 0x56c5
leaq 0x64a5(%rip), %rsi      # 0x8388
movq %r12, %rdi
movq %r13, %rdx
movq %r13, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x14e8
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_O2/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 0xa22f(%rip), %r14      # 0xc180
movq %r15, %rdi
movq %r14, %rsi
callq 0x7653
testb %al, %al
jne 0x1f73
leaq 0xa299(%rip), %rsi      # 0xc200
movq %r15, %rdi
callq 0x7653
testb %al, %al
je 0x1f9d
addq $0x10, %rbp
leaq 0xa202(%rip), %rsi      # 0xc180
movq %rbp, %rdi
callq 0x7653
testb %al, %al
jne 0x1fcf
leaq 0xa26f(%rip), %rsi      # 0xc200
movq %rbp, %rdi
callq 0x7653
testb %al, %al
jne 0x1fcf
movups 0x6404(%rip), %xmm0     # 0x83a8
leaq 0xa535(%rip), %rax      # 0xc4e0
movaps %xmm0, 0x10(%rax)
movups 0x63e2(%rip), %xmm0     # 0x8398
movaps %xmm0, (%rax)
movabsq $0x273e2720687469, %rcx # imm = 0x273E2720687469
movq %rcx, 0x1e(%rax)
pushq $0x1
popq %rdi
callq 0x56c5
leaq 0x63e8(%rip), %rsi      # 0x83be
movq %r12, %rdi
movq %r13, %rdx
movq %r13, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x14e8
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_O2/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 0xa13c(%rip), %r14      # 0xc180
movq %r13, %rdi
movq %r14, %rsi
callq 0x7653
testb %al, %al
jne 0x2066
leaq 0xa1a6(%rip), %rsi      # 0xc200
movq %r13, %rdi
callq 0x7653
testb %al, %al
je 0x2090
addq $0x10, %rbp
leaq 0xa10f(%rip), %rsi      # 0xc180
movq %rbp, %rdi
callq 0x7653
testb %al, %al
jne 0x20c2
leaq 0xa17c(%rip), %rsi      # 0xc200
movq %rbp, %rdi
callq 0x7653
testb %al, %al
jne 0x20c2
movups 0x6347(%rip), %xmm0     # 0x83de
leaq 0xa442(%rip), %rax      # 0xc4e0
movaps %xmm0, 0x10(%rax)
movups 0x6325(%rip), %xmm0     # 0x83ce
movaps %xmm0, (%rax)
movabsq $0x273d3c27206874, %rcx # imm = 0x273D3C27206874
movq %rcx, 0x1f(%rax)
pushq $0x1
popq %rdi
callq 0x56c5
leaq 0x62f5(%rip), %rsi      # 0x83be
movq %r15, %rdi
movq %r12, %rdx
movq %r12, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x14e8
leaq 0x6311(%rip), %rsi      # 0x83f5
movq %r15, %rdi
movq %r12, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x14e8
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_O2/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 0xa032(%rip), %r14      # 0xc180
movq %r13, %rdi
movq %r14, %rsi
callq 0x7653
testb %al, %al
jne 0x2170
leaq 0xa09c(%rip), %rsi      # 0xc200
movq %r13, %rdi
callq 0x7653
testb %al, %al
je 0x219a
addq $0x10, %rbp
leaq 0xa005(%rip), %rsi      # 0xc180
movq %rbp, %rdi
callq 0x7653
testb %al, %al
jne 0x21cc
leaq 0xa072(%rip), %rsi      # 0xc200
movq %rbp, %rdi
callq 0x7653
testb %al, %al
jne 0x21cc
movups 0x6277(%rip), %xmm0     # 0x8418
leaq 0xa338(%rip), %rax      # 0xc4e0
movaps %xmm0, 0x10(%rax)
movups 0x6255(%rip), %xmm0     # 0x8408
movaps %xmm0, (%rax)
movabsq $0x273d3e27206874, %rcx # imm = 0x273D3E27206874
movq %rcx, 0x1f(%rax)
pushq $0x1
popq %rdi
callq 0x56c5
leaq 0x61b5(%rip), %rsi      # 0x8388
movq %r15, %rdi
movq %r12, %rdx
movq %r12, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x14e8
leaq 0x6207(%rip), %rsi      # 0x83f5
movq %r15, %rdi
movq %r12, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x14e8
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_O2/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 0x7603
cmpl $0x5, %eax
je 0x226c
leaq 0x10(%r13), %rdi
callq 0x7603
cmpl $0x5, %eax
jne 0x2290
movups 0x61ca(%rip), %xmm0     # 0x843d
leaq 0xa266(%rip), %rax      # 0xc4e0
movups %xmm0, 0xe(%rax)
movups 0x61aa(%rip), %xmm0     # 0x842f
movaps %xmm0, (%rax)
pushq $0x1
popq %rdi
callq 0x56c5
movq %rbp, %rdi
callq 0x7603
movl %eax, %r14d
addq $0x10, %r13
movq %r13, %rdi
callq 0x7603
cmpl $0x4, %r14d
jne 0x22f5
cmpl $0x4, %eax
jne 0x22fa
movq %rbp, %rdi
callq 0x761b
movq %r13, %rdi
callq 0x761b
movq %rbp, %rdi
movq %r13, %rsi
callq 0x7653
testb %al, %al
jne 0x232b
movups 0x6185(%rip), %xmm0     # 0x845d
leaq 0xa101(%rip), %rax      # 0xc3e0
movaps %xmm0, 0x10(%rax)
movups 0x6163(%rip), %xmm0     # 0x844d
movaps %xmm0, (%rax)
movw $0x73, 0x20(%rax)
jmp 0x2324
cmpl $0x4, %eax
jne 0x232b
movups 0x618e(%rip), %xmm0     # 0x848f
leaq 0xa0d8(%rip), %rax      # 0xc3e0
movaps %xmm0, 0x10(%rax)
movups 0x616c(%rip), %xmm0     # 0x847f
movaps %xmm0, (%rax)
movabsq $0x73657079742072, %rcx # imm = 0x73657079742072
movq %rcx, 0x20(%rax)
xorl %eax, %eax
callq 0x5688
leaq 0x613d(%rip), %rsi      # 0x846f
movq %r15, %rdi
movq %r12, %rdx
movq %r12, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x14e8
leaq 0x9e33(%rip), %rax      # 0xc180
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
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/expression.c
// Function: operation_not_equals_func
void operation_not_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, "sne %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, "sne %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, "sne %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 0x7603
cmpl $0x5, %eax
je 0x23b7
leaq 0x10(%r13), %rdi
callq 0x7603
cmpl $0x5, %eax
jne 0x23db
movups 0x607f(%rip), %xmm0     # 0x843d
leaq 0xa11b(%rip), %rax      # 0xc4e0
movups %xmm0, 0xe(%rax)
movups 0x605f(%rip), %xmm0     # 0x842f
movaps %xmm0, (%rax)
pushq $0x1
popq %rdi
callq 0x56c5
movq %rbp, %rdi
callq 0x7603
movl %eax, %r14d
addq $0x10, %r13
movq %r13, %rdi
callq 0x7603
cmpl $0x4, %r14d
jne 0x2440
cmpl $0x4, %eax
jne 0x2445
movq %rbp, %rdi
callq 0x761b
movq %r13, %rdi
callq 0x761b
movq %rbp, %rdi
movq %r13, %rsi
callq 0x7653
testb %al, %al
jne 0x2476
movups 0x603a(%rip), %xmm0     # 0x845d
leaq 0x9fb6(%rip), %rax      # 0xc3e0
movaps %xmm0, 0x10(%rax)
movups 0x6018(%rip), %xmm0     # 0x844d
movaps %xmm0, (%rax)
movw $0x73, 0x20(%rax)
jmp 0x246f
cmpl $0x4, %eax
jne 0x2476
movups 0x6043(%rip), %xmm0     # 0x848f
leaq 0x9f8d(%rip), %rax      # 0xc3e0
movaps %xmm0, 0x10(%rax)
movups 0x6021(%rip), %xmm0     # 0x847f
movaps %xmm0, (%rax)
movabsq $0x73657079742072, %rcx # imm = 0x73657079742072
movq %rcx, 0x20(%rax)
xorl %eax, %eax
callq 0x5688
leaq 0x602a(%rip), %rsi      # 0x84a7
movq %r15, %rdi
movq %r12, %rdx
movq %r12, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x14e8
leaq 0x9ce8(%rip), %rax      # 0xc180
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
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/expression.c
// Function: operation_and_func
void operation_and_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 '&' non-int types");
		do_error(1);
	}
	fileprint(output_file, "and %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 0x9c92(%rip), %r14      # 0xc180
movq %r15, %rdi
movq %r14, %rsi
callq 0x7653
testb %al, %al
jne 0x2510
leaq 0x9cfc(%rip), %rsi      # 0xc200
movq %r15, %rdi
callq 0x7653
testb %al, %al
je 0x253a
addq $0x10, %rbp
leaq 0x9c65(%rip), %rsi      # 0xc180
movq %rbp, %rdi
callq 0x7653
testb %al, %al
jne 0x255e
leaq 0x9cd2(%rip), %rsi      # 0xc200
movq %rbp, %rdi
callq 0x7653
testb %al, %al
jne 0x255e
movups 0x5f7f(%rip), %xmm0     # 0x84c0
leaq 0x9f98(%rip), %rax      # 0xc4e0
movups %xmm0, 0x9(%rax)
movups 0x5f64(%rip), %xmm0     # 0x84b7
movaps %xmm0, (%rax)
pushq $0x1
popq %rdi
callq 0x56c5
leaq 0x5f6b(%rip), %rsi      # 0x84d0
movq %r12, %rdi
movq %r13, %rdx
movq %r13, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x14e8
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_O2/been-jamming[P]MinimalCC/expression.c
// Function: operation_shift_left_func
void operation_shift_left_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 '<<' non-arithmetic types");
		do_error(1);
	}
	fileprint(output_file, "sllv %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 0x9ac8(%rip), %r14      # 0xc180
movq %r15, %rdi
movq %r14, %rsi
callq 0x7653
testb %al, %al
jne 0x26da
leaq 0x9b32(%rip), %rsi      # 0xc200
movq %r15, %rdi
callq 0x7653
testb %al, %al
je 0x2704
addq $0x10, %rbp
leaq 0x9a9b(%rip), %rsi      # 0xc180
movq %rbp, %rdi
callq 0x7653
testb %al, %al
jne 0x272c
leaq 0x9b08(%rip), %rsi      # 0xc200
movq %rbp, %rdi
callq 0x7653
testb %al, %al
jne 0x272c
movups 0x5e0d(%rip), %xmm0     # 0x8518
leaq 0x9dce(%rip), %rax      # 0xc4e0
movaps %xmm0, 0x10(%rax)
movups 0x5deb(%rip), %xmm0     # 0x8508
movaps %xmm0, (%rax)
movb $0x0, 0x20(%rax)
pushq $0x1
popq %rdi
callq 0x56c5
leaq 0x5df6(%rip), %rsi      # 0x8529
movq %r12, %rdi
movq %r13, %rdx
movq %r13, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x14e8
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_O2/been-jamming[P]MinimalCC/expression.c
// Function: operation_shift_right_func
void operation_shift_right_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 '>>' non-arithmetic types");
		do_error(1);
	}
	fileprint(output_file, "srav %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 0x99df(%rip), %r14      # 0xc180
movq %r15, %rdi
movq %r14, %rsi
callq 0x7653
testb %al, %al
jne 0x27c3
leaq 0x9a49(%rip), %rsi      # 0xc200
movq %r15, %rdi
callq 0x7653
testb %al, %al
je 0x27ed
addq $0x10, %rbp
leaq 0x99b2(%rip), %rsi      # 0xc180
movq %rbp, %rdi
callq 0x7653
testb %al, %al
jne 0x2815
leaq 0x9a1f(%rip), %rsi      # 0xc200
movq %rbp, %rdi
callq 0x7653
testb %al, %al
jne 0x2815
movups 0x5d56(%rip), %xmm0     # 0x854a
leaq 0x9ce5(%rip), %rax      # 0xc4e0
movaps %xmm0, 0x10(%rax)
movups 0x5d34(%rip), %xmm0     # 0x853a
movaps %xmm0, (%rax)
movb $0x0, 0x20(%rax)
pushq $0x1
popq %rdi
callq 0x56c5
leaq 0x5d3f(%rip), %rsi      # 0x855b
movq %r12, %rdi
movq %r13, %rdx
movq %r13, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x14e8
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_O2/been-jamming[P]MinimalCC/expression.c
// Function: free_local_variables
void free_local_variables(){
	int i;

	for(i = current_scope; i >= 0; i--){
		if(local_variables[i]){
			free_dictionary(*local_variables[i], free_var);
			free(local_variables[i]);
			local_variables[i] = NULL;
		}
	}

	variables_size = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl 0x9a1b(%rip), %ebp      # 0xc2c8
leaq 0x9a1c(%rip), %r15      # 0xc2d0
pushq $0x9
popq %rbx
leaq -0x38(%rip), %r14       # 0x2886
testl %ebp, %ebp
js 0x28f1
movl %ebp, %r12d
movq (%r15,%r12,8), %rsi
testq %rsi, %rsi
je 0x28ed
movq %rbx, %rcx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
callq 0x6f4a
movq (%r15,%r12,8), %rdi
callq 0x1030
andq $0x0, (%r15,%r12,8)
decl %ebp
jmp 0x28be
leaq 0x9950(%rip), %rax      # 0xc248
andl $0x0, (%rax)
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/expression.c
// Function: compile_variable_initializer
void compile_variable_initializer(char **c){
	variable *var;
	char varname_buf[32];
	type vartype;

	vartype = EMPTY_TYPE;
	parse_type(&vartype, c, varname_buf, NULL, 32, 0);
	var = malloc(sizeof(variable));
	var->varname = malloc(sizeof(char)*32);
	var->var_type = vartype;
	strcpy(var->varname, varname_buf);
	variables_size += align4(type_size(&(var->var_type), 0));
	var->stack_pos = variables_size - 4;
	if(read_dictionary(*local_variables[current_scope], var->varname, 0)){
		free(var->varname);
		free(var);
		snprintf(error_message, sizeof(error_message), "Duplicate local variable definition");
		do_error(1);
	}
	write_dictionary(local_variables[current_scope], var->varname, var, 0);
	skip_whitespace(c);
	if(**c != ';'){
		snprintf(error_message, sizeof(error_message), "Expected ';'");
		do_error(1);
	}
	++*c;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq 0x9e2e(%rip), %rax      # 0xc758
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %xmm3
leaq 0x70(%rsp), %r12
movaps %xmm3, 0x30(%r12)
movaps %xmm2, 0x20(%r12)
movaps %xmm1, 0x10(%r12)
movaps %xmm0, (%r12)
leaq 0x50(%rsp), %r13
pushq $0x20
popq %r8
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x78de
pushq $0x50
popq %rdi
callq 0x1140
movq %rax, %r14
pushq $0x20
popq %rdi
callq 0x1140
movq %rax, %r15
movq %rax, (%r14)
leaq 0x8(%r14), %rbp
movaps (%r12), %xmm0
movaps 0x10(%r12), %xmm1
movaps 0x20(%r12), %xmm2
movaps 0x30(%r12), %xmm3
movups %xmm0, 0x8(%r14)
movups %xmm1, 0x18(%r14)
movups %xmm2, 0x28(%r14)
movups %xmm3, 0x38(%r14)
movq %rax, %rdi
movq %r13, %rsi
callq 0x1050
movq %rbp, %rdi
xorl %esi, %esi
callq 0x1756
addl $0x3, %eax
andl $-0x4, %eax
leaq 0x986d(%rip), %rcx      # 0xc248
movl (%rcx), %edx
leal (%rax,%rdx), %esi
movl %esi, (%rcx)
leal -0x4(%rax,%rdx), %eax
movl %eax, 0x48(%r14)
movslq 0x98d7(%rip), %rax      # 0xc2c8
leaq 0x98d8(%rip), %r12      # 0xc2d0
movq (%r12,%rax,8), %rsi
pushq $0x9
popq %rcx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %r15, %rdi
xorl %esi, %esi
callq 0x6ff5
testq %rax, %rax
je 0x2a52
movq %r15, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
leaq 0x9ab5(%rip), %rax      # 0xc4e0
movups 0x5b4a(%rip), %xmm0     # 0x857c
movaps %xmm0, 0x10(%rax)
movups 0x5b2f(%rip), %xmm0     # 0x856c
movaps %xmm0, (%rax)
movl $0x6e6f69, 0x20(%rax)   # imm = 0x6E6F69
pushq $0x1
popq %rdi
callq 0x56c5
movq (%r14), %r15
movslq 0x986f(%rip), %rax      # 0xc2c8
movq (%r12,%rax,8), %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x7098
movq %rbx, %rdi
callq 0x7549
movq (%rbx), %rax
cmpb $0x3b, (%rax)
je 0x2aa7
leaq 0x9a5f(%rip), %rax      # 0xc4e0
movabsq $0x273b2720646574, %rcx # imm = 0x273B2720646574
movq %rcx, 0x5(%rax)
movabsq $0x6465746365707845, %rcx # imm = 0x6465746365707845
movq %rcx, (%rax)
pushq $0x1
popq %rdi
callq 0x56c5
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/expression.c
// Function: compile_integer
void compile_integer(value *output, char **c, unsigned char dereference, unsigned char force_stack, FILE *output_file){
	int int_value;

	output->data = allocate(force_stack);
	int_value = strtol(*c, c, 0);
	if(output->data.type == data_register){
		fileprint(output_file, "li $s%d, %d\n", output->data.reg, int_value);
	} else if(output->data.type == data_stack){
		fileprint(output_file, "li $t0, %d\nsw $t0, %d($sp)\n", int_value, get_stack_pos(output->data));
	}
	output->data_type = INT_TYPE;
	output->is_reference = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl %ecx, %edi
callq 0x12e0
movq %rax, (%rbx)
movl %edx, 0x8(%rbx)
movq (%r15), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1120
movq %rax, %r15
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x2b07
testl %eax, %eax
jne 0x2b28
movl 0x4(%rbx), %edx
leaq 0x5a9e(%rip), %rsi      # 0x859d
movq %r14, %rdi
movl %r15d, %ecx
jmp 0x2b21
movq (%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0x1393
leaq 0x5a91(%rip), %rsi      # 0x85aa
movq %r14, %rdi
movl %r15d, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0x14e8
leaq 0x9651(%rip), %rax      # 0xc180
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %xmm3
movups %xmm3, 0x40(%rbx)
movups %xmm2, 0x30(%rbx)
movups %xmm1, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movb $0x0, 0x50(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/expression.c
// Function: compile_expression
void compile_expression(value *first_value, char **c, unsigned char dereference, unsigned char force_stack, FILE *output_file){
	char *temp_c;
	int current_line_temp;
	operation next_operation;

	temp_c = *c;
	current_line_temp = current_line;
	skip_value(&temp_c);
	current_line = current_line_temp;

	next_operation = peek_operation(temp_c);
	if(peek_operation(temp_c) == operation_assign){
		compile_value(first_value, c, 0, force_stack, output_file);
	} else {
		compile_value(first_value, c, dereference || next_operation != operation_none, force_stack, output_file);
	}
	while(**c && **c != ';' && **c != ',' && **c != ')' && **c != ']'){
		compile_expression_recursive(first_value, c, output_file);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movl %ecx, 0xc(%rsp)
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
leaq 0x8ba6(%rip), %rax      # 0xc600
movl (%rax), %ebp
movq %r13, %rdi
callq 0x415b
leaq 0x8b95(%rip), %rax      # 0xc600
movl %ebp, (%rax)
movq (%r13), %rdi
callq 0x4c19
cmpl $0x5, %eax
setne %cl
orl %eax, %r12d
setne %al
andb %cl, %al
movzbl %al, %edx
movq %r15, %rdi
movq %r14, %rsi
movl 0xc(%rsp), %ecx
movq %rbx, %r8
callq 0x481c
movabsq $0x10000000040009, %r12 # imm = 0x10000000040009
movq (%r14), %rax
movzbl (%rax), %eax
leal -0x29(%rax), %ecx
cmpl $0x34, %ecx
ja 0x3ab7
btq %rcx, %r12
jb 0x3acb
testl %eax, %eax
je 0x3acb
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x508e
jmp 0x3aa3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/expression.c
// Function: skip_string
void skip_string(char **c){
	while(**c && **c != '\"'){
		if(**c == '\\'){
			*c += 2;
		} else {
			++*c;
		}
	}
	if(**c){
		++*c;
	}
}

// Assembly:
movq (%rdi), %rax
pushq $0x2
popq %rcx
pushq $0x1
popq %rdx
movzbl (%rax), %esi
movq %rcx, %r8
cmpl $0x5c, %esi
je 0x3fa2
testl %esi, %esi
je 0x3fb0
cmpl $0x22, %esi
je 0x3faa
movq %rdx, %r8
addq %r8, %rax
movq %rax, (%rdi)
jmp 0x3f8b
incq %rax
movq %rax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/expression.c
// Function: match_parentheses
void match_parentheses(char **c){
	while(**c && **c != ')' && **c != ']'){
		if(**c == '"'){
			++*c;
			skip_string(c);
			skip_whitespace(c);
			continue;
		}
		if(**c == '('){
			++*c;
			match_parentheses(c);
		} else if(**c == '['){
			++*c;
			match_brackets(c);
		} else {
			++*c;
		}
		skip_whitespace(c);
	}
	if(!**c || **c == ']'){
		snprintf(error_message, sizeof(error_message), "Expected ')'");
		do_error(1);
	}
	++*c;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x22, %ecx
je 0x3ff0
cmpl $0x28, %ecx
je 0x4000
cmpl $0x5b, %ecx
je 0x3fe0
testl %ecx, %ecx
je 0x4018
cmpl $0x29, %ecx
je 0x4045
cmpl $0x5d, %ecx
je 0x4018
incq %rax
movq %rax, (%rbx)
jmp 0x400e
incq %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x404d
jmp 0x400e
incq %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x3f82
jmp 0x400e
incq %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x3fb1
movq %rbx, %rdi
callq 0x7549
jmp 0x3fb5
leaq 0x84c1(%rip), %rax      # 0xc4e0
movabsq $0x27292720646574, %rcx # imm = 0x27292720646574
movq %rcx, 0x5(%rax)
movabsq $0x6465746365707845, %rcx # imm = 0x6465746365707845
movq %rcx, (%rax)
pushq $0x1
popq %rdi
callq 0x56c5
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/expression.c
// Function: skip_comment
void skip_comment(char **c){
	++*c;
	if(**c == '/'){
		while(**c && **c != '\n'){
			++*c;
		}
		if(**c){
			++*c;
		}
	} else {
		++*c;
		while(**c && (**c != '*' || (*c)[1] != '/')){
			++*c;
		}
		if(**c){
			*c += 2;
		}
	}
}

// Assembly:
movq (%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rdi)
cmpb $0x2f, 0x1(%rax)
jne 0x4115
addq $0x2, %rax
movb $0x2f, %cl
testb %cl, %cl
je 0x413c
movzbl %cl, %ecx
cmpl $0xa, %ecx
je 0x4139
movq %rax, (%rdi)
movb (%rax), %cl
incq %rax
jmp 0x40ff
addq $0x2, %rax
movq %rax, (%rdi)
movzbl (%rax), %ecx
cmpl $0x2a, %ecx
je 0x412a
testl %ecx, %ecx
jne 0x4130
jmp 0x413c
cmpb $0x2f, 0x1(%rax)
je 0x4135
incq %rax
jmp 0x4119
addq $0x2, %rax
movq %rax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/expression.c
// Function: is_cast
unsigned char is_cast(char *c){
	if(*c != '('){
		return 0;
	}

	c++;
	return parse_datatype(NULL, &c);
}

// Assembly:
cmpb $0x28, (%rdi)
jne 0x4158
pushq %rax
incq %rdi
movq %rsp, %rsi
movq %rdi, (%rsi)
xorl %edi, %edi
callq 0x7455
addq $0x8, %rsp
retq
xorl %eax, %eax
retq