LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x7a61
cmpl $0x5, %eax
je 0x2602
leaq 0x10(%r13), %rdi
callq 0x7a61
cmpl $0x5, %eax
jne 0x2628
movups 0x6e54(%rip), %xmm0     # 0x945d
leaq 0xaed0(%rip), %rax      # 0xd4e0
movups %xmm0, 0xe(%rax)
movups 0x6e34(%rip), %xmm0     # 0x944f
movaps %xmm0, (%rax)
movl $0x1, %edi
callq 0x5ae0
movq %rbp, %rdi
callq 0x7a61
movl %eax, %r14d
addq $0x10, %r13
movq %r13, %rdi
callq 0x7a61
cmpl $0x4, %r14d
jne 0x268d
cmpl $0x4, %eax
jne 0x2692
movq %rbp, %rdi
callq 0x7a79
movq %r13, %rdi
callq 0x7a79
movq %rbp, %rdi
movq %r13, %rsi
callq 0x7ab1
testb %al, %al
jne 0x26c3
movups 0x6e0d(%rip), %xmm0     # 0x947d
leaq 0xad69(%rip), %rax      # 0xd3e0
movaps %xmm0, 0x10(%rax)
movups 0x6deb(%rip), %xmm0     # 0x946d
movaps %xmm0, (%rax)
movw $0x73, 0x20(%rax)
jmp 0x26bc
cmpl $0x4, %eax
jne 0x26c3
movups 0x6e16(%rip), %xmm0     # 0x94af
leaq 0xad40(%rip), %rax      # 0xd3e0
movaps %xmm0, 0x10(%rax)
movups 0x6df4(%rip), %xmm0     # 0x949f
movaps %xmm0, (%rax)
movabsq $0x73657079742072, %rcx # imm = 0x73657079742072
movq %rcx, 0x20(%rax)
xorl %eax, %eax
callq 0x5ac8
leaq 0x6dfd(%rip), %rsi      # 0x94c7
movq %r15, %rdi
movq %r12, %rdx
movq %r12, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x1710
leaq 0xaa9b(%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_O1/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 0xaa45(%rip), %r14      # 0xd180
movq %r15, %rdi
movq %r14, %rsi
callq 0x7ab1
testb %al, %al
jne 0x275d
leaq 0xaaaf(%rip), %rsi      # 0xd200
movq %r15, %rdi
callq 0x7ab1
testb %al, %al
je 0x2787
addq $0x10, %rbp
leaq 0xaa18(%rip), %rsi      # 0xd180
movq %rbp, %rdi
callq 0x7ab1
testb %al, %al
jne 0x27ad
leaq 0xaa85(%rip), %rsi      # 0xd200
movq %rbp, %rdi
callq 0x7ab1
testb %al, %al
jne 0x27ad
movups 0x6d52(%rip), %xmm0     # 0x94e0
leaq 0xad4b(%rip), %rax      # 0xd4e0
movups %xmm0, 0x9(%rax)
movups 0x6d37(%rip), %xmm0     # 0x94d7
movaps %xmm0, (%rax)
movl $0x1, %edi
callq 0x5ae0
leaq 0x6d3c(%rip), %rsi      # 0x94f0
movq %r12, %rdi
movq %r13, %rdx
movq %r13, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x1710
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/been-jamming[P]MinimalCC/expression.c
// Function: operation_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 0xa877(%rip), %r14      # 0xd180
movq %r15, %rdi
movq %r14, %rsi
callq 0x7ab1
testb %al, %al
jne 0x292b
leaq 0xa8e1(%rip), %rsi      # 0xd200
movq %r15, %rdi
callq 0x7ab1
testb %al, %al
je 0x2955
addq $0x10, %rbp
leaq 0xa84a(%rip), %rsi      # 0xd180
movq %rbp, %rdi
callq 0x7ab1
testb %al, %al
jne 0x297f
leaq 0xa8b7(%rip), %rsi      # 0xd200
movq %rbp, %rdi
callq 0x7ab1
testb %al, %al
jne 0x297f
movups 0x6bdc(%rip), %xmm0     # 0x9538
leaq 0xab7d(%rip), %rax      # 0xd4e0
movaps %xmm0, 0x10(%rax)
movups 0x6bba(%rip), %xmm0     # 0x9528
movaps %xmm0, (%rax)
movb $0x0, 0x20(%rax)
movl $0x1, %edi
callq 0x5ae0
leaq 0x6bc3(%rip), %rsi      # 0x9549
movq %r12, %rdi
movq %r13, %rdx
movq %r13, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x1710
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/been-jamming[P]MinimalCC/expression.c
// Function: operation_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 0xa78c(%rip), %r14      # 0xd180
movq %r15, %rdi
movq %r14, %rsi
callq 0x7ab1
testb %al, %al
jne 0x2a16
leaq 0xa7f6(%rip), %rsi      # 0xd200
movq %r15, %rdi
callq 0x7ab1
testb %al, %al
je 0x2a40
addq $0x10, %rbp
leaq 0xa75f(%rip), %rsi      # 0xd180
movq %rbp, %rdi
callq 0x7ab1
testb %al, %al
jne 0x2a6a
leaq 0xa7cc(%rip), %rsi      # 0xd200
movq %rbp, %rdi
callq 0x7ab1
testb %al, %al
jne 0x2a6a
movups 0x6b23(%rip), %xmm0     # 0x956a
leaq 0xaa92(%rip), %rax      # 0xd4e0
movaps %xmm0, 0x10(%rax)
movups 0x6b01(%rip), %xmm0     # 0x955a
movaps %xmm0, (%rax)
movb $0x0, 0x20(%rax)
movl $0x1, %edi
callq 0x5ae0
leaq 0x6b0a(%rip), %rsi      # 0x957b
movq %r12, %rdi
movq %r13, %rdx
movq %r13, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x1710
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/been-jamming[P]MinimalCC/expression.c
// Function: 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 0xa7c6(%rip), %r14      # 0xd2c8
testq %r14, %r14
js 0x2b4f
leaq 0xa7c2(%rip), %rax      # 0xd2d0
leaq (%rax,%r14,8), %r15
incq %r14
leaq -0x3f(%rip), %rbx       # 0x2add
movq (%r15), %rsi
testq %rsi, %rsi
je 0x2b46
movl $0x9, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
callq 0x72a6
movq (%r15), %rdi
callq 0x1030
movq $0x0, (%r15)
addq $-0x8, %r15
decq %r14
jg 0x2b1c
leaq 0xa6f2(%rip), %rax      # 0xd248
movl $0x0, (%rax)
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xabd0(%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 0x7e04
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 0x1984
addl $0x3, %eax
andl $-0x4, %eax
leaq 0xa609(%rip), %rcx      # 0xd248
movl (%rcx), %edx
leal (%rax,%rdx), %esi
movl %esi, (%rcx)
leal -0x4(%rax,%rdx), %eax
movl %eax, 0x48(%r14)
movslq 0xa673(%rip), %rax      # 0xd2c8
leaq 0xa674(%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 0x734d
testq %rax, %rax
je 0x2cb7
movq (%r14), %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
leaq 0xa84f(%rip), %rax      # 0xd4e0
movups 0x6904(%rip), %xmm0     # 0x959c
movaps %xmm0, 0x10(%rax)
movups 0x68e9(%rip), %xmm0     # 0x958c
movaps %xmm0, (%rax)
movl $0x6e6f69, 0x20(%rax)   # imm = 0x6E6F69
movl $0x1, %edi
callq 0x5ae0
movslq 0xa60a(%rip), %rax      # 0xd2c8
movq (%r12,%rax,8), %rdi
movq (%r14), %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x7405
movq %rbx, %rdi
callq 0x799f
movq (%rbx), %rax
cmpb $0x3b, (%rax)
je 0x2d0b
leaq 0xa7fa(%rip), %rax      # 0xd4e0
movabsq $0x273b2720646574, %rcx # imm = 0x273B2720646574
movq %rcx, 0x5(%rax)
movabsq $0x6465746365707845, %rcx # imm = 0x6465746365707845
movq %rcx, (%rax)
movl $0x1, %edi
callq 0x5ae0
incq (%rbx)
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/been-jamming[P]MinimalCC/expression.c
// Function: 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 0x2d68
testl %eax, %eax
jne 0x2d89
movl 0x4(%rbx), %edx
leaq 0x685d(%rip), %rsi      # 0x95bd
movq %r14, %rdi
movl %r15d, %ecx
jmp 0x2d82
movq (%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0x15ba
leaq 0x6850(%rip), %rsi      # 0x95ca
movq %r14, %rdi
movl %r15d, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0x1710
leaq 0xa3f0(%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_O1/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 0x98c7(%rip), %rax      # 0xd600
movl (%rax), %ebp
movq %r13, %rdi
callq 0x4474
leaq 0x98b6(%rip), %rax      # 0xd600
movl %ebp, (%rax)
movq (%r13), %rdi
callq 0x4fb2
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 0x4ba2
movabsq $0x10000000040009, %r12 # imm = 0x10000000040009
movq (%r14), %rax
movzbl (%rax), %eax
leal -0x29(%rax), %ecx
cmpl $0x34, %ecx
ja 0x3d96
btq %rcx, %r12
jb 0x3daa
testl %eax, %eax
je 0x3daa
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5499
jmp 0x3d82
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/been-jamming[P]MinimalCC/expression.c
// Function: 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 0x4287
testl %ecx, %ecx
je 0x4295
cmpl $0x22, %ecx
je 0x428f
movl $0x1, %edx
addq %rdx, %rax
movq %rax, (%rdi)
jmp 0x426c
incq %rax
movq %rax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x42bf
cmpl $0x22, %ecx
je 0x42d4
cmpl $0x28, %ecx
jne 0x4306
incq %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x4296
jmp 0x4310
cmpl $0x5b, %ecx
jne 0x42fa
incq %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x434b
jmp 0x4310
incq %rax
movq %rax, (%rbx)
movzbl (%rax), %ecx
movl $0x2, %edx
cmpl $0x5c, %ecx
je 0x42f5
testl %ecx, %ecx
je 0x4310
cmpl $0x22, %ecx
je 0x430a
movl $0x1, %edx
addq %rdx, %rax
jmp 0x42d7
cmpl $0x29, %ecx
je 0x4346
cmpl $0x5d, %ecx
jne 0x430a
jmp 0x431a
testl %ecx, %ecx
je 0x431a
incq %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x799f
jmp 0x429a
leaq 0x91bf(%rip), %rax      # 0xd4e0
movabsq $0x27292720646574, %rcx # imm = 0x27292720646574
movq %rcx, 0x5(%rax)
movabsq $0x6465746365707845, %rcx # imm = 0x6465746365707845
movq %rcx, (%rax)
movl $0x1, %edi
callq 0x5ae0
incq (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4428
movq (%rdi), %rax
incq %rax
movzbl -0x1(%rax), %ecx
testl %ecx, %ecx
je 0x4453
cmpl $0xa, %ecx
je 0x4450
movq %rax, (%rdi)
jmp 0x4413
addq $0x2, %rax
movq %rax, (%rdi)
movzbl (%rax), %ecx
cmpl $0x2a, %ecx
je 0x443d
testl %ecx, %ecx
jne 0x4443
jmp 0x4453
cmpb $0x2f, 0x1(%rax)
je 0x4448
incq %rax
jmp 0x442c
testb %cl, %cl
je 0x4453
addq $0x2, %rax
movq %rax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rax
movq %rdi, (%rsp)
cmpb $0x28, (%rdi)
jne 0x4470
incq %rdi
movq %rsp, %rsi
movq %rdi, (%rsi)
xorl %edi, %edi
callq 0x7853
jmp 0x4472
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x799f
leaq 0x8(%rsp), %r14
movabsq $0x244200000000, %r15   # imm = 0x244200000000
movq (%rbx), %rax
movzbl (%rax), %ecx
cmpq $0x2d, %rcx
ja 0x44a6
btq %rcx, %r15
jb 0x44d7
cmpl $0x7e, %ecx
je 0x44d7
movq %rax, 0x8(%rsp)
cmpb $0x28, (%rax)
jne 0x44cb
incq %rax
movq %rax, 0x8(%rsp)
xorl %edi, %edi
movq %r14, %rsi
callq 0x7853
testb %al, %al
jne 0x44d7
movq (%rbx), %rdi
callq 0x796b
testb %al, %al
je 0x451c
movq (%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x2f, %ecx
je 0x44f7
incq %rax
cmpl $0x28, %ecx
jne 0x4501
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x4296
jmp 0x4494
movq %rbx, %rdi
callq 0x4400
jmp 0x4494
movq %rax, (%rbx)
jmp 0x4494
incq %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x4296
movq %rbx, %rdi
callq 0x799f
movq (%rbx), %rax
movb (%rax), %cl
cmpb $0x28, %cl
je 0x4506
movsbl %cl, %edi
callq 0x755c
movq (%rbx), %rcx
movb (%rcx), %cl
movsbl %cl, %edi
testb %al, %al
jne 0x4577
callq 0x7528
movq (%rbx), %rcx
movzbl (%rcx), %edx
testb %al, %al
je 0x4585
movsbl %dl, %edi
callq 0x753d
testb %al, %al
je 0x460e
movq (%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movsbl 0x1(%rax), %edi
jmp 0x454c
movq (%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movsbl 0x1(%rax), %edi
callq 0x755c
testb %al, %al
jne 0x4569
jmp 0x460e
cmpl $0x27, %edx
je 0x45b5
cmpl $0x22, %edx
jne 0x460e
incq %rcx
movq %rcx, (%rbx)
movzbl (%rcx), %eax
movl $0x2, %edx
cmpl $0x5c, %eax
je 0x45b0
testl %eax, %eax
je 0x460e
cmpl $0x22, %eax
je 0x45e0
movl $0x1, %edx
addq %rdx, %rcx
jmp 0x4592
leaq 0x1(%rcx), %rax
movq %rax, (%rbx)
cmpb $0x5c, 0x1(%rcx)
jne 0x45c9
addq $0x2, %rcx
movq %rcx, (%rbx)
movq (%rbx), %rcx
movzbl (%rcx), %eax
testl %eax, %eax
je 0x460e
cmpl $0x27, %eax
je 0x45e0
incq %rcx
movq %rcx, (%rbx)
jmp 0x45cc
incq %rcx
movq %rcx, (%rbx)
jmp 0x460e
incq %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x4296
jmp 0x4606
incq %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x434b
movq %rbx, %rdi
callq 0x799f
movq %rbx, %rdi
callq 0x799f
movq (%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x5b, %ecx
je 0x45f8
cmpl $0x28, %ecx
je 0x45e8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x465e
testl %edx, %edx
je 0x4669
cmpl $0x22, %edx
je 0x4663
movl $0x1, %edi
addq %rdi, %rax
jmp 0x4640
incq %rax
movq %rax, (%rsi)
movzbl %cl, %edi
callq 0x1505
movq %rax, (%rbx)
movl %edx, 0x8(%rbx)
cmpl $0x1, %eax
je 0x469c
testl %eax, %eax
jne 0x46d1
movl 0x4(%rbx), %edx
movl 0x8beb(%rip), %ecx      # 0xd274
leaq 0x52a7(%rip), %rsi      # 0x9937
movq %r14, %rdi
xorl %eax, %eax
callq 0x1710
jmp 0x46d1
movl 0x8bd2(%rip), %edx      # 0xd274
leaq 0x52a0(%rip), %rsi      # 0x9949
movq %r14, %rdi
xorl %eax, %eax
callq 0x1710
movq (%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0x15ba
leaq 0x4f10(%rip), %rsi      # 0x95d5
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x1710
cmpb $0x0, 0x8ba0(%rip)      # 0xd278
je 0x46e0
incl 0x8b94(%rip)            # 0xd274
leaq 0x10(%rbx), %rdi
leaq 0x8b15(%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 0x7568
movb $0x0, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/been-jamming[P]MinimalCC/expression.c
// Function: compile_character
void compile_character(value *output, char **c, unsigned char dereference, unsigned char force_stack, FILE *output_file){
	int char_constant = 0;
	char escape_sequences[] = {'a', 'b', 'e', 'f', 'n', 'r', 't', 'v', '\\', '\'', '\"', '\?'};
	int escape_values[] = {0x07, 0x08, 0x1B, 0x0C, 0x0A, 0x0D, 0x09, 0x0B, 0x5C, 0x27, 0x22, 0x3F};
	unsigned char i;

	++*c;

	if(**c == '\\'){
		++*c;
		for(i = 0; i < sizeof(escape_sequences)/sizeof(char); i++){
			if(**c == escape_sequences[i]){
				char_constant = escape_values[i];
			}
		}
		if(!char_constant){
			snprintf(error_message, sizeof(error_message), "Unrecognized escape sequence\n");
			do_error(1);
		}
	} else {
		char_constant = **c;
	}
	++*c;
	if(**c != '\''){
		snprintf(error_message, sizeof(error_message), "Expected closing '\n");
		do_error(1);
	}
	++*c;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r14
movl %ecx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rsi)
movsbl 0x1(%rax), %ebp
cmpl $0x5c, %ebp
jne 0x47a4
leaq 0x2(%rax), %rcx
movq %rcx, (%r12)
movb 0x2(%rax), %al
xorl %ecx, %ecx
leaq 0x4995(%rip), %rdx      # 0x90f0
leaq 0x497a(%rip), %rsi      # 0x90dc
xorl %ebp, %ebp
cmpb (%rcx,%rsi), %al
jne 0x476b
movl (%rdx), %ebp
incq %rcx
addq $0x4, %rdx
cmpq $0xc, %rcx
jne 0x4764
testl %ebp, %ebp
jne 0x47a4
movups 0x51e5(%rip), %xmm0     # 0x9968
leaq 0x8d56(%rip), %rax      # 0xd4e0
movups %xmm0, 0xe(%rax)
movups 0x51c5(%rip), %xmm0     # 0x995a
movaps %xmm0, (%rax)
movl $0x1, %edi
callq 0x5ae0
xorl %ebp, %ebp
movq (%r12), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%r12)
cmpb $0x27, 0x1(%rax)
je 0x47d8
movups 0x51bb(%rip), %xmm0     # 0x9978
leaq 0x8d1c(%rip), %rax      # 0xd4e0
movaps %xmm0, (%rax)
movl $0xa2720, 0x10(%rax)    # imm = 0xA2720
movl $0x1, %edi
callq 0x5ae0
incq (%r12)
movzbl %r15b, %edi
callq 0x1505
movq %rax, (%rbx)
movl %edx, 0x8(%rbx)
cmpl $0x1, %eax
je 0x480c
testl %eax, %eax
jne 0x483d
movl 0x4(%rbx), %edx
leaq 0x4dbf(%rip), %rsi      # 0x95bd
movq %r14, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x1710
jmp 0x483d
leaq 0x5045(%rip), %rsi      # 0x9858
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1710
movq (%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0x15ba
leaq 0x4da4(%rip), %rsi      # 0x95d5
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x1710
leaq 0x893c(%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 %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x48a2
testl %eax, %eax
jne 0x4910
movl 0x4(%rbx), %ecx
leaq 0x50f8(%rip), %rsi      # 0x998c
movq %r14, %rdi
movl %ecx, %edx
xorl %eax, %eax
callq 0x1710
jmp 0x4910
leaq 0x10(%rbx), %rdi
xorl %esi, %esi
callq 0x1984
cmpl $0x4, %eax
je 0x48c0
cmpl $0x1, %eax
jne 0x48e1
leaq 0x4ddd(%rip), %r15      # 0x969b
jmp 0x48c7
leaq 0x4d9f(%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 0x1710
leaq 0x50bb(%rip), %rsi      # 0x99a3
movq %r14, %rdi
xorl %eax, %eax
callq 0x1710
movq (%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0x15ba
leaq 0x4cd1(%rip), %rsi      # 0x95d5
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x1710
leaq 0x8869(%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_O1/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 0x882a(%rip), %r14      # 0xd180
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7ab1
testb %al, %al
jne 0x49a9
leaq 0x8894(%rip), %rsi      # 0xd200
movq %rbx, %rdi
callq 0x7ab1
testb %al, %al
jne 0x49a9
movups 0x5059(%rip), %xmm0     # 0x99d8
leaq 0x8b5a(%rip), %rax      # 0xd4e0
movaps %xmm0, 0x20(%rax)
movups 0x5037(%rip), %xmm0     # 0x99c8
movaps %xmm0, 0x10(%rax)
movups 0x501c(%rip), %xmm0     # 0x99b8
movaps %xmm0, (%rax)
movl $0x1, %edi
callq 0x5ae0
movl (%r12), %eax
cmpl $0x1, %eax
je 0x49d7
testl %eax, %eax
jne 0x4a4a
movl 0x4(%r12), %ecx
leaq 0x5022(%rip), %rsi      # 0x99e8
movq %r15, %rdi
movl %ecx, %edx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x1710
jmp 0x4a4a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1984
cmpl $0x4, %eax
je 0x49f4
cmpl $0x1, %eax
jne 0x4a18
leaq 0x4ca9(%rip), %r13      # 0x969b
jmp 0x49fb
leaq 0x4c6b(%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 0x1710
leaq 0x4fdf(%rip), %rsi      # 0x99fe
movq %r15, %rdi
xorl %eax, %eax
callq 0x1710
movq (%r12), %rdi
movl 0x8(%r12), %esi
callq 0x15ba
leaq 0x4b97(%rip), %rsi      # 0x95d5
movq %r15, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x1710
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x86f0(%rip), %r14      # 0xd180
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7ab1
testb %al, %al
jne 0x4ad8
leaq 0x875a(%rip), %rsi      # 0xd200
movq %rbx, %rdi
callq 0x7ab1
testb %al, %al
jne 0x4ad8
movups 0x4f68(%rip), %xmm0     # 0x9a21
leaq 0x8a20(%rip), %rax      # 0xd4e0
movaps %xmm0, 0x10(%rax)
movups 0x4f46(%rip), %xmm0     # 0x9a11
movaps %xmm0, (%rax)
movl $0x1, %edi
callq 0x5ae0
movl (%r12), %eax
cmpl $0x1, %eax
je 0x4b03
testl %eax, %eax
jne 0x4b76
movl 0x4(%r12), %ecx
leaq 0x4f3c(%rip), %rsi      # 0x9a31
movq %r15, %rdi
movl %ecx, %edx
xorl %eax, %eax
callq 0x1710
jmp 0x4b76
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1984
cmpl $0x4, %eax
je 0x4b20
cmpl $0x1, %eax
jne 0x4b44
leaq 0x4b7d(%rip), %r13      # 0x969b
jmp 0x4b27
leaq 0x4b3f(%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 0x1710
leaq 0x4efd(%rip), %rsi      # 0x9a48
movq %r15, %rdi
xorl %eax, %eax
callq 0x1710
movq (%r12), %rdi
movl 0x8(%r12), %esi
callq 0x15ba
leaq 0x4a6b(%rip), %rsi      # 0x95d5
movq %r15, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x1710
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4fe6
addl $-0x21, %eax
cmpl $0xe, %eax
ja 0x5087
leaq 0x4097(%rip), %rcx      # 0x9064
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %ecx, %ecx
cmpb $0x3d, 0x1(%rdi)
movl $0xb, %eax
jmp 0x5083
cmpl $0x3d, %eax
jg 0x5009
cmpl $0x3c, %eax
je 0x5051
cmpl $0x3d, %eax
jne 0x5087
xorl %eax, %eax
cmpb $0x3d, 0x1(%rdi)
sete %al
leal (%rax,%rax,4), %eax
addl $0x5, %eax
retq
cmpl $0x3e, %eax
je 0x506b
cmpl $0x7c, %eax
jne 0x5087
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 0x5083
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_O1/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 0x799f
movq (%rbx), %rcx
movzbl (%rcx), %eax
cmpl $0x3b, %eax
jg 0x50d6
addl $-0x21, %eax
cmpl $0xe, %eax
ja 0x51be
leaq 0x3fef(%rip), %rdx      # 0x90a0
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
xorl %eax, %eax
cmpb $0x3d, 0x1(%rcx)
jne 0x51d4
incq %rcx
movq %rcx, (%rbx)
movl $0xb, %eax
jmp 0x51d4
cmpl $0x3d, %eax
jg 0x510c
cmpl $0x3c, %eax
je 0x517e
cmpl $0x3d, %eax
jne 0x51be
movl $0x5, %eax
cmpb $0x3d, 0x1(%rcx)
jne 0x51d4
incq %rcx
movq %rcx, (%rbx)
movl $0xa, %eax
jmp 0x51d4
cmpl $0x3e, %eax
je 0x519e
cmpl $0x7c, %eax
jne 0x51be
movl $0xd, %eax
cmpb $0x7c, 0x1(%rcx)
jne 0x51d4
incq %rcx
movq %rcx, (%rbx)
movl $0x10, %eax
jmp 0x51d4
movl $0x2, %eax
jmp 0x51d4
movl $0x1, %eax
jmp 0x51d4
movl $0xc, %eax
cmpb $0x26, 0x1(%rcx)
jne 0x51d4
incq %rcx
movq %rcx, (%rbx)
movl $0xf, %eax
jmp 0x51d4
movl $0x3, %eax
jmp 0x51d4
movl $0xe, %eax
jmp 0x51d4
movl $0x4, %eax
jmp 0x51d4
movzbl 0x1(%rcx), %edx
incq %rcx
cmpl $0x3d, %edx
je 0x51c2
movl $0x6, %eax
cmpl $0x3c, %edx
jne 0x51d4
movq %rcx, (%rbx)
movl $0x11, %eax
jmp 0x51d4
movzbl 0x1(%rcx), %edx
incq %rcx
cmpl $0x3d, %edx
je 0x51cc
movl $0x7, %eax
cmpl $0x3e, %edx
jne 0x51d4
movq %rcx, (%rbx)
movl $0x12, %eax
jmp 0x51d4
xorl %eax, %eax
jmp 0x51d4
movq %rcx, (%rbx)
movl $0x8, %eax
jmp 0x51d4
movq %rcx, (%rbx)
movl $0x9, %eax
incq (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x78ba(%rip)      # 0xd278
leaq 0x7887(%rip), %rax      # 0xd24c
movl $0x0, (%rax)
movq (%rsi), %r14
xorl %r8d, %r8d
callq 0x3d08
movq %r14, (%rbx)
movb $0x1, 0x7898(%rip)      # 0xd278
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x7870(%rip)      # 0xd278
leaq 0x783d(%rip), %rax      # 0xd24c
movl $0x0, (%rax)
movq (%rsi), %r13
xorl %r8d, %r8d
callq 0x3d08
movq %r13, (%r14)
movb $0x1, 0x784e(%rip)      # 0xd278
movq (%r15), %rdi
movl 0x8(%r15), %esi
callq 0x156a
leaq 0x780f(%rip), %rax      # 0xd24c
movl (%rax), %edx
testl %edx, %edx
je 0x5a56
negl %edx
leaq 0x3d98(%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 0x3d08
// File: /workspace/github_c_makefile_star2_O1/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 0x5aa4
movq (%rdi), %rax
movl 0x8(%rdi), %esi
movq %rax, %rdi
callq 0x15ba
leaq 0x3bce(%rip), %rsi      # 0x9666
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x77a1(%rip), %rax      # 0xd24c
movl (%rax), %edx
testl %edx, %edx
je 0x5ac3
leaq 0x3d2c(%rip), %rsi      # 0x97e4
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x1100
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x7af3(%rip), %rdi      # 0xd5e0
callq 0x1080
movb $0x0, 0x7ae6(%rip)      # 0xd5df
leaq 0x79e0(%rip), %r14      # 0xd4e0
callq 0x11b0
movq 0x74ec(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x40ec(%rip), %rsi      # 0x9c02
movq %r14, %rdx
xorl %eax, %eax
callq 0x1100
movq 0x7ac1(%rip), %rdi      # 0xd5e8
callq 0x1030
xorl %eax, %eax
callq 0x2af2
xorl %eax, %eax
callq 0x2ab6
movl %ebx, %edi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O1/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, 0x7a8e(%rip)      # 0xd5f0
leaq 0x7a87(%rip), %r13      # 0xd5f0
movq %rdi, 0x7a88(%rip)      # 0xd5f8
leaq 0x4096(%rip), %rdi      # 0x9c0d
movl $0x6, %esi
movl $0x1, %edx
movq %r9, %rcx
callq 0x1190
movl $0x1, 0x7a6d(%rip)      # 0xd600
movq %r13, %rdi
callq 0x799f
movl 0x7a5e(%rip), %r13d     # 0xd600
movq 0x7a47(%rip), %rdi      # 0xd5f0
movq %rbx, %rsi
callq 0x5c25
movl %r13d, 0x7a48(%rip)     # 0xd600
leaq 0x4055(%rip), %rdi      # 0x9c14
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
movq 0x7a18(%rip), %rax      # 0xd5f0
cmpb $0x0, (%rax)
je 0x5c16
leaq 0x7a0c(%rip), %r13      # 0xd5f0
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movq %rbx, %r9
callq 0x5d09
xorl %eax, %eax
callq 0x2af2
movq %r13, %rdi
callq 0x799f
movq 0x79df(%rip), %rax      # 0xd5f0
cmpb $0x0, (%rax)
jne 0x5be4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/been-jamming[P]MinimalCC/compile.c
// Function: compile_string_constants
void compile_string_constants(char *c, FILE *output_file){
	unsigned char ignore;

	ignore = 0;
	skip_whitespace(&c);
	while(*c){
		if(ignore || *c != '"'){
			ignore = 0;
			if(*c == '\\' || *c == '\''){
				ignore = 1;
			} else if(*c == '\n'){
				current_line++;
			}
			c++;
		} else {
			c++;
			fprintf(output_file, "__str%d:\n", num_strs);
			fprintf(output_file, ".asciiz \"");
			place_string_constant(&c, output_file);
			fprintf(output_file, "\n");
			num_strs++;
		}
		skip_whitespace(&c);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %rdi, (%r14)
movq %r14, %rdi
callq 0x799f
movq (%r14), %rax
movb (%rax), %cl
testb %cl, %cl
je 0x5cfc
xorl %ebp, %ebp
leaq 0x4202(%rip), %r14      # 0x9e5c
leaq 0x4205(%rip), %r15      # 0x9e66
leaq 0x8(%rsp), %r12
movl %ecx, %edx
xorb $0x22, %dl
orb %bpl, %dl
jne 0x5cc0
incq %rax
movq %rax, 0x8(%rsp)
movl 0x775a(%rip), %edx      # 0xd3d8
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1100
movl $0x9, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x1190
movq %r12, %rdi
movq %rbx, %rsi
callq 0x6f69
movl $0xa, %edi
movq %rbx, %rsi
callq 0x10e0
incl 0x771a(%rip)            # 0xd3d8
jmp 0x5ce5
movb $0x1, %bpl
cmpb $0x5c, %cl
je 0x5cdd
movzbl %cl, %ecx
cmpl $0x27, %ecx
je 0x5cdd
cmpl $0xa, %ecx
jne 0x5cdb
incl 0x7925(%rip)            # 0xd600
xorl %ebp, %ebp
incq %rax
movq %rax, 0x8(%rsp)
movq %r12, %rdi
callq 0x799f
movq 0x8(%rsp), %rax
movb (%rax), %cl
testb %cl, %cl
jne 0x5c66
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/been-jamming[P]MinimalCC/compile.c
// Function: place_string_constant
void place_string_constant(char **c, FILE *output_file){
	unsigned char ignore_next = 0;
	char *beginning;

	beginning = *c;

	while(**c && (**c != '"' || ignore_next)){
		fprintf(output_file, "%c", **c);
		if(**c == '\\'){
			ignore_next = 1;
		} else {
			ignore_next = 0;
		}
		if(**c == '\n'){
			program_pointer = *c;
			snprintf(error_message, sizeof(error_message), "Expected closing '\"'");
			do_error(1);
		}
		++*c;
	}

	if(!**c){
		program_pointer = beginning;
		snprintf(error_message, sizeof(error_message), "Expected closing '\"'");
		do_error(1);
	}
	fprintf(output_file, "\"");
	++*c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %r15
movb (%r15), %al
testb %al, %al
je 0x6fb7
movq %rsi, %r14
movq %rdi, %rbx
xorl %ecx, %ecx
cmpb $0x22, %al
sete %dl
notb %cl
testb %dl, %cl
jne 0x6fc0
movsbl %al, %edi
movq %r14, %rsi
callq 0x10e0
movq (%rbx), %rax
movb (%rax), %cl
cmpb $0xa, %cl
je 0x6fd6
cmpb $0x5c, %cl
sete %cl
movq (%rbx), %rax
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb 0x1(%rax), %al
testb %al, %al
jne 0x6f80
movq %r15, 0x6632(%rip)      # 0xd5f0
jmp 0x6fdd
movl $0x22, %edi
movq %r14, %rsi
callq 0x10e0
incq (%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, 0x6613(%rip)      # 0xd5f0
movups 0x2e63(%rip), %xmm0     # 0x9e47
movaps %xmm0, 0x64f5(%rip)     # 0xd4e0
movabsq $0x27222720676e69, %rax # imm = 0x27222720676E69
movq %rax, 0x64f1(%rip)      # 0xd4ed
movl $0x1, %edi
callq 0x5ae0