LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_OUT_Ib_eAX
void ins_enc_OUT_Ib_eAX(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(2);

	ParserASTNode *ins_node = data->ins_node;

	ParserASTNode *target = ins_node->childs[0];

	ParserASTNode *source = ins_node->childs[1];

	EncoderInstruction enc_ins;

	ins_init(data->ctx, ins, ins_node, &enc_ins);

	InsRegister *source_reg = ASM_REG_AST_NODE_GET_REG(source);

	switch (ASM_PARSER_CONTEXT_DATA_GET_ARCH(data->ctx)) {
		case ASM_ARCH_BIT16: {
			switch (source_reg->type) {
				case INS_REGISTER_GENERAL_2BYTE: {
					// 无需操作数大小前缀。
					break;
				}
				case INS_REGISTER_GENERAL_4BYTE: {
					enc_ins.legacy_prefix.operand_size_override = true;
					break;
				}
				default: {
					assert(0);
					break;
				}
			}
			break;
		}
		case ASM_ARCH_BIT32:
		case ASM_ARCH_BIT64: {
			switch (source_reg->type) {
				case INS_REGISTER_GENERAL_2BYTE: {
					enc_ins.legacy_prefix.operand_size_override = true;
					break;
				}
				case INS_REGISTER_GENERAL_4BYTE: {
					// 无需操作数大小前缀。
					break;
				}
				default: {
					assert(0);
					break;
				}
			}
			break;
		}
		default: {
			assert(0);
			break;
		}
	}

	ins_fill_imm8(data->ctx, ins, target, &enc_ins);

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
testq %rdi, %rdi
je 0x1a9f7
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1aa00
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1aa09
cmpl $0x2, 0x44(%rdx)
jne 0x1aa12
movq %rdi, %r14
movq 0x48(%rdx), %rax
movq (%rax), %r15
movq 0x8(%rax), %r12
movq 0x8(%rbx), %rdi
leaq -0x80(%rbp), %rcx
movq %r14, %rsi
callq 0x155a6
movq 0x60(%r12), %rax
movq 0x8(%rbx), %rdi
movl 0xb0(%rdi), %ecx
cmpl $0x4, %ecx
je 0x1a99d
cmpl $0x2, %ecx
je 0x1a99d
cmpl $0x1, %ecx
jne 0x1aa31
movl 0xc(%rax), %eax
cmpl $0x3, %eax
je 0x1a9cd
cmpl $0x4, %eax
je 0x1a9c9
leaq 0x14a0f(%rip), %rdi     # 0x2f394
leaq 0x18308(%rip), %rsi     # 0x32c94
leaq 0x18dcf(%rip), %rcx     # 0x33762
movl $0x643, %edx            # imm = 0x643
callq 0xa0b0
movl 0xc(%rax), %eax
cmpl $0x3, %eax
je 0x1a9c9
cmpl $0x4, %eax
je 0x1a9cd
leaq 0x149e3(%rip), %rdi     # 0x2f394
leaq 0x182dc(%rip), %rsi     # 0x32c94
leaq 0x18da3(%rip), %rcx     # 0x33762
movl $0x655, %edx            # imm = 0x655
callq 0xa0b0
movb $0x1, -0x75(%rbp)
leaq -0x80(%rbp), %r12
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x15fb3
movq %rbx, %rdi
movq %r12, %rsi
callq 0x181fc
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16d7c(%rip), %rdi     # 0x3177a
jmp 0x1aa19
leaq 0x1cbed(%rip), %rdi     # 0x375f4
jmp 0x1aa19
leaq 0x182e1(%rip), %rdi     # 0x32cf1
jmp 0x1aa19
leaq 0x182e7(%rip), %rdi     # 0x32d00
leaq 0x18274(%rip), %rsi     # 0x32c94
leaq 0x18d3b(%rip), %rcx     # 0x33762
movl $0x629, %edx            # imm = 0x629
callq 0xa0b0
leaq 0x1495c(%rip), %rdi     # 0x2f394
leaq 0x18255(%rip), %rsi     # 0x32c94
leaq 0x18d1c(%rip), %rcx     # 0x33762
movl $0x65c, %edx            # imm = 0x65C
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_opcode_ext_Eb
void ins_enc_opcode_ext_Eb(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(1);

	ParserASTNode *ins_node = data->ins_node;

	ParserASTNode *oprd = ins_node->childs[0];

	EncoderInstruction enc_ins;

	ins_init(data->ctx, ins, ins_node, &enc_ins);

	enc_ins.mod_rm_used = true;
	enc_ins.mod_rm.reg = ins->opcode_ext.reg;

	ins_fill_EX(data->ctx, ins, oprd, &enc_ins);

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
testq %rdi, %rdi
je 0x1aad5
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1aade
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1aae7
cmpl $0x1, 0x44(%rdx)
jne 0x1aaf0
movq %rdi, %r14
movq 0x48(%rdx), %rax
movq (%rax), %r15
movq 0x8(%rbx), %rdi
leaq -0x80(%rbp), %r12
movq %r14, %rsi
movq %r12, %rcx
callq 0x155a6
movb $0x1, 0x16(%r12)
movb 0x22(%r14), %al
shrb $0x2, %al
andb $0x7, %al
movb %al, 0x18(%r12)
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x157df
movq %rbx, %rdi
movq %r12, %rsi
callq 0x181fc
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16c9e(%rip), %rdi     # 0x3177a
jmp 0x1aaf7
leaq 0x1cb0f(%rip), %rdi     # 0x375f4
jmp 0x1aaf7
leaq 0x18203(%rip), %rdi     # 0x32cf1
jmp 0x1aaf7
leaq 0x1847b(%rip), %rdi     # 0x32f72
leaq 0x18196(%rip), %rsi     # 0x32c94
leaq 0x18c9e(%rip), %rcx     # 0x337a3
movl $0x66a, %edx            # imm = 0x66A
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_XXX_Iz
void ins_enc_XXX_Iz(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(1);

	ParserASTNode *ins_node = data->ins_node;

	ParserASTNode *oprd = ins_node->childs[0];

	EncoderInstruction enc_ins;

	ins_init(data->ctx, ins, ins_node, &enc_ins);

	switch (ASM_PARSER_CONTEXT_DATA_GET_ARCH(data->ctx)) {
		case ASM_ARCH_BIT16: {
			ins_fill_imm16(data->ctx, ins, oprd, &enc_ins);
			break;
		}
		case ASM_ARCH_BIT32:
		case ASM_ARCH_BIT64: {
			ins_fill_imm32(data->ctx, ins, oprd, &enc_ins);
			break;
		}
		default: {
			assert(0);
			break;
		}
	}

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
testq %rdi, %rdi
je 0x1ac70
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1ac79
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1ac82
cmpl $0x1, 0x44(%rdx)
jne 0x1ac8b
movq %rdi, %r14
movq 0x48(%rdx), %rax
movq (%rax), %r15
movq 0x8(%rbx), %rdi
leaq -0x78(%rbp), %rcx
movq %r14, %rsi
callq 0x155a6
movq 0x8(%rbx), %rdi
movl 0xb0(%rdi), %eax
cmpl $0x4, %eax
je 0x1ac4a
cmpl $0x2, %eax
je 0x1ac4a
cmpl $0x1, %eax
jne 0x1acaa
leaq -0x78(%rbp), %rcx
movq %r14, %rsi
movq %r15, %rdx
callq 0x160a9
jmp 0x1ac59
leaq -0x78(%rbp), %rcx
movq %r14, %rsi
movq %r15, %rdx
callq 0x1619f
leaq -0x78(%rbp), %rsi
movq %rbx, %rdi
callq 0x181fc
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16b03(%rip), %rdi     # 0x3177a
jmp 0x1ac92
leaq 0x1c974(%rip), %rdi     # 0x375f4
jmp 0x1ac92
leaq 0x18068(%rip), %rdi     # 0x32cf1
jmp 0x1ac92
leaq 0x182e0(%rip), %rdi     # 0x32f72
leaq 0x17ffb(%rip), %rsi     # 0x32c94
leaq 0x18b8b(%rip), %rcx     # 0x3382b
movl $0x696, %edx            # imm = 0x696
callq 0xa0b0
leaq 0x146e3(%rip), %rdi     # 0x2f394
leaq 0x17fdc(%rip), %rsi     # 0x32c94
leaq 0x18b6c(%rip), %rcx     # 0x3382b
movl $0x6ab, %edx            # imm = 0x6AB
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_IMUL_Gv_Ev_Iz
void ins_enc_IMUL_Gv_Ev_Iz(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(3);

	ParserASTNode *ins_node = data->ins_node;

	ParserASTNode *target = ins_node->childs[0];

	ParserASTNode *source1 = ins_node->childs[1];

	ParserASTNode *source2 = ins_node->childs[2];

	EncoderInstruction enc_ins;

	ins_init(data->ctx, ins, ins_node, &enc_ins);

	ins_fill_GX(data->ctx, ins, target, &enc_ins);

	ins_fill_EX(data->ctx, ins, source1, &enc_ins);

	ins_check_operand_type(data->ctx, ins, target, source1, NULL);

	switch (ins_get_oprd_size(data->ctx, target)) {
		case 2: {
			ins_fill_imm16(data->ctx, ins, source2, &enc_ins);
			break;
		}
		case 4:
		case 8: {
			ins_fill_imm32(data->ctx, ins, source2, &enc_ins);
			break;
		}
		default: {
			assert(0);
			break;
		}
	}

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
testq %rdi, %rdi
je 0x1adda
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1ade3
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1adec
cmpl $0x3, 0x44(%rdx)
jne 0x1adf5
movq %rdi, %r14
movq 0x48(%rdx), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rbx), %rdi
leaq -0x90(%rbp), %r15
movq %r14, %rsi
movq %r15, %rcx
callq 0x155a6
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x156a1
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x157df
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
callq 0x16a9b
movq 0x8(%rbx), %rdi
movq %r12, %rsi
callq 0x16a49
cmpq $0x8, %rax
je 0x1ada5
cmpq $0x4, %rax
je 0x1ada5
cmpq $0x2, %rax
jne 0x1ae14
movq 0x8(%rbx), %rdi
leaq -0x90(%rbp), %rcx
movq %r14, %rsi
movq -0x30(%rbp), %rdx
callq 0x160a9
jmp 0x1adbc
movq 0x8(%rbx), %rdi
leaq -0x90(%rbp), %rcx
movq %r14, %rsi
movq -0x30(%rbp), %rdx
callq 0x1619f
leaq -0x90(%rbp), %rsi
movq %rbx, %rdi
callq 0x181fc
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16999(%rip), %rdi     # 0x3177a
jmp 0x1adfc
leaq 0x1c80a(%rip), %rdi     # 0x375f4
jmp 0x1adfc
leaq 0x17efe(%rip), %rdi     # 0x32cf1
jmp 0x1adfc
leaq 0x18ab0(%rip), %rdi     # 0x338ac
leaq 0x17e91(%rip), %rsi     # 0x32c94
leaq 0x18a5e(%rip), %rcx     # 0x33868
movl $0x6b7, %edx            # imm = 0x6B7
callq 0xa0b0
leaq 0x14579(%rip), %rdi     # 0x2f394
leaq 0x17e72(%rip), %rsi     # 0x32c94
leaq 0x18a3f(%rip), %rcx     # 0x33868
movl $0x6d6, %edx            # imm = 0x6D6
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_XXX_Ib
void ins_enc_XXX_Ib(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(1);

	ParserASTNode *ins_node = data->ins_node;

	ParserASTNode *oprd = ins_node->childs[0];

	EncoderInstruction enc_ins;

	ins_init(data->ctx, ins, ins_node, &enc_ins);

	ins_fill_imm8(data->ctx, ins, oprd, &enc_ins);

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
testq %rdi, %rdi
je 0x1aea4
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1aead
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1aeb6
cmpl $0x1, 0x44(%rdx)
jne 0x1aebf
movq %rdi, %r14
movq 0x48(%rdx), %rax
movq (%rax), %r15
movq 0x8(%rbx), %rdi
leaq -0x80(%rbp), %r12
movq %r14, %rsi
movq %r12, %rcx
callq 0x155a6
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x15fb3
movq %rbx, %rdi
movq %r12, %rsi
callq 0x181fc
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x168cf(%rip), %rdi     # 0x3177a
jmp 0x1aec6
leaq 0x1c740(%rip), %rdi     # 0x375f4
jmp 0x1aec6
leaq 0x17e34(%rip), %rdi     # 0x32cf1
jmp 0x1aec6
leaq 0x180ac(%rip), %rdi     # 0x32f72
leaq 0x17dc7(%rip), %rsi     # 0x32c94
leaq 0x189f7(%rip), %rcx     # 0x338cb
movl $0x6e2, %edx            # imm = 0x6E2
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_IMUL_Gv_Ev_Ib
void ins_enc_IMUL_Gv_Ev_Ib(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(3);

	ParserASTNode *ins_node = data->ins_node;

	ParserASTNode *target = ins_node->childs[0];

	ParserASTNode *source1 = ins_node->childs[1];

	ParserASTNode *source2 = ins_node->childs[2];

	EncoderInstruction enc_ins;

	ins_init(data->ctx, ins, ins_node, &enc_ins);

	ins_fill_GX(data->ctx, ins, target, &enc_ins);

	ins_fill_EX(data->ctx, ins, source1, &enc_ins);

	ins_check_operand_type(data->ctx, ins, target, source1, NULL);

	ins_fill_imm8(data->ctx, ins, source2, &enc_ins);

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
testq %rdi, %rdi
je 0x1afac
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1afb5
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1afbe
cmpl $0x3, 0x44(%rdx)
jne 0x1afc7
movq %rdi, %r14
movq 0x48(%rdx), %rax
movq (%rax), %r13
movq 0x8(%rax), %r12
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rbx), %rdi
leaq -0x90(%rbp), %r15
movq %r14, %rsi
movq %r15, %rcx
callq 0x155a6
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x156a1
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x157df
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x16a9b
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq -0x30(%rbp), %rdx
movq %r15, %rcx
callq 0x15fb3
movq %rbx, %rdi
movq %r15, %rsi
callq 0x181fc
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x167c7(%rip), %rdi     # 0x3177a
jmp 0x1afce
leaq 0x1c638(%rip), %rdi     # 0x375f4
jmp 0x1afce
leaq 0x17d2c(%rip), %rdi     # 0x32cf1
jmp 0x1afce
leaq 0x188de(%rip), %rdi     # 0x338ac
leaq 0x17cbf(%rip), %rsi     # 0x32c94
leaq 0x1892c(%rip), %rcx     # 0x33908
movl $0x6f5, %edx            # imm = 0x6F5
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_INS_OUTS_W
void ins_enc_INS_OUTS_W(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(0);

	ParserASTNode *ins_node = data->ins_node;

	EncoderInstruction enc_ins;

	ins_init(data->ctx, ins, ins_node, &enc_ins);

	switch (ASM_PARSER_CONTEXT_DATA_GET_ARCH(data->ctx)) {
		case ASM_ARCH_BIT16: {
			break;
		}
		case ASM_ARCH_BIT32:
		case ASM_ARCH_BIT64: {
			enc_ins.legacy_prefix.operand_size_override = true;
			break;
		}
	}

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
testq %rdi, %rdi
je 0x1b045
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1b04e
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1b057
cmpl $0x0, 0x44(%rdx)
jne 0x1b060
movq %rdi, %rsi
movq 0x8(%rbx), %rdi
leaq -0x68(%rbp), %rcx
callq 0x155a6
movq 0x8(%rbx), %rax
movl 0xb0(%rax), %eax
cmpl $0x4, %eax
je 0x1b02e
cmpl $0x2, %eax
jne 0x1b032
movb $0x1, -0x5d(%rbp)
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x181fc
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1672e(%rip), %rdi     # 0x3177a
jmp 0x1b067
leaq 0x1c59f(%rip), %rdi     # 0x375f4
jmp 0x1b067
leaq 0x17c93(%rip), %rdi     # 0x32cf1
jmp 0x1b067
leaq 0x1805b(%rip), %rdi     # 0x330c2
leaq 0x17c26(%rip), %rsi     # 0x32c94
leaq 0x188d7(%rip), %rcx     # 0x3394c
movl $0x712, %edx            # imm = 0x712
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_POP_Ev
void ins_enc_POP_Ev(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(1);

	ParserASTNode *ins_node = data->ins_node;

	ParserASTNode *oprd = ins_node->childs[0];

	EncoderInstruction enc_ins;
	
	ins_init(data->ctx, ins, ins_node, &enc_ins);

	size_t oprd_size = ins_get_oprd_size(data->ctx, oprd);

	switch (ASM_PARSER_CONTEXT_DATA_GET_ARCH(data->ctx)) {
		case ASM_ARCH_BIT16: {
			if (oprd_size == 2
					|| oprd_size == 4) {
				ins_fill_EX(data->ctx, ins, oprd, &enc_ins);
			} else {
				data->ctx->syntax_error_node_msg(
					data->ctx,
					ins_node,
					"instruction not supported in 16-bit mode."
				);
			}
			break;
		}
		case ASM_ARCH_BIT32: {
			if (oprd_size == 2
					|| oprd_size == 4) {
				ins_fill_EX(data->ctx, ins, oprd, &enc_ins);
			} else {
				data->ctx->syntax_error_node_msg(
					data->ctx,
					ins_node,
					"instruction not supported in 32-bit mode."
				);
			}
			break;
		}
		case ASM_ARCH_BIT64: {
			if (oprd_size == 2
					|| oprd_size == 8) {
				ins_fill_EX(data->ctx, ins, oprd, &enc_ins);
			} else {
				data->ctx->syntax_error_node_msg(
					data->ctx,
					ins_node,
					"instruction not supported in 64-bit mode."
				);
			}
			break;
		}
		default: {
			assert(0);
			break;
		}
	}

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
testq %rdi, %rdi
je 0x1b46c
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1b475
movq (%rbx), %r15
testq %r15, %r15
je 0x1b47e
cmpl $0x1, 0x44(%r15)
jne 0x1b487
movq %rdi, %r14
movq 0x48(%r15), %rax
movq (%rax), %r12
movq 0x8(%rbx), %rdi
leaq -0x80(%rbp), %rcx
movq %r14, %rsi
movq %r15, %rdx
callq 0x155a6
movq 0x8(%rbx), %rdi
movq %r12, %rsi
callq 0x16a49
movq 0x8(%rbx), %rdi
movl 0xb0(%rdi), %ecx
cmpl $0x4, %ecx
je 0x1b429
cmpl $0x2, %ecx
je 0x1b414
cmpl $0x1, %ecx
jne 0x1b4a6
cmpq $0x4, %rax
je 0x1b435
cmpq $0x2, %rax
je 0x1b435
leaq 0x17a8e(%rip), %rdx     # 0x32ea0
jmp 0x1b44d
cmpq $0x4, %rax
je 0x1b435
cmpq $0x2, %rax
je 0x1b435
leaq 0x17aa3(%rip), %rdx     # 0x32eca
jmp 0x1b44d
cmpq $0x8, %rax
je 0x1b435
cmpq $0x2, %rax
jne 0x1b446
leaq -0x80(%rbp), %rcx
movq %r14, %rsi
movq %r12, %rdx
callq 0x157df
jmp 0x1b453
leaq 0x17b85(%rip), %rdx     # 0x32fd2
movq %r15, %rsi
callq *0x58(%rdi)
leaq -0x80(%rbp), %rsi
movq %rbx, %rdi
callq 0x181fc
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16307(%rip), %rdi     # 0x3177a
jmp 0x1b48e
leaq 0x1c178(%rip), %rdi     # 0x375f4
jmp 0x1b48e
leaq 0x1786c(%rip), %rdi     # 0x32cf1
jmp 0x1b48e
leaq 0x17ae4(%rip), %rdi     # 0x32f72
leaq 0x177ff(%rip), %rsi     # 0x32c94
leaq 0x185f1(%rip), %rcx     # 0x33a8d
movl $0x78d, %edx            # imm = 0x78D
callq 0xa0b0
leaq 0x13ee7(%rip), %rdi     # 0x2f394
leaq 0x177e0(%rip), %rsi     # 0x32c94
leaq 0x185d2(%rip), %rcx     # 0x33a8d
movl $0x7c2, %edx            # imm = 0x7C2
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_opcode_implicit_oprd64
void ins_enc_opcode_implicit_oprd64(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(0);

	ParserASTNode *ins_node = data->ins_node;

	EncoderInstruction enc_ins;
	
	ins_init(data->ctx, ins, ins_node, &enc_ins);

	switch (ASM_PARSER_CONTEXT_DATA_GET_ARCH(data->ctx)) {
		case ASM_ARCH_BIT16: {
			data->ctx->syntax_error_node_msg(
				data->ctx,
				ins_node,
				"instruction not supported in 16-bit mode."
			);
			break;
		}
		case ASM_ARCH_BIT32: {
			data->ctx->syntax_error_node_msg(
				data->ctx,
				ins_node,
				"instruction not supported in 32-bit mode."
			);
			break;
		}
		case ASM_ARCH_BIT64: {
			enc_ins.rex_prefix_used = true;
			enc_ins.rex_prefix.w = true;
			break;
		}
		default: {
			assert(0);
			break;
		}
	}

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
testq %rdi, %rdi
je 0x1b6c5
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1b6ce
movq (%rbx), %r14
testq %r14, %r14
je 0x1b6d7
cmpl $0x0, 0x44(%r14)
jne 0x1b6e0
movq %rdi, %rsi
movq 0x8(%rbx), %rdi
leaq -0x70(%rbp), %rcx
movq %r14, %rdx
callq 0x155a6
movq 0x8(%rbx), %rdi
movl 0xb0(%rdi), %eax
cmpl $0x4, %eax
je 0x1b6aa
cmpl $0x2, %eax
je 0x1b69b
cmpl $0x1, %eax
jne 0x1b6ff
leaq 0x17807(%rip), %rdx     # 0x32ea0
jmp 0x1b6a2
leaq 0x17828(%rip), %rdx     # 0x32eca
movq %r14, %rsi
callq *0x58(%rdi)
jmp 0x1b6b0
movw $0x101, -0x63(%rbp)     # imm = 0x101
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x181fc
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x160ae(%rip), %rdi     # 0x3177a
jmp 0x1b6e7
leaq 0x1bf1f(%rip), %rdi     # 0x375f4
jmp 0x1b6e7
leaq 0x17613(%rip), %rdi     # 0x32cf1
jmp 0x1b6e7
leaq 0x179db(%rip), %rdi     # 0x330c2
leaq 0x175a6(%rip), %rsi     # 0x32c94
leaq 0x1846f(%rip), %rcx     # 0x33b64
movl $0x80c, %edx            # imm = 0x80C
callq 0xa0b0
leaq 0x13c8e(%rip), %rdi     # 0x2f394
leaq 0x17587(%rip), %rsi     # 0x32c94
leaq 0x18450(%rip), %rcx     # 0x33b64
movl $0x82b, %edx            # imm = 0x82B
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_pushfd_popfd
void ins_enc_pushfd_popfd(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(0);

	ParserASTNode *ins_node = data->ins_node;

	EncoderInstruction enc_ins;
	
	ins_init(data->ctx, ins, ins_node, &enc_ins);

	switch (ASM_PARSER_CONTEXT_DATA_GET_ARCH(data->ctx)) {
		case ASM_ARCH_BIT16: {
			enc_ins.legacy_prefix.operand_size_override = true;
			break;
		}
		case ASM_ARCH_BIT32: {

			break;
		}
		case ASM_ARCH_BIT64: {
			data->ctx->syntax_error_node_msg(
				data->ctx,
				ins_node,
				"instruction not supported in 64-bit mode."
			);
			break;
		}
		default: {
			assert(0);
			break;
		}
	}

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
testq %rdi, %rdi
je 0x1b980
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1b989
movq (%rbx), %r14
testq %r14, %r14
je 0x1b992
cmpl $0x0, 0x44(%r14)
jne 0x1b99b
movq %rdi, %rsi
movq 0x8(%rbx), %rdi
leaq -0x70(%rbp), %rcx
movq %r14, %rdx
callq 0x155a6
movq 0x8(%rbx), %rdi
movl 0xb0(%rdi), %eax
cmpl $0x4, %eax
je 0x1b95e
cmpl $0x2, %eax
je 0x1b96b
cmpl $0x1, %eax
jne 0x1b9ba
movb $0x1, -0x65(%rbp)
jmp 0x1b96b
leaq 0x1766d(%rip), %rdx     # 0x32fd2
movq %r14, %rsi
callq *0x58(%rdi)
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x181fc
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x15df3(%rip), %rdi     # 0x3177a
jmp 0x1b9a2
leaq 0x1bc64(%rip), %rdi     # 0x375f4
jmp 0x1b9a2
leaq 0x17358(%rip), %rdi     # 0x32cf1
jmp 0x1b9a2
leaq 0x17720(%rip), %rdi     # 0x330c2
leaq 0x172eb(%rip), %rsi     # 0x32c94
leaq 0x1823a(%rip), %rcx     # 0x33bea
movl $0x8a6, %edx            # imm = 0x8A6
callq 0xa0b0
leaq 0x139d3(%rip), %rdi     # 0x2f394
leaq 0x172cc(%rip), %rsi     # 0x32c94
leaq 0x1821b(%rip), %rcx     # 0x33bea
movl $0x8c0, %edx            # imm = 0x8C0
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_pushfq_popfq
void ins_enc_pushfq_popfq(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(0);

	ParserASTNode *ins_node = data->ins_node;

	EncoderInstruction enc_ins;
	
	ins_init(data->ctx, ins, ins_node, &enc_ins);

	switch (ASM_PARSER_CONTEXT_DATA_GET_ARCH(data->ctx)) {
		case ASM_ARCH_BIT16: {
			data->ctx->syntax_error_node_msg(
				data->ctx,
				ins_node,
				"instruction not supported in 16-bit mode."
			);
			break;
		}
		case ASM_ARCH_BIT32: {
			data->ctx->syntax_error_node_msg(
				data->ctx,
				ins_node,
				"instruction not supported in 32-bit mode."
			);
			break;
		}
		case ASM_ARCH_BIT64: {
			
			break;
		}
		default: {
			assert(0);
			break;
		}
	}

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
testq %rdi, %rdi
je 0x1ba57
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1ba60
movq (%rbx), %r14
testq %r14, %r14
je 0x1ba69
cmpl $0x0, 0x44(%r14)
jne 0x1ba72
movq %rdi, %rsi
movq 0x8(%rbx), %rdi
leaq -0x70(%rbp), %rcx
movq %r14, %rdx
callq 0x155a6
movq 0x8(%rbx), %rdi
movl 0xb0(%rdi), %eax
cmpl $0x1, %eax
je 0x1ba35
cmpl $0x4, %eax
je 0x1ba42
cmpl $0x2, %eax
jne 0x1ba91
leaq 0x17497(%rip), %rdx     # 0x32eca
jmp 0x1ba3c
leaq 0x17464(%rip), %rdx     # 0x32ea0
movq %r14, %rsi
callq *0x58(%rdi)
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x181fc
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x15d1c(%rip), %rdi     # 0x3177a
jmp 0x1ba79
leaq 0x1bb8d(%rip), %rdi     # 0x375f4
jmp 0x1ba79
leaq 0x17281(%rip), %rdi     # 0x32cf1
jmp 0x1ba79
leaq 0x17649(%rip), %rdi     # 0x330c2
leaq 0x17214(%rip), %rsi     # 0x32c94
leaq 0x181a6(%rip), %rcx     # 0x33c2d
movl $0x8cc, %edx            # imm = 0x8CC
callq 0xa0b0
leaq 0x138fc(%rip), %rdi     # 0x2f394
leaq 0x171f5(%rip), %rsi     # 0x32c94
leaq 0x18187(%rip), %rcx     # 0x33c2d
movl $0x8ea, %edx            # imm = 0x8EA
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_enter
void ins_enc_enter(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(2);

	ParserASTNode *ins_node = data->ins_node;

	ParserASTNode *oprd_iw = ins_node->childs[0];
	ParserASTNode *oprd_ib = ins_node->childs[1];

	EncoderInstruction enc_ins;

	ins_init(data->ctx, ins, ins_node, &enc_ins);

	ins_add_uint16_expr_to_ext(
		data->ctx,
		ins,
		&enc_ins,
		oprd_iw
	);
	ins_add_uint8_expr_to_ext(
		data->ctx,
		ins,
		&enc_ins,
		oprd_ib
	);

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
testq %rdi, %rdi
je 0x1bb3e
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1bb47
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1bb50
cmpl $0x2, 0x44(%rdx)
jne 0x1bb59
movq %rdi, %r14
movq 0x48(%rdx), %rax
movq (%rax), %r15
movq 0x8(%rax), %r12
movq 0x8(%rbx), %rdi
leaq -0x88(%rbp), %r13
movq %r14, %rsi
movq %r13, %rcx
callq 0x155a6
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x16608
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x1650a
movq %rbx, %rdi
movq %r13, %rsi
callq 0x181fc
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15c35(%rip), %rdi     # 0x3177a
jmp 0x1bb60
leaq 0x1baa6(%rip), %rdi     # 0x375f4
jmp 0x1bb60
leaq 0x1719a(%rip), %rdi     # 0x32cf1
jmp 0x1bb60
leaq 0x171a0(%rip), %rdi     # 0x32d00
leaq 0x1712d(%rip), %rsi     # 0x32c94
leaq 0x18102(%rip), %rcx     # 0x33c70
movl $0x8f6, %edx            # imm = 0x8F6
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_Jz
void ins_enc_Jz(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(1);

	ParserASTNode *ins_node = data->ins_node;

	ParserASTNode *node_label = data->ins_node->childs[0];

	uint64_t addr = asm_parser_get_symbol_by_token_key(data->ctx, node_label->token);

	EncoderInstruction enc_ins;
	
	ins_init(data->ctx, ins, ins_node, &enc_ins);

	switch (ASM_PARSER_CONTEXT_DATA_GET_ARCH(data->ctx)) {
		case ASM_ARCH_BIT16: {
			enc_ins.disp_len = 2;
			break;
		}
		case ASM_ARCH_BIT32:
		case ASM_ARCH_BIT64: {
			enc_ins.disp_len = 4;
			break;
		}
		default: {
			assert(0);
			break;
		}
	}

	enc_ins.disp = 0;

	uint8_t buffer[32];
	size_t len = enc_ins_encode(&enc_ins, buffer, sizeof(buffer));

	uint64_t ip = ASM_PARSER_CONTEXT_DATA_GET_ADDRESS_COUNTER(data->ctx) + len;
	uint64_t offset = addr - ip;
	enc_ins.disp = offset;

	len = enc_ins_encode(&enc_ins, buffer, sizeof(buffer));

	ASM_PARSER_CONTEXT_DATA_INC_ADDRESS_COUNTER(data->ctx, len);
	if (ASM_PARSER_CONTEXT_DATA_GET_STEP(data->ctx) == ASM_STEP_SCAN) {
		return;
	}

	fwrite(buffer, len, 1, ASM_PARSER_CONTEXT_DATA_GET_OUT(data->ctx));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
testq %rdi, %rdi
je 0x1be2c
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1be35
movq (%rbx), %r12
testq %r12, %r12
je 0x1be3e
cmpl $0x1, 0x44(%r12)
jne 0x1be47
movq %rdi, %r15
movq 0x48(%r12), %rax
movq (%rax), %rax
movq 0x8(%rbx), %rdi
movq 0x10(%rax), %rsi
callq 0x1f0af
movq %rax, %r14
movq 0x8(%rbx), %rdi
leaq -0xa0(%rbp), %rcx
movq %r15, %rsi
movq %r12, %rdx
callq 0x155a6
movq 0x8(%rbx), %rax
movl 0xb0(%rax), %eax
cmpl $0x1, %eax
je 0x1bda5
cmpl $0x4, %eax
je 0x1bda1
cmpl $0x2, %eax
jne 0x1be66
movb $0x4, %al
jmp 0x1bda7
movb $0x2, %al
leaq -0xa0(%rbp), %r15
movb %al, 0x1e(%r15)
movq $0x0, 0x20(%r15)
leaq -0x40(%rbp), %r12
movl $0x20, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x148c4
movq 0x8(%rbx), %rcx
addq 0xc0(%rcx), %rax
subq %rax, %r14
movq %r14, 0x20(%r15)
movl $0x20, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x148c4
movq 0x8(%rbx), %rcx
addq %rax, 0xc0(%rcx)
cmpl $0x1, 0xc8(%rcx)
je 0x1be1c
movq 0xb8(%rcx), %rcx
leaq -0x40(%rbp), %rdi
movl $0x1, %edx
movq %rax, %rsi
callq 0xa170
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15947(%rip), %rdi     # 0x3177a
jmp 0x1be4e
leaq 0x1b7b8(%rip), %rdi     # 0x375f4
jmp 0x1be4e
leaq 0x16eac(%rip), %rdi     # 0x32cf1
jmp 0x1be4e
leaq 0x17124(%rip), %rdi     # 0x32f72
leaq 0x16e3f(%rip), %rsi     # 0x32c94
leaq 0x17ec8(%rip), %rcx     # 0x33d24
movl $0x95f, %edx            # imm = 0x95F
callq 0xa0b0
leaq 0x13527(%rip), %rdi     # 0x2f394
leaq 0x16e20(%rip), %rsi     # 0x32c94
leaq 0x17ea9(%rip), %rcx     # 0x33d24
movl $0x976, %edx            # imm = 0x976
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_IN_eAX_DX
void ins_enc_IN_eAX_DX(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(2);

	ParserASTNode *ins_node = data->ins_node;

	ParserASTNode *target = ins_node->childs[0];

	EncoderInstruction enc_ins;

	ins_init(data->ctx, ins, ins_node, &enc_ins);

	InsRegister *target_reg = ASM_REG_AST_NODE_GET_REG(target);

	switch (ASM_PARSER_CONTEXT_DATA_GET_ARCH(data->ctx)) {
		case ASM_ARCH_BIT16: {
			switch (target_reg->type) {
				case INS_REGISTER_GENERAL_2BYTE: {
					
					break;
				}
				case INS_REGISTER_GENERAL_4BYTE: {
					enc_ins.legacy_prefix.operand_size_override = true;
					break;
				}
				default: {
					assert(0);
					break;
				}
			}
			break;
		}
		case ASM_ARCH_BIT32:
		case ASM_ARCH_BIT64: {
			switch (target_reg->type) {
				case INS_REGISTER_GENERAL_2BYTE: {
					enc_ins.legacy_prefix.operand_size_override = true;
					break;
				}
				case INS_REGISTER_GENERAL_4BYTE: {
					
					break;
				}
				default: {
					assert(0);
					break;
				}
			}
			break;
		}
		default: {
			assert(0);
			break;
		}
	}

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
testq %rdi, %rdi
je 0x1bf64
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1bf6d
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1bf76
cmpl $0x2, 0x44(%rdx)
jne 0x1bf7f
movq %rdi, %rsi
movq 0x48(%rdx), %rax
movq (%rax), %r14
movq 0x8(%rbx), %rdi
leaq -0x70(%rbp), %rcx
callq 0x155a6
movq 0x60(%r14), %rax
movq 0x8(%rbx), %rcx
movl 0xb0(%rcx), %ecx
cmpl $0x4, %ecx
je 0x1bf1f
cmpl $0x2, %ecx
je 0x1bf1f
cmpl $0x1, %ecx
jne 0x1bf9e
movl 0xc(%rax), %eax
cmpl $0x3, %eax
je 0x1bf4f
cmpl $0x4, %eax
je 0x1bf4b
leaq 0x1348d(%rip), %rdi     # 0x2f394
leaq 0x16d86(%rip), %rsi     # 0x32c94
leaq 0x17e48(%rip), %rcx     # 0x33d5d
movl $0x9aa, %edx            # imm = 0x9AA
callq 0xa0b0
movl 0xc(%rax), %eax
cmpl $0x3, %eax
je 0x1bf4b
cmpl $0x4, %eax
je 0x1bf4f
leaq 0x13461(%rip), %rdi     # 0x2f394
leaq 0x16d5a(%rip), %rsi     # 0x32c94
leaq 0x17e1c(%rip), %rcx     # 0x33d5d
movl $0x9bc, %edx            # imm = 0x9BC
callq 0xa0b0
movb $0x1, -0x65(%rbp)
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x181fc
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1580f(%rip), %rdi     # 0x3177a
jmp 0x1bf86
leaq 0x1b680(%rip), %rdi     # 0x375f4
jmp 0x1bf86
leaq 0x16d74(%rip), %rdi     # 0x32cf1
jmp 0x1bf86
leaq 0x16d7a(%rip), %rdi     # 0x32d00
leaq 0x16d07(%rip), %rsi     # 0x32c94
leaq 0x17dc9(%rip), %rcx     # 0x33d5d
movl $0x992, %edx            # imm = 0x992
callq 0xa0b0
leaq 0x133ef(%rip), %rdi     # 0x2f394
leaq 0x16ce8(%rip), %rsi     # 0x32c94
leaq 0x17daa(%rip), %rcx     # 0x33d5d
movl $0x9c3, %edx            # imm = 0x9C3
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_OUT_DX_eAX
void ins_enc_OUT_DX_eAX(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(2);

	ParserASTNode *ins_node = data->ins_node;

	ParserASTNode *source = ins_node->childs[1];

	EncoderInstruction enc_ins;

	ins_init(data->ctx, ins, ins_node, &enc_ins);

	InsRegister *source_reg = ASM_REG_AST_NODE_GET_REG(source);

	switch (ASM_PARSER_CONTEXT_DATA_GET_ARCH(data->ctx)) {
		case ASM_ARCH_BIT16: {
			switch (source_reg->type) {
				case INS_REGISTER_GENERAL_2BYTE: {
					
					break;
				}
				case INS_REGISTER_GENERAL_4BYTE: {
					enc_ins.legacy_prefix.operand_size_override = true;
					break;
				}
				default: {
					assert(0);
					break;
				}
			}
			break;
		}
		case ASM_ARCH_BIT32:
		case ASM_ARCH_BIT64: {
			switch (source_reg->type) {
				case INS_REGISTER_GENERAL_2BYTE: {
					enc_ins.legacy_prefix.operand_size_override = true;
					break;
				}
				case INS_REGISTER_GENERAL_4BYTE: {
					
					break;
				}
				default: {
					assert(0);
					break;
				}
			}
			break;
		}
		default: {
			assert(0);
			break;
		}
	}

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
testq %rdi, %rdi
je 0x1c09d
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1c0a6
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1c0af
cmpl $0x2, 0x44(%rdx)
jne 0x1c0b8
movq %rdi, %rsi
movq 0x48(%rdx), %rax
movq 0x8(%rax), %r14
movq 0x8(%rbx), %rdi
leaq -0x70(%rbp), %rcx
callq 0x155a6
movq 0x60(%r14), %rax
movq 0x8(%rbx), %rcx
movl 0xb0(%rcx), %ecx
cmpl $0x4, %ecx
je 0x1c058
cmpl $0x2, %ecx
je 0x1c058
cmpl $0x1, %ecx
jne 0x1c0d7
movl 0xc(%rax), %eax
cmpl $0x3, %eax
je 0x1c088
cmpl $0x4, %eax
je 0x1c084
leaq 0x13354(%rip), %rdi     # 0x2f394
leaq 0x16c4d(%rip), %rsi     # 0x32c94
leaq 0x17d4f(%rip), %rcx     # 0x33d9d
movl $0x9e7, %edx            # imm = 0x9E7
callq 0xa0b0
movl 0xc(%rax), %eax
cmpl $0x3, %eax
je 0x1c084
cmpl $0x4, %eax
je 0x1c088
leaq 0x13328(%rip), %rdi     # 0x2f394
leaq 0x16c21(%rip), %rsi     # 0x32c94
leaq 0x17d23(%rip), %rcx     # 0x33d9d
movl $0x9f9, %edx            # imm = 0x9F9
callq 0xa0b0
movb $0x1, -0x65(%rbp)
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x181fc
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x156d6(%rip), %rdi     # 0x3177a
jmp 0x1c0bf
leaq 0x1b547(%rip), %rdi     # 0x375f4
jmp 0x1c0bf
leaq 0x16c3b(%rip), %rdi     # 0x32cf1
jmp 0x1c0bf
leaq 0x16c41(%rip), %rdi     # 0x32d00
leaq 0x16bce(%rip), %rsi     # 0x32c94
leaq 0x17cd0(%rip), %rcx     # 0x33d9d
movl $0x9cf, %edx            # imm = 0x9CF
callq 0xa0b0
leaq 0x132b6(%rip), %rdi     # 0x2f394
leaq 0x16baf(%rip), %rsi     # 0x32c94
leaq 0x17cb1(%rip), %rcx     # 0x33d9d
movl $0xa00, %edx            # imm = 0xA00
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_opcode_ext_XXX_Rv
void ins_enc_opcode_ext_XXX_Rv(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(1);

	ParserASTNode *ins_node = data->ins_node;

	ParserASTNode *rv_node = data->ins_node->childs[0];

	EncoderInstruction enc_ins;
	
	ins_init(data->ctx, ins, ins_node, &enc_ins);

	enc_ins.mod_rm_used = true;
	enc_ins.mod_rm.reg = ins->opcode_ext.reg;

	ins_fill_RX(data->ctx, ins, rv_node, &enc_ins);

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
testq %rdi, %rdi
je 0x1c17b
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1c184
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1c18d
cmpl $0x1, 0x44(%rdx)
jne 0x1c196
movq %rdi, %r14
movq 0x48(%rdx), %rax
movq (%rax), %r15
movq 0x8(%rbx), %rdi
leaq -0x80(%rbp), %r12
movq %r14, %rsi
movq %r12, %rcx
callq 0x155a6
movb $0x1, 0x16(%r12)
movb 0x22(%r14), %al
shrb $0x2, %al
andb $0x7, %al
movb %al, 0x18(%r12)
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x15e29
movq %rbx, %rdi
movq %r12, %rsi
callq 0x181fc
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x155f8(%rip), %rdi     # 0x3177a
jmp 0x1c19d
leaq 0x1b469(%rip), %rdi     # 0x375f4
jmp 0x1c19d
leaq 0x16b5d(%rip), %rdi     # 0x32cf1
jmp 0x1c19d
leaq 0x16dd5(%rip), %rdi     # 0x32f72
leaq 0x16af0(%rip), %rsi     # 0x32c94
leaq 0x17c33(%rip), %rcx     # 0x33dde
movl $0xa0c, %edx            # imm = 0xA0C
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_opcode_ext_XXX_Mv
void ins_enc_opcode_ext_XXX_Mv(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(1);

	ParserASTNode *ins_node = data->ins_node;

	ParserASTNode *mv_node = data->ins_node->childs[0];

	EncoderInstruction enc_ins;
	
	ins_init(data->ctx, ins, ins_node, &enc_ins);

	enc_ins.mod_rm_used = true;
	enc_ins.mod_rm.reg = ins->opcode_ext.reg;

	ins_fill_MX(data->ctx, ins, mv_node, &enc_ins);

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
testq %rdi, %rdi
je 0x1c23a
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1c243
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1c24c
cmpl $0x1, 0x44(%rdx)
jne 0x1c255
movq %rdi, %r14
movq 0x48(%rdx), %rax
movq (%rax), %r15
movq 0x8(%rbx), %rdi
leaq -0x80(%rbp), %r12
movq %r14, %rsi
movq %r12, %rcx
callq 0x155a6
movb $0x1, 0x16(%r12)
movb 0x22(%r14), %al
shrb $0x2, %al
andb $0x7, %al
movb %al, 0x18(%r12)
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x15eee
movq %rbx, %rdi
movq %r12, %rsi
callq 0x181fc
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15539(%rip), %rdi     # 0x3177a
jmp 0x1c25c
leaq 0x1b3aa(%rip), %rdi     # 0x375f4
jmp 0x1c25c
leaq 0x16a9e(%rip), %rdi     # 0x32cf1
jmp 0x1c25c
leaq 0x16d16(%rip), %rdi     # 0x32f72
leaq 0x16a31(%rip), %rsi     # 0x32c94
leaq 0x17bbc(%rip), %rcx     # 0x33e26
movl $0xa22, %edx            # imm = 0xA22
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_opcode_ext_XXX_Ew
void ins_enc_opcode_ext_XXX_Ew(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(1);

	ParserASTNode *ins_node = data->ins_node;

	ParserASTNode *ew_node = data->ins_node->childs[0];

	EncoderInstruction enc_ins;
	
	ins_init(data->ctx, ins, ins_node, &enc_ins);

	enc_ins.mod_rm_used = true;
	enc_ins.mod_rm.reg = ins->opcode_ext.reg;

	ins_fill_EX(data->ctx, ins, ew_node, &enc_ins);

	enc_ins.legacy_prefix.operand_size_override = false;

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
testq %rdi, %rdi
je 0x1c489
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1c492
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1c49b
cmpl $0x1, 0x44(%rdx)
jne 0x1c4a4
movq %rdi, %r14
movq 0x48(%rdx), %rax
movq (%rax), %r15
movq 0x8(%rbx), %rdi
leaq -0x80(%rbp), %r12
movq %r14, %rsi
movq %r12, %rcx
callq 0x155a6
movb $0x1, 0x16(%r12)
movb 0x22(%r14), %al
shrb $0x2, %al
andb $0x7, %al
movb %al, 0x18(%r12)
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x157df
movb $0x0, 0xb(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x181fc
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x152ea(%rip), %rdi     # 0x3177a
jmp 0x1c4ab
leaq 0x1b15b(%rip), %rdi     # 0x375f4
jmp 0x1c4ab
leaq 0x1684f(%rip), %rdi     # 0x32cf1
jmp 0x1c4ab
leaq 0x16ac7(%rip), %rdi     # 0x32f72
leaq 0x167e2(%rip), %rsi     # 0x32c94
leaq 0x17a45(%rip), %rcx     # 0x33efe
movl $0xa68, %edx            # imm = 0xA68
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_opcode_ext_XXX_Ms
void ins_enc_opcode_ext_XXX_Ms(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(1);

	ParserASTNode *ins_node = data->ins_node;

	ParserASTNode *ms_node = data->ins_node->childs[0];

	EncoderInstruction enc_ins;
	
	ins_init(data->ctx, ins, ins_node, &enc_ins);

	enc_ins.mod_rm_used = true;
	enc_ins.mod_rm.reg = ins->opcode_ext.reg;

	ins_fill_MX(data->ctx, ins, ms_node, &enc_ins);

	enc_ins.legacy_prefix.operand_size_override = false;

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
testq %rdi, %rdi
je 0x1c54e
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1c557
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1c560
cmpl $0x1, 0x44(%rdx)
jne 0x1c569
movq %rdi, %r14
movq 0x48(%rdx), %rax
movq (%rax), %r15
movq 0x8(%rbx), %rdi
leaq -0x80(%rbp), %r12
movq %r14, %rsi
movq %r12, %rcx
callq 0x155a6
movb $0x1, 0x16(%r12)
movb 0x22(%r14), %al
shrb $0x2, %al
andb $0x7, %al
movb %al, 0x18(%r12)
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x15eee
movb $0x0, 0xb(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x181fc
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15225(%rip), %rdi     # 0x3177a
jmp 0x1c570
leaq 0x1b096(%rip), %rdi     # 0x375f4
jmp 0x1c570
leaq 0x1678a(%rip), %rdi     # 0x32cf1
jmp 0x1c570
leaq 0x16a02(%rip), %rdi     # 0x32f72
leaq 0x1671d(%rip), %rsi     # 0x32c94
leaq 0x179c8(%rip), %rcx     # 0x33f46
movl $0xa80, %edx            # imm = 0xA80
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_opcode_ext_rm
void ins_enc_opcode_ext_rm(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(0);

	ParserASTNode *ins_node = data->ins_node;

	EncoderInstruction enc_ins;
	
	ins_init(data->ctx, ins, ins_node, &enc_ins);

	enc_ins.mod_rm_used = true;
	enc_ins.mod_rm.reg = ins->opcode_ext.reg;
	if (ins->opcode_ext.mod == INS_OPCODE_EXT_MOD_11B) {
		enc_ins.mod_rm.mod = 0x3;
	}
	enc_ins.mod_rm.rm = ins->opcode_ext.rm;

	enc_ins.legacy_prefix.operand_size_override = false;

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
testq %rdi, %rdi
je 0x1c60a
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1c613
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1c61c
cmpl $0x0, 0x44(%rdx)
jne 0x1c625
movq %rdi, %r14
movq 0x8(%rbx), %rdi
leaq -0x78(%rbp), %r15
movq %r14, %rsi
movq %r15, %rcx
callq 0x155a6
movb $0x1, 0x16(%r15)
movb 0x22(%r14), %al
movl %eax, %ecx
shrb $0x2, %cl
andb $0x7, %cl
movb %cl, 0x18(%r15)
movl %eax, %ecx
andb $0x3, %cl
cmpb $0x2, %cl
jne 0x1c5e9
movb $0x3, -0x61(%rbp)
shrb $0x5, %al
leaq -0x78(%rbp), %rsi
movb %al, 0x19(%rsi)
movb $0x0, 0xb(%rsi)
movq %rbx, %rdi
callq 0x181fc
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15169(%rip), %rdi     # 0x3177a
jmp 0x1c62c
leaq 0x1afda(%rip), %rdi     # 0x375f4
jmp 0x1c62c
leaq 0x166ce(%rip), %rdi     # 0x32cf1
jmp 0x1c62c
leaq 0x16a96(%rip), %rdi     # 0x330c2
leaq 0x16661(%rip), %rsi     # 0x32c94
leaq 0x17954(%rip), %rcx     # 0x33f8e
movl $0xa98, %edx            # imm = 0xA98
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/lexer.c
// Function: asm_lexer_new_context
LexerContext * asm_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 0x1c663
testq %rsi, %rsi
je 0x1c682
testl %edx, %edx
js 0x1c6a1
leaq 0x2a6f3(%rip), %rcx     # 0x46d50
popq %rbp
jmp 0xae24
leaq 0x123af(%rip), %rdi     # 0x2ea19
leaq 0x17983(%rip), %rsi     # 0x33ff4
leaq 0x17997(%rip), %rcx     # 0x3400f
movl $0x145, %edx            # imm = 0x145
callq 0xa0b0
leaq 0x11ebd(%rip), %rdi     # 0x2e546
leaq 0x17964(%rip), %rsi     # 0x33ff4
leaq 0x17978(%rip), %rcx     # 0x3400f
movl $0x146, %edx            # imm = 0x146
callq 0xa0b0
leaq 0x11ea5(%rip), %rdi     # 0x2e54d
leaq 0x17945(%rip), %rsi     # 0x33ff4
leaq 0x17959(%rip), %rcx     # 0x3400f
movl $0x147, %edx            # imm = 0x147
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/lexer.c
// Function: asm_lexer_get_uint32_val
uint32_t asm_lexer_get_uint32_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	switch (token->type) {
		case ASM_TOKEN_LITERAL_UINT_BIN: {
			return util_get_uint32_bin_val(token->content, token->len);
		}
		case ASM_TOKEN_LITERAL_UINT_OCT: {
			return util_get_uint32_oct_val(token->content, token->len);
		}
		case ASM_TOKEN_LITERAL_UINT_DEC: {
			return util_get_uint32_dec_val(token->content, token->len);
		}
		case ASM_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 0x1c74e
testq %rsi, %rsi
je 0x1c76d
movl $0xfffff000, %eax       # imm = 0xFFFFF000
addl (%rsi), %eax
cmpl $0x3, %eax
ja 0x1c78c
leaq 0x178c3(%rip), %rcx     # 0x33fd4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x1118f
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x113d3
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x11577
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x112b7
leaq 0x1a001(%rip), %rdi     # 0x36756
leaq 0x17898(%rip), %rsi     # 0x33ff4
leaq 0x1791d(%rip), %rcx     # 0x34080
movl $0x158, %edx            # imm = 0x158
callq 0xa0b0
leaq 0x11d56(%rip), %rdi     # 0x2e4ca
leaq 0x17879(%rip), %rsi     # 0x33ff4
leaq 0x178fe(%rip), %rcx     # 0x34080
movl $0x159, %edx            # imm = 0x159
callq 0xa0b0
leaq 0x12c01(%rip), %rdi     # 0x2f394
leaq 0x1785a(%rip), %rsi     # 0x33ff4
leaq 0x178df(%rip), %rcx     # 0x34080
movl $0x169, %edx            # imm = 0x169
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/lexer.c
// Function: asm_lexer_get_uint64_val
uint64_t asm_lexer_get_uint64_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	switch (token->type) {
		case ASM_TOKEN_LITERAL_UINT_BIN: {
			return util_get_uint64_bin_val(token->content, token->len);
		}
		case ASM_TOKEN_LITERAL_UINT_OCT: {
			return util_get_uint64_oct_val(token->content, token->len);
		}
		case ASM_TOKEN_LITERAL_UINT_DEC: {
			return util_get_uint64_dec_val(token->content, token->len);
		}
		case ASM_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 0x1c80d
testq %rsi, %rsi
je 0x1c82c
movl $0xfffff000, %eax       # imm = 0xFFFFF000
addl (%rsi), %eax
cmpl $0x3, %eax
ja 0x1c84b
leaq 0x17814(%rip), %rcx     # 0x33fe4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x110e7
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x11332
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x1144e
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x1120a
leaq 0x19f42(%rip), %rdi     # 0x36756
leaq 0x177d9(%rip), %rsi     # 0x33ff4
leaq 0x1789e(%rip), %rcx     # 0x340c0
movl $0x174, %edx            # imm = 0x174
callq 0xa0b0
leaq 0x11c97(%rip), %rdi     # 0x2e4ca
leaq 0x177ba(%rip), %rsi     # 0x33ff4
leaq 0x1787f(%rip), %rcx     # 0x340c0
movl $0x175, %edx            # imm = 0x175
callq 0xa0b0
leaq 0x12b42(%rip), %rdi     # 0x2f394
leaq 0x1779b(%rip), %rsi     # 0x33ff4
leaq 0x17860(%rip), %rcx     # 0x340c0
movl $0x185, %edx            # imm = 0x185
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/lexer.c
// Function: asm_lexer_get_float_val
float asm_lexer_get_float_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	if (token->type == ASM_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 0x1c88d
testq %rsi, %rsi
je 0x1c8ac
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x1c8cb
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x11712
leaq 0x19ec2(%rip), %rdi     # 0x36756
leaq 0x17759(%rip), %rsi     # 0x33ff4
leaq 0x1785e(%rip), %rcx     # 0x34100
movl $0x190, %edx            # imm = 0x190
callq 0xa0b0
leaq 0x11c17(%rip), %rdi     # 0x2e4ca
leaq 0x1773a(%rip), %rsi     # 0x33ff4
leaq 0x1783f(%rip), %rcx     # 0x34100
movl $0x191, %edx            # imm = 0x191
callq 0xa0b0
leaq 0x12ac2(%rip), %rdi     # 0x2f394
leaq 0x1771b(%rip), %rsi     # 0x33ff4
leaq 0x17820(%rip), %rcx     # 0x34100
movl $0x196, %edx            # imm = 0x196
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/lexer.c
// Function: asm_lexer_get_double_val
double asm_lexer_get_double_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	if (token->type == ASM_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 0x1c90d
testq %rsi, %rsi
je 0x1c92c
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x1c94b
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x115f2
leaq 0x19e42(%rip), %rdi     # 0x36756
leaq 0x176d9(%rip), %rsi     # 0x33ff4
leaq 0x1781a(%rip), %rcx     # 0x3413c
movl $0x1a0, %edx            # imm = 0x1A0
callq 0xa0b0
leaq 0x11b97(%rip), %rdi     # 0x2e4ca
leaq 0x176ba(%rip), %rsi     # 0x33ff4
leaq 0x177fb(%rip), %rcx     # 0x3413c
movl $0x1a1, %edx            # imm = 0x1A1
callq 0xa0b0
leaq 0x12a42(%rip), %rdi     # 0x2f394
leaq 0x1769b(%rip), %rsi     # 0x33ff4
leaq 0x177dc(%rip), %rcx     # 0x3413c
movl $0x1a6, %edx            # imm = 0x1A6
callq 0xa0b0