LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_movsx_x_x
static void _asm_inst_movsx_x_x(
	ASMGeneratorGas32Context *ctx,
	ResizableString *rstr,
	uint8_t target_type,
	const char *target,
	uint8_t source_type,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);

	ResizableString rstr_mnemonic;
	rstr_init_with_cstr(&rstr_mnemonic, "movs");
	rstr_append_with_char(
		&rstr_mnemonic,
		_asm_inst_type_suffix(ctx, source_type)
	);
	rstr_append_with_char(
		&rstr_mnemonic,
		_asm_inst_type_suffix(ctx, target_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 0x15cdb
movq %rdx, %r14
testq %rdx, %rdx
je 0x15cfa
movq %r8, %rbx
testq %r8, %r8
je 0x15d19
movl %ecx, %r13d
movl %esi, %r12d
movq %rdi, %r15
leaq 0x2c29a(%rip), %rsi     # 0x41eb4
leaq -0x38(%rbp), %rdi
callq 0x7343
decb %r13b
cmpb $0x10, %r13b
jae 0x15cbc
movzbl %r13b, %eax
movl $0x87ff, %ecx           # imm = 0x87FF
btl %eax, %ecx
jae 0x15cbc
leaq 0x2a54b(%rip), %r13     # 0x40190
movsbl (%rax,%r13), %esi
leaq -0x38(%rbp), %rdi
callq 0x749a
decb %r12b
cmpb $0x10, %r12b
jae 0x15cbc
movzbl %r12b, %eax
movl $0x87ff, %ecx           # imm = 0x87FF
btl %eax, %ecx
jae 0x15cbc
movsbl (%rax,%r13), %esi
leaq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0x749a
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x2ad91(%rip), %rdx     # 0x40a1b
cmovneq %rax, %rdx
leaq 0x2b332(%rip), %rsi     # 0x40fc7
movq %r15, %rdi
movq %rbx, %rcx
movq %r14, %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 0x286a6(%rip), %rdi     # 0x3e369
leaq 0x2a76e(%rip), %rsi     # 0x40438
leaq 0x2b2b6(%rip), %rcx     # 0x40f87
movl $0x147, %edx            # imm = 0x147
callq 0x30a0
leaq 0x28d4e(%rip), %rdi     # 0x3ea30
leaq 0x2a74f(%rip), %rsi     # 0x40438
leaq 0x2c14e(%rip), %rcx     # 0x41e3e
movl $0x48f, %edx            # imm = 0x48F
callq 0x30a0
leaq 0x32d80(%rip), %rdi     # 0x48a81
leaq 0x2a730(%rip), %rsi     # 0x40438
leaq 0x2c12f(%rip), %rcx     # 0x41e3e
movl $0x490, %edx            # imm = 0x490
callq 0x30a0
leaq 0x2fdea(%rip), %rdi     # 0x45b0a
leaq 0x2a711(%rip), %rsi     # 0x40438
leaq 0x2c110(%rip), %rcx     # 0x41e3e
movl $0x491, %edx            # imm = 0x491
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_xor_x_x
static void _asm_inst_xor_x_x(
	ASMGeneratorGas32Context *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 %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x15eb1
movq %rsi, %rbx
testq %rsi, %rsi
je 0x15ed0
movq %rdx, %r14
testq %rdx, %rdx
je 0x15eef
movq %rdi, %r15
leaq 0x321c3(%rip), %rsi     # 0x4801c
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x7343
movq %r12, %rdi
movl $0x6c, %esi
callq 0x749a
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x2ab9a(%rip), %rdx     # 0x40a1b
cmovneq %rax, %rdx
leaq 0x2b13b(%rip), %rsi     # 0x40fc7
movq %r15, %rdi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x7905
movq %r12, %rdi
callq 0x7812
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28b78(%rip), %rdi     # 0x3ea30
leaq 0x2a579(%rip), %rsi     # 0x40438
leaq 0x2c0b3(%rip), %rcx     # 0x41f79
movl $0x899, %edx            # imm = 0x899
callq 0x30a0
leaq 0x32baa(%rip), %rdi     # 0x48a81
leaq 0x2a55a(%rip), %rsi     # 0x40438
leaq 0x2c094(%rip), %rcx     # 0x41f79
movl $0x89a, %edx            # imm = 0x89A
callq 0x30a0
leaq 0x2fc14(%rip), %rdi     # 0x45b0a
leaq 0x2a53b(%rip), %rsi     # 0x40438
leaq 0x2c075(%rip), %rcx     # 0x41f79
movl $0x89b, %edx            # imm = 0x89B
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_cvtsi2ss_x_x
static void _asm_inst_cvtsi2ss_x_x(
	ASMGeneratorGas32Context *ctx,
	ResizableString *rstr,
	uint8_t type,
	const char *target,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(type == BE_TYPE_INT32 || type == BE_TYPE_INT64);
	assert(target);
	assert(source);

	ResizableString rstr_mnemonic;
	rstr_init_with_cstr(&rstr_mnemonic, "cvtsi2ss");
	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 0x15f9d
andb $-0x2, %sil
cmpb $0x4, %sil
jne 0x15fbc
movq %rdx, %rbx
testq %rdx, %rdx
je 0x15fdb
movq %rdi, %r14
leaq 0x2c13f(%rip), %rsi     # 0x42083
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x7343
movq %r15, %rdi
movl $0x6c, %esi
callq 0x749a
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x2aab0(%rip), %rdx     # 0x40a1b
cmovneq %rax, %rdx
leaq 0x2b051(%rip), %rsi     # 0x40fc7
leaq 0x2bff3(%rip), %r8      # 0x41f70
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 0x28a8c(%rip), %rdi     # 0x3ea30
leaq 0x2a48d(%rip), %rsi     # 0x40438
leaq 0x2c032(%rip), %rcx     # 0x41fe4
movl $0x4dc, %edx            # imm = 0x4DC
callq 0x30a0
leaq 0x2c091(%rip), %rdi     # 0x42054
leaq 0x2a46e(%rip), %rsi     # 0x40438
leaq 0x2c013(%rip), %rcx     # 0x41fe4
movl $0x4dd, %edx            # imm = 0x4DD
callq 0x30a0
leaq 0x2fb28(%rip), %rdi     # 0x45b0a
leaq 0x2a44f(%rip), %rsi     # 0x40438
leaq 0x2bff4(%rip), %rcx     # 0x41fe4
movl $0x4df, %edx            # imm = 0x4DF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_movss_sym_x
static void _asm_inst_movss_sym_x(
	ASMGeneratorGas32Context *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:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x16037
testq %rsi, %rsi
je 0x16056
movq 0x58(%rsi), %rax
testq %rax, %rax
leaq 0x2aa05(%rip), %r8      # 0x40a1b
cmovneq %rax, %r8
leaq 0x2afa6(%rip), %rsi     # 0x40fc7
leaq 0x2c130(%rip), %rdx     # 0x42158
leaq 0x2bf41(%rip), %rcx     # 0x41f70
xorl %eax, %eax
popq %rbp
jmp 0x7905
leaq 0x289f2(%rip), %rdi     # 0x3ea30
leaq 0x2a3f3(%rip), %rsi     # 0x40438
leaq 0x2c040(%rip), %rcx     # 0x4208c
movl $0x537, %edx            # imm = 0x537
callq 0x30a0
leaq 0x32a24(%rip), %rdi     # 0x48a81
leaq 0x2a3d4(%rip), %rsi     # 0x40438
leaq 0x2c021(%rip), %rcx     # 0x4208c
movl $0x538, %edx            # imm = 0x538
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_cvtsi2sd_x_x
static void _asm_inst_cvtsi2sd_x_x(
	ASMGeneratorGas32Context *ctx,
	ResizableString *rstr,
	uint8_t type,
	const char *target,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(type == BE_TYPE_INT32 || type == BE_TYPE_INT64);
	assert(target);
	assert(source);

	ResizableString rstr_mnemonic;
	rstr_init_with_cstr(&rstr_mnemonic, "cvtsi2sd");
	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 0x16104
andb $-0x2, %sil
cmpb $0x4, %sil
jne 0x16123
movq %rdx, %rbx
testq %rdx, %rdx
je 0x16142
movq %rdi, %r14
leaq 0x2c123(%rip), %rsi     # 0x421ce
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x7343
movq %r15, %rdi
movl $0x6c, %esi
callq 0x749a
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x2a949(%rip), %rdx     # 0x40a1b
cmovneq %rax, %rdx
leaq 0x2aeea(%rip), %rsi     # 0x40fc7
leaq 0x2be8c(%rip), %r8      # 0x41f70
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 0x28925(%rip), %rdi     # 0x3ea30
leaq 0x2a326(%rip), %rsi     # 0x40438
leaq 0x2c045(%rip), %rcx     # 0x4215e
movl $0x4ff, %edx            # imm = 0x4FF
callq 0x30a0
leaq 0x2bf2a(%rip), %rdi     # 0x42054
leaq 0x2a307(%rip), %rsi     # 0x40438
leaq 0x2c026(%rip), %rcx     # 0x4215e
movl $0x500, %edx            # imm = 0x500
callq 0x30a0
leaq 0x2f9c1(%rip), %rdi     # 0x45b0a
leaq 0x2a2e8(%rip), %rsi     # 0x40438
leaq 0x2c007(%rip), %rcx     # 0x4215e
movl $0x502, %edx            # imm = 0x502
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_movsd_sym_x
static void _asm_inst_movsd_sym_x(
	ASMGeneratorGas32Context *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:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1619e
testq %rsi, %rsi
je 0x161bd
movq 0x58(%rsi), %rax
testq %rax, %rax
leaq 0x2a89e(%rip), %r8      # 0x40a1b
cmovneq %rax, %r8
leaq 0x2ae3f(%rip), %rsi     # 0x40fc7
leaq 0x2c114(%rip), %rdx     # 0x422a3
leaq 0x2bdda(%rip), %rcx     # 0x41f70
xorl %eax, %eax
popq %rbp
jmp 0x7905
leaq 0x2888b(%rip), %rdi     # 0x3ea30
leaq 0x2a28c(%rip), %rsi     # 0x40438
leaq 0x2c024(%rip), %rcx     # 0x421d7
movl $0x577, %edx            # imm = 0x577
callq 0x30a0
leaq 0x328bd(%rip), %rdi     # 0x48a81
leaq 0x2a26d(%rip), %rsi     # 0x40438
leaq 0x2c005(%rip), %rcx     # 0x421d7
movl $0x578, %edx            # imm = 0x578
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_movss_x_x
static void _asm_inst_movss_x_x(
	ASMGeneratorGas32Context *ctx,
	ResizableString *rstr,
	const char *target,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);

	const char *mnemonic = "movss";

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1620b
movq %rsi, %r8
testq %rsi, %rsi
je 0x1622a
movq %rdx, %rcx
testq %rdx, %rdx
je 0x16249
leaq 0x2adcb(%rip), %rsi     # 0x40fc7
leaq 0x2bf55(%rip), %rdx     # 0x42158
xorl %eax, %eax
popq %rbp
jmp 0x7905
leaq 0x2881e(%rip), %rdi     # 0x3ea30
leaq 0x2a21f(%rip), %rsi     # 0x40438
leaq 0x2bed4(%rip), %rcx     # 0x420f4
movl $0x521, %edx            # imm = 0x521
callq 0x30a0
leaq 0x32850(%rip), %rdi     # 0x48a81
leaq 0x2a200(%rip), %rsi     # 0x40438
leaq 0x2beb5(%rip), %rcx     # 0x420f4
movl $0x522, %edx            # imm = 0x522
callq 0x30a0
leaq 0x2f8ba(%rip), %rdi     # 0x45b0a
leaq 0x2a1e1(%rip), %rsi     # 0x40438
leaq 0x2be96(%rip), %rcx     # 0x420f4
movl $0x523, %edx            # imm = 0x523
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_movsd_x_x
static void _asm_inst_movsd_x_x(
	ASMGeneratorGas32Context *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 0x16297
movq %rsi, %r8
testq %rsi, %rsi
je 0x162b6
movq %rdx, %rcx
testq %rdx, %rdx
je 0x162d5
leaq 0x2ad3f(%rip), %rsi     # 0x40fc7
leaq 0x2c014(%rip), %rdx     # 0x422a3
xorl %eax, %eax
popq %rbp
jmp 0x7905
leaq 0x28792(%rip), %rdi     # 0x3ea30
leaq 0x2a193(%rip), %rsi     # 0x40438
leaq 0x2bf93(%rip), %rcx     # 0x4223f
movl $0x561, %edx            # imm = 0x561
callq 0x30a0
leaq 0x327c4(%rip), %rdi     # 0x48a81
leaq 0x2a174(%rip), %rsi     # 0x40438
leaq 0x2bf74(%rip), %rcx     # 0x4223f
movl $0x562, %edx            # imm = 0x562
callq 0x30a0
leaq 0x2f82e(%rip), %rdi     # 0x45b0a
leaq 0x2a155(%rip), %rsi     # 0x40438
leaq 0x2bf55(%rip), %rcx     # 0x4223f
movl $0x563, %edx            # imm = 0x563
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_test_x_x
static void _asm_inst_test_x_x(
	ASMGeneratorGas32Context *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, "test");
	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 %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x163c6
movq %rdx, %rbx
testq %rdx, %rdx
je 0x163e5
movq %rcx, %r14
testq %rcx, %rcx
je 0x16404
movl %esi, %r12d
movq %rdi, %r15
leaq 0x2c128(%rip), %rsi     # 0x42459
leaq -0x30(%rbp), %rdi
callq 0x7343
decb %r12b
cmpb $0x10, %r12b
jae 0x163a7
movzbl %r12b, %eax
movl $0x87ff, %ecx           # imm = 0x87FF
btl %eax, %ecx
jae 0x163a7
leaq 0x29e38(%rip), %rcx     # 0x40190
movsbl (%rax,%rcx), %esi
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x749a
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x2a6a4(%rip), %rdx     # 0x40a1b
cmovneq %rax, %rdx
leaq 0x2ac45(%rip), %rsi     # 0x40fc7
movq %r15, %rdi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x7905
movq %r12, %rdi
callq 0x7812
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x27fbb(%rip), %rdi     # 0x3e369
leaq 0x2a083(%rip), %rsi     # 0x40438
leaq 0x2abcb(%rip), %rcx     # 0x40f87
movl $0x147, %edx            # imm = 0x147
callq 0x30a0
leaq 0x28663(%rip), %rdi     # 0x3ea30
leaq 0x2a064(%rip), %rsi     # 0x40438
leaq 0x2c012(%rip), %rcx     # 0x423ed
movl $0x689, %edx            # imm = 0x689
callq 0x30a0
leaq 0x32695(%rip), %rdi     # 0x48a81
leaq 0x2a045(%rip), %rsi     # 0x40438
leaq 0x2bff3(%rip), %rcx     # 0x423ed
movl $0x68a, %edx            # imm = 0x68A
callq 0x30a0
leaq 0x2f6ff(%rip), %rdi     # 0x45b0a
leaq 0x2a026(%rip), %rsi     # 0x40438
leaq 0x2bfd4(%rip), %rcx     # 0x423ed
movl $0x68b, %edx            # imm = 0x68B
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: out_func_tmp_label
static void _out_func_tmp_label(
	ASMGeneratorGas32Context *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 0x164af
movq %rsi, %rbx
testq %rsi, %rsi
je 0x164ce
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 0x2c455(%rip), %rsi     # 0x428bd
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x7905
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x2a597(%rip), %rcx     # 0x40a1b
cmovneq %rax, %rcx
leaq 0x2c017(%rip), %rdx     # 0x424a6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14137
movq %r12, %rdi
callq 0x7812
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a608(%rip), %rdi     # 0x40abe
leaq 0x29f7b(%rip), %rsi     # 0x40438
leaq 0x2bf9a(%rip), %rcx     # 0x4245e
movl $0x280, %edx            # imm = 0x280
callq 0x30a0
leaq 0x2855b(%rip), %rdi     # 0x3ea30
leaq 0x29f5c(%rip), %rsi     # 0x40438
leaq 0x2bf7b(%rip), %rcx     # 0x4245e
movl $0x281, %edx            # imm = 0x281
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_addss_x_x
static void _asm_inst_addss_x_x(
	ASMGeneratorGas32Context *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 0x166fe
movq %rsi, %rcx
testq %rsi, %rsi
je 0x1671d
leaq 0x2a8df(%rip), %rsi     # 0x40fc7
leaq 0x2bf9e(%rip), %rdx     # 0x4268d
leaq 0x2b87a(%rip), %r8      # 0x41f70
xorl %eax, %eax
popq %rbp
jmp 0x7905
leaq 0x2832b(%rip), %rdi     # 0x3ea30
leaq 0x29d2c(%rip), %rsi     # 0x40438
leaq 0x2bf16(%rip), %rcx     # 0x42629
movl $0x6aa, %edx            # imm = 0x6AA
callq 0x30a0
leaq 0x2f3e6(%rip), %rdi     # 0x45b0a
leaq 0x29d0d(%rip), %rsi     # 0x40438
leaq 0x2bef7(%rip), %rcx     # 0x42629
movl $0x6ac, %edx            # imm = 0x6AC
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_addsd_x_x
static void _asm_inst_addsd_x_x(
	ASMGeneratorGas32Context *ctx,
	ResizableString *rstr,
	const char *target,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);

	const char *mnemonic = "addsd";

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1676a
movq %rsi, %rcx
testq %rsi, %rsi
je 0x16789
leaq 0x2a873(%rip), %rsi     # 0x40fc7
leaq 0x2bf9c(%rip), %rdx     # 0x426f7
leaq 0x2b80e(%rip), %r8      # 0x41f70
xorl %eax, %eax
popq %rbp
jmp 0x7905
leaq 0x282bf(%rip), %rdi     # 0x3ea30
leaq 0x29cc0(%rip), %rsi     # 0x40438
leaq 0x2bf14(%rip), %rcx     # 0x42693
movl $0x6c4, %edx            # imm = 0x6C4
callq 0x30a0
leaq 0x2f37a(%rip), %rdi     # 0x45b0a
leaq 0x29ca1(%rip), %rsi     # 0x40438
leaq 0x2bef5(%rip), %rcx     # 0x42693
movl $0x6c6, %edx            # imm = 0x6C6
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_call_x
static void _asm_inst_call_x(
	ASMGeneratorGas32Context *ctx,
	ResizableString *rstr,
	const char *func
) {
	assert(ctx);
	assert(rstr);
	assert(func);

	const char *mnemonic = "calll";

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x16fb5
movq %rsi, %rcx
testq %rsi, %rsi
je 0x16fd4
leaq 0x2a6d2(%rip), %rsi     # 0x41678
leaq 0x2bd8c(%rip), %rdx     # 0x42d39
xorl %eax, %eax
popq %rbp
jmp 0x7905
leaq 0x27a74(%rip), %rdi     # 0x3ea30
leaq 0x29475(%rip), %rsi     # 0x40438
leaq 0x2bd17(%rip), %rcx     # 0x42ce1
movl $0x6dd, %edx            # imm = 0x6DD
callq 0x30a0
leaq 0x2bd59(%rip), %rdi     # 0x42d34
leaq 0x29456(%rip), %rsi     # 0x40438
leaq 0x2bcf8(%rip), %rcx     # 0x42ce1
movl $0x6de, %edx            # imm = 0x6DE
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_imul_x_x_x
static void _asm_inst_imul_x_x_x(
	ASMGeneratorGas32Context *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 0x17077
movq %rsi, %rbx
testq %rsi, %rsi
je 0x17096
movq %rdi, %r14
leaq 0x2be85(%rip), %rsi     # 0x42ea0
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x7343
movq %r15, %rdi
movl $0x6c, %esi
callq 0x749a
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x299d9(%rip), %rdx     # 0x40a1b
cmovneq %rax, %rdx
leaq 0x2be58(%rip), %rsi     # 0x42ea5
leaq 0x29d45(%rip), %r8      # 0x40d99
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 0x279b2(%rip), %rdi     # 0x3ea30
leaq 0x293b3(%rip), %rsi     # 0x40438
leaq 0x2bd90(%rip), %rcx     # 0x42e1c
movl $0x986, %edx            # imm = 0x986
callq 0x30a0
leaq 0x2bdfb(%rip), %rdi     # 0x42e98
leaq 0x29394(%rip), %rsi     # 0x40438
leaq 0x2bd71(%rip), %rcx     # 0x42e1c
movl $0x989, %edx            # imm = 0x989
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_sub_x_x
static void _asm_inst_sub_x_x(
	ASMGeneratorGas32Context *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, "sub");
	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 %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x17143
movq %rsi, %rbx
testq %rsi, %rsi
je 0x17162
movq %rdx, %r14
testq %rdx, %rdx
je 0x17181
movq %rdi, %r15
leaq 0x2bee6(%rip), %rsi     # 0x42fd1
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x7343
movq %r12, %rdi
movl $0x6c, %esi
callq 0x749a
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x29908(%rip), %rdx     # 0x40a1b
cmovneq %rax, %rdx
leaq 0x29ea9(%rip), %rsi     # 0x40fc7
movq %r15, %rdi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x7905
movq %r12, %rdi
callq 0x7812
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x278e6(%rip), %rdi     # 0x3ea30
leaq 0x292e7(%rip), %rsi     # 0x40438
leaq 0x2be0e(%rip), %rcx     # 0x42f66
movl $0x923, %edx            # imm = 0x923
callq 0x30a0
leaq 0x31918(%rip), %rdi     # 0x48a81
leaq 0x292c8(%rip), %rsi     # 0x40438
leaq 0x2bdef(%rip), %rcx     # 0x42f66
movl $0x924, %edx            # imm = 0x924
callq 0x30a0
leaq 0x2e982(%rip), %rdi     # 0x45b0a
leaq 0x292a9(%rip), %rsi     # 0x40438
leaq 0x2bdd0(%rip), %rcx     # 0x42f66
movl $0x925, %edx            # imm = 0x925
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: emu_sub_64
static void _emu_sub_64(
	ASMGeneratorGas32Context *ctx,
	const char *al, const char *ah,
	const char *bl, const char *bh
) {
	assert(ctx);
	assert(al);
	assert(ah);
	assert(bl);
	assert(bh);

	_asm_inst_sub_x_x(
		ctx,
		ctx->body,
		BE_TYPE_UINT32,
		al,
		bl
	);

	_asm_inst_sbb_x_x(
		ctx,
		ctx->body,
		BE_TYPE_UINT32,
		ah,
		bh
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rsi, %rsi
je 0x17254
movq %rdx, %r14
testq %rdx, %rdx
je 0x17273
testq %rcx, %rcx
je 0x17292
movq %r8, %rbx
testq %r8, %r8
je 0x172b1
movq %rdi, %r15
movq 0x20(%rdi), %rdi
movq %rcx, %rdx
callq 0x170b5
movq 0x20(%r15), %r15
testq %r15, %r15
je 0x172d0
leaq 0x2bea9(%rip), %rsi     # 0x430a5
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x7343
movq %r12, %rdi
movl $0x6c, %esi
callq 0x749a
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x297f7(%rip), %rdx     # 0x40a1b
cmovneq %rax, %rdx
leaq 0x29d98(%rip), %rsi     # 0x40fc7
movq %r15, %rdi
movq %rbx, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x7905
movq %r12, %rdi
callq 0x7812
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x29e2d(%rip), %rdi     # 0x41088
leaq 0x291d6(%rip), %rsi     # 0x40438
leaq 0x2bd6c(%rip), %rcx     # 0x42fd5
movl $0x192b, %edx           # imm = 0x192B
callq 0x30a0
leaq 0x2a39a(%rip), %rdi     # 0x41614
leaq 0x291b7(%rip), %rsi     # 0x40438
leaq 0x2bd4d(%rip), %rcx     # 0x42fd5
movl $0x192c, %edx           # imm = 0x192C
callq 0x30a0
leaq 0x2a1da(%rip), %rdi     # 0x41473
leaq 0x29198(%rip), %rsi     # 0x40438
leaq 0x2bd2e(%rip), %rcx     # 0x42fd5
movl $0x192d, %edx           # imm = 0x192D
callq 0x30a0
leaq 0x2bbfc(%rip), %rdi     # 0x42eb4
leaq 0x29179(%rip), %rsi     # 0x40438
leaq 0x2bd0f(%rip), %rcx     # 0x42fd5
movl $0x192e, %edx           # imm = 0x192E
callq 0x30a0
leaq 0x27759(%rip), %rdi     # 0x3ea30
leaq 0x2915a(%rip), %rsi     # 0x40438
leaq 0x2bd55(%rip), %rcx     # 0x4303a
movl $0x945, %edx            # imm = 0x945
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: release_func_call_arg_space
static void _release_func_call_arg_space(
	ASMGeneratorGas32Context *ctx,
	ResizableString *rstr,
	size_t size
) {
	ResizableString sz_const;
	rstr_init(&sz_const);
	_asm_inst_uint_const(ctx, &sz_const, size);

	_asm_inst_add_x_x(
		ctx,
		ctx->body,
		BE_TYPE_UINT32,
		_ASM_REG_NAME_ESP,
		RSTR_CSTR(&sz_const)
	);

	rstr_free(&sz_const);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq -0x20(%rbp), %rbx
movq %rbx, %rdi
callq 0x7314
leaq 0x2a095(%rip), %rsi     # 0x413a5
movl $0x20, %edx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7905
movq 0x20(%r14), %rdi
movq 0x8(%rbx), %rax
testq %rax, %rax
leaq 0x296ea(%rip), %rcx     # 0x40a1b
cmovneq %rax, %rcx
leaq 0x2ac2f(%rip), %rdx     # 0x41f6b
movl $0x8, %esi
callq 0x155a1
movq %rbx, %rdi
callq 0x7812
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_idiv_x
static void _asm_inst_idiv_x(
	ASMGeneratorGas32Context *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 0x1748f
movq %rdi, %rbx
leaq 0x2c038(%rip), %rsi     # 0x43473
leaq -0x20(%rbp), %r14
movq %r14, %rdi
callq 0x7343
movq %r14, %rdi
movl $0x6c, %esi
callq 0x749a
movq 0x8(%r14), %rax
testq %rax, %rax
leaq 0x295b9(%rip), %rdx     # 0x40a1b
cmovneq %rax, %rdx
leaq 0x2a20b(%rip), %rsi     # 0x41678
leaq 0x2a00e(%rip), %rcx     # 0x41482
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7905
movq %r14, %rdi
callq 0x7812
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2759a(%rip), %rdi     # 0x3ea30
leaq 0x28f9b(%rip), %rsi     # 0x40438
leaq 0x2bf73(%rip), %rcx     # 0x43417
movl $0xa44, %edx            # imm = 0xA44
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_sete_x
static void _asm_inst_sete_x(
	ASMGeneratorGas32Context *ctx,
	ResizableString *rstr,
	const char *target
) {
	assert(ctx);
	assert(rstr);
	assert(target);

	const char *mnemonic = "sete";

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x174d5
movq %rsi, %rcx
testq %rsi, %rsi
je 0x174f4
leaq 0x2a1b2(%rip), %rsi     # 0x41678
leaq 0x2c26b(%rip), %rdx     # 0x43738
xorl %eax, %eax
popq %rbp
jmp 0x7905
leaq 0x27554(%rip), %rdi     # 0x3ea30
leaq 0x28f55(%rip), %rsi     # 0x40438
leaq 0x2c1fb(%rip), %rcx     # 0x436e5
movl $0x74c, %edx            # imm = 0x74C
callq 0x30a0
leaq 0x31586(%rip), %rdi     # 0x48a81
leaq 0x28f36(%rip), %rsi     # 0x40438
leaq 0x2c1dc(%rip), %rcx     # 0x436e5
movl $0x74d, %edx            # imm = 0x74D
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_shrd_x_x_x
static void _asm_inst_shrd_x_x_x(
	ASMGeneratorGas32Context *ctx,
	ResizableString *rstr,
	uint8_t type,
	const char *target,
	const char *source,
	const char *count
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);
	assert(count);

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

	_asm_inst3(
		ctx,
		rstr,
		RSTR_CSTR(&rstr_mnemonic),
		count,
		source,
		target
	);

	rstr_free(&rstr_mnemonic);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x177a9
movq %rdi, %r14
leaq 0x2c2e1(%rip), %rsi     # 0x43a28
leaq -0x20(%rbp), %rbx
movq %rbx, %rdi
callq 0x7343
movq %rbx, %rdi
movl $0x6c, %esi
callq 0x749a
movq 0x8(%rbx), %rax
testq %rax, %rax
leaq 0x292ad(%rip), %rdx     # 0x40a1b
cmovneq %rax, %rdx
leaq 0x2b72c(%rip), %rsi     # 0x42ea5
leaq 0x29cfa(%rip), %rcx     # 0x4147a
leaq 0x29612(%rip), %r8      # 0x40d99
leaq 0x29497(%rip), %r9      # 0x40c25
movq %r14, %rdi
xorl %eax, %eax
callq 0x7905
movq %rbx, %rdi
callq 0x7812
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x27280(%rip), %rdi     # 0x3ea30
leaq 0x28c81(%rip), %rsi     # 0x40438
leaq 0x2c1ee(%rip), %rcx     # 0x439ac
movl $0xaf2, %edx            # imm = 0xAF2
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_shr_x_x
static void _asm_inst_shr_x_x(
	ASMGeneratorGas32Context *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, "shr");
	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 0x17849
movq %rsi, %rbx
testq %rsi, %rsi
je 0x17868
movq %rdi, %r14
leaq 0x2ad6e(%rip), %rsi     # 0x4255e
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x7343
movq %r15, %rdi
movl $0x6c, %esi
callq 0x749a
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x29204(%rip), %rdx     # 0x40a1b
cmovneq %rax, %rdx
leaq 0x297a5(%rip), %rsi     # 0x40fc7
leaq 0x29c51(%rip), %rcx     # 0x4147a
movq %r14, %rdi
movq %rbx, %r8
xorl %eax, %eax
callq 0x7905
movq %r15, %rdi
callq 0x7812
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x271e0(%rip), %rdi     # 0x3ea30
leaq 0x28be1(%rip), %rsi     # 0x40438
leaq 0x2c1cf(%rip), %rcx     # 0x43a2d
movl $0x667, %edx            # imm = 0x667
callq 0x30a0
leaq 0x31212(%rip), %rdi     # 0x48a81
leaq 0x28bc2(%rip), %rsi     # 0x40438
leaq 0x2c1b0(%rip), %rcx     # 0x43a2d
movl $0x668, %edx            # imm = 0x668
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: get_id_or_constexpr_type
static uint8_t _get_id_or_constexpr_type(
	ASMGeneratorGas32Context *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 0x178b6
movl (%rsi), %eax
cmpl $0xe00, %eax            # imm = 0xE00
je 0x178ae
cmpl $0x200, %eax            # imm = 0x200
jne 0x178d5
callq 0x1424f
movq %rax, %rsi
addq $0x30, %rsi
jmp 0x178b2
addq $0x60, %rsi
movb (%rsi), %al
popq %rbp
retq
leaq 0x29a50(%rip), %rdi     # 0x4130d
leaq 0x28b74(%rip), %rsi     # 0x40438
leaq 0x2c20c(%rip), %rcx     # 0x43ad7
movl $0xf2d, %edx            # imm = 0xF2D
callq 0x30a0
leaq 0x26a8d(%rip), %rdi     # 0x3e369
leaq 0x28b55(%rip), %rsi     # 0x40438
leaq 0x2c1ed(%rip), %rcx     # 0x43ad7
movl $0xf35, %edx            # imm = 0xF35
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: be_asmgen_gas64_new_context
ASMGeneratorGas64Context * be_asmgen_gas64_new_context(
	ParserContext *psrctx,
	FILE *out,
	int platform
) {
	assert(psrctx);
	assert(psrctx->ast);
	assert(out);
	assert(
		platform == BE_ASMGEN_PLATFORM_WINDOWS
			|| platform == BE_ASMGEN_PLATFORM_SYSTEM_V
			|| platform == BE_ASMGEN_PLATFORM_ISYSTEM
	);
	
	ASMGeneratorGas64Context *ctx = (ASMGeneratorGas64Context *)malloc(sizeof(ASMGeneratorGas64Context));
	if (ctx == NULL) {
		_error("cannot allocate memory for a new context!");
	}

	ctx->psrctx = psrctx;
	ctx->out = out;

	ctx->global = rstr_new();
	ctx->head = rstr_new();
	ctx->body = rstr_new();
	ctx->foot = rstr_new();
	ctx->local_var_defs = NULL;

	ctx->local_var_address_counter = 0;
	ctx->local_var_size = 0;

	rstr_init(ctx->global);
	rstr_init(ctx->head);
	rstr_init(ctx->body);
	rstr_init(ctx->foot);

	ctx->counter = 0;
	ctx->func_symbol = NULL;

	ctx->platform = platform;

	return ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x183f4
movq %rdi, %r12
cmpq $0x0, 0x8(%rdi)
je 0x18413
movq %rsi, %r15
testq %rsi, %rsi
je 0x18432
leal -0x1(%rdx), %eax
cmpl $0x3, %eax
jae 0x18451
movq %rdx, -0x30(%rbp)
movl $0x68, %edi
callq 0x3120
testq %rax, %rax
je 0x18470
movq %rax, %r14
movq %r12, (%rax)
movq %r15, 0x8(%rax)
callq 0x7705
movq %rax, %r15
movq %rax, 0x10(%r14)
callq 0x7705
movq %rax, %r12
movq %rax, 0x18(%r14)
callq 0x7705
movq %rax, %r13
movq %rax, 0x20(%r14)
callq 0x7705
movq %rax, %rbx
movq %rax, 0x28(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r14)
movq $0x0, 0x40(%r14)
movq %r15, %rdi
callq 0x7314
movq %r12, %rdi
callq 0x7314
movq %r13, %rdi
callq 0x7314
movq %rbx, %rdi
callq 0x7314
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r14)
movq -0x30(%rbp), %rax
movl %eax, 0x60(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2809c(%rip), %rdi     # 0x40497
leaq 0x2c266(%rip), %rsi     # 0x44668
leaq 0x2c2b9(%rip), %rcx     # 0x446c2
movl $0x1e5a, %edx           # imm = 0x1E5A
callq 0x30a0
leaq 0x28089(%rip), %rdi     # 0x404a3
leaq 0x2c247(%rip), %rsi     # 0x44668
leaq 0x2c29a(%rip), %rcx     # 0x446c2
movl $0x1e5b, %edx           # imm = 0x1E5B
callq 0x30a0
leaq 0x280a4(%rip), %rdi     # 0x404dd
leaq 0x2c228(%rip), %rsi     # 0x44668
leaq 0x2c27b(%rip), %rcx     # 0x446c2
movl $0x1e5c, %edx           # imm = 0x1E5C
callq 0x30a0
leaq 0x280dd(%rip), %rdi     # 0x40535
leaq 0x2c209(%rip), %rsi     # 0x44668
leaq 0x2c25c(%rip), %rcx     # 0x446c2
movl $0x1e61, %edx           # imm = 0x1E61
callq 0x30a0
callq 0x3220
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: be_asmgen_gas64_free_context
void be_asmgen_gas64_free_context(
	ASMGeneratorGas64Context *ctx
) {
	assert(ctx);
	assert(ctx->global);
	assert(ctx->head);
	assert(ctx->body);
	assert(ctx->foot);

	rstr_free(ctx->global);
	rstr_free(ctx->head);
	rstr_free(ctx->body);
	rstr_free(ctx->foot);

	free(ctx->global);
	free(ctx->head);
	free(ctx->body);
	free(ctx->foot);

	ctx->global = NULL;
	ctx->head = NULL;
	ctx->body = NULL;
	ctx->foot = NULL;

	free(ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x18507
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x18526
cmpq $0x0, 0x18(%rbx)
je 0x18545
cmpq $0x0, 0x20(%rbx)
je 0x18564
cmpq $0x0, 0x28(%rbx)
je 0x18583
callq 0x7812
movq 0x18(%rbx), %rdi
callq 0x7812
movq 0x20(%rbx), %rdi
callq 0x7812
movq 0x28(%rbx), %rdi
callq 0x7812
movq 0x10(%rbx), %rdi
callq 0x31a0
movq 0x18(%rbx), %rdi
callq 0x31a0
movq 0x20(%rbx), %rdi
callq 0x31a0
movq 0x28(%rbx), %rdi
callq 0x31a0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x31a0
leaq 0x278a6(%rip), %rdi     # 0x3fdb4
leaq 0x2c153(%rip), %rsi     # 0x44668
leaq 0x2c1fa(%rip), %rcx     # 0x44716
movl $0x1e84, %edx           # imm = 0x1E84
callq 0x30a0
leaq 0x280ec(%rip), %rdi     # 0x40619
leaq 0x2c134(%rip), %rsi     # 0x44668
leaq 0x2c1db(%rip), %rcx     # 0x44716
movl $0x1e85, %edx           # imm = 0x1E85
callq 0x30a0
leaq 0x280d9(%rip), %rdi     # 0x40625
leaq 0x2c115(%rip), %rsi     # 0x44668
leaq 0x2c1bc(%rip), %rcx     # 0x44716
movl $0x1e86, %edx           # imm = 0x1E86
callq 0x30a0
leaq 0x280c4(%rip), %rdi     # 0x4062f
leaq 0x2c0f6(%rip), %rsi     # 0x44668
leaq 0x2c19d(%rip), %rcx     # 0x44716
movl $0x1e87, %edx           # imm = 0x1E87
callq 0x30a0
leaq 0x280af(%rip), %rdi     # 0x40639
leaq 0x2c0d7(%rip), %rsi     # 0x44668
leaq 0x2c17e(%rip), %rcx     # 0x44716
movl $0x1e88, %edx           # imm = 0x1E88
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: get_var_symbol_by_id_node
static ParserSymbol * _get_var_symbol_by_id_node(
	ASMGeneratorGas64Context *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_IDENTIFIER);

	ParserSymbol *symbol = parser_get_symbol_from_node(
		ctx->psrctx, node, BE_SYM_VAR, node->token
	);
	if (symbol == NULL) {
		assert(0);
	}

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0x1d5fa
cmpl $0x200, (%rsi)          # imm = 0x200
jne 0x1d619
movq (%rdi), %rdi
movq 0x10(%rsi), %rcx
movl $0x1, %edx
callq 0x6c49
testq %rax, %rax
je 0x1d638
popq %rbp
retq
leaq 0x2390a(%rip), %rdi     # 0x40f0b
leaq 0x27060(%rip), %rsi     # 0x44668
leaq 0x27508(%rip), %rcx     # 0x44b17
movl $0xc58, %edx            # imm = 0xC58
callq 0x30a0
leaq 0x237d4(%rip), %rdi     # 0x40df4
leaq 0x27041(%rip), %rsi     # 0x44668
leaq 0x274e9(%rip), %rcx     # 0x44b17
movl $0xc59, %edx            # imm = 0xC59
callq 0x30a0
leaq 0x20d2a(%rip), %rdi     # 0x3e369
leaq 0x27022(%rip), %rsi     # 0x44668
leaq 0x274ca(%rip), %rcx     # 0x44b17
movl $0xc5f, %edx            # imm = 0xC5F
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: get_symbol_by_id_node
static ParserSymbol * _get_symbol_by_id_node(
	ASMGeneratorGas64Context *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_IDENTIFIER);

	ParserSymbol *symbol = parser_get_symbol_from_node(
		ctx->psrctx, node, 0, node->token
	);
	if (symbol == NULL) {
		assert(0);
	}

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0x1d67d
cmpl $0x200, (%rsi)          # imm = 0x200
jne 0x1d69c
movq (%rdi), %rdi
movq 0x10(%rsi), %rcx
xorl %edx, %edx
callq 0x6c49
testq %rax, %rax
je 0x1d6bb
popq %rbp
retq
leaq 0x23887(%rip), %rdi     # 0x40f0b
leaq 0x26fdd(%rip), %rsi     # 0x44668
leaq 0x274db(%rip), %rcx     # 0x44b6d
movl $0xc6a, %edx            # imm = 0xC6A
callq 0x30a0
leaq 0x23751(%rip), %rdi     # 0x40df4
leaq 0x26fbe(%rip), %rsi     # 0x44668
leaq 0x274bc(%rip), %rcx     # 0x44b6d
movl $0xc6b, %edx            # imm = 0xC6B
callq 0x30a0
leaq 0x20ca7(%rip), %rdi     # 0x3e369
leaq 0x26f9f(%rip), %rsi     # 0x44668
leaq 0x2749d(%rip), %rcx     # 0x44b6d
movl $0xc71, %edx            # imm = 0xC71
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_mov_x_fsym
static void _asm_inst_mov_x_fsym(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	const char *target,
	ParserSymbol *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);
	assert(source->type == BE_SYM_FUNC);

	ResizableString rstr_func_name;
	rstr_init_with_raw(
		&rstr_func_name,
		source->token->content,
		source->token->len
	);

	ResizableString rstr_source;
	rstr_init(&rstr_source);
	_asm_inst_memref_base_disp(
		ctx,
		&rstr_source,
		_ASM_REG_NAME_RIP,
		RSTR_CSTR(&rstr_func_name)
	);

	_asm_inst_lea_x_x(
		ctx,
		rstr,
		target,
		RSTR_CSTR(&rstr_source)
	);

	rstr_free(&rstr_func_name);
	rstr_free(&rstr_source);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x1d79f
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1d7be
cmpl $0x3, (%rdx)
jne 0x1d7dd
movq %rdi, %r14
movq 0x8(%rdx), %rax
movq 0x8(%rax), %rsi
movl 0x4(%rax), %edx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x74bc
leaq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0x7314
movq 0x8(%r15), %rdx
testq %rdx, %rdx
leaq 0x232de(%rip), %r13     # 0x40a1b
cmoveq %r13, %rdx
leaq 0x23333(%rip), %rsi     # 0x40a7b
leaq 0x27083(%rip), %rcx     # 0x447d2
movq %r12, %rdi
xorl %eax, %eax
callq 0x7905
movq 0x8(%r12), %rcx
testq %rcx, %rcx
cmoveq %r13, %rcx
leaq 0x2385b(%rip), %rsi     # 0x40fc7
leaq 0x27690(%rip), %rdx     # 0x44e03
movq %r14, %rdi
movq %rbx, %r8
xorl %eax, %eax
callq 0x7905
movq %r15, %rdi
callq 0x7812
movq %r12, %rdi
callq 0x7812
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2128a(%rip), %rdi     # 0x3ea30
leaq 0x26ebb(%rip), %rsi     # 0x44668
leaq 0x27586(%rip), %rcx     # 0x44d3a
movl $0x383, %edx            # imm = 0x383
callq 0x30a0
leaq 0x2b2bc(%rip), %rdi     # 0x48a81
leaq 0x26e9c(%rip), %rsi     # 0x44668
leaq 0x27567(%rip), %rcx     # 0x44d3a
movl $0x384, %edx            # imm = 0x384
callq 0x30a0
leaq 0x239b6(%rip), %rdi     # 0x4119a
leaq 0x26e7d(%rip), %rsi     # 0x44668
leaq 0x27548(%rip), %rcx     # 0x44d3a
movl $0x386, %edx            # imm = 0x386
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_mov_x_sym
static void _asm_inst_mov_x_sym(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	const char *target,
	ParserSymbol *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);

	_asm_inst_mov_x_x(
		ctx,
		rstr,
		BE_VAR_SYMBOL_GET_TYPE(source),
		target,
		RSTR_CSTR(BE_VAR_SYMBOL_GET_CODE_GEN_NAME(source))
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1dbba
movq %rsi, %rax
testq %rsi, %rsi
je 0x1dbd9
movzbl 0x30(%rdx), %esi
movq 0x58(%rdx), %rdx
testq %rdx, %rdx
leaq 0x22e6b(%rip), %rcx     # 0x40a1b
cmovneq %rdx, %rcx
movq %rax, %rdx
popq %rbp
jmp 0x1dbf8
leaq 0x20e6f(%rip), %rdi     # 0x3ea30
leaq 0x26aa0(%rip), %rsi     # 0x44668
leaq 0x2705a(%rip), %rcx     # 0x44c29
movl $0x308, %edx            # imm = 0x308
callq 0x30a0
leaq 0x2aea1(%rip), %rdi     # 0x48a81
leaq 0x26a81(%rip), %rsi     # 0x44668
leaq 0x2703b(%rip), %rcx     # 0x44c29
movl $0x309, %edx            # imm = 0x309
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_lea_x_x
static void _asm_inst_lea_x_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	const char *target,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);

	const char *mnemonic = "leaq";

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1dd69
movq %rsi, %r8
testq %rsi, %rsi
je 0x1dd88
movq %rdx, %rcx
testq %rdx, %rdx
je 0x1dda7
leaq 0x2326d(%rip), %rsi     # 0x40fc7
leaq 0x270a2(%rip), %rdx     # 0x44e03
xorl %eax, %eax
popq %rbp
jmp 0x7905
leaq 0x20cc0(%rip), %rdi     # 0x3ea30
leaq 0x268f1(%rip), %rsi     # 0x44668
leaq 0x27023(%rip), %rcx     # 0x44da1
movl $0x348, %edx            # imm = 0x348
callq 0x30a0
leaq 0x2acf2(%rip), %rdi     # 0x48a81
leaq 0x268d2(%rip), %rsi     # 0x44668
leaq 0x27004(%rip), %rcx     # 0x44da1
movl $0x349, %edx            # imm = 0x349
callq 0x30a0
leaq 0x27d5c(%rip), %rdi     # 0x45b0a
leaq 0x268b3(%rip), %rsi     # 0x44668
leaq 0x26fe5(%rip), %rcx     # 0x44da1
movl $0x34a, %edx            # imm = 0x34A
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_movsx_x_x
static void _asm_inst_movsx_x_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	uint8_t target_type,
	const char *target,
	uint8_t source_type,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);

	ResizableString rstr_mnemonic;
	rstr_init_with_cstr(&rstr_mnemonic, "movs");
	rstr_append_with_char(
		&rstr_mnemonic,
		_asm_inst_type_suffix(ctx, source_type)
	);
	rstr_append_with_char(
		&rstr_mnemonic,
		_asm_inst_type_suffix(ctx, target_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 0x1e33f
movq %rdx, %r14
testq %rdx, %rdx
je 0x1e35e
testq %r8, %r8
movq %r8, -0x30(%rbp)
je 0x1e37d
movl %ecx, %r13d
movq %rdi, %r15
movl %esi, %ebx
leaq 0x23bea(%rip), %rsi     # 0x41eb4
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x7343
movzbl %r13b, %edi
callq 0x1dcf5
movsbl %al, %esi
movq %r12, %rdi
callq 0x749a
movzbl %bl, %edi
callq 0x1dcf5
movsbl %al, %esi
movq %r12, %rdi
callq 0x749a
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x2270f(%rip), %rdx     # 0x40a1b
cmovneq %rax, %rdx
leaq 0x22cb0(%rip), %rsi     # 0x40fc7
movq %r15, %rdi
movq -0x30(%rbp), %rcx
movq %r14, %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 0x206ea(%rip), %rdi     # 0x3ea30
leaq 0x2631b(%rip), %rsi     # 0x44668
leaq 0x26c6e(%rip), %rcx     # 0x44fc2
movl $0x445, %edx            # imm = 0x445
callq 0x30a0
leaq 0x2a71c(%rip), %rdi     # 0x48a81
leaq 0x262fc(%rip), %rsi     # 0x44668
leaq 0x26c4f(%rip), %rcx     # 0x44fc2
movl $0x446, %edx            # imm = 0x446
callq 0x30a0
leaq 0x27786(%rip), %rdi     # 0x45b0a
leaq 0x262dd(%rip), %rsi     # 0x44668
leaq 0x26c30(%rip), %rcx     # 0x44fc2
movl $0x447, %edx            # imm = 0x447
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_mov_reg64_imm64
static void _asm_inst_mov_reg64_imm64(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	const char *target,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);
	
	const char *mnemonic = "movabsq";

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1e3cb
movq %rsi, %r8
testq %rsi, %rsi
je 0x1e3ea
movq %rdx, %rcx
testq %rdx, %rdx
je 0x1e409
leaq 0x22c0b(%rip), %rsi     # 0x40fc7
leaq 0x26cdf(%rip), %rdx     # 0x450a2
xorl %eax, %eax
popq %rbp
jmp 0x7905
leaq 0x2065e(%rip), %rdi     # 0x3ea30
leaq 0x2628f(%rip), %rsi     # 0x44668
leaq 0x26c58(%rip), %rcx     # 0x45038
movl $0x2de, %edx            # imm = 0x2DE
callq 0x30a0
leaq 0x2a690(%rip), %rdi     # 0x48a81
leaq 0x26270(%rip), %rsi     # 0x44668
leaq 0x26c39(%rip), %rcx     # 0x45038
movl $0x2df, %edx            # imm = 0x2DF
callq 0x30a0
leaq 0x276fa(%rip), %rdi     # 0x45b0a
leaq 0x26251(%rip), %rsi     # 0x44668
leaq 0x26c1a(%rip), %rcx     # 0x45038
movl $0x2e0, %edx            # imm = 0x2E0
callq 0x30a0