LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/hsjoihs[P]c-compiler/alignment.c
// Function: get_size_alignment_offsets_for_struct_not_union
struct SizeAndAlignment get_size_alignment_offsets_for_struct_not_union(
    const struct SizeAndAlignment *inner_type_vec, int **ptr_offset_vec,
    int length)
{
	struct SizeAndAlignment res;
	res.alignment = 1;

	/* struct's alignment is the maximum of the members' alignments */
	for (int i = 0; i < length; i++) {
		if (inner_type_vec[i].alignment > res.alignment) {
			res.alignment = inner_type_vec[i].alignment;
		}
	}

	int offset = 0;
	int *offset_vec = calloc(length, sizeof(int));

	for (int i = 0; i < length; i++) {
		if (offset % inner_type_vec[i].alignment) {
			offset += inner_type_vec[i].alignment -
			          (offset % inner_type_vec[i].alignment);
		}
		offset_vec[i] = offset;
		offset += inner_type_vec[i].size;
	}

	if (offset % res.alignment) {
		offset += res.alignment - (offset % res.alignment);
	}

	res.size = offset;
	*ptr_offset_vec = offset_vec;
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r13d
movl $0x1, %r12d
testl %edx, %edx
jle 0x2f6f
xorl %eax, %eax
movl 0x4(%r14,%rax,8), %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
incq %rax
cmpq %rax, %r13
jne 0x2f5b
movslq %r15d, %rdi
movl $0x4, %esi
callq 0x10d0
movq %rax, %rcx
testl %r15d, %r15d
jle 0x2fb0
xorl %r8d, %r8d
xorl %edi, %edi
movl 0x4(%r14,%r8,8), %esi
movl %edi, %eax
cltd
idivl %esi
subl %edx, %esi
testl %edx, %edx
cmovel %edx, %esi
addl %edi, %esi
movl %esi, (%rcx,%r8,4)
addl (%r14,%r8,8), %esi
incq %r8
movl %esi, %edi
cmpq %r8, %r13
jne 0x2f89
jmp 0x2fb2
xorl %esi, %esi
movl %esi, %eax
cltd
idivl %r12d
movl %r12d, %eax
subl %edx, %eax
testl %edx, %edx
cmovel %edx, %eax
addl %esi, %eax
movq %rcx, (%rbx)
shlq $0x20, %r12
orq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/hsjoihs[P]c-compiler/parse_analyze_toplevel.c
// Function: push_offset_and_type
static int
push_offset_and_type(struct AnalyzerState *ptr_ps, const struct Type *ref_type,
                     struct Vector /*<LocalVarInfo>*/ *ptr_offsets_and_types,
                     const char *ident_str)
{

	int offset = add_local_var_to_scope(ptr_ps, ref_type, ident_str);

	struct LocalVarInfo info;
	info.offset = offset;
	info.type = *ref_type;

	struct LocalVarInfo *ptr1 = calloc(1, sizeof(struct LocalVarInfo));
	*ptr1 = info;
	push_vector(ptr_offsets_and_types, ptr1);

	return offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdx
callq 0x38f4
movl %eax, %r15d
movl $0x1, %edi
movl $0x58, %esi
callq 0x10d0
movl $0xa, %ecx
movq %rax, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl %r15d, 0x50(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5ba7
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/hsjoihs[P]c-compiler/parse_analyze_statement.c
// Function: add_local_var_to_scope
int add_local_var_to_scope(struct AnalyzerState *ptr_ps,
                           const struct Type *ref_vartype, const char *str)
{
	ptr_ps->newest_offset -= size_of(ptr_ps, ref_vartype);

	struct LocalVarInfo *ptr_varinfo = calloc(1, sizeof(struct LocalVarInfo));
	ptr_varinfo->offset = ptr_ps->newest_offset;
	ptr_varinfo->type = *ref_vartype;
	insert(ptr_ps->scope_chain.var_table, str, ptr_varinfo);

	return ptr_varinfo->offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2fe0
movl 0x70(%r15), %r13d
subl %eax, %r13d
movl %r13d, 0x70(%r15)
movl $0x1, %edi
movl $0x58, %esi
callq 0x10d0
movq %rax, %r12
movl %r13d, 0x50(%rax)
movl $0xa, %ecx
movq %rax, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq (%r15), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xa2d8
movl 0x50(%r12), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hsjoihs[P]c-compiler/parse_analyze_statement.c
// Function: parse_labeled_statement
struct Statement parse_labeled_statement(struct AnalyzerState *ptr_ps,
                                         const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;
	enum TokenKind kind = tokvec[0].kind;

	struct SourceLabel l;
	if (kind == RES_DEFAULT) {
		++tokvec;
		l.category = DEFAULT_LABEL;
	} else if (kind == RES_CASE) {
		++tokvec;
		const struct UntypedExpr u = parse_constant_expression(&tokvec);
		int case_int =
		    typecheck_constant_integral_expression(ptr_ps, &u, "case");
		l.category = CASE_LABEL;
		l.case_int = case_int;
	} else {
		l.ident_str = tokvec[0].ident_str;
		++tokvec;
		l.category = IDENT_LABEL;
	}
	expect_and_consume(&tokvec, COLON,
	                   "colon of `default:`, `case VALUE:`, or `ident:`");

	struct Statement s = parse_statement(ptr_ps, &tokvec);

	struct SourceLabel *ptr_l = calloc(1, sizeof(struct SourceLabel));
	*ptr_l = l;
	push_vector(&s.labels, ptr_l);
	*ptr_tokvec = tokvec;
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdx), %rax
movq %rax, -0x30(%rbp)
movl (%rax), %ecx
cmpl $0x40, %ecx
je 0x399e
cmpl $0x41, %ecx
jne 0x39d5
addq $0x20, %rax
movq %rax, -0x30(%rbp)
xorl %r12d, %r12d
jmp 0x39d3
addq $0x20, %rax
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
leaq -0xe0(%rbp), %r12
movq %r12, %rdi
callq 0x89d9
leaq 0xae8d(%rip), %rdx      # 0xe84c
movq %r15, %rdi
movq %r12, %rsi
callq 0x5c70
movl %eax, -0x34(%rbp)
movl $0x1, %r12d
jmp 0x39eb
movq 0x8(%rax), %rcx
movq %rcx, -0x40(%rbp)
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movl $0x2, %r12d
leaq 0xae5f(%rip), %rdx      # 0xe851
leaq -0x30(%rbp), %r13
movq %r13, %rdi
movl $0x1d, %esi
callq 0x94af
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x3a5f
movl $0x1, %edi
movl $0x10, %esi
callq 0x10d0
movl %r12d, (%rax)
movl -0x34(%rbp), %ecx
movl %ecx, 0x4(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq %r14, %rdi
addq $0x378, %rdi            # imm = 0x378
movq %rax, %rsi
callq 0x5ba7
movq (%r13), %rax
movq %rax, (%rbx)
movq %r14, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hsjoihs[P]c-compiler/parse_analyze_statement.c
// Function: declare_var_and_return_initializer
static struct Expr *declare_var_and_return_initializer(
    struct AnalyzerState *ptr_ps, const struct Type *ref_vartype,
    const char *str, const struct UntypedExpr *ptr_uexpr,
    struct Statement *ptr_statement)
{
	const struct Type vartype = *ref_vartype;
	add_local_var_to_scope(ptr_ps, ref_vartype, str);

	struct Statement s;
	s.category = DECLARATION_STATEMENT;
	s.declaration.type = vartype;
	s.declaration.ident_str = str;
	s.labels = init_vector();
	struct Statement *ptr_s = calloc(1, sizeof(struct Statement));
	*ptr_s = s;
	push_vector(&ptr_statement->statement_vector, ptr_s);

	struct Expr *ptr_expr = 0;
	if (ptr_uexpr) { /* initializer exists */
		struct UntypedExpr left_uexpr;
		left_uexpr.category = VAR;
		left_uexpr.var_name = str;

		struct UntypedExpr uexpr =
		    binary_op_untyped(&left_uexpr, ptr_uexpr, OP_EQ);
		struct Expr expr = typecheck_expression(ptr_ps, &uexpr);
		ptr_expr = calloc(1, sizeof(struct Expr));
		*ptr_expr = expr;
	}
	return ptr_expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x618, %rsp            # imm = 0x618
movq %r8, %r12
movq %rcx, -0x38(%rbp)
movq %rdx, %r15
movq %rsi, %rax
movq %rdi, %rdx
leaq -0x88(%rbp), %r13
movl $0xa, %ecx
movq %r13, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rdx, -0x30(%rbp)
movq %rdx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x38f4
leaq -0x318(%rbp), %rdi
movl $0x14, %ecx
movq %r13, %rsi
rep  movsl (%rsi), %es:(%rdi)
callq 0x5af4
movq %rax, %r13
movq %rdx, %rbx
movl $0x1, %edi
movl $0x390, %esi            # imm = 0x390
callq 0x10d0
movq %rax, %r14
movl $0xa, (%rax)
leaq 0x4(%rax), %rdi
leaq -0x634(%rbp), %rsi
movl $0x36c, %edx            # imm = 0x36C
callq 0x1100
movq %r15, 0x370(%r14)
movq %r13, 0x378(%r14)
movq %rbx, 0x380(%r14)
addq $0x8, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x5ba7
movq -0x38(%rbp), %rdx
testq %rdx, %rdx
je 0x4978
leaq -0x1c8(%rbp), %rsi
movl $0x3, 0x4(%rsi)
movq %r15, 0x28(%rsi)
leaq -0x128(%rbp), %rbx
movq %rbx, %rdi
movl $0x17, %ecx
callq 0x8088
leaq -0x2c8(%rbp), %r14
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movq %rbx, %rdx
callq 0x6573
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10d0
movq %rax, %rbx
movl $0x100, %edx            # imm = 0x100
movq %rax, %rdi
movq %r14, %rsi
callq 0x1100
jmp 0x497a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x618, %rsp            # imm = 0x618
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq (%rsi), %r15
testq %r15, %r15
jle 0x557b
movq %rdi, %r14
incq %r15
movq 0x8(%rbx), %rax
movq -0x10(%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x4cdb
decq %r15
cmpq $0x1, %r15
jg 0x5561
cmpl $0x0, (%rbx)
jle 0x55dc
xorl %r14d, %r14d
leaq 0x9e59(%rip), %r15      # 0xf3e3
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
movq %r15, %rsi
callq 0x9529
cmpl $0x1, %eax
je 0x55a9
cmpl $0x8, %eax
je 0x55bb
cmpl $0x4, %eax
jne 0x55e7
movl %r14d, %edi
callq 0xb7a2
movq %rax, %rdi
callq 0xb163
jmp 0x55cb
movl %r14d, %edi
callq 0xb6e6
movq %rax, %rdi
callq 0xb1a9
cmpq $0x4, %r14
ja 0x55dc
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x558a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9dd7(%rip), %rdi      # 0xf3c5
callq 0x94cd
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %eax
xorl %ebx, %ebx
testl %eax, %eax
cmovgl %eax, %ebx
jle 0x5651
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0x9dca(%rip), %r15      # 0xf3e3
movl $0x112, %r12d           # imm = 0x112
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rdi
movq %r15, %rsi
callq 0x9529
cmpl $0x8, %eax
ja 0x5662
btl %eax, %r12d
jae 0x5662
leaq 0x1(%r13), %rax
cmpq $0x4, %r13
ja 0x564f
movslq (%r14), %rcx
movq %rax, %r13
cmpq %rcx, %rax
jl 0x561f
subl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9d5c(%rip), %rdi      # 0xf3c5
callq 0x94cd
// File: /workspace/github_c_makefile_star2_O1/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 0x9516
movq %r15, %rdi
movq %rbx, %rsi
testl %eax, %eax
je 0x56a5
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x49b8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4cdb
// File: /workspace/github_c_makefile_star2_O1/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 0x996f(%rip), %rsi      # 0xf037
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
je 0x56f0
leaq 0x9983(%rip), %rsi      # 0xf05e
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
je 0x5705
leaq 0x9983(%rip), %rdi      # 0xf071
jmp 0x56f7
leaq 0x9951(%rip), %rdi      # 0xf048
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
movl $0x30, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0xb70c
// File: /workspace/github_c_makefile_star2_O1/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 0x96c8(%rip), %rdx      # 0xee12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x49b8
movl 0xa0(%r14), %eax
cmpl $0x19, %eax
ja 0x57ce
cmpl $0x7, %eax
je 0x5793
cmpl $0x8, %eax
jne 0x57b8
leaq -0x110(%rbp), %rbx
movq 0xd0(%rbx), %rsi
leaq 0x9b8a(%rip), %rdi      # 0xf30a
xorl %eax, %eax
callq 0x1070
leaq 0x9b95(%rip), %rsi      # 0xf323
movq %rbx, %rdi
jmp 0x57e7
leaq 0x9b5c(%rip), %rsi      # 0xf2f6
leaq -0x110(%rbp), %rbx
movq %rbx, %rdi
callq 0x9529
movl 0xf0(%rbx), %esi
movl %eax, %edi
callq 0xa82e
jmp 0x57f3
movl $0x3600000, %ecx        # imm = 0x3600000
btl %eax, %ecx
jae 0x57ce
leaq 0x9afb(%rip), %rdi      # 0xf2c4
callq 0x94cd
cmpl $0x6, %eax
jne 0x580b
cmpl $0x7, -0x68(%rbp)
jne 0x57ff
leaq 0x9b58(%rip), %rsi      # 0xf338
leaq -0x110(%rbp), %rdi
callq 0x9529
movl %eax, %edi
callq 0xaa00
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x96ab(%rip), %rdi      # 0xeeb1
callq 0x9492
leaq 0x959e(%rip), %rdi      # 0xedb0
callq 0x9492
// File: /workspace/github_c_makefile_star2_O1/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 0x11606(%rip), %rax     # 0x16fd8
movq (%rax), %r14
callq 0x5af4
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
cmpl $0x2, %r15d
jl 0x5aa4
movl %r15d, %r13d
movl $0x1, %r15d
movq (%rbx,%r15,8), %r12
movl $0x2, %edx
movq %r12, %rdi
leaq 0x99e4(%rip), %rsi      # 0xf3ec
callq 0x1030
testl %eax, %eax
je 0x5a58
movl $0x5, %edx
movq %r12, %rdi
leaq 0x99cf(%rip), %rsi      # 0xf3ef
callq 0x1030
testl %eax, %eax
je 0x5a6a
movq %r12, %rdi
leaq 0x99e3(%rip), %rsi      # 0xf416
callq 0x10e0
testl %eax, %eax
je 0x5a8e
movq %r12, %rdi
leaq 0xa8b8(%rip), %rsi      # 0x102fe
callq 0x1130
movq %rax, %r14
testq %rax, %rax
jne 0x5a98
jmp 0x5ae2
addq $0x2, %r12
leaq -0x38(%rbp), %rdi
movq %r12, %rsi
callq 0x5ba7
jmp 0x5a98
addq $0x5, %r12
movq %r12, %rdi
leaq 0x997d(%rip), %rsi      # 0xf3f5
callq 0x1130
leaq 0x1165c(%rip), %rcx     # 0x170e0
movq %rax, (%rcx)
testq %rax, %rax
jne 0x5a98
jmp 0x5aea
movl $0x1, 0x11644(%rip)     # 0x170dc
incq %r15
cmpq %r15, %r13
jne 0x59f5
movq %r14, %rdi
callq 0xd26c
leaq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0xbee4
leaq 0x20(%rax), %rdi
callq 0x3177
leaq -0x48(%rbp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0x29a8
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x159a
movq %r12, %rdi
callq 0x15c1
nop
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
movl $0x10, %esi
callq 0x10d0
movq %rax, %rbx
movabsq $0x10000000000, %rax    # imm = 0x10000000000
movq %rax, (%rbx)
movl $0x100, %edi            # imm = 0x100
movl $0x8, %esi
callq 0x10d0
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5ba6
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_O1/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
cmpl $0x0, (%rdi)
jne 0x5be6
xorl %edi, %edi
xorl %eax, %eax
callq 0x243c
movslq (%rbx), %rax
leaq -0x1(%rax), %rcx
movl %ecx, (%rbx)
movq 0x8(%rbx), %rcx
movq -0x8(%rcx,%rax,8), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
testq %rdi, %rdi
je 0x5c5e
movq %rsi, %rbx
testq %rsi, %rsi
je 0x5c63
cmpq $0x0, 0x8(%rbx)
je 0x5c68
cmpl $0x0, (%rbx)
jle 0x5c55
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %r12
movq %r14, %rdi
callq 0x5b7b
movq 0x8(%r14), %rax
movslq (%r14), %rcx
movq %r12, (%rax,%rcx,8)
leal 0x1(%rcx), %eax
movl %eax, (%r14)
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0x5c29
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1638
callq 0x1610
callq 0x15e8
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x5c8f
cmpl $0x4, %eax
jne 0x5cd4
movl 0x20(%rsi), %eax
jmp 0x5cc9
movq %rdi, %r14
movq 0x28(%rsi), %r15
movq %r15, %rsi
callq 0x5cdc
testl %eax, %eax
je 0x5ca6
movb $0x1, %cl
jmp 0x5cc5
addq $0x88, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x5d0f
testq %rax, %rax
sete %cl
je 0x5ca4
movl 0x8(%rax), %eax
xorl %ecx, %ecx
testb %cl, %cl
jne 0x5cd4
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x1660
// File: /workspace/github_c_makefile_star2_O1/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, -0x30(%rbp)
movslq (%rdi), %r15
testq %r15, %r15
jle 0x5d50
movq 0x8(%rdi), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rbx
movq (%rbx), %rdi
movq -0x30(%rbp), %rsi
callq 0x10e0
testl %eax, %eax
cmoveq %rbx, %r14
je 0x5d53
incq %r13
cmpq %r13, %r15
jne 0x5d30
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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), %ecx
cmpl $0x14, %ecx
jae 0x5fb6
movl $0x1, %eax
movl $0xff801, %edx          # imm = 0xFF801
btl %ecx, %edx
jb 0x5fbe
xorl %eax, %eax
cmpl $0x2b, %edi
sete %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x608e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
leaq -0x68(%rbp), %rax
movl $0xa, %ecx
movq %rax, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq -0x108(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x9639
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10d0
movq %rax, %r15
movl $0x100, %edx            # imm = 0x100
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1100
movl $0xa0, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1100
movl $0x6, %eax
movl %eax, 0xa0(%rbx)
movl %eax, 0xa8(%rbx)
movq %r15, 0xb0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xb8(%rbx)
addq $0xf8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10d0
movq %rax, %r14
movl $0x100, %edx            # imm = 0x100
movq %rax, %rdi
movq %r13, %rsi
callq 0x1100
movl $0xa, %ecx
movq %rbx, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0x6, 0xa0(%rbx)
cmpl $0x14, %r15d
jg 0x6105
cmpl $0x4, %r15d
jg 0x6120
testl %r15d, %r15d
je 0x6146
cmpl $0x1, %r15d
jne 0x6182
movl $0x3, %eax
jmp 0x6159
cmpl $0x31, %r15d
jg 0x6133
xorl %eax, %eax
cmpl $0x15, %r15d
je 0x6159
cmpl $0x16, %r15d
jne 0x6182
movl $0x1, %eax
jmp 0x6159
cmpl $0x5, %r15d
je 0x614d
cmpl $0x11, %r15d
jne 0x6182
movl $0x6, %eax
jmp 0x6159
cmpl $0x32, %r15d
je 0x6154
cmpl $0x33, %r15d
jne 0x6182
movl $0x5, %eax
jmp 0x6159
movl $0x2, %eax
jmp 0x6159
movl $0x7, %eax
jmp 0x6159
movl $0x4, %eax
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
movl %r15d, %edi
callq 0x17f0
// File: /workspace/github_c_makefile_star2_O1/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
callq 0x5af4
movq %rax, 0xe0(%rbx)
movq %rdx, 0xe8(%rbx)
movq %rbx, -0x30(%rbp)
movl $0x1b, 0xa0(%rbx)
cmpl $0x0, (%r14)
jle 0x6557
movq -0x30(%rbp), %rax
addq $0xe0, %rax
movq %rax, -0x38(%rbp)
xorl %r12d, %r12d
leaq -0x140(%rbp), %r13
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rbx
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10d0
movq %rax, %r15
movq %r13, %rdi
movq -0x40(%rbp), %rsi
movq %rbx, %rdx
callq 0x6573
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
movq %r13, %rsi
callq 0x1100
movq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x5ba7
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x6507
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_O1/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 0x9507
movq %r14, %rdi
movq %r15, %rsi
callq 0x9639
leaq 0x50(%r14), %r12
movq %rbx, %rdi
callq 0x1060
leal 0x1(%rax), %edx
leaq -0x78(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x9676
movl $0xa, %ecx
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_O1/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, %r14d
movq %rdx, -0x38(%rbp)
movq %rsi, %r15
movq %rdi, %rbx
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10d0
movq %rax, %r12
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10d0
movl $0x100, %edx            # imm = 0x100
movq %r12, -0x30(%rbp)
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %r15
callq 0x1100
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
movq -0x38(%rbp), %rsi
callq 0x1100
movl $0xa, %ecx
movq %rbx, %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x50(%rbx), %rdi
movl $0xa, %ecx
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0x0, 0xa0(%rbx)
cmpl $0x1c, %r14d
jae 0x7b4d
movl $0x81ffb23, %eax        # imm = 0x81FFB23
btl %r14d, %eax
jae 0x7b4d
movl %r14d, %eax
leaq 0x7b3f(%rip), %rcx      # 0xf654
movl (%rcx,%rax,4), %eax
movl %eax, 0xa4(%rbx)
movq -0x30(%rbp), %rax
movq %rax, 0xb0(%rbx)
movq %r15, 0xb8(%rbx)
movq $0x0, 0xc0(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r14d, %edi
callq 0x1c94
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10d0
movq %rax, %r13
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
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 0x7bd8
movl $0x1, 0x50(%rbx)
cmpl $0x1, -0x2c(%rbp)
movl $0x3, %eax
sbbl $0x0, %eax
movl %eax, 0xa0(%rbx)
movq %r13, 0xb0(%rbx)
movq %r14, 0xb8(%rbx)
movq $0x0, 0xc0(%rbx)
leaq -0x88(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x9607
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x2fe0
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_O1/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
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10d0
movq %rax, %r12
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
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
movl $0xa, %ecx
movq %rbx, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x50(%rbx), %rdi
movl $0xa, %ecx
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl -0x2c(%rbp), %eax
movl %eax, 0xa0(%rbx)
movq %r12, 0xb0(%rbx)
movq %r14, 0xb8(%rbx)
movq $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_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, -0x30(%rbp)
movq %rsi, %r12
movq %rdi, %rbx
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10d0
movq %rax, %r15
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10d0
movq %rax, %r13
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
movq %r12, %rsi
callq 0x1100
movl $0x100, %edx            # imm = 0x100
movq %r13, %rdi
movq -0x30(%rbp), %rsi
callq 0x1100
movl $0xa, %ecx
movq %rbx, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x50(%rbx), %rdi
movl $0xa, %ecx
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0x1, 0xa0(%rbx)
movq %r15, 0xb0(%rbx)
movq %r13, 0xb8(%rbx)
movq $0x0, 0xc0(%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_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%r15), %rdi
movq %r14, %rsi
callq 0xa389
testl %eax, %eax
jne 0x805e
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x803e
movq %r14, %rdi
callq 0x1cc1
movq (%r15), %rdi
movq %r14, %rsi
callq 0xa32d
movl $0xb, %ecx
movq %rbx, %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10d0
movq %rax, %r13
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10d0
movq %rax, %r14
movl $0xa0, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x1100
movl $0xa0, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1100
movl $0x0, 0x4(%rbx)
movl -0x2c(%rbp), %eax
movl %eax, (%rbx)
movq %r13, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq $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_O1/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 0x8229
movq (%r15), %r15
movl (%r15), %edi
callq 0x5f9b
testl %eax, %eax
je 0x81ff
leaq -0x30(%rbp), %r12
movq %r15, (%r12)
movl (%r15), %edi
callq 0x5f9b
movl %eax, %edi
xorl %eax, %eax
callq 0x243c
movl (%r15), %r13d
addq $0x20, %r15
movq %r15, (%r12)
leaq -0x178(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x8114
movq (%r12), %rax
movq %rax, (%r14)
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10d0
movq %rax, %r14
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10d0
movq %rax, %r12
leaq -0xd8(%rbp), %rsi
movl $0xa0, %edx
movq %r14, %rdi
callq 0x1100
movl $0xa0, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x1100
movl $0x0, 0x4(%rbx)
movl %r13d, (%rbx)
movq %r14, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
jmp 0x8214
leaq -0x30(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x87cc
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_O1/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 $0xb8, %rsp
movq %rdi, %r14
movq %rsi, -0x38(%rbp)
movq (%rsi), %rax
leaq -0x30(%rbp), %r15
movq %rax, (%r15)
movq %r15, %rsi
callq 0x8114
movq (%r15), %rax
cmpl $0xa, (%rax)
jne 0x8aac
leaq -0xd8(%rbp), %r15
leaq -0x30(%rbp), %r12
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x8114
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10d0
movq %rax, %r13
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10d0
movq %rax, %rbx
movl $0xa0, %edx
movq %r13, %rdi
movq %r14, %rsi
callq 0x1100
movl $0xa0, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1100
movq $0xa, (%r14)
movq %r13, 0x8(%r14)
movq %rbx, 0x10(%r14)
movq $0x0, 0x18(%r14)
movq -0x30(%rbp), %rax
cmpl $0xa, (%rax)
je 0x8a35
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq %r14, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x158, %rsp            # imm = 0x158
movq %rdi, %rbx
movq (%rdi), %rax
movq %rax, -0x30(%rbp)
callq 0x5af4
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x7, (%rax)
jne 0x8b0d
addq $0x20, %rax
movq %rax, -0x30(%rbp)
jmp 0x8bc2
leaq -0x180(%rbp), %r14
leaq -0x30(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x8114
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10d0
movq %rax, %r12
movl $0xa0, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1100
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0x5ba7
movq (%r15), %rax
cmpl $0xa, (%rax)
jne 0x8bad
leaq -0xe0(%rbp), %r14
leaq -0x40(%rbp), %r12
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x8114
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10d0
movq %rax, %r13
movl $0xa0, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1100
movq %r12, %rdi
movq %r13, %rsi
callq 0x5ba7
movq -0x30(%rbp), %rax
cmpl $0xa, (%rax)
je 0x8b64
leaq 0x759d(%rip), %rdx      # 0x10151
leaq -0x30(%rbp), %rdi
movl $0x7, %esi
callq 0x94af
movq -0x30(%rbp), %rax
movq %rax, (%rbx)
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdx
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0xb8, %rsp
movq %rdi, %r14
movq %rsi, -0x38(%rbp)
movq (%rsi), %rax
leaq -0x30(%rbp), %r15
movq %rax, (%r15)
movq %r15, %rsi
callq 0x8cbe
movq (%r15), %rax
cmpl $0x20, (%rax)
jne 0x8c9e
leaq -0xd8(%rbp), %r15
leaq -0x30(%rbp), %r12
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x8cbe
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10d0
movq %rax, %r13
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10d0
movq %rax, %rbx
movl $0xa0, %edx
movq %r13, %rdi
movq %r14, %rsi
callq 0x1100
movl $0xa0, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1100
movq $0x20, (%r14)
movq %r13, 0x8(%r14)
movq %rbx, 0x10(%r14)
movq $0x0, 0x18(%r14)
movq -0x30(%rbp), %rax
cmpl $0x20, (%rax)
je 0x8c27
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq %r14, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq