LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x22e7c
jmp 0x22e9b
leaq 0x26c83(%rip), %rdi     # 0x49b06
leaq 0x28196(%rip), %rsi     # 0x4b020
movl $0x696, %edx            # imm = 0x696
leaq 0x28d21(%rip), %rcx     # 0x4bbb7
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x22ea4
jmp 0x22ec3
leaq 0x2d144(%rip), %rdi     # 0x4ffef
leaq 0x2816e(%rip), %rsi     # 0x4b020
movl $0x696, %edx            # imm = 0x696
leaq 0x28cf9(%rip), %rcx     # 0x4bbb7
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x22ecf
jmp 0x22eee
leaq 0x281a7(%rip), %rdi     # 0x4b07d
leaq 0x28143(%rip), %rsi     # 0x4b020
movl $0x696, %edx            # imm = 0x696
leaq 0x28cce(%rip), %rcx     # 0x4bbb7
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x44(%rax)
jne 0x22efd
jmp 0x22f1c
leaq 0x283fa(%rip), %rdi     # 0x4b2fe
leaq 0x28115(%rip), %rsi     # 0x4b020
movl $0x696, %edx            # imm = 0x696
leaq 0x28ca0(%rip), %rcx     # 0x4bbb7
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x80(%rbp), %rcx
callq 0x1a9e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0xb0(%rax), %eax
movl %eax, -0x84(%rbp)
subl $0x1, %eax
je 0x22f84
jmp 0x22f6a
movl -0x84(%rbp), %eax
subl $0x2, %eax
je 0x22f9f
jmp 0x22f77
movl -0x84(%rbp), %eax
subl $0x4, %eax
je 0x22f9f
jmp 0x22fba
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x80(%rbp), %rcx
callq 0x1b950
jmp 0x22fd9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x80(%rbp), %rcx
callq 0x1baa0
jmp 0x22fd9
leaq 0x244a4(%rip), %rdi     # 0x47465
leaq 0x28058(%rip), %rsi     # 0x4b020
movl $0x6ab, %edx            # imm = 0x6AB
leaq 0x28be3(%rip), %rcx     # 0x4bbb7
callq 0xa0b0
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1e570
addq $0x90, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2323c
jmp 0x2325b
leaq 0x268c3(%rip), %rdi     # 0x49b06
leaq 0x27dd6(%rip), %rsi     # 0x4b020
movl $0x6e2, %edx            # imm = 0x6E2
leaq 0x28a01(%rip), %rcx     # 0x4bc57
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x23264
jmp 0x23283
leaq 0x2cd84(%rip), %rdi     # 0x4ffef
leaq 0x27dae(%rip), %rsi     # 0x4b020
movl $0x6e2, %edx            # imm = 0x6E2
leaq 0x289d9(%rip), %rcx     # 0x4bc57
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2328f
jmp 0x232ae
leaq 0x27de7(%rip), %rdi     # 0x4b07d
leaq 0x27d83(%rip), %rsi     # 0x4b020
movl $0x6e2, %edx            # imm = 0x6E2
leaq 0x289ae(%rip), %rcx     # 0x4bc57
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x44(%rax)
jne 0x232bd
jmp 0x232dc
leaq 0x2803a(%rip), %rdi     # 0x4b2fe
leaq 0x27d55(%rip), %rsi     # 0x4b020
movl $0x6e2, %edx            # imm = 0x6E2
leaq 0x28980(%rip), %rcx     # 0x4bc57
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x80(%rbp), %rcx
callq 0x1a9e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x80(%rbp), %rcx
callq 0x1b800
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1e570
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2335c
jmp 0x2337b
leaq 0x267a3(%rip), %rdi     # 0x49b06
leaq 0x27cb6(%rip), %rsi     # 0x4b020
movl $0x6f5, %edx            # imm = 0x6F5
leaq 0x2891e(%rip), %rcx     # 0x4bc94
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x23384
jmp 0x233a3
leaq 0x2cc64(%rip), %rdi     # 0x4ffef
leaq 0x27c8e(%rip), %rsi     # 0x4b020
movl $0x6f5, %edx            # imm = 0x6F5
leaq 0x288f6(%rip), %rcx     # 0x4bc94
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x233af
jmp 0x233ce
leaq 0x27cc7(%rip), %rdi     # 0x4b07d
leaq 0x27c63(%rip), %rsi     # 0x4b020
movl $0x6f5, %edx            # imm = 0x6F5
leaq 0x288cb(%rip), %rcx     # 0x4bc94
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x3, 0x44(%rax)
jne 0x233dd
jmp 0x233fc
leaq 0x28854(%rip), %rdi     # 0x4bc38
leaq 0x27c35(%rip), %rsi     # 0x4b020
movl $0x6f5, %edx            # imm = 0x6F5
leaq 0x2889d(%rip), %rcx     # 0x4bc94
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x90(%rbp), %rcx
callq 0x1a9e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x90(%rbp), %rcx
callq 0x1ab40
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x90(%rbp), %rcx
callq 0x1ad40
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x1c600
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x90(%rbp), %rcx
callq 0x1b800
movq -0x10(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1e570
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x234fc
jmp 0x2351b
leaq 0x26603(%rip), %rdi     # 0x49b06
leaq 0x27b16(%rip), %rsi     # 0x4b020
movl $0x712, %edx            # imm = 0x712
leaq 0x287c2(%rip), %rcx     # 0x4bcd8
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x23524
jmp 0x23543
leaq 0x2cac4(%rip), %rdi     # 0x4ffef
leaq 0x27aee(%rip), %rsi     # 0x4b020
movl $0x712, %edx            # imm = 0x712
leaq 0x2879a(%rip), %rcx     # 0x4bcd8
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2354f
jmp 0x2356e
leaq 0x27b27(%rip), %rdi     # 0x4b07d
leaq 0x27ac3(%rip), %rsi     # 0x4b020
movl $0x712, %edx            # imm = 0x712
leaq 0x2876f(%rip), %rcx     # 0x4bcd8
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x44(%rax)
jne 0x2357d
jmp 0x2359c
leaq 0x27eca(%rip), %rdi     # 0x4b44e
leaq 0x27a95(%rip), %rsi     # 0x4b020
movl $0x712, %edx            # imm = 0x712
leaq 0x28741(%rip), %rcx     # 0x4bcd8
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x78(%rbp), %rcx
callq 0x1a9e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0xb0(%rax), %eax
movl %eax, -0x7c(%rbp)
subl $0x1, %eax
je 0x235ec
jmp 0x235d8
movl -0x7c(%rbp), %eax
subl $0x2, %eax
je 0x235ee
jmp 0x235e2
movl -0x7c(%rbp), %eax
subl $0x4, %eax
je 0x235ee
jmp 0x235f2
jmp 0x235f2
movb $0x1, -0x6d(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1e570
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2409c
jmp 0x240bb
leaq 0x25a63(%rip), %rdi     # 0x49b06
leaq 0x26f76(%rip), %rsi     # 0x4b020
movl $0x80c, %edx            # imm = 0x80C
leaq 0x27e3a(%rip), %rcx     # 0x4bef0
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x240c4
jmp 0x240e3
leaq 0x2bf24(%rip), %rdi     # 0x4ffef
leaq 0x26f4e(%rip), %rsi     # 0x4b020
movl $0x80c, %edx            # imm = 0x80C
leaq 0x27e12(%rip), %rcx     # 0x4bef0
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x240ef
jmp 0x2410e
leaq 0x26f87(%rip), %rdi     # 0x4b07d
leaq 0x26f23(%rip), %rsi     # 0x4b020
movl $0x80c, %edx            # imm = 0x80C
leaq 0x27de7(%rip), %rcx     # 0x4bef0
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x44(%rax)
jne 0x2411d
jmp 0x2413c
leaq 0x2732a(%rip), %rdi     # 0x4b44e
leaq 0x26ef5(%rip), %rsi     # 0x4b020
movl $0x80c, %edx            # imm = 0x80C
leaq 0x27db9(%rip), %rcx     # 0x4bef0
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x78(%rbp), %rcx
callq 0x1a9e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0xb0(%rax), %eax
movl %eax, -0x7c(%rbp)
subl $0x1, %eax
je 0x2418c
jmp 0x24178
movl -0x7c(%rbp), %eax
subl $0x2, %eax
je 0x241af
jmp 0x24182
movl -0x7c(%rbp), %eax
subl $0x4, %eax
je 0x241d2
jmp 0x241dc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x18(%rbp), %rsi
leaq 0x27081(%rip), %rdx     # 0x4b22c
callq *%rax
jmp 0x241fb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x18(%rbp), %rsi
leaq 0x27088(%rip), %rdx     # 0x4b256
callq *%rax
jmp 0x241fb
movb $0x1, -0x6b(%rbp)
movb $0x1, -0x6a(%rbp)
jmp 0x241fb
leaq 0x23282(%rip), %rdi     # 0x47465
leaq 0x26e36(%rip), %rsi     # 0x4b020
movl $0x82b, %edx            # imm = 0x82B
leaq 0x27cfa(%rip), %rcx     # 0x4bef0
callq 0xa0b0
movq -0x10(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1e570
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2457c
jmp 0x2459b
leaq 0x25583(%rip), %rdi     # 0x49b06
leaq 0x26a96(%rip), %rsi     # 0x4b020
movl $0x8a6, %edx            # imm = 0x8A6
leaq 0x279e0(%rip), %rcx     # 0x4bf76
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x245a4
jmp 0x245c3
leaq 0x2ba44(%rip), %rdi     # 0x4ffef
leaq 0x26a6e(%rip), %rsi     # 0x4b020
movl $0x8a6, %edx            # imm = 0x8A6
leaq 0x279b8(%rip), %rcx     # 0x4bf76
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x245cf
jmp 0x245ee
leaq 0x26aa7(%rip), %rdi     # 0x4b07d
leaq 0x26a43(%rip), %rsi     # 0x4b020
movl $0x8a6, %edx            # imm = 0x8A6
leaq 0x2798d(%rip), %rcx     # 0x4bf76
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x44(%rax)
jne 0x245fd
jmp 0x2461c
leaq 0x26e4a(%rip), %rdi     # 0x4b44e
leaq 0x26a15(%rip), %rsi     # 0x4b020
movl $0x8a6, %edx            # imm = 0x8A6
leaq 0x2795f(%rip), %rcx     # 0x4bf76
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x78(%rbp), %rcx
callq 0x1a9e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0xb0(%rax), %eax
movl %eax, -0x7c(%rbp)
subl $0x1, %eax
je 0x2466c
jmp 0x24658
movl -0x7c(%rbp), %eax
subl $0x2, %eax
je 0x24672
jmp 0x24662
movl -0x7c(%rbp), %eax
subl $0x4, %eax
je 0x24674
jmp 0x24697
movb $0x1, -0x6d(%rbp)
jmp 0x246b6
jmp 0x246b6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x18(%rbp), %rsi
leaq 0x26ccb(%rip), %rdx     # 0x4b35e
callq *%rax
jmp 0x246b6
leaq 0x22dc7(%rip), %rdi     # 0x47465
leaq 0x2697b(%rip), %rsi     # 0x4b020
movl $0x8c0, %edx            # imm = 0x8C0
leaq 0x278c5(%rip), %rcx     # 0x4bf76
callq 0xa0b0
movq -0x10(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1e570
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x246ec
jmp 0x2470b
leaq 0x25413(%rip), %rdi     # 0x49b06
leaq 0x26926(%rip), %rsi     # 0x4b020
movl $0x8cc, %edx            # imm = 0x8CC
leaq 0x278b3(%rip), %rcx     # 0x4bfb9
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x24714
jmp 0x24733
leaq 0x2b8d4(%rip), %rdi     # 0x4ffef
leaq 0x268fe(%rip), %rsi     # 0x4b020
movl $0x8cc, %edx            # imm = 0x8CC
leaq 0x2788b(%rip), %rcx     # 0x4bfb9
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2473f
jmp 0x2475e
leaq 0x26937(%rip), %rdi     # 0x4b07d
leaq 0x268d3(%rip), %rsi     # 0x4b020
movl $0x8cc, %edx            # imm = 0x8CC
leaq 0x27860(%rip), %rcx     # 0x4bfb9
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x44(%rax)
jne 0x2476d
jmp 0x2478c
leaq 0x26cda(%rip), %rdi     # 0x4b44e
leaq 0x268a5(%rip), %rsi     # 0x4b020
movl $0x8cc, %edx            # imm = 0x8CC
leaq 0x27832(%rip), %rcx     # 0x4bfb9
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x78(%rbp), %rcx
callq 0x1a9e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0xb0(%rax), %eax
movl %eax, -0x7c(%rbp)
subl $0x1, %eax
je 0x247dc
jmp 0x247c8
movl -0x7c(%rbp), %eax
subl $0x2, %eax
je 0x247ff
jmp 0x247d2
movl -0x7c(%rbp), %eax
subl $0x4, %eax
je 0x24822
jmp 0x24824
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x18(%rbp), %rsi
leaq 0x26a31(%rip), %rdx     # 0x4b22c
callq *%rax
jmp 0x24843
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x18(%rbp), %rsi
leaq 0x26a38(%rip), %rdx     # 0x4b256
callq *%rax
jmp 0x24843
jmp 0x24843
leaq 0x22c3a(%rip), %rdi     # 0x47465
leaq 0x267ee(%rip), %rsi     # 0x4b020
movl $0x8ea, %edx            # imm = 0x8EA
leaq 0x2777b(%rip), %rcx     # 0x4bfb9
callq 0xa0b0
movq -0x10(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1e570
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2487c
jmp 0x2489b
leaq 0x25283(%rip), %rdi     # 0x49b06
leaq 0x26796(%rip), %rsi     # 0x4b020
movl $0x8f6, %edx            # imm = 0x8F6
leaq 0x27766(%rip), %rcx     # 0x4bffc
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x248a4
jmp 0x248c3
leaq 0x2b744(%rip), %rdi     # 0x4ffef
leaq 0x2676e(%rip), %rsi     # 0x4b020
movl $0x8f6, %edx            # imm = 0x8F6
leaq 0x2773e(%rip), %rcx     # 0x4bffc
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x248cf
jmp 0x248ee
leaq 0x267a7(%rip), %rdi     # 0x4b07d
leaq 0x26743(%rip), %rsi     # 0x4b020
movl $0x8f6, %edx            # imm = 0x8F6
leaq 0x27713(%rip), %rcx     # 0x4bffc
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x2, 0x44(%rax)
jne 0x248fd
jmp 0x2491c
leaq 0x26788(%rip), %rdi     # 0x4b08c
leaq 0x26715(%rip), %rsi     # 0x4b020
movl $0x8f6, %edx            # imm = 0x8F6
leaq 0x276e5(%rip), %rcx     # 0x4bffc
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1a9e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq -0x88(%rbp), %rdx
callq 0x1c060
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq -0x88(%rbp), %rdx
callq 0x1bf40
movq -0x10(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1e570
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2533c
jmp 0x2535b
leaq 0x247c3(%rip), %rdi     # 0x49b06
leaq 0x25cd6(%rip), %rsi     # 0x4b020
movl $0xa0c, %edx            # imm = 0xA0C
leaq 0x26e14(%rip), %rcx     # 0x4c16a
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x25364
jmp 0x25383
leaq 0x2ac84(%rip), %rdi     # 0x4ffef
leaq 0x25cae(%rip), %rsi     # 0x4b020
movl $0xa0c, %edx            # imm = 0xA0C
leaq 0x26dec(%rip), %rcx     # 0x4c16a
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2538f
jmp 0x253ae
leaq 0x25ce7(%rip), %rdi     # 0x4b07d
leaq 0x25c83(%rip), %rsi     # 0x4b020
movl $0xa0c, %edx            # imm = 0xA0C
leaq 0x26dc1(%rip), %rcx     # 0x4c16a
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x44(%rax)
jne 0x253bd
jmp 0x253dc
leaq 0x25f3a(%rip), %rdi     # 0x4b2fe
leaq 0x25c55(%rip), %rsi     # 0x4b020
movl $0xa0c, %edx            # imm = 0xA0C
leaq 0x26d93(%rip), %rcx     # 0x4c16a
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x80(%rbp), %rcx
callq 0x1a9e0
movb $0x1, -0x6a(%rbp)
movq -0x8(%rbp), %rax
movb 0x22(%rax), %al
shrb $0x2, %al
andb $0x7, %al
movb %al, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x80(%rbp), %rcx
callq 0x1b600
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1e570
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2547c
jmp 0x2549b
leaq 0x24683(%rip), %rdi     # 0x49b06
leaq 0x25b96(%rip), %rsi     # 0x4b020
movl $0xa22, %edx            # imm = 0xA22
leaq 0x26d1c(%rip), %rcx     # 0x4c1b2
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x254a4
jmp 0x254c3
leaq 0x2ab44(%rip), %rdi     # 0x4ffef
leaq 0x25b6e(%rip), %rsi     # 0x4b020
movl $0xa22, %edx            # imm = 0xA22
leaq 0x26cf4(%rip), %rcx     # 0x4c1b2
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x254cf
jmp 0x254ee
leaq 0x25ba7(%rip), %rdi     # 0x4b07d
leaq 0x25b43(%rip), %rsi     # 0x4b020
movl $0xa22, %edx            # imm = 0xA22
leaq 0x26cc9(%rip), %rcx     # 0x4c1b2
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x44(%rax)
jne 0x254fd
jmp 0x2551c
leaq 0x25dfa(%rip), %rdi     # 0x4b2fe
leaq 0x25b15(%rip), %rsi     # 0x4b020
movl $0xa22, %edx            # imm = 0xA22
leaq 0x26c9b(%rip), %rcx     # 0x4c1b2
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x80(%rbp), %rcx
callq 0x1a9e0
movb $0x1, -0x6a(%rbp)
movq -0x8(%rbp), %rax
movb 0x22(%rax), %al
shrb $0x2, %al
andb $0x7, %al
movb %al, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x80(%rbp), %rcx
callq 0x1b700
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1e570
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2583c
jmp 0x2585b
leaq 0x242c3(%rip), %rdi     # 0x49b06
leaq 0x257d6(%rip), %rsi     # 0x4b020
movl $0xa68, %edx            # imm = 0xA68
leaq 0x26a34(%rip), %rcx     # 0x4c28a
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x25864
jmp 0x25883
leaq 0x2a784(%rip), %rdi     # 0x4ffef
leaq 0x257ae(%rip), %rsi     # 0x4b020
movl $0xa68, %edx            # imm = 0xA68
leaq 0x26a0c(%rip), %rcx     # 0x4c28a
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2588f
jmp 0x258ae
leaq 0x257e7(%rip), %rdi     # 0x4b07d
leaq 0x25783(%rip), %rsi     # 0x4b020
movl $0xa68, %edx            # imm = 0xA68
leaq 0x269e1(%rip), %rcx     # 0x4c28a
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x44(%rax)
jne 0x258bd
jmp 0x258dc
leaq 0x25a3a(%rip), %rdi     # 0x4b2fe
leaq 0x25755(%rip), %rsi     # 0x4b020
movl $0xa68, %edx            # imm = 0xA68
leaq 0x269b3(%rip), %rcx     # 0x4c28a
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x80(%rbp), %rcx
callq 0x1a9e0
movb $0x1, -0x6a(%rbp)
movq -0x8(%rbp), %rax
movb 0x22(%rax), %al
shrb $0x2, %al
andb $0x7, %al
movb %al, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x80(%rbp), %rcx
callq 0x1ad40
movb $0x0, -0x75(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1e570
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2597c
jmp 0x2599b
leaq 0x24183(%rip), %rdi     # 0x49b06
leaq 0x25696(%rip), %rsi     # 0x4b020
movl $0xa80, %edx            # imm = 0xA80
leaq 0x2693c(%rip), %rcx     # 0x4c2d2
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x259a4
jmp 0x259c3
leaq 0x2a644(%rip), %rdi     # 0x4ffef
leaq 0x2566e(%rip), %rsi     # 0x4b020
movl $0xa80, %edx            # imm = 0xA80
leaq 0x26914(%rip), %rcx     # 0x4c2d2
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x259cf
jmp 0x259ee
leaq 0x256a7(%rip), %rdi     # 0x4b07d
leaq 0x25643(%rip), %rsi     # 0x4b020
movl $0xa80, %edx            # imm = 0xA80
leaq 0x268e9(%rip), %rcx     # 0x4c2d2
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x44(%rax)
jne 0x259fd
jmp 0x25a1c
leaq 0x258fa(%rip), %rdi     # 0x4b2fe
leaq 0x25615(%rip), %rsi     # 0x4b020
movl $0xa80, %edx            # imm = 0xA80
leaq 0x268bb(%rip), %rcx     # 0x4c2d2
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x80(%rbp), %rcx
callq 0x1a9e0
movb $0x1, -0x6a(%rbp)
movq -0x8(%rbp), %rax
movb 0x22(%rax), %al
shrb $0x2, %al
andb $0x7, %al
movb %al, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x80(%rbp), %rcx
callq 0x1b700
movb $0x0, -0x75(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1e570
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x25abc
jmp 0x25adb
leaq 0x24043(%rip), %rdi     # 0x49b06
leaq 0x25556(%rip), %rsi     # 0x4b020
movl $0xa98, %edx            # imm = 0xA98
leaq 0x26844(%rip), %rcx     # 0x4c31a
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x25ae4
jmp 0x25b03
leaq 0x2a504(%rip), %rdi     # 0x4ffef
leaq 0x2552e(%rip), %rsi     # 0x4b020
movl $0xa98, %edx            # imm = 0xA98
leaq 0x2681c(%rip), %rcx     # 0x4c31a
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x25b0f
jmp 0x25b2e
leaq 0x25567(%rip), %rdi     # 0x4b07d
leaq 0x25503(%rip), %rsi     # 0x4b020
movl $0xa98, %edx            # imm = 0xA98
leaq 0x267f1(%rip), %rcx     # 0x4c31a
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x44(%rax)
jne 0x25b3d
jmp 0x25b5c
leaq 0x2590a(%rip), %rdi     # 0x4b44e
leaq 0x254d5(%rip), %rsi     # 0x4b020
movl $0xa98, %edx            # imm = 0xA98
leaq 0x267c3(%rip), %rcx     # 0x4c31a
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x78(%rbp), %rcx
callq 0x1a9e0
movb $0x1, -0x62(%rbp)
movq -0x8(%rbp), %rax
movb 0x22(%rax), %al
shrb $0x2, %al
andb $0x7, %al
movb %al, -0x60(%rbp)
movq -0x8(%rbp), %rax
movb 0x22(%rax), %al
andb $0x3, %al
movzbl %al, %eax
cmpl $0x2, %eax
jne 0x25ba8
movb $0x3, -0x61(%rbp)
movq -0x8(%rbp), %rax
movb 0x22(%rax), %al
shrb $0x5, %al
movb %al, -0x5f(%rbp)
movb $0x0, -0x6d(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1e570
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x25bec
jmp 0x25c0b
leaq 0x20e7b(%rip), %rdi     # 0x46a6e
leaq 0x26786(%rip), %rsi     # 0x4c380
movl $0x145, %edx            # imm = 0x145
leaq 0x26795(%rip), %rcx     # 0x4c39b
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x25c14
jmp 0x25c33
leaq 0x20980(%rip), %rdi     # 0x4659b
leaq 0x2675e(%rip), %rsi     # 0x4c380
movl $0x146, %edx            # imm = 0x146
leaq 0x2676d(%rip), %rcx     # 0x4c39b
callq 0xa0b0
cmpl $0x0, -0x14(%rbp)
jl 0x25c3b
jmp 0x25c5a
leaq 0x20960(%rip), %rdi     # 0x465a2
leaq 0x26737(%rip), %rsi     # 0x4c380
movl $0x147, %edx            # imm = 0x147
leaq 0x26746(%rip), %rcx     # 0x4c39b
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq 0x39154(%rip), %rcx     # 0x5edc0
callq 0xb170
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x25ce9
jmp 0x25d08
leaq 0x27e71(%rip), %rdi     # 0x4db61
leaq 0x26689(%rip), %rsi     # 0x4c380
movl $0x158, %edx            # imm = 0x158
leaq 0x26709(%rip), %rcx     # 0x4c40c
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x25d11
jmp 0x25d30
leaq 0x20822(%rip), %rdi     # 0x4653a
leaq 0x26661(%rip), %rsi     # 0x4c380
movl $0x159, %edx            # imm = 0x159
leaq 0x266e1(%rip), %rcx     # 0x4c40c
callq 0xa0b0
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl $0xfffff000, %eax       # imm = 0xFFFFF000
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x25dbe
movq -0x20(%rbp), %rax
leaq 0x2660f(%rip), %rcx     # 0x4c360
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x13aa0
movl %eax, -0x4(%rbp)
jmp 0x25ddd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x13d50
movl %eax, -0x4(%rbp)
jmp 0x25ddd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x13fe0
movl %eax, -0x4(%rbp)
jmp 0x25ddd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x14350
movl %eax, -0x4(%rbp)
jmp 0x25ddd
leaq 0x216a0(%rip), %rdi     # 0x47465
leaq 0x265b4(%rip), %rsi     # 0x4c380
movl $0x169, %edx            # imm = 0x169
leaq 0x26634(%rip), %rcx     # 0x4c40c
callq 0xa0b0
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x25e09
jmp 0x25e28
leaq 0x27d51(%rip), %rdi     # 0x4db61
leaq 0x26569(%rip), %rsi     # 0x4c380
movl $0x174, %edx            # imm = 0x174
leaq 0x26629(%rip), %rcx     # 0x4c44c
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x25e31
jmp 0x25e50
leaq 0x20702(%rip), %rdi     # 0x4653a
leaq 0x26541(%rip), %rsi     # 0x4c380
movl $0x175, %edx            # imm = 0x175
leaq 0x26601(%rip), %rcx     # 0x4c44c
callq 0xa0b0
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl $0xfffff000, %eax       # imm = 0xFFFFF000
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x25ee2
movq -0x20(%rbp), %rax
leaq 0x264ff(%rip), %rcx     # 0x4c370
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x13960
movq %rax, -0x8(%rbp)
jmp 0x25f01
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x13c10
movq %rax, -0x8(%rbp)
jmp 0x25f01
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x13ec0
movq %rax, -0x8(%rbp)
jmp 0x25f01
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x14150
movq %rax, -0x8(%rbp)
jmp 0x25f01
leaq 0x2157c(%rip), %rdi     # 0x47465
leaq 0x26490(%rip), %rsi     # 0x4c380
movl $0x185, %edx            # imm = 0x185
leaq 0x26550(%rip), %rcx     # 0x4c44c
callq 0xa0b0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x25f29
jmp 0x25f48
leaq 0x27c31(%rip), %rdi     # 0x4db61
leaq 0x26449(%rip), %rsi     # 0x4c380
movl $0x190, %edx            # imm = 0x190
leaq 0x26549(%rip), %rcx     # 0x4c48c
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x25f51
jmp 0x25f70
leaq 0x205e2(%rip), %rdi     # 0x4653a
leaq 0x26421(%rip), %rsi     # 0x4c380
movl $0x191, %edx            # imm = 0x191
leaq 0x26521(%rip), %rcx     # 0x4c48c
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x1004, (%rax)         # imm = 0x1004
jne 0x25f96
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x147b0
addq $0x10, %rsp
popq %rbp
retq
leaq 0x214c8(%rip), %rdi     # 0x47465
leaq 0x263dc(%rip), %rsi     # 0x4c380
movl $0x196, %edx            # imm = 0x196
leaq 0x264dc(%rip), %rcx     # 0x4c48c
callq 0xa0b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x25fd9
jmp 0x25ff8
leaq 0x27b81(%rip), %rdi     # 0x4db61
leaq 0x26399(%rip), %rsi     # 0x4c380
movl $0x1a0, %edx            # imm = 0x1A0
leaq 0x264d5(%rip), %rcx     # 0x4c4c8
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x26001
jmp 0x26020
leaq 0x20532(%rip), %rdi     # 0x4653a
leaq 0x26371(%rip), %rsi     # 0x4c380
movl $0x1a1, %edx            # imm = 0x1A1
leaq 0x264ad(%rip), %rcx     # 0x4c4c8
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x1004, (%rax)         # imm = 0x1004
jne 0x26046
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x144c0
addq $0x10, %rsp
popq %rbp
retq
leaq 0x21418(%rip), %rdi     # 0x47465
leaq 0x2632c(%rip), %rsi     # 0x4c380
movl $0x1a6, %edx            # imm = 0x1A6
leaq 0x26468(%rip), %rcx     # 0x4c4c8
callq 0xa0b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/assembler/lexer.c
// Function: asm_lexer_get_char_val
char asm_lexer_get_char_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

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

	return '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x26089
jmp 0x260a8
leaq 0x27ad1(%rip), %rdi     # 0x4db61
leaq 0x262e9(%rip), %rsi     # 0x4c380
movl $0x1b0, %edx            # imm = 0x1B0
leaq 0x26463(%rip), %rcx     # 0x4c506
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x260b1
jmp 0x260d0
leaq 0x20482(%rip), %rdi     # 0x4653a
leaq 0x262c1(%rip), %rsi     # 0x4c380
movl $0x1b1, %edx            # imm = 0x1B1
leaq 0x2643b(%rip), %rcx     # 0x4c506
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x1005, (%rax)         # imm = 0x1005
jne 0x260f6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x13740
addq $0x10, %rsp
popq %rbp
retq
leaq 0x21368(%rip), %rdi     # 0x47465
leaq 0x2627c(%rip), %rsi     # 0x4c380
movl $0x1b6, %edx            # imm = 0x1B6
leaq 0x263f6(%rip), %rcx     # 0x4c506
callq 0xa0b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/assembler/lexer.c
// Function: asm_lexer_unescape_string
void asm_lexer_unescape_string(
	LexerContext *ctx,
	ResizableString *target,
	const char *source,
	size_t source_len
) {
	assert(ctx);
	assert(target);
	assert(source);

	util_unescape_string(target, source, source_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x26141
jmp 0x26160
leaq 0x27a19(%rip), %rdi     # 0x4db61
leaq 0x26231(%rip), %rsi     # 0x4c380
movl $0x1c2, %edx            # imm = 0x1C2
leaq 0x263e5(%rip), %rcx     # 0x4c540
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x26169
jmp 0x26188
leaq 0x27322(%rip), %rdi     # 0x4d492
leaq 0x26209(%rip), %rsi     # 0x4c380
movl $0x1c3, %edx            # imm = 0x1C3
leaq 0x263bd(%rip), %rcx     # 0x4c540
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x26191
jmp 0x261b0
leaq 0x20403(%rip), %rdi     # 0x4659b
leaq 0x261e1(%rip), %rsi     # 0x4c380
movl $0x1c4, %edx            # imm = 0x1C4
leaq 0x26395(%rip), %rcx     # 0x4c540
callq 0xa0b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x13860
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/assembler/lexer.c
// Function: asm_lexer_has_unsigned_mark
bool asm_lexer_has_unsigned_mark(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);
	assert(
		token->type == ASM_TOKEN_LITERAL_UINT_BIN
		|| token->type == ASM_TOKEN_LITERAL_UINT_OCT
		|| token->type == ASM_TOKEN_LITERAL_UINT_DEC
		|| token->type == ASM_TOKEN_LITERAL_UINT_HEX
	);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x261e9
jmp 0x26208
leaq 0x27971(%rip), %rdi     # 0x4db61
leaq 0x26189(%rip), %rsi     # 0x4c380
movl $0x1cd, %edx            # imm = 0x1CD
leaq 0x26395(%rip), %rcx     # 0x4c598
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x26211
jmp 0x26230
leaq 0x20322(%rip), %rdi     # 0x4653a
leaq 0x26161(%rip), %rsi     # 0x4c380
movl $0x1ce, %edx            # imm = 0x1CE
leaq 0x2636d(%rip), %rcx     # 0x4c598
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x1000, (%rax)         # imm = 0x1000
je 0x26260
movq -0x10(%rbp), %rax
cmpl $0x1001, (%rax)         # imm = 0x1001
je 0x26260
movq -0x10(%rbp), %rax
cmpl $0x1002, (%rax)         # imm = 0x1002
je 0x26260
movq -0x10(%rbp), %rax
cmpl $0x1003, (%rax)         # imm = 0x1003
jne 0x26262
jmp 0x26281
leaq 0x2636f(%rip), %rdi     # 0x4c5d8
leaq 0x26110(%rip), %rsi     # 0x4c380
movl $0x1d4, %edx            # imm = 0x1D4
leaq 0x2631c(%rip), %rcx     # 0x4c598
callq 0xa0b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x75, %eax
sete %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/assembler/lexer.c
// Function: asm_lexer_has_float_mark
bool asm_lexer_has_float_mark(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);
	assert(token->type == ASM_TOKEN_LITERAL_REAL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x262c9
jmp 0x262e8
leaq 0x27891(%rip), %rdi     # 0x4db61
leaq 0x260a9(%rip), %rsi     # 0x4c380
movl $0x1dd, %edx            # imm = 0x1DD
leaq 0x263a6(%rip), %rcx     # 0x4c689
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x262f1
jmp 0x26310
leaq 0x20242(%rip), %rdi     # 0x4653a
leaq 0x26081(%rip), %rsi     # 0x4c380
movl $0x1de, %edx            # imm = 0x1DE
leaq 0x2637e(%rip), %rcx     # 0x4c689
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x1004, (%rax)         # imm = 0x1004
jne 0x2631e
jmp 0x2633d
leaq 0x263a1(%rip), %rdi     # 0x4c6c6
leaq 0x26054(%rip), %rsi     # 0x4c380
movl $0x1df, %edx            # imm = 0x1DF
leaq 0x26351(%rip), %rcx     # 0x4c689
callq 0xa0b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x66, %eax
sete %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/assembler/lexer.c
// Function: is_register
static bool _is_register(
	LexerToken *token
) {
	assert(token);

	InsRegisterIterator iter;
	ins_reg_iter_init(&iter);
	for (InsRegister *reg = ins_reg_iter_next(&iter); reg != NULL; reg = ins_reg_iter_next(&iter)) {
		assert(reg->name);

		if (strlen(reg->name) == token->len
				&& strncmp(reg->name, token->content, token->len) == 0) {
			return true;
		}
	}
	ins_reg_iter_free(&iter);

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x29425
jmp 0x29444
leaq 0x1d10e(%rip), %rdi     # 0x4653a
leaq 0x22f4d(%rip), %rsi     # 0x4c380
movl $0x90, %edx
leaq 0x23823(%rip), %rcx     # 0x4cc62
callq 0xa0b0
leaq -0x18(%rbp), %rdi
callq 0x1a5d0
leaq -0x18(%rbp), %rdi
callq 0x1a620
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x294e0
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2946d
jmp 0x2948c
leaq 0x20562(%rip), %rdi     # 0x499d6
leaq 0x22f05(%rip), %rsi     # 0x4c380
movl $0x95, %edx
leaq 0x237db(%rip), %rcx     # 0x4cc62
callq 0xa0b0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0xa080
movq -0x10(%rbp), %rcx
movslq 0x4(%rcx), %rcx
cmpq %rcx, %rax
jne 0x294cc
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rdx
callq 0xa040
cmpl $0x0, %eax
jne 0x294cc
movb $0x1, -0x1(%rbp)
jmp 0x294ed
jmp 0x294ce
leaq -0x18(%rbp), %rdi
callq 0x1a620
movq %rax, -0x20(%rbp)
jmp 0x2945a
leaq -0x18(%rbp), %rdi
callq 0x1a6a0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/assembler/main.c
// Function: test
static void _test(void) {
	rstr_test();
	rarr_test();
	llst_test();
	map_test();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x11d80
callq 0xa920
callq 0xce60
callq 0xdf90
popq %rbp
retq
nopw (%rax,%rax)