LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_addss_x_x
static void _asm_inst_addss_x_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	const char *target,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);

	const char *mnemonic = "addss";

	_asm_inst2(
		ctx,
		rstr,
		mnemonic,
		source,
		target
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1cd1d
movq %rsi, %rcx
testq %rsi, %rsi
je 0x1cd3c
leaq 0x212bf(%rip), %rsi     # 0x3dfc6
leaq 0x229b1(%rip), %rdx     # 0x3f6bf
leaq 0x2228d(%rip), %r8      # 0x3efa2
xorl %eax, %eax
popq %rbp
jmp 0x739a
leaq 0x1ed0c(%rip), %rdi     # 0x3ba30
leaq 0x2496d(%rip), %rsi     # 0x41698
leaq 0x25ff3(%rip), %rcx     # 0x42d25
movl $0x5fe, %edx            # imm = 0x5FE
callq 0x30a0
leaq 0x25df7(%rip), %rdi     # 0x42b3a
leaq 0x2494e(%rip), %rsi     # 0x41698
leaq 0x25fd4(%rip), %rcx     # 0x42d25
movl $0x600, %edx            # imm = 0x600
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_call_x
static void _asm_inst_call_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	const char *func
) {
	assert(ctx);
	assert(rstr);
	assert(func);

	const char *mnemonic = "callq";

	_asm_inst1(
		ctx,
		rstr,
		mnemonic,
		func
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1d46c
movq %rsi, %rcx
testq %rsi, %rsi
je 0x1d48b
leaq 0x2124d(%rip), %rsi     # 0x3e6aa
leaq 0x25eee(%rip), %rdx     # 0x43352
xorl %eax, %eax
popq %rbp
jmp 0x739a
leaq 0x1e5bd(%rip), %rdi     # 0x3ba30
leaq 0x2421e(%rip), %rsi     # 0x41698
leaq 0x25e7e(%rip), %rcx     # 0x432ff
movl $0x631, %edx            # imm = 0x631
callq 0x30a0
leaq 0x228d4(%rip), %rdi     # 0x3fd66
leaq 0x241ff(%rip), %rsi     # 0x41698
leaq 0x25e5f(%rip), %rcx     # 0x432ff
movl $0x632, %edx            # imm = 0x632
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_imul_x_x_x
static void _asm_inst_imul_x_x_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	uint8_t type,
	const char *target,
	const char *source1,
	const char *source2
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source1);
	assert(source2);

	ResizableString rstr_mnemonic;
	rstr_init_with_cstr(&rstr_mnemonic, "imul");
	rstr_append_with_char(
		&rstr_mnemonic,
		_asm_inst_type_suffix(ctx, type)
	);

	_asm_inst3(
		ctx,
		rstr,
		RSTR_CSTR(&rstr_mnemonic),
		source2,
		source1,
		target
	);

	rstr_free(&rstr_mnemonic);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x1d52c
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1d54b
movq %rdi, %r14
leaq 0x22a00(%rip), %rsi     # 0x3fed2
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x6e49
pushq $0x71
popq %rsi
movq %r15, %rdi
callq 0x6f81
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x20534(%rip), %rdx     # 0x3da2b
cmovneq %rax, %rdx
leaq 0x229d5(%rip), %rsi     # 0x3fed7
leaq 0x24c15(%rip), %r8      # 0x4211e
movq %r14, %rdi
movq %rbx, %rcx
movq %r8, %r9
xorl %eax, %eax
callq 0x739a
movq %r15, %rdi
callq 0x72b9
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e4fd(%rip), %rdi     # 0x3ba30
leaq 0x2415e(%rip), %rsi     # 0x41698
leaq 0x25eee(%rip), %rcx     # 0x4342f
movl $0x728, %edx            # imm = 0x728
callq 0x30a0
leaq 0x22978(%rip), %rdi     # 0x3feca
leaq 0x2413f(%rip), %rsi     # 0x41698
leaq 0x25ecf(%rip), %rcx     # 0x4342f
movl $0x72b, %edx            # imm = 0x72B
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_idiv_x
static void _asm_inst_idiv_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	uint8_t type,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(source);

	ResizableString rstr_mnemonic;
	rstr_init_with_cstr(&rstr_mnemonic, "idiv");
	rstr_append_with_char(
		&rstr_mnemonic,
		_asm_inst_type_suffix(ctx, type)
	);

	_asm_inst1(
		ctx,
		rstr,
		RSTR_CSTR(&rstr_mnemonic),
		source
	);

	rstr_free(&rstr_mnemonic);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x1d787
movq %rdi, %r14
leaq 0x22d70(%rip), %rsi     # 0x404a5
leaq -0x20(%rbp), %rbx
movq %rbx, %rdi
callq 0x6e49
pushq $0x71
popq %rsi
movq %rbx, %rdi
callq 0x6f81
movq 0x8(%rbx), %rax
testq %rax, %rax
leaq 0x202d1(%rip), %rdx     # 0x3da2b
cmovneq %rax, %rdx
leaq 0x20f45(%rip), %rsi     # 0x3e6aa
leaq 0x249b2(%rip), %rcx     # 0x4211e
movq %r14, %rdi
xorl %eax, %eax
callq 0x739a
movq %rbx, %rdi
callq 0x72b9
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1e2a2(%rip), %rdi     # 0x3ba30
leaq 0x23f03(%rip), %rsi     # 0x41698
leaq 0x260d8(%rip), %rcx     # 0x43874
movl $0x7f4, %edx            # imm = 0x7F4
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_and_x_x
static void _asm_inst_and_x_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	uint8_t type,
	const char *target,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);

	ResizableString rstr_mnemonic;
	rstr_init_with_cstr(&rstr_mnemonic, "and");
	rstr_append_with_char(
		&rstr_mnemonic,
		_asm_inst_type_suffix(ctx, type)
	);

	_asm_inst2(
		ctx,
		rstr,
		RSTR_CSTR(&rstr_mnemonic),
		source,
		target
	);

	rstr_free(&rstr_mnemonic);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x1d88a
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1d8a9
movq %rcx, %r14
testq %rcx, %rcx
je 0x1d8c8
movl %esi, %r13d
movq %rdi, %r15
leaq 0x2781a(%rip), %rsi     # 0x45043
leaq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0x6e49
movzbl %r13b, %edi
callq 0x1bd9f
movsbl %al, %esi
movq %r12, %rdi
callq 0x6f81
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x201d3(%rip), %rdx     # 0x3da2b
cmovneq %rax, %rdx
leaq 0x20763(%rip), %rsi     # 0x3dfc6
movq %r15, %rdi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x739a
movq %r12, %rdi
callq 0x72b9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e19f(%rip), %rdi     # 0x3ba30
leaq 0x23e00(%rip), %rsi     # 0x41698
leaq 0x2624c(%rip), %rcx     # 0x43aeb
movl $0x950, %edx            # imm = 0x950
callq 0x30a0
leaq 0x28201(%rip), %rdi     # 0x45ab1
leaq 0x23de1(%rip), %rsi     # 0x41698
leaq 0x2622d(%rip), %rcx     # 0x43aeb
movl $0x951, %edx            # imm = 0x951
callq 0x30a0
leaq 0x2526b(%rip), %rdi     # 0x42b3a
leaq 0x23dc2(%rip), %rsi     # 0x41698
leaq 0x2620e(%rip), %rcx     # 0x43aeb
movl $0x952, %edx            # imm = 0x952
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_xor_x_x
static void _asm_inst_xor_x_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	uint8_t type,
	const char *target,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);

	ResizableString rstr_mnemonic;
	rstr_init_with_cstr(&rstr_mnemonic, "xor");
	rstr_append_with_char(
		&rstr_mnemonic,
		_asm_inst_type_suffix(ctx, type)
	);

	_asm_inst2(
		ctx,
		rstr,
		RSTR_CSTR(&rstr_mnemonic),
		source,
		target
	);

	rstr_free(&rstr_mnemonic);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x1d966
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1d985
movq %rdi, %r14
leaq 0x2773d(%rip), %rsi     # 0x4504c
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x6e49
pushq $0x71
popq %rsi
movq %r15, %rdi
callq 0x6f81
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x200f7(%rip), %rdx     # 0x3da2b
cmovneq %rax, %rdx
leaq 0x20687(%rip), %rsi     # 0x3dfc6
leaq 0x241fc(%rip), %r8      # 0x41b42
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x739a
movq %r15, %rdi
callq 0x72b9
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e0c3(%rip), %rdi     # 0x3ba30
leaq 0x23d24(%rip), %rsi     # 0x41698
leaq 0x2625c(%rip), %rcx     # 0x43bd7
movl $0x994, %edx            # imm = 0x994
callq 0x30a0
leaq 0x251ae(%rip), %rdi     # 0x42b3a
leaq 0x23d05(%rip), %rsi     # 0x41698
leaq 0x2623d(%rip), %rcx     # 0x43bd7
movl $0x996, %edx            # imm = 0x996
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: get_id_or_constexpr_type
static uint8_t _get_id_or_constexpr_type(
	ASMGeneratorGas64Context *ctx,
	ParserASTNode *id_or_constexpr
) {
	assert(ctx);
	assert(id_or_constexpr);

	if (id_or_constexpr->type == BE_NODE_IDENTIFIER) {
		ParserSymbol *symbol = _get_var_symbol_by_id_node(ctx, id_or_constexpr);
		return BE_VAR_SYMBOL_GET_TYPE(symbol);
	} else if (id_or_constexpr->type == BE_NODE_EXPR) {
		return BE_EXPR_AST_NODE_GET_TYPE(id_or_constexpr);
	} else {
		assert(0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0x1d9d3
movl (%rsi), %eax
cmpl $0xe00, %eax            # imm = 0xE00
je 0x1d9cb
cmpl $0x200, %eax            # imm = 0x200
jne 0x1d9f2
callq 0x1b683
movq %rax, %rsi
addq $0x30, %rsi
jmp 0x1d9cf
addq $0x60, %rsi
movb (%rsi), %al
popq %rbp
retq
leaq 0x20932(%rip), %rdi     # 0x3e30c
leaq 0x23cb7(%rip), %rsi     # 0x41698
leaq 0x263ef(%rip), %rcx     # 0x43dd7
movl $0xce2, %edx            # imm = 0xCE2
callq 0x30a0
leaq 0x1d970(%rip), %rdi     # 0x3b369
leaq 0x23c98(%rip), %rsi     # 0x41698
leaq 0x263d0(%rip), %rcx     # 0x43dd7
movl $0xcea, %edx            # imm = 0xCEA
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/lexer.c
// Function: be_lexer_new_context
LexerContext * be_lexer_new_context(
	const char *file,
	const char *source,
	int len
) {
	assert(file);
	assert(source);
	assert(len >= 0);

	return lexer_new_context(file, source, len, _matchers);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1dd9f
testq %rsi, %rsi
je 0x1ddbe
testl %edx, %edx
js 0x1dddd
leaq 0x39397(%rip), %rcx     # 0x57130
popq %rbp
jmp 0x3c5c
leaq 0x1cc5c(%rip), %rdi     # 0x3aa02
leaq 0x268f3(%rip), %rsi     # 0x446a0
leaq 0x26905(%rip), %rcx     # 0x446b9
movl $0x170, %edx            # imm = 0x170
callq 0x30a0
leaq 0x24d75(%rip), %rdi     # 0x42b3a
leaq 0x268d4(%rip), %rsi     # 0x446a0
leaq 0x268e6(%rip), %rcx     # 0x446b9
movl $0x171, %edx            # imm = 0x171
callq 0x30a0
leaq 0x1c752(%rip), %rdi     # 0x3a536
leaq 0x268b5(%rip), %rsi     # 0x446a0
leaq 0x268c7(%rip), %rcx     # 0x446b9
movl $0x172, %edx            # imm = 0x172
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/lexer.c
// Function: be_lexer_get_uint32_val
uint32_t be_lexer_get_uint32_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	switch (token->type) {
		case BE_TOKEN_LITERAL_UINT_BIN: {
			return util_get_uint32_bin_val(token->content, token->len);
		}
		case BE_TOKEN_LITERAL_UINT_OCT: {
			return util_get_uint32_oct_val(token->content, token->len);
		}
		case BE_TOKEN_LITERAL_UINT_DEC: {
			return util_get_uint32_dec_val(token->content, token->len);
		}
		case BE_TOKEN_LITERAL_UINT_HEX: {
			return util_get_uint32_hex_val(token->content, token->len);
		}
		default: {
			assert(0);
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1de8a
testq %rsi, %rsi
je 0x1dea9
movl $0xfffff000, %eax       # imm = 0xFFFFF000
addl (%rsi), %eax
cmpl $0x3, %eax
ja 0x1dec8
leaq 0x26833(%rip), %rcx     # 0x44680
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x9713
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x993b
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x9ad7
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x982f
leaq 0x1ef43(%rip), %rdi     # 0x3cdd4
leaq 0x26808(%rip), %rsi     # 0x446a0
leaq 0x26889(%rip), %rcx     # 0x44728
movl $0x183, %edx            # imm = 0x183
callq 0x30a0
leaq 0x1c606(%rip), %rdi     # 0x3a4b6
leaq 0x267e9(%rip), %rsi     # 0x446a0
leaq 0x2686a(%rip), %rcx     # 0x44728
movl $0x184, %edx            # imm = 0x184
callq 0x30a0
leaq 0x1d49a(%rip), %rdi     # 0x3b369
leaq 0x267ca(%rip), %rsi     # 0x446a0
leaq 0x2684b(%rip), %rcx     # 0x44728
movl $0x194, %edx            # imm = 0x194
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/lexer.c
// Function: be_lexer_get_uint64_val
uint64_t be_lexer_get_uint64_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	switch (token->type) {
		case BE_TOKEN_LITERAL_UINT_BIN: {
			return util_get_uint64_bin_val(token->content, token->len);
		}
		case BE_TOKEN_LITERAL_UINT_OCT: {
			return util_get_uint64_oct_val(token->content, token->len);
		}
		case BE_TOKEN_LITERAL_UINT_DEC: {
			return util_get_uint64_dec_val(token->content, token->len);
		}
		case BE_TOKEN_LITERAL_UINT_HEX: {
			return util_get_uint64_hex_val(token->content, token->len);
		}
		default: {
			assert(0);
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1df49
testq %rsi, %rsi
je 0x1df68
movl $0xfffff000, %eax       # imm = 0xFFFFF000
addl (%rsi), %eax
cmpl $0x3, %eax
ja 0x1df87
leaq 0x26784(%rip), %rcx     # 0x44690
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x966d
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x98aa
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x99b6
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x978e
leaq 0x1ee84(%rip), %rdi     # 0x3cdd4
leaq 0x26749(%rip), %rsi     # 0x446a0
leaq 0x26809(%rip), %rcx     # 0x44767
movl $0x19f, %edx            # imm = 0x19F
callq 0x30a0
leaq 0x1c547(%rip), %rdi     # 0x3a4b6
leaq 0x2672a(%rip), %rsi     # 0x446a0
leaq 0x267ea(%rip), %rcx     # 0x44767
movl $0x1a0, %edx            # imm = 0x1A0
callq 0x30a0
leaq 0x1d3db(%rip), %rdi     # 0x3b369
leaq 0x2670b(%rip), %rsi     # 0x446a0
leaq 0x267cb(%rip), %rcx     # 0x44767
movl $0x1b0, %edx            # imm = 0x1B0
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/lexer.c
// Function: be_lexer_get_float_val
float be_lexer_get_float_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	if (token->type == BE_TOKEN_LITERAL_REAL) {
		return util_get_float_val(token->content, token->len);
	} else {
		assert(0);
	}
	
	return 0.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1dfc9
testq %rsi, %rsi
je 0x1dfe8
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x1e007
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x9c54
leaq 0x1ee04(%rip), %rdi     # 0x3cdd4
leaq 0x266c9(%rip), %rsi     # 0x446a0
leaq 0x267c8(%rip), %rcx     # 0x447a6
movl $0x1bb, %edx            # imm = 0x1BB
callq 0x30a0
leaq 0x1c4c7(%rip), %rdi     # 0x3a4b6
leaq 0x266aa(%rip), %rsi     # 0x446a0
leaq 0x267a9(%rip), %rcx     # 0x447a6
movl $0x1bc, %edx            # imm = 0x1BC
callq 0x30a0
leaq 0x1d35b(%rip), %rdi     # 0x3b369
leaq 0x2668b(%rip), %rsi     # 0x446a0
leaq 0x2678a(%rip), %rcx     # 0x447a6
movl $0x1c1, %edx            # imm = 0x1C1
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/lexer.c
// Function: be_lexer_get_double_val
double be_lexer_get_double_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	if (token->type == BE_TOKEN_LITERAL_REAL) {
		return util_get_double_val(token->content, token->len);
	} else {
		assert(0);
	}
	
	return 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1e049
testq %rsi, %rsi
je 0x1e068
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x1e087
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x9b52
leaq 0x1ed84(%rip), %rdi     # 0x3cdd4
leaq 0x26649(%rip), %rsi     # 0x446a0
leaq 0x26783(%rip), %rcx     # 0x447e1
movl $0x1cb, %edx            # imm = 0x1CB
callq 0x30a0
leaq 0x1c447(%rip), %rdi     # 0x3a4b6
leaq 0x2662a(%rip), %rsi     # 0x446a0
leaq 0x26764(%rip), %rcx     # 0x447e1
movl $0x1cc, %edx            # imm = 0x1CC
callq 0x30a0
leaq 0x1d2db(%rip), %rdi     # 0x3b369
leaq 0x2660b(%rip), %rsi     # 0x446a0
leaq 0x26745(%rip), %rcx     # 0x447e1
movl $0x1d1, %edx            # imm = 0x1D1
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/lexer.c
// Function: be_lexer_get_char_val
char be_lexer_get_char_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	if (token->type == BE_TOKEN_LITERAL_CHAR) {
		return util_get_char_val(token->content, token->len);
	} else {
		assert(0);
	}

	return '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1e0c9
testq %rsi, %rsi
je 0x1e0e8
cmpl $0x1005, (%rsi)         # imm = 0x1005
jne 0x1e107
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x9528
leaq 0x1ed04(%rip), %rdi     # 0x3cdd4
leaq 0x265c9(%rip), %rsi     # 0x446a0
leaq 0x26740(%rip), %rcx     # 0x4481e
movl $0x1db, %edx            # imm = 0x1DB
callq 0x30a0
leaq 0x1c3c7(%rip), %rdi     # 0x3a4b6
leaq 0x265aa(%rip), %rsi     # 0x446a0
leaq 0x26721(%rip), %rcx     # 0x4481e
movl $0x1dc, %edx            # imm = 0x1DC
callq 0x30a0
leaq 0x1d25b(%rip), %rdi     # 0x3b369
leaq 0x2658b(%rip), %rsi     # 0x446a0
leaq 0x26702(%rip), %rcx     # 0x4481e
movl $0x1e1, %edx            # imm = 0x1E1
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/lexer.c
// Function: be_lexer_has_unsigned_mark
bool be_lexer_has_unsigned_mark(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);
	assert(
		token->type == BE_TOKEN_LITERAL_UINT_BIN
		|| token->type == BE_TOKEN_LITERAL_UINT_OCT
		|| token->type == BE_TOKEN_LITERAL_UINT_DEC
		|| token->type == BE_TOKEN_LITERAL_UINT_HEX
	);

	return token->content[token->len - 1] == 'u';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1e1d1
testq %rsi, %rsi
je 0x1e1f0
movl (%rsi), %eax
andl $-0x4, %eax
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x1e20f
movq 0x8(%rsi), %rax
movslq 0x4(%rsi), %rcx
cmpb $0x75, -0x1(%rax,%rcx)
sete %al
popq %rbp
retq
leaq 0x1ebfc(%rip), %rdi     # 0x3cdd4
leaq 0x264c1(%rip), %rsi     # 0x446a0
leaq 0x266c8(%rip), %rcx     # 0x448ae
movl $0x1f8, %edx            # imm = 0x1F8
callq 0x30a0
leaq 0x1c2bf(%rip), %rdi     # 0x3a4b6
leaq 0x264a2(%rip), %rsi     # 0x446a0
leaq 0x266a9(%rip), %rcx     # 0x448ae
movl $0x1f9, %edx            # imm = 0x1F9
callq 0x30a0
leaq 0x266d7(%rip), %rdi     # 0x448ed
leaq 0x26483(%rip), %rsi     # 0x446a0
leaq 0x2668a(%rip), %rcx     # 0x448ae
movl $0x1ff, %edx            # imm = 0x1FF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/lexer.c
// Function: be_lexer_has_float_mark
bool be_lexer_has_float_mark(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);
	assert(token->type == BE_TOKEN_LITERAL_REAL);

	return token->content[token->len - 1] == 'f';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1e256
testq %rsi, %rsi
je 0x1e275
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x1e294
movq 0x8(%rsi), %rax
movslq 0x4(%rsi), %rcx
cmpb $0x66, -0x1(%rax,%rcx)
sete %al
popq %rbp
retq
leaq 0x1eb77(%rip), %rdi     # 0x3cdd4
leaq 0x2643c(%rip), %rsi     # 0x446a0
leaq 0x2672f(%rip), %rcx     # 0x4499a
movl $0x208, %edx            # imm = 0x208
callq 0x30a0
leaq 0x1c23a(%rip), %rdi     # 0x3a4b6
leaq 0x2641d(%rip), %rsi     # 0x446a0
leaq 0x26710(%rip), %rcx     # 0x4499a
movl $0x209, %edx            # imm = 0x209
callq 0x30a0
leaq 0x2673b(%rip), %rdi     # 0x449d6
leaq 0x263fe(%rip), %rsi     # 0x446a0
leaq 0x266f1(%rip), %rcx     # 0x4499a
movl $0x20a, %edx            # imm = 0x20A
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_new_context
_RULE_END




ParserContext * be_parser_new_context(
	const char *file,
	const char *source,
	int len,
	int arch
) {
	assert(file);
	assert(source);
	assert(len >= 0);

	LexerContext *lexctx = be_lexer_new_context(file, source, len);
	lexer_parse(lexctx);

	BeParserContextData data;
	data.align_node = NULL;
	data.packed_node = NULL;

	ParserContext *ctx = parser_new_context_with_data(
		lexctx, sizeof(data), &data
	);
	ctx->arch = arch;

	return ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x20342
testq %rsi, %rsi
je 0x20361
testl %edx, %edx
js 0x20380
movl %ecx, %ebx
callq 0x1dd80
movq %rax, %r14
movq %rax, %rdi
callq 0x44d1
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rdx
movaps %xmm0, (%rdx)
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x5c34
movl %ebx, 0x30(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1a6b9(%rip), %rdi     # 0x3aa02
leaq 0x25f08(%rip), %rsi     # 0x46258
leaq 0x25f1b(%rip), %rcx     # 0x46272
movl $0x92a, %edx            # imm = 0x92A
callq 0x30a0
leaq 0x227d2(%rip), %rdi     # 0x42b3a
leaq 0x25ee9(%rip), %rsi     # 0x46258
leaq 0x25efc(%rip), %rcx     # 0x46272
movl $0x92b, %edx            # imm = 0x92B
callq 0x30a0
leaq 0x1a1af(%rip), %rdi     # 0x3a536
leaq 0x25eca(%rip), %rsi     # 0x46258
leaq 0x25edd(%rip), %rcx     # 0x46272
movl $0x92c, %edx            # imm = 0x92C
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_get_uint32_val
uint32_t be_parser_get_uint32_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_UINT);

	return be_lexer_get_uint32_val(ctx->lexctx, node->token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x20b61
testq %rsi, %rsi
je 0x20b80
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x20b9f
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1de28
leaq 0x1c26c(%rip), %rdi     # 0x3cdd4
leaq 0x256e9(%rip), %rsi     # 0x46258
leaq 0x257dd(%rip), %rcx     # 0x46353
movl $0x976, %edx            # imm = 0x976
callq 0x30a0
leaq 0x1d383(%rip), %rdi     # 0x3df0a
leaq 0x256ca(%rip), %rsi     # 0x46258
leaq 0x257be(%rip), %rcx     # 0x46353
movl $0x977, %edx            # imm = 0x977
callq 0x30a0
leaq 0x257f1(%rip), %rdi     # 0x46397
leaq 0x256ab(%rip), %rsi     # 0x46258
leaq 0x2579f(%rip), %rcx     # 0x46353
movl $0x978, %edx            # imm = 0x978
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_get_uint64_val
uint64_t be_parser_get_uint64_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_UINT);

	return be_lexer_get_uint64_val(ctx->lexctx, node->token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x20be1
testq %rsi, %rsi
je 0x20c00
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x20c1f
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1dee7
leaq 0x1c1ec(%rip), %rdi     # 0x3cdd4
leaq 0x25669(%rip), %rsi     # 0x46258
leaq 0x257c4(%rip), %rcx     # 0x463ba
movl $0x981, %edx            # imm = 0x981
callq 0x30a0
leaq 0x1d303(%rip), %rdi     # 0x3df0a
leaq 0x2564a(%rip), %rsi     # 0x46258
leaq 0x257a5(%rip), %rcx     # 0x463ba
movl $0x982, %edx            # imm = 0x982
callq 0x30a0
leaq 0x25771(%rip), %rdi     # 0x46397
leaq 0x2562b(%rip), %rsi     # 0x46258
leaq 0x25786(%rip), %rcx     # 0x463ba
movl $0x983, %edx            # imm = 0x983
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_get_uint_val
uint64_t be_parser_get_uint_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_UINT);

	int arch = ctx->arch;
	if (arch == BE_ARCH_32) {
		return be_parser_get_uint32_val(ctx, node);
	} else if (arch == BE_ARCH_64) {
		return be_parser_get_uint64_val(ctx, node);
	} else {
		assert(0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x20c70
testq %rsi, %rsi
je 0x20c8f
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x20cae
movl 0x30(%rdi), %eax
cmpl $0x2, %eax
je 0x20c6a
cmpl $0x1, %eax
jne 0x20ccd
callq 0x20b3e
movl %eax, %eax
popq %rbp
retq
popq %rbp
jmp 0x20bbe
leaq 0x1c15d(%rip), %rdi     # 0x3cdd4
leaq 0x255da(%rip), %rsi     # 0x46258
leaq 0x25779(%rip), %rcx     # 0x463fe
movl $0x98c, %edx            # imm = 0x98C
callq 0x30a0
leaq 0x1d274(%rip), %rdi     # 0x3df0a
leaq 0x255bb(%rip), %rsi     # 0x46258
leaq 0x2575a(%rip), %rcx     # 0x463fe
movl $0x98d, %edx            # imm = 0x98D
callq 0x30a0
leaq 0x256e2(%rip), %rdi     # 0x46397
leaq 0x2559c(%rip), %rsi     # 0x46258
leaq 0x2573b(%rip), %rcx     # 0x463fe
movl $0x98e, %edx            # imm = 0x98E
callq 0x30a0
leaq 0x1a695(%rip), %rdi     # 0x3b369
leaq 0x2557d(%rip), %rsi     # 0x46258
leaq 0x2571c(%rip), %rcx     # 0x463fe
movl $0x996, %edx            # imm = 0x996
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_get_float_val
float be_parser_get_float_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_REAL);

	return be_lexer_get_float_val(ctx->lexctx, node->token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x20d0f
testq %rsi, %rsi
je 0x20d2e
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x20d4d
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1dfa6
leaq 0x1c0be(%rip), %rdi     # 0x3cdd4
leaq 0x2553b(%rip), %rsi     # 0x46258
leaq 0x2571c(%rip), %rcx     # 0x46440
movl $0x99e, %edx            # imm = 0x99E
callq 0x30a0
leaq 0x1d1d5(%rip), %rdi     # 0x3df0a
leaq 0x2551c(%rip), %rsi     # 0x46258
leaq 0x256fd(%rip), %rcx     # 0x46440
movl $0x99f, %edx            # imm = 0x99F
callq 0x30a0
leaq 0x2572c(%rip), %rdi     # 0x46480
leaq 0x254fd(%rip), %rsi     # 0x46258
leaq 0x256de(%rip), %rcx     # 0x46440
movl $0x9a0, %edx            # imm = 0x9A0
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_get_double_val
double be_parser_get_double_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_REAL);

	return be_lexer_get_double_val(ctx->lexctx, node->token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x20d8f
testq %rsi, %rsi
je 0x20dae
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x20dcd
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1e026
leaq 0x1c03e(%rip), %rdi     # 0x3cdd4
leaq 0x254bb(%rip), %rsi     # 0x46258
leaq 0x256ff(%rip), %rcx     # 0x464a3
movl $0x9a9, %edx            # imm = 0x9A9
callq 0x30a0
leaq 0x1d155(%rip), %rdi     # 0x3df0a
leaq 0x2549c(%rip), %rsi     # 0x46258
leaq 0x256e0(%rip), %rcx     # 0x464a3
movl $0x9aa, %edx            # imm = 0x9AA
callq 0x30a0
leaq 0x256ac(%rip), %rdi     # 0x46480
leaq 0x2547d(%rip), %rsi     # 0x46258
leaq 0x256c1(%rip), %rcx     # 0x464a3
movl $0x9ab, %edx            # imm = 0x9AB
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_get_char_val
char be_parser_get_char_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_CHAR);

	return be_lexer_get_char_val(ctx->lexctx, node->token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x20e0f
testq %rsi, %rsi
je 0x20e2e
cmpl $0x302, (%rsi)          # imm = 0x302
jne 0x20e4d
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1e0a6
leaq 0x1bfbe(%rip), %rdi     # 0x3cdd4
leaq 0x2543b(%rip), %rsi     # 0x46258
leaq 0x256c1(%rip), %rcx     # 0x464e5
movl $0x9b4, %edx            # imm = 0x9B4
callq 0x30a0
leaq 0x1d0d5(%rip), %rdi     # 0x3df0a
leaq 0x2541c(%rip), %rsi     # 0x46258
leaq 0x256a2(%rip), %rcx     # 0x464e5
movl $0x9b5, %edx            # imm = 0x9B5
callq 0x30a0
leaq 0x256cf(%rip), %rdi     # 0x46523
leaq 0x253fd(%rip), %rsi     # 0x46258
leaq 0x25683(%rip), %rcx     # 0x464e5
movl $0x9b6, %edx            # imm = 0x9B6
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_add_var_symbol_to_node
ParserSymbol * be_parser_add_var_symbol_to_node(
	ParserContext *ctx,
	ParserASTNode *node,
	LexerToken *token,
	uint8_t var_type,
	ParserASTNode *var_type_node,
	size_t type_size
) {
	assert(ctx);
	assert(node);
	assert(token);
	assert(var_type > 0);
	assert(var_type_node);

	BeParserVarSymbolData data;
	data.type = var_type;
	data.type_node = var_type_node;
	data.func_symbol = NULL;
	data.has_code_gen_name = false;

	data.align = 1;
	data.address = SIZE_MAX;
	data.type_size = type_size;

	data.scope_type = BE_VAR_TYPE_UNKNOWN;

	ParserSymbol *symbol = parser_add_symbol_to_node(
		ctx,
		node,
		BE_SYM_VAR,
		token,
		sizeof(data),
		&data
	);
	symbol->releaser = _var_symbol_releaser;

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
testq %rdi, %rdi
je 0x20f25
testq %rsi, %rsi
je 0x20f44
movq %rdx, %rax
testq %rdx, %rdx
je 0x20f63
testb %cl, %cl
je 0x20f82
testq %r8, %r8
je 0x20fa1
leaq -0x50(%rbp), %r10
movb %cl, (%r10)
movq %r8, 0x8(%r10)
andq $0x0, 0x10(%r10)
xorl %ecx, %ecx
movb %cl, 0x18(%r10)
movl $0x1, 0x30(%r10)
orq $-0x1, 0x38(%r10)
movq %r9, 0x40(%r10)
movb %cl, 0x48(%r10)
pushq $0x1
popq %rdx
pushq $0x50
popq %r8
movq %rax, %rcx
movq %r10, %r9
callq 0x6820
leaq -0xaf(%rip), %rcx       # 0x20e6c
movq %rcx, 0x20(%rax)
addq $0x50, %rsp
popq %rbp
retq
leaq 0x1bea8(%rip), %rdi     # 0x3cdd4
leaq 0x25325(%rip), %rsi     # 0x46258
leaq 0x25636(%rip), %rcx     # 0x46570
movl $0x9ce, %edx            # imm = 0x9CE
callq 0x30a0
leaq 0x1cfbf(%rip), %rdi     # 0x3df0a
leaq 0x25306(%rip), %rsi     # 0x46258
leaq 0x25617(%rip), %rcx     # 0x46570
movl $0x9cf, %edx            # imm = 0x9CF
callq 0x30a0
leaq 0x1954c(%rip), %rdi     # 0x3a4b6
leaq 0x252e7(%rip), %rsi     # 0x46258
leaq 0x255f8(%rip), %rcx     # 0x46570
movl $0x9d0, %edx            # imm = 0x9D0
callq 0x30a0
leaq 0x25668(%rip), %rdi     # 0x465f1
leaq 0x252c8(%rip), %rsi     # 0x46258
leaq 0x255d9(%rip), %rcx     # 0x46570
movl $0x9d1, %edx            # imm = 0x9D1
callq 0x30a0
leaq 0x25656(%rip), %rdi     # 0x465fe
leaq 0x252a9(%rip), %rsi     # 0x46258
leaq 0x255ba(%rip), %rcx     # 0x46570
movl $0x9d2, %edx            # imm = 0x9D2
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_add_struct_member_var_symbol_to_symbol
ParserSymbol * be_parser_add_struct_member_var_symbol_to_symbol(
	ParserContext *ctx,
	ParserSymbol *symbol,
	LexerToken *token,
	uint8_t var_type,
	ParserASTNode *var_type_node,
	size_t offset
) {
	assert(ctx);
	assert(symbol);
	assert(token);
	assert(var_type > 0);
	assert(var_type_node);

	BeParserStructMemberVarSymbolData data;
	data.type = var_type;
	data.type_node = var_type_node;
	data.offset = offset;

	return parser_add_symbol_to_symbol(
		ctx,
		symbol,
		BE_SYM_STRUCT_MEMBER_VAR,
		token,
		sizeof(data),
		&data
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
testq %rdi, %rdi
je 0x21012
testq %rsi, %rsi
je 0x21031
movq %rdx, %rax
testq %rdx, %rdx
je 0x21050
testb %cl, %cl
je 0x2106f
testq %r8, %r8
je 0x2108e
leaq -0x18(%rbp), %r10
movb %cl, (%r10)
movq %r8, 0x8(%r10)
movq %r9, 0x10(%r10)
pushq $0x5
popq %rdx
pushq $0x18
popq %r8
movq %rax, %rcx
movq %r10, %r9
callq 0x6b48
addq $0x20, %rsp
popq %rbp
retq
leaq 0x1bdbb(%rip), %rdi     # 0x3cdd4
leaq 0x25238(%rip), %rsi     # 0x46258
leaq 0x255e5(%rip), %rcx     # 0x4660c
movl $0x9f5, %edx            # imm = 0x9F5
callq 0x30a0
leaq 0x1caa0(%rip), %rdi     # 0x3dad8
leaq 0x25219(%rip), %rsi     # 0x46258
leaq 0x255c6(%rip), %rcx     # 0x4660c
movl $0x9f6, %edx            # imm = 0x9F6
callq 0x30a0
leaq 0x1945f(%rip), %rdi     # 0x3a4b6
leaq 0x251fa(%rip), %rsi     # 0x46258
leaq 0x255a7(%rip), %rcx     # 0x4660c
movl $0x9f7, %edx            # imm = 0x9F7
callq 0x30a0
leaq 0x2557b(%rip), %rdi     # 0x465f1
leaq 0x251db(%rip), %rsi     # 0x46258
leaq 0x25588(%rip), %rcx     # 0x4660c
movl $0x9f8, %edx            # imm = 0x9F8
callq 0x30a0
leaq 0x25569(%rip), %rdi     # 0x465fe
leaq 0x251bc(%rip), %rsi     # 0x46258
leaq 0x25569(%rip), %rcx     # 0x4660c
movl $0x9f9, %edx            # imm = 0x9F9
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_new_struct_symbol
ParserSymbol * be_parser_new_struct_symbol(
	ParserContext *ctx,
	LexerToken *token,
	ParserASTNode *struct_node,
	ParserASTNode *body_node,
	bool dummy
) {
	assert(ctx);
	assert(token);
	assert(body_node);

	BeParserStructSymbolData data;
	data.struct_node = struct_node;
	data.body_node = body_node;
	data.dummy = dummy;

	return parser_new_symbol(
		ctx,
		BE_SYM_STRUCT,
		token,
		sizeof(data),
		&data
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
testq %rdi, %rdi
je 0x210ed
movq %rsi, %rax
testq %rsi, %rsi
je 0x2110c
testq %rcx, %rcx
je 0x2112b
leaq -0x18(%rbp), %r9
movq %rdx, (%r9)
movq %rcx, 0x8(%r9)
movb %r8b, 0x10(%r9)
pushq $0x2
popq %rsi
pushq $0x18
popq %rcx
movq %rax, %rdx
movq %r9, %r8
callq 0x64ee
addq $0x20, %rsp
popq %rbp
retq
leaq 0x1bce0(%rip), %rdi     # 0x3cdd4
leaq 0x2515d(%rip), %rsi     # 0x46258
leaq 0x2559a(%rip), %rcx     # 0x4669c
movl $0xa11, %edx            # imm = 0xA11
callq 0x30a0
leaq 0x193a3(%rip), %rdi     # 0x3a4b6
leaq 0x2513e(%rip), %rsi     # 0x46258
leaq 0x2557b(%rip), %rcx     # 0x4669c
movl $0xa12, %edx            # imm = 0xA12
callq 0x30a0
leaq 0x28613(%rip), %rdi     # 0x49745
leaq 0x2511f(%rip), %rsi     # 0x46258
leaq 0x2555c(%rip), %rcx     # 0x4669c
movl $0xa13, %edx            # imm = 0xA13
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_add_struct_symbol_to_node
ParserSymbol * be_parser_add_struct_symbol_to_node(
	ParserContext *ctx,
	ParserASTNode *node,
	LexerToken *token,
	ParserASTNode *body_node,
	bool dummy
) {
	assert(ctx);
	assert(node);
	assert(token);
	assert(body_node);

	BeParserStructSymbolData data;
	data.body_node = body_node;
	data.dummy = dummy;

	return parser_add_symbol_to_node(
		ctx,
		node,
		BE_SYM_STRUCT,
		token,
		sizeof(data),
		&data
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
testq %rdi, %rdi
je 0x2118a
testq %rsi, %rsi
je 0x211a9
movq %rdx, %rax
testq %rdx, %rdx
je 0x211c8
testq %rcx, %rcx
je 0x211e7
leaq -0x18(%rbp), %r9
movq %rcx, 0x8(%r9)
movb %r8b, 0x10(%r9)
pushq $0x2
popq %rdx
pushq $0x18
popq %r8
movq %rax, %rcx
callq 0x6820
addq $0x20, %rsp
popq %rbp
retq
leaq 0x1bc43(%rip), %rdi     # 0x3cdd4
leaq 0x250c0(%rip), %rsi     # 0x46258
leaq 0x2556f(%rip), %rcx     # 0x4670e
movl $0xa2a, %edx            # imm = 0xA2A
callq 0x30a0
leaq 0x1cd5a(%rip), %rdi     # 0x3df0a
leaq 0x250a1(%rip), %rsi     # 0x46258
leaq 0x25550(%rip), %rcx     # 0x4670e
movl $0xa2b, %edx            # imm = 0xA2B
callq 0x30a0
leaq 0x192e7(%rip), %rdi     # 0x3a4b6
leaq 0x25082(%rip), %rsi     # 0x46258
leaq 0x25531(%rip), %rcx     # 0x4670e
movl $0xa2c, %edx            # imm = 0xA2C
callq 0x30a0
leaq 0x28557(%rip), %rdi     # 0x49745
leaq 0x25063(%rip), %rsi     # 0x46258
leaq 0x25512(%rip), %rcx     # 0x4670e
movl $0xa2d, %edx            # imm = 0xA2D
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_add_func_symbol_to_node
ParserSymbol * be_parser_add_func_symbol_to_node(
	ParserContext *ctx,
	ParserASTNode *node,
	LexerToken *token,
	ParserASTNode *params_node,
	ParserASTNode *return_type_node,
	bool dummy
) {
	assert(ctx);
	assert(node);
	assert(token);
	assert(params_node);

	BeParserFuncSymbolData data;
	data.params_node = params_node;
	data.return_type_node = return_type_node;
	data.dummy = dummy;
	data.counter = 0;

	ParserASTNode *func_type_node = _NEW_NODE(ctx, BE_NODE_TYPE_FUNC, NULL);
	parser_add_child(ctx, func_type_node, params_node);
	if (return_type_node != NULL) {
		parser_add_child(ctx, func_type_node, return_type_node);
	}

	data.func_type_node = func_type_node;

	ParserASTNode *func_pointer_type_node = _NEW_NODE(ctx, BE_NODE_TYPE_POINTER, NULL);
	parser_add_child(ctx, func_pointer_type_node, func_type_node);

	data.func_pointer_type_node = func_pointer_type_node;

	return parser_add_symbol_to_node(
		ctx,
		node,
		BE_SYM_FUNC,
		token,
		sizeof(data),
		&data
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
testq %rdi, %rdi
je 0x212ef
movq %rsi, %r14
testq %rsi, %rsi
je 0x2130e
testq %rdx, %rdx
je 0x2132d
movq %rcx, %r13
movq %rdx, -0x30(%rbp)
testq %rcx, %rcx
je 0x2134c
movq %r8, %r12
movq %rdi, %r15
movq %r13, -0x60(%rbp)
movq %r8, -0x58(%rbp)
movb %r9b, -0x40(%rbp)
andl $0x0, -0x3c(%rbp)
leaq 0x255bb(%rip), %rdx     # 0x4681d
movl $0x430, %esi            # imm = 0x430
xorl %ecx, %ecx
callq 0x201bf
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x63c4
testq %r12, %r12
je 0x21292
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x63c4
leaq -0x60(%rbp), %r12
movq %rbx, 0x10(%r12)
leaq 0x1f376(%rip), %rdx     # 0x40618
movq %r15, %rdi
movl $0x440, %esi            # imm = 0x440
xorl %ecx, %ecx
callq 0x201bf
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x63c4
movq %r13, 0x18(%r12)
pushq $0x3
popq %rdx
pushq $0x30
popq %r8
movq %r15, %rdi
movq %r14, %rsi
movq -0x30(%rbp), %rcx
movq %r12, %r9
callq 0x6820
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bade(%rip), %rdi     # 0x3cdd4
leaq 0x24f5b(%rip), %rsi     # 0x46258
leaq 0x25484(%rip), %rcx     # 0x46788
movl $0xa45, %edx            # imm = 0xA45
callq 0x30a0
leaq 0x1cbf5(%rip), %rdi     # 0x3df0a
leaq 0x24f3c(%rip), %rsi     # 0x46258
leaq 0x25465(%rip), %rcx     # 0x46788
movl $0xa46, %edx            # imm = 0xA46
callq 0x30a0
leaq 0x19182(%rip), %rdi     # 0x3a4b6
leaq 0x24f1d(%rip), %rsi     # 0x46258
leaq 0x25446(%rip), %rcx     # 0x46788
movl $0xa47, %edx            # imm = 0xA47
callq 0x30a0
leaq 0x254be(%rip), %rdi     # 0x46811
leaq 0x24efe(%rip), %rsi     # 0x46258
leaq 0x25427(%rip), %rcx     # 0x46788
movl $0xa48, %edx            # imm = 0xA48
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_has_unsigned_mark
bool be_parser_has_unsigned_mark(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_UINT);

	return be_lexer_has_unsigned_mark(ctx->lexctx, node->token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2138e
testq %rsi, %rsi
je 0x213ad
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x213cc
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1e1a5
leaq 0x1ba3f(%rip), %rdi     # 0x3cdd4
leaq 0x24ebc(%rip), %rsi     # 0x46258
leaq 0x2548c(%rip), %rcx     # 0x4682f
movl $0xa6b, %edx            # imm = 0xA6B
callq 0x30a0
leaq 0x1cb56(%rip), %rdi     # 0x3df0a
leaq 0x24e9d(%rip), %rsi     # 0x46258
leaq 0x2546d(%rip), %rcx     # 0x4682f
movl $0xa6c, %edx            # imm = 0xA6C
callq 0x30a0
leaq 0x24fc4(%rip), %rdi     # 0x46397
leaq 0x24e7e(%rip), %rsi     # 0x46258
leaq 0x2544e(%rip), %rcx     # 0x4682f
movl $0xa6d, %edx            # imm = 0xA6D
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_has_float_mark
bool be_parser_has_float_mark(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_REAL);

	return be_lexer_has_float_mark(ctx->lexctx, node->token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2140e
testq %rsi, %rsi
je 0x2142d
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x2144c
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1e22e
leaq 0x1b9bf(%rip), %rdi     # 0x3cdd4
leaq 0x24e3c(%rip), %rsi     # 0x46258
leaq 0x25450(%rip), %rcx     # 0x46873
movl $0xa76, %edx            # imm = 0xA76
callq 0x30a0
leaq 0x1cad6(%rip), %rdi     # 0x3df0a
leaq 0x24e1d(%rip), %rsi     # 0x46258
leaq 0x25431(%rip), %rcx     # 0x46873
movl $0xa77, %edx            # imm = 0xA77
callq 0x30a0
leaq 0x2502d(%rip), %rdi     # 0x46480
leaq 0x24dfe(%rip), %rsi     # 0x46258
leaq 0x25412(%rip), %rcx     # 0x46873
movl $0xa78, %edx            # imm = 0xA78
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: rule_expr_mul
_RULE(expr_mul)
	_RULE_RETURNED_NODE(_RULE_NAME(expr_unary)(_RULE_PARSER_CTX))

	for (;_RULE_CURRENT_NODE != NULL;) {
		_RULE_PUSH_LEXCTX
		_RULE_NEXT_TOKEN
		if (_RULE_TOKEN_TYPE == BE_TOKEN_PNCT_MUL) {
			_EXPR_BINARY_ITEM(BE_NODE_EXPR_MUL, expr_unary)
		} else if (_RULE_TOKEN_TYPE == BE_TOKEN_PNCT_DIV) {
			_EXPR_BINARY_ITEM(BE_NODE_EXPR_DIV, expr_unary)
		} else if (_RULE_TOKEN_TYPE == BE_TOKEN_PNCT_MOD) {
			_EXPR_BINARY_ITEM(BE_NODE_EXPR_MOD, expr_unary)
		} else {
			_RULE_POP_LEXCTX
			break;
		}
		_RULE_ABANDON_LEXCTX
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x22988
callq 0x43b3
movq %rbx, %rdi
callq 0x229a7
movq %rax, %r14
leaq 0x244e8(%rip), %r12     # 0x46d6e
leaq 0x244d0(%rip), %r13     # 0x46d5d
testq %r14, %r14
je 0x2296e
movq (%rbx), %rdi
callq 0x43b3
movq (%rbx), %rdi
callq 0x4167
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x22966
movl (%rax), %eax
cmpl $0x4018, %eax           # imm = 0x4018
je 0x2290c
cmpl $0x4017, %eax           # imm = 0x4017
je 0x228ef
cmpl $0x4016, %eax           # imm = 0x4016
jne 0x22966
movq %rbx, %rdi
callq 0x229a7
testq %rax, %rax
je 0x22966
movq %rax, %r15
movq %rbx, %rdi
movl $0xeb0, %esi            # imm = 0xEB0
movq %r13, %rdx
jmp 0x2292b
movq %rbx, %rdi
callq 0x229a7
testq %rax, %rax
je 0x22966
movq %rax, %r15
movq %rbx, %rdi
movl $0xeb1, %esi            # imm = 0xEB1
movq %r12, %rdx
jmp 0x2292b
movq %rbx, %rdi
callq 0x229a7
testq %rax, %rax
je 0x22966
movq %rax, %r15
movq %rbx, %rdi
movl $0xeb2, %esi            # imm = 0xEB2
leaq 0x24454(%rip), %rdx     # 0x46d7f
xorl %ecx, %ecx
callq 0x201bf
movq %rax, 0x30(%r14)
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x63c4
movq %rax, 0x30(%r15)
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x63c4
movq %rax, %r14
movq (%rbx), %rdi
callq 0x447c
jmp 0x2288d
movq (%rbx), %rdi
callq 0x441b
movq (%rbx), %rdi
callq 0x447c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23fa5(%rip), %rdi     # 0x46934
leaq 0x238c2(%rip), %rsi     # 0x46258
leaq 0x24391(%rip), %rcx     # 0x46d2e
movl $0x341, %edx            # imm = 0x341
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: print_ast
static void _print_ast(ParserASTNode *node, FILE *file, int level, char padchr) {
	assert(node);
	assert(file);
	assert(level >= 0);

	for (int i = 0; i < level; i++) {
		fputc(padchr, file);
	}
	fprintf(
		file,
		"@%s#%x#%p#%p",
		node->type_name != NULL ? node->type_name : "N/A",
		node->type,
		node->parent,
		node
	);
	if (node->token != NULL) {
		fputc('(', file);
		for (int i = 0; i < node->token->len; i++) {
			fputc(*(node->token->content + i), file);
		}
		fprintf(file, "#%x)", node->token->type);
	}
	fputc('\n', file);

	if (BE_IS_EXPR_NODE(node->type)) {
		for (int i = 0; i < level; i++) {
			fputc(padchr, file);
		}
		fputs("|ExprNodeType: ", file);
		ParserASTNode *node_t = BE_EXPR_AST_NODE_GET_TYPE_NODE(node);
		if (node_t != NULL) {
			_print_type_node(node_t, file);
		}
		fputc('\n', file);
	}

	for (int i = 0; i < node->nchilds; i++) {
		_print_ast(node->childs[i], file, level + 1, padchr);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x27a1a
movl %edx, %ebx
testl %edx, %edx
js 0x27a39
movq %rsi, %r14
movq %rdi, %r15
pushq $0x9
popq %r12
movl %ebx, %r13d
subl $0x1, %r13d
jb 0x2790f
movl %r12d, %edi
movq %r14, %rsi
callq 0x30c0
jmp 0x278fc
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x20c90(%rip), %rdx     # 0x485ad
cmovneq %rax, %rdx
movl (%r15), %ecx
movq 0x30(%r15), %r8
leaq 0x20c71(%rip), %rsi     # 0x485a0
movq %r14, %rdi
movq %r15, %r9
xorl %eax, %eax
callq 0x30e0
cmpq $0x0, 0x10(%r15)
je 0x27987
pushq $0x28
popq %rdi
movq %r14, %rsi
callq 0x30c0
xorl %r12d, %r12d
movq 0x10(%r15), %rax
movslq 0x4(%rax), %rcx
cmpq %rcx, %r12
jge 0x27974
movq 0x8(%rax), %rax
movsbl (%rax,%r12), %edi
movq %r14, %rsi
callq 0x30c0
incq %r12
jmp 0x27951
movl (%rax), %edx
leaq 0x20c34(%rip), %rsi     # 0x485b1
movq %r14, %rdi
xorl %eax, %eax
callq 0x30e0
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x30c0
movzbl 0x1(%r15), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x279e6
pushq $0x9
popq %r12
movl %ebx, %r13d
subl $0x1, %r13d
jb 0x279bb
movl %r12d, %edi
movq %r14, %rsi
callq 0x30c0
jmp 0x279a8
leaq 0x2440b(%rip), %rdi     # 0x4bdcd
movq %r14, %rsi
callq 0x30b0
movq 0x68(%r15), %rdi
testq %rdi, %rdi
je 0x279db
movq %r14, %rsi
callq 0x31403
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x30c0
incl %ebx
xorl %r12d, %r12d
movslq 0x44(%r15), %rax
cmpq %rax, %r12
jge 0x27a0b
movq 0x48(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x278ce
incq %r12
jmp 0x279eb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x164e9(%rip), %rdi     # 0x3df0a
leaq 0x21748(%rip), %rsi     # 0x49170
leaq 0x20b32(%rip), %rcx     # 0x48561
movl $0x191c, %edx           # imm = 0x191C
callq 0x30a0
leaq 0x20b55(%rip), %rdi     # 0x48595
leaq 0x21729(%rip), %rsi     # 0x49170
leaq 0x20b13(%rip), %rcx     # 0x48561
movl $0x191e, %edx           # imm = 0x191E
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: be_sem_calc_type_size
size_t be_sem_calc_type_size(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserASTNode *node_type
) {
	assert(ctx);
	assert(node);
	assert(node_type);

	return _calc_type_size(ctx, node, node_type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x27a6e
testq %rsi, %rsi
je 0x27a8d
testq %rdx, %rdx
je 0x27aac
popq %rbp
jmp 0x27acb
leaq 0x1535f(%rip), %rdi     # 0x3cdd4
leaq 0x216f4(%rip), %rsi     # 0x49170
leaq 0x21765(%rip), %rcx     # 0x491e8
movl $0x1955, %edx           # imm = 0x1955
callq 0x30a0
leaq 0x16476(%rip), %rdi     # 0x3df0a
leaq 0x216d5(%rip), %rsi     # 0x49170
leaq 0x21746(%rip), %rcx     # 0x491e8
movl $0x1956, %edx           # imm = 0x1956
callq 0x30a0
leaq 0x23d36(%rip), %rdi     # 0x4b7e9
leaq 0x216b6(%rip), %rsi     # 0x49170
leaq 0x21727(%rip), %rcx     # 0x491e8
movl $0x1957, %edx           # imm = 0x1957
callq 0x30a0