LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_push_x
static void _asm_inst_push_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, "push");
	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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x15b1a
movq %rsi, %rbx
testq %rsi, %rsi
je 0x15b39
movq %rdi, %r14
leaq 0x2dbeb(%rip), %rsi     # 0x436b3
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x7537
movq %r15, %rdi
movl $0x6c, %esi
callq 0x768b
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x2cf6c(%rip), %rdx     # 0x42a5b
cmovneq %rax, %rdx
leaq 0x2dbbe(%rip), %rsi     # 0x436b8
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x7af1
movq %r15, %rdi
callq 0x79f8
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2af2f(%rip), %rdi     # 0x40a50
leaq 0x2c950(%rip), %rsi     # 0x42478
leaq 0x2db28(%rip), %rcx     # 0x43657
movl $0x70e, %edx            # imm = 0x70E
callq 0x30a0
leaq 0x3200a(%rip), %rdi     # 0x47b4a
leaq 0x2c931(%rip), %rsi     # 0x42478
leaq 0x2db09(%rip), %rcx     # 0x43657
movl $0x70f, %edx            # imm = 0x70F
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: out_label
static void _out_label(
	ASMGeneratorGas32Context *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 0x15bbe
testq %rdx, %rdx
je 0x15bdd
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 0x76ad
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x2cec1(%rip), %rcx     # 0x42a5b
cmovneq %rax, %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1444d
movq %r15, %rdi
callq 0x79f8
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ae8b(%rip), %rdi     # 0x40a50
leaq 0x2c8ac(%rip), %rsi     # 0x42478
leaq 0x2dc25(%rip), %rcx     # 0x437f8
movl $0x272, %edx            # imm = 0x272
callq 0x30a0
leaq 0x2dc72(%rip), %rdi     # 0x43856
leaq 0x2c88d(%rip), %rsi     # 0x42478
leaq 0x2dc06(%rip), %rcx     # 0x437f8
movl $0x273, %edx            # imm = 0x273
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_jmp_x
static void _asm_inst_jmp_x(
	ASMGeneratorGas32Context *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 0x15c23
movq %rsi, %rcx
testq %rsi, %rsi
je 0x15c42
leaq 0x2daa4(%rip), %rsi     # 0x436b8
leaq 0x2dcd4(%rip), %rdx     # 0x438ef
xorl %eax, %eax
popq %rbp
jmp 0x7af1
leaq 0x2ae26(%rip), %rdi     # 0x40a50
leaq 0x2c847(%rip), %rsi     # 0x42478
leaq 0x2dc65(%rip), %rcx     # 0x4389d
movl $0x3fe, %edx            # imm = 0x3FE
callq 0x30a0
leaq 0x34e78(%rip), %rdi     # 0x4aac1
leaq 0x2c828(%rip), %rsi     # 0x42478
leaq 0x2dc46(%rip), %rcx     # 0x4389d
movl $0x3ff, %edx            # imm = 0x3FF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x15fc2
movq %rdx, %r14
testq %rdx, %rdx
je 0x15fe1
movq %r8, %rbx
testq %r8, %r8
je 0x16000
movl %ecx, %r13d
movl %esi, %r12d
movq %rdi, %r15
leaq 0x2dff3(%rip), %rsi     # 0x43ef4
leaq -0x38(%rbp), %rdi
callq 0x7537
decb %r13b
cmpb $0x10, %r13b
jae 0x15fa3
movzbl %r13b, %eax
movl $0x87ff, %ecx           # imm = 0x87FF
btl %eax, %ecx
jae 0x15fa3
leaq 0x2c2a4(%rip), %r13     # 0x421d0
movsbl (%rax,%r13), %esi
leaq -0x38(%rbp), %rdi
callq 0x768b
decb %r12b
cmpb $0x10, %r12b
jae 0x15fa3
movzbl %r12b, %eax
movl $0x87ff, %ecx           # imm = 0x87FF
btl %eax, %ecx
jae 0x15fa3
movsbl (%rax,%r13), %esi
leaq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0x768b
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x2caea(%rip), %rdx     # 0x42a5b
cmovneq %rax, %rdx
leaq 0x2d08b(%rip), %rsi     # 0x43007
movq %r15, %rdi
movq %rbx, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x7af1
movq %r12, %rdi
callq 0x79f8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a3e3(%rip), %rdi     # 0x4038d
leaq 0x2c4c7(%rip), %rsi     # 0x42478
leaq 0x2d00f(%rip), %rcx     # 0x42fc7
movl $0x147, %edx            # imm = 0x147
callq 0x30a0
leaq 0x2aa87(%rip), %rdi     # 0x40a50
leaq 0x2c4a8(%rip), %rsi     # 0x42478
leaq 0x2dea7(%rip), %rcx     # 0x43e7e
movl $0x48f, %edx            # imm = 0x48F
callq 0x30a0
leaq 0x34ad9(%rip), %rdi     # 0x4aac1
leaq 0x2c489(%rip), %rsi     # 0x42478
leaq 0x2de88(%rip), %rcx     # 0x43e7e
movl $0x490, %edx            # imm = 0x490
callq 0x30a0
leaq 0x31b43(%rip), %rdi     # 0x47b4a
leaq 0x2c46a(%rip), %rsi     # 0x42478
leaq 0x2de69(%rip), %rcx     # 0x43e7e
movl $0x491, %edx            # imm = 0x491
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x16198
movq %rsi, %rbx
testq %rsi, %rsi
je 0x161b7
movq %rdx, %r14
testq %rdx, %rdx
je 0x161d6
movq %rdi, %r15
leaq 0x33f1c(%rip), %rsi     # 0x4a05c
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x7537
movq %r12, %rdi
movl $0x6c, %esi
callq 0x768b
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x2c8f3(%rip), %rdx     # 0x42a5b
cmovneq %rax, %rdx
leaq 0x2ce94(%rip), %rsi     # 0x43007
movq %r15, %rdi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x7af1
movq %r12, %rdi
callq 0x79f8
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a8b1(%rip), %rdi     # 0x40a50
leaq 0x2c2d2(%rip), %rsi     # 0x42478
leaq 0x2de0c(%rip), %rcx     # 0x43fb9
movl $0x899, %edx            # imm = 0x899
callq 0x30a0
leaq 0x34903(%rip), %rdi     # 0x4aac1
leaq 0x2c2b3(%rip), %rsi     # 0x42478
leaq 0x2dded(%rip), %rcx     # 0x43fb9
movl $0x89a, %edx            # imm = 0x89A
callq 0x30a0
leaq 0x3196d(%rip), %rdi     # 0x47b4a
leaq 0x2c294(%rip), %rsi     # 0x42478
leaq 0x2ddce(%rip), %rcx     # 0x43fb9
movl $0x89b, %edx            # imm = 0x89B
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x162a2
movl %esi, %r15d
movl %r15d, %eax
andb $-0x2, %al
cmpb $0x4, %al
jne 0x162c1
movq %rdx, %rbx
testq %rdx, %rdx
je 0x162e0
movq %rdi, %r14
leaq 0x2de92(%rip), %rsi     # 0x440c3
leaq -0x28(%rbp), %rdi
callq 0x7537
decb %r15b
cmpb $0x10, %r15b
jae 0x162ff
movzbl %r15b, %eax
leaq 0x2bf7e(%rip), %rcx     # 0x421d0
movsbl (%rax,%rcx), %esi
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x768b
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x2c7eb(%rip), %rdx     # 0x42a5b
cmovneq %rax, %rdx
leaq 0x2cd8c(%rip), %rsi     # 0x43007
leaq 0x2dd2e(%rip), %r8      # 0x43fb0
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x7af1
movq %r15, %rdi
callq 0x79f8
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a7a7(%rip), %rdi     # 0x40a50
leaq 0x2c1c8(%rip), %rsi     # 0x42478
leaq 0x2dd6d(%rip), %rcx     # 0x44024
movl $0x4dc, %edx            # imm = 0x4DC
callq 0x30a0
leaq 0x2ddcc(%rip), %rdi     # 0x44094
leaq 0x2c1a9(%rip), %rsi     # 0x42478
leaq 0x2dd4e(%rip), %rcx     # 0x44024
movl $0x4dd, %edx            # imm = 0x4DD
callq 0x30a0
leaq 0x31863(%rip), %rdi     # 0x47b4a
leaq 0x2c18a(%rip), %rsi     # 0x42478
leaq 0x2dd2f(%rip), %rcx     # 0x44024
movl $0x4df, %edx            # imm = 0x4DF
callq 0x30a0
leaq 0x2a087(%rip), %rdi     # 0x4038d
leaq 0x2c16b(%rip), %rsi     # 0x42478
leaq 0x2ccb3(%rip), %rcx     # 0x42fc7
movl $0x147, %edx            # imm = 0x147
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x1635b
testq %rsi, %rsi
je 0x1637a
movq 0x58(%rsi), %rax
testq %rax, %rax
leaq 0x2c721(%rip), %r8      # 0x42a5b
cmovneq %rax, %r8
leaq 0x2ccc2(%rip), %rsi     # 0x43007
leaq 0x2de4c(%rip), %rdx     # 0x44198
leaq 0x2dc5d(%rip), %rcx     # 0x43fb0
xorl %eax, %eax
popq %rbp
jmp 0x7af1
leaq 0x2a6ee(%rip), %rdi     # 0x40a50
leaq 0x2c10f(%rip), %rsi     # 0x42478
leaq 0x2dd5c(%rip), %rcx     # 0x440cc
movl $0x537, %edx            # imm = 0x537
callq 0x30a0
leaq 0x34740(%rip), %rdi     # 0x4aac1
leaq 0x2c0f0(%rip), %rsi     # 0x42478
leaq 0x2dd3d(%rip), %rcx     # 0x440cc
movl $0x538, %edx            # imm = 0x538
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x16446
movl %esi, %r15d
movl %r15d, %eax
andb $-0x2, %al
cmpb $0x4, %al
jne 0x16465
movq %rdx, %rbx
testq %rdx, %rdx
je 0x16484
movq %rdi, %r14
leaq 0x2de39(%rip), %rsi     # 0x4420e
leaq -0x28(%rbp), %rdi
callq 0x7537
decb %r15b
cmpb $0x10, %r15b
jae 0x164a3
movzbl %r15b, %eax
leaq 0x2bdda(%rip), %rcx     # 0x421d0
movsbl (%rax,%rcx), %esi
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x768b
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x2c647(%rip), %rdx     # 0x42a5b
cmovneq %rax, %rdx
leaq 0x2cbe8(%rip), %rsi     # 0x43007
leaq 0x2db8a(%rip), %r8      # 0x43fb0
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x7af1
movq %r15, %rdi
callq 0x79f8
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a603(%rip), %rdi     # 0x40a50
leaq 0x2c024(%rip), %rsi     # 0x42478
leaq 0x2dd43(%rip), %rcx     # 0x4419e
movl $0x4ff, %edx            # imm = 0x4FF
callq 0x30a0
leaq 0x2dc28(%rip), %rdi     # 0x44094
leaq 0x2c005(%rip), %rsi     # 0x42478
leaq 0x2dd24(%rip), %rcx     # 0x4419e
movl $0x500, %edx            # imm = 0x500
callq 0x30a0
leaq 0x316bf(%rip), %rdi     # 0x47b4a
leaq 0x2bfe6(%rip), %rsi     # 0x42478
leaq 0x2dd05(%rip), %rcx     # 0x4419e
movl $0x502, %edx            # imm = 0x502
callq 0x30a0
leaq 0x29ee3(%rip), %rdi     # 0x4038d
leaq 0x2bfc7(%rip), %rsi     # 0x42478
leaq 0x2cb0f(%rip), %rcx     # 0x42fc7
movl $0x147, %edx            # imm = 0x147
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x164ff
testq %rsi, %rsi
je 0x1651e
movq 0x58(%rsi), %rax
testq %rax, %rax
leaq 0x2c57d(%rip), %r8      # 0x42a5b
cmovneq %rax, %r8
leaq 0x2cb1e(%rip), %rsi     # 0x43007
leaq 0x2ddf3(%rip), %rdx     # 0x442e3
leaq 0x2dab9(%rip), %rcx     # 0x43fb0
xorl %eax, %eax
popq %rbp
jmp 0x7af1
leaq 0x2a54a(%rip), %rdi     # 0x40a50
leaq 0x2bf6b(%rip), %rsi     # 0x42478
leaq 0x2dd03(%rip), %rcx     # 0x44217
movl $0x577, %edx            # imm = 0x577
callq 0x30a0
leaq 0x3459c(%rip), %rdi     # 0x4aac1
leaq 0x2bf4c(%rip), %rsi     # 0x42478
leaq 0x2dce4(%rip), %rcx     # 0x44217
movl $0x578, %edx            # imm = 0x578
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x1656c
movq %rsi, %r8
testq %rsi, %rsi
je 0x1658b
movq %rdx, %rcx
testq %rdx, %rdx
je 0x165aa
leaq 0x2caaa(%rip), %rsi     # 0x43007
leaq 0x2dc34(%rip), %rdx     # 0x44198
xorl %eax, %eax
popq %rbp
jmp 0x7af1
leaq 0x2a4dd(%rip), %rdi     # 0x40a50
leaq 0x2befe(%rip), %rsi     # 0x42478
leaq 0x2dbb3(%rip), %rcx     # 0x44134
movl $0x521, %edx            # imm = 0x521
callq 0x30a0
leaq 0x3452f(%rip), %rdi     # 0x4aac1
leaq 0x2bedf(%rip), %rsi     # 0x42478
leaq 0x2db94(%rip), %rcx     # 0x44134
movl $0x522, %edx            # imm = 0x522
callq 0x30a0
leaq 0x31599(%rip), %rdi     # 0x47b4a
leaq 0x2bec0(%rip), %rsi     # 0x42478
leaq 0x2db75(%rip), %rcx     # 0x44134
movl $0x523, %edx            # imm = 0x523
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x165f8
movq %rsi, %r8
testq %rsi, %rsi
je 0x16617
movq %rdx, %rcx
testq %rdx, %rdx
je 0x16636
leaq 0x2ca1e(%rip), %rsi     # 0x43007
leaq 0x2dcf3(%rip), %rdx     # 0x442e3
xorl %eax, %eax
popq %rbp
jmp 0x7af1
leaq 0x2a451(%rip), %rdi     # 0x40a50
leaq 0x2be72(%rip), %rsi     # 0x42478
leaq 0x2dc72(%rip), %rcx     # 0x4427f
movl $0x561, %edx            # imm = 0x561
callq 0x30a0
leaq 0x344a3(%rip), %rdi     # 0x4aac1
leaq 0x2be53(%rip), %rsi     # 0x42478
leaq 0x2dc53(%rip), %rcx     # 0x4427f
movl $0x562, %edx            # imm = 0x562
callq 0x30a0
leaq 0x3150d(%rip), %rdi     # 0x47b4a
leaq 0x2be34(%rip), %rsi     # 0x42478
leaq 0x2dc34(%rip), %rcx     # 0x4427f
movl $0x563, %edx            # imm = 0x563
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x16727
movq %rdx, %rbx
testq %rdx, %rdx
je 0x16746
movq %rcx, %r14
testq %rcx, %rcx
je 0x16765
movl %esi, %r12d
movq %rdi, %r15
leaq 0x2de07(%rip), %rsi     # 0x44499
leaq -0x30(%rbp), %rdi
callq 0x7537
decb %r12b
cmpb $0x10, %r12b
jae 0x16708
movzbl %r12b, %eax
movl $0x87ff, %ecx           # imm = 0x87FF
btl %eax, %ecx
jae 0x16708
leaq 0x2bb17(%rip), %rcx     # 0x421d0
movsbl (%rax,%rcx), %esi
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x768b
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x2c383(%rip), %rdx     # 0x42a5b
cmovneq %rax, %rdx
leaq 0x2c924(%rip), %rsi     # 0x43007
movq %r15, %rdi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x7af1
movq %r12, %rdi
callq 0x79f8
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x29c7e(%rip), %rdi     # 0x4038d
leaq 0x2bd62(%rip), %rsi     # 0x42478
leaq 0x2c8aa(%rip), %rcx     # 0x42fc7
movl $0x147, %edx            # imm = 0x147
callq 0x30a0
leaq 0x2a322(%rip), %rdi     # 0x40a50
leaq 0x2bd43(%rip), %rsi     # 0x42478
leaq 0x2dcf1(%rip), %rcx     # 0x4442d
movl $0x689, %edx            # imm = 0x689
callq 0x30a0
leaq 0x34374(%rip), %rdi     # 0x4aac1
leaq 0x2bd24(%rip), %rsi     # 0x42478
leaq 0x2dcd2(%rip), %rcx     # 0x4442d
movl $0x68a, %edx            # imm = 0x68A
callq 0x30a0
leaq 0x313de(%rip), %rdi     # 0x47b4a
leaq 0x2bd05(%rip), %rsi     # 0x42478
leaq 0x2dcb3(%rip), %rcx     # 0x4442d
movl $0x68b, %edx            # imm = 0x68B
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x16810
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1682f
movq %rdi, %r14
movl 0x54(%rax), %r15d
leal 0x1(%r15), %ecx
movl %ecx, 0x54(%rax)
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x7508
leaq 0x2e134(%rip), %rsi     # 0x448fd
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x7af1
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x2c276(%rip), %rcx     # 0x42a5b
cmovneq %rax, %rcx
leaq 0x2dcf6(%rip), %rdx     # 0x444e6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1444d
movq %r12, %rdi
callq 0x79f8
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2c2e7(%rip), %rdi     # 0x42afe
leaq 0x2bc5a(%rip), %rsi     # 0x42478
leaq 0x2dc79(%rip), %rcx     # 0x4449e
movl $0x280, %edx            # imm = 0x280
callq 0x30a0
leaq 0x2a21a(%rip), %rdi     # 0x40a50
leaq 0x2bc3b(%rip), %rsi     # 0x42478
leaq 0x2dc5a(%rip), %rcx     # 0x4449e
movl $0x281, %edx            # imm = 0x281
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x16a5f
movq %rsi, %rcx
testq %rsi, %rsi
je 0x16a7e
leaq 0x2c5be(%rip), %rsi     # 0x43007
leaq 0x2dc7d(%rip), %rdx     # 0x446cd
leaq 0x2d559(%rip), %r8      # 0x43fb0
xorl %eax, %eax
popq %rbp
jmp 0x7af1
leaq 0x29fea(%rip), %rdi     # 0x40a50
leaq 0x2ba0b(%rip), %rsi     # 0x42478
leaq 0x2dbf5(%rip), %rcx     # 0x44669
movl $0x6aa, %edx            # imm = 0x6AA
callq 0x30a0
leaq 0x310c5(%rip), %rdi     # 0x47b4a
leaq 0x2b9ec(%rip), %rsi     # 0x42478
leaq 0x2dbd6(%rip), %rcx     # 0x44669
movl $0x6ac, %edx            # imm = 0x6AC
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x16acb
movq %rsi, %rcx
testq %rsi, %rsi
je 0x16aea
leaq 0x2c552(%rip), %rsi     # 0x43007
leaq 0x2dc7b(%rip), %rdx     # 0x44737
leaq 0x2d4ed(%rip), %r8      # 0x43fb0
xorl %eax, %eax
popq %rbp
jmp 0x7af1
leaq 0x29f7e(%rip), %rdi     # 0x40a50
leaq 0x2b99f(%rip), %rsi     # 0x42478
leaq 0x2dbf3(%rip), %rcx     # 0x446d3
movl $0x6c4, %edx            # imm = 0x6C4
callq 0x30a0
leaq 0x31059(%rip), %rdi     # 0x47b4a
leaq 0x2b980(%rip), %rsi     # 0x42478
leaq 0x2dbd4(%rip), %rcx     # 0x446d3
movl $0x6c6, %edx            # imm = 0x6C6
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x17366
movq %rsi, %rcx
testq %rsi, %rsi
je 0x17385
leaq 0x2c361(%rip), %rsi     # 0x436b8
leaq 0x2da1b(%rip), %rdx     # 0x44d79
xorl %eax, %eax
popq %rbp
jmp 0x7af1
leaq 0x296e3(%rip), %rdi     # 0x40a50
leaq 0x2b104(%rip), %rsi     # 0x42478
leaq 0x2d9a6(%rip), %rcx     # 0x44d21
movl $0x6dd, %edx            # imm = 0x6DD
callq 0x30a0
leaq 0x2d9e8(%rip), %rdi     # 0x44d74
leaq 0x2b0e5(%rip), %rsi     # 0x42478
leaq 0x2d987(%rip), %rcx     # 0x44d21
movl $0x6de, %edx            # imm = 0x6DE
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x17428
movq %rsi, %rbx
testq %rsi, %rsi
je 0x17447
movq %rdi, %r14
leaq 0x2db14(%rip), %rsi     # 0x44ee0
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x7537
movq %r15, %rdi
movl $0x6c, %esi
callq 0x768b
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x2b668(%rip), %rdx     # 0x42a5b
cmovneq %rax, %rdx
leaq 0x2dae7(%rip), %rsi     # 0x44ee5
leaq 0x2b9d4(%rip), %r8      # 0x42dd9
movq %r14, %rdi
movq %rbx, %rcx
movq %r8, %r9
xorl %eax, %eax
callq 0x7af1
movq %r15, %rdi
callq 0x79f8
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x29621(%rip), %rdi     # 0x40a50
leaq 0x2b042(%rip), %rsi     # 0x42478
leaq 0x2da1f(%rip), %rcx     # 0x44e5c
movl $0x986, %edx            # imm = 0x986
callq 0x30a0
leaq 0x2da8a(%rip), %rdi     # 0x44ed8
leaq 0x2b023(%rip), %rsi     # 0x42478
leaq 0x2da00(%rip), %rcx     # 0x44e5c
movl $0x989, %edx            # imm = 0x989
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x174f4
movq %rsi, %rbx
testq %rsi, %rsi
je 0x17513
movq %rdx, %r14
testq %rdx, %rdx
je 0x17532
movq %rdi, %r15
leaq 0x2db75(%rip), %rsi     # 0x45011
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x7537
movq %r12, %rdi
movl $0x6c, %esi
callq 0x768b
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x2b597(%rip), %rdx     # 0x42a5b
cmovneq %rax, %rdx
leaq 0x2bb38(%rip), %rsi     # 0x43007
movq %r15, %rdi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x7af1
movq %r12, %rdi
callq 0x79f8
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x29555(%rip), %rdi     # 0x40a50
leaq 0x2af76(%rip), %rsi     # 0x42478
leaq 0x2da9d(%rip), %rcx     # 0x44fa6
movl $0x923, %edx            # imm = 0x923
callq 0x30a0
leaq 0x335a7(%rip), %rdi     # 0x4aac1
leaq 0x2af57(%rip), %rsi     # 0x42478
leaq 0x2da7e(%rip), %rcx     # 0x44fa6
movl $0x924, %edx            # imm = 0x924
callq 0x30a0
leaq 0x30611(%rip), %rdi     # 0x47b4a
leaq 0x2af38(%rip), %rsi     # 0x42478
leaq 0x2da5f(%rip), %rcx     # 0x44fa6
movl $0x925, %edx            # imm = 0x925
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x17605
movq %rdx, %r14
testq %rdx, %rdx
je 0x17624
testq %rcx, %rcx
je 0x17643
movq %r8, %rbx
testq %r8, %r8
je 0x17662
movq %rdi, %r15
movq 0x20(%rdi), %rdi
movq %rcx, %rdx
callq 0x17466
movq 0x20(%r15), %r15
testq %r15, %r15
je 0x17681
leaq 0x2db38(%rip), %rsi     # 0x450e5
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x7537
movq %r12, %rdi
movl $0x6c, %esi
callq 0x768b
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x2b486(%rip), %rdx     # 0x42a5b
cmovneq %rax, %rdx
leaq 0x2ba27(%rip), %rsi     # 0x43007
movq %r15, %rdi
movq %rbx, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x7af1
movq %r12, %rdi
callq 0x79f8
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2babc(%rip), %rdi     # 0x430c8
leaq 0x2ae65(%rip), %rsi     # 0x42478
leaq 0x2d9fb(%rip), %rcx     # 0x45015
movl $0x192b, %edx           # imm = 0x192B
callq 0x30a0
leaq 0x2c029(%rip), %rdi     # 0x43654
leaq 0x2ae46(%rip), %rsi     # 0x42478
leaq 0x2d9dc(%rip), %rcx     # 0x45015
movl $0x192c, %edx           # imm = 0x192C
callq 0x30a0
leaq 0x2be69(%rip), %rdi     # 0x434b3
leaq 0x2ae27(%rip), %rsi     # 0x42478
leaq 0x2d9bd(%rip), %rcx     # 0x45015
movl $0x192d, %edx           # imm = 0x192D
callq 0x30a0
leaq 0x2d88b(%rip), %rdi     # 0x44ef4
leaq 0x2ae08(%rip), %rsi     # 0x42478
leaq 0x2d99e(%rip), %rcx     # 0x45015
movl $0x192e, %edx           # imm = 0x192E
callq 0x30a0
leaq 0x293c8(%rip), %rdi     # 0x40a50
leaq 0x2ade9(%rip), %rsi     # 0x42478
leaq 0x2d9e4(%rip), %rcx     # 0x4507a
movl $0x945, %edx            # imm = 0x945
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x7508
leaq 0x2bd24(%rip), %rsi     # 0x433e5
movl $0x20, %edx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7af1
movq 0x20(%r14), %rdi
movq 0x8(%rbx), %rax
testq %rax, %rax
leaq 0x2b379(%rip), %rcx     # 0x42a5b
cmovneq %rax, %rcx
leaq 0x2c8be(%rip), %rdx     # 0x43fab
movl $0x8, %esi
callq 0x15888
movq %rbx, %rdi
callq 0x79f8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x17840
movq %rdi, %rbx
leaq 0x2dcc7(%rip), %rsi     # 0x454b3
leaq -0x20(%rbp), %r14
movq %r14, %rdi
callq 0x7537
movq %r14, %rdi
movl $0x6c, %esi
callq 0x768b
movq 0x8(%r14), %rax
testq %rax, %rax
leaq 0x2b248(%rip), %rdx     # 0x42a5b
cmovneq %rax, %rdx
leaq 0x2be9a(%rip), %rsi     # 0x436b8
leaq 0x2bc9d(%rip), %rcx     # 0x434c2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7af1
movq %r14, %rdi
callq 0x79f8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x29209(%rip), %rdi     # 0x40a50
leaq 0x2ac2a(%rip), %rsi     # 0x42478
leaq 0x2dc02(%rip), %rcx     # 0x45457
movl $0xa44, %edx            # imm = 0xA44
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x17886
movq %rsi, %rcx
testq %rsi, %rsi
je 0x178a5
leaq 0x2be41(%rip), %rsi     # 0x436b8
leaq 0x2defa(%rip), %rdx     # 0x45778
xorl %eax, %eax
popq %rbp
jmp 0x7af1
leaq 0x291c3(%rip), %rdi     # 0x40a50
leaq 0x2abe4(%rip), %rsi     # 0x42478
leaq 0x2de8a(%rip), %rcx     # 0x45725
movl $0x74c, %edx            # imm = 0x74C
callq 0x30a0
leaq 0x33215(%rip), %rdi     # 0x4aac1
leaq 0x2abc5(%rip), %rsi     # 0x42478
leaq 0x2de6b(%rip), %rcx     # 0x45725
movl $0x74d, %edx            # imm = 0x74D
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x17b5a
movq %rdi, %r14
leaq 0x2df70(%rip), %rsi     # 0x45a68
leaq -0x20(%rbp), %rbx
movq %rbx, %rdi
callq 0x7537
movq %rbx, %rdi
movl $0x6c, %esi
callq 0x768b
movq 0x8(%rbx), %rax
testq %rax, %rax
leaq 0x2af3c(%rip), %rdx     # 0x42a5b
cmovneq %rax, %rdx
leaq 0x2d3bb(%rip), %rsi     # 0x44ee5
leaq 0x2b989(%rip), %rcx     # 0x434ba
leaq 0x2b2a1(%rip), %r8      # 0x42dd9
leaq 0x2b126(%rip), %r9      # 0x42c65
movq %r14, %rdi
xorl %eax, %eax
callq 0x7af1
movq %rbx, %rdi
callq 0x79f8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28eef(%rip), %rdi     # 0x40a50
leaq 0x2a910(%rip), %rsi     # 0x42478
leaq 0x2de7d(%rip), %rcx     # 0x459ec
movl $0xaf2, %edx            # imm = 0xAF2
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x17bfa
movq %rsi, %rbx
testq %rsi, %rsi
je 0x17c19
movq %rdi, %r14
leaq 0x2c9fd(%rip), %rsi     # 0x4459e
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x7537
movq %r15, %rdi
movl $0x6c, %esi
callq 0x768b
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x2ae93(%rip), %rdx     # 0x42a5b
cmovneq %rax, %rdx
leaq 0x2b434(%rip), %rsi     # 0x43007
leaq 0x2b8e0(%rip), %rcx     # 0x434ba
movq %r14, %rdi
movq %rbx, %r8
xorl %eax, %eax
callq 0x7af1
movq %r15, %rdi
callq 0x79f8
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28e4f(%rip), %rdi     # 0x40a50
leaq 0x2a870(%rip), %rsi     # 0x42478
leaq 0x2de5e(%rip), %rcx     # 0x45a6d
movl $0x667, %edx            # imm = 0x667
callq 0x30a0
leaq 0x32ea1(%rip), %rdi     # 0x4aac1
leaq 0x2a851(%rip), %rsi     # 0x42478
leaq 0x2de3f(%rip), %rcx     # 0x45a6d
movl $0x668, %edx            # imm = 0x668
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x17c67
movl (%rsi), %eax
cmpl $0xe00, %eax            # imm = 0xE00
je 0x17c5f
cmpl $0x200, %eax            # imm = 0x200
jne 0x17c86
callq 0x14565
movq %rax, %rsi
addq $0x30, %rsi
jmp 0x17c63
addq $0x60, %rsi
movb (%rsi), %al
popq %rbp
retq
leaq 0x2b6df(%rip), %rdi     # 0x4334d
leaq 0x2a803(%rip), %rsi     # 0x42478
leaq 0x2de9b(%rip), %rcx     # 0x45b17
movl $0xf2d, %edx            # imm = 0xF2D
callq 0x30a0
leaq 0x28700(%rip), %rdi     # 0x4038d
leaq 0x2a7e4(%rip), %rsi     # 0x42478
leaq 0x2de7c(%rip), %rcx     # 0x45b17
movl $0xf35, %edx            # imm = 0xF35
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x187a0
movq %rdi, %r12
cmpq $0x0, 0x8(%rdi)
je 0x187bf
movq %rsi, %r15
testq %rsi, %rsi
je 0x187de
leal -0x1(%rdx), %eax
cmpl $0x3, %eax
jae 0x187fd
movq %rdx, -0x30(%rbp)
movl $0x68, %edi
callq 0x3110
testq %rax, %rax
je 0x1881c
movq %rax, %r14
movq %r12, (%rax)
movq %r15, 0x8(%rax)
callq 0x78ea
movq %rax, %r15
movq %rax, 0x10(%r14)
callq 0x78ea
movq %rax, %r12
movq %rax, 0x18(%r14)
callq 0x78ea
movq %rax, %r13
movq %rax, 0x20(%r14)
callq 0x78ea
movq %rax, %rbx
movq %rax, 0x28(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r14)
movq $0x0, 0x40(%r14)
movq %r15, %rdi
callq 0x7508
movq %r12, %rdi
callq 0x7508
movq %r13, %rdi
callq 0x7508
movq %rbx, %rdi
callq 0x7508
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 0x29d30(%rip), %rdi     # 0x424d7
leaq 0x2defa(%rip), %rsi     # 0x466a8
leaq 0x2df4d(%rip), %rcx     # 0x46702
movl $0x1e5a, %edx           # imm = 0x1E5A
callq 0x30a0
leaq 0x29d1d(%rip), %rdi     # 0x424e3
leaq 0x2dedb(%rip), %rsi     # 0x466a8
leaq 0x2df2e(%rip), %rcx     # 0x46702
movl $0x1e5b, %edx           # imm = 0x1E5B
callq 0x30a0
leaq 0x29d38(%rip), %rdi     # 0x4251d
leaq 0x2debc(%rip), %rsi     # 0x466a8
leaq 0x2df0f(%rip), %rcx     # 0x46702
movl $0x1e5c, %edx           # imm = 0x1E5C
callq 0x30a0
leaq 0x29d71(%rip), %rdi     # 0x42575
leaq 0x2de9d(%rip), %rsi     # 0x466a8
leaq 0x2def0(%rip), %rcx     # 0x46702
movl $0x1e61, %edx           # imm = 0x1E61
callq 0x30a0
callq 0x3210
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
testq %rdi, %rdi
je 0x188c2
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x188e1
cmpq $0x0, 0x18(%rbx)
je 0x18900
cmpq $0x0, 0x20(%rbx)
je 0x1891f
cmpq $0x0, 0x28(%rbx)
je 0x1893e
leaq 0x10(%rbx), %r14
callq 0x79f8
movq 0x18(%rbx), %rdi
callq 0x79f8
movq 0x20(%rbx), %rdi
callq 0x79f8
movq 0x28(%rbx), %rdi
callq 0x79f8
movq 0x10(%rbx), %rdi
callq 0x3190
movq 0x18(%rbx), %rdi
callq 0x3190
movq 0x20(%rbx), %rdi
callq 0x3190
movq 0x28(%rbx), %rdi
callq 0x3190
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3190
leaq 0x38a0d(%rip), %rdi     # 0x512d6
leaq 0x2ddd8(%rip), %rsi     # 0x466a8
leaq 0x2de7f(%rip), %rcx     # 0x46756
movl $0x1e84, %edx           # imm = 0x1E84
callq 0x30a0
leaq 0x29d71(%rip), %rdi     # 0x42659
leaq 0x2ddb9(%rip), %rsi     # 0x466a8
leaq 0x2de60(%rip), %rcx     # 0x46756
movl $0x1e85, %edx           # imm = 0x1E85
callq 0x30a0
leaq 0x29d5e(%rip), %rdi     # 0x42665
leaq 0x2dd9a(%rip), %rsi     # 0x466a8
leaq 0x2de41(%rip), %rcx     # 0x46756
movl $0x1e86, %edx           # imm = 0x1E86
callq 0x30a0
leaq 0x29d49(%rip), %rdi     # 0x4266f
leaq 0x2dd7b(%rip), %rsi     # 0x466a8
leaq 0x2de22(%rip), %rcx     # 0x46756
movl $0x1e87, %edx           # imm = 0x1E87
callq 0x30a0
leaq 0x29d34(%rip), %rdi     # 0x42679
leaq 0x2dd5c(%rip), %rsi     # 0x466a8
leaq 0x2de03(%rip), %rcx     # 0x46756
movl $0x1e88, %edx           # imm = 0x1E88
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x1d9ef
cmpl $0x200, (%rsi)          # imm = 0x200
jne 0x1da0e
movq (%rdi), %rdi
movq 0x10(%rsi), %rcx
movl $0x1, %edx
callq 0x6d79
testq %rax, %rax
je 0x1da2d
popq %rbp
retq
leaq 0x25555(%rip), %rdi     # 0x42f4b
leaq 0x28cab(%rip), %rsi     # 0x466a8
leaq 0x29153(%rip), %rcx     # 0x46b57
movl $0xc58, %edx            # imm = 0xC58
callq 0x30a0
leaq 0x2541f(%rip), %rdi     # 0x42e34
leaq 0x28c8c(%rip), %rsi     # 0x466a8
leaq 0x29134(%rip), %rcx     # 0x46b57
movl $0xc59, %edx            # imm = 0xC59
callq 0x30a0
leaq 0x22959(%rip), %rdi     # 0x4038d
leaq 0x28c6d(%rip), %rsi     # 0x466a8
leaq 0x29115(%rip), %rcx     # 0x46b57
movl $0xc5f, %edx            # imm = 0xC5F
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x1da72
cmpl $0x200, (%rsi)          # imm = 0x200
jne 0x1da91
movq (%rdi), %rdi
movq 0x10(%rsi), %rcx
xorl %edx, %edx
callq 0x6d79
testq %rax, %rax
je 0x1dab0
popq %rbp
retq
leaq 0x254d2(%rip), %rdi     # 0x42f4b
leaq 0x28c28(%rip), %rsi     # 0x466a8
leaq 0x29126(%rip), %rcx     # 0x46bad
movl $0xc6a, %edx            # imm = 0xC6A
callq 0x30a0
leaq 0x2539c(%rip), %rdi     # 0x42e34
leaq 0x28c09(%rip), %rsi     # 0x466a8
leaq 0x29107(%rip), %rcx     # 0x46bad
movl $0xc6b, %edx            # imm = 0xC6B
callq 0x30a0
leaq 0x228d6(%rip), %rdi     # 0x4038d
leaq 0x28bea(%rip), %rsi     # 0x466a8
leaq 0x290e8(%rip), %rcx     # 0x46bad
movl $0xc71, %edx            # imm = 0xC71
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x1db94
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1dbb3
cmpl $0x3, (%rdx)
jne 0x1dbd2
movq %rdi, %r14
movq 0x8(%rdx), %rax
movq 0x8(%rax), %rsi
movl 0x4(%rax), %edx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x76ad
leaq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0x7508
movq 0x8(%r15), %rdx
testq %rdx, %rdx
leaq 0x24f29(%rip), %r13     # 0x42a5b
cmoveq %r13, %rdx
leaq 0x24f7e(%rip), %rsi     # 0x42abb
leaq 0x28cce(%rip), %rcx     # 0x46812
movq %r12, %rdi
xorl %eax, %eax
callq 0x7af1
movq 0x8(%r12), %rcx
testq %rcx, %rcx
cmoveq %r13, %rcx
leaq 0x254a6(%rip), %rsi     # 0x43007
leaq 0x292db(%rip), %rdx     # 0x46e43
movq %r14, %rdi
movq %rbx, %r8
xorl %eax, %eax
callq 0x7af1
movq %r15, %rdi
callq 0x79f8
movq %r12, %rdi
callq 0x79f8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22eb5(%rip), %rdi     # 0x40a50
leaq 0x28b06(%rip), %rsi     # 0x466a8
leaq 0x291d1(%rip), %rcx     # 0x46d7a
movl $0x383, %edx            # imm = 0x383
callq 0x30a0
leaq 0x2cf07(%rip), %rdi     # 0x4aac1
leaq 0x28ae7(%rip), %rsi     # 0x466a8
leaq 0x291b2(%rip), %rcx     # 0x46d7a
movl $0x384, %edx            # imm = 0x384
callq 0x30a0
leaq 0x25601(%rip), %rdi     # 0x431da
leaq 0x28ac8(%rip), %rsi     # 0x466a8
leaq 0x29193(%rip), %rcx     # 0x46d7a
movl $0x386, %edx            # imm = 0x386
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x1dfaf
movq %rsi, %rax
testq %rsi, %rsi
je 0x1dfce
movzbl 0x30(%rdx), %esi
movq 0x58(%rdx), %rdx
testq %rdx, %rdx
leaq 0x24ab6(%rip), %rcx     # 0x42a5b
cmovneq %rdx, %rcx
movq %rax, %rdx
popq %rbp
jmp 0x1dfed
leaq 0x22a9a(%rip), %rdi     # 0x40a50
leaq 0x286eb(%rip), %rsi     # 0x466a8
leaq 0x28ca5(%rip), %rcx     # 0x46c69
movl $0x308, %edx            # imm = 0x308
callq 0x30a0
leaq 0x2caec(%rip), %rdi     # 0x4aac1
leaq 0x286cc(%rip), %rsi     # 0x466a8
leaq 0x28c86(%rip), %rcx     # 0x46c69
movl $0x309, %edx            # imm = 0x309
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x1e15e
movq %rsi, %r8
testq %rsi, %rsi
je 0x1e17d
movq %rdx, %rcx
testq %rdx, %rdx
je 0x1e19c
leaq 0x24eb8(%rip), %rsi     # 0x43007
leaq 0x28ced(%rip), %rdx     # 0x46e43
xorl %eax, %eax
popq %rbp
jmp 0x7af1
leaq 0x228eb(%rip), %rdi     # 0x40a50
leaq 0x2853c(%rip), %rsi     # 0x466a8
leaq 0x28c6e(%rip), %rcx     # 0x46de1
movl $0x348, %edx            # imm = 0x348
callq 0x30a0
leaq 0x2c93d(%rip), %rdi     # 0x4aac1
leaq 0x2851d(%rip), %rsi     # 0x466a8
leaq 0x28c4f(%rip), %rcx     # 0x46de1
movl $0x349, %edx            # imm = 0x349
callq 0x30a0
leaq 0x299a7(%rip), %rdi     # 0x47b4a
leaq 0x284fe(%rip), %rsi     # 0x466a8
leaq 0x28c30(%rip), %rcx     # 0x46de1
movl $0x34a, %edx            # imm = 0x34A
callq 0x30a0