LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x1c(%rsp)
movl %esi, -0x14(%rsp)
movq -0x1c(%rsp), %rax
movq %rax, -0xc(%rsp)
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
cmpl $0x0, -0xc(%rsp)
jne 0x1475
movl 0xfec4(%rip), %eax      # 0x112a0
addl $-0x1, %eax
movl %eax, 0xfebb(%rip)      # 0x112a0
movl 0xfeb5(%rip), %eax      # 0x112a0
movl %eax, %ecx
leaq 0xfeac(%rip), %rax      # 0x112a0
movzbl 0x4(%rax,%rcx), %eax
movl %eax, -0x20(%rsp)
movl -0x8(%rsp), %eax
movb %al, %dl
movl 0xfe97(%rip), %eax      # 0x112a0
movl %eax, %ecx
leaq 0xfe8e(%rip), %rax      # 0x112a0
movb %dl, 0x4(%rax,%rcx)
movl -0x20(%rsp), %eax
movb %al, %dl
movslq -0x8(%rsp), %rcx
leaq 0xfe78(%rip), %rax      # 0x112a0
movzbl 0xc(%rax,%rcx), %eax
movl %eax, %ecx
leaq 0xfe6a(%rip), %rax      # 0x112a0
movb %dl, 0x4(%rax,%rcx)
movslq -0x8(%rsp), %rcx
leaq 0xfe5a(%rip), %rax      # 0x112a0
movb 0xc(%rax,%rcx), %dl
movl -0x20(%rsp), %eax
movl %eax, %ecx
leaq 0xfe49(%rip), %rax      # 0x112a0
movb %dl, 0xc(%rax,%rcx)
movl 0xfe3f(%rip), %eax      # 0x112a0
movb %al, %dl
movslq -0x8(%rsp), %rcx
leaq 0xfe31(%rip), %rax      # 0x112a0
movb %dl, 0xc(%rax,%rcx)
jmp 0x1488
cmpl $0x1, -0xc(%rsp)
jne 0x1486
movl -0x4(%rsp), %eax
movl %eax, 0xfe0e(%rip)      # 0x11294
jmp 0x1488
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, %rax
movq %rax, (%rsp)
movq %rsi, 0x10(%rsp)
movq 0xfda9(%rip), %rax      # 0x112a0
movq %rax, (%rdi)
movq 0xfda7(%rip), %rax      # 0x112a8
movq %rax, 0x8(%rdi)
movl 0xfda5(%rip), %eax      # 0x112b0
movl %eax, 0x10(%rdi)
movl 0xfd8c(%rip), %eax      # 0x112a0
subl $0x1, %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jl 0x154c
movslq 0xc(%rsp), %rcx
leaq 0xfd72(%rip), %rax      # 0x112a0
movb 0x4(%rax,%rcx), %al
movq 0x10(%rsp), %rsi
movzbl %al, %edi
callq 0x1560
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x151b
movq (%rsp), %rax
movl $0x0, 0xfd46(%rip)      # 0x112a0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/been-jamming[P]MinimalCC/allocate.c
// Function: store_register
static void store_register(unsigned char reg, FILE *output_file){
	if(output_file)
		fprintf(output_file, "sw $s%d, %d($sp)\n", (int) reg, saved_stack_size - stack_size - 4);
	stack_size += 4;
	if(stack_size > saved_stack_size){
		saved_stack_size = stack_size;
	}
}

// Assembly:
subq $0x18, %rsp
movb %dil, %al
movb %al, 0x17(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x159f
movq 0x8(%rsp), %rdi
movzbl 0x17(%rsp), %edx
movl 0xfd14(%rip), %ecx      # 0x1129c
subl 0xfd06(%rip), %ecx      # 0x11294
subl $0x4, %ecx
leaq 0xba6c(%rip), %rsi      # 0xd004
movb $0x0, %al
callq 0x10f0
movl 0xfcef(%rip), %eax      # 0x11294
addl $0x4, %eax
movl %eax, 0xfce6(%rip)      # 0x11294
movl 0xfce0(%rip), %eax      # 0x11294
cmpl 0xfce2(%rip), %eax      # 0x1129c
jle 0x15c8
movl 0xfcd2(%rip), %eax      # 0x11294
movl %eax, 0xfcd4(%rip)      # 0x1129c
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
leaq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jae 0x165c
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movb 0x4(%rax,%rcx), %al
movq 0x10(%rsp), %rsi
movzbl %al, %edi
callq 0x1690
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x162a
movq (%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0xfc36(%rip)      # 0x112a0
movq 0x8(%rax), %rcx
movq %rcx, 0xfc33(%rip)      # 0x112a8
movl 0x10(%rax), %eax
movl %eax, 0xfc32(%rip)      # 0x112b0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
testb %al, %al
je 0x172c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
cmpb $0x0, 0xfb71(%rip)      # 0x112c8
je 0x17a6
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xe0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0x1160
leaq 0xb0(%rsp), %rax
addq $0xd8, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/been-jamming[P]MinimalCC/expression.c
// Function: type_size
int type_size(type *t, unsigned int start_entry){
	uint64_t d0;
	uint64_t d1;
	uint64_t d2;
	unsigned int index;
	unsigned int current_entry = 0;
	int entry;
	int output = 1;

	d0 = t->d0;
	d1 = t->d1;
	d2 = t->d2;
	index = t->current_index;
	while(1){
		entry = 0;
		if(d0&1){
			entry |= 1;
		}
		if(d1&1){
			entry |= 2;
		}
		if(d2&1){
			entry |= 4;
		}
		if(current_entry >= start_entry){
			switch(entry){
				case type_void:
					return output*VOID_SIZE;
				case type_int:
					return output*INT_SIZE;
				case type_char:
					return output*CHAR_SIZE;
				case type_pointer:
					return output*POINTER_SIZE;
				case type_function:
					return output*POINTER_SIZE;
				case type_list:
					index--;
					output *= t->list_indicies[index];
					break;
				default:
					return 0;
			}
		} else if(entry == type_list){
			index--;
		}
		d0 >>= 1;
		d1 >>= 1;
		d2 >>= 1;
		current_entry++;
	}
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movl $0x0, -0x38(%rsp)
movl $0x1, -0x40(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x10(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x34(%rsp)
movl $0x0, -0x3c(%rsp)
movq -0x20(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1ab0
movl -0x3c(%rsp), %eax
orl $0x1, %eax
movl %eax, -0x3c(%rsp)
movq -0x28(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1aca
movl -0x3c(%rsp), %eax
orl $0x2, %eax
movl %eax, -0x3c(%rsp)
movq -0x30(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1ae4
movl -0x3c(%rsp), %eax
orl $0x4, %eax
movl %eax, -0x3c(%rsp)
movl -0x38(%rsp), %eax
cmpl -0x14(%rsp), %eax
jb 0x1b99
movl -0x3c(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x48(%rsp)
subl $0x6, %eax
ja 0x1b8d
movq -0x48(%rsp), %rax
leaq 0xb51c(%rip), %rcx      # 0xd030
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x40(%rsp), %eax
shll $0x0, %eax
movl %eax, -0x4(%rsp)
jmp 0x1be4
movl -0x40(%rsp), %eax
shll $0x2, %eax
movl %eax, -0x4(%rsp)
jmp 0x1be4
movl -0x40(%rsp), %eax
shll $0x0, %eax
movl %eax, -0x4(%rsp)
jmp 0x1be4
movl -0x40(%rsp), %eax
shll $0x2, %eax
movl %eax, -0x4(%rsp)
jmp 0x1be4
movl -0x40(%rsp), %eax
shll $0x2, %eax
movl %eax, -0x4(%rsp)
jmp 0x1be4
movl -0x34(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rsp)
movq -0x10(%rsp), %rax
movl -0x34(%rsp), %ecx
movl 0x18(%rax,%rcx,4), %eax
imull -0x40(%rsp), %eax
movl %eax, -0x40(%rsp)
jmp 0x1b97
movl $0x0, -0x4(%rsp)
jmp 0x1be4
jmp 0x1bad
cmpl $0x7, -0x3c(%rsp)
jne 0x1bab
movl -0x34(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rsp)
jmp 0x1bad
movq -0x20(%rsp), %rax
shrq %rax
movq %rax, -0x20(%rsp)
movq -0x28(%rsp), %rax
shrq %rax
movq %rax, -0x28(%rsp)
movq -0x30(%rsp), %rax
shrq %rax
movq %rax, -0x30(%rsp)
movl -0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rsp)
jmp 0x1a8e
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xf286(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x1f64
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xf2ed(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
je 0x1f96
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0xf254(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x1fba
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0xf2bb(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
jne 0x1fba
leaq 0xf593(%rip), %rdi      # 0x11530
movl $0x100, %esi            # imm = 0x100
leaq 0xb509(%rip), %rdx      # 0xd4b2
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x87b0
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
leaq 0xb500(%rip), %rsi      # 0xd4d0
movb $0x0, %al
callq 0x16f0
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rdx
leaq 0xb43f(%rip), %rsi      # 0xd427
movb $0x0, %al
callq 0x16f0
movq 0x8(%rsp), %rdi
leaq 0xf1cd(%rip), %rsi      # 0x111c8
movl $0x40, %edx
callq 0x1120
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xf186(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x2064
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xf1ed(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
je 0x2096
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0xf154(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x20ba
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0xf1bb(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
jne 0x20ba
leaq 0xf493(%rip), %rdi      # 0x11530
movl $0x100, %esi            # imm = 0x100
leaq 0xb434(%rip), %rdx      # 0xd4dd
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x87b0
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
leaq 0xb429(%rip), %rsi      # 0xd4f9
movb $0x0, %al
callq 0x16f0
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rdx
leaq 0xb33f(%rip), %rsi      # 0xd427
movb $0x0, %al
callq 0x16f0
movq 0x8(%rsp), %rdi
leaq 0xf0cd(%rip), %rsi      # 0x111c8
movl $0x40, %edx
callq 0x1120
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xf086(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x2164
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xf0ed(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
je 0x2196
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0xf054(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x21ba
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0xf0bb(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
jne 0x21ba
leaq 0xf393(%rip), %rdi      # 0x11530
movl $0x100, %esi            # imm = 0x100
leaq 0xb35c(%rip), %rdx      # 0xd505
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x87b0
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
leaq 0xb329(%rip), %rsi      # 0xd4f9
movb $0x0, %al
callq 0x16f0
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rdx
leaq 0xb339(%rip), %rsi      # 0xd521
movb $0x0, %al
callq 0x16f0
movq 0x8(%rsp), %rdi
leaq 0xefcd(%rip), %rsi      # 0x111c8
movl $0x40, %edx
callq 0x1120
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x20(%rsp), %rax
cmpb $0x0, 0x50(%rax)
jne 0x2261
leaq 0xf2ec(%rip), %rdi      # 0x11530
movl $0x100, %esi            # imm = 0x100
leaq 0xb2da(%rip), %rdx      # 0xd52a
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x87b0
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
callq 0xbe20
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
callq 0xbdb0
cmpl $0x5, %eax
jne 0x22a6
leaq 0xf2a7(%rip), %rdi      # 0x11530
movl $0x100, %esi            # imm = 0x100
leaq 0xb2ae(%rip), %rdx      # 0xd543
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x87b0
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
callq 0x1a40
cmpl $0x4, %eax
jne 0x22da
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
leaq 0xb28c(%rip), %rsi      # 0xd55d
movb $0x0, %al
callq 0x16f0
jmp 0x230e
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
callq 0x1a40
cmpl $0x1, %eax
jne 0x230c
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
leaq 0xb266(%rip), %rsi      # 0xd56b
movb $0x0, %al
callq 0x16f0
jmp 0x230e
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
leaq 0xb255(%rip), %rsi      # 0xd579
movb $0x0, %al
callq 0x16f0
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x10, %rsi
movl $0x40, %edx
callq 0x1120
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xee46(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x23a4
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xeead(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
je 0x23d6
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0xee14(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x23fa
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0xee7b(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
jne 0x23fa
leaq 0xf153(%rip), %rdi      # 0x11530
movl $0x100, %esi            # imm = 0x100
leaq 0xb19d(%rip), %rdx      # 0xd586
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x87b0
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
leaq 0xb197(%rip), %rsi      # 0xd5ac
movb $0x0, %al
callq 0x16f0
movq 0x8(%rsp), %rdi
leaq 0xeda0(%rip), %rsi      # 0x111c8
movl $0x40, %edx
callq 0x1120
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xed56(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x2494
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xedbd(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
je 0x24c6
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0xed24(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x24ea
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0xed8b(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
jne 0x24ea
leaq 0xf063(%rip), %rdi      # 0x11530
movl $0x100, %esi            # imm = 0x100
leaq 0xb0e3(%rip), %rdx      # 0xd5bc
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x87b0
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
leaq 0xb0dd(%rip), %rsi      # 0xd5e2
movb $0x0, %al
callq 0x16f0
movq 0x8(%rsp), %rdi
leaq 0xecb0(%rip), %rsi      # 0x111c8
movl $0x40, %edx
callq 0x1120
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xec66(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x2584
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xeccd(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
je 0x25b6
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0xec34(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x25da
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0xec9b(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
jne 0x25da
leaq 0xef73(%rip), %rdi      # 0x11530
movl $0x100, %esi            # imm = 0x100
leaq 0xb029(%rip), %rdx      # 0xd5f2
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x87b0
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
leaq 0xafed(%rip), %rsi      # 0xd5e2
movb $0x0, %al
callq 0x16f0
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x30(%rsp), %rcx
leaq 0xb007(%rip), %rsi      # 0xd619
movb $0x0, %al
callq 0x16f0
movq 0x8(%rsp), %rdi
leaq 0xeba3(%rip), %rsi      # 0x111c8
movl $0x40, %edx
callq 0x1120
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xeb56(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x2694
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xebbd(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
je 0x26c6
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0xeb24(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x26ea
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0xeb8b(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
jne 0x26ea
leaq 0xee63(%rip), %rdi      # 0x11530
movl $0x100, %esi            # imm = 0x100
leaq 0xaf53(%rip), %rdx      # 0xd62c
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x87b0
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
leaq 0xaea7(%rip), %rsi      # 0xd5ac
movb $0x0, %al
callq 0x16f0
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x30(%rsp), %rcx
leaq 0xaef7(%rip), %rsi      # 0xd619
movb $0x0, %al
callq 0x16f0
movq 0x8(%rsp), %rdi
leaq 0xea93(%rip), %rsi      # 0x111c8
movl $0x40, %edx
callq 0x1120
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xe646(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x2ba4
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xe6ad(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
je 0x2bd6
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0xe614(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x2bfa
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0xe67b(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
jne 0x2bfa
leaq 0xe953(%rip), %rdi      # 0x11530
movl $0x100, %esi            # imm = 0x100
leaq 0xaaf2(%rip), %rdx      # 0xd6db
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x87b0
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
leaq 0xaadf(%rip), %rsi      # 0xd6f4
movb $0x0, %al
callq 0x16f0
movq 0x8(%rsp), %rdi
leaq 0xe5a0(%rip), %rsi      # 0x111c8
movl $0x40, %edx
callq 0x1120
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xe466(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x2d84
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xe4cd(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
je 0x2db6
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0xe434(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x2dda
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0xe49b(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
jne 0x2dda
leaq 0xe773(%rip), %rdi      # 0x11530
movl $0x100, %esi            # imm = 0x100
leaq 0xa963(%rip), %rdx      # 0xd72c
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x87b0
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
leaq 0xa958(%rip), %rsi      # 0xd74d
movb $0x0, %al
callq 0x16f0
movq 0x8(%rsp), %rdi
leaq 0xe3c0(%rip), %rsi      # 0x111c8
movl $0x40, %edx
callq 0x1120
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xe376(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x2e74
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xe3dd(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
je 0x2ea6
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0xe344(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x2eca
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0xe3ab(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
jne 0x2eca
leaq 0xe683(%rip), %rdi      # 0x11530
movl $0x100, %esi            # imm = 0x100
leaq 0xa8a5(%rip), %rdx      # 0xd75e
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x87b0
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
leaq 0xa89a(%rip), %rsi      # 0xd77f
movb $0x0, %al
callq 0x16f0
movq 0x8(%rsp), %rdi
leaq 0xe2d0(%rip), %rsi      # 0x111c8
movl $0x40, %edx
callq 0x1120
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/been-jamming[P]MinimalCC/expression.c
// Function: free_var
static void free_var(void *v){
	variable *var;

	var = (variable *) v;
	free(var->varname);
	free(var);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x8(%rsp), %rdi
callq 0x1030
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movl 0xe37e(%rip), %eax      # 0x11318
movl %eax, 0x54(%rsp)
cmpl $0x0, 0x54(%rsp)
jl 0x303c
movslq 0x54(%rsp), %rcx
leaq 0xe36b(%rip), %rax      # 0x11320
cmpq $0x0, (%rax,%rcx,8)
je 0x302a
movslq 0x54(%rsp), %rcx
leaq 0xe358(%rip), %rax      # 0x11320
movq (%rax,%rcx,8), %rcx
movq 0x40(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x40(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups 0x30(%rcx), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x9c(%rip), %rdi       # 0x2f60
callq 0xaf70
movslq 0x54(%rsp), %rcx
leaq 0xe313(%rip), %rax      # 0x11320
movq (%rax,%rcx,8), %rdi
callq 0x1030
movslq 0x54(%rsp), %rcx
leaq 0xe2fe(%rip), %rax      # 0x11320
movq $0x0, (%rax,%rcx,8)
jmp 0x302c
movl 0x54(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x2f9e
leaq 0xe255(%rip), %rax      # 0x11298
movl $0x0, (%rax)
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/been-jamming[P]MinimalCC/expression.c
// Function: align4
unsigned int align4(unsigned int size){
	unsigned int remainder;

	remainder = size%4;
	if(remainder){
		size += 4 - remainder;
	}

	return size;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
andl $0x3, %eax
movl %eax, -0x8(%rsp)
cmpl $0x0, -0x8(%rsp)
je 0x3077
movl $0x4, %eax
subl -0x8(%rsp), %eax
addl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movb %cl, 0x57(%rsp)
movb %al, 0x56(%rsp)
movq %r8, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movzbl 0x56(%rsp), %edi
callq 0x1300
movq %rax, %rcx
movq 0x10(%rsp), %rax
movl %edx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movl 0x30(%rsp), %ecx
movl %ecx, 0x40(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, (%rax)
movl 0x40(%rsp), %ecx
movl %ecx, 0x8(%rax)
movq 0x58(%rsp), %rax
movq (%rax), %rdi
movq 0x58(%rsp), %rsi
xorl %edx, %edx
callq 0x1110
movl %eax, 0x44(%rsp)
movq 0x60(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x3338
movq 0x48(%rsp), %rdi
movq 0x60(%rsp), %rax
movl 0x4(%rax), %edx
movl 0x44(%rsp), %ecx
leaq 0xa492(%rip), %rsi      # 0xd7c1
movb $0x0, %al
callq 0x16f0
jmp 0x338f
movq 0x60(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x338d
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x1490
movq (%rsp), %rdi
movl 0xc(%rsp), %edx
movl %eax, %ecx
leaq 0xa448(%rip), %rsi      # 0xd7ce
movb $0x0, %al
callq 0x16f0
jmp 0x338f
movq 0x60(%rsp), %rdi
addq $0x10, %rdi
leaq 0xde29(%rip), %rsi      # 0x111c8
movl $0x40, %edx
callq 0x1120
movq 0x60(%rsp), %rax
movb $0x0, 0x50(%rax)
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movb %cl, 0x47(%rsp)
movb %al, 0x46(%rsp)
movq %r8, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
leaq 0xc63d(%rip), %rax      # 0x11650
movl (%rax), %eax
movl %eax, 0x2c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5ed0
movl 0x2c(%rsp), %ecx
leaq 0xc622(%rip), %rax      # 0x11650
movl %ecx, (%rax)
movq 0x30(%rsp), %rdi
callq 0x7380
movl %eax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x7380
cmpl $0x5, %eax
jne 0x506c
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movb 0x46(%rsp), %al
movq 0x38(%rsp), %r8
xorl %edx, %edx
movzbl %al, %ecx
callq 0x6b80
jmp 0x50c5
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movzbl 0x47(%rsp), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0x27(%rsp)
jne 0x509c
cmpl $0x0, 0x28(%rsp)
setne %al
movb %al, 0x27(%rsp)
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
movb 0x27(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %cl
movb 0x46(%rsp), %al
movq 0x38(%rsp), %r8
movzbl %cl, %edx
movzbl %al, %ecx
callq 0x6b80
jmp 0x50c7
movq 0x48(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
je 0x5134
movq 0x48(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x3b, %ecx
movb %al, 0xf(%rsp)
je 0x5134
movq 0x48(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2c, %ecx
movb %al, 0xf(%rsp)
je 0x5134
movq 0x48(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x29, %ecx
movb %al, 0xf(%rsp)
je 0x5134
movq 0x48(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x5d, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x513e
jmp 0x5157
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x7cd0
jmp 0x50c7
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x9(%rsp)
je 0x5a40
movq -0x8(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
setne %al
movb %al, -0x9(%rsp)
movb -0x9(%rsp), %al
testb $0x1, %al
jne 0x5a4a
jmp 0x5a7c
movq -0x8(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x5a6b
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
jmp 0x5a7a
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x5a15
movq -0x8(%rsp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0x5a98
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
je 0x5aea
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x29, %ecx
movb %al, 0xf(%rsp)
je 0x5aea
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x5d, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x5af7
jmp 0x5ba5
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x5b2f
movq 0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
callq 0x5a10
movq 0x10(%rsp), %rdi
callq 0xbb70
jmp 0x5aa9
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0x5b5a
movq 0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
callq 0x5aa0
jmp 0x5b96
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x5b, %eax
jne 0x5b85
movq 0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
callq 0x5c00
jmp 0x5b94
movq 0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x5b96
movq 0x10(%rsp), %rdi
callq 0xbb70
jmp 0x5aa9
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0x5bc2
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0x5be6
leaq 0xb967(%rip), %rdi      # 0x11530
movl $0x100, %esi            # imm = 0x100
leaq 0x7df9(%rip), %rdx      # 0xd9ce
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x87b0
movq 0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x5ded
jmp 0x5d86
movq -0x8(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x9(%rsp)
je 0x5db1
movq -0x8(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x9(%rsp)
movb -0x9(%rsp), %al
testb $0x1, %al
jne 0x5dbb
jmp 0x5dcc
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x5d86
movq -0x8(%rsp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0x5de8
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x5e7f
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xa(%rsp)
je 0x5e46
movq -0x8(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x2a, %ecx
movb %al, -0xb(%rsp)
jne 0x5e3e
movq -0x8(%rsp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0xb(%rsp)
movb -0xb(%rsp), %al
movb %al, -0xa(%rsp)
movb -0xa(%rsp), %al
testb $0x1, %al
jne 0x5e50
jmp 0x5e61
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x5dfc
movq -0x8(%rsp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0x5e7d
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
jmp 0x5e7f
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
je 0x5e9d
movb $0x0, 0x17(%rsp)
jmp 0x5ebd
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x8(%rsp), %rsi
callq 0xb980
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/been-jamming[P]MinimalCC/expression.c
// Function: compile_string
void compile_string(value *output, char **c, unsigned char dereference, unsigned char force_stack, FILE *output_file){
	++*c;
	skip_string(c);

	output->data = allocate(force_stack);
	if(output->data.type == data_register){
		fileprint(output_file, "la $s%d, __str%d\n", output->data.reg, current_string);
	} else if(output->data.type == data_stack){
		fileprint(output_file, "la $t0, __str%d\n", current_string);
		fileprint(output_file, "sw $t0, %d($sp)\n", get_stack_pos(output->data));
	}
	if(do_print)
		current_string++;
	output->data_type = CHAR_TYPE;
	add_type_entry(&(output->data_type), type_pointer);
	output->is_reference = 0;
}

// Assembly:
subq $0x68, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movb %cl, 0x57(%rsp)
movb %al, 0x56(%rsp)
movq %r8, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq (%rax), %rcx
incq %rcx
movq %rcx, (%rax)
movq 0x58(%rsp), %rdi
callq 0x5a10
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movzbl 0x56(%rsp), %edi
callq 0x1300
movq %rax, %rcx
movq 0x10(%rsp), %rax
movl %edx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, 0x3c(%rsp)
movl 0x30(%rsp), %ecx
movl %ecx, 0x44(%rsp)
movq 0x3c(%rsp), %rcx
movq %rcx, (%rax)
movl 0x44(%rsp), %ecx
movl %ecx, 0x8(%rax)
movq 0x60(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x62ea
movq 0x48(%rsp), %rdi
movq 0x60(%rsp), %rax
movl 0x4(%rax), %edx
movl 0xafea(%rip), %ecx      # 0x112c4
leaq 0x785a(%rip), %rsi      # 0xdb3b
movb $0x0, %al
callq 0x16f0
jmp 0x6350
movq 0x60(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x634e
movq 0x48(%rsp), %rdi
movl 0xafc5(%rip), %edx      # 0x112c4
leaq 0x7847(%rip), %rsi      # 0xdb4d
movb $0x0, %al
callq 0x16f0
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x1490
movq 0x8(%rsp), %rdi
movl %eax, %edx
leaq 0x7492(%rip), %rsi      # 0xd7d9
movb $0x0, %al
callq 0x16f0
jmp 0x6350
cmpb $0x0, 0xaf71(%rip)      # 0x112c8
je 0x6368
movl 0xaf65(%rip), %eax      # 0x112c4
addl $0x1, %eax
movl %eax, 0xaf5c(%rip)      # 0x112c4
movq 0x60(%rsp), %rdi
addq $0x10, %rdi
leaq 0xaed0(%rip), %rsi      # 0x11248
movl $0x40, %edx
callq 0x1120
movq 0x60(%rsp), %rdi
addq $0x10, %rdi
movl $0x4, %esi
callq 0xb510
movq 0x60(%rsp), %rax
movb $0x0, 0x50(%rax)
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/been-jamming[P]MinimalCC/expression.c
// Function: compile_logical_not
void compile_logical_not(value *v, FILE *output_file){
	int size;

	if(v->data.type == data_register){
		fileprint(output_file, "seq $s%d, $s%d, $zero\n", v->data.reg, v->data.reg);
	} else if(v->data.type == data_stack){
		size = type_size(&(v->data_type), 0);
		if(size == 4){
			fileprint(output_file, "lw $t0, %d($sp)\n", get_stack_pos(v->data));
		} else if(size == 1){
			fileprint(output_file, "lb $t0, %d($sp)\n", get_stack_pos(v->data));
		}
		fileprint(output_file, "seq $t0, $t0, $zero\n");
		fileprint(output_file, "sw $t0, %d($sp)\n", get_stack_pos(v->data));
	}

	v->data_type = INT_TYPE;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x66b0
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rax
movl 0x4(%rax), %edx
movq 0x60(%rsp), %rax
movl 0x4(%rax), %ecx
leaq 0x74ec(%rip), %rsi      # 0xdb90
movb $0x0, %al
callq 0x16f0
jmp 0x67bc
movq 0x60(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x67ba
movq 0x60(%rsp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
callq 0x1a40
movl %eax, 0x54(%rsp)
cmpl $0x4, 0x54(%rsp)
jne 0x671c
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x40(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x48(%rsp)
movq 0x40(%rsp), %rdi
movl 0x48(%rsp), %esi
callq 0x1490
movq 0x18(%rsp), %rdi
movl %eax, %edx
leaq 0x7157(%rip), %rsi      # 0xd86a
movb $0x0, %al
callq 0x16f0
jmp 0x6766
cmpl $0x1, 0x54(%rsp)
jne 0x6764
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x30(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x38(%rsp)
movq 0x30(%rsp), %rdi
movl 0x38(%rsp), %esi
callq 0x1490
movq 0x10(%rsp), %rdi
movl %eax, %edx
leaq 0x7142(%rip), %rsi      # 0xd89f
movb $0x0, %al
callq 0x16f0
jmp 0x6766
movq 0x58(%rsp), %rdi
leaq 0x7435(%rip), %rsi      # 0xdba7
movb $0x0, %al
callq 0x16f0
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0x1490
movq 0x8(%rsp), %rdi
movl %eax, %edx
leaq 0x7026(%rip), %rsi      # 0xd7d9
movb $0x0, %al
callq 0x16f0
jmp 0x67bc
movq 0x60(%rsp), %rdi
addq $0x10, %rdi
leaq 0xa9fc(%rip), %rsi      # 0x111c8
movl $0x40, %edx
callq 0x1120
addq $0x68, %rsp
retq
nopl (%rax,%rax)