LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/codegen_expression.c
// Function: pass_args
static void pass_args(struct PrinterState *ptr_prs,
                      const struct Vector /*<Expr>*/ *ref_args)
{
	for (int counter = ref_args->length - 1; counter >= 0; counter--) {
		const struct Expr *ptr_expr_ = ref_args->vector[counter];

		print_expression(ptr_prs, ptr_expr_);
	}

	for (int counter = 0; counter < ref_args->length; counter++) {
		if (counter >= 6) {
			break;
		}
		const struct Expr *ptr_expr_ = ref_args->vector[counter];

		switch (size_of_basic(&ptr_expr_->details.type, "argument")) {
		case 1:
		case 4:
			gen_pop_to_reg_4byte(get_reg_name_from_arg_pos_4byte(counter));
			break;
		case 8:
			gen_pop_to_reg_8byte(get_reg_name_from_arg_pos_8byte(counter));
			break;
		default:
			unsupported("Unsupported width in function argument");
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x5a0e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4f90
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x59dc
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x5ab3
cmpl $0x6, -0x24(%rbp)
jl 0x5a2f
jmp 0x5ab3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0xea51(%rip), %rsi      # 0x1449f
callq 0xb280
movl %eax, %ecx
movl %ecx, -0x34(%rbp)
subl $0x1, %eax
je 0x5a73
jmp 0x5a5f
movl -0x34(%rbp), %eax
subl $0x4, %eax
je 0x5a73
jmp 0x5a69
movl -0x34(%rbp), %eax
subl $0x8, %eax
je 0x5a85
jmp 0x5a97
movl -0x24(%rbp), %edi
callq 0xe4c0
movq %rax, %rdi
callq 0xdd90
jmp 0x5aa3
movl -0x24(%rbp), %edi
callq 0xe390
movq %rax, %rdi
callq 0xdde0
jmp 0x5aa3
leaq 0xe9e3(%rip), %rdi      # 0x14481
callq 0xb1f0
jmp 0x5aa5
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5a15
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/codegen_expression.c
// Function: count_args
static int count_args(const struct Vector /*<Expr>*/ *ref_args)
{
	int ans = 0;
	for (int counter = ref_args->length - 1; counter >= 0; counter--) {
		ans++;
	}

	for (int counter = 0; counter < ref_args->length; counter++) {
		if (counter >= 6) {
			break;
		}
		const struct Expr *ptr_expr_ = ref_args->vector[counter];

		switch (size_of_basic(&ptr_expr_->details.type, "argument")) {
		case 1:
		case 4:
		case 8:
			ans--;
			break;
		default:
			unsupported("Unsupported width in function argument");
		}
	}
	return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0x5af9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5adf
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x5b7b
cmpl $0x6, -0x14(%rbp)
jl 0x5b13
jmp 0x5b7b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0xe96d(%rip), %rsi      # 0x1449f
callq 0xb280
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
subl $0x1, %eax
je 0x5b57
jmp 0x5b43
movl -0x24(%rbp), %eax
subl $0x4, %eax
je 0x5b57
jmp 0x5b4d
movl -0x24(%rbp), %eax
subl $0x8, %eax
jne 0x5b62
jmp 0x5b57
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5b6e
leaq 0xe918(%rip), %rdi      # 0x14481
callq 0xb1f0
jmp 0x5b70
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5b00
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb250
cmpl $0x0, %eax
je 0x5bc5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4bc0
jmp 0x5bd2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4f90
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xe4f8(%rip), %rsi      # 0x140f3
callq 0x10c0
cmpl $0x0, %eax
jne 0x5c19
movq -0x10(%rbp), %rsi
leaq 0xe4f4(%rip), %rdi      # 0x14104
movb $0x0, %al
callq 0x1080
jmp 0x5c6a
movq -0x10(%rbp), %rdi
leaq 0xe4f6(%rip), %rsi      # 0x1411a
callq 0x10c0
cmpl $0x0, %eax
jne 0x5c56
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x44(%rax), %edi
shll $0x3, %edi
movl -0x14(%rbp), %eax
addl $0x1, %eax
imull $0x30, %eax, %esi
movq -0x8(%rbp), %rax
movl 0x48(%rax), %edx
callq 0xe420
jmp 0x5c6a
jmp 0x5c58
movq -0x10(%rbp), %rsi
leaq 0xe4ca(%rip), %rdi      # 0x1412d
movb $0x0, %al
callq 0x1080
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x110(%rbp), %rdi
movq %rdi, -0x120(%rbp)
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0x120(%rbp), %rsi
movq -0x8(%rbp), %rdi
leaq 0xe1dd(%rip), %rdx      # 0x13ece
callq 0x4bc0
movl -0x70(%rbp), %eax
addl $-0x6, %eax
movl %eax, %ecx
movq %rcx, -0x118(%rbp)
subl $0x13, %eax
ja 0x5dac
movq -0x118(%rbp), %rax
leaq 0xe084(%rip), %rcx      # 0x13da0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xe654(%rip), %rdi      # 0x14380
callq 0xb1f0
leaq -0x110(%rbp), %rdi
leaq 0xe673(%rip), %rsi      # 0x143b2
callq 0xb280
movl %eax, %edi
movl -0x20(%rbp), %esi
callq 0xd260
jmp 0x5db8
movq -0x40(%rbp), %rsi
leaq 0xe66b(%rip), %rdi      # 0x143c6
movb $0x0, %al
callq 0x1080
leaq -0x110(%rbp), %rdi
leaq 0xe66f(%rip), %rsi      # 0x143df
callq 0xb280
movl %eax, %edi
callq 0xd480
jmp 0x5db8
cmpl $0x7, -0x68(%rbp)
jne 0x5da0
leaq -0x110(%rbp), %rdi
leaq 0xe662(%rip), %rsi      # 0x143f4
callq 0xb280
movl %eax, %edi
callq 0xd480
jmp 0x5db8
leaq 0xe1c6(%rip), %rdi      # 0x13f6d
callq 0xb150
leaq 0xe0b9(%rip), %rdi      # 0x13e6c
callq 0xb150
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl $0x1, %edi
movl $0x10, %esi
callq 0x10b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x100, 0x4(%rax)       # imm = 0x100
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rdi
movl $0x8, %esi
callq 0x10b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x62b4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
shll %eax
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x1100
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
shll %ecx
movl %ecx, 0x4(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x6349
xorl %eax, %eax
movb $0x1, %cl
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x6333
jmp 0x633a
xorl %eax, %eax
movb %al, -0x9(%rbp)
jmp 0x633a
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %edi
movb $0x0, %al
callq 0x1260
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x63a9
movq 0x15c6a(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0xe17c(%rip), %rsi      # 0x14514
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
cmpq $0x0, -0x10(%rbp)
jne 0x63d2
movq 0x15c41(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0xe177(%rip), %rsi      # 0x14538
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x63ff
movq 0x15c14(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0xe16f(%rip), %rsi      # 0x1455d
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x6435
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x62c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6406
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
movl $0xa0, %edx
callq 0x10e0
movl -0xbc(%rbp), %eax
movl %eax, -0xd4(%rbp)
subl $0x3, %eax
je 0x649a
jmp 0x647f
movl -0xd4(%rbp), %eax
subl $0x4, %eax
jne 0x64f8
jmp 0x648c
movl -0xa0(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6538
movq -0x98(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x6550
cmpl $0x0, %eax
je 0x64bf
jmp 0x64fa
movq -0x10(%rbp), %rdi
addq $0x88, %rdi
movq -0xc8(%rbp), %rsi
callq 0x65b0
movq %rax, -0xd0(%rbp)
cmpq $0x0, -0xd0(%rbp)
jne 0x64e9
jmp 0x64fa
movq -0xd0(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x6538
jmp 0x64fa
movq 0x15af7(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0xe399(%rip), %rsi      # 0x148a4
movb $0x0, %al
callq 0x10d0
movq 0x15adf(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0xe400(%rip), %rsi      # 0x14927
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/typecheck_expression.c
// Function: is_local_var
static int is_local_var(const struct ScopeChain *ref_t, const char *str)
{
	if (isElem(ref_t->var_table, str)) {
		return 1;
	} else if (ref_t->outer == 0) {
		/* most outer, but cannot be found */
		return 0;
	} else {
		return is_local_var(ref_t->outer, str);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xcc90
cmpl $0x0, %eax
je 0x657e
movl $0x1, -0x4(%rbp)
jmp 0x65a6
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x6592
movl $0x0, -0x4(%rbp)
jmp 0x65a6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x6550
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x6612
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x6605
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x661a
jmp 0x6607
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x65c7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x66f0
cmpl $0x0, %eax
jne 0x66e2
movq 0x1598f(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0xe262(%rip), %rsi      # 0x148d5
movb $0x0, %al
callq 0x10d0
movq -0x18(%rbp), %rdi
callq 0xb390
movq 0x1596e(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0xe3c0(%rip), %rsi      # 0x14a54
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rdi
callq 0xb390
movq 0x1594d(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0x111b1(%rip), %rsi     # 0x17866
movb $0x0, %al
callq 0x10d0
movq 0x15935(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0xe256(%rip), %rsi      # 0x14927
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x69d0
cmpl $0x0, %eax
jne 0x69c5
movq 0x15673(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0xdf61(%rip), %rsi      # 0x148f0
movb $0x0, %al
callq 0x10d0
movq -0x8(%rbp), %rdi
callq 0xb390
movq 0x15652(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0xdf70(%rip), %rsi      # 0x14924
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6aa0
cmpl $0x0, %eax
jne 0x6a8d
movq 0x155c3(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0xdef5(%rip), %rsi      # 0x14934
movb $0x0, %al
callq 0x10d0
movq -0x8(%rbp), %rdi
callq 0xb390
movq 0x155a2(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0x10e06(%rip), %rsi     # 0x17866
movb $0x0, %al
callq 0x10d0
movq 0x1558a(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0xdeab(%rip), %rsi      # 0x14927
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movl %edi, -0x4(%rbp)
movb $0x1, %al
cmpl $0x17, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x6b5f
movb $0x1, %al
cmpl $0x22, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x6b5f
movb $0x1, %al
cmpl $0x23, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x6b5f
movb $0x1, %al
cmpl $0x24, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x6b5f
movb $0x1, %al
cmpl $0x25, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x6b5f
movb $0x1, %al
cmpl $0x26, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x6b5f
movb $0x1, %al
cmpl $0x27, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x6b5f
movb $0x1, %al
cmpl $0x28, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x6b5f
movb $0x1, %al
cmpl $0x29, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x6b5f
movb $0x1, %al
cmpl $0x2a, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x6b5f
cmpl $0x2b, -0x4(%rbp)
sete %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x6c2b
movq -0x8(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movl $0x50, %edx
callq 0x10e0
leaq -0xa8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xb8a0
movq -0x8(%rbp), %rsi
leaq -0x1a8(%rbp), %rdi
movl $0x11, %edx
leaq -0xa8(%rbp), %rcx
callq 0x6c40
movq -0x8(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
movq -0x30(%rbp), %rdi
movl $0x6, 0xa0(%rdi)
movl -0xc(%rbp), %edi
callq 0x9800
movq -0x30(%rbp), %rdi
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xa8(%rdi)
movq -0x20(%rbp), %rcx
movq %rcx, 0xb0(%rdi)
movq $0x0, 0xb8(%rdi)
movq $0x0, 0xc0(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x190(%rbp)
movq %rdi, -0x198(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl $0x7, -0x60(%rbp)
callq 0x61d0
movq -0x190(%rbp), %rdi
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq -0x70(%rbp), %rax
movq %rax, 0xe0(%rdi)
movq -0x68(%rbp), %rax
movq %rax, 0xe8(%rdi)
movl $0x1b, 0xa0(%rdi)
movl $0x0, -0x74(%rbp)
movl -0x74(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x70fe
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x74(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x80(%rbp)
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10b0
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x1a0(%rbp)
movq -0x8(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x188(%rbp), %rdi
callq 0x7130
movq -0x1a0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0x190(%rbp), %rdi
addq $0xe0, %rdi
movq -0x88(%rbp), %rsi
callq 0x62c0
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x7063
movq -0x190(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
movq -0x198(%rbp), %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x108(%rbp)
movq %rdi, -0x100(%rbp)
movq %rsi, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xb240
leaq -0xa8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xb8a0
movq -0x108(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
movq -0x108(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x110(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
addq $0x1, %rax
movl %eax, %edx
leaq -0xf8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xb900
movq -0x110(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
movq -0x108(%rbp), %rdi
movq -0x100(%rbp), %rax
movl $0x11, 0xa0(%rdi)
movq -0x8(%rbp), %rcx
movq %rcx, 0xd8(%rdi)
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/typecheck_expression.c
// Function: op_before_assign
static enum SimpleBinOp op_before_assign(enum TokenKind token_kind)
{
	switch (token_kind) {
	case OP_PLUS_EQ:
		return SIMPLE_BIN_OP_PLUS;
	case OP_MINUS_EQ:
		return SIMPLE_BIN_OP_MINUS;
	case OP_ASTERISK_EQ:
		return SIMPLE_BIN_OP_ASTERISK;
	case OP_SLASH_EQ:
		return SIMPLE_BIN_OP_SLASH;
	case OP_PERCENT_EQ:
		return SIMPLE_BIN_OP_PERCENT;
	case OP_LSHIFT_EQ:
		return SIMPLE_BIN_OP_LSHIFT;
	case OP_RSHIFT_EQ:
		return SIMPLE_BIN_OP_RSHIFT;
	case OP_AND_EQ:
		return SIMPLE_BIN_OP_AND;
	case OP_HAT_EQ:
		return SIMPLE_BIN_OP_HAT;
	case OP_OR_EQ:
		return SIMPLE_BIN_OP_OR;
	default:
		fprintf(stderr,
		        "****************************\n"
		        "* INTERNAL COMPILER ERROR @ %s\n"
		        "* Unexpected value of TokenKind: a compound assignment "
		        "operator is needed, but `token_kind` is `%d`\n"
		        "****************************\n",
		        __func__, token_kind);
		exit(EXIT_FAILURE);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x22, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x9, %eax
ja 0x909a
movq -0x10(%rbp), %rax
leaq 0xb705(%rip), %rcx      # 0x1473c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x90c6
movl $0x1, -0x4(%rbp)
jmp 0x90c6
movl $0x2, -0x4(%rbp)
jmp 0x90c6
movl $0x3, -0x4(%rbp)
jmp 0x90c6
movl $0x4, -0x4(%rbp)
jmp 0x90c6
movl $0x7, -0x4(%rbp)
jmp 0x90c6
movl $0xa, -0x4(%rbp)
jmp 0x90c6
movl $0xb, -0x4(%rbp)
jmp 0x90c6
movl $0xf, -0x4(%rbp)
jmp 0x90c6
movl $0xc, -0x4(%rbp)
jmp 0x90c6
movq 0x12f57(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movl -0x8(%rbp), %ecx
leaq 0xbfd5(%rip), %rsi      # 0x15083
leaq 0xc08c(%rip), %rdx      # 0x15141
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10b0
movq %rax, -0x28(%rbp)
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10b0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
movq -0x20(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
movq -0x40(%rbp), %rdi
movl $0x0, 0xa0(%rdi)
movl -0x14(%rbp), %edi
callq 0x9960
movq -0x40(%rbp), %rdi
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0xa4(%rdi)
movq -0x28(%rbp), %rcx
movq %rcx, 0xb0(%rdi)
movq -0x30(%rbp), %rcx
movq %rcx, 0xb8(%rdi)
movq $0x0, 0xc0(%rdi)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, -0x90(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10b0
movq %rax, -0x28(%rbp)
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10b0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0x88(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
movq -0x88(%rbp), %rdi
cmpl $0x2, 0x50(%rdi)
jne 0x9253
movq -0x88(%rbp), %rax
movl $0x1, 0x50(%rax)
movq -0x88(%rbp), %rax
movl -0x1c(%rbp), %esi
movl $0x3, %ecx
movl $0x2, %edx
cmpl $0x0, %esi
cmovel %edx, %ecx
movl %ecx, 0xa0(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0xb0(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0xb8(%rax)
movq $0x0, 0xc0(%rax)
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0xb800
movq -0x8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x2570
movq -0x88(%rbp), %rcx
movl %eax, %edx
movq -0x90(%rbp), %rax
movl %edx, 0xf4(%rcx)
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10b0
movq %rax, -0x28(%rbp)
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10b0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
movq -0x20(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0xa0(%rdi)
movq -0x28(%rbp), %rcx
movq %rcx, 0xb0(%rdi)
movq -0x30(%rbp), %rcx
movq %rcx, 0xb8(%rdi)
movq $0x0, 0xc0(%rdi)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/typecheck_expression.c
// Function: comma_op
static struct Expr comma_op(const struct Expr *ref_expr,
                            const struct Expr *ref_expr2,
                            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 = COMMA_EXPR;
	new_expr.ptr1 = ptr_expr1;
	new_expr.ptr2 = ptr_expr2;
	new_expr.ptr3 = 0;

	return new_expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10b0
movq %rax, -0x20(%rbp)
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10b0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
movq -0x38(%rbp), %rdi
addq $0x50, %rdi
movq -0x18(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movl $0x1, 0xa0(%rdi)
movq -0x20(%rbp), %rcx
movq %rcx, 0xb0(%rdi)
movq -0x28(%rbp), %rcx
movq %rcx, 0xb8(%rdi)
movq $0x0, 0xc0(%rdi)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/typecheck_expression.c
// Function: to_unaryop
static enum UnaryOp to_unaryop(enum TokenKind token_kind)
{
	switch (token_kind) {
	case OP_NOT:
		return UNARY_OP_NOT;
	case OP_TILDA:
		return UNARY_OP_TILDA;
	case OP_PLUS:
		return UNARY_OP_PLUS;
	case OP_MINUS:
		return UNARY_OP_MINUS;

	case OP_PLUS_PLUS:
		return UNARY_OP_PLUS_PLUS;
	case OP_MINUS_MINUS:
		return UNARY_OP_MINUS_MINUS;

	case OP_AND:
		return UNARY_OP_AND;

	case OP_ASTERISK:
		return UNARY_OP_ASTERISK;

	default:
		fprintf(stderr,
		        "****************************\n"
		        "* INTERNAL COMPILER ERROR @ %s\n"
		        "* Unexpected value of TokenKind: a unary operator is needed, "
		        "but `token_kind` is `%d`\n"
		        "****************************\n",
		        __func__, token_kind);
		exit(EXIT_FAILURE);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x33, %rax
ja 0x9874
movq -0x10(%rbp), %rax
leaq 0xaf41(%rip), %rcx      # 0x14764
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x98a0
movl $0x1, -0x4(%rbp)
jmp 0x98a0
movl $0x2, -0x4(%rbp)
jmp 0x98a0
movl $0x3, -0x4(%rbp)
jmp 0x98a0
movl $0x4, -0x4(%rbp)
jmp 0x98a0
movl $0x5, -0x4(%rbp)
jmp 0x98a0
movl $0x6, -0x4(%rbp)
jmp 0x98a0
movl $0x7, -0x4(%rbp)
jmp 0x98a0
movq 0x1277d(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movl -0x8(%rbp), %ecx
leaq 0xb71b(%rip), %rsi      # 0x14fa3
leaq 0xb7c4(%rip), %rdx      # 0x15053
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/typecheck_expression.c
// Function: resolve_name_locally
static struct LocalVarInfo resolve_name_locally(const struct ScopeChain *ref_t,
                                                const char *str)
{
	if (isElem(ref_t->var_table, str)) {
		struct LocalVarInfo *ptr_varinfo = lookup(ref_t->var_table, str);
		return *ptr_varinfo;
	} else if (ref_t->outer == 0) {
		/* most outer, but cannot be found */
		fprintf(stderr, "%s is not declared locally\n", str);
		exit(EXIT_FAILURE);
	} else {
		return resolve_name_locally(ref_t->outer, str);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xcc90
cmpl $0x0, %eax
je 0x9905
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xcc00
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movl $0x58, %edx
callq 0x10e0
jmp 0x994b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x9936
movq 0x126e1(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0xb742(%rip), %rsi      # 0x15067
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x98b0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/typecheck_expression.c
// Function: to_simplebinop
static enum SimpleBinOp to_simplebinop(enum TokenKind token_kind)
{
	switch (token_kind) {
	case OP_PLUS:
		return SIMPLE_BIN_OP_PLUS;
	case OP_MINUS:
		return SIMPLE_BIN_OP_MINUS;
	case OP_ASTERISK:
		return SIMPLE_BIN_OP_ASTERISK;
	case OP_SLASH:
		return SIMPLE_BIN_OP_SLASH;
	case OP_PERCENT:
		return SIMPLE_BIN_OP_PERCENT;
	case OP_LT:
		return SIMPLE_BIN_OP_LT;
	case OP_LT_EQ:
		return SIMPLE_BIN_OP_LT_EQ;
	case OP_LSHIFT:
		return SIMPLE_BIN_OP_LSHIFT;
	case OP_GT:
		return SIMPLE_BIN_OP_GT;
	case OP_GT_EQ:
		return SIMPLE_BIN_OP_GT_EQ;
	case OP_RSHIFT:
		return SIMPLE_BIN_OP_RSHIFT;
	case OP_AND:
		return SIMPLE_BIN_OP_AND;
	case OP_OR:
		return SIMPLE_BIN_OP_OR;
	case OP_EQ_EQ:
		return SIMPLE_BIN_OP_EQ_EQ;
	case OP_NOT_EQ:
		return SIMPLE_BIN_OP_NOT_EQ;
	case OP_HAT:
		return SIMPLE_BIN_OP_HAT;
	default:
		fprintf(stderr,
		        "****************************\n"
		        "* INTERNAL COMPILER ERROR @ %s\n"
		        "* Unexpected value of TokenKind: a binary operator is needed, "
		        "but `token_kind` is `%d`\n"
		        "****************************\n",
		        __func__, token_kind);
		exit(EXIT_FAILURE);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x1b, %rax
ja 0x9a32
movq -0x10(%rbp), %rax
leaq 0xaead(%rip), %rcx      # 0x14834
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x9a5e
movl $0x1, -0x4(%rbp)
jmp 0x9a5e
movl $0x2, -0x4(%rbp)
jmp 0x9a5e
movl $0x3, -0x4(%rbp)
jmp 0x9a5e
movl $0x4, -0x4(%rbp)
jmp 0x9a5e
movl $0x5, -0x4(%rbp)
jmp 0x9a5e
movl $0x6, -0x4(%rbp)
jmp 0x9a5e
movl $0x7, -0x4(%rbp)
jmp 0x9a5e
movl $0x8, -0x4(%rbp)
jmp 0x9a5e
movl $0x9, -0x4(%rbp)
jmp 0x9a5e
movl $0xa, -0x4(%rbp)
jmp 0x9a5e
movl $0xb, -0x4(%rbp)
jmp 0x9a5e
movl $0xc, -0x4(%rbp)
jmp 0x9a5e
movl $0xd, -0x4(%rbp)
jmp 0x9a5e
movl $0xe, -0x4(%rbp)
jmp 0x9a5e
movl $0xf, -0x4(%rbp)
jmp 0x9a5e
movq 0x125bf(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movl -0x8(%rbp), %ecx
leaq 0xb70c(%rip), %rsi      # 0x15152
leaq 0xb7b6(%rip), %rdx      # 0x15203
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10b0
movq %rax, -0x20(%rbp)
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10b0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movl $0x0, 0x4(%rdi)
movl -0x14(%rbp), %ecx
movl %ecx, (%rdi)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rdi)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x170(%rbp)
movq %rdi, -0x168(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x9c00
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x6ae0
cmpl $0x0, %eax
jne 0x9b7d
movq -0x170(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x9e80
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x9bec
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x6ae0
movl %eax, %edi
movb $0x0, %al
callq 0x1260
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xbc(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
leaq -0x160(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x9b10
movq -0x170(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0xbc(%rbp), %ecx
leaq -0xb8(%rbp), %rsi
leaq -0x160(%rbp), %rdx
callq 0x9a70
movq -0x168(%rbp), %rax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopl (%rax)