LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: out_label
static void _out_label(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	const char *prefix,
	ParserASTNode *node_id
) {
	assert(ctx);
	assert(rstr);
	assert(node_id);

	ResizableString rstr_id;
	rstr_init_with_raw(&rstr_id, node_id->token->content, node_id->token->len);
	__out_label(ctx, rstr, prefix, RSTR_CSTR(&rstr_id));
	rstr_free(&rstr_id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x1e608
testq %rdx, %rdx
je 0x1e627
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdx), %rax
movq 0x8(%rax), %rsi
movl 0x4(%rax), %edx
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x74bc
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x22437(%rip), %rcx     # 0x40a1b
cmovneq %rax, %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1d4b9
movq %r15, %rdi
callq 0x7812
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20421(%rip), %rdi     # 0x3ea30
leaq 0x26052(%rip), %rsi     # 0x44668
leaq 0x26d02(%rip), %rcx     # 0x4531f
movl $0xead, %edx            # imm = 0xEAD
callq 0x30a0
leaq 0x231e8(%rip), %rdi     # 0x41816
leaq 0x26033(%rip), %rsi     # 0x44668
leaq 0x26ce3(%rip), %rcx     # 0x4531f
movl $0xeae, %edx            # imm = 0xEAE
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_jmp_x
static void _asm_inst_jmp_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	const char *target
) {
	assert(ctx);
	assert(rstr);
	assert(target);

	const char *mnemonic = "jmp";

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1e66d
movq %rsi, %rcx
testq %rsi, %rsi
je 0x1e68c
leaq 0x2301a(%rip), %rsi     # 0x41678
leaq 0x2324a(%rip), %rdx     # 0x418af
xorl %eax, %eax
popq %rbp
jmp 0x7905
leaq 0x203bc(%rip), %rdi     # 0x3ea30
leaq 0x25fed(%rip), %rsi     # 0x44668
leaq 0x26d3a(%rip), %rcx     # 0x453bc
movl $0x3d0, %edx            # imm = 0x3D0
callq 0x30a0
leaq 0x2a3ee(%rip), %rdi     # 0x48a81
leaq 0x25fce(%rip), %rsi     # 0x44668
leaq 0x26d1b(%rip), %rcx     # 0x453bc
movl $0x3d1, %edx            # imm = 0x3D1
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_cmp_x_x
static void _asm_inst_cmp_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, "cmp");
	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 0x1e74b
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1e76a
movq %rcx, %r14
testq %rcx, %rcx
je 0x1e789
movl %esi, %r13d
movq %rdi, %r15
leaq 0x233b0(%rip), %rsi     # 0x41a9a
leaq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0x7343
movzbl %r13b, %edi
callq 0x1dcf5
movsbl %al, %esi
movq %r12, %rdi
callq 0x749a
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x22302(%rip), %rdx     # 0x40a1b
cmovneq %rax, %rdx
leaq 0x228a3(%rip), %rsi     # 0x40fc7
movq %r15, %rdi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x7905
movq %r12, %rdi
callq 0x7812
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x202de(%rip), %rdi     # 0x3ea30
leaq 0x25f0f(%rip), %rsi     # 0x44668
leaq 0x26d54(%rip), %rcx     # 0x454b4
movl $0x40e, %edx            # imm = 0x40E
callq 0x30a0
leaq 0x2a310(%rip), %rdi     # 0x48a81
leaq 0x25ef0(%rip), %rsi     # 0x44668
leaq 0x26d35(%rip), %rcx     # 0x454b4
movl $0x40f, %edx            # imm = 0x40F
callq 0x30a0
leaq 0x2737a(%rip), %rdi     # 0x45b0a
leaq 0x25ed1(%rip), %rsi     # 0x44668
leaq 0x26d16(%rip), %rcx     # 0x454b4
movl $0x410, %edx            # imm = 0x410
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_movss_sym_x
static void _asm_inst_movss_sym_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	ParserSymbol *target,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);

	_asm_inst_movss_x_x(
		ctx,
		rstr,
		RSTR_CSTR(BE_VAR_SYMBOL_GET_CODE_GEN_NAME(target)),
		source
	);
}

// Assembly:
testq %rdi, %rdi
je 0x1e86f
movq 0x58(%rsi), %rax
testq %rax, %rax
leaq 0x221cc(%rip), %r8      # 0x40a1b
cmovneq %rax, %r8
leaq 0x2276d(%rip), %rsi     # 0x40fc7
leaq 0x238f7(%rip), %rdx     # 0x42158
leaq 0x23708(%rip), %rcx     # 0x41f70
xorl %eax, %eax
jmp 0x7905
pushq %rbp
movq %rsp, %rbp
leaq 0x201b6(%rip), %rdi     # 0x3ea30
leaq 0x25de7(%rip), %rsi     # 0x44668
leaq 0x26fe7(%rip), %rcx     # 0x4586f
movl $0x4c6, %edx            # imm = 0x4C6
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_movsd_sym_x
static void _asm_inst_movsd_sym_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	ParserSymbol *target,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);

	_asm_inst_movsd_x_x(
		ctx,
		rstr,
		RSTR_CSTR(BE_VAR_SYMBOL_GET_CODE_GEN_NAME(target)),
		source
	);
}

// Assembly:
testq %rdi, %rdi
je 0x1e959
movq 0x58(%rsi), %rax
testq %rax, %rax
leaq 0x220e2(%rip), %r8      # 0x40a1b
cmovneq %rax, %r8
leaq 0x22683(%rip), %rsi     # 0x40fc7
leaq 0x23958(%rip), %rdx     # 0x422a3
leaq 0x2361e(%rip), %rcx     # 0x41f70
xorl %eax, %eax
jmp 0x7905
pushq %rbp
movq %rsp, %rbp
leaq 0x200cc(%rip), %rdi     # 0x3ea30
leaq 0x25cfd(%rip), %rsi     # 0x44668
leaq 0x27039(%rip), %rcx     # 0x459ab
movl $0x506, %edx            # imm = 0x506
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_movsd_x_x
static void _asm_inst_movsd_x_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	const char *target,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);

	const char *mnemonic = "movsd";

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1ea37
movq %rsi, %r8
testq %rsi, %rsi
je 0x1ea56
movq %rdx, %rcx
testq %rdx, %rdx
je 0x1ea75
leaq 0x2259f(%rip), %rsi     # 0x40fc7
leaq 0x23874(%rip), %rdx     # 0x422a3
xorl %eax, %eax
popq %rbp
jmp 0x7905
leaq 0x1fff2(%rip), %rdi     # 0x3ea30
leaq 0x25c23(%rip), %rsi     # 0x44668
leaq 0x26fc7(%rip), %rcx     # 0x45a13
movl $0x4f0, %edx            # imm = 0x4F0
callq 0x30a0
leaq 0x2a024(%rip), %rdi     # 0x48a81
leaq 0x25c04(%rip), %rsi     # 0x44668
leaq 0x26fa8(%rip), %rcx     # 0x45a13
movl $0x4f1, %edx            # imm = 0x4F1
callq 0x30a0
leaq 0x2708e(%rip), %rdi     # 0x45b0a
leaq 0x25be5(%rip), %rsi     # 0x44668
leaq 0x26f89(%rip), %rcx     # 0x45a13
movl $0x4f2, %edx            # imm = 0x4F2
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: out_func_tmp_label
static void _out_func_tmp_label(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr
) {
	assert(ctx);
	assert(ctx->func_symbol);
	assert(rstr);

	size_t no = BE_FUNC_SYMBOL_NEXT_NO(ctx->func_symbol);
	ResizableString rstr_no;
	rstr_init(&rstr_no);
	rstr_appendf(&rstr_no, "%zu", no);

	__out_label(ctx, rstr, "FUNC_TMP", RSTR_CSTR(&rstr_no));

	rstr_free(&rstr_no);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x1eb54
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1eb73
movq %rdi, %r14
movl 0x54(%rax), %r15d
leal 0x1(%r15), %ecx
movl %ecx, 0x54(%rax)
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x7314
leaq 0x23db0(%rip), %rsi     # 0x428bd
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x7905
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x21ef2(%rip), %rcx     # 0x40a1b
cmovneq %rax, %rcx
leaq 0x23972(%rip), %rdx     # 0x424a6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d4b9
movq %r12, %rdi
callq 0x7812
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x21f63(%rip), %rdi     # 0x40abe
leaq 0x25b06(%rip), %rsi     # 0x44668
leaq 0x27098(%rip), %rcx     # 0x45c01
movl $0xebb, %edx            # imm = 0xEBB
callq 0x30a0
leaq 0x1feb6(%rip), %rdi     # 0x3ea30
leaq 0x25ae7(%rip), %rsi     # 0x44668
leaq 0x27079(%rip), %rcx     # 0x45c01
movl $0xebc, %edx            # imm = 0xEBC
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_shr_x
static void _asm_inst_shr_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, "shr");
	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 0x1ec00
movq %rdi, %rbx
leaq 0x239b2(%rip), %rsi     # 0x4255e
leaq -0x20(%rbp), %r14
movq %r14, %rdi
callq 0x7343
movq %r14, %rdi
movl $0x71, %esi
callq 0x749a
movq 0x8(%r14), %rax
testq %rax, %rax
leaq 0x21e48(%rip), %rdx     # 0x40a1b
cmovneq %rax, %rdx
leaq 0x22a9a(%rip), %rsi     # 0x41678
leaq 0x25f2d(%rip), %rcx     # 0x44b12
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7905
movq %r14, %rdi
callq 0x7812
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1fe29(%rip), %rdi     # 0x3ea30
leaq 0x25a5a(%rip), %rsi     # 0x44668
leaq 0x27085(%rip), %rcx     # 0x45c9a
movl $0x59f, %edx            # imm = 0x59F
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x1ec4d
movq %rsi, %rcx
testq %rsi, %rsi
je 0x1ec6c
leaq 0x22390(%rip), %rsi     # 0x40fc7
leaq 0x23a4f(%rip), %rdx     # 0x4268d
leaq 0x2332b(%rip), %r8      # 0x41f70
xorl %eax, %eax
popq %rbp
jmp 0x7905
leaq 0x1fddc(%rip), %rdi     # 0x3ea30
leaq 0x25a0d(%rip), %rsi     # 0x44668
leaq 0x27093(%rip), %rcx     # 0x45cf5
movl $0x5fe, %edx            # imm = 0x5FE
callq 0x30a0
leaq 0x26e97(%rip), %rdi     # 0x45b0a
leaq 0x259ee(%rip), %rsi     # 0x44668
leaq 0x27074(%rip), %rcx     # 0x45cf5
movl $0x600, %edx            # imm = 0x600
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x1f3b0
movq %rsi, %rcx
testq %rsi, %rsi
je 0x1f3cf
leaq 0x222d7(%rip), %rsi     # 0x41678
leaq 0x26f7a(%rip), %rdx     # 0x46322
xorl %eax, %eax
popq %rbp
jmp 0x7905
leaq 0x1f679(%rip), %rdi     # 0x3ea30
leaq 0x252aa(%rip), %rsi     # 0x44668
leaq 0x26f0a(%rip), %rcx     # 0x462cf
movl $0x631, %edx            # imm = 0x631
callq 0x30a0
leaq 0x2395e(%rip), %rdi     # 0x42d34
leaq 0x2528b(%rip), %rsi     # 0x44668
leaq 0x26eeb(%rip), %rcx     # 0x462cf
movl $0x632, %edx            # imm = 0x632
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x1f472
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1f491
movq %rdi, %r14
leaq 0x23a8a(%rip), %rsi     # 0x42ea0
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x7343
movq %r15, %rdi
movl $0x71, %esi
callq 0x749a
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x215de(%rip), %rdx     # 0x40a1b
cmovneq %rax, %rdx
leaq 0x23a5d(%rip), %rsi     # 0x42ea5
leaq 0x25c9f(%rip), %r8      # 0x450ee
movq %r14, %rdi
movq %rbx, %rcx
movq %r8, %r9
xorl %eax, %eax
callq 0x7905
movq %r15, %rdi
callq 0x7812
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f5b7(%rip), %rdi     # 0x3ea30
leaq 0x251e8(%rip), %rsi     # 0x44668
leaq 0x26f78(%rip), %rcx     # 0x463ff
movl $0x728, %edx            # imm = 0x728
callq 0x30a0
leaq 0x23a00(%rip), %rdi     # 0x42e98
leaq 0x251c9(%rip), %rsi     # 0x44668
leaq 0x26f59(%rip), %rcx     # 0x463ff
movl $0x72b, %edx            # imm = 0x72B
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x1f6d3
movq %rdi, %rbx
leaq 0x23df4(%rip), %rsi     # 0x43473
leaq -0x20(%rbp), %r14
movq %r14, %rdi
callq 0x7343
movq %r14, %rdi
movl $0x71, %esi
callq 0x749a
movq 0x8(%r14), %rax
testq %rax, %rax
leaq 0x21375(%rip), %rdx     # 0x40a1b
cmovneq %rax, %rdx
leaq 0x21fc7(%rip), %rsi     # 0x41678
leaq 0x25a36(%rip), %rcx     # 0x450ee
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7905
movq %r14, %rdi
callq 0x7812
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1f356(%rip), %rdi     # 0x3ea30
leaq 0x24f87(%rip), %rsi     # 0x44668
leaq 0x2715c(%rip), %rcx     # 0x46844
movl $0x7f4, %edx            # imm = 0x7F4
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x1f7d6
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1f7f5
movq %rcx, %r14
testq %rcx, %rcx
je 0x1f814
movl %esi, %r13d
movq %rdi, %r15
leaq 0x2889e(%rip), %rsi     # 0x48013
leaq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0x7343
movzbl %r13b, %edi
callq 0x1dcf5
movsbl %al, %esi
movq %r12, %rdi
callq 0x749a
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x21277(%rip), %rdx     # 0x40a1b
cmovneq %rax, %rdx
leaq 0x21818(%rip), %rsi     # 0x40fc7
movq %r15, %rdi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x7905
movq %r12, %rdi
callq 0x7812
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f253(%rip), %rdi     # 0x3ea30
leaq 0x24e84(%rip), %rsi     # 0x44668
leaq 0x272d0(%rip), %rcx     # 0x46abb
movl $0x950, %edx            # imm = 0x950
callq 0x30a0
leaq 0x29285(%rip), %rdi     # 0x48a81
leaq 0x24e65(%rip), %rsi     # 0x44668
leaq 0x272b1(%rip), %rcx     # 0x46abb
movl $0x951, %edx            # imm = 0x951
callq 0x30a0
leaq 0x262ef(%rip), %rdi     # 0x45b0a
leaq 0x24e46(%rip), %rsi     # 0x44668
leaq 0x27292(%rip), %rcx     # 0x46abb
movl $0x952, %edx            # imm = 0x952
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x1f8b4
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1f8d3
movq %rdi, %r14
leaq 0x287c1(%rip), %rsi     # 0x4801c
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x7343
movq %r15, %rdi
movl $0x71, %esi
callq 0x749a
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x21199(%rip), %rdx     # 0x40a1b
cmovneq %rax, %rdx
leaq 0x2173a(%rip), %rsi     # 0x40fc7
leaq 0x2527e(%rip), %r8      # 0x44b12
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x7905
movq %r15, %rdi
callq 0x7812
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f175(%rip), %rdi     # 0x3ea30
leaq 0x24da6(%rip), %rsi     # 0x44668
leaq 0x272de(%rip), %rcx     # 0x46ba7
movl $0x994, %edx            # imm = 0x994
callq 0x30a0
leaq 0x26230(%rip), %rdi     # 0x45b0a
leaq 0x24d87(%rip), %rsi     # 0x44668
leaq 0x272bf(%rip), %rcx     # 0x46ba7
movl $0x996, %edx            # imm = 0x996
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x1f921
movl (%rsi), %eax
cmpl $0xe00, %eax            # imm = 0xE00
je 0x1f919
cmpl $0x200, %eax            # imm = 0x200
jne 0x1f940
callq 0x1d5d1
movq %rax, %rsi
addq $0x30, %rsi
jmp 0x1f91d
addq $0x60, %rsi
movb (%rsi), %al
popq %rbp
retq
leaq 0x219e5(%rip), %rdi     # 0x4130d
leaq 0x24d39(%rip), %rsi     # 0x44668
leaq 0x27471(%rip), %rcx     # 0x46da7
movl $0xce2, %edx            # imm = 0xCE2
callq 0x30a0
leaq 0x1ea22(%rip), %rdi     # 0x3e369
leaq 0x24d1a(%rip), %rsi     # 0x44668
leaq 0x27452(%rip), %rcx     # 0x46da7
movl $0xcea, %edx            # imm = 0xCEA
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x1fcef
testq %rsi, %rsi
je 0x1fd0e
testl %edx, %edx
js 0x1fd2d
leaq 0x3a447(%rip), %rcx     # 0x5a130
popq %rbp
jmp 0x3eb8
leaq 0x1dd0c(%rip), %rdi     # 0x3da02
leaq 0x27973(%rip), %rsi     # 0x47670
leaq 0x27985(%rip), %rcx     # 0x47689
movl $0x170, %edx            # imm = 0x170
callq 0x30a0
leaq 0x25df5(%rip), %rdi     # 0x45b0a
leaq 0x27954(%rip), %rsi     # 0x47670
leaq 0x27966(%rip), %rcx     # 0x47689
movl $0x171, %edx            # imm = 0x171
callq 0x30a0
leaq 0x1d802(%rip), %rdi     # 0x3d536
leaq 0x27935(%rip), %rsi     # 0x47670
leaq 0x27947(%rip), %rcx     # 0x47689
movl $0x172, %edx            # imm = 0x172
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x1fdda
testq %rsi, %rsi
je 0x1fdf9
movl $0xfffff000, %eax       # imm = 0xFFFFF000
addl (%rsi), %eax
cmpl $0x3, %eax
ja 0x1fe18
leaq 0x278b3(%rip), %rcx     # 0x47650
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x9fd3
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa205
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa3a3
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa0f2
leaq 0x1ffd3(%rip), %rdi     # 0x3fdb4
leaq 0x27888(%rip), %rsi     # 0x47670
leaq 0x27909(%rip), %rcx     # 0x476f8
movl $0x183, %edx            # imm = 0x183
callq 0x30a0
leaq 0x1d6b6(%rip), %rdi     # 0x3d4b6
leaq 0x27869(%rip), %rsi     # 0x47670
leaq 0x278ea(%rip), %rcx     # 0x476f8
movl $0x184, %edx            # imm = 0x184
callq 0x30a0
leaq 0x1e54a(%rip), %rdi     # 0x3e369
leaq 0x2784a(%rip), %rsi     # 0x47670
leaq 0x278cb(%rip), %rcx     # 0x476f8
movl $0x194, %edx            # imm = 0x194
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x1fe99
testq %rsi, %rsi
je 0x1feb8
movl $0xfffff000, %eax       # imm = 0xFFFFF000
addl (%rsi), %eax
cmpl $0x3, %eax
ja 0x1fed7
leaq 0x27804(%rip), %rcx     # 0x47660
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x9f34
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa16d
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa280
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa04e
leaq 0x1ff14(%rip), %rdi     # 0x3fdb4
leaq 0x277c9(%rip), %rsi     # 0x47670
leaq 0x27889(%rip), %rcx     # 0x47737
movl $0x19f, %edx            # imm = 0x19F
callq 0x30a0
leaq 0x1d5f7(%rip), %rdi     # 0x3d4b6
leaq 0x277aa(%rip), %rsi     # 0x47670
leaq 0x2786a(%rip), %rcx     # 0x47737
movl $0x1a0, %edx            # imm = 0x1A0
callq 0x30a0
leaq 0x1e48b(%rip), %rdi     # 0x3e369
leaq 0x2778b(%rip), %rsi     # 0x47670
leaq 0x2784b(%rip), %rcx     # 0x47737
movl $0x1b0, %edx            # imm = 0x1B0
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x1ff19
testq %rsi, %rsi
je 0x1ff38
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x1ff57
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa52b
leaq 0x1fe94(%rip), %rdi     # 0x3fdb4
leaq 0x27749(%rip), %rsi     # 0x47670
leaq 0x27848(%rip), %rcx     # 0x47776
movl $0x1bb, %edx            # imm = 0x1BB
callq 0x30a0
leaq 0x1d577(%rip), %rdi     # 0x3d4b6
leaq 0x2772a(%rip), %rsi     # 0x47670
leaq 0x27829(%rip), %rcx     # 0x47776
movl $0x1bc, %edx            # imm = 0x1BC
callq 0x30a0
leaq 0x1e40b(%rip), %rdi     # 0x3e369
leaq 0x2770b(%rip), %rsi     # 0x47670
leaq 0x2780a(%rip), %rcx     # 0x47776
movl $0x1c1, %edx            # imm = 0x1C1
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x1ff99
testq %rsi, %rsi
je 0x1ffb8
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x1ffd7
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa41e
leaq 0x1fe14(%rip), %rdi     # 0x3fdb4
leaq 0x276c9(%rip), %rsi     # 0x47670
leaq 0x27803(%rip), %rcx     # 0x477b1
movl $0x1cb, %edx            # imm = 0x1CB
callq 0x30a0
leaq 0x1d4f7(%rip), %rdi     # 0x3d4b6
leaq 0x276aa(%rip), %rsi     # 0x47670
leaq 0x277e4(%rip), %rcx     # 0x477b1
movl $0x1cc, %edx            # imm = 0x1CC
callq 0x30a0
leaq 0x1e38b(%rip), %rdi     # 0x3e369
leaq 0x2768b(%rip), %rsi     # 0x47670
leaq 0x277c5(%rip), %rcx     # 0x477b1
movl $0x1d1, %edx            # imm = 0x1D1
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x20019
testq %rsi, %rsi
je 0x20038
cmpl $0x1005, (%rsi)         # imm = 0x1005
jne 0x20057
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x9dbf
leaq 0x1fd94(%rip), %rdi     # 0x3fdb4
leaq 0x27649(%rip), %rsi     # 0x47670
leaq 0x277c0(%rip), %rcx     # 0x477ee
movl $0x1db, %edx            # imm = 0x1DB
callq 0x30a0
leaq 0x1d477(%rip), %rdi     # 0x3d4b6
leaq 0x2762a(%rip), %rsi     # 0x47670
leaq 0x277a1(%rip), %rcx     # 0x477ee
movl $0x1dc, %edx            # imm = 0x1DC
callq 0x30a0
leaq 0x1e30b(%rip), %rdi     # 0x3e369
leaq 0x2760b(%rip), %rsi     # 0x47670
leaq 0x27782(%rip), %rcx     # 0x477ee
movl $0x1e1, %edx            # imm = 0x1E1
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x20121
testq %rsi, %rsi
je 0x20140
movl (%rsi), %eax
andl $-0x4, %eax
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x2015f
movq 0x8(%rsi), %rax
movslq 0x4(%rsi), %rcx
cmpb $0x75, -0x1(%rax,%rcx)
sete %al
popq %rbp
retq
leaq 0x1fc8c(%rip), %rdi     # 0x3fdb4
leaq 0x27541(%rip), %rsi     # 0x47670
leaq 0x27748(%rip), %rcx     # 0x4787e
movl $0x1f8, %edx            # imm = 0x1F8
callq 0x30a0
leaq 0x1d36f(%rip), %rdi     # 0x3d4b6
leaq 0x27522(%rip), %rsi     # 0x47670
leaq 0x27729(%rip), %rcx     # 0x4787e
movl $0x1f9, %edx            # imm = 0x1F9
callq 0x30a0
leaq 0x27757(%rip), %rdi     # 0x478bd
leaq 0x27503(%rip), %rsi     # 0x47670
leaq 0x2770a(%rip), %rcx     # 0x4787e
movl $0x1ff, %edx            # imm = 0x1FF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x201a6
testq %rsi, %rsi
je 0x201c5
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x201e4
movq 0x8(%rsi), %rax
movslq 0x4(%rsi), %rcx
cmpb $0x66, -0x1(%rax,%rcx)
sete %al
popq %rbp
retq
leaq 0x1fc07(%rip), %rdi     # 0x3fdb4
leaq 0x274bc(%rip), %rsi     # 0x47670
leaq 0x277af(%rip), %rcx     # 0x4796a
movl $0x208, %edx            # imm = 0x208
callq 0x30a0
leaq 0x1d2ea(%rip), %rdi     # 0x3d4b6
leaq 0x2749d(%rip), %rsi     # 0x47670
leaq 0x27790(%rip), %rcx     # 0x4796a
movl $0x209, %edx            # imm = 0x209
callq 0x30a0
leaq 0x277bb(%rip), %rdi     # 0x479a6
leaq 0x2747e(%rip), %rsi     # 0x47670
leaq 0x27771(%rip), %rcx     # 0x4796a
movl $0x20a, %edx            # imm = 0x20A
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x223e7
testq %rsi, %rsi
je 0x22406
testl %edx, %edx
js 0x22425
movl %ecx, %ebx
callq 0x1fcd0
movq %rax, %r14
movq %rax, %rdi
callq 0x47b7
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rdx
movaps %xmm0, (%rdx)
movl $0x10, %esi
movq %r14, %rdi
callq 0x60a8
movl %ebx, 0x30(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1b614(%rip), %rdi     # 0x3da02
leaq 0x26e33(%rip), %rsi     # 0x49228
leaq 0x26e46(%rip), %rcx     # 0x49242
movl $0x92a, %edx            # imm = 0x92A
callq 0x30a0
leaq 0x236fd(%rip), %rdi     # 0x45b0a
leaq 0x26e14(%rip), %rsi     # 0x49228
leaq 0x26e27(%rip), %rcx     # 0x49242
movl $0x92b, %edx            # imm = 0x92B
callq 0x30a0
leaq 0x1b10a(%rip), %rdi     # 0x3d536
leaq 0x26df5(%rip), %rsi     # 0x49228
leaq 0x26e08(%rip), %rcx     # 0x49242
movl $0x92c, %edx            # imm = 0x92C
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x22c62
testq %rsi, %rsi
je 0x22c81
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x22ca0
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1fd78
leaq 0x1d14b(%rip), %rdi     # 0x3fdb4
leaq 0x265b8(%rip), %rsi     # 0x49228
leaq 0x266ac(%rip), %rcx     # 0x49323
movl $0x976, %edx            # imm = 0x976
callq 0x30a0
leaq 0x1e283(%rip), %rdi     # 0x40f0b
leaq 0x26599(%rip), %rsi     # 0x49228
leaq 0x2668d(%rip), %rcx     # 0x49323
movl $0x977, %edx            # imm = 0x977
callq 0x30a0
leaq 0x266c0(%rip), %rdi     # 0x49367
leaq 0x2657a(%rip), %rsi     # 0x49228
leaq 0x2666e(%rip), %rcx     # 0x49323
movl $0x978, %edx            # imm = 0x978
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x22ce2
testq %rsi, %rsi
je 0x22d01
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x22d20
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1fe37
leaq 0x1d0cb(%rip), %rdi     # 0x3fdb4
leaq 0x26538(%rip), %rsi     # 0x49228
leaq 0x26693(%rip), %rcx     # 0x4938a
movl $0x981, %edx            # imm = 0x981
callq 0x30a0
leaq 0x1e203(%rip), %rdi     # 0x40f0b
leaq 0x26519(%rip), %rsi     # 0x49228
leaq 0x26674(%rip), %rcx     # 0x4938a
movl $0x982, %edx            # imm = 0x982
callq 0x30a0
leaq 0x26640(%rip), %rdi     # 0x49367
leaq 0x264fa(%rip), %rsi     # 0x49228
leaq 0x26655(%rip), %rcx     # 0x4938a
movl $0x983, %edx            # imm = 0x983
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x22d71
testq %rsi, %rsi
je 0x22d90
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x22daf
movl 0x30(%rdi), %eax
cmpl $0x2, %eax
je 0x22d6b
cmpl $0x1, %eax
jne 0x22dce
callq 0x22c3f
movl %eax, %eax
popq %rbp
retq
popq %rbp
jmp 0x22cbf
leaq 0x1d03c(%rip), %rdi     # 0x3fdb4
leaq 0x264a9(%rip), %rsi     # 0x49228
leaq 0x26648(%rip), %rcx     # 0x493ce
movl $0x98c, %edx            # imm = 0x98C
callq 0x30a0
leaq 0x1e174(%rip), %rdi     # 0x40f0b
leaq 0x2648a(%rip), %rsi     # 0x49228
leaq 0x26629(%rip), %rcx     # 0x493ce
movl $0x98d, %edx            # imm = 0x98D
callq 0x30a0
leaq 0x265b1(%rip), %rdi     # 0x49367
leaq 0x2646b(%rip), %rsi     # 0x49228
leaq 0x2660a(%rip), %rcx     # 0x493ce
movl $0x98e, %edx            # imm = 0x98E
callq 0x30a0
leaq 0x1b594(%rip), %rdi     # 0x3e369
leaq 0x2644c(%rip), %rsi     # 0x49228
leaq 0x265eb(%rip), %rcx     # 0x493ce
movl $0x996, %edx            # imm = 0x996
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x22e10
testq %rsi, %rsi
je 0x22e2f
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x22e4e
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1fef6
leaq 0x1cf9d(%rip), %rdi     # 0x3fdb4
leaq 0x2640a(%rip), %rsi     # 0x49228
leaq 0x265eb(%rip), %rcx     # 0x49410
movl $0x99e, %edx            # imm = 0x99E
callq 0x30a0
leaq 0x1e0d5(%rip), %rdi     # 0x40f0b
leaq 0x263eb(%rip), %rsi     # 0x49228
leaq 0x265cc(%rip), %rcx     # 0x49410
movl $0x99f, %edx            # imm = 0x99F
callq 0x30a0
leaq 0x265fb(%rip), %rdi     # 0x49450
leaq 0x263cc(%rip), %rsi     # 0x49228
leaq 0x265ad(%rip), %rcx     # 0x49410
movl $0x9a0, %edx            # imm = 0x9A0
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x22e90
testq %rsi, %rsi
je 0x22eaf
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x22ece
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1ff76
leaq 0x1cf1d(%rip), %rdi     # 0x3fdb4
leaq 0x2638a(%rip), %rsi     # 0x49228
leaq 0x265ce(%rip), %rcx     # 0x49473
movl $0x9a9, %edx            # imm = 0x9A9
callq 0x30a0
leaq 0x1e055(%rip), %rdi     # 0x40f0b
leaq 0x2636b(%rip), %rsi     # 0x49228
leaq 0x265af(%rip), %rcx     # 0x49473
movl $0x9aa, %edx            # imm = 0x9AA
callq 0x30a0
leaq 0x2657b(%rip), %rdi     # 0x49450
leaq 0x2634c(%rip), %rsi     # 0x49228
leaq 0x26590(%rip), %rcx     # 0x49473
movl $0x9ab, %edx            # imm = 0x9AB
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x22f10
testq %rsi, %rsi
je 0x22f2f
cmpl $0x302, (%rsi)          # imm = 0x302
jne 0x22f4e
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1fff6
leaq 0x1ce9d(%rip), %rdi     # 0x3fdb4
leaq 0x2630a(%rip), %rsi     # 0x49228
leaq 0x26590(%rip), %rcx     # 0x494b5
movl $0x9b4, %edx            # imm = 0x9B4
callq 0x30a0
leaq 0x1dfd5(%rip), %rdi     # 0x40f0b
leaq 0x262eb(%rip), %rsi     # 0x49228
leaq 0x26571(%rip), %rcx     # 0x494b5
movl $0x9b5, %edx            # imm = 0x9B5
callq 0x30a0
leaq 0x2659e(%rip), %rdi     # 0x494f3
leaq 0x262cc(%rip), %rsi     # 0x49228
leaq 0x26552(%rip), %rcx     # 0x494b5
movl $0x9b6, %edx            # imm = 0x9B6
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x23030
testq %rsi, %rsi
je 0x2304f
movq %rdx, %rax
testq %rdx, %rdx
je 0x2306e
testb %cl, %cl
je 0x2308d
testq %r8, %r8
je 0x230ac
leaq -0x50(%rbp), %r10
movb %cl, (%r10)
movq %r8, 0x8(%r10)
movq $0x0, 0x10(%r10)
xorl %ecx, %ecx
movb %cl, 0x18(%r10)
movl $0x1, 0x30(%r10)
movq $-0x1, 0x38(%r10)
movq %r9, 0x40(%r10)
movb %cl, 0x48(%r10)
movl $0x50, %r8d
movl $0x1, %edx
movq %rax, %rcx
movq %r10, %r9
callq 0x6cf0
leaq -0xb9(%rip), %rcx       # 0x22f6d
movq %rcx, 0x20(%rax)
addq $0x50, %rsp
popq %rbp
retq
leaq 0x1cd7d(%rip), %rdi     # 0x3fdb4
leaq 0x261ea(%rip), %rsi     # 0x49228
leaq 0x264fb(%rip), %rcx     # 0x49540
movl $0x9ce, %edx            # imm = 0x9CE
callq 0x30a0
leaq 0x1deb5(%rip), %rdi     # 0x40f0b
leaq 0x261cb(%rip), %rsi     # 0x49228
leaq 0x264dc(%rip), %rcx     # 0x49540
movl $0x9cf, %edx            # imm = 0x9CF
callq 0x30a0
leaq 0x1a441(%rip), %rdi     # 0x3d4b6
leaq 0x261ac(%rip), %rsi     # 0x49228
leaq 0x264bd(%rip), %rcx     # 0x49540
movl $0x9d0, %edx            # imm = 0x9D0
callq 0x30a0
leaq 0x2652d(%rip), %rdi     # 0x495c1
leaq 0x2618d(%rip), %rsi     # 0x49228
leaq 0x2649e(%rip), %rcx     # 0x49540
movl $0x9d1, %edx            # imm = 0x9D1
callq 0x30a0
leaq 0x2651b(%rip), %rdi     # 0x495ce
leaq 0x2616e(%rip), %rsi     # 0x49228
leaq 0x2647f(%rip), %rcx     # 0x49540
movl $0x9d2, %edx            # imm = 0x9D2
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x23121
testq %rsi, %rsi
je 0x23140
movq %rdx, %rax
testq %rdx, %rdx
je 0x2315f
testb %cl, %cl
je 0x2317e
testq %r8, %r8
je 0x2319d
leaq -0x18(%rbp), %r10
movb %cl, (%r10)
movq %r8, 0x8(%r10)
movq %r9, 0x10(%r10)
movl $0x18, %r8d
movl $0x5, %edx
movq %rax, %rcx
movq %r10, %r9
callq 0x7029
addq $0x20, %rsp
popq %rbp
retq
leaq 0x1cc8c(%rip), %rdi     # 0x3fdb4
leaq 0x260f9(%rip), %rsi     # 0x49228
leaq 0x264a6(%rip), %rcx     # 0x495dc
movl $0x9f5, %edx            # imm = 0x9F5
callq 0x30a0
leaq 0x1d981(%rip), %rdi     # 0x40ac8
leaq 0x260da(%rip), %rsi     # 0x49228
leaq 0x26487(%rip), %rcx     # 0x495dc
movl $0x9f6, %edx            # imm = 0x9F6
callq 0x30a0
leaq 0x1a350(%rip), %rdi     # 0x3d4b6
leaq 0x260bb(%rip), %rsi     # 0x49228
leaq 0x26468(%rip), %rcx     # 0x495dc
movl $0x9f7, %edx            # imm = 0x9F7
callq 0x30a0
leaq 0x2643c(%rip), %rdi     # 0x495c1
leaq 0x2609c(%rip), %rsi     # 0x49228
leaq 0x26449(%rip), %rcx     # 0x495dc
movl $0x9f8, %edx            # imm = 0x9F8
callq 0x30a0
leaq 0x2642a(%rip), %rdi     # 0x495ce
leaq 0x2607d(%rip), %rsi     # 0x49228
leaq 0x2642a(%rip), %rcx     # 0x495dc
movl $0x9f9, %edx            # imm = 0x9F9
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x23200
movq %rsi, %rax
testq %rsi, %rsi
je 0x2321f
testq %rcx, %rcx
je 0x2323e
leaq -0x18(%rbp), %r9
movq %rdx, (%r9)
movq %rcx, 0x8(%r9)
movb %r8b, 0x10(%r9)
movl $0x18, %ecx
movl $0x2, %esi
movq %rax, %rdx
movq %r9, %r8
callq 0x69bb
addq $0x20, %rsp
popq %rbp
retq
leaq 0x1cbad(%rip), %rdi     # 0x3fdb4
leaq 0x2601a(%rip), %rsi     # 0x49228
leaq 0x26457(%rip), %rcx     # 0x4966c
movl $0xa11, %edx            # imm = 0xA11
callq 0x30a0
leaq 0x1a290(%rip), %rdi     # 0x3d4b6
leaq 0x25ffb(%rip), %rsi     # 0x49228
leaq 0x26438(%rip), %rcx     # 0x4966c
movl $0xa12, %edx            # imm = 0xA12
callq 0x30a0
leaq 0x294d0(%rip), %rdi     # 0x4c715
leaq 0x25fdc(%rip), %rsi     # 0x49228
leaq 0x26419(%rip), %rcx     # 0x4966c
movl $0xa13, %edx            # imm = 0xA13
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x232a5
testq %rsi, %rsi
je 0x232c4
movq %rdx, %rax
testq %rdx, %rdx
je 0x232e3
testq %rcx, %rcx
je 0x23302
leaq -0x18(%rbp), %r9
movq %rcx, 0x8(%r9)
movb %r8b, 0x10(%r9)
movl $0x18, %r8d
movl $0x2, %edx
movq %rax, %rcx
callq 0x6cf0
addq $0x20, %rsp
popq %rbp
retq
leaq 0x1cb08(%rip), %rdi     # 0x3fdb4
leaq 0x25f75(%rip), %rsi     # 0x49228
leaq 0x26424(%rip), %rcx     # 0x496de
movl $0xa2a, %edx            # imm = 0xA2A
callq 0x30a0
leaq 0x1dc40(%rip), %rdi     # 0x40f0b
leaq 0x25f56(%rip), %rsi     # 0x49228
leaq 0x26405(%rip), %rcx     # 0x496de
movl $0xa2b, %edx            # imm = 0xA2B
callq 0x30a0
leaq 0x1a1cc(%rip), %rdi     # 0x3d4b6
leaq 0x25f37(%rip), %rsi     # 0x49228
leaq 0x263e6(%rip), %rcx     # 0x496de
movl $0xa2c, %edx            # imm = 0xA2C
callq 0x30a0
leaq 0x2940c(%rip), %rdi     # 0x4c715
leaq 0x25f18(%rip), %rsi     # 0x49228
leaq 0x263c7(%rip), %rcx     # 0x496de
movl $0xa2d, %edx            # imm = 0xA2D
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x2341d
movq %rsi, %r14
testq %rsi, %rsi
je 0x2343c
testq %rdx, %rdx
je 0x2345b
movq %rcx, %r13
movq %rdx, -0x30(%rbp)
testq %rcx, %rcx
je 0x2347a
movq %r8, %r12
movq %rdi, %r15
movq %r13, -0x60(%rbp)
movq %r8, -0x58(%rbp)
movb %r9b, -0x40(%rbp)
movl $0x0, -0x3c(%rbp)
leaq 0x2646d(%rip), %rdx     # 0x497ed
movl $0x430, %esi            # imm = 0x430
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x65b1
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x688f
testq %r12, %r12
je 0x233b6
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x688f
leaq -0x60(%rbp), %r12
movq %rbx, 0x10(%r12)
leaq 0x20220(%rip), %rdx     # 0x435e6
movq %r15, %rdi
movl $0x440, %esi            # imm = 0x440
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x65b1
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x688f
movq %r13, 0x18(%r12)
movl $0x30, %r8d
movq %r15, %rdi
movq %r14, %rsi
movl $0x3, %edx
movq -0x30(%rbp), %rcx
movq %r12, %r9
callq 0x6cf0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c990(%rip), %rdi     # 0x3fdb4
leaq 0x25dfd(%rip), %rsi     # 0x49228
leaq 0x26326(%rip), %rcx     # 0x49758
movl $0xa45, %edx            # imm = 0xA45
callq 0x30a0
leaq 0x1dac8(%rip), %rdi     # 0x40f0b
leaq 0x25dde(%rip), %rsi     # 0x49228
leaq 0x26307(%rip), %rcx     # 0x49758
movl $0xa46, %edx            # imm = 0xA46
callq 0x30a0
leaq 0x1a054(%rip), %rdi     # 0x3d4b6
leaq 0x25dbf(%rip), %rsi     # 0x49228
leaq 0x262e8(%rip), %rcx     # 0x49758
movl $0xa47, %edx            # imm = 0xA47
callq 0x30a0
leaq 0x26360(%rip), %rdi     # 0x497e1
leaq 0x25da0(%rip), %rsi     # 0x49228
leaq 0x262c9(%rip), %rcx     # 0x49758
movl $0xa48, %edx            # imm = 0xA48
callq 0x30a0