LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/codegen_expression.c
// Function: print_expression_or_addr_of_struct_or_union
void print_expression_or_addr_of_struct_or_union(struct PrinterState *ptr_prs,
                                                 const struct Expr *ref_expr,
                                                 const char *msg)
{
	if (is_struct_or_union(&ref_expr->details.type)) {
		print_address_of_lvalue_or_struct_or_union(ptr_prs, ref_expr, msg);
	} else {
		print_expression(ptr_prs, ref_expr);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x81cb
movq %r15, %rdi
movq %rbx, %rsi
testl %eax, %eax
je 0x456d
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3832
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3b8f
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/codegen_expression.c
// Function: handle_builtin
void handle_builtin(struct PrinterState *ptr_prs, const char *ident_str)
{
	if (strcmp(ident_str, "__builtin_va_end") == 0) {
		printf("// do nothing for %s\n", ident_str);
		return;
	} else if (strcmp(ident_str, "__builtin_va_start") == 0) {
		int float_arg_num = 0; /* since we still cannot handle them */

		gen_va_start(8 * ptr_prs->integral_explicit_arg_num,
		             48 * (1 + float_arg_num), ptr_prs->reg_save_area);
		return;
	}

	printf("***** Help me: %s\n", ident_str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9aa7(%rip), %rsi      # 0xe037
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
je 0x45b8
leaq 0x9abb(%rip), %rsi      # 0xe05e
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
je 0x45cd
leaq 0x9abb(%rip), %rdi      # 0xe071
jmp 0x45bf
leaq 0x9a89(%rip), %rdi      # 0xe048
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1070
movl 0x44(%r14), %edi
movl 0x48(%r14), %edx
shll $0x3, %edi
pushq $0x30
popq %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xa5e0
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/codegen_expression.c
// Function: print_expression_as_lvalue
static void print_expression_as_lvalue(struct PrinterState *ptr_prs,
                                       const struct Expr *ref_expr)
{
	const struct Expr expr = *ref_expr;
	print_address_of_lvalue_or_struct_or_union(ptr_prs, &expr, "as lvalue");
	switch (expr.category) {
	case FPCALL_EXPR_RETURNING_INTEGER_CLASS:
	case FPCALL_EXPR_RETURNING_MEMORY_CLASS:
	case FUNCCALL_EXPR_RETURNING_INTEGER_CLASS:
	case FUNCCALL_EXPR_RETURNING_MEMORY_CLASS: {
		unsupported("struct returned by function used as a pure rvalue");
	}
	case LOCAL_VAR_: {
		gen_push_from_local_nbyte(
		    size_of_basic(&expr.details.type, "local var as lvalue"),
		    expr.local_var_offset);

		return;
	}
	case GLOBAL_VAR_: {
		printf("//load from global `%s`\n", expr.global_var_name);
		gen_peek_deref_push_nbyte(
		    size_of_basic(&expr.details.type, "global var as lvalue"));

		return;
	}
	case UNARY_OP_EXPR:
		if (expr.unary_operator == UNARY_OP_ASTERISK) {
			gen_peek_deref_push_nbyte(
			    size_of_basic(&expr.details.type, "*expr as lvalue"));
			return;
		} else {
			simple_error("the only unary operator that can create "
			             "lvalue is `*`\n");
		}
	default:
		simple_error("doesn't seem like an lvalue\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
leaq -0x110(%rbp), %r14
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
callq 0x1100
leaq 0x97cc(%rip), %rdx      # 0xde12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3832
movl 0xa0(%r14), %eax
cmpl $0x19, %eax
ja 0x46ca
cmpl $0x7, %eax
je 0x468f
cmpl $0x8, %eax
jne 0x46b4
leaq -0x110(%rbp), %rbx
movq 0xd0(%rbx), %rsi
leaq 0x9c8e(%rip), %rdi      # 0xe30a
xorl %eax, %eax
callq 0x1070
leaq 0x9c99(%rip), %rsi      # 0xe323
movq %rbx, %rdi
jmp 0x46e3
leaq 0x9c60(%rip), %rsi      # 0xe2f6
leaq -0x110(%rbp), %rbx
movq %rbx, %rdi
callq 0x81de
movl 0xf0(%rbx), %esi
movl %eax, %edi
callq 0x979c
jmp 0x46ef
movl $0x3600000, %ecx        # imm = 0x3600000
btl %eax, %ecx
jae 0x46ca
leaq 0x9bff(%rip), %rdi      # 0xe2c4
callq 0x8186
cmpl $0x6, %eax
jne 0x4707
cmpl $0x7, -0x68(%rbp)
jne 0x46fb
leaq 0x9c5c(%rip), %rsi      # 0xe338
leaq -0x110(%rbp), %rdi
callq 0x81de
movl %eax, %edi
callq 0x996e
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x97af(%rip), %rdi      # 0xdeb1
callq 0x814d
leaq 0x96a2(%rip), %rdi      # 0xddb0
callq 0x814d
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/main.c
// Function: main
int main(int argc, char const **argv)
{
	struct __FILE *fp = stdin;
	struct Vector macros = init_vector();

	for (int i = 1; i < argc; i++) {
		if (strncmp(argv[i], "-D", 2) == 0) {
			push_vector(&macros, argv[i] + 2);
		} else if (strncmp(argv[i], "--ir=", 5) == 0) {
			const char *ir_filename = argv[i] + 5;
			global_ir = fopen(ir_filename, "w");
			if (!global_ir) {
				fprintf(stderr, "failed to write to file `%s`.\n", ir_filename);
				exit(EXIT_FAILURE);
			}
		} else if (strcmp(argv[i], "-pedantic") == 0) {
			global_flag_pedantic = 1;
		} else {
			const char *filename = argv[i];
			fp = fopen(filename, "r");
			if (!fp) {
				fprintf(stderr, "failed to open file `%s`.\n", filename);
				exit(EXIT_FAILURE);
			}
		}
	}

	char *str = read_from_file(fp);
	const struct Token *tokvec = read_and_preprocess(str, &macros);
	++tokvec; /* skip the dummy token BEGINNING */
	const struct Vector /*<Toplevel>*/ vec = parse(tokvec);
	generate(&vec);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl %edi, %r15d
movq 0x1172a(%rip), %rax     # 0x15fd8
movq (%rax), %r14
callq 0x49e0
leaq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq %rdx, 0x8(%rcx)
movslq %r15d, %r12
pushq $0x1
popq %r13
cmpq %r12, %r13
jge 0x496c
movq (%rbx,%r13,8), %r15
cmpb $0x2d, (%r15)
jne 0x48f4
cmpb $0x44, 0x1(%r15)
jne 0x48f4
addq $0x2, %r15
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x4a57
jmp 0x4964
movq %r15, %rdi
leaq 0x9aee(%rip), %rsi      # 0xe3ec
pushq $0x5
popq %rdx
callq 0x1030
testl %eax, %eax
je 0x4936
movq %r15, %rdi
leaq 0x9aff(%rip), %rsi      # 0xe413
callq 0x10e0
testl %eax, %eax
je 0x495a
movq %r15, %rdi
leaq 0xa9c7(%rip), %rsi      # 0xf2ee
callq 0x1130
movq %rax, %r14
testq %rax, %rax
jne 0x4964
jmp 0x49aa
addq $0x5, %r15
movq %r15, %rdi
leaq 0x9aae(%rip), %rsi      # 0xe3f2
callq 0x1130
leaq 0x11790(%rip), %rcx     # 0x160e0
movq %rax, (%rcx)
testq %rax, %rax
jne 0x4964
jmp 0x49bd
movl $0x1, 0x11778(%rip)     # 0x160dc
incq %r13
jmp 0x48c8
movq %r14, %rdi
callq 0xbf44
leaq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0xacac
leaq 0x20(%rax), %rdi
callq 0x2136
leaq -0x48(%rbp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0x182c
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x11647(%rip), %rax     # 0x15ff8
movq (%rax), %rdi
leaq 0x9a62(%rip), %rsi      # 0xe41d
jmp 0x49ce
movq 0x11634(%rip), %rax     # 0x15ff8
movq (%rax), %rdi
leaq 0x9a26(%rip), %rsi      # 0xe3f4
movq %r15, %rdx
xorl %eax, %eax
callq 0x10f0
pushq $0x1
popq %rdi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/vector.c
// Function: init_vector_
struct Vector *init_vector_(void)
{
	struct Vector *ptr_res = calloc(1, sizeof(struct Vector));
	ptr_res->length = 0;
	ptr_res->capacity = 256;
	ptr_res->vector = calloc(ptr_res->capacity, sizeof(void *));
	return ptr_res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x10d0
movq %rax, %rbx
movl $0x100, 0x4(%rax)       # imm = 0x100
pushq $0x8
popq %rsi
movl $0x100, %edi            # imm = 0x100
callq 0x10d0
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/vector.c
// Function: extend_vector
void extend_vector(struct Vector *ptr)
{
	if (ptr->capacity < ptr->length + 1) {
		ptr->vector =
		    realloc(ptr->vector, ptr->capacity * 2 * sizeof(void *));

		ptr->capacity *= 2;
	}
}

// Assembly:
movslq 0x4(%rdi), %rsi
cmpl (%rdi), %esi
jg 0x4a56
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
shlq $0x4, %rsi
callq 0x1120
movq %rax, 0x8(%rbx)
shll 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/vector.c
// Function: pop_vector
const void *pop_vector(struct Vector *ptr)
{
	if (ptr->length == 0) {
		assert("tried to pop an empty vector" && 0);
	}
	--(ptr->length);
	return ptr->vector[ptr->length]; /* safe, since it is not yet released or
	                                    anything */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
testl %eax, %eax
jne 0x4a99
xorl %edi, %edi
xorl %eax, %eax
callq 0x128c
movl (%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rbx)
movq 0x8(%rbx), %rcx
cltq
movq -0x8(%rcx,%rax,8), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/vector.c
// Function: concat_vector
void concat_vector(struct Vector *ptr_ans, const struct Vector *ptr_vec)
{
	if (!ptr_ans) {
		fprintf(stderr, "NULL POINTER IN THE FIRST ARGUMENT\n");
		exit(1);
	}

	if (!ptr_vec) {
		fprintf(stderr, "NULL POINTER IN THE SECOND ARGUMENT\n");
		exit(1);
	}

	if (!ptr_vec->vector) {
		fprintf(stderr, "OH MY GOD: INVALID VECTOR IN THE SECOND ARGUMENT\n");
		exit(1);
	}

	for (int i = 0; i < ptr_vec->length; i++) {
		push_vector(ptr_ans, ptr_vec->vector[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4afc
movq %rsi, %rbx
testq %rsi, %rsi
je 0x4b11
cmpq $0x0, 0x8(%rbx)
je 0x4b26
movq %rdi, %r14
xorl %r15d, %r15d
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0x4af1
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x4a57
incq %r15
jmp 0x4ad4
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x114f5(%rip), %rax     # 0x15ff8
movq (%rax), %rcx
leaq 0x992b(%rip), %rdi      # 0xe438
pushq $0x23
jmp 0x4b39
movq 0x114e0(%rip), %rax     # 0x15ff8
movq (%rax), %rcx
leaq 0x993a(%rip), %rdi      # 0xe45c
pushq $0x24
jmp 0x4b39
movq 0x114cb(%rip), %rax     # 0x15ff8
movq (%rax), %rcx
leaq 0x994a(%rip), %rdi      # 0xe481
pushq $0x31
popq %rsi
pushq $0x1
popq %rdx
callq 0x1180
pushq $0x1
popq %rdi
callq 0x1170
nop
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/typecheck_expression.c
// Function: typecheck_constant_integral_expression
int typecheck_constant_integral_expression(struct AnalyzerState *ptr_ps,
                                           const struct UntypedExpr *ref_uexpr,
                                           const char *context)
{
	const struct UntypedExpr uexpr = *ref_uexpr;
	switch (uexpr.category) {
	case INT_LITERAL_:
		return uexpr.int_value;
	case VAR: {
		const char *name = uexpr.var_name;

		if (is_local_var(&ptr_ps->scope_chain, name)) {
			break;
		}

		const struct EnumeratorAndValue *ptr_enum_and_value =
		    get_global_enumerator(&ptr_ps->global_enumerator_list, name);

		if (!ptr_enum_and_value) {
			break;
		}

		return ptr_enum_and_value->value;
	}
	default:
		break;
	}

	fprintf(stderr, "Expected const expression, but did not get one.\n");
	fprintf(stderr, "context: %s\n", context);
	exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl 0x4(%rsi), %eax
cmpl $0x3, %eax
je 0x4b6c
cmpl $0x4, %eax
jne 0x4baa
addq $0x20, %rsi
jmp 0x4b9d
movq %rdi, %r14
movq 0x28(%rsi), %r15
movq %r15, %rsi
callq 0x4be2
testl %eax, %eax
jne 0x4baa
addq $0x88, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x4c1c
testq %rax, %rax
je 0x4baa
movq %rax, %rsi
addq $0x8, %rsi
movl (%rsi), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x11447(%rip), %r14     # 0x15ff8
movq (%r14), %rcx
leaq 0x9b05(%rip), %rdi      # 0xe6c0
pushq $0x30
popq %rsi
pushq $0x1
popq %rdx
callq 0x1180
movq (%r14), %rdi
leaq 0x9b73(%rip), %rsi      # 0xe743
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10f0
pushq $0x1
popq %rdi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/typecheck_expression.c
// Function: get_global_enumerator
static const struct EnumeratorAndValue *
get_global_enumerator(const struct Vector /*<EnumeratorAndValue>*/ *ref_list,
                      const char *name)
{
	for (int i = 0; i < ref_list->length; i++) {
		const struct EnumeratorAndValue *ptr_vec_i = ref_list->vector[i];
		if (strcmp(ptr_vec_i->ident, name) == 0) {
			return ptr_vec_i;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %r12d
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
cmpq %r13, %r12
je 0x4c5e
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %r15
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x10e0
incq %r13
testl %eax, %eax
jne 0x4c3d
jmp 0x4c61
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/typecheck_expression.c
// Function: expect_type
void expect_type(const struct AnalyzerState *ptr_ps,
                 const struct Type *ref_actual_type,
                 const struct Type *ref_expected_type, const char *message)
{

	if (!is_compatible(ptr_ps, ref_actual_type, ref_expected_type)) {
		fprintf(stderr, "Unmatched type: expected `");
		debug_print_type(ref_expected_type);
		fprintf(stderr, "`, but got `");
		debug_print_type(ref_actual_type);
		fprintf(stderr, "`.\n");
		fprintf(stderr, "context: %s\n", message);
		exit(EXIT_FAILURE);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
callq 0x4d1c
testl %eax, %eax
je 0x4ca2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1134f(%rip), %r13     # 0x15ff8
movq (%r13), %rcx
leaq 0x9a3d(%rip), %rdi      # 0xe6f1
pushq $0x1a
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
callq 0x1180
movq %r12, %rdi
callq 0x827e
movq (%r13), %rcx
leaq 0x9b9a(%rip), %rdi      # 0xe870
pushq $0xc
popq %rsi
movq %r15, %rdx
callq 0x1180
movq %r14, %rdi
callq 0x827e
movq (%r13), %rcx
leaq 0xc9e9(%rip), %rdi      # 0x116dd
pushq $0x3
popq %rsi
movq %r15, %rdx
callq 0x1180
movq (%r13), %rdi
leaq 0x9a39(%rip), %rsi      # 0xe743
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10f0
pushq $0x1
popq %rdi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/typecheck_expression.c
// Function: expect_scalar
void expect_scalar(const struct Type *ref_type, const char *context)
{
	if (!is_scalar(ref_type)) {
		fprintf(stderr, "Expected a scalar type, but got a non-scalar type `");
		debug_print_type(ref_type);
		fprintf(stderr, "`.\ncontext: %s\n", context);
		exit(EXIT_FAILURE);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, (%rdi)
je 0x4efb
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4fc5
testl %eax, %eax
je 0x4f06
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x110eb(%rip), %r15     # 0x15ff8
movq (%r15), %rcx
leaq 0x97f5(%rip), %rdi      # 0xe70c
pushq $0x33
popq %rsi
pushq $0x1
popq %rdx
callq 0x1180
movq %r14, %rdi
callq 0x827e
movq (%r15), %rdi
leaq 0x980c(%rip), %rsi      # 0xe740
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10f0
pushq $0x1
popq %rdi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/typecheck_expression.c
// Function: expect_integral
void expect_integral(const struct Type *ref_actual_type, const char *message)
{

	if (!is_integral(ref_actual_type)) {
		fprintf(stderr, "Unmatched type: expected an integral type, but got a "
		                "non-integral type `");
		debug_print_type(ref_actual_type);
		fprintf(stderr, "`.\n");
		fprintf(stderr, "context: %s\n", message);
		exit(EXIT_FAILURE);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4fc5
testl %eax, %eax
je 0x4f69
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x11088(%rip), %r12     # 0x15ff8
movq (%r12), %rcx
leaq 0x97d5(%rip), %rdi      # 0xe750
pushq $0x48
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
callq 0x1180
movq %r14, %rdi
callq 0x827e
movq (%r12), %rcx
leaq 0xc740(%rip), %rdi      # 0x116dd
pushq $0x3
popq %rsi
movq %r15, %rdx
callq 0x1180
movq (%r12), %rdi
leaq 0x9790(%rip), %rsi      # 0xe743
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10f0
pushq $0x1
popq %rdi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/typecheck_expression.c
// Function: isAssign
int isAssign(enum TokenKind opkind)
{
	return (opkind == OP_EQ || opkind == OP_PLUS_EQ || opkind == OP_MINUS_EQ ||
	        opkind == OP_ASTERISK_EQ || opkind == OP_SLASH_EQ ||
	        opkind == OP_PERCENT_EQ || opkind == OP_LSHIFT_EQ ||
	        opkind == OP_RSHIFT_EQ || opkind == OP_AND_EQ ||
	        opkind == OP_HAT_EQ || opkind == OP_OR_EQ);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal -0x17(%rdi), %eax
cmpl $0x14, %eax
jae 0x5001
movl $0xff801, %ecx          # imm = 0xFF801
btl %eax, %ecx
jae 0x5001
movl $0x1, %eax
jmp 0x5009
xorl %eax, %eax
cmpl $0x2b, %edi
sete %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/typecheck_expression.c
// Function: if_function_cast_to_pointer
void if_function_cast_to_pointer(struct Expr *ptr_expr)
{
	if (ptr_expr->details.type.type_category == FN) {
		struct Type type = ptr_expr->details.type;
		const struct Type ptr_to_type_ = ptr_to_type(&type);
		struct Expr e = unary_op_(ptr_expr, OP_AND, &ptr_to_type_);
		*ptr_expr = e;
	}
}

// Assembly:
cmpl $0x3, (%rdi)
jne 0x50a7
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
pushq $0xa
popq %rcx
leaq -0xb8(%rbp), %rax
movq %rax, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq -0x68(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x862d
leaq -0x1b8(%rbp), %r15
pushq $0x11
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x50a8
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1100
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/typecheck_expression.c
// Function: unary_op_
static struct Expr unary_op_(const struct Expr *ref_expr, enum TokenKind kind,
                             const struct Type *ref_type)
{
	struct Expr *ptr_expr1 = calloc(1, sizeof(struct Expr));
	*ptr_expr1 = *ref_expr;

	struct Expr new_expr;
	new_expr.details.type = *ref_type;
	new_expr.category = UNARY_OP_EXPR;
	new_expr.unary_operator = to_unaryop(kind);
	new_expr.ptr1 = ptr_expr1;
	new_expr.ptr2 = 0;
	new_expr.ptr3 = 0;

	return new_expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movl %edx, %r15d
movq %rsi, %r13
movq %rdi, %rbx
pushq $0x1
popq %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x10d0
movq %rax, %r14
movl $0x100, %edx            # imm = 0x100
movq %rax, %rdi
movq %r13, %rsi
callq 0x1100
pushq $0xa
popq %rcx
movq %rbx, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0x6, 0xa0(%rbx)
testl %r15d, %r15d
je 0x513b
cmpl $0x1, %r15d
je 0x5143
cmpl $0x5, %r15d
je 0x513f
cmpl $0x11, %r15d
je 0x512b
cmpl $0x15, %r15d
je 0x5133
cmpl $0x33, %r15d
je 0x5137
cmpl $0x32, %r15d
je 0x512f
cmpl $0x16, %r15d
jne 0x516f
pushq $0x1
jmp 0x5145
pushq $0x6
jmp 0x5145
pushq $0x4
jmp 0x5145
xorl %eax, %eax
jmp 0x5146
pushq $0x5
jmp 0x5145
pushq $0x2
jmp 0x5145
pushq $0x7
jmp 0x5145
pushq $0x3
popq %rax
movl %eax, 0xa8(%rbx)
movq %r14, 0xb0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xb8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10e82(%rip), %rax     # 0x15ff8
movq (%rax), %rdi
leaq 0x9c3f(%rip), %rsi      # 0xedbf
leaq 0x9ce8(%rip), %rdx      # 0xee6f
movl %r15d, %ecx
xorl %eax, %eax
callq 0x10f0
pushq $0x1
popq %rdi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/typecheck_expression.c
// Function: builtin_func_call_expr
struct Expr builtin_func_call_expr(
    struct AnalyzerState *ptr_ps,
    const struct Vector /* <UntypedExpr> */ *ref_arg_exprs_vec)
{
	struct Type ret_type;
	ret_type.type_category = VOID_;

	struct Expr expr;
	expr.args = init_vector();
	expr.category = BUILTIN_FUNCCALL_EXPR;

	for (int counter = 0; counter < ref_arg_exprs_vec->length; counter++) {
		const struct UntypedExpr *ptr = ref_arg_exprs_vec->vector[counter];

		struct Expr *ptr_arg = calloc(1, sizeof(struct Expr));
		*ptr_arg = typecheck_expression(ptr_ps, ptr);

		push_vector(&expr.args, ptr_arg);
	}

	expr.details.type = ret_type;
	return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdx, %r14
movq %rsi, -0x40(%rbp)
movq %rdi, %rbx
leaq 0xe0(%rdi), %rax
movq %rax, -0x38(%rbp)
callq 0x49e0
movq %rax, 0xe0(%rbx)
movq %rdx, 0xe8(%rbx)
movq %rbx, -0x30(%rbp)
movl $0x1b, 0xa0(%rbx)
xorl %r12d, %r12d
leaq -0x140(%rbp), %rbx
movslq (%r14), %rax
cmpq %rax, %r12
jge 0x54bb
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %r13
movl $0x100, %esi            # imm = 0x100
pushq $0x1
popq %rdi
callq 0x10d0
movq %rax, %r15
movq %rbx, %rdi
movq -0x40(%rbp), %rsi
movq %r13, %rdx
callq 0x54d7
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1100
movq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x4a57
incq %r12
jmp 0x546b
movq -0x30(%rbp), %rax
movl $0x7, (%rax)
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/typecheck_expression.c
// Function: string_literal
static struct Expr string_literal(const char *string)
{
	const struct Type char_type = CHAR_TYPE();

	struct Expr expr;
	expr.details.type = ptr_to_type(&char_type);
	expr.details.true_type = arr_of_type(&char_type, strlen(string) + 1);
	expr.category = STRING_LITERAL;
	expr.literal_string = string;

	return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0xc8(%rbp), %r15
movq %r15, %rdi
callq 0x81bc
movq %r14, %rdi
movq %r15, %rsi
callq 0x862d
leaq 0x50(%r14), %r12
movq %rbx, %rdi
callq 0x1060
leal 0x1(%rax), %edx
leaq -0x78(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x8664
pushq $0xa
popq %rcx
movq %r12, %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0x11, 0xa0(%r14)
movq %rbx, 0xd8(%r14)
movq %r14, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/typecheck_expression.c
// Function: simple_binary_op
static struct Expr simple_binary_op(const struct Expr *ref_expr,
                                    const struct Expr *ref_expr2,
                                    enum TokenKind kind,
                                    const struct Type *ref_type)
{
	struct Expr *ptr_expr1 = calloc(1, sizeof(struct Expr));
	struct Expr *ptr_expr2 = calloc(1, sizeof(struct Expr));
	*ptr_expr1 = *ref_expr;
	*ptr_expr2 = *ref_expr2;

	struct Expr new_expr;
	new_expr.details.type = *ref_type;
	new_expr.details.true_type = *ref_type;
	new_expr.category = SIMPLE_BINARY_EXPR;
	new_expr.simple_binary_operator = to_simplebinop(kind);
	new_expr.ptr1 = ptr_expr1;
	new_expr.ptr2 = ptr_expr2;
	new_expr.ptr3 = 0;

	return new_expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r13
movl %ecx, %ebx
movq %rdx, -0x40(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdi, %r14
pushq $0x1
popq %r12
movl $0x100, %esi            # imm = 0x100
movq %r12, %rdi
callq 0x10d0
movq %rax, %r15
movl $0x100, %esi            # imm = 0x100
movq %r12, %rdi
callq 0x10d0
movq %rax, %r12
movl $0x100, %edx            # imm = 0x100
movq %r15, -0x30(%rbp)
movq %r15, %rdi
movq -0x38(%rbp), %rsi
callq 0x1100
movl $0x100, %edx            # imm = 0x100
movq %r12, %rdi
movq -0x40(%rbp), %rsi
callq 0x1100
pushq $0xa
popq %rax
movq %rax, %rcx
movq %r14, %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x50(%r14), %rdi
movq %rax, %rcx
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
andl $0x0, 0xa0(%r14)
cmpl $0x1c, %ebx
jae 0x6d4e
movl $0x81ffb23, %eax        # imm = 0x81FFB23
btl %ebx, %eax
jae 0x6d4e
movl %ebx, %eax
leaq 0x7938(%rip), %rcx      # 0xe650
movl (%rcx,%rax,4), %eax
movl %eax, 0xa4(%r14)
movq -0x30(%rbp), %rax
movq %rax, 0xb0(%r14)
movq %r12, 0xb8(%r14)
andq $0x0, 0xc0(%r14)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xf2a3(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
leaq 0x820f(%rip), %rsi      # 0xef6e
leaq 0x82b9(%rip), %rdx      # 0xf01f
movl %ebx, %ecx
xorl %eax, %eax
callq 0x10f0
pushq $0x1
popq %rdi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/typecheck_expression.c
// Function: pointer_plusorminus_int
static struct Expr pointer_plusorminus_int(const struct AnalyzerState *ptr_ps,
                                           const struct Expr *ref_expr,
                                           const struct Expr *ref_expr2,
                                           enum TokenKind kind)
{
	struct Expr *ptr_expr1 = calloc(1, sizeof(struct Expr));
	struct Expr *ptr_expr2 = calloc(1, sizeof(struct Expr));
	*ptr_expr1 = *ref_expr;
	*ptr_expr2 = *ref_expr2;

	struct Expr new_expr;
	new_expr.details = ref_expr->details;

	// array must decay into a pointer once pointer arithmetic happens
	if (new_expr.details.true_type.type_category == ARRAY) {
		new_expr.details.true_type.type_category = PTR_;
	}
	new_expr.category = kind == OP_PLUS ? POINTER_PLUS_INT : POINTER_MINUS_INT;
	new_expr.ptr1 = ptr_expr1;
	new_expr.ptr2 = ptr_expr2;
	new_expr.ptr3 = 0;
	const struct Type deref = deref_type(&ref_expr->details.type);
	new_expr.size_info_for_pointer_arith = size_of(ptr_ps, &deref);

	return new_expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, -0x2c(%rbp)
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, -0x38(%rbp)
movq %rdi, %rbx
pushq $0x1
popq %r14
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
callq 0x10d0
movq %rax, %r13
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
callq 0x10d0
movq %rax, %r14
movl $0x100, %edx            # imm = 0x100
movq %r13, %rdi
movq %r15, %rsi
callq 0x1100
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
movq %r12, %rsi
callq 0x1100
movl $0xa0, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1100
cmpl $0x2, 0x50(%rbx)
jne 0x6dfa
movl $0x1, 0x50(%rbx)
cmpl $0x1, -0x2c(%rbp)
pushq $0x3
popq %rax
sbbl $0x0, %eax
movl %eax, 0xa0(%rbx)
movq %r13, 0xb0(%rbx)
movq %r14, 0xb8(%rbx)
andq $0x0, 0xc0(%rbx)
leaq -0x88(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x85ad
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x1e24
movl %eax, 0xf4(%rbx)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/typecheck_expression.c
// Function: binary_op
static struct Expr binary_op(const struct Expr *ref_expr,
                             const struct Expr *ref_expr2,
                             enum ExprCategory cat, const struct Type *ref_type)
{
	struct Expr *ptr_expr1 = calloc(1, sizeof(struct Expr));
	struct Expr *ptr_expr2 = calloc(1, sizeof(struct Expr));
	*ptr_expr1 = *ref_expr;
	*ptr_expr2 = *ref_expr2;

	struct Expr new_expr;
	new_expr.details.type = *ref_type;
	new_expr.details.true_type = *ref_type;
	new_expr.category = cat;
	new_expr.ptr1 = ptr_expr1;
	new_expr.ptr2 = ptr_expr2;
	new_expr.ptr3 = 0;

	return new_expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movl %ecx, -0x2c(%rbp)
movq %rdx, -0x38(%rbp)
movq %rsi, %r13
movq %rdi, %rbx
pushq $0x1
popq %r14
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
callq 0x10d0
movq %rax, %r12
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
callq 0x10d0
movq %rax, %r14
movl $0x100, %edx            # imm = 0x100
movq %r12, %rdi
movq %r13, %rsi
callq 0x1100
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
movq -0x38(%rbp), %rsi
callq 0x1100
pushq $0xa
popq %rax
movq %rax, %rcx
movq %rbx, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x50(%rbx), %rdi
movq %rax, %rcx
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl -0x2c(%rbp), %eax
movl %eax, 0xa0(%rbx)
movq %r12, 0xb0(%rbx)
movq %r14, 0xb8(%rbx)
andq $0x0, 0xc0(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/parse_expression.c
// Function: binary_op_untyped
struct UntypedExpr binary_op_untyped(const struct UntypedExpr *ref_expr,
                                     const struct UntypedExpr *ref_expr2,
                                     enum TokenKind kind)
{
	struct UntypedExpr *ptr_expr1 = calloc(1, sizeof(struct UntypedExpr));
	struct UntypedExpr *ptr_expr2 = calloc(1, sizeof(struct UntypedExpr));
	*ptr_expr1 = *ref_expr;
	*ptr_expr2 = *ref_expr2;

	struct UntypedExpr new_expr;
	new_expr.category = BINARY_EXPR;
	new_expr.operator_ = kind;
	new_expr.ptr1 = ptr_expr1;
	new_expr.ptr2 = ptr_expr2;
	new_expr.ptr3 = 0;

	return new_expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, -0x2c(%rbp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x1
popq %r13
movl $0xa0, %esi
movq %r13, %rdi
callq 0x10d0
movq %rax, %r14
movl $0xa0, %esi
movq %r13, %rdi
callq 0x10d0
movq %rax, %r13
movl $0xa0, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x1100
movl $0xa0, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x1100
andl $0x0, 0x4(%rbx)
movl -0x2c(%rbp), %eax
movl %eax, (%rbx)
movq %r14, 0x8(%rbx)
movq %r13, 0x10(%rbx)
andq $0x0, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_assignment_expression
struct UntypedExpr parse_assignment_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;

	const struct Token *tokvec2 = tokvec;
	struct UntypedExpr expr = parse_unary_expression(&tokvec2);

	/* parse failed */
	if (!isAssign(tokvec2[0].kind)) {
		struct UntypedExpr expr_ = parse_conditional_expression(&tokvec);
		*ptr_tokvec = tokvec;
		return expr_;
	}

	tokvec = tokvec2;

	assert(isAssign(tokvec[0].kind));
	enum TokenKind opkind = tokvec[0].kind;
	++tokvec;

	const struct UntypedExpr expr2 = parse_assignment_expression(&tokvec);

	*ptr_tokvec = tokvec;
	return binary_op_untyped(&expr, &expr2, opkind);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, -0x30(%rbp)
leaq -0x38(%rbp), %r15
movq %rax, (%r15)
leaq -0xd8(%rbp), %rdi
movq %r15, %rsi
callq 0x725d
movq (%r15), %r13
movl (%r13), %edi
callq 0x4fe4
testl %eax, %eax
je 0x7233
movl (%r13), %edi
callq 0x4fe4
movl %eax, %edi
xorl %eax, %eax
callq 0x128c
movl (%r13), %r15d
addq $0x20, %r13
leaq -0x30(%rbp), %r12
movq %r13, (%r12)
leaq -0x178(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x719a
movq (%r12), %rax
movq %rax, (%r14)
leaq -0xd8(%rbp), %rsi
movq %rbx, %rdi
movq %r13, %rdx
movl %r15d, %ecx
callq 0x7114
jmp 0x7248
leaq -0x30(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x76ff
movq (%r15), %rax
movq %rax, (%r14)
movq %rbx, %rax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_conditional_expression
static struct UntypedExpr
parse_conditional_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;
	struct UntypedExpr expr = parse_logical_OR_expression(&tokvec);
	if (tokvec[0].kind == QUESTION) {

		++tokvec;
		*ptr_tokvec = tokvec;
		struct UntypedExpr true_branch = parse_expression(&tokvec);

		expect_and_consume(&tokvec, COLON, "colon of the conditional operator");

		*ptr_tokvec = tokvec;
		struct UntypedExpr false_branch = parse_conditional_expression(&tokvec);

		*ptr_tokvec = tokvec;

		struct UntypedExpr *ptr_expr1 = calloc(1, sizeof(struct UntypedExpr));
		struct UntypedExpr *ptr_expr2 = calloc(1, sizeof(struct UntypedExpr));
		struct UntypedExpr *ptr_expr3 = calloc(1, sizeof(struct UntypedExpr));
		*ptr_expr1 = expr;
		*ptr_expr2 = true_branch;
		*ptr_expr3 = false_branch;

		struct UntypedExpr new_expr;
		new_expr.category = CONDITIONAL;
		new_expr.ptr1 = ptr_expr1;
		new_expr.ptr2 = ptr_expr2;
		new_expr.ptr3 = ptr_expr3;

		return new_expr;
	}
	*ptr_tokvec = tokvec;
	return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, -0x40(%rbp)
movq %rsi, -0x38(%rbp)
movq (%rsi), %rax
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
leaq -0xe0(%rbp), %r12
movq %r12, %rdi
callq 0x7b13
leaq -0x180(%rbp), %r13
leaq -0x220(%rbp), %r14
pushq $0x21
popq %rbx
movq -0x30(%rbp), %r15
movl (%r15), %eax
cmpl $0x21, %eax
jne 0x7787
addq $0x20, %r15
movq %r15, -0x30(%rbp)
movq %r13, %rdi
leaq -0x30(%rbp), %rsi
callq 0x7b13
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %ebx, %ecx
callq 0x7114
movl $0xa0, %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x1100
jmp 0x7745
cmpl $0x1c, %eax
jne 0x786e
addq $0x20, %r15
leaq -0x30(%rbp), %rbx
movq %r15, (%rbx)
movq -0x38(%rbp), %rax
movq %r15, (%rax)
movq %rax, %r14
leaq -0x180(%rbp), %rdi
movq %rbx, %rsi
callq 0x78ba
leaq 0x79eb(%rip), %rdx      # 0xf1a6
pushq $0x1d
popq %rsi
movq %rbx, %rdi
callq 0x8168
movq (%rbx), %rax
movq %rax, (%r14)
leaq -0x220(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x76ff
movq (%rbx), %r15
pushq $0x1
popq %rbx
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x10d0
movq %rax, %r13
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x10d0
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x10d0
movq %rax, %rbx
leaq -0xe0(%rbp), %rsi
movl $0xa0, %edx
movq %r13, %rdi
callq 0x1100
movl $0xa0, %edx
movq %r14, %rdi
leaq -0x180(%rbp), %rsi
callq 0x1100
movl $0xa0, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1100
movq -0x40(%rbp), %r12
movl $0x2, 0x4(%r12)
movq %r13, 0x8(%r12)
movq %r14, 0x10(%r12)
movq -0x38(%rbp), %rax
movq %rbx, 0x18(%r12)
jmp 0x788a
leaq -0xe0(%rbp), %rsi
movl $0xa0, %edx
movq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x1100
movq -0x38(%rbp), %rax
movq %r15, (%rax)
movq %r12, %rax
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_expression
struct UntypedExpr parse_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;
	struct UntypedExpr expr = parse_assignment_expression(&tokvec);
	while (1) {
		enum TokenKind kind = tokvec[0].kind;
		if (kind != OP_COMMA) {
			break;
		}
		++tokvec;

		const struct UntypedExpr expr2 = parse_assignment_expression(&tokvec);

		expr = binary_op_untyped(&expr, &expr2, kind);
	}
	*ptr_tokvec = tokvec;
	return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rdi, %r14
movq %rsi, -0x38(%rbp)
movq (%rsi), %rax
leaq -0x30(%rbp), %r15
movq %rax, (%r15)
movq %r15, %rsi
callq 0x719a
leaq -0x178(%rbp), %r12
leaq -0xd8(%rbp), %r13
pushq $0xa
popq %rbx
movq -0x30(%rbp), %rax
cmpl $0xa, (%rax)
jne 0x7936
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x719a
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x7114
movl $0xa0, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1100
jmp 0x78f8
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq %r14, %rax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/parse_expression.c
// Function: unary_op_untyped
static struct UntypedExpr unary_op_untyped(const struct UntypedExpr *ref_expr,
                                           enum TokenKind kind)
{
	struct UntypedExpr *ptr_expr1 = calloc(1, sizeof(struct UntypedExpr));
	*ptr_expr1 = *ref_expr;

	struct UntypedExpr new_expr;
	new_expr.category = UNARY_EXPR;
	new_expr.operator_ = kind;
	new_expr.ptr1 = ptr_expr1;
	new_expr.ptr2 = 0;
	new_expr.ptr3 = 0;

	return new_expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
movl $0xa0, %esi
callq 0x10d0
movq %rax, %r12
movl $0xa0, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1100
movl $0x1, 0x4(%r15)
movl %ebx, (%r15)
movq %r12, 0x8(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_arguments
static struct Vector /*<UntypedExpr>*/
parse_arguments(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;
	struct Vector /*<UntypedExpr>*/ arguments = init_vector();

	if (tokvec[0].kind == RIGHT_PAREN) {
		tokvec++;
	} else {
		struct UntypedExpr e = parse_assignment_expression(&tokvec);
		struct UntypedExpr *ptr_e = calloc(1, sizeof(struct UntypedExpr));
		*ptr_e = e;
		push_vector(&arguments, ptr_e);

		while (1) {
			enum TokenKind kind = tokvec[0].kind;
			if (kind != OP_COMMA) {
				break;
			}
			++tokvec;

			struct UntypedExpr e2 = parse_assignment_expression(&tokvec);
			struct UntypedExpr *ptr_e2 = calloc(1, sizeof(struct UntypedExpr));
			*ptr_e2 = e2;
			push_vector(&arguments, ptr_e2);
		}

		expect_and_consume(&tokvec, RIGHT_PAREN,
		                   "closing parenthesis of function call");
	}
	*ptr_tokvec = tokvec;
	return arguments;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %rdi, %r14
movq (%rdi), %rbx
movq %rbx, -0x30(%rbp)
callq 0x49e0
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
cmpl $0x7, (%rbx)
jne 0x79e1
addq $0x20, %rbx
jmp 0x7aa3
movq %r14, -0x48(%rbp)
leaq -0x188(%rbp), %r12
leaq -0x30(%rbp), %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x719a
pushq $0x1
popq %r15
movl $0xa0, %esi
movq %r15, %rdi
callq 0x10d0
movq %rax, %r13
movl $0xa0, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x1100
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x4a57
leaq -0xe8(%rbp), %r13
movq -0x30(%rbp), %rax
cmpl $0xa, (%rax)
jne 0x7a7e
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq %r13, %rdi
movq %r14, %rsi
callq 0x719a
movl $0xa0, %esi
movq %r15, %rdi
callq 0x10d0
movq %rax, %rbx
movl $0xa0, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x1100
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4a57
jmp 0x7a35
leaq 0x76bc(%rip), %rdx      # 0xf141
leaq -0x30(%rbp), %rbx
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x8168
movq (%rbx), %rbx
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdx
movq -0x48(%rbp), %r14
movq %rbx, (%r14)
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/parse_expression.c
// Function: ampersand_dot
static struct UntypedExpr ampersand_dot(const struct UntypedExpr *ref_expr,
                                        const char *name)
{
	struct UntypedExpr *ptr_expr1 = calloc(1, sizeof(struct UntypedExpr));
	*ptr_expr1 = *ref_expr;

	struct UntypedExpr new_expr;
	new_expr.category = AMPERSAND_DOT;
	new_expr.ptr1 = ptr_expr1;
	new_expr.ptr2 = 0;
	new_expr.ptr3 = 0;
	new_expr.ident_after_dot = name;
	return new_expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
movl $0xa0, %esi
callq 0x10d0
movq %rax, %r12
movl $0xa0, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1100
movl $0xb, 0x4(%r15)
movq %r12, 0x8(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq %rbx, 0x98(%r15)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_logical_AND_expression
static struct UntypedExpr
parse_logical_AND_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;

	struct UntypedExpr first_expr = parse_inclusive_OR_expression(&tokvec);

	while (1) {
		enum TokenKind kind = tokvec[0].kind;
		if (kind != OP_AND_AND) {
			break;
		}

		++tokvec;

		struct UntypedExpr expr2 = parse_inclusive_OR_expression(&tokvec);

		first_expr = binary_op_untyped(&first_expr, &expr2, OP_AND_AND);
	}

	*ptr_tokvec = tokvec;
	return first_expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rdi, %r14
movq %rsi, -0x38(%rbp)
movq (%rsi), %rax
leaq -0x30(%rbp), %r15
movq %rax, (%r15)
movq %r15, %rsi
callq 0x7bab
leaq -0x178(%rbp), %r12
leaq -0xd8(%rbp), %r13
pushq $0x20
popq %rbx
movq -0x30(%rbp), %rax
cmpl $0x20, (%rax)
jne 0x7b8f
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x7bab
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x7114
movl $0xa0, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1100
jmp 0x7b51
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq %r14, %rax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_inclusive_OR_expression
static struct UntypedExpr
parse_inclusive_OR_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;

	struct UntypedExpr expr = parse_exclusive_OR_expression(&tokvec);

	while (1) {
		enum TokenKind kind = tokvec[0].kind;
		if (kind != OP_OR) {
			break;
		}
		++tokvec;

		const struct UntypedExpr expr2 = parse_exclusive_OR_expression(&tokvec);
		expr = binary_op_untyped(&expr, &expr2, kind);
	}
	*ptr_tokvec = tokvec;
	return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rdi, %r14
movq %rsi, -0x38(%rbp)
movq (%rsi), %rax
leaq -0x30(%rbp), %r15
movq %rax, (%r15)
movq %r15, %rsi
callq 0x7c43
leaq -0x178(%rbp), %r12
leaq -0xd8(%rbp), %r13
pushq $0x12
popq %rbx
movq -0x30(%rbp), %rax
cmpl $0x12, (%rax)
jne 0x7c27
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x7c43
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x7114
movl $0xa0, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1100
jmp 0x7be9
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq %r14, %rax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_exclusive_OR_expression
static struct UntypedExpr
parse_exclusive_OR_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;

	struct UntypedExpr expr = parse_AND_expression(&tokvec);

	while (1) {
		enum TokenKind kind = tokvec[0].kind;
		if (kind != OP_HAT) {
			break;
		}
		++tokvec;

		const struct UntypedExpr expr2 = parse_AND_expression(&tokvec);
		expr = binary_op_untyped(&expr, &expr2, kind);
	}
	*ptr_tokvec = tokvec;

	return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rdi, %r14
movq %rsi, -0x38(%rbp)
movq (%rsi), %rax
leaq -0x30(%rbp), %r15
movq %rax, (%r15)
movq %r15, %rsi
callq 0x7cdb
leaq -0x178(%rbp), %r12
leaq -0xd8(%rbp), %r13
pushq $0x1b
popq %rbx
movq -0x30(%rbp), %rax
cmpl $0x1b, (%rax)
jne 0x7cbf
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x7cdb
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x7114
movl $0xa0, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1100
jmp 0x7c81
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq %r14, %rax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_AND_expression
static struct UntypedExpr parse_AND_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;

	struct UntypedExpr expr = parse_equality_expression(&tokvec);

	while (1) {
		enum TokenKind kind = tokvec[0].kind;
		if (kind != OP_AND) {
			break;
		}
		++tokvec;

		struct UntypedExpr expr2 = parse_equality_expression(&tokvec);
		expr = binary_op_untyped(&expr, &expr2, kind);
	}
	*ptr_tokvec = tokvec;

	return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rdi, %r14
movq %rsi, -0x38(%rbp)
movq (%rsi), %rax
leaq -0x30(%rbp), %r15
movq %rax, (%r15)
movq %r15, %rsi
callq 0x7d73
leaq -0x178(%rbp), %r12
leaq -0xd8(%rbp), %r13
pushq $0x11
popq %rbx
movq -0x30(%rbp), %rax
cmpl $0x11, (%rax)
jne 0x7d57
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x7d73
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x7114
movl $0xa0, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1100
jmp 0x7d19
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq %r14, %rax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_equality_expression
static struct UntypedExpr
parse_equality_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;
	struct UntypedExpr expr = parse_relational_expression(&tokvec);

	while (1) {
		enum TokenKind kind = tokvec[0].kind;
		if (kind != OP_EQ_EQ && kind != OP_NOT_EQ) {
			break;
		}
		++tokvec;

		struct UntypedExpr expr2 = parse_relational_expression(&tokvec);
		expr = binary_op_untyped(&expr, &expr2, kind);
	}
	*ptr_tokvec = tokvec;
	return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rdi, %r14
movq %rsi, -0x38(%rbp)
movq (%rsi), %rax
leaq -0x30(%rbp), %r15
movq %rax, (%r15)
movq %r15, %rsi
callq 0x7e0d
leaq -0x178(%rbp), %r12
leaq -0xd8(%rbp), %r13
movq -0x30(%rbp), %rax
movl (%rax), %ebx
leal -0x15(%rbx), %ecx
cmpl $-0x2, %ecx
jb 0x7df1
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x7e0d
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x7114
movl $0xa0, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1100
jmp 0x7dae
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq %r14, %rax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq