LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x146f0
movl %esi, %r12d
movl %r12d, %eax
andb $-0x2, %al
cmpb $0x4, %al
jne 0x1470f
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1472e
movq %rdi, %r14
leaq 0x2ab72(%rip), %rsi     # 0x3f200
leaq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0x6e49
movzbl %r12b, %edi
callq 0x136c4
movsbl %al, %esi
movq %r15, %rdi
callq 0x6f81
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x2936f(%rip), %rdx     # 0x3da2b
cmovneq %rax, %rdx
leaq 0x298ff(%rip), %rsi     # 0x3dfc6
leaq 0x2a8d4(%rip), %r8      # 0x3efa2
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x739a
movq %r15, %rdi
callq 0x72b9
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x27339(%rip), %rdi     # 0x3ba30
leaq 0x28d4a(%rip), %rsi     # 0x3d448
leaq 0x2aa8b(%rip), %rcx     # 0x3f190
movl $0x4ff, %edx            # imm = 0x4FF
callq 0x30a0
leaq 0x2a970(%rip), %rdi     # 0x3f086
leaq 0x28d2b(%rip), %rsi     # 0x3d448
leaq 0x2aa6c(%rip), %rcx     # 0x3f190
movl $0x500, %edx            # imm = 0x500
callq 0x30a0
leaq 0x2e405(%rip), %rdi     # 0x42b3a
leaq 0x28d0c(%rip), %rsi     # 0x3d448
leaq 0x2aa4d(%rip), %rcx     # 0x3f190
movl $0x502, %edx            # imm = 0x502
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x1477a
testq %rsi, %rsi
je 0x14799
movq 0x58(%rsi), %rax
testq %rax, %rax
leaq 0x292c2(%rip), %rsi     # 0x3da2b
cmovneq %rax, %rsi
leaq 0x2a82e(%rip), %rdx     # 0x3efa2
popq %rbp
jmp 0x14844
leaq 0x272af(%rip), %rdi     # 0x3ba30
leaq 0x28cc0(%rip), %rsi     # 0x3d448
leaq 0x2aa7a(%rip), %rcx     # 0x3f209
movl $0x577, %edx            # imm = 0x577
callq 0x30a0
leaq 0x31311(%rip), %rdi     # 0x45ab1
leaq 0x28ca1(%rip), %rsi     # 0x3d448
leaq 0x2aa5b(%rip), %rcx     # 0x3f209
movl $0x578, %edx            # imm = 0x578
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x147e7
movq %rsi, %r8
testq %rsi, %rsi
je 0x14806
movq %rdx, %rcx
testq %rdx, %rdx
je 0x14825
leaq 0x297ee(%rip), %rsi     # 0x3dfc6
leaq 0x2a9ab(%rip), %rdx     # 0x3f18a
xorl %eax, %eax
popq %rbp
jmp 0x739a
leaq 0x27242(%rip), %rdi     # 0x3ba30
leaq 0x28c53(%rip), %rsi     # 0x3d448
leaq 0x2a92a(%rip), %rcx     # 0x3f126
movl $0x521, %edx            # imm = 0x521
callq 0x30a0
leaq 0x312a4(%rip), %rdi     # 0x45ab1
leaq 0x28c34(%rip), %rsi     # 0x3d448
leaq 0x2a90b(%rip), %rcx     # 0x3f126
movl $0x522, %edx            # imm = 0x522
callq 0x30a0
leaq 0x2e30e(%rip), %rdi     # 0x42b3a
leaq 0x28c15(%rip), %rsi     # 0x3d448
leaq 0x2a8ec(%rip), %rcx     # 0x3f126
movl $0x523, %edx            # imm = 0x523
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x14873
movq %rsi, %r8
testq %rsi, %rsi
je 0x14892
movq %rdx, %rcx
testq %rdx, %rdx
je 0x148b1
leaq 0x29762(%rip), %rsi     # 0x3dfc6
leaq 0x2aa6a(%rip), %rdx     # 0x3f2d5
xorl %eax, %eax
popq %rbp
jmp 0x739a
leaq 0x271b6(%rip), %rdi     # 0x3ba30
leaq 0x28bc7(%rip), %rsi     # 0x3d448
leaq 0x2a9e9(%rip), %rcx     # 0x3f271
movl $0x561, %edx            # imm = 0x561
callq 0x30a0
leaq 0x31218(%rip), %rdi     # 0x45ab1
leaq 0x28ba8(%rip), %rsi     # 0x3d448
leaq 0x2a9ca(%rip), %rcx     # 0x3f271
movl $0x562, %edx            # imm = 0x562
callq 0x30a0
leaq 0x2e282(%rip), %rdi     # 0x42b3a
leaq 0x28b89(%rip), %rsi     # 0x3d448
leaq 0x2a9ab(%rip), %rcx     # 0x3f271
movl $0x563, %edx            # imm = 0x563
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x14970
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1498f
movq %rcx, %r14
testq %rcx, %rcx
je 0x149ae
movl %esi, %r13d
movq %rdi, %r15
leaq 0x2ab7c(%rip), %rsi     # 0x3f48b
leaq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0x6e49
movzbl %r13b, %edi
callq 0x136c4
movsbl %al, %esi
movq %r12, %rdi
callq 0x6f81
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x290ed(%rip), %rdx     # 0x3da2b
cmovneq %rax, %rdx
leaq 0x2967d(%rip), %rsi     # 0x3dfc6
movq %r15, %rdi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x739a
movq %r12, %rdi
callq 0x72b9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x270b9(%rip), %rdi     # 0x3ba30
leaq 0x28aca(%rip), %rsi     # 0x3d448
leaq 0x2aa9a(%rip), %rcx     # 0x3f41f
movl $0x689, %edx            # imm = 0x689
callq 0x30a0
leaq 0x3111b(%rip), %rdi     # 0x45ab1
leaq 0x28aab(%rip), %rsi     # 0x3d448
leaq 0x2aa7b(%rip), %rcx     # 0x3f41f
movl $0x68a, %edx            # imm = 0x68A
callq 0x30a0
leaq 0x2e185(%rip), %rdi     # 0x42b3a
leaq 0x28a8c(%rip), %rsi     # 0x3d448
leaq 0x2aa5c(%rip), %rcx     # 0x3f41f
movl $0x68b, %edx            # imm = 0x68B
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x14a59
movq %rsi, %rbx
testq %rsi, %rsi
je 0x14a78
movq %rdi, %r14
movl 0x54(%rax), %r15d
leal 0x1(%r15), %ecx
movl %ecx, 0x54(%rax)
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x6e1c
leaq 0x2aedd(%rip), %rsi     # 0x3f8ef
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x739a
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x28ffd(%rip), %rcx     # 0x3da2b
cmovneq %rax, %rcx
leaq 0x2aa9f(%rip), %rdx     # 0x3f4d8
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbf58
movq %r12, %rdi
callq 0x72b9
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2906e(%rip), %rdi     # 0x3dace
leaq 0x289e1(%rip), %rsi     # 0x3d448
leaq 0x2aa22(%rip), %rcx     # 0x3f490
movl $0x280, %edx            # imm = 0x280
callq 0x30a0
leaq 0x26fb1(%rip), %rdi     # 0x3ba30
leaq 0x289c2(%rip), %rsi     # 0x3d448
leaq 0x2aa03(%rip), %rcx     # 0x3f490
movl $0x281, %edx            # imm = 0x281
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x14ca4
movq %rsi, %rcx
testq %rsi, %rsi
je 0x14cc3
leaq 0x29338(%rip), %rsi     # 0x3dfc6
leaq 0x2aa2a(%rip), %rdx     # 0x3f6bf
leaq 0x2a306(%rip), %r8      # 0x3efa2
xorl %eax, %eax
popq %rbp
jmp 0x739a
leaq 0x26d85(%rip), %rdi     # 0x3ba30
leaq 0x28796(%rip), %rsi     # 0x3d448
leaq 0x2a9a2(%rip), %rcx     # 0x3f65b
movl $0x6aa, %edx            # imm = 0x6AA
callq 0x30a0
leaq 0x2de70(%rip), %rdi     # 0x42b3a
leaq 0x28777(%rip), %rsi     # 0x3d448
leaq 0x2a983(%rip), %rcx     # 0x3f65b
movl $0x6ac, %edx            # imm = 0x6AC
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x14d10
movq %rsi, %rcx
testq %rsi, %rsi
je 0x14d2f
leaq 0x292cc(%rip), %rsi     # 0x3dfc6
leaq 0x2aa28(%rip), %rdx     # 0x3f729
leaq 0x2a29a(%rip), %r8      # 0x3efa2
xorl %eax, %eax
popq %rbp
jmp 0x739a
leaq 0x26d19(%rip), %rdi     # 0x3ba30
leaq 0x2872a(%rip), %rsi     # 0x3d448
leaq 0x2a9a0(%rip), %rcx     # 0x3f6c5
movl $0x6c4, %edx            # imm = 0x6C4
callq 0x30a0
leaq 0x2de04(%rip), %rdi     # 0x42b3a
leaq 0x2870b(%rip), %rsi     # 0x3d448
leaq 0x2a981(%rip), %rcx     # 0x3f6c5
movl $0x6c6, %edx            # imm = 0x6C6
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x15552
movq %rsi, %rcx
testq %rsi, %rsi
je 0x15571
leaq 0x29167(%rip), %rsi     # 0x3e6aa
leaq 0x2a821(%rip), %rdx     # 0x3fd6b
xorl %eax, %eax
popq %rbp
jmp 0x739a
leaq 0x264d7(%rip), %rdi     # 0x3ba30
leaq 0x27ee8(%rip), %rsi     # 0x3d448
leaq 0x2a7ac(%rip), %rcx     # 0x3fd13
movl $0x6dd, %edx            # imm = 0x6DD
callq 0x30a0
leaq 0x2a7ee(%rip), %rdi     # 0x3fd66
leaq 0x27ec9(%rip), %rsi     # 0x3d448
leaq 0x2a78d(%rip), %rcx     # 0x3fd13
movl $0x6de, %edx            # imm = 0x6DE
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x15612
movq %rsi, %rbx
testq %rsi, %rsi
je 0x15631
movq %rdi, %r14
leaq 0x2a91a(%rip), %rsi     # 0x3fed2
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x6e49
pushq $0x6c
popq %rsi
movq %r15, %rdi
callq 0x6f81
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x2844e(%rip), %rdx     # 0x3da2b
cmovneq %rax, %rdx
leaq 0x2a8ef(%rip), %rsi     # 0x3fed7
leaq 0x287a9(%rip), %r8      # 0x3dd98
movq %r14, %rdi
movq %rbx, %rcx
movq %r8, %r9
xorl %eax, %eax
callq 0x739a
movq %r15, %rdi
callq 0x72b9
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x26417(%rip), %rdi     # 0x3ba30
leaq 0x27e28(%rip), %rsi     # 0x3d448
leaq 0x2a827(%rip), %rcx     # 0x3fe4e
movl $0x986, %edx            # imm = 0x986
callq 0x30a0
leaq 0x2a892(%rip), %rdi     # 0x3feca
leaq 0x27e09(%rip), %rsi     # 0x3d448
leaq 0x2a808(%rip), %rcx     # 0x3fe4e
movl $0x989, %edx            # imm = 0x989
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x156dc
movq %rsi, %rbx
testq %rsi, %rsi
je 0x156fb
movq %rdx, %r14
testq %rdx, %rdx
je 0x1571a
movq %rdi, %r15
leaq 0x2a97d(%rip), %rsi     # 0x40003
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x6e49
pushq $0x6c
popq %rsi
movq %r12, %rdi
callq 0x6f81
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x2837f(%rip), %rdx     # 0x3da2b
cmovneq %rax, %rdx
leaq 0x2890f(%rip), %rsi     # 0x3dfc6
movq %r15, %rdi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x739a
movq %r12, %rdi
callq 0x72b9
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2634d(%rip), %rdi     # 0x3ba30
leaq 0x27d5e(%rip), %rsi     # 0x3d448
leaq 0x2a8a7(%rip), %rcx     # 0x3ff98
movl $0x923, %edx            # imm = 0x923
callq 0x30a0
leaq 0x303af(%rip), %rdi     # 0x45ab1
leaq 0x27d3f(%rip), %rsi     # 0x3d448
leaq 0x2a888(%rip), %rcx     # 0x3ff98
movl $0x924, %edx            # imm = 0x924
callq 0x30a0
leaq 0x2d419(%rip), %rdi     # 0x42b3a
leaq 0x27d20(%rip), %rsi     # 0x3d448
leaq 0x2a869(%rip), %rcx     # 0x3ff98
movl $0x925, %edx            # imm = 0x925
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x157ea
movq %rdx, %r14
testq %rdx, %rdx
je 0x15809
testq %rcx, %rcx
je 0x15828
movq %r8, %rbx
testq %r8, %r8
je 0x15847
movq %rdi, %r15
movq 0x20(%rdi), %rdi
movq %rcx, %rdx
callq 0x15650
movq 0x20(%r15), %r12
testq %r12, %r12
je 0x15866
leaq 0x2a942(%rip), %rsi     # 0x400d7
leaq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0x6e49
pushq $0x6c
popq %rsi
movq %r15, %rdi
callq 0x6f81
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x28271(%rip), %rdx     # 0x3da2b
cmovneq %rax, %rdx
leaq 0x28801(%rip), %rsi     # 0x3dfc6
movq %r12, %rdi
movq %rbx, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x739a
movq %r15, %rdi
callq 0x72b9
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28896(%rip), %rdi     # 0x3e087
leaq 0x27c50(%rip), %rsi     # 0x3d448
leaq 0x2a808(%rip), %rcx     # 0x40007
movl $0x192b, %edx           # imm = 0x192B
callq 0x30a0
leaq 0x28e03(%rip), %rdi     # 0x3e613
leaq 0x27c31(%rip), %rsi     # 0x3d448
leaq 0x2a7e9(%rip), %rcx     # 0x40007
movl $0x192c, %edx           # imm = 0x192C
callq 0x30a0
leaq 0x28c43(%rip), %rdi     # 0x3e472
leaq 0x27c12(%rip), %rsi     # 0x3d448
leaq 0x2a7ca(%rip), %rcx     # 0x40007
movl $0x192d, %edx           # imm = 0x192D
callq 0x30a0
leaq 0x2a698(%rip), %rdi     # 0x3fee6
leaq 0x27bf3(%rip), %rsi     # 0x3d448
leaq 0x2a7ab(%rip), %rcx     # 0x40007
movl $0x192e, %edx           # imm = 0x192E
callq 0x30a0
leaq 0x261c3(%rip), %rdi     # 0x3ba30
leaq 0x27bd4(%rip), %rsi     # 0x3d448
leaq 0x2a7f1(%rip), %rcx     # 0x4006c
movl $0x945, %edx            # imm = 0x945
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x6e1c
leaq 0x28ad6(%rip), %rsi     # 0x3e3a4
pushq $0x20
popq %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x739a
movq 0x20(%r14), %rdi
movq 0x8(%rbx), %rax
testq %rax, %rax
leaq 0x2813e(%rip), %rcx     # 0x3da2b
cmovneq %rax, %rcx
leaq 0x296a5(%rip), %rdx     # 0x3ef9d
pushq $0x8
popq %rsi
callq 0x13bfe
movq %rbx, %rdi
callq 0x72b9
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x15a45
movq %rdi, %r14
leaq 0x2aab2(%rip), %rsi     # 0x404a5
leaq -0x20(%rbp), %rbx
movq %rbx, %rdi
callq 0x6e49
pushq $0x6c
popq %rsi
movq %rbx, %rdi
callq 0x6f81
movq 0x8(%rbx), %rax
testq %rax, %rax
leaq 0x28013(%rip), %rdx     # 0x3da2b
cmovneq %rax, %rdx
leaq 0x28c87(%rip), %rsi     # 0x3e6aa
leaq 0x28a57(%rip), %rcx     # 0x3e481
movq %r14, %rdi
xorl %eax, %eax
callq 0x739a
movq %rbx, %rdi
callq 0x72b9
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x25fe4(%rip), %rdi     # 0x3ba30
leaq 0x279f5(%rip), %rsi     # 0x3d448
leaq 0x2a9ef(%rip), %rcx     # 0x40449
movl $0xa44, %edx            # imm = 0xA44
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x15a8b
movq %rsi, %rcx
testq %rsi, %rsi
je 0x15aaa
leaq 0x28c2e(%rip), %rsi     # 0x3e6aa
leaq 0x2ace7(%rip), %rdx     # 0x4076a
xorl %eax, %eax
popq %rbp
jmp 0x739a
leaq 0x25f9e(%rip), %rdi     # 0x3ba30
leaq 0x279af(%rip), %rsi     # 0x3d448
leaq 0x2ac77(%rip), %rcx     # 0x40717
movl $0x74c, %edx            # imm = 0x74C
callq 0x30a0
leaq 0x30000(%rip), %rdi     # 0x45ab1
leaq 0x27990(%rip), %rsi     # 0x3d448
leaq 0x2ac58(%rip), %rcx     # 0x40717
movl $0x74d, %edx            # imm = 0x74D
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x15d29
movq %rdi, %r14
leaq 0x2ad91(%rip), %rsi     # 0x40a5a
leaq -0x20(%rbp), %rbx
movq %rbx, %rdi
callq 0x6e49
pushq $0x6c
popq %rsi
movq %rbx, %rdi
callq 0x6f81
movq 0x8(%rbx), %rax
testq %rax, %rax
leaq 0x27d3d(%rip), %rdx     # 0x3da2b
cmovneq %rax, %rdx
leaq 0x2a1de(%rip), %rsi     # 0x3fed7
leaq 0x28779(%rip), %rcx     # 0x3e479
leaq 0x28091(%rip), %r8      # 0x3dd98
leaq 0x27f27(%rip), %r9      # 0x3dc35
movq %r14, %rdi
xorl %eax, %eax
callq 0x739a
movq %rbx, %rdi
callq 0x72b9
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x25d00(%rip), %rdi     # 0x3ba30
leaq 0x27711(%rip), %rsi     # 0x3d448
leaq 0x2aca0(%rip), %rcx     # 0x409de
movl $0xaf2, %edx            # imm = 0xAF2
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x15dc7
movq %rsi, %rbx
testq %rsi, %rsi
je 0x15de6
movq %rdi, %r14
leaq 0x29820(%rip), %rsi     # 0x3f590
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x6e49
pushq $0x6c
popq %rsi
movq %r15, %rdi
callq 0x6f81
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x27c96(%rip), %rdx     # 0x3da2b
cmovneq %rax, %rdx
leaq 0x28226(%rip), %rsi     # 0x3dfc6
leaq 0x286d2(%rip), %rcx     # 0x3e479
movq %r14, %rdi
movq %rbx, %r8
xorl %eax, %eax
callq 0x739a
movq %r15, %rdi
callq 0x72b9
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25c62(%rip), %rdi     # 0x3ba30
leaq 0x27673(%rip), %rsi     # 0x3d448
leaq 0x2ac83(%rip), %rcx     # 0x40a5f
movl $0x667, %edx            # imm = 0x667
callq 0x30a0
leaq 0x2fcc4(%rip), %rdi     # 0x45ab1
leaq 0x27654(%rip), %rsi     # 0x3d448
leaq 0x2ac64(%rip), %rcx     # 0x40a5f
movl $0x668, %edx            # imm = 0x668
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x15e34
movl (%rsi), %eax
cmpl $0xe00, %eax            # imm = 0xE00
je 0x15e2c
cmpl $0x200, %eax            # imm = 0x200
jne 0x15e53
callq 0x128ba
movq %rax, %rsi
addq $0x30, %rsi
jmp 0x15e30
addq $0x60, %rsi
movb (%rsi), %al
popq %rbp
retq
leaq 0x284d1(%rip), %rdi     # 0x3e30c
leaq 0x27606(%rip), %rsi     # 0x3d448
leaq 0x2acc0(%rip), %rcx     # 0x40b09
movl $0xf2d, %edx            # imm = 0xF2D
callq 0x30a0
leaq 0x2550f(%rip), %rdi     # 0x3b369
leaq 0x275e7(%rip), %rsi     # 0x3d448
leaq 0x2aca1(%rip), %rcx     # 0x40b09
movl $0xf35, %edx            # imm = 0xF35
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x1693b
movq %rdi, %r12
cmpq $0x0, 0x8(%rdi)
je 0x1695a
movq %rsi, %r15
testq %rsi, %rsi
je 0x16979
leal -0x1(%rdx), %eax
cmpl $0x3, %eax
jae 0x16998
movq %rdx, -0x30(%rbp)
pushq $0x68
popq %rdi
callq 0x3110
testq %rax, %rax
je 0x169b7
movq %rax, %r14
movq %r12, (%rax)
movq %r15, 0x8(%rax)
callq 0x71d5
movq %rax, %r15
movq %rax, 0x10(%r14)
callq 0x71d5
movq %rax, %r12
movq %rax, 0x18(%r14)
callq 0x71d5
movq %rax, %r13
movq %rax, 0x20(%r14)
callq 0x71d5
movq %rax, %rbx
movq %rax, 0x28(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r14)
andq $0x0, 0x40(%r14)
movq %r15, %rdi
callq 0x6e1c
movq %r12, %rdi
callq 0x6e1c
movq %r13, %rdi
callq 0x6e1c
movq %rbx, %rdi
callq 0x6e1c
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 0x26b65(%rip), %rdi     # 0x3d4a7
leaq 0x2ad4f(%rip), %rsi     # 0x41698
leaq 0x2ada2(%rip), %rcx     # 0x416f2
movl $0x1e5a, %edx           # imm = 0x1E5A
callq 0x30a0
leaq 0x26b52(%rip), %rdi     # 0x3d4b3
leaq 0x2ad30(%rip), %rsi     # 0x41698
leaq 0x2ad83(%rip), %rcx     # 0x416f2
movl $0x1e5b, %edx           # imm = 0x1E5B
callq 0x30a0
leaq 0x26b6d(%rip), %rdi     # 0x3d4ed
leaq 0x2ad11(%rip), %rsi     # 0x41698
leaq 0x2ad64(%rip), %rcx     # 0x416f2
movl $0x1e5c, %edx           # imm = 0x1E5C
callq 0x30a0
leaq 0x26ba6(%rip), %rdi     # 0x3d545
leaq 0x2acf2(%rip), %rsi     # 0x41698
leaq 0x2ad45(%rip), %rcx     # 0x416f2
movl $0x1e61, %edx           # imm = 0x1E61
callq 0x30a0
movq 0x4063a(%rip), %rax     # 0x56ff8
movq (%rax), %rdi
leaq 0x2dc9d(%rip), %rsi     # 0x44665
leaq 0x26bf2(%rip), %rdx     # 0x3d5c1
xorl %eax, %eax
callq 0x30e0
pushq $0x1
popq %rdi
callq 0x3160
// File: /workspace/github_c_makefile_star2_O2/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 0x16a70
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x16a8f
cmpq $0x0, 0x18(%rbx)
je 0x16aae
cmpq $0x0, 0x20(%rbx)
je 0x16acd
cmpq $0x0, 0x28(%rbx)
je 0x16aec
callq 0x72b9
movq 0x18(%rbx), %rdi
callq 0x72b9
movq 0x20(%rbx), %rdi
callq 0x72b9
movq 0x28(%rbx), %rdi
callq 0x72b9
movq 0x10(%rbx), %rdi
callq 0x3190
movq 0x18(%rbx), %rdi
callq 0x3190
movq 0x20(%rbx), %rdi
callq 0x3190
movq 0x28(%rbx), %rdi
callq 0x3190
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3190
leaq 0x2635d(%rip), %rdi     # 0x3cdd4
leaq 0x2ac1a(%rip), %rsi     # 0x41698
leaq 0x2acc1(%rip), %rcx     # 0x41746
movl $0x1e84, %edx           # imm = 0x1E84
callq 0x30a0
leaq 0x26b93(%rip), %rdi     # 0x3d629
leaq 0x2abfb(%rip), %rsi     # 0x41698
leaq 0x2aca2(%rip), %rcx     # 0x41746
movl $0x1e85, %edx           # imm = 0x1E85
callq 0x30a0
leaq 0x26b80(%rip), %rdi     # 0x3d635
leaq 0x2abdc(%rip), %rsi     # 0x41698
leaq 0x2ac83(%rip), %rcx     # 0x41746
movl $0x1e86, %edx           # imm = 0x1E86
callq 0x30a0
leaq 0x26b6b(%rip), %rdi     # 0x3d63f
leaq 0x2abbd(%rip), %rsi     # 0x41698
leaq 0x2ac64(%rip), %rcx     # 0x41746
movl $0x1e87, %edx           # imm = 0x1E87
callq 0x30a0
leaq 0x26b56(%rip), %rdi     # 0x3d649
leaq 0x2ab9e(%rip), %rsi     # 0x41698
leaq 0x2ac45(%rip), %rcx     # 0x41746
movl $0x1e88, %edx           # imm = 0x1E88
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x1b6aa
cmpl $0x200, (%rsi)          # imm = 0x200
jne 0x1b6c9
movq (%rdi), %rdi
movq 0x10(%rsi), %rcx
pushq $0x1
popq %rdx
callq 0x6779
testq %rax, %rax
je 0x1b6e8
popq %rbp
retq
leaq 0x22859(%rip), %rdi     # 0x3df0a
leaq 0x25fe0(%rip), %rsi     # 0x41698
leaq 0x26488(%rip), %rcx     # 0x41b47
movl $0xc58, %edx            # imm = 0xC58
callq 0x30a0
leaq 0x22723(%rip), %rdi     # 0x3ddf3
leaq 0x25fc1(%rip), %rsi     # 0x41698
leaq 0x26469(%rip), %rcx     # 0x41b47
movl $0xc59, %edx            # imm = 0xC59
callq 0x30a0
leaq 0x1fc7a(%rip), %rdi     # 0x3b369
leaq 0x25fa2(%rip), %rsi     # 0x41698
leaq 0x2644a(%rip), %rcx     # 0x41b47
movl $0xc5f, %edx            # imm = 0xC5F
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x1b72d
cmpl $0x200, (%rsi)          # imm = 0x200
jne 0x1b74c
movq (%rdi), %rdi
movq 0x10(%rsi), %rcx
xorl %edx, %edx
callq 0x6779
testq %rax, %rax
je 0x1b76b
popq %rbp
retq
leaq 0x227d6(%rip), %rdi     # 0x3df0a
leaq 0x25f5d(%rip), %rsi     # 0x41698
leaq 0x2645b(%rip), %rcx     # 0x41b9d
movl $0xc6a, %edx            # imm = 0xC6A
callq 0x30a0
leaq 0x226a0(%rip), %rdi     # 0x3ddf3
leaq 0x25f3e(%rip), %rsi     # 0x41698
leaq 0x2643c(%rip), %rcx     # 0x41b9d
movl $0xc6b, %edx            # imm = 0xC6B
callq 0x30a0
leaq 0x1fbf7(%rip), %rdi     # 0x3b369
leaq 0x25f1f(%rip), %rsi     # 0x41698
leaq 0x2641d(%rip), %rcx     # 0x41b9d
movl $0xc71, %edx            # imm = 0xC71
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x1b83f
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1b85e
cmpl $0x3, (%rdx)
jne 0x1b87d
movq %rdi, %r14
movq 0x8(%rdx), %rax
movq 0x8(%rax), %rsi
movl 0x4(%rax), %edx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x6fa2
leaq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0x6e1c
movq 0x8(%r15), %rdx
testq %rdx, %rdx
leaq 0x2223e(%rip), %r13     # 0x3da2b
cmoveq %r13, %rdx
leaq 0x22293(%rip), %rsi     # 0x3da8b
leaq 0x26003(%rip), %rcx     # 0x41802
movq %r12, %rdi
xorl %eax, %eax
callq 0x739a
movq 0x8(%r12), %rdx
testq %rdx, %rdx
cmoveq %r13, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1bde4
movq %r15, %rdi
callq 0x72b9
movq %r12, %rdi
callq 0x72b9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x201ea(%rip), %rdi     # 0x3ba30
leaq 0x25e4b(%rip), %rsi     # 0x41698
leaq 0x26516(%rip), %rcx     # 0x41d6a
movl $0x383, %edx            # imm = 0x383
callq 0x30a0
leaq 0x2a24c(%rip), %rdi     # 0x45ab1
leaq 0x25e2c(%rip), %rsi     # 0x41698
leaq 0x264f7(%rip), %rcx     # 0x41d6a
movl $0x384, %edx            # imm = 0x384
callq 0x30a0
leaq 0x22915(%rip), %rdi     # 0x3e199
leaq 0x25e0d(%rip), %rsi     # 0x41698
leaq 0x264d8(%rip), %rcx     # 0x41d6a
movl $0x386, %edx            # imm = 0x386
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x1bc64
movq %rsi, %rax
testq %rsi, %rsi
je 0x1bc83
movzbl 0x30(%rdx), %esi
movq 0x58(%rdx), %rdx
testq %rdx, %rdx
leaq 0x21dd1(%rip), %rcx     # 0x3da2b
cmovneq %rdx, %rcx
movq %rax, %rdx
popq %rbp
jmp 0x1bca2
leaq 0x1fdc5(%rip), %rdi     # 0x3ba30
leaq 0x25a26(%rip), %rsi     # 0x41698
leaq 0x25fe0(%rip), %rcx     # 0x41c59
movl $0x308, %edx            # imm = 0x308
callq 0x30a0
leaq 0x29e27(%rip), %rdi     # 0x45ab1
leaq 0x25a07(%rip), %rsi     # 0x41698
leaq 0x25fc1(%rip), %rcx     # 0x41c59
movl $0x309, %edx            # imm = 0x309
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x1be13
movq %rsi, %r8
testq %rsi, %rsi
je 0x1be32
movq %rdx, %rcx
testq %rdx, %rdx
je 0x1be51
leaq 0x221c2(%rip), %rsi     # 0x3dfc6
leaq 0x26028(%rip), %rdx     # 0x41e33
xorl %eax, %eax
popq %rbp
jmp 0x739a
leaq 0x1fc16(%rip), %rdi     # 0x3ba30
leaq 0x25877(%rip), %rsi     # 0x41698
leaq 0x25fa9(%rip), %rcx     # 0x41dd1
movl $0x348, %edx            # imm = 0x348
callq 0x30a0
leaq 0x29c78(%rip), %rdi     # 0x45ab1
leaq 0x25858(%rip), %rsi     # 0x41698
leaq 0x25f8a(%rip), %rcx     # 0x41dd1
movl $0x349, %edx            # imm = 0x349
callq 0x30a0
leaq 0x26ce2(%rip), %rdi     # 0x42b3a
leaq 0x25839(%rip), %rsi     # 0x41698
leaq 0x25f6b(%rip), %rcx     # 0x41dd1
movl $0x34a, %edx            # imm = 0x34A
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x1c3e1
movq %rdx, %r14
testq %rdx, %rdx
je 0x1c400
testq %r8, %r8
movq %r8, -0x30(%rbp)
je 0x1c41f
movl %ecx, %r13d
movq %rdi, %r15
movl %esi, %ebx
leaq 0x22b7a(%rip), %rsi     # 0x3eee6
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x6e49
movzbl %r13b, %edi
callq 0x1bd9f
movsbl %al, %esi
movq %r12, %rdi
callq 0x6f81
movzbl %bl, %edi
callq 0x1bd9f
movsbl %al, %esi
movq %r12, %rdi
callq 0x6f81
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x2167d(%rip), %rdx     # 0x3da2b
cmovneq %rax, %rdx
leaq 0x21c0d(%rip), %rsi     # 0x3dfc6
movq %r15, %rdi
movq -0x30(%rbp), %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x739a
movq %r12, %rdi
callq 0x72b9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f648(%rip), %rdi     # 0x3ba30
leaq 0x252a9(%rip), %rsi     # 0x41698
leaq 0x25bfc(%rip), %rcx     # 0x41ff2
movl $0x445, %edx            # imm = 0x445
callq 0x30a0
leaq 0x296aa(%rip), %rdi     # 0x45ab1
leaq 0x2528a(%rip), %rsi     # 0x41698
leaq 0x25bdd(%rip), %rcx     # 0x41ff2
movl $0x446, %edx            # imm = 0x446
callq 0x30a0
leaq 0x26714(%rip), %rdi     # 0x42b3a
leaq 0x2526b(%rip), %rsi     # 0x41698
leaq 0x25bbe(%rip), %rcx     # 0x41ff2
movl $0x447, %edx            # imm = 0x447
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x1c46d
movq %rsi, %r8
testq %rsi, %rsi
je 0x1c48c
movq %rdx, %rcx
testq %rdx, %rdx
je 0x1c4ab
leaq 0x21b68(%rip), %rsi     # 0x3dfc6
leaq 0x25c6d(%rip), %rdx     # 0x420d2
xorl %eax, %eax
popq %rbp
jmp 0x739a
leaq 0x1f5bc(%rip), %rdi     # 0x3ba30
leaq 0x2521d(%rip), %rsi     # 0x41698
leaq 0x25be6(%rip), %rcx     # 0x42068
movl $0x2de, %edx            # imm = 0x2DE
callq 0x30a0
leaq 0x2961e(%rip), %rdi     # 0x45ab1
leaq 0x251fe(%rip), %rsi     # 0x41698
leaq 0x25bc7(%rip), %rcx     # 0x42068
movl $0x2df, %edx            # imm = 0x2DF
callq 0x30a0
leaq 0x26688(%rip), %rdi     # 0x42b3a
leaq 0x251df(%rip), %rsi     # 0x41698
leaq 0x25ba8(%rip), %rcx     # 0x42068
movl $0x2e0, %edx            # imm = 0x2E0
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: out_label
static void _out_label(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	const char *prefix,
	ParserASTNode *node_id
) {
	assert(ctx);
	assert(rstr);
	assert(node_id);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x1c700
testq %rdx, %rdx
je 0x1c71f
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 0x6fa2
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x2134f(%rip), %rcx     # 0x3da2b
cmovneq %rax, %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1739e
movq %r15, %rdi
callq 0x72b9
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f329(%rip), %rdi     # 0x3ba30
leaq 0x24f8a(%rip), %rsi     # 0x41698
leaq 0x25c3a(%rip), %rcx     # 0x4234f
movl $0xead, %edx            # imm = 0xEAD
callq 0x30a0
leaq 0x22122(%rip), %rdi     # 0x3e848
leaq 0x24f6b(%rip), %rsi     # 0x41698
leaq 0x25c1b(%rip), %rcx     # 0x4234f
movl $0xeae, %edx            # imm = 0xEAE
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_jmp_x
static void _asm_inst_jmp_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	const char *target
) {
	assert(ctx);
	assert(rstr);
	assert(target);

	const char *mnemonic = "jmp";

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1c765
movq %rsi, %rcx
testq %rsi, %rsi
je 0x1c784
leaq 0x21f54(%rip), %rsi     # 0x3e6aa
leaq 0x22184(%rip), %rdx     # 0x3e8e1
xorl %eax, %eax
popq %rbp
jmp 0x739a
leaq 0x1f2c4(%rip), %rdi     # 0x3ba30
leaq 0x24f25(%rip), %rsi     # 0x41698
leaq 0x25c72(%rip), %rcx     # 0x423ec
movl $0x3d0, %edx            # imm = 0x3D0
callq 0x30a0
leaq 0x29326(%rip), %rdi     # 0x45ab1
leaq 0x24f06(%rip), %rsi     # 0x41698
leaq 0x25c53(%rip), %rcx     # 0x423ec
movl $0x3d1, %edx            # imm = 0x3D1
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_cmp_x_x
static void _asm_inst_cmp_x_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	uint8_t type,
	const char *target,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);

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

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

	rstr_free(&rstr_mnemonic);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x1c843
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1c862
movq %rcx, %r14
testq %rcx, %rcx
je 0x1c881
movl %esi, %r13d
movq %rdi, %r15
leaq 0x222ea(%rip), %rsi     # 0x3eacc
leaq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0x6e49
movzbl %r13b, %edi
callq 0x1bd9f
movsbl %al, %esi
movq %r12, %rdi
callq 0x6f81
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x2121a(%rip), %rdx     # 0x3da2b
cmovneq %rax, %rdx
leaq 0x217aa(%rip), %rsi     # 0x3dfc6
movq %r15, %rdi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x739a
movq %r12, %rdi
callq 0x72b9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f1e6(%rip), %rdi     # 0x3ba30
leaq 0x24e47(%rip), %rsi     # 0x41698
leaq 0x25c8c(%rip), %rcx     # 0x424e4
movl $0x40e, %edx            # imm = 0x40E
callq 0x30a0
leaq 0x29248(%rip), %rdi     # 0x45ab1
leaq 0x24e28(%rip), %rsi     # 0x41698
leaq 0x25c6d(%rip), %rcx     # 0x424e4
movl $0x40f, %edx            # imm = 0x40F
callq 0x30a0
leaq 0x262b2(%rip), %rdi     # 0x42b3a
leaq 0x24e09(%rip), %rsi     # 0x41698
leaq 0x25c4e(%rip), %rcx     # 0x424e4
movl $0x410, %edx            # imm = 0x410
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_movsd_x_x
static void _asm_inst_movsd_x_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	const char *target,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);

	const char *mnemonic = "movsd";

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1cb0b
movq %rsi, %r8
testq %rsi, %rsi
je 0x1cb2a
movq %rdx, %rcx
testq %rdx, %rdx
je 0x1cb49
leaq 0x214ca(%rip), %rsi     # 0x3dfc6
leaq 0x227d2(%rip), %rdx     # 0x3f2d5
xorl %eax, %eax
popq %rbp
jmp 0x739a
leaq 0x1ef1e(%rip), %rdi     # 0x3ba30
leaq 0x24b7f(%rip), %rsi     # 0x41698
leaq 0x25f23(%rip), %rcx     # 0x42a43
movl $0x4f0, %edx            # imm = 0x4F0
callq 0x30a0
leaq 0x28f80(%rip), %rdi     # 0x45ab1
leaq 0x24b60(%rip), %rsi     # 0x41698
leaq 0x25f04(%rip), %rcx     # 0x42a43
movl $0x4f1, %edx            # imm = 0x4F1
callq 0x30a0
leaq 0x25fea(%rip), %rdi     # 0x42b3a
leaq 0x24b41(%rip), %rsi     # 0x41698
leaq 0x25ee5(%rip), %rcx     # 0x42a43
movl $0x4f2, %edx            # imm = 0x4F2
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: out_func_tmp_label
static void _out_func_tmp_label(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr
) {
	assert(ctx);
	assert(ctx->func_symbol);
	assert(rstr);

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

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

	rstr_free(&rstr_no);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x1cc26
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1cc45
movq %rdi, %r14
movl 0x54(%rax), %r15d
leal 0x1(%r15), %ecx
movl %ecx, 0x54(%rax)
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x6e1c
leaq 0x22d10(%rip), %rsi     # 0x3f8ef
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x739a
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x20e30(%rip), %rcx     # 0x3da2b
cmovneq %rax, %rcx
leaq 0x228d2(%rip), %rdx     # 0x3f4d8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1739e
movq %r12, %rdi
callq 0x72b9
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20ea1(%rip), %rdi     # 0x3dace
leaq 0x24a64(%rip), %rsi     # 0x41698
leaq 0x25ff6(%rip), %rcx     # 0x42c31
movl $0xebb, %edx            # imm = 0xEBB
callq 0x30a0
leaq 0x1ede4(%rip), %rdi     # 0x3ba30
leaq 0x24a45(%rip), %rsi     # 0x41698
leaq 0x25fd7(%rip), %rcx     # 0x42c31
movl $0xebc, %edx            # imm = 0xEBC
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_shr_x
static void _asm_inst_shr_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	uint8_t type,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(source);

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

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

	rstr_free(&rstr_mnemonic);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x1ccd0
movq %rdi, %r14
leaq 0x22912(%rip), %rsi     # 0x3f590
leaq -0x20(%rbp), %rbx
movq %rbx, %rdi
callq 0x6e49
pushq $0x71
popq %rsi
movq %rbx, %rdi
callq 0x6f81
movq 0x8(%rbx), %rax
testq %rax, %rax
leaq 0x20d88(%rip), %rdx     # 0x3da2b
cmovneq %rax, %rdx
leaq 0x219fc(%rip), %rsi     # 0x3e6aa
leaq 0x24e8d(%rip), %rcx     # 0x41b42
movq %r14, %rdi
xorl %eax, %eax
callq 0x739a
movq %rbx, %rdi
callq 0x72b9
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1ed59(%rip), %rdi     # 0x3ba30
leaq 0x249ba(%rip), %rsi     # 0x41698
leaq 0x25fe5(%rip), %rcx     # 0x42cca
movl $0x59f, %edx            # imm = 0x59F
callq 0x30a0