LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x1e724
movq %rdx, %r14
testq %rdx, %rdx
je 0x1e743
testq %r8, %r8
movq %r8, -0x30(%rbp)
je 0x1e762
movl %ecx, %r13d
movq %rdi, %r15
movl %esi, %ebx
leaq 0x25845(%rip), %rsi     # 0x43ef4
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x7537
movzbl %r13b, %edi
callq 0x1e0ea
movsbl %al, %esi
movq %r12, %rdi
callq 0x768b
movzbl %bl, %edi
callq 0x1e0ea
movsbl %al, %esi
movq %r12, %rdi
callq 0x768b
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x2436a(%rip), %rdx     # 0x42a5b
cmovneq %rax, %rdx
leaq 0x2490b(%rip), %rsi     # 0x43007
movq %r15, %rdi
movq -0x30(%rbp), %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 0x22325(%rip), %rdi     # 0x40a50
leaq 0x27f76(%rip), %rsi     # 0x466a8
leaq 0x288c9(%rip), %rcx     # 0x47002
movl $0x445, %edx            # imm = 0x445
callq 0x30a0
leaq 0x2c377(%rip), %rdi     # 0x4aac1
leaq 0x27f57(%rip), %rsi     # 0x466a8
leaq 0x288aa(%rip), %rcx     # 0x47002
movl $0x446, %edx            # imm = 0x446
callq 0x30a0
leaq 0x293e1(%rip), %rdi     # 0x47b4a
leaq 0x27f38(%rip), %rsi     # 0x466a8
leaq 0x2888b(%rip), %rcx     # 0x47002
movl $0x447, %edx            # imm = 0x447
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x1e7b0
movq %rsi, %r8
testq %rsi, %rsi
je 0x1e7cf
movq %rdx, %rcx
testq %rdx, %rdx
je 0x1e7ee
leaq 0x24866(%rip), %rsi     # 0x43007
leaq 0x2893a(%rip), %rdx     # 0x470e2
xorl %eax, %eax
popq %rbp
jmp 0x7af1
leaq 0x22299(%rip), %rdi     # 0x40a50
leaq 0x27eea(%rip), %rsi     # 0x466a8
leaq 0x288b3(%rip), %rcx     # 0x47078
movl $0x2de, %edx            # imm = 0x2DE
callq 0x30a0
leaq 0x2c2eb(%rip), %rdi     # 0x4aac1
leaq 0x27ecb(%rip), %rsi     # 0x466a8
leaq 0x28894(%rip), %rcx     # 0x47078
movl $0x2df, %edx            # imm = 0x2DF
callq 0x30a0
leaq 0x29355(%rip), %rdi     # 0x47b4a
leaq 0x27eac(%rip), %rsi     # 0x466a8
leaq 0x28875(%rip), %rcx     # 0x47078
movl $0x2e0, %edx            # imm = 0x2E0
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x1e9ed
testq %rdx, %rdx
je 0x1ea0c
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 0x24092(%rip), %rcx     # 0x42a5b
cmovneq %rax, %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1d8ae
movq %r15, %rdi
callq 0x79f8
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2205c(%rip), %rdi     # 0x40a50
leaq 0x27cad(%rip), %rsi     # 0x466a8
leaq 0x2895d(%rip), %rcx     # 0x4735f
movl $0xead, %edx            # imm = 0xEAD
callq 0x30a0
leaq 0x24e43(%rip), %rdi     # 0x43856
leaq 0x27c8e(%rip), %rsi     # 0x466a8
leaq 0x2893e(%rip), %rcx     # 0x4735f
movl $0xeae, %edx            # imm = 0xEAE
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x1ea52
movq %rsi, %rcx
testq %rsi, %rsi
je 0x1ea71
leaq 0x24c75(%rip), %rsi     # 0x436b8
leaq 0x24ea5(%rip), %rdx     # 0x438ef
xorl %eax, %eax
popq %rbp
jmp 0x7af1
leaq 0x21ff7(%rip), %rdi     # 0x40a50
leaq 0x27c48(%rip), %rsi     # 0x466a8
leaq 0x28995(%rip), %rcx     # 0x473fc
movl $0x3d0, %edx            # imm = 0x3D0
callq 0x30a0
leaq 0x2c049(%rip), %rdi     # 0x4aac1
leaq 0x27c29(%rip), %rsi     # 0x466a8
leaq 0x28976(%rip), %rcx     # 0x473fc
movl $0x3d1, %edx            # imm = 0x3D1
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x1eb30
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1eb4f
movq %rcx, %r14
testq %rcx, %rcx
je 0x1eb6e
movl %esi, %r13d
movq %rdi, %r15
leaq 0x2500b(%rip), %rsi     # 0x43ada
leaq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0x7537
movzbl %r13b, %edi
callq 0x1e0ea
movsbl %al, %esi
movq %r12, %rdi
callq 0x768b
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x23f5d(%rip), %rdx     # 0x42a5b
cmovneq %rax, %rdx
leaq 0x244fe(%rip), %rsi     # 0x43007
movq %r15, %rdi
movq %r14, %rcx
movq %rbx, %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 0x21f19(%rip), %rdi     # 0x40a50
leaq 0x27b6a(%rip), %rsi     # 0x466a8
leaq 0x289af(%rip), %rcx     # 0x474f4
movl $0x40e, %edx            # imm = 0x40E
callq 0x30a0
leaq 0x2bf6b(%rip), %rdi     # 0x4aac1
leaq 0x27b4b(%rip), %rsi     # 0x466a8
leaq 0x28990(%rip), %rcx     # 0x474f4
movl $0x40f, %edx            # imm = 0x40F
callq 0x30a0
leaq 0x28fd5(%rip), %rdi     # 0x47b4a
leaq 0x27b2c(%rip), %rsi     # 0x466a8
leaq 0x28971(%rip), %rcx     # 0x474f4
movl $0x410, %edx            # imm = 0x410
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_movss_sym_x
static void _asm_inst_movss_sym_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	ParserSymbol *target,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);

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

// Assembly:
testq %rdi, %rdi
je 0x1ec54
movq 0x58(%rsi), %rax
testq %rax, %rax
leaq 0x23e27(%rip), %r8      # 0x42a5b
cmovneq %rax, %r8
leaq 0x243c8(%rip), %rsi     # 0x43007
leaq 0x25552(%rip), %rdx     # 0x44198
leaq 0x25363(%rip), %rcx     # 0x43fb0
xorl %eax, %eax
jmp 0x7af1
pushq %rbp
movq %rsp, %rbp
leaq 0x21df1(%rip), %rdi     # 0x40a50
leaq 0x27a42(%rip), %rsi     # 0x466a8
leaq 0x28c42(%rip), %rcx     # 0x478af
movl $0x4c6, %edx            # imm = 0x4C6
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_movsd_sym_x
static void _asm_inst_movsd_sym_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	ParserSymbol *target,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);

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

// Assembly:
testq %rdi, %rdi
je 0x1ed3e
movq 0x58(%rsi), %rax
testq %rax, %rax
leaq 0x23d3d(%rip), %r8      # 0x42a5b
cmovneq %rax, %r8
leaq 0x242de(%rip), %rsi     # 0x43007
leaq 0x255b3(%rip), %rdx     # 0x442e3
leaq 0x25279(%rip), %rcx     # 0x43fb0
xorl %eax, %eax
jmp 0x7af1
pushq %rbp
movq %rsp, %rbp
leaq 0x21d07(%rip), %rdi     # 0x40a50
leaq 0x27958(%rip), %rsi     # 0x466a8
leaq 0x28c94(%rip), %rcx     # 0x479eb
movl $0x506, %edx            # imm = 0x506
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x1ee1c
movq %rsi, %r8
testq %rsi, %rsi
je 0x1ee3b
movq %rdx, %rcx
testq %rdx, %rdx
je 0x1ee5a
leaq 0x241fa(%rip), %rsi     # 0x43007
leaq 0x254cf(%rip), %rdx     # 0x442e3
xorl %eax, %eax
popq %rbp
jmp 0x7af1
leaq 0x21c2d(%rip), %rdi     # 0x40a50
leaq 0x2787e(%rip), %rsi     # 0x466a8
leaq 0x28c22(%rip), %rcx     # 0x47a53
movl $0x4f0, %edx            # imm = 0x4F0
callq 0x30a0
leaq 0x2bc7f(%rip), %rdi     # 0x4aac1
leaq 0x2785f(%rip), %rsi     # 0x466a8
leaq 0x28c03(%rip), %rcx     # 0x47a53
movl $0x4f1, %edx            # imm = 0x4F1
callq 0x30a0
leaq 0x28ce9(%rip), %rdi     # 0x47b4a
leaq 0x27840(%rip), %rsi     # 0x466a8
leaq 0x28be4(%rip), %rcx     # 0x47a53
movl $0x4f2, %edx            # imm = 0x4F2
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x1ef39
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1ef58
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 0x25a0b(%rip), %rsi     # 0x448fd
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x7af1
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x23b4d(%rip), %rcx     # 0x42a5b
cmovneq %rax, %rcx
leaq 0x255cd(%rip), %rdx     # 0x444e6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d8ae
movq %r12, %rdi
callq 0x79f8
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23bbe(%rip), %rdi     # 0x42afe
leaq 0x27761(%rip), %rsi     # 0x466a8
leaq 0x28cf3(%rip), %rcx     # 0x47c41
movl $0xebb, %edx            # imm = 0xEBB
callq 0x30a0
leaq 0x21af1(%rip), %rdi     # 0x40a50
leaq 0x27742(%rip), %rsi     # 0x466a8
leaq 0x28cd4(%rip), %rcx     # 0x47c41
movl $0xebc, %edx            # imm = 0xEBC
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x1efe5
movq %rdi, %rbx
leaq 0x2560d(%rip), %rsi     # 0x4459e
leaq -0x20(%rbp), %r14
movq %r14, %rdi
callq 0x7537
movq %r14, %rdi
movl $0x71, %esi
callq 0x768b
movq 0x8(%r14), %rax
testq %rax, %rax
leaq 0x23aa3(%rip), %rdx     # 0x42a5b
cmovneq %rax, %rdx
leaq 0x246f5(%rip), %rsi     # 0x436b8
leaq 0x27b88(%rip), %rcx     # 0x46b52
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7af1
movq %r14, %rdi
callq 0x79f8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x21a64(%rip), %rdi     # 0x40a50
leaq 0x276b5(%rip), %rsi     # 0x466a8
leaq 0x28ce0(%rip), %rcx     # 0x47cda
movl $0x59f, %edx            # imm = 0x59F
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_addss_x_x
static void _asm_inst_addss_x_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	const char *target,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);

	const char *mnemonic = "addss";

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1f032
movq %rsi, %rcx
testq %rsi, %rsi
je 0x1f051
leaq 0x23feb(%rip), %rsi     # 0x43007
leaq 0x256aa(%rip), %rdx     # 0x446cd
leaq 0x24f86(%rip), %r8      # 0x43fb0
xorl %eax, %eax
popq %rbp
jmp 0x7af1
leaq 0x21a17(%rip), %rdi     # 0x40a50
leaq 0x27668(%rip), %rsi     # 0x466a8
leaq 0x28cee(%rip), %rcx     # 0x47d35
movl $0x5fe, %edx            # imm = 0x5FE
callq 0x30a0
leaq 0x28af2(%rip), %rdi     # 0x47b4a
leaq 0x27649(%rip), %rsi     # 0x466a8
leaq 0x28ccf(%rip), %rcx     # 0x47d35
movl $0x600, %edx            # imm = 0x600
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_call_x
static void _asm_inst_call_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	const char *func
) {
	assert(ctx);
	assert(rstr);
	assert(func);

	const char *mnemonic = "callq";

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1f78c
movq %rsi, %rcx
testq %rsi, %rsi
je 0x1f7ab
leaq 0x23f3b(%rip), %rsi     # 0x436b8
leaq 0x28bde(%rip), %rdx     # 0x48362
xorl %eax, %eax
popq %rbp
jmp 0x7af1
leaq 0x212bd(%rip), %rdi     # 0x40a50
leaq 0x26f0e(%rip), %rsi     # 0x466a8
leaq 0x28b6e(%rip), %rcx     # 0x4830f
movl $0x631, %edx            # imm = 0x631
callq 0x30a0
leaq 0x255c2(%rip), %rdi     # 0x44d74
leaq 0x26eef(%rip), %rsi     # 0x466a8
leaq 0x28b4f(%rip), %rcx     # 0x4830f
movl $0x632, %edx            # imm = 0x632
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_imul_x_x_x
static void _asm_inst_imul_x_x_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	uint8_t type,
	const char *target,
	const char *source1,
	const char *source2
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source1);
	assert(source2);

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

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

	rstr_free(&rstr_mnemonic);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x1f84e
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1f86d
movq %rdi, %r14
leaq 0x256ee(%rip), %rsi     # 0x44ee0
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x7537
movq %r15, %rdi
movl $0x71, %esi
callq 0x768b
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x23242(%rip), %rdx     # 0x42a5b
cmovneq %rax, %rdx
leaq 0x256c1(%rip), %rsi     # 0x44ee5
leaq 0x27903(%rip), %r8      # 0x4712e
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 0x211fb(%rip), %rdi     # 0x40a50
leaq 0x26e4c(%rip), %rsi     # 0x466a8
leaq 0x28bdc(%rip), %rcx     # 0x4843f
movl $0x728, %edx            # imm = 0x728
callq 0x30a0
leaq 0x25664(%rip), %rdi     # 0x44ed8
leaq 0x26e2d(%rip), %rsi     # 0x466a8
leaq 0x28bbd(%rip), %rcx     # 0x4843f
movl $0x72b, %edx            # imm = 0x72B
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_idiv_x
static void _asm_inst_idiv_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	uint8_t type,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(source);

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

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

	rstr_free(&rstr_mnemonic);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x1faaf
