LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x6181
movl $0x1, %eax
movl $0xff801, %edx          # imm = 0xFF801
btl %ecx, %edx
jb 0x6189
xorl %eax, %eax
cmpl $0x2b, %edi
sete %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x62d0
cmpl $0x4, %r15d
jg 0x62eb
testl %r15d, %r15d
je 0x6311
cmpl $0x1, %r15d
jne 0x634a
movl $0x3, %eax
jmp 0x6324
cmpl $0x31, %r15d
jg 0x62fe
xorl %eax, %eax
cmpl $0x15, %r15d
je 0x6324
cmpl $0x16, %r15d
jne 0x634a
movl $0x1, %eax
jmp 0x6324
cmpl $0x5, %r15d
je 0x6318
cmpl $0x11, %r15d
jne 0x634a
movl $0x6, %eax
jmp 0x6324
cmpl $0x32, %r15d
je 0x631f
cmpl $0x33, %r15d
jne 0x634a
movl $0x5, %eax
jmp 0x6324
movl $0x2, %eax
jmp 0x6324
movl $0x7, %eax
jmp 0x6324
movl $0x4, %eax
movl %eax, 0xa8(%rbx)
movq %r14, 0xb0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xb8(%rbx)
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_O3/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 0x5cf8
movq %rax, 0xe0(%rbx)
movq %rdx, 0xe8(%rbx)
movq %rbx, -0x30(%rbp)
movl $0x1b, 0xa0(%rbx)
cmpl $0x0, (%r14)
jle 0x671f
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 0x673b
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
movq %r13, %rsi
callq 0x1100
movq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x5d9b
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x66cf
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_O3/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 0x95bb
leaq -0x78(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x96ed
movl $0xa, %ecx
movq %r14, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x50(%r14), %r12
movq %rbx, %rdi
callq 0x1060
leal 0x1(%rax), %edx
leaq -0x78(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x972a
movl $0xa, %ecx
movq %r12, %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0x11, 0xa0(%r14)
movq %rbx, 0xd8(%r14)
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7d07
movl $0x81ffb23, %eax        # imm = 0x81FFB23
btl %r14d, %eax
jae 0x7d07
movl %r14d, %eax
leaq 0x795a(%rip), %rcx      # 0xf62c
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)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r14d, %edi
callq 0x1cb8
// File: /workspace/github_c_makefile_star2_O3/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 0x7d92
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 0x96bb
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x2ffc
movl %eax, 0xf4(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, -0x38(%rbp)
leaq -0x40(%rbp), %r15
movq %rax, (%r15)
leaq -0x180(%rbp), %rdi
movq %r15, %rsi
callq 0x8338
movq (%r15), %r15
movl (%r15), %edi
callq 0x6166
testl %eax, %eax
je 0x830e
movl (%r15), %edi
callq 0x6166
movl %eax, %edi
xorl %eax, %eax
callq 0x243c
movl (%r15), %eax
movl %eax, -0x2c(%rbp)
addq $0x20, %r15
leaq -0x38(%rbp), %r12
movq %r15, (%r12)
leaq -0xe0(%rbp), %rdi
movq %r12, %rsi
callq 0x8224
movq (%r12), %r15
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10d0
movq %rax, %r12
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10d0
movq %rax, %r13
leaq -0x180(%rbp), %rsi
movl $0xa0, %edx
movq %r12, %rdi
callq 0x1100
movl $0xa0, %edx
movq %r13, %rdi
leaq -0xe0(%rbp), %rsi
callq 0x1100
movl $0x0, 0x4(%rbx)
movl -0x2c(%rbp), %eax
movl %eax, (%rbx)
movq %r12, 0x8(%rbx)
movq %r13, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
jmp 0x8320
leaq -0x38(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x88ca
movq (%r15), %r15
movq %r15, (%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_O3/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, %rbx
movq %rsi, -0x38(%rbp)
movq (%rsi), %rax
leaq -0x30(%rbp), %r15
movq %rax, (%r15)
movq %r15, %rsi
callq 0x8224
movq (%r15), %rax
cmpl $0xa, (%rax)
jne 0x8ba0
leaq -0xd8(%rbp), %r15
leaq -0x30(%rbp), %r12
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x8224
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 %rbx, %rsi
callq 0x1100
movl $0xa0, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1100
movq $0xa, (%rbx)
movq %r13, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
movq -0x30(%rbp), %rax
cmpl $0xa, (%rax)
je 0x8b29
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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), %r14
movq %r14, -0x30(%rbp)
callq 0x5cf8
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
cmpl $0x7, (%r14)
jne 0x8bf6
addq $0x20, %r14
jmp 0x8cb9
leaq -0x180(%rbp), %r14
leaq -0x30(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x8224
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 0x5d9b
movq (%r15), %rax
cmpl $0xa, (%rax)
jne 0x8c96
leaq -0xe0(%rbp), %r14
leaq -0x40(%rbp), %r12
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x8224
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 0x5d9b
movq -0x30(%rbp), %rax
cmpl $0xa, (%rax)
je 0x8c4d
leaq 0x7484(%rip), %rdx      # 0x10121
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movl $0x7, %esi
callq 0x9563
movq (%r14), %r14
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdx
movq %r14, (%rbx)
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8da2
movq (%r15), %rax
cmpl $0x20, (%rax)
jne 0x8d89
leaq -0xd8(%rbp), %r15
leaq -0x30(%rbp), %r12
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x8da2
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 0x8d12
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_inclusive_OR_expression
static struct UntypedExpr
parse_inclusive_OR_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;

	struct UntypedExpr expr = parse_exclusive_OR_expression(&tokvec);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %r14
movq %rsi, -0x38(%rbp)
movq (%rsi), %rax
leaq -0x30(%rbp), %r15
movq %rax, (%r15)
movq %r15, %rsi
callq 0x8e76
movq (%r15), %rax
cmpl $0x12, (%rax)
jne 0x8e5d
leaq -0xd8(%rbp), %r15
leaq -0x30(%rbp), %r12
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x8e76
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 $0x12, (%r14)
movq %r13, 0x8(%r14)
movq %rbx, 0x10(%r14)
movq $0x0, 0x18(%r14)
movq -0x30(%rbp), %rax
cmpl $0x12, (%rax)
je 0x8de6
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_exclusive_OR_expression
static struct UntypedExpr
parse_exclusive_OR_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;

	struct UntypedExpr expr = parse_AND_expression(&tokvec);

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

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

	return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %r14
movq %rsi, -0x38(%rbp)
movq (%rsi), %rax
leaq -0x30(%rbp), %r15
movq %rax, (%r15)
movq %r15, %rsi
callq 0x8f4a
movq (%r15), %rax
cmpl $0x1b, (%rax)
jne 0x8f31
leaq -0xd8(%rbp), %r15
leaq -0x30(%rbp), %r12
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x8f4a
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 $0x1b, (%r14)
movq %r13, 0x8(%r14)
movq %rbx, 0x10(%r14)
movq $0x0, 0x18(%r14)
movq -0x30(%rbp), %rax
cmpl $0x1b, (%rax)
je 0x8eba
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_AND_expression
static struct UntypedExpr parse_AND_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;

	struct UntypedExpr expr = parse_equality_expression(&tokvec);

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

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

	return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %r14
movq %rsi, -0x38(%rbp)
movq (%rsi), %rax
leaq -0x30(%rbp), %r15
movq %rax, (%r15)
movq %r15, %rsi
callq 0x901e
movq (%r15), %rax
cmpl $0x11, (%rax)
jne 0x9005
leaq -0xd8(%rbp), %r15
leaq -0x30(%rbp), %r12
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x901e
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 $0x11, (%r14)
movq %r13, 0x8(%r14)
movq %rbx, 0x10(%r14)
movq $0x0, 0x18(%r14)
movq -0x30(%rbp), %rax
cmpl $0x11, (%rax)
je 0x8f8e
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/parse_expression.c
// Function: parse_equality_expression
static struct UntypedExpr
parse_equality_expression(const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;
	struct UntypedExpr expr = parse_relational_expression(&tokvec);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %r14
movq %rsi, -0x38(%rbp)
movq (%rsi), %rax
leaq -0x30(%rbp), %r15
movq %rax, (%r15)
movq %r15, %rsi
callq 0x9107
movq (%r15), %rax
movl (%rax), %r12d
leal -0x15(%r12), %ecx
cmpl $-0x2, %ecx
jb 0x90ee
leaq -0xd8(%rbp), %r15
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq %r15, %rdi
leaq -0x30(%rbp), %rsi
callq 0x9107
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
movl %r12d, (%r14)
movl $0x0, 0x4(%r14)
movq %r13, 0x8(%r14)
movq %rbx, 0x10(%r14)
movq $0x0, 0x18(%r14)
movq -0x30(%rbp), %rax
movl (%rax), %r12d
leal -0x15(%r12), %ecx
cmpl $-0x3, %ecx
ja 0x9066
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
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), %rsi
movq %rax, (%rsi)
callq 0x91e5
leaq -0xd8(%rbp), %r12
movq -0x30(%rbp), %rax
movl (%rax), %r15d
cmpl $0x10, %r15d
ja 0x91cc
movl $0x1b000, %ecx          # imm = 0x1B000
btl %r15d, %ecx
jae 0x91cc
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq %r12, %rdi
leaq -0x30(%rbp), %rsi
callq 0x91e5
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 %r12, %rsi
callq 0x1100
movl %r15d, (%r14)
movl $0x0, 0x4(%r14)
movq %r13, 0x8(%r14)
movq %rbx, 0x10(%r14)
movq $0x0, 0x18(%r14)
jmp 0x9138
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
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), %rsi
movq %rax, (%rsi)
callq 0x92ba
leaq -0xd8(%rbp), %r12
movq -0x30(%rbp), %rax
movl (%rax), %r15d
cmpl $0xe, %r15d
je 0x9229
cmpl $0xb, %r15d
jne 0x92a1
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq %r12, %rdi
leaq -0x30(%rbp), %rsi
callq 0x92ba
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 %r12, %rsi
callq 0x1100
movl %r15d, (%r14)
movl $0x0, 0x4(%r14)
movq %r13, 0x8(%r14)
movq %rbx, 0x10(%r14)
movq $0x0, 0x18(%r14)
jmp 0x9216
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
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 0x9397
movq (%r15), %rax
movl (%rax), %r12d
cmpl $0x1, %r12d
ja 0x937e
leaq -0xd8(%rbp), %r15
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq %r15, %rdi
leaq -0x30(%rbp), %rsi
callq 0x9397
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
movl %r12d, (%r14)
movl $0x0, 0x4(%r14)
movq %r13, 0x8(%r14)
movq %rbx, 0x10(%r14)
movq $0x0, 0x18(%r14)
movq -0x30(%rbp), %rax
movl (%rax), %r12d
cmpl $0x2, %r12d
jb 0x92fe
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
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), %rsi
movq %rax, (%rsi)
callq 0x8338
leaq -0xd8(%rbp), %r12
movq -0x30(%rbp), %rax
movl (%rax), %r15d
cmpl $0x9, %r15d
ja 0x945c
movl $0x320, %ecx            # imm = 0x320
btl %r15d, %ecx
jae 0x945c
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq %r12, %rdi
leaq -0x30(%rbp), %rsi
callq 0x8338
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 %r12, %rsi
callq 0x1100
movl %r15d, (%r14)
movl $0x0, 0x4(%r14)
movq %r13, 0x8(%r14)
movq %rbx, 0x10(%r14)
movq $0x0, 0x18(%r14)
jmp 0x93c8
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0xdb69(%rip), %r15      # 0x16ff8
movq (%r15), %rcx
leaq 0x6d0f(%rip), %rdi      # 0x101a8
movl $0x13, %esi
movl $0x1, %edx
callq 0x1180
movq %rbx, %rdi
callq 0xc346
movq (%r15), %rdi
leaq 0x6d02(%rip), %rsi      # 0x101bc
movq %r14, %rdx
xorl %eax, %eax
callq 0x10f0
movq (%r15), %rcx
leaq 0x6d06(%rip), %rdi      # 0x101d4
movl $0xd, %esi
movl $0x1, %edx
callq 0x1180
leaq 0x20(%rbx), %rdi
callq 0xc346
movq (%r15), %rcx
leaq 0x59d1(%rip), %r14      # 0xeec1
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rdi
callq 0x1180
movq (%r15), %rcx
leaq 0x6cd6(%rip), %rdi      # 0x101e2
movl $0x11, %esi
movl $0x1, %edx
callq 0x1180
addq $-0x20, %rbx
movq %rbx, %rdi
callq 0xc346
movq (%r15), %rcx
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rdi
callq 0x1180
movl $0x1, %edi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O3/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:
movq %rdi, %rax
movq (%rdi), %rdi
cmpl %esi, (%rdi)
jne 0x9575
addq $0x20, %rdi
movq %rdi, (%rax)
retq
pushq %rbp
movq %rsp, %rbp
movq %rdx, %rsi
callq 0x9478
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %r14
movq $0x0, -0x28(%rbp)
movl $0x1, %edi
movl $0x58, %esi
callq 0x10d0
movq %rax, %rbx
movq %r14, %rdi
callq 0x985f
movq %rax, %r15
callq 0x5d33
movq %rax, %r12
movq (%r14), %rax
movl (%rax), %eax
cmpl $0x7, %eax
je 0x97d8
cmpl $0xa, %eax
je 0x97d8
leaq -0x28(%rbp), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x9af6
movq %r12, %rdi
movq %r15, %rsi
callq 0x5d9b
movq 0x8(%r12), %rsi
leaq -0xc8(%rbp), %r14
movq %r14, %rdi
callq 0x9bfd
leaq -0x78(%rbp), %rax
movl $0xa, %ecx
movq %rax, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl (%rax), %eax
cmpl $0x2, %eax
je 0x982e
cmpl $0x3, %eax
jne 0x9835
leaq -0x78(%rbp), %rsi
movq %r14, %rdi
callq 0x96ed
movl $0xa, %ecx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x9841
movl $0x1, -0x78(%rbp)
leaq -0x78(%rbp), %rsi
movl $0xa, %ecx
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq -0x28(%rbp), %rax
movq %rax, 0x50(%rbx)
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movl (%rdi), %eax
xorl %r13d, %r13d
cmpl $0x5, %eax
jne 0x9b39
xorl %r13d, %r13d
movl 0x20(%rdi), %eax
addq $0x20, %rdi
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x44, %ecx
je 0x9b1d
incl %r13d
cmpl $0x5, %eax
je 0x9b1d
movq %rdi, (%r14)
movups (%rbx), %xmm0
movaps %xmm0, -0x40(%rbp)
cmpl $0x18, %eax
je 0x9b81
cmpl $0x6, %eax
jne 0x9bf1
addq $0x20, %rdi
leaq -0x30(%rbp), %r15
movq %rdi, (%r15)
leaq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x9af6
leaq 0x6aa0(%rip), %rdx      # 0x1060c
movq %r15, %rdi
movl $0x7, %esi
callq 0x9563
movq (%r15), %rax
movq %rax, (%r14)
jmp 0x9b90
movq 0x8(%rdi), %rax
movq %rax, (%rsi)
addq $0x20, %rdi
movq %rdi, -0x30(%rbp)
leaq -0x30(%rbp), %r15
leaq -0x40(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xa00e
movq (%r15), %rax
movq %rax, (%r14)
movaps (%r12), %xmm0
movups %xmm0, (%rbx)
testl %r13d, %r13d
jle 0x9be2
incl %r13d
movl $0x1, %edi
movl $0x50, %esi
callq 0x10d0
movl $0x1, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5d9b
decl %r13d
cmpl $0x1, %r13d
ja 0x9bb9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6a41(%rip), %rsi      # 0x10639
callq 0x9478
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/parse_type.c
// Function: from_type3_to_type
static struct Type from_type3_to_type(const void **type3)
{
	struct Type type;
	const struct TypeNode *ptr_elem = type3[0];
	struct TypeNode elem = *ptr_elem;
	type = elem;
	switch (elem.type_category) {
	case INT_:
	case CHAR_:
	case STRUCT_NOT_UNION:
	case UNION:
	case VOID_:
	case ENUM_:
		return type;

	case PTR_:
	case ARRAY:
	case FN: {
		struct Type *ptr_to_current_type = calloc(1, sizeof(struct Type));
		*ptr_to_current_type = from_type3_to_type(type3 + 1);

		type.derived_from = ptr_to_current_type;

		if (type.type_category == ARRAY &&
		    type.derived_from->type_category == FN) {
			fprintf(stderr, "It is illegal to declare an array of functions\n");
			exit(EXIT_FAILURE);
		} else if (type.type_category == FN &&
		           type.derived_from->type_category == FN) {
			fprintf(stderr,
			        "It is illegal for a function to return a function type\n");
			exit(EXIT_FAILURE);
		} else if (type.type_category == FN &&
		           type.derived_from->type_category == ARRAY) {
			fprintf(stderr,
			        "It is illegal for a function to return an array type\n");
			exit(EXIT_FAILURE);
		}
		return type;
	}
	}
	fprintf(stderr,
	        "****************************\n"
	        "* INTERNAL COMPILER ERROR @ %s\n"
	        "* Unexpected value of TypeCategory: `elem.type_category` is `%d`\n"
	        "****************************\n",
	        __func__, elem.type_category);
	exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rsi
movl (%rsi), %ebx
addq $0x4, %rsi
movl %ebx, (%rdi)
addq $0x4, %rdi
movl $0x13, %ecx
rep  movsl (%rsi), %es:(%rdi)
cmpl $0x8, %ebx
ja 0x9cad
movl $0x1f1, %eax            # imm = 0x1F1
btl %ebx, %eax
jae 0x9c48
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
movl $0x50, %esi
callq 0x10d0
movq %rax, %r12
addq $0x8, %r15
leaq -0x78(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x9bfd
movl $0xa, %ecx
movq %r12, %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r12, 0x8(%r14)
cmpl $0x3, %ebx
je 0x9c95
cmpl $0x2, %ebx
jne 0x9c39
cmpl $0x3, (%r12)
jne 0x9c39
callq 0x211f
movl (%r12), %eax
cmpl $0x2, %eax
je 0x9ca8
cmpl $0x3, %eax
jne 0x9c39
callq 0x20f7
callq 0x20cf
movl %ebx, %edi
callq 0x2147
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
leaq -0x18(%rbp), %r14
movq %rax, (%r14)
movq %r14, %rdi
callq 0x985f
movq (%r14), %rcx
cmpl $0x1a, (%rcx)
jne 0x9ce5
addq $0x20, %rcx
movq %rcx, (%rbx)
jmp 0x9ce7
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x985f
movq %rax, %r12
callq 0x5d33
movq %rax, %r13
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x9af6
movq %r13, %rdi
movq %r12, %rsi
callq 0x5d9b
movq 0x8(%r13), %rsi
movq %r15, %rdi
callq 0x9bfd
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
callq 0x9af6
movq (%rbx), %rax
cmpl $0x17, (%rax)
jne 0x9dae
addq $0x20, %rax
movq %rax, (%rbx)
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10d0
movq %rax, %r14
leaq -0xb8(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8224
movl $0xa0, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1100
jmp 0x9db1
xorl %r14d, %r14d
movq %r14, %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl (%rdi), %ecx
leal -0x35(%rcx), %edx
cmpl $0x11, %edx
jae 0x9ddf
movl $0x1, %eax
movl $0x1c229, %esi          # imm = 0x1C229
btl %edx, %esi
jb 0x9de7
xorl %eax, %eax
cmpl $0x4a, %ecx
sete %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, -0x30(%rbp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x985f
movq %rax, %r13
callq 0x5d33
movq %rax, %r14
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x9d51
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
movq %r14, %rdi
movq %r13, %rsi
callq 0x5d9b
leaq 0x664a(%rip), %rdx      # 0x10488
movq %r12, %rdi
movl $0x1a, %esi
callq 0x9563
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x9bfd
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_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x985f
movq %rax, %r15
callq 0x5d33
movq %rax, %r12
movq (%r14), %r13
movq %r13, -0x30(%rbp)
movl (%r13), %eax
cmpq $0x36, %rax
ja 0x9f25
movabsq $0x40000000000060, %rcx # imm = 0x40000000000060
btq %rax, %rcx
jae 0x9f25
leaq -0x30(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x9f52
movq (%r13), %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0x5d9b
movq %r13, (%r14)
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq 0x9bfd
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_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq %rax, -0x28(%rbp)
cmpl $0x5, (%rax)
jne 0x9f9f
xorl %r12d, %r12d
movl $0x5, %ecx
movl $0x1, %r15d
cmpl $0x5, %ecx
jne 0x9fad
movl 0x20(%rax), %ecx
addq $0x20, %rax
movl %ecx, %edx
andl $-0x2, %edx
cmpl $0x44, %edx
je 0x9f86
incl %r12d
incl %r15d
jmp 0x9f81
leaq -0x28(%rbp), %rdi
movq %r14, %rsi
callq 0xa2a6
jmp 0x9ffa
cmpl $0x6, %ecx
je 0x9fb7
cmpl $0x36, %ecx
jne 0x9fc8
leaq -0x28(%rbp), %rdi
movq %rax, (%rdi)
movq %r14, %rsi
callq 0xa2a6
jmp 0x9fcc
movq %rax, -0x28(%rbp)
testl %r12d, %r12d
je 0x9ffa
movl $0x1, %edi
movl $0x50, %esi
callq 0x10d0
movl $0x1, (%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x5d9b
decl %r15d
cmpl $0x1, %r15d
jg 0x9fd1
movq -0x28(%rbp), %rax
movq %rax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/parse_type.c
// Function: parse_direct_abstract_declarator
static void
parse_direct_abstract_declarator(const struct Token **ptr_tokvec,
                                 struct Vector /*<struct TypeNode>*/ *ptr_vec)
{
	const struct Token *tokvec = *ptr_tokvec;

	struct Vector vec = *ptr_vec;
	if (tokvec[0].kind == LEFT_PAREN && !can_start_a_type(&tokvec[1]) &&
	    tokvec[1].kind !=
	        RIGHT_PAREN) { /* an empty parenthesis must be of a function */
		++tokvec;
		parse_abstract_declarator(&tokvec, &vec);
		expect_and_consume(&tokvec, RIGHT_PAREN,
		                   "closing parenthesis inside direct declarator");
	}

	parse_dcl_postfixes(&tokvec, &vec);

	*ptr_tokvec = tokvec;
	*ptr_vec = vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq %rax, -0x28(%rbp)
movups (%rsi), %xmm0
movaps %xmm0, -0x40(%rbp)
cmpl $0x6, (%rax)
jne 0xa2e3
movl 0x20(%rax), %ecx
leal -0x35(%rcx), %edx
cmpl $0x15, %edx
ja 0xa311
movl $0x21c229, %esi         # imm = 0x21C229
btl %edx, %esi
jae 0xa311
leaq -0x28(%rbp), %r15
leaq -0x40(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xa00e
movq (%r15), %rax
movq %rax, (%r14)
movaps (%r12), %xmm0
movups %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x7, %ecx
je 0xa2e3
addq $0x20, %rax
leaq -0x28(%rbp), %r15
movq %rax, (%r15)
leaq -0x40(%rbp), %rsi
movq %r15, %rdi
callq 0x9f52
leaq 0x62d8(%rip), %rdx      # 0x1060c
movq %r15, %rdi
movl $0x7, %esi
callq 0x9563
jmp 0xa2e3
nop
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/map.c
// Function: lookup
void *lookup(const struct Map2 *m, const char *key)
{
	for (int i = (m->_length) - 1; i >= 0; --i) {
		if (strcmp(m->_vec[i].ptr, key) == 0) {
			return m->_vec[i].value;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %r12d
leal 0x1(%r12), %r13d
shlq $0x4, %r12
orq $0x8, %r12
decl %r13d
testl %r13d, %r13d
jle 0xa3e7
movq 0x8(%r14), %r15
movq -0x18(%r15,%r12), %rdi
addq $-0x10, %r12
movq %rbx, %rsi
callq 0x10e0
testl %eax, %eax
jne 0xa3c0
movq (%r15,%r12), %rax
jmp 0xa3e9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq