LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7549
movabsq $0x244200000000, %r14   # imm = 0x244200000000
movq (%rbx), %rdi
movzbl (%rdi), %eax
cmpq $0x2d, %rax
ja 0x4183
btq %rax, %r14
jb 0x41a2
cmpl $0x7e, %eax
je 0x41a2
callq 0x413d
movq (%rbx), %rdi
testb %al, %al
jne 0x41a0
callq 0x7515
testb %al, %al
je 0x41e3
movq (%rbx), %rdi
movb (%rdi), %al
cmpb $0x2f, %al
je 0x41be
movzbl %al, %eax
incq %rdi
cmpl $0x28, %eax
jne 0x41c8
movq %rdi, (%rbx)
movq %rbx, %rdi
callq 0x3fb1
jmp 0x4171
movq %rbx, %rdi
callq 0x40e9
jmp 0x4171
movq %rdi, (%rbx)
jmp 0x4171
incq %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x3fb1
movq %rbx, %rdi
callq 0x7549
movq (%rbx), %rax
movb (%rax), %cl
cmpb $0x28, %cl
je 0x41cd
movsbl %cl, %edi
callq 0x71f8
movq (%rbx), %rcx
testb %al, %al
je 0x4217
movsbl (%rcx), %edi
callq 0x71f8
testb %al, %al
je 0x42ab
movq (%rbx), %rcx
incq %rcx
movq %rcx, (%rbx)
jmp 0x41fc
movsbl (%rcx), %edi
callq 0x71c4
movq (%rbx), %rcx
testb %al, %al
je 0x423d
movsbl (%rcx), %edi
callq 0x71d9
testb %al, %al
je 0x42ab
movq (%rbx), %rcx
incq %rcx
movq %rcx, (%rbx)
jmp 0x4226
movzbl (%rcx), %eax
cmpl $0x27, %eax
je 0x425a
cmpl $0x22, %eax
jne 0x42ab
incq %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
callq 0x3f82
jmp 0x42ab
leaq 0x1(%rcx), %rax
movq %rax, (%rbx)
cmpb $0x5c, 0x1(%rcx)
jne 0x4271
addq $0x2, %rcx
movq %rcx, %rax
movq %rax, (%rbx)
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x42ab
incq %rax
cmpl $0x27, %ecx
jne 0x426e
movq %rax, (%rbx)
jmp 0x42ab
incq %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x3fb1
jmp 0x42a3
incq %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x404d
movq %rbx, %rdi
callq 0x7549
movq %rbx, %rdi
callq 0x7549
movq (%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x5b, %ecx
je 0x4295
cmpl $0x28, %ecx
je 0x4285
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %r8, %r14
movl %ecx, %ebp
movq %rdi, %rbx
incq (%rsi)
movq %rsi, %rdi
callq 0x3f82
movl %ebp, %edi
callq 0x12e0
movq %rax, (%rbx)
movl %edx, 0x8(%rbx)
cmpl $0x1, %eax
je 0x4317
testl %eax, %eax
jne 0x434c
shrq $0x20, %rax
movl 0x7f72(%rip), %ecx      # 0xc274
leaq 0x460e(%rip), %rsi      # 0x8917
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x14e8
jmp 0x434c
movl 0x7f57(%rip), %edx      # 0xc274
leaq 0x4605(%rip), %rsi      # 0x8929
movq %r14, %rdi
xorl %eax, %eax
callq 0x14e8
movq (%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0x1393
leaq 0x4275(%rip), %rsi      # 0x85b5
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x14e8
cmpb $0x0, 0x7f25(%rip)      # 0xc278
je 0x435b
incl 0x7f19(%rip)            # 0xc274
leaq 0x10(%rbx), %rdi
leaq 0x7e9a(%rip), %rax      # 0xc200
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)
pushq $0x4
popq %rsi
callq 0x7204
movb $0x0, 0x50(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4520
testl %eax, %eax
jne 0x458e
movl 0x4(%rbx), %ecx
leaq 0x445a(%rip), %rsi      # 0x896c
movq %r14, %rdi
movl %ecx, %edx
xorl %eax, %eax
callq 0x14e8
jmp 0x458e
leaq 0x10(%rbx), %rdi
xorl %esi, %esi
callq 0x1756
cmpl $0x4, %eax
je 0x453e
cmpl $0x1, %eax
jne 0x455f
leaq 0x413f(%rip), %r15      # 0x867b
jmp 0x4545
leaq 0x4101(%rip), %r15      # 0x8646
movq (%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0x1393
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x14e8
leaq 0x441d(%rip), %rsi      # 0x8983
movq %r14, %rdi
xorl %eax, %eax
callq 0x14e8
movq (%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0x1393
leaq 0x4033(%rip), %rsi      # 0x85b5
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x14e8
leaq 0x7beb(%rip), %rax      # 0xc180
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %xmm3
movups %xmm3, 0x40(%rbx)
movups %xmm2, 0x30(%rbx)
movups %xmm1, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7bac(%rip), %r14      # 0xc180
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7653
testb %al, %al
jne 0x4625
leaq 0x7c16(%rip), %rsi      # 0xc200
movq %rbx, %rdi
callq 0x7653
testb %al, %al
jne 0x4625
movups 0x43bb(%rip), %xmm0     # 0x89b8
leaq 0x7edc(%rip), %rax      # 0xc4e0
movaps %xmm0, 0x20(%rax)
movups 0x4399(%rip), %xmm0     # 0x89a8
movaps %xmm0, 0x10(%rax)
movups 0x437e(%rip), %xmm0     # 0x8998
movaps %xmm0, (%rax)
pushq $0x1
popq %rdi
callq 0x56c5
movl (%r12), %eax
cmpl $0x1, %eax
je 0x4653
testl %eax, %eax
jne 0x46c6
movl 0x4(%r12), %ecx
leaq 0x4386(%rip), %rsi      # 0x89c8
movq %r15, %rdi
movl %ecx, %edx
movl %ecx, %r8d
xorl %eax, %eax
callq 0x14e8
jmp 0x46c6
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1756
cmpl $0x4, %eax
je 0x4670
cmpl $0x1, %eax
jne 0x4694
leaq 0x400d(%rip), %r13      # 0x867b
jmp 0x4677
leaq 0x3fcf(%rip), %r13      # 0x8646
movq (%r12), %rdi
movl 0x8(%r12), %esi
callq 0x1393
movq %r15, %rdi
movq %r13, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x14e8
leaq 0x4343(%rip), %rsi      # 0x89de
movq %r15, %rdi
xorl %eax, %eax
callq 0x14e8
movq (%r12), %rdi
movl 0x8(%r12), %esi
callq 0x1393
leaq 0x3efb(%rip), %rsi      # 0x85b5
movq %r15, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x14e8
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7a74(%rip), %r14      # 0xc180
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7653
testb %al, %al
jne 0x4752
leaq 0x7ade(%rip), %rsi      # 0xc200
movq %rbx, %rdi
callq 0x7653
testb %al, %al
jne 0x4752
movups 0x42cc(%rip), %xmm0     # 0x8a01
leaq 0x7da4(%rip), %rax      # 0xc4e0
movaps %xmm0, 0x10(%rax)
movups 0x42aa(%rip), %xmm0     # 0x89f1
movaps %xmm0, (%rax)
pushq $0x1
popq %rdi
callq 0x56c5
movl (%r12), %eax
cmpl $0x1, %eax
je 0x477d
testl %eax, %eax
jne 0x47f0
movl 0x4(%r12), %ecx
leaq 0x42a2(%rip), %rsi      # 0x8a11
movq %r15, %rdi
movl %ecx, %edx
xorl %eax, %eax
callq 0x14e8
jmp 0x47f0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1756
cmpl $0x4, %eax
je 0x479a
cmpl $0x1, %eax
jne 0x47be
leaq 0x3ee3(%rip), %r13      # 0x867b
jmp 0x47a1
leaq 0x3ea5(%rip), %r13      # 0x8646
movq (%r12), %rdi
movl 0x8(%r12), %esi
callq 0x1393
movq %r15, %rdi
movq %r13, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x14e8
leaq 0x4263(%rip), %rsi      # 0x8a28
movq %r15, %rdi
xorl %eax, %eax
callq 0x14e8
movq (%r12), %rdi
movl 0x8(%r12), %esi
callq 0x1393
leaq 0x3dd1(%rip), %rsi      # 0x85b5
movq %r15, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x14e8
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
leal -0x21(%rax), %ecx
cmpl $0xe, %ecx
ja 0x4c41
leaq 0x3421(%rip), %rax      # 0x804c
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
xorl %ecx, %ecx
cmpb $0x3d, 0x1(%rdi)
pushq $0xb
jmp 0x4cc8
cmpl $0x3c, %eax
je 0x4c8c
cmpl $0x3d, %eax
je 0x4ca3
cmpl $0x3e, %eax
je 0x4cb3
cmpl $0x7c, %eax
jne 0x4c65
xorl %eax, %eax
cmpb $0x7c, 0x1(%rdi)
sete %al
leal (%rax,%rax,2), %eax
addl $0xd, %eax
retq
xorl %eax, %eax
retq
pushq $0x3
jmp 0x4c8a
pushq $0xe
jmp 0x4c8a
pushq $0x1
jmp 0x4c8a
xorl %eax, %eax
cmpb $0x26, 0x1(%rdi)
sete %al
leal (%rax,%rax,2), %eax
addl $0xc, %eax
retq
pushq $0x4
jmp 0x4c8a
pushq $0x2
popq %rax
retq
movb 0x1(%rdi), %al
xorl %ecx, %ecx
cmpb $0x3d, %al
sete %cl
leal 0x6(,%rcx,2), %ecx
cmpb $0x3c, %al
pushq $0x11
jmp 0x4cc8
xorl %eax, %eax
cmpb $0x3d, 0x1(%rdi)
sete %al
leal (%rax,%rax,4), %eax
addl $0x5, %eax
retq
movb 0x1(%rdi), %al
xorl %ecx, %ecx
cmpb $0x3d, %al
sete %cl
leal 0x7(,%rcx,2), %ecx
cmpb $0x3e, %al
pushq $0x12
popq %rax
cmovnel %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7549
movq (%rbx), %rcx
movzbl (%rcx), %eax
leal -0x21(%rax), %edx
cmpl $0xe, %edx
ja 0x4d0d
leaq 0x339d(%rip), %rax      # 0x8088
movslq (%rax,%rdx,4), %rdx
addq %rax, %rdx
jmpq *%rdx
leaq 0x1(%rcx), %rax
xorl %edx, %edx
cmpb $0x3d, 0x1(%rcx)
cmoveq %rax, %rcx
pushq $0xb
popq %rax
cmovnel %edx, %eax
jmp 0x4dd0
cmpl $0x3c, %eax
je 0x4d78
cmpl $0x3d, %eax
je 0x4d8e
cmpl $0x3e, %eax
je 0x4da7
cmpl $0x7c, %eax
jne 0x4d41
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 0x4dd0
xorl %eax, %eax
jmp 0x4dd0
pushq $0x3
jmp 0x4dcf
pushq $0xe
jmp 0x4dcf
pushq $0x1
jmp 0x4dcf
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 0x4dd0
pushq $0x4
jmp 0x4dcf
pushq $0x2
jmp 0x4dcf
leaq 0x1(%rcx), %rdx
movzbl 0x1(%rcx), %eax
cmpl $0x3d, %eax
je 0x4dbd
cmpl $0x3c, %eax
jne 0x4dc9
pushq $0x11
jmp 0x4dc3
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 0x4dd0
leaq 0x1(%rcx), %rdx
movzbl 0x1(%rcx), %eax
cmpl $0x3d, %eax
je 0x4dc1
cmpl $0x3e, %eax
jne 0x4dcd
pushq $0x12
jmp 0x4dc3
pushq $0x8
jmp 0x4dc3
pushq $0x9
popq %rax
movq %rdx, %rcx
jmp 0x4dd0
pushq $0x6
jmp 0x4dcf
pushq $0x7
popq %rax
incq %rcx
movq %rcx, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x6cc8(%rip)      # 0xc278
leaq 0x6c95(%rip), %rax      # 0xc24c
andl $0x0, (%rax)
movq (%rsi), %r14
xorl %r8d, %r8d
callq 0x3a29
movq %r14, (%rbx)
movb $0x1, 0x6ca9(%rip)      # 0xc278
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %r15
callq 0x55a2
movq (%r15), %rdi
movl 0x8(%r15), %esi
callq 0x1343
leaq 0x6c47(%rip), %rax      # 0xc24c
movl (%rax), %edx
testl %edx, %edx
je 0x561e
negl %edx
leaq 0x31b0(%rip), %rsi      # 0x87c4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movzbl %r12b, %edx
movzbl %bpl, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %r8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3a29
// File: /workspace/github_c_makefile_star2_O2/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 0x5666
movq (%rdi), %rax
movl 0x8(%rdi), %esi
movq %rax, %rdi
callq 0x1393
leaq 0x2fec(%rip), %rsi      # 0x8646
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x6bdf(%rip), %rax      # 0xc24c
movl (%rax), %edx
testl %edx, %edx
je 0x5685
leaq 0x314a(%rip), %rsi      # 0x87c4
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x1100
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/compile.c
// Function: do_warning
void do_warning(){
	if(do_print){
		warning_message[255] = '\0';
		print_line();
		fprintf(stderr, "Warning: %s\n", warning_message);
	}
}

// Assembly:
leaq 0x6be9(%rip), %rax      # 0xc278
cmpb $0x0, (%rax)
jne 0x5695
retq
pushq %rbx
movb $0x0, 0x6e42(%rip)      # 0xc4df
leaq 0x6d3c(%rip), %rbx      # 0xc3e0
callq 0x6e58
movq 0x6948(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x351b(%rip), %rsi      # 0x8bd5
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
jmp 0x1100
// File: /workspace/github_c_makefile_star2_O2/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 0x6f0e(%rip), %rdi      # 0xc5e0
callq 0x1080
movb $0x0, 0x6f01(%rip)      # 0xc5df
leaq 0x6dfb(%rip), %r14      # 0xc4e0
callq 0x6e58
movq 0x6907(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x34e7(%rip), %rsi      # 0x8be2
movq %r14, %rdx
xorl %eax, %eax
callq 0x1100
movq 0x6edc(%rip), %rdi      # 0xc5e8
callq 0x1030
xorl %eax, %eax
callq 0x289b
xorl %eax, %eax
callq 0x2861
movl %ebx, %edi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/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, 0x6ea9(%rip)      # 0xc5f0
leaq 0x6ea2(%rip), %r13      # 0xc5f0
movq %rdi, 0x6ea3(%rip)      # 0xc5f8
leaq 0x3491(%rip), %rdi      # 0x8bed
pushq $0x6
popq %rsi
pushq $0x1
popq %rdx
movq %r9, %rcx
callq 0x1190
movl $0x1, 0x6e8c(%rip)      # 0xc600
movq %r13, %rdi
callq 0x7549
movl 0x6e7e(%rip), %eax      # 0xc600
movl %eax, 0x4(%rsp)
movq 0x6e63(%rip), %rdi      # 0xc5f0
movq %rbx, %rsi
callq 0x57f7
movl 0x4(%rsp), %eax
movl %eax, 0x6e61(%rip)      # 0xc600
leaq 0x344e(%rip), %rdi      # 0x8bf4
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x1190
movq 0x6e35(%rip), %rax      # 0xc5f0
cmpb $0x0, (%rax)
je 0x57e8
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movq %rbx, %r9
callq 0x58c4
xorl %eax, %eax
callq 0x289b
movq %r13, %rdi
callq 0x7549
jmp 0x57b4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsp, %r14
movq %rdi, (%r14)
xorl %r12d, %r12d
pushq $0x9
popq %r13
pushq $0x1
popq %rbp
pushq $0xa
popq %r15
movq %r14, %rdi
callq 0x7549
movq (%rsp), %rax
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x58b5
testb %r12b, %r12b
jne 0x588e
cmpb $0x22, %cl
jne 0x588e
incq %rax
movq %rax, (%rsp)
movl 0x6b91(%rip), %edx      # 0xc3d8
xorl %r12d, %r12d
movq %rbx, %rdi
leaq 0x35dc(%rip), %rsi      # 0x8e30
xorl %eax, %eax
callq 0x1100
leaq 0x35d8(%rip), %rdi      # 0x8e3a
movq %r13, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
callq 0x1190
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6ad3
movl %r15d, %edi
movq %rbx, %rsi
callq 0x10e0
incl 0x6b4c(%rip)            # 0xc3d8
jmp 0x5819
movb $0x1, %r12b
cmpl $0x5c, %ecx
je 0x58a9
cmpl $0x27, %ecx
je 0x58a9
cmpl $0xa, %ecx
jne 0x58a6
incl 0x6d5a(%rip)            # 0xc600
xorl %r12d, %r12d
incq %rax
movq %rax, (%rsp)
jmp 0x5819
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/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 %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
xorl %eax, %eax
movq %r15, %rcx
movsbl (%rcx), %edi
testl %edi, %edi
je 0x6b2c
cmpb $0x22, %dil
sete %cl
notb %al
testb %cl, %al
jne 0x6b18
movq %r14, %rsi
callq 0x10e0
movq (%rbx), %rcx
movb (%rcx), %al
cmpb $0xa, %al
je 0x6b35
cmpb $0x5c, %al
sete %al
incq %rcx
movq %rcx, (%rbx)
jmp 0x6ae6
pushq $0x22
popq %rdi
movq %r14, %rsi
callq 0x10e0
incq (%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %r15, 0x5abd(%rip)      # 0xc5f0
jmp 0x6b3c
movq %rcx, 0x5ab4(%rip)      # 0xc5f0
movups 0x22d8(%rip), %xmm0     # 0x8e1b
movaps %xmm0, 0x5996(%rip)     # 0xc4e0
movabsq $0x27222720676e69, %rax # imm = 0x27222720676E69
movq %rax, 0x5992(%rip)      # 0xc4ed
pushq $0x1
popq %rdi
callq 0x56c5
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/compile.c
// Function: parse_arguments
void parse_arguments(int argc, char **argv, char *filenames[], unsigned int num_filenames, char **output_filename){
	unsigned int current_arg;
	unsigned int current_filename = 0;
	enum cmd_argtype argtype = cmd_source_file;

	for(current_arg = 1; current_arg < argc; current_arg++){
		switch(argtype){
			case cmd_source_file:
				if(argv[current_arg][0] == '-'){
					if(argv[current_arg][1] == 'h' || (argv[current_arg][1] == '-' && argv[current_arg][2] == 'h')){//Display help message
						printf("Arguments:\n-h --help     Displays this help message\n-o            Specify output file\n\nTo compile:\nmcc [SOURCE1] [SOURCE2] [SOURCE3] ... -o [OUTPUT_FILE]\n");
						exit(1);
					} else if(argv[current_arg][1] == 'o'){
						argtype = cmd_output_file;
					} else {
						fprintf(stderr, "Unrecognized option '%s'\n", argv[current_arg]);
						exit(1);
					}
				} else {
					if(current_filename < num_filenames){
						filenames[current_filename] = argv[current_arg];
						current_filename++;
					} else {
						fprintf(stderr, "Too many source files\n");
						exit(1);
					}
				}
				break;
			case cmd_output_file:
				if(argv[current_arg][0] == '-'){
					fprintf(stderr, "Expected output file name after '-o'\n");
					exit(1);
				}
				*output_filename = argv[current_arg];
				argtype = cmd_source_file;
				break;
		}
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %edi
xorl %r9d, %r9d
pushq $0x1
popq %r10
pushq $0x1
popq %r11
xorl %ebx, %ebx
cmpq %rdi, %r10
jae 0x6bba
movq (%rsi,%r10,8), %rax
movb (%rax), %bpl
testl %ebx, %ebx
je 0x6b90
cmpb $0x2d, %bpl
je 0x6bc1
movq %rax, (%r8)
jmp 0x6bb3
cmpb $0x2d, %bpl
jne 0x6ba4
movzbl 0x1(%rax), %ebp
movl %r11d, %ebx
cmpl $0x6f, %ebp
je 0x6bb5
jmp 0x6bd6
cmpl %ecx, %r9d
jae 0x6c11
movl %r9d, %ebx
movq %rax, (%rdx,%rbx,8)
incl %r9d
xorl %ebx, %ebx
incq %r10
jmp 0x6b75
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x5430(%rip), %rax      # 0xbff8
movq (%rax), %rcx
leaq 0x22a3(%rip), %rdi      # 0x8e75
pushq $0x25
jmp 0x6c24
cmpl $0x68, %ebp
je 0x6be6
cmpl $0x2d, %ebp
jne 0x6bf4
cmpb $0x68, 0x2(%rax)
jne 0x6bf4
leaq 0x2330(%rip), %rdi      # 0x8f1d
callq 0x1060
jmp 0x6c2d
movq 0x53fd(%rip), %rcx      # 0xbff8
movq (%rcx), %rdi
leaq 0x223f(%rip), %rsi      # 0x8e44
movq %rax, %rdx
xorl %eax, %eax
callq 0x1100
jmp 0x6c2d
movq 0x53e0(%rip), %rax      # 0xbff8
movq (%rax), %rcx
leaq 0x223c(%rip), %rdi      # 0x8e5e
pushq $0x16
popq %rsi
pushq $0x1
popq %rdx
callq 0x1190
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/compile.c
// Function: print_line
static void print_line(){
	char *line_pointer;
	char *line_beginning;

	line_pointer = program_pointer;
	fprintf(stderr, "Line %d in %s:\n", current_line, *current_source_file);
	while(line_pointer != program_beginning && line_pointer[-1] != '\n'){
		line_pointer--;
	}
	while(*line_pointer && line_pointer != program_pointer && (*line_pointer == ' ' || *line_pointer == '\t')){
		line_pointer++;
	}
	line_beginning = line_pointer;
	while(*line_pointer && *line_pointer != '\n'){
		fputc(*line_pointer, stderr);
		line_pointer++;
	}
	fputc('\n', stderr);
	while(line_beginning != program_pointer){
		fputc(' ', stderr);
		line_beginning++;
	}
	fprintf(stderr, "^\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x578c(%rip), %rbx      # 0xc5f0
movq 0x518d(%rip), %r14      # 0xbff8
movq (%r14), %rdi
movl 0x578c(%rip), %edx      # 0xc600
movq 0x58d5(%rip), %rax      # 0xc750
movq (%rax), %rcx
leaq 0x2085(%rip), %rsi      # 0x8f0a
xorl %eax, %eax
callq 0x1100
movq 0x5765(%rip), %r15      # 0xc5f8
cmpq %r15, %rbx
je 0x6eab
leaq -0x1(%rbx), %rax
cmpb $0xa, -0x1(%rbx)
movq %rax, %rbx
jne 0x6e93
incq %rax
movq %rax, %r15
movq 0x573e(%rip), %rcx      # 0xc5f0
movzbl (%r15), %eax
testl %eax, %eax
je 0x6ece
cmpq %rcx, %r15
je 0x6ece
cmpl $0x20, %eax
je 0x6ec9
cmpl $0x9, %eax
jne 0x6ece
incq %r15
jmp 0x6eb2
leaq 0x1(%r15), %rbx
testb %al, %al
je 0x6ef0
movzbl %al, %ecx
cmpl $0xa, %ecx
je 0x6ef0
movsbl %al, %edi
movq (%r14), %rsi
callq 0x10e0
movb (%rbx), %al
incq %rbx
jmp 0x6ed2
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x10e0
pushq $0x20
popq %rbx
movq (%r14), %rcx
cmpq 0x56e8(%rip), %r15      # 0xc5f0
je 0x6f19
movl %ebx, %edi
movq %rcx, %rsi
callq 0x10e0
incq %r15
jmp 0x6efe
leaq 0x1ffa(%rip), %rdi      # 0x8f1a
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/dictionary.c
// Function: free_dictionary
void free_dictionary(dictionary dict, void (*free_value)(void *)){
	unsigned char i;

	for(i = 0; i < 8; i++){
		if(dict.next_chars[i]){
			free_dictionary_recursive(dict.next_chars[i], free_value);
			free(dict.next_chars[i]);
		}
	}

	if(dict.value){
		free_value(dict.value);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
leaq 0x30(%rsp), %r14
xorl %r15d, %r15d
cmpq $0x8, %r15
je 0x6f84
movq (%r14,%r15,8), %rbx
testq %rbx, %rbx
je 0x6f7f
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6fa9
movq %rbx, %rdi
callq 0x1030
incq %r15
jmp 0x6f5d
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x6f9d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/dictionary.c
// Function: free_dictionary_recursive
static void free_dictionary_recursive(dictionary *dict, void (*free_value)(void *)){
	unsigned char i;

	for(i = 0; i < 8; i++){
		if(dict->next_chars[i]){
			free_dictionary_recursive(dict->next_chars[i], free_value);
			free(dict->next_chars[i]);
		}
	}

	if(dict->value){
		free_value(dict->value);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq $0x8, %r14
je 0x6fdc
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x6fd7
movq %r15, %rsi
callq 0x6fa9
movq (%rbx,%r14,8), %rdi
callq 0x1030
incq %r14
jmp 0x6fb7
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x6fef
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
jmpq *%rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/dictionary.c
// Function: read_dictionary
void *read_dictionary(dictionary dict, char *string, unsigned char offset){
	unsigned char zeros = 0;
	unsigned char c;

	while(*string){
		c = (*string)>>offset | (*(string + 1))<<(8 - offset);
		zeros = 0;

		if(!(c&15)){
			zeros += 4;
			c>>=4;
		}
		if(!(c&3)){
			zeros += 2;
			c>>=2;
		}
		if(!(c&1)){
			zeros++;
		}

		offset += zeros + 1;
		string += (offset&0x08)>>3;
		offset = offset&0x07;
		if(dict.next_chars[zeros]){
			dict = *(dict.next_chars[zeros]);
		} else {
			return (void *) 0;
		}
	}
	
	return dict.value;
}

// Assembly:
pushq %rbx
movl %esi, %edx
movq %rdi, %r8
leaq 0x10(%rsp), %r9
xorl %eax, %eax
movabsq $0x9, %r10
movsbl (%r8), %esi
testl %esi, %esi
je 0x7092
movl %edx, %ecx
sarl %cl, %esi
movzbl 0x1(%r8), %edi
movb $0x8, %cl
subb %dl, %cl
shll %cl, %edi
orl %esi, %edi
movl %edi, %ecx
shrb $0x4, %cl
testb $0xf, %dil
sete %sil
movzbl %cl, %r11d
cmovnel %edi, %r11d
shlb $0x2, %sil
leal 0x2(%rsi), %ecx
movl %r11d, %edi
shrb $0x2, %dil
testb $0x3, %r11b
movzbl %sil, %esi
movzbl %cl, %ebx
cmovnel %esi, %ebx
movzbl %dil, %ecx
cmovnel %r11d, %ecx
andb $0x1, %cl
orb %bl, %cl
xorb $0x1, %cl
movzbl %cl, %esi
movq (%r9,%rsi,8), %rsi
testq %rsi, %rsi
je 0x7096
addb %cl, %dl
incb %dl
movzbl %dl, %ecx
andb $0x7, %dl
btl $0x3, %ecx
adcq $0x0, %r8
movq %r10, %rcx
movq %r9, %rdi
rep  movsq (%rsi), %es:(%rdi)
jmp 0x700c
movq 0x40(%r9), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/dictionary.c
// Function: write_dictionary
void write_dictionary(dictionary *dict, char *string, void *value, unsigned char offset){
	unsigned char zeros = 0;
	unsigned char c;

	while(*string){
		c = (*string)>>offset | (*(string + 1))<<(8 - offset);
		zeros = 0;

		if(!(c&15)){
			zeros += 4;
			c>>=4;
		}
		if(!(c&3)){
			zeros += 2;
			c>>=2;
		}
		if(!(c&1)){
			zeros++;
		}

		offset += zeros + 1;
		string += (offset&0x08)>>3;
		offset = offset&0x07;
		if(!dict->next_chars[zeros]){
			dict->next_chars[zeros] = malloc(sizeof(dictionary));
			*(dict->next_chars[zeros]) = create_dictionary((void *) 0);
		}
		dict = dict->next_chars[zeros];
	}
	
	dict->value = value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
pushq $0x48
popq %r15
movq %rdi, %r12
movsbl (%r14), %eax
testl %eax, %eax
je 0x7156
movl %ebp, %ecx
sarl %cl, %eax
movzbl 0x1(%r14), %edx
movb $0x8, %cl
subb %bpl, %cl
shll %cl, %edx
orl %eax, %edx
movl %edx, %eax
shrb $0x4, %al
testb $0xf, %dl
sete %cl
movzbl %al, %eax
cmovnel %edx, %eax
shlb $0x2, %cl
leal 0x2(%rcx), %edx
movl %eax, %esi
shrb $0x2, %sil
testb $0x3, %al
movzbl %cl, %ecx
movzbl %dl, %edx
cmovnel %ecx, %edx
movzbl %sil, %ecx
cmovnel %eax, %ecx
andb $0x1, %cl
orb %dl, %cl
xorb $0x1, %cl
addb %cl, %bpl
incb %bpl
movzbl %bpl, %ebp
btl $0x3, %ebp
adcq $0x0, %r14
andb $0x7, %bpl
movzbl %cl, %r13d
movq (%r12,%r13,8), %rdi
testq %rdi, %rdi
jne 0x70af
movq %r15, %rdi
callq 0x1140
movq %rax, (%r12,%r13,8)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
andq $0x0, 0x40(%rax)
movq (%r12,%r13,8), %rdi
jmp 0x70af
movq %rbx, 0x40(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/dictionary.c
// Function: iterate_dictionary
void iterate_dictionary(dictionary dict, void (*func)(void *)){
	unsigned char i;
	
	if(dict.value){
		func(dict.value);
	}

	for(i = 0; i < 8; i++){
		if(dict.next_chars[i]){
			iterate_dictionary(*dict.next_chars[i], func);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x7187
callq *%rbx
leaq 0x70(%rsp), %r15
xorl %r12d, %r12d
pushq $0x9
popq %r14
cmpq $0x8, %r12
je 0x71b8
movq (%r15,%r12,8), %rsi
testq %rsi, %rsi
je 0x71b3
movq %r14, %rcx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
callq 0x716a
incq %r12
jmp 0x7193
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/types.c
// Function: add_type_entry
void add_type_entry(type *t, type_entry entry){
	t->d0 <<= 1;
	if(entry&1){
		t->d0 |= 1;
	}
	t->d1 <<= 1;
	if(entry&2){
		t->d1 |= 1;
	}
	t->d2 <<= 1;
	if(entry&4){
		t->d2 |= 1;
	}
}

// Assembly:
movl %esi, %eax
shrl %eax
movdqu (%rdi), %xmm0
paddq %xmm0, %xmm0
movd %esi, %xmm1
movd %eax, %xmm2
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
pand 0x1dcc(%rip), %xmm1     # 0x8ff0
pxor %xmm2, %xmm2
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
por %xmm0, %xmm1
movdqu %xmm1, (%rdi)
movq 0x10(%rdi), %rax
shrl $0x2, %esi
andl $0x1, %esi
leaq (%rsi,%rax,2), %rax
movq %rax, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/types.c
// Function: poke_type_entry
void poke_type_entry(type *t, type_entry entry, unsigned int position){
	if(entry&1){
		t->d0 |= 1ULL<<position;
	}
	if(entry&2){
		t->d1 |= 1ULL<<position;
	}
	if(entry&4){
		t->d2 |= 1ULL<<position;
	}
}

// Assembly:
movl %edx, %ecx
pushq $0x1
popq %rax
testb $0x1, %sil
je 0x725b
movq %rax, %rdx
shlq %cl, %rdx
orq %rdx, (%rdi)
testb $0x2, %sil
je 0x726b
movq %rax, %rdx
shlq %cl, %rdx
orq %rdx, 0x8(%rdi)
testb $0x4, %sil
je 0x7278
shlq %cl, %rax
orq %rax, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/types.c
// Function: append_type
void append_type(type *t, type d){
	uint64_t d_mask;
	int shift_amount = 1;

	d_mask = d.d0 | d.d1 | d.d2;

	if(!d_mask){
		return;
	}

	if(d_mask&0xFFFFFFFF00000000ULL){
		shift_amount += 32;
		d_mask >>= 32;
	}
	if(d_mask&0xFFFF0000U){
		shift_amount += 16;
		d_mask >>= 16;
	}
	if(d_mask&0xFF00U){
		shift_amount += 8;
		d_mask >>= 8;
	}
	if(d_mask&0xF0U){
		shift_amount += 4;
		d_mask >>= 4;
	}
	if(d_mask&0xCU){
		shift_amount += 2;
		d_mask >>= 2;
	}
	if(d_mask&0x2){
		shift_amount++;
	}

	t->d0 = (t->d0<<shift_amount) | d.d0;
	t->d1 = (t->d1<<shift_amount) | d.d1;
	t->d2 = (t->d2<<shift_amount) | d.d2;
	while(d.current_index){
		d.current_index--;
		t->list_indicies[t->current_index] = d.list_indicies[d.current_index];
		t->current_index++;
	}
}

// Assembly:
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rdx, %rcx
orq %rsi, %rcx
movq 0x18(%rsp), %rax
orq %rax, %rcx
je 0x7367
xorl %r8d, %r8d
movq %rcx, %r9
shrq $0x20, %r9
setne %r8b
cmoveq %rcx, %r9
shll $0x5, %r8d
leal 0x1(%r8), %ecx
orl $0x11, %r8d
movq %r9, %r10
shrq $0x10, %r10
cmpq $0x10000, %r9           # imm = 0x10000
cmovbq %r9, %r10
cmovbl %ecx, %r8d
leal 0x8(%r8), %ecx
movq %r10, %r9
shrq $0x8, %r9
testw $0xff00, %r10w          # imm = 0xFF00
cmoveq %r10, %r9
cmovel %r8d, %ecx
leal 0x4(%rcx), %r8d
movq %r9, %r10
shrq $0x4, %r10
testb $-0x10, %r9b
cmoveq %r9, %r10
cmovel %ecx, %r8d
leal 0x2(%r8), %ecx
movl %r10d, %r9d
shrl $0x2, %r9d
testb $0xc, %r10b
cmovel %r8d, %ecx
cmovel %r10d, %r9d
btl $0x1, %r9d
adcl $0x0, %ecx
movq (%rdi), %r8
movq 0x8(%rdi), %r9
shlq %cl, %r8
orq %rsi, %r8
shlq %cl, %r9
movq %r8, (%rdi)
orq %rdx, %r9
movq %r9, 0x8(%rdi)
movq 0x10(%rdi), %rdx
shlq %cl, %rdx
leaq 0x8(%rsp), %rcx
orq %rax, %rdx
movq %rdx, 0x10(%rdi)
movl 0x38(%rcx), %eax
testq %rax, %rax
je 0x7367
decq %rax
movl %eax, 0x38(%rcx)
movl %eax, %edx
movl 0x18(%rcx,%rdx,4), %edx
movl 0x38(%rdi), %esi
movl %edx, 0x18(%rdi,%rsi,4)
incl 0x38(%rdi)
jmp 0x734a
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/types.c
// Function: parse_identifier
unsigned char parse_identifier(char **c, char *identifier_name, unsigned int identifier_length){
	if(!alpha(**c)){
		return 0;
	}
	if(!strncmp(*c, "void", 4) && !alphanumeric((*c)[4])){
		return 0;
	}
	if(!strncmp(*c, "int", 3) && !alphanumeric((*c)[3])){
		return 0;
	}
	if(!strncmp(*c, "char", 4) && !alphanumeric((*c)[4])){
		return 0;
	}

	if(identifier_length){
		identifier_length--;
	}

	while(alphanumeric(**c)){
		if(identifier_length && identifier_name){
			*identifier_name = **c;
			identifier_name++;
			identifier_length--;
		}
		++*c;
	}

	if(identifier_name){
		*identifier_name = '\0';
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movb (%r15), %r12b
cmpb $0x5f, %r12b
je 0x7396
movl %r12d, %eax
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jae 0x7396
xorl %eax, %eax
jmp 0x744c
leaq 0x1c93(%rip), %rsi      # 0x9030
pushq $0x4
popq %rdx
movq %r15, %rdi
callq 0x1040
testl %eax, %eax
jne 0x73ba
movsbl 0x4(%r15), %edi
callq 0x71d9
testb %al, %al
je 0x738f
cmpb $0x69, %r12b
jne 0x73dc
cmpb $0x6e, 0x1(%r15)
jne 0x73dc
cmpb $0x74, 0x2(%r15)
jne 0x73dc
movsbl 0x3(%r15), %edi
callq 0x71d9
testb %al, %al
je 0x738f
leaq 0x1c52(%rip), %rsi      # 0x9035
pushq $0x4
popq %rdx
movq %r15, %rdi
callq 0x1040
testl %eax, %eax
jne 0x7400
movsbl 0x4(%r15), %edi
callq 0x71d9
testb %al, %al
je 0x738f
xorl %eax, %eax
subl $0x1, %ebp
cmovbl %eax, %ebp
movsbl %r12b, %edi
callq 0x71d9
testb %al, %al
je 0x7442
testl %ebp, %ebp
setne %al
testq %rbx, %rbx
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x7432
movb %r12b, (%rbx)
incq %rbx
decl %ebp
movq (%r14), %r15
leaq 0x1(%r15), %rax
movq %rax, (%r14)
movb 0x1(%r15), %r12b
movq %rax, %r15
jmp 0x7408
movb $0x1, %al
testq %rbx, %rbx
je 0x744c
movb $0x0, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/types.c
// Function: parse_datatype
unsigned char parse_datatype(type *t, char **c){
	if(!strncmp(*c, "void", 4) && !alphanumeric((*c)[4])){
		if(t){
			add_type_entry(t, type_void);
		}
		*c += 4;
		return 1;
	} else if(!strncmp(*c, "int", 3) && !alphanumeric((*c)[3])){
		if(t){
			add_type_entry(t, type_int);
		}
		*c += 3;
		return 1;
	} else if(!strncmp(*c, "char", 4) && !alphanumeric((*c)[4])){
		if(t){
			add_type_entry(t, type_char);
		}
		*c += 4;
		return 1;
	} else {
		return 0;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %r14
leaq 0x1bc6(%rip), %rsi      # 0x9030
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x1040
testl %eax, %eax
jne 0x7487
movsbl 0x4(%r14), %edi
callq 0x71d9
testb %al, %al
je 0x74d1
cmpb $0x69, (%r14)
jne 0x74a9
cmpb $0x6e, 0x1(%r14)
jne 0x74a9
cmpb $0x74, 0x2(%r14)
jne 0x74a9
movsbl 0x3(%r14), %edi
callq 0x71d9
testb %al, %al
je 0x74fc
leaq 0x1b85(%rip), %rsi      # 0x9035
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x1040
testl %eax, %eax
jne 0x74cd
movsbl 0x4(%r14), %edi
callq 0x71d9
testb %al, %al
je 0x74da
xorl %eax, %eax
jmp 0x74f6
testq %r15, %r15
je 0x74ed
pushq $0x1
jmp 0x74e1
testq %r15, %r15
je 0x74ed
pushq $0x3
popq %rsi
movq %r15, %rdi
callq 0x7204
movq (%rbx), %r14
addq $0x4, %r14
movq %r14, (%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
testq %r15, %r15
je 0x750f
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0x7204
movq (%rbx), %r14
addq $0x3, %r14
jmp 0x74f1
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/types.c
// Function: skip_whitespace
void skip_whitespace(char **c){
	while(**c == ' ' || **c == '\t' || **c == '\n' || **c == '\r' || (**c == '/' && ((*c)[1] == '/' || (*c)[1] == '*'))){
		if(**c == '/' && (*c)[1] == '/'){
			while(**c && **c != '\n'){
				++*c;
			}
		} else if(**c == '/' && (*c)[1] == '*'){
			while(**c && (**c != '*' || (*c)[1] != '/')){
				if(**c == '\n'){
					current_line++;
				}
				++*c;
			}
			++*c;
		}
		if(**c == '\n'){
			current_line++;
		}
		if(**c){
			++*c;
		}
	}
}

// Assembly:
movq (%rdi), %rax
leaq 0x50ad(%rip), %rcx      # 0xc600
movl (%rcx), %edx
movabsq $0x100002600, %rsi      # imm = 0x100002600
movzbl (%rax), %r8d
cmpq $0x2f, %r8
ja 0x7602
btq %r8, %rsi
jae 0x758d
cmpb $0xa, %r8b
jne 0x7580
incl %edx
movl %edx, (%rcx)
movb (%rax), %r8b
testb %r8b, %r8b
je 0x755f
incq %rax
movq %rax, (%rdi)
jmp 0x755f
cmpq $0x2f, %r8
jne 0x7602
movzbl 0x1(%rax), %r8d
cmpl $0x2f, %r8d
je 0x75dd
cmpl $0x2a, %r8d
jne 0x7602
incq %rax
movb $0x2f, %r8b
cmpb $0xa, %r8b
je 0x75c8
movzbl %r8b, %r8d
cmpl $0x2a, %r8d
je 0x75c1
testl %r8d, %r8d
jne 0x75cc
jmp 0x75f7
cmpb $0x2f, (%rax)
jne 0x75cc
jmp 0x75f7
incl %edx
movl %edx, (%rcx)
movq %rax, (%rdi)
movb (%rax), %r8b
incq %rax
jmp 0x75aa
movq %rax, (%rdi)
movb (%rax), %r8b
incq %rax
testb %r8b, %r8b
je 0x75ef
movzbl %r8b, %r9d
cmpl $0xa, %r9d
jne 0x75d7
decq %rax
jmp 0x7573
movq %rax, (%rdi)
movb (%rax), %r8b
jmp 0x7573
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/types.c
// Function: types_equal
unsigned char types_equal(type *t0, type *t1){
	unsigned char i;
	unsigned int t0_index;
	unsigned int t1_index;

	if(t0->d0 != t1->d0 || t0->d1 != t1->d1 || t0->d2 != t1->d2){
		return 0;
	}
	if(t0->current_index == 0 && t1->current_index != 0 && t1->list_indicies[t1->current_index - 1] != 0){
		return 0;
	}
	if(t1->current_index == 0 && t0->current_index != 0 && t0->list_indicies[t0->current_index - 1] != 0){
		return 0;
	}
	if(!t0->current_index || !t1->current_index){
		return 1;
	}
	t0_index = t0->current_index;
	t1_index = t1->current_index;
	for(i = 0; i < 8; i++){
		t0_index--;
		t1_index--;
		if(t0->list_indicies[t0_index] != t1->list_indicies[t1_index]){
			return 0;
		}
		if(t0_index == 0 && t1_index != 0 && t1->list_indicies[t1_index - 1] != 0){
			return 0;
		}
		if(t1_index == 0 && t0_index != 0 && t0->list_indicies[t0_index - 1] != 0){
			return 0;
		}
		if(!t0_index || !t1_index){
			break;
		}
	}

	return 1;
}

// Assembly:
movq (%rdi), %rax
cmpq (%rsi), %rax
jne 0x771e
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0x771e
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x771e
movl 0x38(%rdi), %edx
movl 0x38(%rsi), %ecx
testl %edx, %edx
je 0x7710
testq %rcx, %rcx
je 0x7721
pushq %rbp
pushq %r14
pushq %rbx
movabsq $0x1, %r8
subq %rcx, %r8
leaq (%rsi,%rcx,4), %r10
addq $0x14, %r10
movl $0x1, %r11d
subl %edx, %r11d
leal -0x1(%rdx), %ebx
xorl %r9d, %r9d
movb $0x1, %al
cmpb $-0x8, %r9b
je 0x7750
leal (%rbx,%r9), %r14d
movl 0x18(%rdi,%r14,4), %ebp
cmpl (%r10,%r9,4), %ebp
jne 0x772f
cmpl %r9d, %r11d
setne %bpl
cmpq %r9, %r8
sete %r14b
orb %bpl, %r14b
je 0x7733
cmpq %r9, %r8
setne %bpl
cmpl %r9d, %r11d
sete %r14b
orb %bpl, %r14b
je 0x7741
cmpq %r9, %r8
je 0x7750
movq %r9, %r14
decq %r14
cmpl %r9d, %r11d
movq %r14, %r9
jne 0x76ba
jmp 0x7750
testq %rcx, %rcx
je 0x772c
decl %ecx
cmpl $0x0, 0x18(%rsi,%rcx,4)
je 0x772c
xorl %eax, %eax
retq
decl %edx
cmpl $0x0, 0x18(%rdi,%rdx,4)
sete %al
retq
movb $0x1, %al
retq
xorl %eax, %eax
jmp 0x7750
leal (%rcx,%r9), %eax
addl $-0x2, %eax
cmpl $0x0, 0x18(%rsi,%rax,4)
jmp 0x774d
leal (%rdx,%r9), %eax
addl $-0x2, %eax
cmpl $0x0, 0x18(%rdi,%rax,4)
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/types.c
// Function: get_argument_type
type get_argument_type(type *t){
	type_entry next_type_entry;
	type output;
	unsigned int function_count = 0;
	unsigned int current_entry_index = 0;

	output = EMPTY_TYPE;
	output.current_index = MAX_LISTS - 1;//Have to put indicies in reverse order
	while((next_type_entry = pop_type(t)) >= 4 || function_count){
		poke_type_entry(&output, next_type_entry, current_entry_index);
		current_entry_index++;
		if(next_type_entry == type_function){
			function_count++;
		} else if(function_count && next_type_entry == type_returns){
			function_count--;
		}
		if(next_type_entry == type_list){
			t->current_index--;
			output.list_indicies[output.current_index] = t->list_indicies[t->current_index];
			output.current_index--;
		}
	}
	poke_type_entry(&output, next_type_entry, current_entry_index);
	output.current_index = MAX_LISTS;

	return output;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movups 0x501e(%rip), %xmm0     # 0xc788
movups %xmm0, 0x30(%rdi)
movups 0x5003(%rip), %xmm0     # 0xc778
movups %xmm0, 0x20(%rdi)
movups 0x4fe8(%rip), %xmm0     # 0xc768
movups %xmm0, 0x10(%rdi)
movups 0x4fcd(%rip), %xmm0     # 0xc758
movups %xmm0, (%rdi)
movl $0x7, 0x38(%rdi)
xorl %r12d, %r12d
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x761b
movl %eax, %r15d
movq %rbx, %rdi
movl %eax, %esi
movl %ebp, %edx
callq 0x7247
cmpl $0x3, %r15d
ja 0x77bc
testl %r12d, %r12d
je 0x77ff
cmpl $0x5, %r15d
jne 0x77c7
incl %r12d
jmp 0x77fb
testl %r12d, %r12d
setne %al
cmpl $0x6, %r15d
sete %cl
andb %al, %cl
movzbl %cl, %eax
subl %eax, %r12d
cmpl $0x7, %r15d
jne 0x77fb
movl 0x38(%r14), %eax
decl %eax
movl %eax, 0x38(%r14)
movl 0x18(%r14,%rax,4), %eax
movl 0x38(%rbx), %ecx
movl %eax, 0x18(%rbx,%rcx,4)
decl 0x38(%rbx)
incl %ebp
jmp 0x779a
movl $0x8, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq