LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xaddf(%rip), %r14      # 0xd180
movq %r13, %rdi
movq %r14, %rsi
callq 0x7aec
testb %al, %al
jne 0x23c3
leaq 0xae49(%rip), %rsi      # 0xd200
movq %r13, %rdi
callq 0x7aec
testb %al, %al
je 0x23ed
addq $0x10, %rbp
leaq 0xadb2(%rip), %rsi      # 0xd180
movq %rbp, %rdi
callq 0x7aec
testb %al, %al
jne 0x2421
leaq 0xae1f(%rip), %rsi      # 0xd200
movq %rbp, %rdi
callq 0x7aec
testb %al, %al
jne 0x2421
movups 0x7044(%rip), %xmm0     # 0x9438
leaq 0xb0e5(%rip), %rax      # 0xd4e0
movaps %xmm0, 0x10(%rax)
movups 0x7022(%rip), %xmm0     # 0x9428
movaps %xmm0, (%rax)
movabsq $0x273d3e27206874, %rcx # imm = 0x273D3E27206874
movq %rcx, 0x1f(%rax)
movl $0x1, %edi
callq 0x5b10
leaq 0x6f80(%rip), %rsi      # 0x93a8
movq %r15, %rdi
movq %r12, %rdx
movq %r12, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x171c
leaq 0x6fd2(%rip), %rsi      # 0x9415
movq %r15, %rdi
movq %r12, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x171c
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7a9c
cmpl $0x5, %eax
je 0x24c1
leaq 0x10(%r13), %rdi
callq 0x7a9c
cmpl $0x5, %eax
jne 0x24e7
movups 0x6f95(%rip), %xmm0     # 0x945d
leaq 0xb011(%rip), %rax      # 0xd4e0
movups %xmm0, 0xe(%rax)
movups 0x6f75(%rip), %xmm0     # 0x944f
movaps %xmm0, (%rax)
movl $0x1, %edi
callq 0x5b10
movq %rbp, %rdi
callq 0x7a9c
movl %eax, %r14d
addq $0x10, %r13
movq %r13, %rdi
callq 0x7a9c
cmpl $0x4, %r14d
jne 0x254c
cmpl $0x4, %eax
jne 0x2551
movq %rbp, %rdi
callq 0x7ab4
movq %r13, %rdi
callq 0x7ab4
movq %rbp, %rdi
movq %r13, %rsi
callq 0x7aec
testb %al, %al
jne 0x2582
movups 0x6f4e(%rip), %xmm0     # 0x947d
leaq 0xaeaa(%rip), %rax      # 0xd3e0
movaps %xmm0, 0x10(%rax)
movups 0x6f2c(%rip), %xmm0     # 0x946d
movaps %xmm0, (%rax)
movw $0x73, 0x20(%rax)
jmp 0x257b
cmpl $0x4, %eax
jne 0x2582
movups 0x6f57(%rip), %xmm0     # 0x94af
leaq 0xae81(%rip), %rax      # 0xd3e0
movaps %xmm0, 0x10(%rax)
movups 0x6f35(%rip), %xmm0     # 0x949f
movaps %xmm0, (%rax)
movabsq $0x73657079742072, %rcx # imm = 0x73657079742072
movq %rcx, 0x20(%rax)
xorl %eax, %eax
callq 0x5af8
leaq 0x6f06(%rip), %rsi      # 0x948f
movq %r15, %rdi
movq %r12, %rdx
movq %r12, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x171c
leaq 0xabdc(%rip), %rax      # 0xd180
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7a9c
cmpl $0x5, %eax
je 0x260e
leaq 0x10(%r13), %rdi
callq 0x7a9c
cmpl $0x5, %eax
jne 0x2634
movups 0x6e48(%rip), %xmm0     # 0x945d
leaq 0xaec4(%rip), %rax      # 0xd4e0
movups %xmm0, 0xe(%rax)
movups 0x6e28(%rip), %xmm0     # 0x944f
movaps %xmm0, (%rax)
movl $0x1, %edi
callq 0x5b10
movq %rbp, %rdi
callq 0x7a9c
movl %eax, %r14d
addq $0x10, %r13
movq %r13, %rdi
callq 0x7a9c
cmpl $0x4, %r14d
jne 0x2699
cmpl $0x4, %eax
jne 0x269e
movq %rbp, %rdi
callq 0x7ab4
movq %r13, %rdi
callq 0x7ab4
movq %rbp, %rdi
movq %r13, %rsi
callq 0x7aec
testb %al, %al
jne 0x26cf
movups 0x6e01(%rip), %xmm0     # 0x947d
leaq 0xad5d(%rip), %rax      # 0xd3e0
movaps %xmm0, 0x10(%rax)
movups 0x6ddf(%rip), %xmm0     # 0x946d
movaps %xmm0, (%rax)
movw $0x73, 0x20(%rax)
jmp 0x26c8
cmpl $0x4, %eax
jne 0x26cf
movups 0x6e0a(%rip), %xmm0     # 0x94af
leaq 0xad34(%rip), %rax      # 0xd3e0
movaps %xmm0, 0x10(%rax)
movups 0x6de8(%rip), %xmm0     # 0x949f
movaps %xmm0, (%rax)
movabsq $0x73657079742072, %rcx # imm = 0x73657079742072
movq %rcx, 0x20(%rax)
xorl %eax, %eax
callq 0x5af8
leaq 0x6df1(%rip), %rsi      # 0x94c7
movq %r15, %rdi
movq %r12, %rdx
movq %r12, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x171c
leaq 0xaa8f(%rip), %rax      # 0xd180
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xaa39(%rip), %r14      # 0xd180
movq %r15, %rdi
movq %r14, %rsi
callq 0x7aec
testb %al, %al
jne 0x2769
leaq 0xaaa3(%rip), %rsi      # 0xd200
movq %r15, %rdi
callq 0x7aec
testb %al, %al
je 0x2793
addq $0x10, %rbp
leaq 0xaa0c(%rip), %rsi      # 0xd180
movq %rbp, %rdi
callq 0x7aec
testb %al, %al
jne 0x27b9
leaq 0xaa79(%rip), %rsi      # 0xd200
movq %rbp, %rdi
callq 0x7aec
testb %al, %al
jne 0x27b9
movups 0x6d46(%rip), %xmm0     # 0x94e0
leaq 0xad3f(%rip), %rax      # 0xd4e0
movups %xmm0, 0x9(%rax)
movups 0x6d2b(%rip), %xmm0     # 0x94d7
movaps %xmm0, (%rax)
movl $0x1, %edi
callq 0x5b10
leaq 0x6d30(%rip), %rsi      # 0x94f0
movq %r12, %rdi
movq %r13, %rdx
movq %r13, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x171c
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/expression.c
// Function: operation_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 0xa86b(%rip), %r14      # 0xd180
movq %r15, %rdi
movq %r14, %rsi
callq 0x7aec
testb %al, %al
jne 0x2937
leaq 0xa8d5(%rip), %rsi      # 0xd200
movq %r15, %rdi
callq 0x7aec
testb %al, %al
je 0x2961
addq $0x10, %rbp
leaq 0xa83e(%rip), %rsi      # 0xd180
movq %rbp, %rdi
callq 0x7aec
testb %al, %al
jne 0x298b
leaq 0xa8ab(%rip), %rsi      # 0xd200
movq %rbp, %rdi
callq 0x7aec
testb %al, %al
jne 0x298b
movups 0x6bd0(%rip), %xmm0     # 0x9538
leaq 0xab71(%rip), %rax      # 0xd4e0
movaps %xmm0, 0x10(%rax)
movups 0x6bae(%rip), %xmm0     # 0x9528
movaps %xmm0, (%rax)
movb $0x0, 0x20(%rax)
movl $0x1, %edi
callq 0x5b10
leaq 0x6bb7(%rip), %rsi      # 0x9549
movq %r12, %rdi
movq %r13, %rdx
movq %r13, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x171c
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/expression.c
// Function: operation_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 0xa780(%rip), %r14      # 0xd180
movq %r15, %rdi
movq %r14, %rsi
callq 0x7aec
testb %al, %al
jne 0x2a22
leaq 0xa7ea(%rip), %rsi      # 0xd200
movq %r15, %rdi
callq 0x7aec
testb %al, %al
je 0x2a4c
addq $0x10, %rbp
leaq 0xa753(%rip), %rsi      # 0xd180
movq %rbp, %rdi
callq 0x7aec
testb %al, %al
jne 0x2a76
leaq 0xa7c0(%rip), %rsi      # 0xd200
movq %rbp, %rdi
callq 0x7aec
testb %al, %al
jne 0x2a76
movups 0x6b17(%rip), %xmm0     # 0x956a
leaq 0xaa86(%rip), %rax      # 0xd4e0
movaps %xmm0, 0x10(%rax)
movups 0x6af5(%rip), %xmm0     # 0x955a
movaps %xmm0, (%rax)
movb $0x0, 0x20(%rax)
movl $0x1, %edi
callq 0x5b10
leaq 0x6afe(%rip), %rsi      # 0x957b
movq %r12, %rdi
movq %r13, %rdx
movq %r13, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x171c
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/expression.c
// Function: 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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movslq 0xa7ba(%rip), %r14      # 0xd2c8
testq %r14, %r14
js 0x2b5b
leaq 0xa7b6(%rip), %rax      # 0xd2d0
leaq (%rax,%r14,8), %r15
incq %r14
leaq -0x3f(%rip), %rbx       # 0x2ae9
movq (%r15), %rsi
testq %rsi, %rsi
je 0x2b52
movl $0x9, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
callq 0x72e2
movq (%r15), %rdi
callq 0x1030
movq $0x0, (%r15)
addq $-0x8, %r15
decq %r14
jg 0x2b28
leaq 0xa6e6(%rip), %rax      # 0xd248
movl $0x0, (%rax)
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xabc4(%rip), %rax      # 0xd758
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
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
callq 0x7e08
movl $0x50, %edi
callq 0x1140
movq %rax, %r14
movl $0x20, %edi
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 0x1990
addl $0x3, %eax
andl $-0x4, %eax
leaq 0xa5fd(%rip), %rcx      # 0xd248
movl (%rcx), %edx
leal (%rax,%rdx), %esi
movl %esi, (%rcx)
leal -0x4(%rax,%rdx), %eax
movl %eax, 0x48(%r14)
movslq 0xa667(%rip), %rax      # 0xd2c8
leaq 0xa668(%rip), %r12      # 0xd2d0
movq (%r12,%rax,8), %rsi
movl $0x9, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %r15, %rdi
xorl %esi, %esi
callq 0x7389
testq %rax, %rax
je 0x2cc6
movq %r15, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
leaq 0xa843(%rip), %rax      # 0xd4e0
movups 0x68f8(%rip), %xmm0     # 0x959c
movaps %xmm0, 0x10(%rax)
movups 0x68dd(%rip), %xmm0     # 0x958c
movaps %xmm0, (%rax)
movl $0x6e6f69, 0x20(%rax)   # imm = 0x6E6F69
movl $0x1, %edi
callq 0x5b10
movq (%r14), %r15
movslq 0xa5fb(%rip), %rax      # 0xd2c8
movq (%r12,%rax,8), %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x7441
movq %rbx, %rdi
callq 0x79e2
movq (%rbx), %rax
cmpb $0x3b, (%rax)
je 0x2d1d
leaq 0xa7eb(%rip), %rax      # 0xd4e0
movabsq $0x273b2720646574, %rcx # imm = 0x273B2720646574
movq %rcx, 0x5(%rax)
movabsq $0x6465746365707845, %rcx # imm = 0x6465746365707845
movq %rcx, (%rax)
movl $0x1, %edi
callq 0x5b10
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_O3/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 0x1505
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 0x2d7d
testl %eax, %eax
jne 0x2d9e
movl 0x4(%rbx), %edx
leaq 0x6848(%rip), %rsi      # 0x95bd
movq %r14, %rdi
movl %r15d, %ecx
jmp 0x2d97
movq (%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0x15ba
leaq 0x683b(%rip), %rsi      # 0x95ca
movq %r14, %rdi
movl %r15d, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0x171c
leaq 0xa3db(%rip), %rax      # 0xd180
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_O3/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 0x98ad(%rip), %rax      # 0xd600
movl (%rax), %ebp
movq %r13, %rdi
callq 0x449e
leaq 0x989c(%rip), %rax      # 0xd600
movl %ebp, (%rax)
movq (%r13), %rdi
callq 0x4fef
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 0x4bd3
movabsq $0x10000000040009, %r12 # imm = 0x10000000040009
movq (%r14), %rax
movzbl (%rax), %eax
leal -0x29(%rax), %ecx
cmpl $0x34, %ecx
ja 0x3db0
btq %rcx, %r12
jb 0x3dc4
testl %eax, %eax
je 0x3dc4
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x54c9
jmp 0x3d9c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/expression.c
// Function: skip_string
void skip_string(char **c){
	while(**c && **c != '\"'){
		if(**c == '\\'){
			*c += 2;
		} else {
			++*c;
		}
	}
	if(**c){
		++*c;
	}
}

// Assembly:
movq (%rdi), %rax
movzbl (%rax), %ecx
movl $0x2, %edx
cmpl $0x5c, %ecx
je 0x42a7
testl %ecx, %ecx
je 0x42b5
cmpl $0x22, %ecx
je 0x42af
movl $0x1, %edx
addq %rdx, %rax
movq %rax, (%rdi)
jmp 0x428c
incq %rax
movq %rax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x28, %ecx
jg 0x42df
cmpl $0x22, %ecx
je 0x42f4
cmpl $0x28, %ecx
jne 0x4326
incq %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x42b6
jmp 0x4330
cmpl $0x5b, %ecx
jne 0x431a
incq %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x4371
jmp 0x4330
incq %rax
movq %rax, (%rbx)
movzbl (%rax), %ecx
movl $0x2, %edx
cmpl $0x5c, %ecx
je 0x4315
testl %ecx, %ecx
je 0x4330
cmpl $0x22, %ecx
je 0x432a
movl $0x1, %edx
addq %rdx, %rax
jmp 0x42f7
cmpl $0x29, %ecx
je 0x4369
cmpl $0x5d, %ecx
jne 0x432a
jmp 0x433a
testl %ecx, %ecx
je 0x433a
incq %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x79e2
jmp 0x42ba
leaq 0x919f(%rip), %rax      # 0xd4e0
movabsq $0x27292720646574, %rcx # imm = 0x27292720646574
movq %rcx, 0x5(%rax)
movabsq $0x6465746365707845, %rcx # imm = 0x6465746365707845
movq %rcx, (%rax)
movl $0x1, %edi
callq 0x5b10
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4458
addq $0x2, %rax
movb $0x2f, %cl
testb %cl, %cl
je 0x447f
movzbl %cl, %ecx
cmpl $0xa, %ecx
je 0x447c
movq %rax, (%rdi)
movb (%rax), %cl
incq %rax
jmp 0x4442
addq $0x2, %rax
movq %rax, (%rdi)
movzbl (%rax), %ecx
cmpl $0x2a, %ecx
je 0x446d
testl %ecx, %ecx
jne 0x4473
jmp 0x447f
cmpb $0x2f, 0x1(%rax)
je 0x4478
incq %rax
jmp 0x445c
addq $0x2, %rax
movq %rax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x449b
pushq %rax
incq %rdi
movq %rsp, %rsi
movq %rdi, (%rsi)
xorl %edi, %edi
callq 0x7896
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/expression.c
// Function: skip_value
void skip_value(char **c){
	skip_whitespace(c);
	while(**c == '*' || **c == '&' || **c == '!' || **c == '~' || **c == '-' || is_cast(*c) || is_whitespace(*c)){
		if(**c == '('){//ie if we are casting
			++*c;
			match_parentheses(c);
		} else if(**c == '/'){
			skip_comment(c);
		} else {
			++*c;
		}
	}
	while(**c == '('){
		++*c;
		match_parentheses(c);
		skip_whitespace(c);
	}
	if(digit(**c)){
		while(digit(**c)){
			++*c;
		}
	} else if(alpha(**c)){
		while(alphanumeric(**c)){
			++*c;
		}
	} else if(**c == '\"'){
		++*c;
		skip_string(c);
	} else if(**c == '\''){
		++*c;
		if(**c == '\\'){
			++*c;
		}
		while(**c && **c != '\''){
			++*c;
		}
		if(**c){
			++*c;
		}
	}
	skip_whitespace(c);
	while(**c == '[' || **c == '('){
		if(**c == '('){
			++*c;
			match_parentheses(c);
		} else if(**c == '['){
			++*c;
			match_brackets(c);
		}
		skip_whitespace(c);
		skip_whitespace(c);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x79e2
leaq 0x8(%rsp), %r14
movabsq $0x244200000000, %r15   # imm = 0x244200000000
movq (%rbx), %rdi
movzbl (%rdi), %eax
cmpq $0x2d, %rax
ja 0x44d0
btq %rax, %r15
jb 0x4500
cmpl $0x7e, %eax
je 0x4500
cmpb $0x28, %al
jne 0x44f2
incq %rdi
movq %rdi, 0x8(%rsp)
xorl %edi, %edi
movq %r14, %rsi
callq 0x7896
movq (%rbx), %rdi
testb %al, %al
jne 0x44fe
callq 0x79ae
movq (%rbx), %rdi
testb %al, %al
je 0x4544
movb (%rdi), %al
cmpb $0x2f, %al
je 0x451c
movzbl %al, %eax
incq %rdi
cmpl $0x28, %eax
jne 0x4526
movq %rdi, (%rbx)
movq %rbx, %rdi
callq 0x42b6
jmp 0x44be
movq %rbx, %rdi
callq 0x442c
jmp 0x44be
movq %rdi, (%rbx)
jmp 0x44be
incq %rdi
movq %rdi, (%rbx)
movq %rbx, %rdi
callq 0x42b6
movq %rbx, %rdi
callq 0x79e2
movq (%rbx), %rdi
movb (%rdi), %al
cmpb $0x28, %al
je 0x452b
movsbl %al, %edi
callq 0x75a0
movq (%rbx), %rcx
movb (%rcx), %cl
movsbl %cl, %edi
testb %al, %al
jne 0x459b
callq 0x756c
movq (%rbx), %rcx
movzbl (%rcx), %edx
testb %al, %al
je 0x45a9
movsbl %dl, %edi
callq 0x7581
testb %al, %al
je 0x4632
movq (%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movsbl 0x1(%rax), %edi
jmp 0x4570
movq (%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movsbl 0x1(%rax), %edi
callq 0x75a0
testb %al, %al
jne 0x458d
jmp 0x4632
cmpl $0x27, %edx
je 0x45dc
cmpl $0x22, %edx
jne 0x4632
incq %rcx
movq %rcx, %rax
movq %rax, (%rbx)
movzbl (%rax), %ecx
movl $0x2, %edx
cmpl $0x5c, %ecx
je 0x45d7
testl %ecx, %ecx
je 0x4632
cmpl $0x22, %ecx
je 0x4604
movl $0x1, %edx
addq %rdx, %rax
jmp 0x45b9
leaq 0x1(%rcx), %rax
movq %rax, (%rbx)
cmpb $0x5c, 0x1(%rcx)
jne 0x45f3
addq $0x2, %rcx
movq %rcx, %rax
movq %rax, (%rbx)
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x4632
cmpl $0x27, %ecx
je 0x4604
incq %rax
jmp 0x45f0
incq %rax
movq %rax, (%rbx)
jmp 0x4632
incq %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x42b6
jmp 0x462a
incq %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x4371
movq %rbx, %rdi
callq 0x79e2
movq %rbx, %rdi
callq 0x79e2
movq (%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x5b, %ecx
je 0x461c
cmpl $0x28, %ecx
je 0x460c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rdi, %rbx
movq (%rsi), %rax
incq %rax
movq %rax, (%rsi)
movzbl (%rax), %edx
movl $0x2, %edi
cmpl $0x5c, %edx
je 0x4682
testl %edx, %edx
je 0x468d
cmpl $0x22, %edx
je 0x4687
movl $0x1, %edi
addq %rdi, %rax
jmp 0x4664
incq %rax
movq %rax, (%rsi)
movzbl %cl, %edi
callq 0x1505
movq %rax, (%rbx)
movl %edx, 0x8(%rbx)
cmpl $0x1, %eax
je 0x46c3
testl %eax, %eax
jne 0x46f8
shrq $0x20, %rax
movl 0x8bc6(%rip), %ecx      # 0xd274
leaq 0x5282(%rip), %rsi      # 0x9937
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x171c
jmp 0x46f8
movl 0x8bab(%rip), %edx      # 0xd274
leaq 0x5279(%rip), %rsi      # 0x9949
movq %r14, %rdi
xorl %eax, %eax
callq 0x171c
movq (%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0x15ba
leaq 0x4ee9(%rip), %rsi      # 0x95d5
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x171c
cmpb $0x0, 0x8b79(%rip)      # 0xd278
je 0x4707
incl 0x8b6d(%rip)            # 0xd274
leaq 0x10(%rbx), %rdi
leaq 0x8aee(%rip), %rax      # 0xd200
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)
movl $0x4, %esi
callq 0x75ac
movb $0x0, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x48d3
testl %eax, %eax
jne 0x4941
movl 0x4(%rbx), %ecx
leaq 0x50c7(%rip), %rsi      # 0x998c
movq %r14, %rdi
movl %ecx, %edx
xorl %eax, %eax
callq 0x171c
jmp 0x4941
leaq 0x10(%rbx), %rdi
xorl %esi, %esi
callq 0x1990
cmpl $0x4, %eax
je 0x48f1
cmpl $0x1, %eax
jne 0x4912
leaq 0x4dac(%rip), %r15      # 0x969b
jmp 0x48f8
leaq 0x4d6e(%rip), %r15      # 0x9666
movq (%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0x15ba
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x171c
leaq 0x508a(%rip), %rsi      # 0x99a3
movq %r14, %rdi
xorl %eax, %eax
callq 0x171c
movq (%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0x15ba
leaq 0x4ca0(%rip), %rsi      # 0x95d5
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x171c
leaq 0x8838(%rip), %rax      # 0xd180
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)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/expression.c
// Function: compile_not
void compile_not(value *v, FILE *output_file){
	int size;

	if(!types_equal(&(v->data_type), &INT_TYPE) && !types_equal(&(v->data_type), &CHAR_TYPE)){
		snprintf(error_message, sizeof(error_message), "Can't perform bitwise not of non-numerical type");
		do_error(1);
	}
	if(v->data.type == data_register){
		fileprint(output_file, "nor $s%d, $s%d, $s%d\n", v->data.reg, 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, "nor $t0, $t0, $t0\n");
		fileprint(output_file, "sw $t0, %d($sp)\n", get_stack_pos(v->data));
	}

	v->data_type = INT_TYPE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x10(%rdi), %rbx
leaq 0x87f9(%rip), %r14      # 0xd180
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7aec
testb %al, %al
jne 0x49da
leaq 0x8863(%rip), %rsi      # 0xd200
movq %rbx, %rdi
callq 0x7aec
testb %al, %al
jne 0x49da
movups 0x5028(%rip), %xmm0     # 0x99d8
leaq 0x8b29(%rip), %rax      # 0xd4e0
movaps %xmm0, 0x20(%rax)
movups 0x5006(%rip), %xmm0     # 0x99c8
movaps %xmm0, 0x10(%rax)
movups 0x4feb(%rip), %xmm0     # 0x99b8
movaps %xmm0, (%rax)
movl $0x1, %edi
callq 0x5b10
movl (%r12), %eax
cmpl $0x1, %eax
je 0x4a08
testl %eax, %eax
jne 0x4a7b
movl 0x4(%r12), %ecx
leaq 0x4ff1(%rip), %rsi      # 0x99e8
movq %r15, %rdi
movl %ecx, %edx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x171c
jmp 0x4a7b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1990
cmpl $0x4, %eax
je 0x4a25
cmpl $0x1, %eax
jne 0x4a49
leaq 0x4c78(%rip), %r13      # 0x969b
jmp 0x4a2c
leaq 0x4c3a(%rip), %r13      # 0x9666
movq (%r12), %rdi
movl 0x8(%r12), %esi
callq 0x15ba
movq %r15, %rdi
movq %r13, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x171c
leaq 0x4fae(%rip), %rsi      # 0x99fe
movq %r15, %rdi
xorl %eax, %eax
callq 0x171c
movq (%r12), %rdi
movl 0x8(%r12), %esi
callq 0x15ba
leaq 0x4b66(%rip), %rsi      # 0x95d5
movq %r15, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x171c
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/expression.c
// Function: compile_negate
void compile_negate(value *v, FILE *output_file){
	int size;

	if(!types_equal(&(v->data_type), &INT_TYPE) && !types_equal(&(v->data_type), &CHAR_TYPE)){
		snprintf(error_message, sizeof(error_message), "Can't negate non-numerical type");
		do_error(1);
	}
	if(v->data.type == data_register){
		fileprint(output_file, "sub $s%d, $zero, $s%d\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, "sub $t0, $zero, $t0\n");
		fileprint(output_file, "sw $t0, %d($sp)\n", get_stack_pos(v->data));
	}

	v->data_type = INT_TYPE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x10(%rdi), %rbx
leaq 0x86bf(%rip), %r14      # 0xd180
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7aec
testb %al, %al
jne 0x4b09
leaq 0x8729(%rip), %rsi      # 0xd200
movq %rbx, %rdi
callq 0x7aec
testb %al, %al
jne 0x4b09
movups 0x4f37(%rip), %xmm0     # 0x9a21
leaq 0x89ef(%rip), %rax      # 0xd4e0
movaps %xmm0, 0x10(%rax)
movups 0x4f15(%rip), %xmm0     # 0x9a11
movaps %xmm0, (%rax)
movl $0x1, %edi
callq 0x5b10
movl (%r12), %eax
cmpl $0x1, %eax
je 0x4b34
testl %eax, %eax
jne 0x4ba7
movl 0x4(%r12), %ecx
leaq 0x4f0b(%rip), %rsi      # 0x9a31
movq %r15, %rdi
movl %ecx, %edx
xorl %eax, %eax
callq 0x171c
jmp 0x4ba7
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1990
cmpl $0x4, %eax
je 0x4b51
cmpl $0x1, %eax
jne 0x4b75
leaq 0x4b4c(%rip), %r13      # 0x969b
jmp 0x4b58
leaq 0x4b0e(%rip), %r13      # 0x9666
movq (%r12), %rdi
movl 0x8(%r12), %esi
callq 0x15ba
movq %r15, %rdi
movq %r13, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x171c
leaq 0x4ecc(%rip), %rsi      # 0x9a48
movq %r15, %rdi
xorl %eax, %eax
callq 0x171c
movq (%r12), %rdi
movl 0x8(%r12), %esi
callq 0x15ba
leaq 0x4a3a(%rip), %rsi      # 0x95d5
movq %r15, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x171c
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/expression.c
// Function: peek_operation
operation peek_operation(char *c){
	switch(*c){
		case '+':
			return operation_add;
		case '-':
			return operation_subtract;
		case '*':
			return operation_multiply;
		case '/':
			return operation_divide;
		case '%':
			return operation_modulo;
		case '=':
			if(c[1] == '='){
				return operation_equals;
			} else {
				return operation_assign;
			}
		case '!':
			if(c[1] == '='){
				return operation_not_equals;
			} else {
				return operation_none;
			}
		case '>':
			if(c[1] == '>'){
				return operation_shift_right;
			} else if(c[1] == '='){
				return operation_greater_than_or_equal;
			} else {
				return operation_greater_than;
			}
		case '<':
			if(c[1] == '<'){
				return operation_shift_left;
			} else if(c[1] == '='){
				return operation_less_than_or_equal;
			} else {
				return operation_less_than;
			}
		case '&':
			if(c[1] == '&'){
				return operation_logical_and;
			} else {
				return operation_and;
			}
		case '|':
			if(c[1] == '|'){
				return operation_logical_or;
			} else {
				return operation_or;
			}
	}

	return operation_none;
}

// Assembly:
movzbl (%rdi), %eax
cmpl $0x3b, %eax
jg 0x5023
addl $-0x21, %eax
cmpl $0xe, %eax
ja 0x50c4
leaq 0x405a(%rip), %rcx      # 0x9064
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %ecx, %ecx
cmpb $0x3d, 0x1(%rdi)
movl $0xb, %eax
jmp 0x50c0
cmpl $0x3d, %eax
jg 0x5046
cmpl $0x3c, %eax
je 0x508e
cmpl $0x3d, %eax
jne 0x50c4
xorl %eax, %eax
cmpb $0x3d, 0x1(%rdi)
sete %al
leal (%rax,%rax,4), %eax
addl $0x5, %eax
retq
cmpl $0x3e, %eax
je 0x50a8
cmpl $0x7c, %eax
jne 0x50c4
xorl %eax, %eax
cmpb $0x7c, 0x1(%rdi)
sete %al
leal (%rax,%rax,2), %eax
addl $0xd, %eax
retq
movl $0x2, %eax
retq
movl $0x1, %eax
retq
xorl %eax, %eax
cmpb $0x26, 0x1(%rdi)
sete %al
leal (%rax,%rax,2), %eax
addl $0xc, %eax
retq
movl $0x3, %eax
retq
movl $0xe, %eax
retq
movl $0x4, %eax
retq
movb 0x1(%rdi), %al
xorl %ecx, %ecx
cmpb $0x3d, %al
sete %cl
leal 0x6(,%rcx,2), %ecx
cmpb $0x3c, %al
movl $0x11, %eax
jmp 0x50c0
movb 0x1(%rdi), %al
xorl %ecx, %ecx
cmpb $0x3d, %al
sete %cl
leal 0x7(,%rcx,2), %ecx
cmpb $0x3e, %al
movl $0x12, %eax
cmovnel %ecx, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/expression.c
// Function: get_operation
operation get_operation(char **c){
	operation output;

	skip_whitespace(c);
	switch(**c){
		case '+':
			output = operation_add;
			break;
		case '-':
			output = operation_subtract;
			break;
		case '*':
			output = operation_multiply;
			break;
		case '/':
			output = operation_divide;
			break;
		case '%':
			output = operation_modulo;
			break;
		case '=':
			if((*c)[1] == '='){
				output = operation_equals;
				++*c;
			} else {
				output = operation_assign;
			}
			break;
		case '!':
			if((*c)[1] == '='){
				output = operation_not_equals;
				++*c;
			} else {
				output = operation_none;
			}
			break;
		case '>':
			if((*c)[1] == '>'){
				output = operation_shift_right;
				++*c;
			} else if((*c)[1] == '='){
				output = operation_greater_than_or_equal;
				++*c;
			} else {
				output = operation_greater_than;
			}
			break;
		case '<':
			if((*c)[1] == '<'){
				output = operation_shift_left;
				++*c;
			} else if((*c)[1] == '='){
				output = operation_less_than_or_equal;
				++*c;
			} else {
				output = operation_less_than;
			}
			break;
		case '&':
			if((*c)[1] == '&'){
				output = operation_logical_and;
				++*c;
			} else {
				output = operation_and;
			}
			break;
		case '|':
			if((*c)[1] == '|'){
				output = operation_logical_or;
				++*c;
			} else {
				output = operation_or;
			}
			break;
		default:
			output = operation_none;
			break;
	}
	++*c;
	return output;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x79e2
movq (%rbx), %rcx
movzbl (%rcx), %eax
cmpl $0x3b, %eax
jg 0x5112
addl $-0x21, %eax
cmpl $0xe, %eax
ja 0x51ee
leaq 0x3fb2(%rip), %rdx      # 0x90a0
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
leaq 0x1(%rcx), %rax
xorl %edx, %edx
cmpb $0x3d, 0x1(%rcx)
cmoveq %rax, %rcx
movl $0xb, %eax
cmovnel %edx, %eax
jmp 0x5201
cmpl $0x3d, %eax
jg 0x5145
cmpl $0x3c, %eax
je 0x51b2
cmpl $0x3d, %eax
jne 0x51ee
leaq 0x1(%rcx), %rax
xorl %edx, %edx
cmpb $0x3d, 0x1(%rcx)
sete %dl
cmoveq %rax, %rcx
leal (%rdx,%rdx,4), %eax
addl $0x5, %eax
jmp 0x5201
cmpl $0x3e, %eax
je 0x51d0
cmpl $0x7c, %eax
jne 0x51ee
leaq 0x1(%rcx), %rax
xorl %edx, %edx
cmpb $0x7c, 0x1(%rcx)
sete %dl
cmoveq %rax, %rcx
leal (%rdx,%rdx,2), %eax
addl $0xd, %eax
jmp 0x5201
movl $0x2, %eax
jmp 0x5201
movl $0x1, %eax
jmp 0x5201
leaq 0x1(%rcx), %rax
xorl %edx, %edx
cmpb $0x26, 0x1(%rcx)
sete %dl
cmoveq %rax, %rcx
leal (%rdx,%rdx,2), %eax
addl $0xc, %eax
jmp 0x5201
movl $0x3, %eax
jmp 0x5201
movl $0xe, %eax
jmp 0x5201
movl $0x4, %eax
jmp 0x5201
leaq 0x1(%rcx), %rdx
movzbl 0x1(%rcx), %esi
cmpl $0x3d, %esi
je 0x51f2
movl $0x6, %eax
cmpl $0x3c, %esi
jne 0x5201
movl $0x11, %eax
jmp 0x51fe
leaq 0x1(%rcx), %rdx
movzbl 0x1(%rcx), %esi
cmpl $0x3d, %esi
je 0x51f9
movl $0x7, %eax
cmpl $0x3e, %esi
jne 0x5201
movl $0x12, %eax
jmp 0x51fe
xorl %eax, %eax
jmp 0x5201
movl $0x8, %eax
jmp 0x51fe
movl $0x9, %eax
movq %rdx, %rcx
incq %rcx
movq %rcx, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/expression.c
// Function: determine_stack_size
void determine_stack_size(value *first_value, char **c, unsigned char dereference, unsigned char force_stack){
	char *temp_c;

	do_print = 0;
	saved_stack_size = 0;
	temp_c = *c;
	compile_expression(first_value, c, dereference, force_stack, NULL);
	*c = temp_c;
	do_print = 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb $0x0, 0x788a(%rip)      # 0xd278
leaq 0x7857(%rip), %rax      # 0xd24c
movl $0x0, (%rax)
movq (%rsi), %r14
xorl %r8d, %r8d
callq 0x3d22
movq %r14, (%rbx)
movb $0x1, 0x7868(%rip)      # 0xd278
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/expression.c
// Function: compile_root_expression
void compile_root_expression(value *first_value, char **c, unsigned char dereference, unsigned char force_stack, FILE *output_file){
	determine_stack_size(first_value, c, dereference, force_stack);
	deallocate(first_value->data);
	if(saved_stack_size != 0){
		fprintf(output_file, "addi $sp, $sp, %d\n", -saved_stack_size);
	}
	compile_expression(first_value, c, dereference, force_stack, output_file);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %r15
movb $0x0, 0x7840(%rip)      # 0xd278
leaq 0x780d(%rip), %rax      # 0xd24c
movl $0x0, (%rax)
movq (%rsi), %r13
xorl %r8d, %r8d
callq 0x3d22
movq %r13, (%r14)
movb $0x1, 0x781e(%rip)      # 0xd278
movq (%r15), %rdi
movl 0x8(%r15), %esi
callq 0x156a
leaq 0x77df(%rip), %rax      # 0xd24c
movl (%rax), %edx
testl %edx, %edx
je 0x5a86
negl %edx
leaq 0x3d68(%rip), %rsi      # 0x97e4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movzbl %r12b, %edx
movzbl %bpl, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3d22
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/expression.c
// Function: reset_stack_pos
void reset_stack_pos(value *first_value, FILE *output_file){
	if(first_value->data.type == data_stack){
		fprintf(output_file, "lw $t0, %d($sp)\n", get_stack_pos(first_value->data));
	}
	if(saved_stack_size != 0){
		fprintf(output_file, "addi $sp, $sp, %d\n", saved_stack_size);
	}
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
cmpl $0x1, (%rdi)
jne 0x5ad4
movq (%rdi), %rax
movl 0x8(%rdi), %esi
movq %rax, %rdi
callq 0x15ba
leaq 0x3b9e(%rip), %rsi      # 0x9666
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x7771(%rip), %rax      # 0xd24c
movl (%rax), %edx
testl %edx, %edx
je 0x5af3
leaq 0x3cfc(%rip), %rsi      # 0x97e4
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x1100
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/compile.c
// Function: do_error
void do_error(int status){
	fclose(output_file);
	error_message[255] = '\0';
	print_line();
	fprintf(stderr, "Error: %s\n", error_message);
	free(program);
	free_local_variables();
	free_global_variables();
	exit(status);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x7ac3(%rip), %rdi      # 0xd5e0
callq 0x1080
movb $0x0, 0x7ab6(%rip)      # 0xd5df
leaq 0x79b0(%rip), %r14      # 0xd4e0
callq 0x11b0
movq 0x74bc(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x40bc(%rip), %rsi      # 0x9c02
movq %r14, %rdx
xorl %eax, %eax
callq 0x1100
movq 0x7a91(%rip), %rdi      # 0xd5e8
callq 0x1030
xorl %eax, %eax
callq 0x2afe
xorl %eax, %eax
callq 0x2ac2
movl %ebx, %edi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/compile.c
// Function: compile_file
void compile_file(char *program, char *identifier_name, char *arguments, unsigned int identifier_length, unsigned int num_arguments, FILE *output_file){
	int current_line_temp;

	program_pointer = program;
	program_beginning = program;
	fprintf(output_file, ".data\n");
	current_line = 1;
	skip_whitespace(&program_pointer);
	current_line_temp = current_line;
	compile_string_constants(program_pointer, output_file);
	current_line = current_line_temp;
	fprintf(output_file, ".text\n\n");
	while(*program_pointer){
		compile_function(&program_pointer, identifier_name, arguments, identifier_length, num_arguments, output_file);
		free_local_variables();
		skip_whitespace(&program_pointer);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, 0x7a5e(%rip)      # 0xd5f0
leaq 0x7a57(%rip), %r13      # 0xd5f0
movq %rdi, 0x7a58(%rip)      # 0xd5f8
leaq 0x4066(%rip), %rdi      # 0x9c0d
movl $0x6, %esi
movl $0x1, %edx
movq %r9, %rcx
callq 0x1190
movl $0x1, 0x7a3d(%rip)      # 0xd600
movq %r13, %rdi
callq 0x79e2
movl 0x7a2e(%rip), %r13d     # 0xd600
movq 0x7a17(%rip), %rdi      # 0xd5f0
movq %rbx, %rsi
callq 0x5c55
movl %r13d, 0x7a18(%rip)     # 0xd600
leaq 0x4025(%rip), %rdi      # 0x9c14
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq 0x79e8(%rip), %rax      # 0xd5f0
cmpb $0x0, (%rax)
je 0x5c46
leaq 0x79dc(%rip), %r13      # 0xd5f0
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movq %rbx, %r9
callq 0x5d3b
xorl %eax, %eax
callq 0x2afe
movq %r13, %rdi
callq 0x79e2
movq 0x79af(%rip), %rax      # 0xd5f0
cmpb $0x0, (%rax)
jne 0x5c14
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq