LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_conditional_expression
static struct UntypedExpr
parse_conditional_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;
	struct UntypedExpr expr = parse_logical_OR_expression(&tokvec);
	if (tokvec[0].kind == QUESTION) {

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

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

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

		*ptr_tokvec = tokvec;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x218(%rbp)
movq %rdi, -0x210(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0xb0(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xa8e0
movq -0x10(%rbp), %rax
cmpl $0x1c, (%rax)
jne 0x9fe2
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
leaq -0x150(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xa050
leaq -0x10(%rbp), %rdi
movl $0x1d, %esi
leaq 0xb44c(%rip), %rdx      # 0x15348
callq 0xb190
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
leaq -0x1f0(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x9e80
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10b0
movq %rax, -0x1f8(%rbp)
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10b0
movq %rax, -0x200(%rbp)
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10b0
movq %rax, -0x208(%rbp)
movq -0x1f8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
movq -0x200(%rbp), %rdi
leaq -0x150(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
movq -0x208(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
movq -0x218(%rbp), %rax
movl $0x2, 0x4(%rax)
movq -0x1f8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x200(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x208(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0xa005
movq -0x218(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
leaq -0xb0(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
movq -0x210(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x168(%rbp)
movq %rdi, %rax
movq %rax, -0x160(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x9b10
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0xa, -0x14(%rbp)
je 0xa095
jmp 0xa0e8
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x9b10
movq -0x168(%rbp), %rsi
movl -0x14(%rbp), %ecx
leaq -0x158(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
callq 0x9a70
movq -0x168(%rbp), %rdi
leaq -0x158(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
jmp 0xa084
movq -0x160(%rbp), %rax
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
movq %rdx, (%rcx)
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_expression.c
// Function: unary_op_untyped
static struct UntypedExpr unary_op_untyped(const struct UntypedExpr *ref_expr,
                                           enum TokenKind kind)
{
	struct UntypedExpr *ptr_expr1 = calloc(1, sizeof(struct UntypedExpr));
	*ptr_expr1 = *ref_expr;

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

	return new_expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movl $0x1, 0x4(%rdi)
movl -0xc(%rbp), %ecx
movl %ecx, (%rdi)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x61d0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x7, (%rax)
jne 0xa631
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
jmp 0xa707
leaq -0xc0(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9b10
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10b0
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
movq -0xc8(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x62c0
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xcc(%rbp)
cmpl $0xa, -0xcc(%rbp)
je 0xa696
jmp 0xa6f2
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
leaq -0x170(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9b10
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10b0
movq %rax, -0x178(%rbp)
movq -0x178(%rbp), %rdi
leaq -0x170(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
movq -0x178(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x62c0
jmp 0xa67f
leaq -0x20(%rbp), %rdi
movl $0x7, %esi
leaq 0xabe1(%rip), %rdx      # 0x152e3
callq 0xb190
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_primary_expression
static struct UntypedExpr
parse_primary_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;
	if (tokvec[0].kind == LIT_DEC_INTEGER) {
		++*ptr_tokvec;

		struct UntypedExpr expr;
		expr.int_value = tokvec[0].int_value;
		expr.category = INT_LITERAL_;

		return expr;

	} else if (tokvec[0].kind == IDENT_OR_RESERVED) {
		++*ptr_tokvec;

		struct UntypedExpr expr;
		expr.category = VAR;
		expr.var_name = tokvec[0].ident_str;
		return expr;

	} else if (tokvec[0].kind == LEFT_PAREN) {
		++tokvec;
		*ptr_tokvec = tokvec;
		struct UntypedExpr expr = parse_expression(&tokvec);
		expect_and_consume(&tokvec, RIGHT_PAREN, "right paren");

		*ptr_tokvec = tokvec;
		return expr;
	} else if (tokvec[0].kind == LIT_STRING) {
		struct UntypedExpr expr;
		expr.category = STRING_LITERAL_;
		expr.literal_string = tokvec[0].literal_str;

		++*ptr_tokvec;
		return expr;
	}

	error_unexpected_token(
	    tokvec, "the beginning of parse_typecheck_primary_expression");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
jne 0xa780
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdx
addq $0x20, %rdx
movq %rdx, (%rcx)
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x20(%rax)
movl $0x4, 0x4(%rax)
jmp 0xa848
movq -0x10(%rbp), %rax
cmpl $0x18, (%rax)
jne 0xa7b3
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdx
addq $0x20, %rdx
movq %rdx, (%rcx)
movl $0x3, 0x4(%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x28(%rax)
jmp 0xa848
movq -0x10(%rbp), %rax
cmpl $0x6, (%rax)
jne 0xa802
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
leaq -0x10(%rbp), %rsi
callq 0xa050
leaq -0x10(%rbp), %rdi
movl $0x7, %esi
leaq 0xab18(%rip), %rdx      # 0x15308
callq 0xb190
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xa848
movq -0x10(%rbp), %rax
cmpl $0x39, (%rax)
jne 0xa832
movq -0x20(%rbp), %rax
movl $0x8, 0x4(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x20, %rcx
movq %rcx, (%rax)
jmp 0xa848
jmp 0xa834
jmp 0xa836
jmp 0xa838
movq -0x10(%rbp), %rdi
leaq 0xaad1(%rip), %rsi      # 0x15314
callq 0xb070
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_expression.c
// Function: ampersand_dot
static struct UntypedExpr ampersand_dot(const struct UntypedExpr *ref_expr,
                                        const char *name)
{
	struct UntypedExpr *ptr_expr1 = calloc(1, sizeof(struct UntypedExpr));
	*ptr_expr1 = *ref_expr;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movl $0xb, 0x4(%rdi)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq -0x10(%rbp), %rcx
movq %rcx, 0x98(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_logical_OR_expression
static struct UntypedExpr
parse_logical_OR_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;

	struct UntypedExpr expr = parse_logical_AND_expression(&tokvec);

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

		++tokvec;
		struct UntypedExpr expr2 = parse_logical_AND_expression(&tokvec);

		expr = binary_op_untyped(&expr, &expr2, OP_OR_OR);
	}

	*ptr_tokvec = tokvec;
	return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x168(%rbp)
movq %rdi, %rax
movq %rax, -0x160(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0xa9a0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x21, -0x14(%rbp)
je 0xa925
jmp 0xa97a
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xa9a0
movq -0x168(%rbp), %rsi
leaq -0x158(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
movl $0x21, %ecx
callq 0x9a70
movq -0x168(%rbp), %rdi
leaq -0x158(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
jmp 0xa914
movq -0x160(%rbp), %rax
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
movq %rdx, (%rcx)
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x168(%rbp)
movq %rdi, %rax
movq %rax, -0x160(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0xaa60
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x20, -0x14(%rbp)
je 0xa9e5
jmp 0xaa3a
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xaa60
movq -0x168(%rbp), %rsi
leaq -0x158(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
movl $0x20, %ecx
callq 0x9a70
movq -0x168(%rbp), %rdi
leaq -0x158(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
jmp 0xa9d4
movq -0x160(%rbp), %rax
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
movq %rdx, (%rcx)
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_inclusive_OR_expression
static struct UntypedExpr
parse_inclusive_OR_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;

	struct UntypedExpr expr = parse_exclusive_OR_expression(&tokvec);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x168(%rbp)
movq %rdi, %rax
movq %rax, -0x160(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0xab20
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x12, -0x14(%rbp)
je 0xaaa5
jmp 0xaaf8
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xab20
movq -0x168(%rbp), %rsi
movl -0x14(%rbp), %ecx
leaq -0x158(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
callq 0x9a70
movq -0x168(%rbp), %rdi
leaq -0x158(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
jmp 0xaa94
movq -0x160(%rbp), %rax
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
movq %rdx, (%rcx)
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_exclusive_OR_expression
static struct UntypedExpr
parse_exclusive_OR_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;

	struct UntypedExpr expr = parse_AND_expression(&tokvec);

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

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

	return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x168(%rbp)
movq %rdi, %rax
movq %rax, -0x160(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0xabe0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x1b, -0x14(%rbp)
je 0xab65
jmp 0xabb8
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xabe0
movq -0x168(%rbp), %rsi
movl -0x14(%rbp), %ecx
leaq -0x158(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
callq 0x9a70
movq -0x168(%rbp), %rdi
leaq -0x158(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
jmp 0xab54
movq -0x160(%rbp), %rax
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
movq %rdx, (%rcx)
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_AND_expression
static struct UntypedExpr parse_AND_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;

	struct UntypedExpr expr = parse_equality_expression(&tokvec);

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

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

	return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x168(%rbp)
movq %rdi, %rax
movq %rax, -0x160(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0xaca0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x11, -0x14(%rbp)
je 0xac25
jmp 0xac78
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xaca0
movq -0x168(%rbp), %rsi
movl -0x14(%rbp), %ecx
leaq -0x158(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
callq 0x9a70
movq -0x168(%rbp), %rdi
leaq -0x158(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
jmp 0xac14
movq -0x160(%rbp), %rax
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
movq %rdx, (%rcx)
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_equality_expression
static struct UntypedExpr
parse_equality_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;
	struct UntypedExpr expr = parse_relational_expression(&tokvec);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x168(%rbp)
movq %rdi, %rax
movq %rax, -0x160(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0xad60
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x13, -0x14(%rbp)
je 0xaceb
cmpl $0x14, -0x14(%rbp)
je 0xaceb
jmp 0xad3e
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xad60
movq -0x168(%rbp), %rsi
movl -0x14(%rbp), %ecx
leaq -0x158(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
callq 0x9a70
movq -0x168(%rbp), %rdi
leaq -0x158(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
jmp 0xacd4
movq -0x160(%rbp), %rax
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
movq %rdx, (%rcx)
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_relational_expression
static struct UntypedExpr
parse_relational_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;

	struct UntypedExpr expr = parse_shift_expression(&tokvec);

	while (1) {
		enum TokenKind kind = tokvec[0].kind;
		if (kind != OP_GT && kind != OP_GT_EQ && kind != OP_LT &&
		    kind != OP_LT_EQ) {
			break;
		}
		++tokvec;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x168(%rbp)
movq %rdi, %rax
movq %rax, -0x160(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0xae30
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
je 0xadb7
cmpl $0xf, -0x14(%rbp)
je 0xadb7
cmpl $0xd, -0x14(%rbp)
je 0xadb7
cmpl $0xc, -0x14(%rbp)
je 0xadb7
jmp 0xae0a
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xae30
movq -0x168(%rbp), %rsi
movl -0x14(%rbp), %ecx
leaq -0x158(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
callq 0x9a70
movq -0x168(%rbp), %rdi
leaq -0x158(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
jmp 0xad94
movq -0x160(%rbp), %rax
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
movq %rdx, (%rcx)
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_shift_expression
static struct UntypedExpr
parse_shift_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;
	struct UntypedExpr expr = parse_additive_expression(&tokvec);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x168(%rbp)
movq %rdi, %rax
movq %rax, -0x160(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0xaef0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0xb, -0x14(%rbp)
je 0xae7b
cmpl $0xe, -0x14(%rbp)
je 0xae7b
jmp 0xaece
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xaef0
movq -0x168(%rbp), %rsi
movl -0x14(%rbp), %ecx
leaq -0x158(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
callq 0x9a70
movq -0x168(%rbp), %rdi
leaq -0x158(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
jmp 0xae64
movq -0x160(%rbp), %rax
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
movq %rdx, (%rcx)
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_additive_expression
static struct UntypedExpr
parse_additive_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;
	struct UntypedExpr expr = parse_multiplicative_expression(&tokvec);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x168(%rbp)
movq %rdi, %rax
movq %rax, -0x160(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0xafb0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xaf3b
cmpl $0x1, -0x14(%rbp)
je 0xaf3b
jmp 0xaf8e
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xafb0
movq -0x168(%rbp), %rsi
movl -0x14(%rbp), %ecx
leaq -0x158(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
callq 0x9a70
movq -0x168(%rbp), %rdi
leaq -0x158(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
jmp 0xaf24
movq -0x160(%rbp), %rax
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
movq %rdx, (%rcx)
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_multiplicative_expression
static struct UntypedExpr
parse_multiplicative_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;
	struct UntypedExpr expr = parse_cast_expression(&tokvec);

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

		struct UntypedExpr expr2 = parse_cast_expression(&tokvec);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x168(%rbp)
movq %rdi, %rax
movq %rax, -0x160(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0xa110
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x5, -0x14(%rbp)
je 0xb001
cmpl $0x8, -0x14(%rbp)
je 0xb001
cmpl $0x9, -0x14(%rbp)
je 0xb001
jmp 0xb054
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xa110
movq -0x168(%rbp), %rsi
movl -0x14(%rbp), %ecx
leaq -0x158(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
callq 0x9a70
movq -0x168(%rbp), %rdi
leaq -0x158(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
jmp 0xafe4
movq -0x160(%rbp), %rax
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
movq %rdx, (%rcx)
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/error.c
// Function: error_unexpected_token
_Noreturn void error_unexpected_token(const struct Token *tokvec,
                                      const char *str)
{
	fprintf(stderr, "Unexpected token: `");
	print_token_at(tokvec);
	fprintf(stderr, "` while expecting %s. \n", str);
	fprintf(stderr, "Next token: `");
	print_token_at(tokvec + 1);
	fprintf(stderr, "`\n");
	fprintf(stderr, "Previous token: `");
	print_token_at(tokvec - 1);
	/* it does not fail if tokvec[0] was the
	   first token, since there always is at least one token (BEGINNING) */
	fprintf(stderr, "`\n");
	exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x10f71(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0xa2d9(%rip), %rsi      # 0x1536a
movb $0x0, %al
callq 0x10d0
movq -0x8(%rbp), %rdi
callq 0xf5d0
movq 0x10f50(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0xa2c8(%rip), %rsi      # 0x1537e
movb $0x0, %al
callq 0x10d0
movq 0x10f34(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0xa2c8(%rip), %rsi      # 0x15396
movb $0x0, %al
callq 0x10d0
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0xf5d0
movq 0x10f0f(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0x8eae(%rip), %rsi      # 0x13fa1
movb $0x0, %al
callq 0x10d0
movq 0x10ef7(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0xa299(%rip), %rsi      # 0x153a4
movb $0x0, %al
callq 0x10d0
movq -0x8(%rbp), %rdi
addq $-0x20, %rdi
callq 0xf5d0
movq 0x10ed2(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0x8e71(%rip), %rsi      # 0x13fa1
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/error.c
// Function: expect_and_consume
void expect_and_consume(const struct Token **ptr_tokvec, enum TokenKind kind,
                        const char *str)
{
	const struct Token *tokvec = *ptr_tokvec;

	if (tokvec[0].kind != kind) {
		error_unexpected_token(tokvec, str);
	}
	++tokvec;
	*ptr_tokvec = tokvec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0xb1c6
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb070
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/type.c
// Function: size_of_basic
int size_of_basic(const struct Type *ref_type, const char *msg)
{
	switch (ref_type->type_category) {
	case INT_:
	case ENUM_:
		return 4;
	case PTR_:
		return 8;
	case CHAR_:
		return 1;
	case ARRAY:
	case FN:
	case STRUCT_NOT_UNION:
	case UNION:
		fprintf(
		    stderr,
		    "array, function, struct, or union type is not a basic type.\n");
		fprintf(stderr, "context: %s\n", msg);
		exit(EXIT_FAILURE);
	case VOID_:
		fprintf(stderr, "size of `void` is never known\n");
		fprintf(stderr, "context: %s\n", msg);
		exit(EXIT_FAILURE);
	}

	fprintf(stderr,
	        "****************************\n"
	        "* INTERNAL COMPILER ERROR @ %s\n"
	        "* Unexpected value of TypeCategory: `ref_type->type_category` is `%d`\n"
	        "****************************\n",
	        __func__, ref_type->type_category);
	exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x8, %rax
ja 0xb358
movq -0x20(%rbp), %rax
leaq 0xa119(%rip), %rcx      # 0x153c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4, -0x4(%rbp)
jmp 0xb387
movl $0x8, -0x4(%rbp)
jmp 0xb387
movl $0x1, -0x4(%rbp)
jmp 0xb387
movq 0x10d15(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0xa123(%rip), %rsi      # 0x15410
movb $0x0, %al
callq 0x10d0
movq 0x10cfd(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x961e(%rip), %rsi      # 0x14927
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
movq 0x10cd7(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0xa122(%rip), %rsi      # 0x1544d
movb $0x0, %al
callq 0x10d0
movq 0x10cbf(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x95e0(%rip), %rsi      # 0x14927
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
movq 0x10c99(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %ecx
leaq 0x83b7(%rip), %rsi      # 0x13726
leaq 0xa0f6(%rip), %rdx      # 0x1546c
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/type.c
// Function: deref_type
struct Type deref_type(const struct Type *ref_type)
{
	if (ref_type->type_category == PTR_) {
		return *ref_type->derived_from;
	}

	fprintf(stderr, "Unmatched type: expected a pointer, but got `");
	debug_print_type(ref_type);
	fprintf(stderr, "`.\n");
	exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0xb83d
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x50, %edx
callq 0x10e0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq 0x107b4(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0x9cd0(%rip), %rsi      # 0x1551e
movb $0x0, %al
callq 0x10d0
movq -0x8(%rbp), %rdi
callq 0xb390
movq 0x10793(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0xbff7(%rip), %rsi      # 0x17866
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/type.c
// Function: ptr_to_type
struct Type ptr_to_type(const struct Type *ref_type)
{
	struct Type *ptr_type = calloc(1, sizeof(struct Type));
	*ptr_type = *ref_type;
	struct Type type;
	type.type_category = PTR_;
	type.derived_from = ptr_type;
	return type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movl $0x1, %edi
movl $0x50, %esi
callq 0x10b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl $0x1, (%rdi)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/type.c
// Function: arr_of_type
struct Type arr_of_type(const struct Type *ref_type, int length)
{
	struct Type *ptr_type = calloc(1, sizeof(struct Type));
	*ptr_type = *ref_type;

	struct Type type;
	type.type_category = ARRAY;
	type.derived_from = ptr_type;
	type.array_length = length;
	return type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl $0x1, %edi
movl $0x50, %esi
callq 0x10b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movl $0x2, (%rdi)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rdi)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_type.c
// Function: parse_parameter_declaration
struct TypeAndIdent *
parse_parameter_declaration(const struct Token **ptr_tokvec)
{
	const char *ident_str = 0; /* null when abstract */
	struct TypeAndIdent *ptr_param_info =
	    calloc(1, sizeof(struct TypeAndIdent));

	struct Type type;
	{
		struct Type *ptr_base_type = parse_type_specifier(ptr_tokvec);
		struct Vector /*<struct TypeNode>*/ *ptr_vec = init_vector_();
		if ((*ptr_tokvec)[0].kind == OP_COMMA ||
		    (*ptr_tokvec)[0].kind == RIGHT_PAREN) {
			/* comma or right paren signifies the immediate end of
			 * parameter_declaration */
		} else {
			parse_declarator(ptr_tokvec, &ident_str, ptr_vec);
			if ((0)) {
				unsupported("abstract-declarator inside parameter declaration");
			}
		}
		push_vector(ptr_vec, ptr_base_type);
		type = from_type3_to_type(ptr_vec->vector);
	}

	if (type.type_category == FN) {
		/* shall be adjusted to `pointer to func`, according to the spec */
		ptr_param_info->type = ptr_to_type(&type);
	} else {
		/* convert to pointer */
		if (type.type_category == ARRAY) {
			type.type_category = PTR_;
		}
		ptr_param_info->type = type;
	}
	ptr_param_info->ident_str = ident_str;
	return ptr_param_info;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x1, %edi
movl $0x58, %esi
callq 0x10b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xba80
movq %rax, -0x70(%rbp)
callq 0x6200
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0xa, (%rax)
je 0xb9b8
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x7, (%rax)
jne 0xb9ba
jmp 0xb9cb
movq -0x8(%rbp), %rdi
movq -0x78(%rbp), %rdx
leaq -0x10(%rbp), %rsi
callq 0xbdf0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x62c0
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0xc8(%rbp), %rdi
callq 0xbe90
leaq -0x68(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
cmpl $0x3, -0x68(%rbp)
jne 0xba3c
movq -0x18(%rbp), %rax
movq %rax, -0x120(%rbp)
leaq -0x118(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xb8a0
movq -0x120(%rbp), %rdi
leaq -0x118(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
jmp 0xba5b
cmpl $0x2, -0x68(%rbp)
jne 0xba49
movl $0x1, -0x68(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_type.c
// Function: parse_declarator
static void parse_declarator(const struct Token **ptr_tokvec,
                             const char **ptr_to_ident_str,
                             struct Vector /*<struct TypeNode>*/ *ptr_vec)
{
	int asterisk_num = 0;
	for (; (*ptr_tokvec)[0].kind == OP_ASTERISK;
	     ++*ptr_tokvec, skip_consts_or_noreturns(ptr_tokvec)) {
		asterisk_num++;
	}

	parse_direct_declarator(ptr_tokvec, ptr_to_ident_str, ptr_vec);

	while (asterisk_num-- > 0) {
		struct TypeNode *ptr = calloc(1, sizeof(struct TypeNode));
		ptr->type_category = PTR_;
		push_vector(ptr_vec, ptr);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x5, (%rax)
jne 0xbe39
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x20, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0xc100
jmp 0xbe0b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xc570
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
jle 0xbe86
movl $0x1, %edi
movl $0x50, %esi
callq 0x10b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x62c0
jmp 0xbe4a
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_type.c
// Function: try_parse_type_specifier_and_semicolon
struct Type *
try_parse_type_specifier_and_semicolon(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec3 = *ptr_tokvec;
	struct Type *ptr_type = parse_type_specifier(&tokvec3);
	if (tokvec3[0].kind != SEMICOLON) {
		return 0;
	}
	++tokvec3;
	*ptr_tokvec = tokvec3;
	return ptr_type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xba80
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1a, (%rax)
je 0xc0d7
movq $0x0, -0x8(%rbp)
jmp 0xc0f6
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_type.c
// Function: skip_consts_or_noreturns
static void skip_consts_or_noreturns(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;
	while (tokvec[0].kind == RES_CONST || tokvec[0].kind == RES_NORETURN) {
		++tokvec;
	}
	*ptr_tokvec = tokvec;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpl $0x44, (%rcx)
movb %al, -0x11(%rbp)
je 0xc12e
movq -0x10(%rbp), %rax
cmpl $0x45, (%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xc137
jmp 0xc145
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
jmp 0xc113
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_type.c
// Function: parse_struct_declaration
struct Type parse_struct_declaration(const struct Token **ptr_tokvec,
                                     const char **ptr_to_ident_str)
{
	struct Type *ptr_base_type = parse_type_specifier(ptr_tokvec);
	struct Vector /*<struct TypeNode>*/ *ptr_vec = init_vector_();
	parse_declarator(ptr_tokvec, ptr_to_ident_str, ptr_vec);
	push_vector(ptr_vec, ptr_base_type);
	return from_type3_to_type(ptr_vec->vector);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xba80
movq %rax, -0x18(%rbp)
callq 0x6200
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xbdf0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x62c0
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xbe90
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_type.c
// Function: parse_init_declarator
struct UntypedExpr *
parse_init_declarator(const struct Token **ptr_tokvec,
                      const char **ptr_to_ident_str,
                      struct Vector /*<struct TypeNode>*/ *ptr_vec)
{
	struct UntypedExpr *ptr_expr = 0;
	parse_declarator(ptr_tokvec, ptr_to_ident_str, ptr_vec);
	if ((*ptr_tokvec)[0].kind == OP_EQ) {
		++*ptr_tokvec;
		ptr_expr = calloc(1, sizeof(struct UntypedExpr));
		*ptr_expr = parse_assignment_expression(ptr_tokvec);
	}
	return ptr_expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xbdf0
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x17, (%rax)
jne 0xc260
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x20, %rcx
movq %rcx, (%rax)
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
callq 0x9b10
movq -0xc8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
movq -0x20(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_type.c
// Function: can_start_a_type
int can_start_a_type(const struct Token *tokvec)
{
	return tokvec[0].kind == RES_INT || tokvec[0].kind == RES_CHAR ||
	       tokvec[0].kind == RES_STRUCT || tokvec[0].kind == RES_VOID ||
	       tokvec[0].kind == RES_ENUM || tokvec[0].kind == RES_CONST ||
	       tokvec[0].kind == RES_NORETURN || tokvec[0].kind == RES_UNION;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x35, (%rcx)
movb %al, -0x9(%rbp)
je 0xc2e7
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x38, (%rcx)
movb %al, -0x9(%rbp)
je 0xc2e7
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x3a, (%rcx)
movb %al, -0x9(%rbp)
je 0xc2e7
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x3e, (%rcx)
movb %al, -0x9(%rbp)
je 0xc2e7
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x43, (%rcx)
movb %al, -0x9(%rbp)
je 0xc2e7
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x44, (%rcx)
movb %al, -0x9(%rbp)
je 0xc2e7
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x45, (%rcx)
movb %al, -0x9(%rbp)
je 0xc2e7
movq -0x8(%rbp), %rax
cmpl $0x4a, (%rax)
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_type.c
// Function: parse_declaration
struct Type parse_declaration(const struct Token **ptr_tokvec,
                              const char **ptr_to_ident_str,
                              struct UntypedExpr **ptr_ptr_uexpr)
{
	struct Type *ptr_base_type = parse_type_specifier(ptr_tokvec);
	struct Vector /*<struct TypeNode>*/ *ptr_vec = init_vector_();
	struct UntypedExpr *ptr_uexpr = parse_init_declarator(
	    ptr_tokvec, ptr_to_ident_str, ptr_vec); /* nullable */
	*ptr_ptr_uexpr = ptr_uexpr;
	push_vector(ptr_vec, ptr_base_type);
	expect_and_consume(
	    ptr_tokvec, SEMICOLON,
	    "semicolon at the end of variable definition/declaration");
	return from_type3_to_type(ptr_vec->vector);
}

// 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)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xba80
movq %rax, -0x20(%rbp)
callq 0x6200
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xc1d0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x62c0
movq -0x8(%rbp), %rdi
movl $0x1a, %esi
leaq 0x92b1(%rip), %rdx      # 0x15620
callq 0xb190
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xbe90
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_type.c
// Function: parse_type_name
struct Type parse_type_name(const struct Token **ptr_tokvec)
{
	struct Type *ptr_base_type = parse_type_specifier(ptr_tokvec);
	struct Vector /*<struct TypeNode>*/ *ptr_vec = init_vector_();

	const struct Token *tokvec = *ptr_tokvec;

	/* optional */
	if (tokvec[0].kind == OP_ASTERISK || tokvec[0].kind == LEFT_PAREN ||
	    tokvec[0].kind == LEFT_BRACKET) {
		parse_abstract_declarator(&tokvec, ptr_vec);
	}
	push_vector(ptr_vec, ptr_base_type);

	*ptr_tokvec = tokvec;
	return from_type3_to_type(ptr_vec->vector);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xba80
movq %rax, -0x10(%rbp)
callq 0x6200
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x5, (%rax)
je 0xc450
movq -0x20(%rbp), %rax
cmpl $0x6, (%rax)
je 0xc450
movq -0x20(%rbp), %rax
cmpl $0x36, (%rax)
jne 0xc45d
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0xc490
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x62c0
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xbe90
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_type.c
// Function: parse_abstract_declarator
static void
parse_abstract_declarator(const struct Token **ptr_tokvec,
                          struct Vector /*<struct TypeNode>*/ *ptr_vec)
{
	const struct Token *tokvec = *ptr_tokvec;

	if (tokvec[0].kind != OP_ASTERISK) {
		parse_direct_abstract_declarator(&tokvec, ptr_vec);
		*ptr_tokvec = tokvec;
		return;
	}

	int asterisk_num = 0;
	for (; tokvec[0].kind == OP_ASTERISK;
	     ++tokvec, skip_consts_or_noreturns(&tokvec)) {
		asterisk_num++;
	}

	/* optional */
	if (tokvec[0].kind == LEFT_PAREN || tokvec[0].kind == LEFT_BRACKET) {
		parse_direct_abstract_declarator(&tokvec, ptr_vec);
	}

	while (asterisk_num-- > 0) {
		struct TypeNode *ptr = calloc(1, sizeof(struct TypeNode));
		ptr->type_category = PTR_;
		push_vector(ptr_vec, ptr);
	}

	*ptr_tokvec = tokvec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x5, (%rax)
je 0xc4d1
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xca90
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xc569
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x5, (%rax)
jne 0xc501
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xc100
jmp 0xc4d8
movq -0x18(%rbp), %rax
cmpl $0x6, (%rax)
je 0xc513
movq -0x18(%rbp), %rax
cmpl $0x36, (%rax)
jne 0xc520
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xca90
jmp 0xc522
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
jle 0xc55e
movl $0x1, %edi
movl $0x50, %esi
callq 0x10b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x62c0
jmp 0xc522
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop