LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
addq $0x10, %rdi
leaq 0xa9ca(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x6844
movq 0x60(%rsp), %rdi
addq $0x10, %rdi
leaq 0xaa31(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
jne 0x6844
leaq 0xad09(%rip), %rdi      # 0x11530
movl $0x100, %esi            # imm = 0x100
leaq 0x7389(%rip), %rdx      # 0xdbbc
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x87b0
movq 0x60(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x687f
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rax
movl 0x4(%rax), %edx
movq 0x60(%rsp), %rax
movl 0x4(%rax), %ecx
movq 0x60(%rsp), %rax
movl 0x4(%rax), %r8d
leaq 0x7379(%rip), %rsi      # 0xdbec
movb $0x0, %al
callq 0x16f0
jmp 0x698b
movq 0x60(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x6989
movq 0x60(%rsp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
callq 0x1a40
movl %eax, 0x54(%rsp)
cmpl $0x4, 0x54(%rsp)
jne 0x68eb
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x40(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x48(%rsp)
movq 0x40(%rsp), %rdi
movl 0x48(%rsp), %esi
callq 0x1490
movq 0x18(%rsp), %rdi
movl %eax, %edx
leaq 0x6f88(%rip), %rsi      # 0xd86a
movb $0x0, %al
callq 0x16f0
jmp 0x6935
cmpl $0x1, 0x54(%rsp)
jne 0x6933
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x30(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x38(%rsp)
movq 0x30(%rsp), %rdi
movl 0x38(%rsp), %esi
callq 0x1490
movq 0x10(%rsp), %rdi
movl %eax, %edx
leaq 0x6f73(%rip), %rsi      # 0xd89f
movb $0x0, %al
callq 0x16f0
jmp 0x6935
movq 0x58(%rsp), %rdi
leaq 0x72c1(%rip), %rsi      # 0xdc02
movb $0x0, %al
callq 0x16f0
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0x1490
movq 0x8(%rsp), %rdi
movl %eax, %edx
leaq 0x6e57(%rip), %rsi      # 0xd7d9
movb $0x0, %al
callq 0x16f0
jmp 0x698b
movq 0x60(%rsp), %rdi
addq $0x10, %rdi
leaq 0xa82d(%rip), %rsi      # 0x111c8
movl $0x40, %edx
callq 0x1120
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
addq $0x10, %rdi
leaq 0xa7fa(%rip), %rsi      # 0x111c8
callq 0xbec0
cmpb $0x0, %al
jne 0x6a14
movq 0x60(%rsp), %rdi
addq $0x10, %rdi
leaq 0xa861(%rip), %rsi      # 0x11248
callq 0xbec0
cmpb $0x0, %al
jne 0x6a14
leaq 0xab39(%rip), %rdi      # 0x11530
movl $0x100, %esi            # imm = 0x100
leaq 0x7212(%rip), %rdx      # 0xdc15
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x87b0
movq 0x60(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x6a46
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rax
movl 0x4(%rax), %edx
movq 0x60(%rsp), %rax
movl 0x4(%rax), %ecx
leaq 0x71fb(%rip), %rsi      # 0xdc35
movb $0x0, %al
callq 0x16f0
jmp 0x6b52
movq 0x60(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x6b50
movq 0x60(%rsp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
callq 0x1a40
movl %eax, 0x54(%rsp)
cmpl $0x4, 0x54(%rsp)
jne 0x6ab2
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x40(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x48(%rsp)
movq 0x40(%rsp), %rdi
movl 0x48(%rsp), %esi
callq 0x1490
movq 0x18(%rsp), %rdi
movl %eax, %edx
leaq 0x6dc1(%rip), %rsi      # 0xd86a
movb $0x0, %al
callq 0x16f0
jmp 0x6afc
cmpl $0x1, 0x54(%rsp)
jne 0x6afa
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x30(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x38(%rsp)
movq 0x30(%rsp), %rdi
movl 0x38(%rsp), %esi
callq 0x1490
movq 0x10(%rsp), %rdi
movl %eax, %edx
leaq 0x6dac(%rip), %rsi      # 0xd89f
movb $0x0, %al
callq 0x16f0
jmp 0x6afc
movq 0x58(%rsp), %rdi
leaq 0x7144(%rip), %rsi      # 0xdc4c
movb $0x0, %al
callq 0x16f0
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0x1490
movq 0x8(%rsp), %rdi
movl %eax, %edx
leaq 0x6c90(%rip), %rsi      # 0xd7d9
movb $0x0, %al
callq 0x16f0
jmp 0x6b52
movq 0x60(%rsp), %rdi
addq $0x10, %rdi
leaq 0xa666(%rip), %rsi      # 0x111c8
movl $0x40, %edx
callq 0x1120
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
addl $-0x21, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rsp)
subl $0x5b, %eax
ja 0x7507
movq -0x18(%rsp), %rax
leaq 0x5ca0(%rip), %rcx      # 0xd04c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rsp)
jmp 0x750f
movl $0x2, -0x4(%rsp)
jmp 0x750f
movl $0x3, -0x4(%rsp)
jmp 0x750f
movl $0x4, -0x4(%rsp)
jmp 0x750f
movl $0xe, -0x4(%rsp)
jmp 0x750f
movq -0x10(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3d, %eax
jne 0x7411
movl $0xa, -0x4(%rsp)
jmp 0x750f
movl $0x5, -0x4(%rsp)
jmp 0x750f
movq -0x10(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3d, %eax
jne 0x7439
movl $0xb, -0x4(%rsp)
jmp 0x750f
movl $0x0, -0x4(%rsp)
jmp 0x750f
movq -0x10(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3e, %eax
jne 0x7461
movl $0x12, -0x4(%rsp)
jmp 0x750f
movq -0x10(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3d, %eax
jne 0x747c
movl $0x9, -0x4(%rsp)
jmp 0x750f
movl $0x7, -0x4(%rsp)
jmp 0x750f
movq -0x10(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3c, %eax
jne 0x74a1
movl $0x11, -0x4(%rsp)
jmp 0x750f
movq -0x10(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3d, %eax
jne 0x74b9
movl $0x8, -0x4(%rsp)
jmp 0x750f
movl $0x6, -0x4(%rsp)
jmp 0x750f
movq -0x10(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x26, %eax
jne 0x74db
movl $0xf, -0x4(%rsp)
jmp 0x750f
movl $0xc, -0x4(%rsp)
jmp 0x750f
movq -0x10(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x7c, %eax
jne 0x74fd
movl $0x10, -0x4(%rsp)
jmp 0x750f
movl $0xd, -0x4(%rsp)
jmp 0x750f
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb %cl, 0x17(%rsp)
movb %al, 0x16(%rsp)
movb $0x0, 0x8d27(%rip)      # 0x112c8
leaq 0x8cf4(%rip), %rax      # 0x1129c
movl $0x0, (%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movb 0x17(%rsp), %al
xorl %ecx, %ecx
movl %ecx, %r8d
movzbl %al, %edx
movzbl 0x16(%rsp), %ecx
callq 0x4fe0
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x8cd9(%rip)      # 0x112c8
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb %cl, 0x27(%rsp)
movb %al, 0x26(%rsp)
movq %r8, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movb 0x27(%rsp), %al
movzbl %al, %edx
movzbl 0x26(%rsp), %ecx
callq 0x8580
movq 0x30(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x13b0
leaq 0x8c39(%rip), %rax      # 0x1129c
cmpl $0x0, (%rax)
je 0x8686
movq 0x18(%rsp), %rdi
xorl %edx, %edx
leaq 0x8c26(%rip), %rax      # 0x1129c
subl (%rax), %edx
leaq 0x5369(%rip), %rsi      # 0xd9e8
movb $0x0, %al
callq 0x10f0
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movb 0x27(%rsp), %cl
movb 0x26(%rsp), %al
movq 0x18(%rsp), %r8
movzbl %cl, %edx
movzbl %al, %ecx
callq 0x4fe0
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x8707
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x1490
movq (%rsp), %rdi
movl %eax, %edx
leaq 0x516a(%rip), %rsi      # 0xd86a
movb $0x0, %al
callq 0x10f0
leaq 0x8b8e(%rip), %rax      # 0x1129c
cmpl $0x0, (%rax)
je 0x872f
movq 0x18(%rsp), %rdi
leaq 0x8b7d(%rip), %rax      # 0x1129c
movl (%rax), %edx
leaq 0x52c0(%rip), %rsi      # 0xd9e8
movb $0x0, %al
callq 0x10f0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
leaq 0x8b50(%rip), %rax      # 0x112c8
cmpb $0x0, (%rax)
je 0x87a8
movb $0x0, 0x8dab(%rip)      # 0x1152f
callq 0xad70
movq 0x8868(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x565f(%rip), %rsi      # 0xddf9
leaq 0x8c8f(%rip), %rdx      # 0x11430
movb $0x0, %al
callq 0x10f0
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl %edi, 0x4(%rsp)
movq 0x8e74(%rip), %rdi      # 0x11630
callq 0x1070
movb $0x0, 0x8e67(%rip)      # 0x1162f
callq 0xad70
movq 0x8824(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x5628(%rip), %rsi      # 0xde06
leaq 0x8d4b(%rip), %rdx      # 0x11530
movb $0x0, %al
callq 0x10f0
movq 0x8e45(%rip), %rdi      # 0x11638
callq 0x1030
movb $0x0, %al
callq 0x2f90
movb $0x0, %al
callq 0x2f10
movl 0x4(%rsp), %edi
callq 0x1170
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl %r8d, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8e03(%rip)      # 0x11640
movq 0x30(%rsp), %rax
movq %rax, 0x8dff(%rip)      # 0x11648
movq 0x10(%rsp), %rdi
leaq 0x55bc(%rip), %rsi      # 0xde11
movb $0x0, %al
callq 0x10f0
movl $0x1, 0x8dea(%rip)      # 0x11650
leaq 0x8dd3(%rip), %rdi      # 0x11640
callq 0xbb70
movl 0x8dd8(%rip), %eax      # 0x11650
movl %eax, 0xc(%rsp)
movq 0x8dbd(%rip), %rdi      # 0x11640
movq 0x10(%rsp), %rsi
callq 0x8900
movl 0xc(%rsp), %eax
movl %eax, 0x8db9(%rip)      # 0x11650
movq 0x10(%rsp), %rdi
leaq 0x5575(%rip), %rsi      # 0xde18
movb $0x0, %al
callq 0x10f0
movq 0x8d8f(%rip), %rax      # 0x11640
cmpb $0x0, (%rax)
je 0x88ef
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ecx
movl 0x18(%rsp), %r8d
movq 0x10(%rsp), %r9
leaq 0x8d6b(%rip), %rdi      # 0x11640
callq 0x8a20
movb $0x0, %al
callq 0x2f90
leaq 0x8d58(%rip), %rdi      # 0x11640
callq 0xbb70
jmp 0x88aa
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movb $0x0, 0x7(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xbb70
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0x8a10
movzbl 0x7(%rsp), %eax
cmpl $0x0, %eax
jne 0x8942
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
je 0x8996
movb $0x0, 0x7(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
je 0x8961
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x27, %eax
jne 0x8968
movb $0x1, 0x7(%rsp)
jmp 0x8986
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x8984
movl 0x8cd5(%rip), %eax      # 0x11650
addl $0x1, %eax
movl %eax, 0x8ccc(%rip)      # 0x11650
jmp 0x8986
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x8a01
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movl 0x8a79(%rip), %edx      # 0x11428
leaq 0x56ad(%rip), %rsi      # 0xe063
movb $0x0, %al
callq 0x10f0
movq 0x8(%rsp), %rdi
leaq 0x56a4(%rip), %rsi      # 0xe06d
movb $0x0, %al
callq 0x10f0
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0xa750
movq 0x8(%rsp), %rdi
leaq 0x5017(%rip), %rsi      # 0xda02
movb $0x0, %al
callq 0x10f0
movl 0x8a30(%rip), %eax      # 0x11428
addl $0x1, %eax
movl %eax, 0x8a27(%rip)      # 0x11428
leaq 0x10(%rsp), %rdi
callq 0xbb70
jmp 0x891d
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb $0x0, 0x17(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
je 0xa7b3
movq 0x20(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x22, %ecx
movb %al, 0x6(%rsp)
jne 0xa7ab
movzbl 0x17(%rsp), %eax
cmpl $0x0, %eax
setne %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0xa7c0
jmp 0xa851
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %edx
leaq 0x3874(%rip), %rsi      # 0xe04b
movb $0x0, %al
callq 0x10f0
movq 0x20(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0xa7f5
movb $0x1, 0x17(%rsp)
jmp 0xa7fa
movb $0x0, 0x17(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0xa83d
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x6e27(%rip)      # 0x11640
leaq 0x6d10(%rip), %rdi      # 0x11530
movl $0x100, %esi            # imm = 0x100
leaq 0x3822(%rip), %rdx      # 0xe04e
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x87b0
movq 0x20(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xa770
movq 0x20(%rsp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
jne 0xa88e
movq 0x8(%rsp), %rax
movq %rax, 0x6dd6(%rip)      # 0x11640
leaq 0x6cbf(%rip), %rdi      # 0x11530
movl $0x100, %esi            # imm = 0x100
leaq 0x37d1(%rip), %rdx      # 0xe04e
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x87b0
movq 0x18(%rsp), %rdi
leaq 0x37db(%rip), %rsi      # 0xe075
movb $0x0, %al
callq 0x10f0
movq 0x20(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq 0x68c5(%rip), %rax      # 0x11640
movq %rax, 0x10(%rsp)
movq 0x6271(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movl 0x68c0(%rip), %edx      # 0x11650
movq 0x6a09(%rip), %rax      # 0x117a0
movq (%rax), %rcx
leaq 0x346b(%rip), %rsi      # 0xe20c
movb $0x0, %al
callq 0x10f0
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x6892(%rip), %rcx      # 0x11648
movb %al, 0x7(%rsp)
je 0xadcf
movq 0x10(%rsp), %rax
movsbl -0x1(%rax), %eax
cmpl $0xa, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0xadd9
jmp 0xade9
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xada8
jmp 0xadeb
movq 0x10(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x6(%rsp)
je 0xae3f
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x6834(%rip), %rcx      # 0x11640
movb %al, 0x6(%rsp)
je 0xae3f
movq 0x10(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, 0x5(%rsp)
je 0xae37
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, 0x5(%rsp)
movb 0x5(%rsp), %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
testb $0x1, %al
jne 0xae49
jmp 0xae59
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xadeb
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x4(%rsp)
je 0xae88
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
setne %al
movb %al, 0x4(%rsp)
movb 0x4(%rsp), %al
testb $0x1, %al
jne 0xae92
jmp 0xaeb9
movq 0x10(%rsp), %rax
movsbl (%rax), %edi
movq 0x6157(%rip), %rax      # 0x10ff8
movq (%rax), %rsi
callq 0x10d0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xae63
movq 0x6138(%rip), %rax      # 0x10ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x10d0
movq 0x8(%rsp), %rax
cmpq 0x6767(%rip), %rax      # 0x11640
je 0xaeff
movq 0x6116(%rip), %rax      # 0x10ff8
movq (%rax), %rsi
movl $0x20, %edi
callq 0x10d0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0xaecd
movq 0x60f2(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x330c(%rip), %rsi      # 0xe21c
movb $0x0, %al
callq 0x10f0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
leaq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq %rdi, 0x10(%rsp)
movb $0x0, 0xf(%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0x8, %eax
jge 0xafd8
movq (%rsp), %rax
movzbl 0xf(%rsp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0xafca
movq (%rsp), %rax
movzbl 0xf(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rsi
callq 0xb000
movq (%rsp), %rax
movzbl 0xf(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x1030
jmp 0xafcc
movb 0xf(%rsp), %al
addb $0x1, %al
movb %al, 0xf(%rsp)
jmp 0xaf87
movq (%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0xaff2
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x40(%rcx), %rdi
callq *%rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movb $0x0, 0x7(%rsp)
movzbl 0x7(%rsp), %eax
cmpl $0x8, %eax
jge 0xb067
movq 0x10(%rsp), %rax
movzbl 0x7(%rsp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0xb059
movq 0x10(%rsp), %rax
movzbl 0x7(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
movq 0x8(%rsp), %rsi
callq 0xb000
movq 0x10(%rsp), %rax
movzbl 0x7(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x1030
jmp 0xb05b
movb 0x7(%rsp), %al
addb $0x1, %al
movb %al, 0x7(%rsp)
jmp 0xb013
movq 0x10(%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0xb083
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x40(%rcx), %rdi
callq *%rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %sil, %al
leaq 0x30(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq %rdi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movb $0x0, 0x16(%rsp)
movq 0x18(%rsp), %rax
cmpb $0x0, (%rax)
je 0xb1c6
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
movzbl 0x17(%rsp), %ecx
sarl %cl, %eax
movq 0x18(%rsp), %rcx
movsbl 0x1(%rcx), %edx
movzbl 0x17(%rsp), %esi
movl $0x8, %ecx
subl %esi, %ecx
shll %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movb %al, 0x15(%rsp)
movb $0x0, 0x16(%rsp)
movzbl 0x15(%rsp), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0xb115
movzbl 0x16(%rsp), %eax
addl $0x4, %eax
movb %al, 0x16(%rsp)
movzbl 0x15(%rsp), %eax
sarl $0x4, %eax
movb %al, 0x15(%rsp)
movzbl 0x15(%rsp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0xb13a
movzbl 0x16(%rsp), %eax
addl $0x2, %eax
movb %al, 0x16(%rsp)
movzbl 0x15(%rsp), %eax
sarl $0x2, %eax
movb %al, 0x15(%rsp)
movzbl 0x15(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xb151
movb 0x16(%rsp), %al
addb $0x1, %al
movb %al, 0x16(%rsp)
movq 0x8(%rsp), %rax
movzbl 0x16(%rsp), %edx
addl $0x1, %edx
movzbl 0x17(%rsp), %ecx
addl %edx, %ecx
movb %cl, 0x17(%rsp)
movzbl 0x17(%rsp), %edx
andl $0x8, %edx
sarl $0x3, %edx
movq 0x18(%rsp), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x18(%rsp)
movzbl 0x17(%rsp), %ecx
andl $0x7, %ecx
movb %cl, 0x17(%rsp)
movzbl 0x16(%rsp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0xb1b6
movq 0x8(%rsp), %rdi
movzbl 0x16(%rsp), %eax
movq (%rdi,%rax,8), %rsi
movl $0x48, %edx
callq 0x1120
jmp 0xb1c1
movq $0x0, 0x20(%rsp)
jmp 0xb1d4
jmp 0xb0af
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x78, %rsp
movb %cl, %al
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movb %al, 0x5f(%rsp)
movb $0x0, 0x5e(%rsp)
movq 0x68(%rsp), %rax
cmpb $0x0, (%rax)
je 0xb353
movq 0x68(%rsp), %rax
movsbl (%rax), %eax
movzbl 0x5f(%rsp), %ecx
sarl %cl, %eax
movq 0x68(%rsp), %rcx
movsbl 0x1(%rcx), %edx
movzbl 0x5f(%rsp), %esi
movl $0x8, %ecx
subl %esi, %ecx
shll %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movb %al, 0x5d(%rsp)
movb $0x0, 0x5e(%rsp)
movzbl 0x5d(%rsp), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0xb264
movzbl 0x5e(%rsp), %eax
addl $0x4, %eax
movb %al, 0x5e(%rsp)
movzbl 0x5d(%rsp), %eax
sarl $0x4, %eax
movb %al, 0x5d(%rsp)
movzbl 0x5d(%rsp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0xb289
movzbl 0x5e(%rsp), %eax
addl $0x2, %eax
movb %al, 0x5e(%rsp)
movzbl 0x5d(%rsp), %eax
sarl $0x2, %eax
movb %al, 0x5d(%rsp)
movzbl 0x5d(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xb2a0
movb 0x5e(%rsp), %al
addb $0x1, %al
movb %al, 0x5e(%rsp)
movzbl 0x5e(%rsp), %ecx
addl $0x1, %ecx
movzbl 0x5f(%rsp), %eax
addl %ecx, %eax
movb %al, 0x5f(%rsp)
movzbl 0x5f(%rsp), %ecx
andl $0x8, %ecx
sarl $0x3, %ecx
movq 0x68(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x68(%rsp)
movzbl 0x5f(%rsp), %eax
andl $0x7, %eax
movb %al, 0x5f(%rsp)
movq 0x70(%rsp), %rax
movzbl 0x5e(%rsp), %ecx
cmpq $0x0, (%rax,%rcx,8)
jne 0xb33b
movl $0x48, %edi
callq 0x1130
movq %rax, %rdx
movq 0x70(%rsp), %rax
movzbl 0x5e(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movq 0x70(%rsp), %rax
movzbl 0x5e(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xaf20
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x48, %edx
callq 0x1120
movq 0x70(%rsp), %rax
movzbl 0x5e(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x70(%rsp)
jmp 0xb1fe
movq 0x60(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rcx, 0x40(%rax)
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
leaq 0x70(%rsp), %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0x60(%rsp)
cmpq $0x0, 0x40(%rax)
je 0xb39a
movq 0x50(%rsp), %rcx
movq 0x60(%rsp), %rax
movq 0x40(%rcx), %rdi
callq *%rax
movb $0x0, 0x5f(%rsp)
movzbl 0x5f(%rsp), %eax
cmpl $0x8, %eax
jge 0xb409
movq 0x50(%rsp), %rax
movzbl 0x5f(%rsp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0xb3fb
movq 0x50(%rsp), %rax
movzbl 0x5f(%rsp), %ecx
movq (%rax,%rcx,8), %rcx
movq 0x60(%rsp), %rdi
movq 0x40(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x40(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups 0x30(%rcx), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xb370
jmp 0xb3fd
movb 0x5f(%rsp), %al
addb $0x1, %al
movb %al, 0x5f(%rsp)
jmp 0xb39f
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
shlq %rcx
movq %rcx, (%rax)
movl -0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xb542
movq -0x8(%rsp), %rax
movq (%rax), %rcx
orq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rcx
shlq %rcx
movq %rcx, 0x8(%rax)
movl -0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xb56f
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rcx
orq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rcx
shlq %rcx
movq %rcx, 0x10(%rax)
movl -0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xb59c
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rcx
orq $0x1, %rcx
movq %rcx, 0x10(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl -0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xb5d5
movl -0x10(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movq -0x8(%rsp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movl -0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xb5ff
movl -0x10(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movq -0x8(%rsp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movl -0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xb629
movl -0x10(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movq -0x8(%rsp), %rax
orq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
leaq 0x8(%rsp), %rcx
movq %rcx, -0x20(%rsp)
movq %rdi, -0x8(%rsp)
movl $0x1, -0x14(%rsp)
movq (%rcx), %rax
orq 0x8(%rcx), %rax
orq 0x10(%rcx), %rax
movq %rax, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0xb664
jmp 0xb7f3
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
andq -0x10(%rsp), %rax
cmpq $0x0, %rax
je 0xb692
movl -0x14(%rsp), %eax
addl $0x20, %eax
movl %eax, -0x14(%rsp)
movq -0x10(%rsp), %rax
shrq $0x20, %rax
movq %rax, -0x10(%rsp)
movabsq $0xffff0000, %rax       # imm = 0xFFFF0000
andq -0x10(%rsp), %rax
cmpq $0x0, %rax
je 0xb6c0
movl -0x14(%rsp), %eax
addl $0x10, %eax
movl %eax, -0x14(%rsp)
movq -0x10(%rsp), %rax
shrq $0x10, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
andq $0xff00, %rax           # imm = 0xFF00
cmpq $0x0, %rax
je 0xb6ea
movl -0x14(%rsp), %eax
addl $0x8, %eax
movl %eax, -0x14(%rsp)
movq -0x10(%rsp), %rax
shrq $0x8, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
andq $0xf0, %rax
cmpq $0x0, %rax
je 0xb714
movl -0x14(%rsp), %eax
addl $0x4, %eax
movl %eax, -0x14(%rsp)
movq -0x10(%rsp), %rax
shrq $0x4, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
andq $0xc, %rax
cmpq $0x0, %rax
je 0xb73c
movl -0x14(%rsp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rsp)
movq -0x10(%rsp), %rax
shrq $0x2, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0xb756
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
movq -0x20(%rsp), %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rdx
movl -0x14(%rsp), %ecx
shlq %cl, %rdx
orq (%rax), %rdx
movq -0x8(%rsp), %rcx
movq %rdx, (%rcx)
movq -0x8(%rsp), %rcx
movq 0x8(%rcx), %rdx
movl -0x14(%rsp), %ecx
shlq %cl, %rdx
orq 0x8(%rax), %rdx
movq -0x8(%rsp), %rcx
movq %rdx, 0x8(%rcx)
movq -0x8(%rsp), %rcx
movq 0x10(%rcx), %rdx
movl -0x14(%rsp), %ecx
shlq %cl, %rdx
movq %rdx, %rcx
orq 0x10(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rsp), %rax
cmpl $0x0, 0x38(%rax)
je 0xb7f3
movq -0x20(%rsp), %rax
movl 0x38(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x38(%rax)
movl 0x38(%rax), %ecx
movl 0x18(%rax,%rcx,4), %edx
movq -0x8(%rsp), %rax
movq -0x8(%rsp), %rcx
movl 0x38(%rcx), %ecx
movl %edx, 0x18(%rax,%rcx,4)
movq -0x8(%rsp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
jmp 0xb7b2
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0xb410
cmpb $0x0, %al
jne 0xb830
movb $0x0, 0x27(%rsp)
jmp 0xb96e
movq 0x18(%rsp), %rax
movq (%rax), %rdi
leaq 0x29fd(%rip), %rsi      # 0xe23c
movl $0x4, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0xb86d
movq 0x18(%rsp), %rax
movq (%rax), %rax
movsbl 0x4(%rax), %edi
callq 0xb470
cmpb $0x0, %al
jne 0xb86d
movb $0x0, 0x27(%rsp)
jmp 0xb96e
movq 0x18(%rsp), %rax
movq (%rax), %rdi
leaq 0x29c5(%rip), %rsi      # 0xe241
movl $0x3, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0xb8aa
movq 0x18(%rsp), %rax
movq (%rax), %rax
movsbl 0x3(%rax), %edi
callq 0xb470
cmpb $0x0, %al
jne 0xb8aa
movb $0x0, 0x27(%rsp)
jmp 0xb96e
movq 0x18(%rsp), %rax
movq (%rax), %rdi
leaq 0x298c(%rip), %rsi      # 0xe245
movl $0x4, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0xb8e7
movq 0x18(%rsp), %rax
movq (%rax), %rax
movsbl 0x4(%rax), %edi
callq 0xb470
cmpb $0x0, %al
jne 0xb8e7
movb $0x0, 0x27(%rsp)
jmp 0xb96e
cmpl $0x0, 0xc(%rsp)
je 0xb8f9
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xb8fb
movq 0x18(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0xb470
cmpb $0x0, %al
je 0xb959
cmpl $0x0, 0xc(%rsp)
je 0xb948
cmpq $0x0, 0x10(%rsp)
je 0xb948
movq 0x18(%rsp), %rax
movq (%rax), %rax
movb (%rax), %cl
movq 0x10(%rsp), %rax
movb %cl, (%rax)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xb8fb
cmpq $0x0, 0x10(%rsp)
je 0xb969
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x28a1(%rip), %rsi      # 0xe23c
movl $0x4, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0xb9ed
movq (%rsp), %rax
movq (%rax), %rax
movsbl 0x4(%rax), %edi
callq 0xb470
cmpb $0x0, %al
jne 0xb9ed
cmpq $0x0, 0x8(%rsp)
je 0xb9d5
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0xb510
movq (%rsp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movb $0x1, 0x17(%rsp)
jmp 0xbaac
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x2846(%rip), %rsi      # 0xe241
movl $0x3, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0xba4a
movq (%rsp), %rax
movq (%rax), %rax
movsbl 0x3(%rax), %edi
callq 0xb470
cmpb $0x0, %al
jne 0xba4a
cmpq $0x0, 0x8(%rsp)
je 0xba35
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0xb510
movq (%rsp), %rax
movq (%rax), %rcx
addq $0x3, %rcx
movq %rcx, (%rax)
movb $0x1, 0x17(%rsp)
jmp 0xbaac
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x27ed(%rip), %rsi      # 0xe245
movl $0x4, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0xbaa7
movq (%rsp), %rax
movq (%rax), %rax
movsbl 0x4(%rax), %edi
callq 0xb470
cmpb $0x0, %al
jne 0xbaa7
cmpq $0x0, 0x8(%rsp)
je 0xba92
movq 0x8(%rsp), %rdi
movl $0x3, %esi
callq 0xb510
movq (%rsp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movb $0x1, 0x17(%rsp)
jmp 0xbaac
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/been-jamming[P]MinimalCC/types.c
// Function: peek_type
int peek_type(type *t){
	int output = 0;

	if(t->d0&1){
		output |= 1;
	}
	if(t->d1&1){
		output |= 2;
	}
	if(t->d2&1){
		output |= 4;
	}

	return output;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xbdda
movl -0xc(%rsp), %eax
orl $0x1, %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xbdf8
movl -0xc(%rsp), %eax
orl $0x2, %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xbe16
movl -0xc(%rsp), %eax
orl $0x4, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/been-jamming[P]MinimalCC/types.c
// Function: pop_type
int pop_type(type *t){
	int output = 0;

	if(t->d0&1){
		output |= 1;
	}
	if(t->d1&1){
		output |= 2;
	}
	if(t->d2&1){
		output |= 4;
	}

	t->d0 >>= 1;
	t->d1 >>= 1;
	t->d2 >>= 1;

	return output;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xbe4a
movl -0xc(%rsp), %eax
orl $0x1, %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xbe68
movl -0xc(%rsp), %eax
orl $0x2, %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xbe86
movl -0xc(%rsp), %eax
orl $0x4, %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
shrq %rcx
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rcx
shrq %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rcx
shrq %rcx
movq %rcx, 0x10(%rax)
movl -0xc(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x30(%rsp)
movl $0x0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
leaq 0x56eb(%rip), %rsi      # 0x117a8
movl $0x40, %edx
callq 0x1120
movq 0x18(%rsp), %rdi
movl $0x7, 0x38(%rdi)
movq 0x30(%rsp), %rdi
callq 0xbe20
movl %eax, %ecx
movl %ecx, 0x2c(%rsp)
movb $0x1, %al
cmpl $0x4, %ecx
movb %al, 0xf(%rsp)
jae 0xc0fa
cmpl $0x0, 0x28(%rsp)
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xc107
jmp 0xc193
movq 0x18(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x24(%rsp), %edx
callq 0xb5a0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
cmpl $0x5, 0x2c(%rsp)
jne 0xc138
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0xc153
cmpl $0x0, 0x28(%rsp)
je 0xc151
cmpl $0x6, 0x2c(%rsp)
jne 0xc151
movl 0x28(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0xc153
cmpl $0x7, 0x2c(%rsp)
jne 0xc18e
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movl 0x38(%rcx), %edx
addl $-0x1, %edx
movl %edx, 0x38(%rcx)
movq 0x30(%rsp), %rcx
movq 0x30(%rsp), %rdx
movl 0x38(%rdx), %edx
movl 0x18(%rcx,%rdx,4), %edx
movl 0x38(%rax), %ecx
movl %edx, 0x18(%rax,%rcx,4)
movl 0x38(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x38(%rax)
jmp 0xc0d3
movq 0x18(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x24(%rsp), %edx
callq 0xb5a0
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movl $0x8, 0x38(%rcx)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/been-jamming[P]MinimalCC/types.c
// Function: print_type
void print_type(type *t){
	uint64_t d0;
	uint64_t d1;
	uint64_t d2;
	unsigned int index;
	unsigned int type_entry_int;

	d0 = t->d0;
	d1 = t->d1;
	d2 = t->d2;
	index = t->current_index;

	while(d0 | d1 | d2){
		type_entry_int = 0;
		if(d0&1){
			type_entry_int |= 1;
		}
		if(d1&1){
			type_entry_int |= 2;
		}
		if(d2&1){
			type_entry_int |= 4;
		}
		switch(type_entry_int){
			case type_void:
				printf("void, ");
				break;
			case type_int:
				printf("int, ");
				break;
			case type_char:
				printf("char, ");
				break;
			case type_pointer:
				printf("pointer to ");
				break;
			case type_function:
				printf("function ( ");
				break;
			case type_returns:
				printf(") returning ");
				break;
			case type_list:
				index--;
				printf("list of length %d of ", t->list_indicies[index]);
				break;
			default:
				printf("unknown ");
		}
		d0 >>= 1;
		d1 >>= 1;
		d2 >>= 1;
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
orq 0x20(%rsp), %rax
orq 0x18(%rsp), %rax
cmpq $0x0, %rax
je 0xc35d
movl $0x0, 0x10(%rsp)
movq 0x28(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xc239
movl 0x10(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xc253
movl 0x10(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xc26d
movl 0x10(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x6, %eax
ja 0xc323
movq 0x8(%rsp), %rax
leaq 0x1f91(%rip), %rcx      # 0xe220
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1fab(%rip), %rdi      # 0xe24a
movb $0x0, %al
callq 0x1090
jmp 0xc331
leaq 0x1f9f(%rip), %rdi      # 0xe251
movb $0x0, %al
callq 0x1090
jmp 0xc331
leaq 0x1f95(%rip), %rdi      # 0xe257
movb $0x0, %al
callq 0x1090
jmp 0xc331
leaq 0x1f8c(%rip), %rdi      # 0xe25e
movb $0x0, %al
callq 0x1090
jmp 0xc331
leaq 0x1f88(%rip), %rdi      # 0xe26a
movb $0x0, %al
callq 0x1090
jmp 0xc331
leaq 0x1f84(%rip), %rdi      # 0xe276
movb $0x0, %al
callq 0x1090
jmp 0xc331
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rax
movl 0x14(%rsp), %ecx
movl 0x18(%rax,%rcx,4), %esi
leaq 0x1f69(%rip), %rdi      # 0xe283
movb $0x0, %al
callq 0x1090
jmp 0xc331
leaq 0x1f6f(%rip), %rdi      # 0xe299
movb $0x0, %al
callq 0x1090
movq 0x28(%rsp), %rax
shrq %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
shrq %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
shrq %rax
movq %rax, 0x18(%rsp)
jmp 0xc1fe
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)