movq %rdi, %rbx
leaq 0x25a58(%rip), %rsi     # 0x454b3
leaq -0x20(%rbp), %r14
movq %r14, %rdi
callq 0x7537
movq %r14, %rdi
movl $0x71, %esi
callq 0x768b
movq 0x8(%r14), %rax
testq %rax, %rax
leaq 0x22fd9(%rip), %rdx     # 0x42a5b
cmovneq %rax, %rdx
leaq 0x23c2b(%rip), %rsi     # 0x436b8
leaq 0x2769a(%rip), %rcx     # 0x4712e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7af1
movq %r14, %rdi
callq 0x79f8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x20f9a(%rip), %rdi     # 0x40a50
leaq 0x26beb(%rip), %rsi     # 0x466a8
leaq 0x28dc0(%rip), %rcx     # 0x48884
movl $0x7f4, %edx            # imm = 0x7F4
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_and_x_x
static void _asm_inst_and_x_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	uint8_t type,
	const char *target,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);

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

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

	rstr_free(&rstr_mnemonic);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x1fbb2
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1fbd1
movq %rcx, %r14
testq %rcx, %rcx
je 0x1fbf0
movl %esi, %r13d
movq %rdi, %r15
leaq 0x2a502(%rip), %rsi     # 0x4a053
leaq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0x7537
movzbl %r13b, %edi
callq 0x1e0ea
movsbl %al, %esi
movq %r12, %rdi
callq 0x768b
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x22edb(%rip), %rdx     # 0x42a5b
cmovneq %rax, %rdx
leaq 0x2347c(%rip), %rsi     # 0x43007
movq %r15, %rdi
movq %r14, %rcx
movq %rbx, %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 0x20e97(%rip), %rdi     # 0x40a50
leaq 0x26ae8(%rip), %rsi     # 0x466a8
leaq 0x28f34(%rip), %rcx     # 0x48afb
movl $0x950, %edx            # imm = 0x950
callq 0x30a0
leaq 0x2aee9(%rip), %rdi     # 0x4aac1
leaq 0x26ac9(%rip), %rsi     # 0x466a8
leaq 0x28f15(%rip), %rcx     # 0x48afb
movl $0x951, %edx            # imm = 0x951
callq 0x30a0
leaq 0x27f53(%rip), %rdi     # 0x47b4a
leaq 0x26aaa(%rip), %rsi     # 0x466a8
leaq 0x28ef6(%rip), %rcx     # 0x48afb
movl $0x952, %edx            # imm = 0x952
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: asm_inst_xor_x_x
static void _asm_inst_xor_x_x(
	ASMGeneratorGas64Context *ctx,
	ResizableString *rstr,
	uint8_t type,
	const char *target,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);

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

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

	rstr_free(&rstr_mnemonic);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x1fc90
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1fcaf
movq %rdi, %r14
leaq 0x2a425(%rip), %rsi     # 0x4a05c
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x7537
movq %r15, %rdi
movl $0x71, %esi
callq 0x768b
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x22dfd(%rip), %rdx     # 0x42a5b
cmovneq %rax, %rdx
leaq 0x2339e(%rip), %rsi     # 0x43007
leaq 0x26ee2(%rip), %r8      # 0x46b52
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 0x20db9(%rip), %rdi     # 0x40a50
leaq 0x26a0a(%rip), %rsi     # 0x466a8
leaq 0x28f42(%rip), %rcx     # 0x48be7
movl $0x994, %edx            # imm = 0x994
callq 0x30a0
leaq 0x27e94(%rip), %rdi     # 0x47b4a
leaq 0x269eb(%rip), %rsi     # 0x466a8
leaq 0x28f23(%rip), %rcx     # 0x48be7
movl $0x996, %edx            # imm = 0x996
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/asmgen_gas64.c
// Function: get_id_or_constexpr_type
static uint8_t _get_id_or_constexpr_type(
	ASMGeneratorGas64Context *ctx,
	ParserASTNode *id_or_constexpr
) {
	assert(ctx);
	assert(id_or_constexpr);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0x1fcfd
movl (%rsi), %eax
cmpl $0xe00, %eax            # imm = 0xE00
je 0x1fcf5
cmpl $0x200, %eax            # imm = 0x200
jne 0x1fd1c
callq 0x1d9c6
movq %rax, %rsi
addq $0x30, %rsi
jmp 0x1fcf9
addq $0x60, %rsi
movb (%rsi), %al
popq %rbp
retq
leaq 0x23649(%rip), %rdi     # 0x4334d
leaq 0x2699d(%rip), %rsi     # 0x466a8
leaq 0x290d5(%rip), %rcx     # 0x48de7
movl $0xce2, %edx            # imm = 0xCE2
callq 0x30a0
leaq 0x2066a(%rip), %rdi     # 0x4038d
leaq 0x2697e(%rip), %rsi     # 0x466a8
leaq 0x290b6(%rip), %rcx     # 0x48de7
movl $0xcea, %edx            # imm = 0xCEA
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/lexer.c
// Function: be_lexer_new_context
LexerContext * be_lexer_new_context(
	const char *file,
	const char *source,
	int len
) {
	assert(file);
	assert(source);
	assert(len >= 0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x200cb
testq %rsi, %rsi
je 0x200ea
testl %edx, %edx
js 0x20109
leaq 0x3c06b(%rip), %rcx     # 0x5c130
popq %rbp
jmp 0x3ec4
leaq 0x1f940(%rip), %rdi     # 0x3fa12
leaq 0x295d7(%rip), %rsi     # 0x496b0
leaq 0x295e9(%rip), %rcx     # 0x496c9
movl $0x170, %edx            # imm = 0x170
callq 0x30a0
leaq 0x27a59(%rip), %rdi     # 0x47b4a
leaq 0x295b8(%rip), %rsi     # 0x496b0
leaq 0x295ca(%rip), %rcx     # 0x496c9
movl $0x171, %edx            # imm = 0x171
callq 0x30a0
leaq 0x1f436(%rip), %rdi     # 0x3f546
leaq 0x29599(%rip), %rsi     # 0x496b0
leaq 0x295ab(%rip), %rcx     # 0x496c9
movl $0x172, %edx            # imm = 0x172
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/lexer.c
// Function: be_lexer_get_uint32_val
uint32_t be_lexer_get_uint32_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

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

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x201b6
testq %rsi, %rsi
je 0x201d5
movl $0xfffff000, %eax       # imm = 0xFFFFF000
addl (%rsi), %eax
cmpl $0x3, %eax
ja 0x201f4
leaq 0x29517(%rip), %rcx     # 0x49690
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa22f
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa473
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa617
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa357
leaq 0x31119(%rip), %rdi     # 0x512d6
leaq 0x294ec(%rip), %rsi     # 0x496b0
leaq 0x2956d(%rip), %rcx     # 0x49738
movl $0x183, %edx            # imm = 0x183
callq 0x30a0
leaq 0x1f2ea(%rip), %rdi     # 0x3f4c6
leaq 0x294cd(%rip), %rsi     # 0x496b0
leaq 0x2954e(%rip), %rcx     # 0x49738
movl $0x184, %edx            # imm = 0x184
callq 0x30a0
leaq 0x20192(%rip), %rdi     # 0x4038d
leaq 0x294ae(%rip), %rsi     # 0x496b0
leaq 0x2952f(%rip), %rcx     # 0x49738
movl $0x194, %edx            # imm = 0x194
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/lexer.c
// Function: be_lexer_get_uint64_val
uint64_t be_lexer_get_uint64_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

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

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x20275
testq %rsi, %rsi
je 0x20294
movl $0xfffff000, %eax       # imm = 0xFFFFF000
addl (%rsi), %eax
cmpl $0x3, %eax
ja 0x202b3
leaq 0x29468(%rip), %rcx     # 0x496a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa187
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa3d2
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa4ee
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa2aa
leaq 0x3105a(%rip), %rdi     # 0x512d6
leaq 0x2942d(%rip), %rsi     # 0x496b0
leaq 0x294ed(%rip), %rcx     # 0x49777
movl $0x19f, %edx            # imm = 0x19F
callq 0x30a0
leaq 0x1f22b(%rip), %rdi     # 0x3f4c6
leaq 0x2940e(%rip), %rsi     # 0x496b0
leaq 0x294ce(%rip), %rcx     # 0x49777
movl $0x1a0, %edx            # imm = 0x1A0
callq 0x30a0
leaq 0x200d3(%rip), %rdi     # 0x4038d
leaq 0x293ef(%rip), %rsi     # 0x496b0
leaq 0x294af(%rip), %rcx     # 0x49777
movl $0x1b0, %edx            # imm = 0x1B0
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/lexer.c
// Function: be_lexer_get_float_val
float be_lexer_get_float_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x202f5
testq %rsi, %rsi
je 0x20314
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x20333
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa7b2
leaq 0x30fda(%rip), %rdi     # 0x512d6
leaq 0x293ad(%rip), %rsi     # 0x496b0
leaq 0x294ac(%rip), %rcx     # 0x497b6
movl $0x1bb, %edx            # imm = 0x1BB
callq 0x30a0
leaq 0x1f1ab(%rip), %rdi     # 0x3f4c6
leaq 0x2938e(%rip), %rsi     # 0x496b0
leaq 0x2948d(%rip), %rcx     # 0x497b6
movl $0x1bc, %edx            # imm = 0x1BC
callq 0x30a0
leaq 0x20053(%rip), %rdi     # 0x4038d
leaq 0x2936f(%rip), %rsi     # 0x496b0
leaq 0x2946e(%rip), %rcx     # 0x497b6
movl $0x1c1, %edx            # imm = 0x1C1
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/lexer.c
// Function: be_lexer_get_double_val
double be_lexer_get_double_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x20375
testq %rsi, %rsi
je 0x20394
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x203b3
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa692
leaq 0x30f5a(%rip), %rdi     # 0x512d6
leaq 0x2932d(%rip), %rsi     # 0x496b0
leaq 0x29467(%rip), %rcx     # 0x497f1
movl $0x1cb, %edx            # imm = 0x1CB
callq 0x30a0
leaq 0x1f12b(%rip), %rdi     # 0x3f4c6
leaq 0x2930e(%rip), %rsi     # 0x496b0
leaq 0x29448(%rip), %rcx     # 0x497f1
movl $0x1cc, %edx            # imm = 0x1CC
callq 0x30a0
leaq 0x1ffd3(%rip), %rdi     # 0x4038d
leaq 0x292ef(%rip), %rsi     # 0x496b0
leaq 0x29429(%rip), %rcx     # 0x497f1
movl $0x1d1, %edx            # imm = 0x1D1
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/lexer.c
// Function: be_lexer_get_char_val
char be_lexer_get_char_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

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

	return '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x203f5
testq %rsi, %rsi
je 0x20414
cmpl $0x1005, (%rsi)         # imm = 0x1005
jne 0x20433
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa00e
leaq 0x30eda(%rip), %rdi     # 0x512d6
leaq 0x292ad(%rip), %rsi     # 0x496b0
leaq 0x29424(%rip), %rcx     # 0x4982e
movl $0x1db, %edx            # imm = 0x1DB
callq 0x30a0
leaq 0x1f0ab(%rip), %rdi     # 0x3f4c6
leaq 0x2928e(%rip), %rsi     # 0x496b0
leaq 0x29405(%rip), %rcx     # 0x4982e
movl $0x1dc, %edx            # imm = 0x1DC
callq 0x30a0
leaq 0x1ff53(%rip), %rdi     # 0x4038d
leaq 0x2926f(%rip), %rsi     # 0x496b0
leaq 0x293e6(%rip), %rcx     # 0x4982e
movl $0x1e1, %edx            # imm = 0x1E1
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/lexer.c
// Function: be_lexer_has_unsigned_mark
bool be_lexer_has_unsigned_mark(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);
	assert(
		token->type == BE_TOKEN_LITERAL_UINT_BIN
		|| token->type == BE_TOKEN_LITERAL_UINT_OCT
		|| token->type == BE_TOKEN_LITERAL_UINT_DEC
		|| token->type == BE_TOKEN_LITERAL_UINT_HEX
	);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x204fd
testq %rsi, %rsi
je 0x2051c
movl (%rsi), %eax
andl $-0x4, %eax
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x2053b
movq 0x8(%rsi), %rax
movslq 0x4(%rsi), %rcx
cmpb $0x75, -0x1(%rax,%rcx)
sete %al
popq %rbp
retq
leaq 0x30dd2(%rip), %rdi     # 0x512d6
leaq 0x291a5(%rip), %rsi     # 0x496b0
leaq 0x293ac(%rip), %rcx     # 0x498be
movl $0x1f8, %edx            # imm = 0x1F8
callq 0x30a0
leaq 0x1efa3(%rip), %rdi     # 0x3f4c6
leaq 0x29186(%rip), %rsi     # 0x496b0
leaq 0x2938d(%rip), %rcx     # 0x498be
movl $0x1f9, %edx            # imm = 0x1F9
callq 0x30a0
leaq 0x293bb(%rip), %rdi     # 0x498fd
leaq 0x29167(%rip), %rsi     # 0x496b0
leaq 0x2936e(%rip), %rcx     # 0x498be
movl $0x1ff, %edx            # imm = 0x1FF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/lexer.c
// Function: be_lexer_has_float_mark
bool be_lexer_has_float_mark(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);
	assert(token->type == BE_TOKEN_LITERAL_REAL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x20582
testq %rsi, %rsi
je 0x205a1
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x205c0
movq 0x8(%rsi), %rax
movslq 0x4(%rsi), %rcx
cmpb $0x66, -0x1(%rax,%rcx)
sete %al
popq %rbp
retq
leaq 0x30d4d(%rip), %rdi     # 0x512d6
leaq 0x29120(%rip), %rsi     # 0x496b0
leaq 0x29413(%rip), %rcx     # 0x499aa
movl $0x208, %edx            # imm = 0x208
callq 0x30a0
leaq 0x1ef1e(%rip), %rdi     # 0x3f4c6
leaq 0x29101(%rip), %rsi     # 0x496b0
leaq 0x293f4(%rip), %rcx     # 0x499aa
movl $0x209, %edx            # imm = 0x209
callq 0x30a0
leaq 0x2941f(%rip), %rdi     # 0x499e6
leaq 0x290e2(%rip), %rsi     # 0x496b0
leaq 0x293d5(%rip), %rcx     # 0x499aa
movl $0x20a, %edx            # imm = 0x20A
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_new_context
_RULE_END




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

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

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

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

	return ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x22767
testq %rsi, %rsi
je 0x22786
testl %edx, %edx
js 0x227a5
movl %ecx, %ebx
callq 0x200ac
movq %rax, %r14
movq %rax, %rdi
callq 0x4780
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rdx
movaps %xmm0, (%rdx)
movl $0x10, %esi
movq %r14, %rdi
callq 0x61dc
movl %ebx, 0x30(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1d2a4(%rip), %rdi     # 0x3fa12
leaq 0x28af3(%rip), %rsi     # 0x4b268
leaq 0x28b06(%rip), %rcx     # 0x4b282
movl $0x92a, %edx            # imm = 0x92A
callq 0x30a0
leaq 0x253bd(%rip), %rdi     # 0x47b4a
leaq 0x28ad4(%rip), %rsi     # 0x4b268
leaq 0x28ae7(%rip), %rcx     # 0x4b282
movl $0x92b, %edx            # imm = 0x92B
callq 0x30a0
leaq 0x1cd9a(%rip), %rdi     # 0x3f546
leaq 0x28ab5(%rip), %rsi     # 0x4b268
leaq 0x28ac8(%rip), %rcx     # 0x4b282
movl $0x92c, %edx            # imm = 0x92C
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_get_uint32_val
uint32_t be_parser_get_uint32_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_UINT);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2304e
testq %rsi, %rsi
je 0x2306d
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x2308c
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x20154
leaq 0x2e281(%rip), %rdi     # 0x512d6
leaq 0x2820c(%rip), %rsi     # 0x4b268
leaq 0x28300(%rip), %rcx     # 0x4b363
movl $0x976, %edx            # imm = 0x976
callq 0x30a0
leaq 0x1fed7(%rip), %rdi     # 0x42f4b
leaq 0x281ed(%rip), %rsi     # 0x4b268
leaq 0x282e1(%rip), %rcx     # 0x4b363
movl $0x977, %edx            # imm = 0x977
callq 0x30a0
leaq 0x28314(%rip), %rdi     # 0x4b3a7
leaq 0x281ce(%rip), %rsi     # 0x4b268
leaq 0x282c2(%rip), %rcx     # 0x4b363
movl $0x978, %edx            # imm = 0x978
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_get_uint64_val
uint64_t be_parser_get_uint64_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_UINT);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x230ce
testq %rsi, %rsi
je 0x230ed
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x2310c
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x20213
leaq 0x2e201(%rip), %rdi     # 0x512d6
leaq 0x2818c(%rip), %rsi     # 0x4b268
leaq 0x282e7(%rip), %rcx     # 0x4b3ca
movl $0x981, %edx            # imm = 0x981
callq 0x30a0
leaq 0x1fe57(%rip), %rdi     # 0x42f4b
leaq 0x2816d(%rip), %rsi     # 0x4b268
leaq 0x282c8(%rip), %rcx     # 0x4b3ca
movl $0x982, %edx            # imm = 0x982
callq 0x30a0
leaq 0x28294(%rip), %rdi     # 0x4b3a7
leaq 0x2814e(%rip), %rsi     # 0x4b268
leaq 0x282a9(%rip), %rcx     # 0x4b3ca
movl $0x983, %edx            # imm = 0x983
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_get_uint_val
uint64_t be_parser_get_uint_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_UINT);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2315d
testq %rsi, %rsi
je 0x2317c
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x2319b
movl 0x30(%rdi), %eax
cmpl $0x2, %eax
je 0x23157
cmpl $0x1, %eax
jne 0x231ba
callq 0x2302b
movl %eax, %eax
popq %rbp
retq
popq %rbp
jmp 0x230ab
leaq 0x2e172(%rip), %rdi     # 0x512d6
leaq 0x280fd(%rip), %rsi     # 0x4b268
leaq 0x2829c(%rip), %rcx     # 0x4b40e
movl $0x98c, %edx            # imm = 0x98C
callq 0x30a0
leaq 0x1fdc8(%rip), %rdi     # 0x42f4b
leaq 0x280de(%rip), %rsi     # 0x4b268
leaq 0x2827d(%rip), %rcx     # 0x4b40e
movl $0x98d, %edx            # imm = 0x98D
callq 0x30a0
leaq 0x28205(%rip), %rdi     # 0x4b3a7
leaq 0x280bf(%rip), %rsi     # 0x4b268
leaq 0x2825e(%rip), %rcx     # 0x4b40e
movl $0x98e, %edx            # imm = 0x98E
callq 0x30a0
leaq 0x1d1cc(%rip), %rdi     # 0x4038d
leaq 0x280a0(%rip), %rsi     # 0x4b268
leaq 0x2823f(%rip), %rcx     # 0x4b40e
movl $0x996, %edx            # imm = 0x996
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_get_float_val
float be_parser_get_float_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_REAL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x231fc
testq %rsi, %rsi
je 0x2321b
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x2323a
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x202d2
leaq 0x2e0d3(%rip), %rdi     # 0x512d6
leaq 0x2805e(%rip), %rsi     # 0x4b268
leaq 0x2823f(%rip), %rcx     # 0x4b450
movl $0x99e, %edx            # imm = 0x99E
callq 0x30a0
leaq 0x1fd29(%rip), %rdi     # 0x42f4b
leaq 0x2803f(%rip), %rsi     # 0x4b268
leaq 0x28220(%rip), %rcx     # 0x4b450
movl $0x99f, %edx            # imm = 0x99F
callq 0x30a0
leaq 0x2824f(%rip), %rdi     # 0x4b490
leaq 0x28020(%rip), %rsi     # 0x4b268
leaq 0x28201(%rip), %rcx     # 0x4b450
movl $0x9a0, %edx            # imm = 0x9A0
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_get_double_val
double be_parser_get_double_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_REAL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2327c
testq %rsi, %rsi
je 0x2329b
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x232ba
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x20352
leaq 0x2e053(%rip), %rdi     # 0x512d6
leaq 0x27fde(%rip), %rsi     # 0x4b268
leaq 0x28222(%rip), %rcx     # 0x4b4b3
movl $0x9a9, %edx            # imm = 0x9A9
callq 0x30a0
leaq 0x1fca9(%rip), %rdi     # 0x42f4b
leaq 0x27fbf(%rip), %rsi     # 0x4b268
leaq 0x28203(%rip), %rcx     # 0x4b4b3
movl $0x9aa, %edx            # imm = 0x9AA
callq 0x30a0
leaq 0x281cf(%rip), %rdi     # 0x4b490
leaq 0x27fa0(%rip), %rsi     # 0x4b268
leaq 0x281e4(%rip), %rcx     # 0x4b4b3
movl $0x9ab, %edx            # imm = 0x9AB
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_get_char_val
char be_parser_get_char_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_CHAR);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x232fc
testq %rsi, %rsi
je 0x2331b
cmpl $0x302, (%rsi)          # imm = 0x302
jne 0x2333a
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x203d2
leaq 0x2dfd3(%rip), %rdi     # 0x512d6
leaq 0x27f5e(%rip), %rsi     # 0x4b268
leaq 0x281e4(%rip), %rcx     # 0x4b4f5
movl $0x9b4, %edx            # imm = 0x9B4
callq 0x30a0
leaq 0x1fc29(%rip), %rdi     # 0x42f4b
leaq 0x27f3f(%rip), %rsi     # 0x4b268
leaq 0x281c5(%rip), %rcx     # 0x4b4f5
movl $0x9b5, %edx            # imm = 0x9B5
callq 0x30a0
leaq 0x281f2(%rip), %rdi     # 0x4b533
leaq 0x27f20(%rip), %rsi     # 0x4b268
leaq 0x281a6(%rip), %rcx     # 0x4b4f5
movl $0x9b6, %edx            # imm = 0x9B6
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_add_var_symbol_to_node
ParserSymbol * be_parser_add_var_symbol_to_node(
	ParserContext *ctx,
	ParserASTNode *node,
	LexerToken *token,
	uint8_t var_type,
	ParserASTNode *var_type_node,
	size_t type_size
) {
	assert(ctx);
	assert(node);
	assert(token);
	assert(var_type > 0);
	assert(var_type_node);

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

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

	data.scope_type = BE_VAR_TYPE_UNKNOWN;

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

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
testq %rdi, %rdi
je 0x2341c
testq %rsi, %rsi
je 0x2343b
movq %rdx, %rax
testq %rdx, %rdx
je 0x2345a
testb %cl, %cl
je 0x23479
testq %r8, %r8
je 0x23498
leaq -0x50(%rbp), %r10
movb %cl, (%r10)
movq %r8, 0x8(%r10)
movq $0x0, 0x10(%r10)
xorl %ecx, %ecx
movb %cl, 0x18(%r10)
movl $0x1, 0x30(%r10)
movq $-0x1, 0x38(%r10)
movq %r9, 0x40(%r10)
movb %cl, 0x48(%r10)
movl $0x50, %r8d
movl $0x1, %edx
movq %rax, %rcx
movq %r10, %r9
callq 0x6e67
leaq -0xb9(%rip), %rcx       # 0x23359
movq %rcx, 0x20(%rax)
addq $0x50, %rsp
popq %rbp
retq
leaq 0x2deb3(%rip), %rdi     # 0x512d6
leaq 0x27e3e(%rip), %rsi     # 0x4b268
leaq 0x2814f(%rip), %rcx     # 0x4b580
movl $0x9ce, %edx            # imm = 0x9CE
callq 0x30a0
leaq 0x1fb09(%rip), %rdi     # 0x42f4b
leaq 0x27e1f(%rip), %rsi     # 0x4b268
leaq 0x28130(%rip), %rcx     # 0x4b580
movl $0x9cf, %edx            # imm = 0x9CF
callq 0x30a0
leaq 0x1c065(%rip), %rdi     # 0x3f4c6
leaq 0x27e00(%rip), %rsi     # 0x4b268
leaq 0x28111(%rip), %rcx     # 0x4b580
movl $0x9d0, %edx            # imm = 0x9D0
callq 0x30a0
leaq 0x28181(%rip), %rdi     # 0x4b601
leaq 0x27de1(%rip), %rsi     # 0x4b268
leaq 0x280f2(%rip), %rcx     # 0x4b580
movl $0x9d1, %edx            # imm = 0x9D1
callq 0x30a0
leaq 0x2816f(%rip), %rdi     # 0x4b60e
leaq 0x27dc2(%rip), %rsi     # 0x4b268
leaq 0x280d3(%rip), %rcx     # 0x4b580
movl $0x9d2, %edx            # imm = 0x9D2
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_add_struct_member_var_symbol_to_symbol
ParserSymbol * be_parser_add_struct_member_var_symbol_to_symbol(
	ParserContext *ctx,
	ParserSymbol *symbol,
	LexerToken *token,
	uint8_t var_type,
	ParserASTNode *var_type_node,
	size_t offset
) {
	assert(ctx);
	assert(symbol);
	assert(token);
	assert(var_type > 0);
	assert(var_type_node);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
testq %rdi, %rdi
je 0x2350d
testq %rsi, %rsi
je 0x2352c
movq %rdx, %rax
testq %rdx, %rdx
je 0x2354b
testb %cl, %cl
je 0x2356a
testq %r8, %r8
je 0x23589
leaq -0x18(%rbp), %r10
movb %cl, (%r10)
movq %r8, 0x8(%r10)
movq %r9, 0x10(%r10)
movl $0x18, %r8d
movl $0x5, %edx
movq %rax, %rcx
movq %r10, %r9
callq 0x719e
addq $0x20, %rsp
popq %rbp
retq
leaq 0x2ddc2(%rip), %rdi     # 0x512d6
leaq 0x27d4d(%rip), %rsi     # 0x4b268
leaq 0x280fa(%rip), %rcx     # 0x4b61c
movl $0x9f5, %edx            # imm = 0x9F5
callq 0x30a0
leaq 0x1f5d5(%rip), %rdi     # 0x42b08
leaq 0x27d2e(%rip), %rsi     # 0x4b268
leaq 0x280db(%rip), %rcx     # 0x4b61c
movl $0x9f6, %edx            # imm = 0x9F6
callq 0x30a0
leaq 0x1bf74(%rip), %rdi     # 0x3f4c6
leaq 0x27d0f(%rip), %rsi     # 0x4b268
leaq 0x280bc(%rip), %rcx     # 0x4b61c
movl $0x9f7, %edx            # imm = 0x9F7
callq 0x30a0
leaq 0x28090(%rip), %rdi     # 0x4b601
leaq 0x27cf0(%rip), %rsi     # 0x4b268
leaq 0x2809d(%rip), %rcx     # 0x4b61c
movl $0x9f8, %edx            # imm = 0x9F8
callq 0x30a0
leaq 0x2807e(%rip), %rdi     # 0x4b60e
leaq 0x27cd1(%rip), %rsi     # 0x4b268
leaq 0x2807e(%rip), %rcx     # 0x4b61c
movl $0x9f9, %edx            # imm = 0x9F9
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_new_struct_symbol
ParserSymbol * be_parser_new_struct_symbol(
	ParserContext *ctx,
	LexerToken *token,
	ParserASTNode *struct_node,
	ParserASTNode *body_node,
	bool dummy
) {
	assert(ctx);
	assert(token);
	assert(body_node);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
testq %rdi, %rdi
je 0x235ec
movq %rsi, %rax
testq %rsi, %rsi
je 0x2360b
testq %rcx, %rcx
je 0x2362a
leaq -0x18(%rbp), %r9
movq %rdx, (%r9)
movq %rcx, 0x8(%r9)
movb %r8b, 0x10(%r9)
movl $0x18, %ecx
movl $0x2, %esi
movq %rax, %rdx
movq %r9, %r8
callq 0x6aeb
addq $0x20, %rsp
popq %rbp
retq
leaq 0x2dce3(%rip), %rdi     # 0x512d6
leaq 0x27c6e(%rip), %rsi     # 0x4b268
leaq 0x280ab(%rip), %rcx     # 0x4b6ac
movl $0xa11, %edx            # imm = 0xA11
callq 0x30a0
leaq 0x1beb4(%rip), %rdi     # 0x3f4c6
leaq 0x27c4f(%rip), %rsi     # 0x4b268
leaq 0x2808c(%rip), %rcx     # 0x4b6ac
movl $0xa12, %edx            # imm = 0xA12
callq 0x30a0
leaq 0x2b114(%rip), %rdi     # 0x4e745
leaq 0x27c30(%rip), %rsi     # 0x4b268
leaq 0x2806d(%rip), %rcx     # 0x4b6ac
movl $0xa13, %edx            # imm = 0xA13
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_add_struct_symbol_to_node
ParserSymbol * be_parser_add_struct_symbol_to_node(
	ParserContext *ctx,
	ParserASTNode *node,
	LexerToken *token,
	ParserASTNode *body_node,
	bool dummy
) {
	assert(ctx);
	assert(node);
	assert(token);
	assert(body_node);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
testq %rdi, %rdi
je 0x23691
testq %rsi, %rsi
je 0x236b0
movq %rdx, %rax
testq %rdx, %rdx
je 0x236cf
testq %rcx, %rcx
je 0x236ee
leaq -0x18(%rbp), %r9
movq %rcx, 0x8(%r9)
movb %r8b, 0x10(%r9)
movl $0x18, %r8d
movl $0x2, %edx
movq %rax, %rcx
callq 0x6e67
addq $0x20, %rsp
popq %rbp
retq
leaq 0x2dc3e(%rip), %rdi     # 0x512d6
leaq 0x27bc9(%rip), %rsi     # 0x4b268
leaq 0x28078(%rip), %rcx     # 0x4b71e
movl $0xa2a, %edx            # imm = 0xA2A
callq 0x30a0
leaq 0x1f894(%rip), %rdi     # 0x42f4b
leaq 0x27baa(%rip), %rsi     # 0x4b268
leaq 0x28059(%rip), %rcx     # 0x4b71e
movl $0xa2b, %edx            # imm = 0xA2B
callq 0x30a0
leaq 0x1bdf0(%rip), %rdi     # 0x3f4c6
leaq 0x27b8b(%rip), %rsi     # 0x4b268
leaq 0x2803a(%rip), %rcx     # 0x4b71e
movl $0xa2c, %edx            # imm = 0xA2C
callq 0x30a0
leaq 0x2b050(%rip), %rdi     # 0x4e745
leaq 0x27b6c(%rip), %rsi     # 0x4b268
leaq 0x2801b(%rip), %rcx     # 0x4b71e
movl $0xa2d, %edx            # imm = 0xA2D
callq 0x30a0