LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x1baa0
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1baa9
movq (%rbx), %r12
testq %r12, %r12
je 0x1bab2
cmpl $0x1, 0x44(%r12)
jne 0x1babb
movq %rdi, %r15
movq 0x48(%r12), %rax
movq (%rax), %rax
movq 0x8(%rbx), %rdi
movq 0x10(%rax), %rsi
callq 0x207e9
movq %rax, %r14
movq 0x8(%rbx), %rdi
leaq -0xa0(%rbp), %rcx
movq %r15, %rsi
movq %r12, %rdx
callq 0x1524f
movq 0x8(%rbx), %rax
movl 0xb0(%rax), %eax
cmpl $0x1, %eax
je 0x1ba19
cmpl $0x4, %eax
je 0x1ba15
cmpl $0x2, %eax
jne 0x1bada
movb $0x4, %al
jmp 0x1ba1b
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 0x14644
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 0x14644
movq 0x8(%rbx), %rcx
addq %rax, 0xc0(%rcx)
cmpl $0x1, 0xc8(%rcx)
je 0x1ba90
movq 0xb8(%rcx), %rcx
leaq -0x40(%rbp), %rdi
movl $0x1, %edx
movq %rax, %rsi
callq 0xa180
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14c83(%rip), %rdi     # 0x3072a
jmp 0x1bac2
leaq 0x1aaab(%rip), %rdi     # 0x3655b
jmp 0x1bac2
leaq 0x161e8(%rip), %rdi     # 0x31ca1
jmp 0x1bac2
leaq 0x16460(%rip), %rdi     # 0x31f22
leaq 0x1617b(%rip), %rsi     # 0x31c44
leaq 0x17204(%rip), %rcx     # 0x32cd4
movl $0x95f, %edx            # imm = 0x95F
callq 0xa0b0
leaq 0x1288f(%rip), %rdi     # 0x2e370
leaq 0x1615c(%rip), %rsi     # 0x31c44
leaq 0x171e5(%rip), %rcx     # 0x32cd4
movl $0x976, %edx            # imm = 0x976
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x1bbd8
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1bbe1
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1bbea
cmpl $0x2, 0x44(%rdx)
jne 0x1bbf3
movq %rdi, %rsi
movq 0x48(%rdx), %rax
movq (%rax), %r14
movq 0x8(%rbx), %rdi
leaq -0x70(%rbp), %rcx
callq 0x1524f
movq 0x60(%r14), %rax
movq 0x8(%rbx), %rcx
movl 0xb0(%rcx), %ecx
cmpl $0x4, %ecx
je 0x1bb93
cmpl $0x2, %ecx
je 0x1bb93
cmpl $0x1, %ecx
jne 0x1bc12
movl 0xc(%rax), %eax
cmpl $0x3, %eax
je 0x1bbc3
cmpl $0x4, %eax
je 0x1bbbf
leaq 0x127f5(%rip), %rdi     # 0x2e370
leaq 0x160c2(%rip), %rsi     # 0x31c44
leaq 0x17184(%rip), %rcx     # 0x32d0d
movl $0x9aa, %edx            # imm = 0x9AA
callq 0xa0b0
movl 0xc(%rax), %eax
cmpl $0x3, %eax
je 0x1bbbf
cmpl $0x4, %eax
je 0x1bbc3
leaq 0x127c9(%rip), %rdi     # 0x2e370
leaq 0x16096(%rip), %rsi     # 0x31c44
leaq 0x17158(%rip), %rcx     # 0x32d0d
movl $0x9bc, %edx            # imm = 0x9BC
callq 0xa0b0
movb $0x1, -0x65(%rbp)
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x17e70
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x14b4b(%rip), %rdi     # 0x3072a
jmp 0x1bbfa
leaq 0x1a973(%rip), %rdi     # 0x3655b
jmp 0x1bbfa
leaq 0x160b0(%rip), %rdi     # 0x31ca1
jmp 0x1bbfa
leaq 0x160b6(%rip), %rdi     # 0x31cb0
leaq 0x16043(%rip), %rsi     # 0x31c44
leaq 0x17105(%rip), %rcx     # 0x32d0d
movl $0x992, %edx            # imm = 0x992
callq 0xa0b0
leaq 0x12757(%rip), %rdi     # 0x2e370
leaq 0x16024(%rip), %rsi     # 0x31c44
leaq 0x170e6(%rip), %rcx     # 0x32d0d
movl $0x9c3, %edx            # imm = 0x9C3
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x1bd11
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1bd1a
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1bd23
cmpl $0x2, 0x44(%rdx)
jne 0x1bd2c
movq %rdi, %rsi
movq 0x48(%rdx), %rax
movq 0x8(%rax), %r14
movq 0x8(%rbx), %rdi
leaq -0x70(%rbp), %rcx
callq 0x1524f
movq 0x60(%r14), %rax
movq 0x8(%rbx), %rcx
movl 0xb0(%rcx), %ecx
cmpl $0x4, %ecx
je 0x1bccc
cmpl $0x2, %ecx
je 0x1bccc
cmpl $0x1, %ecx
jne 0x1bd4b
movl 0xc(%rax), %eax
cmpl $0x3, %eax
je 0x1bcfc
cmpl $0x4, %eax
je 0x1bcf8
leaq 0x126bc(%rip), %rdi     # 0x2e370
leaq 0x15f89(%rip), %rsi     # 0x31c44
leaq 0x1708b(%rip), %rcx     # 0x32d4d
movl $0x9e7, %edx            # imm = 0x9E7
callq 0xa0b0
movl 0xc(%rax), %eax
cmpl $0x3, %eax
je 0x1bcf8
cmpl $0x4, %eax
je 0x1bcfc
leaq 0x12690(%rip), %rdi     # 0x2e370
leaq 0x15f5d(%rip), %rsi     # 0x31c44
leaq 0x1705f(%rip), %rcx     # 0x32d4d
movl $0x9f9, %edx            # imm = 0x9F9
callq 0xa0b0
movb $0x1, -0x65(%rbp)
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x17e70
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x14a12(%rip), %rdi     # 0x3072a
jmp 0x1bd33
leaq 0x1a83a(%rip), %rdi     # 0x3655b
jmp 0x1bd33
leaq 0x15f77(%rip), %rdi     # 0x31ca1
jmp 0x1bd33
leaq 0x15f7d(%rip), %rdi     # 0x31cb0
leaq 0x15f0a(%rip), %rsi     # 0x31c44
leaq 0x1700c(%rip), %rcx     # 0x32d4d
movl $0x9cf, %edx            # imm = 0x9CF
callq 0xa0b0
leaq 0x1261e(%rip), %rdi     # 0x2e370
leaq 0x15eeb(%rip), %rsi     # 0x31c44
leaq 0x16fed(%rip), %rcx     # 0x32d4d
movl $0xa00, %edx            # imm = 0xA00
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x1bdef
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1bdf8
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1be01
cmpl $0x1, 0x44(%rdx)
jne 0x1be0a
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 0x1524f
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 0x15ac7
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17e70
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14934(%rip), %rdi     # 0x3072a
jmp 0x1be11
leaq 0x1a75c(%rip), %rdi     # 0x3655b
jmp 0x1be11
leaq 0x15e99(%rip), %rdi     # 0x31ca1
jmp 0x1be11
leaq 0x16111(%rip), %rdi     # 0x31f22
leaq 0x15e2c(%rip), %rsi     # 0x31c44
leaq 0x16f6f(%rip), %rcx     # 0x32d8e
movl $0xa0c, %edx            # imm = 0xA0C
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x1beae
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1beb7
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1bec0
cmpl $0x1, 0x44(%rdx)
jne 0x1bec9
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 0x1524f
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 0x15b8c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17e70
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14875(%rip), %rdi     # 0x3072a
jmp 0x1bed0
leaq 0x1a69d(%rip), %rdi     # 0x3655b
jmp 0x1bed0
leaq 0x15dda(%rip), %rdi     # 0x31ca1
jmp 0x1bed0
leaq 0x16052(%rip), %rdi     # 0x31f22
leaq 0x15d6d(%rip), %rsi     # 0x31c44
leaq 0x16ef8(%rip), %rcx     # 0x32dd6
movl $0xa22, %edx            # imm = 0xA22
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x1c0fd
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1c106
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1c10f
cmpl $0x1, 0x44(%rdx)
jne 0x1c118
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 0x1524f
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 0x15488
movb $0x0, 0xb(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17e70
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14626(%rip), %rdi     # 0x3072a
jmp 0x1c11f
leaq 0x1a44e(%rip), %rdi     # 0x3655b
jmp 0x1c11f
leaq 0x15b8b(%rip), %rdi     # 0x31ca1
jmp 0x1c11f
leaq 0x15e03(%rip), %rdi     # 0x31f22
leaq 0x15b1e(%rip), %rsi     # 0x31c44
leaq 0x16d81(%rip), %rcx     # 0x32eae
movl $0xa68, %edx            # imm = 0xA68
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x1c1c2
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1c1cb
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1c1d4
cmpl $0x1, 0x44(%rdx)
jne 0x1c1dd
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 0x1524f
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 0x15b8c
movb $0x0, 0xb(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17e70
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14561(%rip), %rdi     # 0x3072a
jmp 0x1c1e4
leaq 0x1a389(%rip), %rdi     # 0x3655b
jmp 0x1c1e4
leaq 0x15ac6(%rip), %rdi     # 0x31ca1
jmp 0x1c1e4
leaq 0x15d3e(%rip), %rdi     # 0x31f22
leaq 0x15a59(%rip), %rsi     # 0x31c44
leaq 0x16d04(%rip), %rcx     # 0x32ef6
movl $0xa80, %edx            # imm = 0xA80
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x1c27e
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1c287
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1c290
cmpl $0x0, 0x44(%rdx)
jne 0x1c299
movq %rdi, %r14
movq 0x8(%rbx), %rdi
leaq -0x78(%rbp), %r15
movq %r14, %rsi
movq %r15, %rcx
callq 0x1524f
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 0x1c25d
movb $0x3, -0x61(%rbp)
shrb $0x5, %al
leaq -0x78(%rbp), %rsi
movb %al, 0x19(%rsi)
movb $0x0, 0xb(%rsi)
movq %rbx, %rdi
callq 0x17e70
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x144a5(%rip), %rdi     # 0x3072a
jmp 0x1c2a0
leaq 0x1a2cd(%rip), %rdi     # 0x3655b
jmp 0x1c2a0
leaq 0x15a0a(%rip), %rdi     # 0x31ca1
jmp 0x1c2a0
leaq 0x15dd2(%rip), %rdi     # 0x32072
leaq 0x1599d(%rip), %rsi     # 0x31c44
leaq 0x16c90(%rip), %rcx     # 0x32f3e
movl $0xa98, %edx            # imm = 0xA98
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x1c2d7
testq %rsi, %rsi
je 0x1c2f6
testl %edx, %edx
js 0x1c315
leaq 0x29a7f(%rip), %rcx     # 0x45d50
popq %rbp
jmp 0xae18
leaq 0x1172b(%rip), %rdi     # 0x2da09
leaq 0x16cbf(%rip), %rsi     # 0x32fa4
leaq 0x16cd3(%rip), %rcx     # 0x32fbf
movl $0x145, %edx            # imm = 0x145
callq 0xa0b0
leaq 0x11239(%rip), %rdi     # 0x2d536
leaq 0x16ca0(%rip), %rsi     # 0x32fa4
leaq 0x16cb4(%rip), %rcx     # 0x32fbf
movl $0x146, %edx            # imm = 0x146
callq 0xa0b0
leaq 0x11221(%rip), %rdi     # 0x2d53d
leaq 0x16c81(%rip), %rsi     # 0x32fa4
leaq 0x16c95(%rip), %rcx     # 0x32fbf
movl $0x147, %edx            # imm = 0x147
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x1c3c2
testq %rsi, %rsi
je 0x1c3e1
movl $0xfffff000, %eax       # imm = 0xFFFFF000
addl (%rsi), %eax
cmpl $0x3, %eax
ja 0x1c400
leaq 0x16bff(%rip), %rcx     # 0x32f84
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x10f33
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x11165
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x11303
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x11052
leaq 0x139fb(%rip), %rdi     # 0x2fdc4
leaq 0x16bd4(%rip), %rsi     # 0x32fa4
leaq 0x16c59(%rip), %rcx     # 0x33030
movl $0x158, %edx            # imm = 0x158
callq 0xa0b0
leaq 0x110d2(%rip), %rdi     # 0x2d4ba
leaq 0x16bb5(%rip), %rsi     # 0x32fa4
leaq 0x16c3a(%rip), %rcx     # 0x33030
movl $0x159, %edx            # imm = 0x159
callq 0xa0b0
leaq 0x11f69(%rip), %rdi     # 0x2e370
leaq 0x16b96(%rip), %rsi     # 0x32fa4
leaq 0x16c1b(%rip), %rcx     # 0x33030
movl $0x169, %edx            # imm = 0x169
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x1c481
testq %rsi, %rsi
je 0x1c4a0
movl $0xfffff000, %eax       # imm = 0xFFFFF000
addl (%rsi), %eax
cmpl $0x3, %eax
ja 0x1c4bf
leaq 0x16b50(%rip), %rcx     # 0x32f94
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x10e94
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x110cd
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x111e0
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x10fae
leaq 0x1393c(%rip), %rdi     # 0x2fdc4
leaq 0x16b15(%rip), %rsi     # 0x32fa4
leaq 0x16bda(%rip), %rcx     # 0x33070
movl $0x174, %edx            # imm = 0x174
callq 0xa0b0
leaq 0x11013(%rip), %rdi     # 0x2d4ba
leaq 0x16af6(%rip), %rsi     # 0x32fa4
leaq 0x16bbb(%rip), %rcx     # 0x33070
movl $0x175, %edx            # imm = 0x175
callq 0xa0b0
leaq 0x11eaa(%rip), %rdi     # 0x2e370
leaq 0x16ad7(%rip), %rsi     # 0x32fa4
leaq 0x16b9c(%rip), %rcx     # 0x33070
movl $0x185, %edx            # imm = 0x185
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x1c501
testq %rsi, %rsi
je 0x1c520
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x1c53f
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x1148b
leaq 0x138bc(%rip), %rdi     # 0x2fdc4
leaq 0x16a95(%rip), %rsi     # 0x32fa4
leaq 0x16b9a(%rip), %rcx     # 0x330b0
movl $0x190, %edx            # imm = 0x190
callq 0xa0b0
leaq 0x10f93(%rip), %rdi     # 0x2d4ba
leaq 0x16a76(%rip), %rsi     # 0x32fa4
leaq 0x16b7b(%rip), %rcx     # 0x330b0
movl $0x191, %edx            # imm = 0x191
callq 0xa0b0
leaq 0x11e2a(%rip), %rdi     # 0x2e370
leaq 0x16a57(%rip), %rsi     # 0x32fa4
leaq 0x16b5c(%rip), %rcx     # 0x330b0
movl $0x196, %edx            # imm = 0x196
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x1c581
testq %rsi, %rsi
je 0x1c5a0
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x1c5bf
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x1137e
leaq 0x1383c(%rip), %rdi     # 0x2fdc4
leaq 0x16a15(%rip), %rsi     # 0x32fa4
leaq 0x16b56(%rip), %rcx     # 0x330ec
movl $0x1a0, %edx            # imm = 0x1A0
callq 0xa0b0
leaq 0x10f13(%rip), %rdi     # 0x2d4ba
leaq 0x169f6(%rip), %rsi     # 0x32fa4
leaq 0x16b37(%rip), %rcx     # 0x330ec
movl $0x1a1, %edx            # imm = 0x1A1
callq 0xa0b0
leaq 0x11daa(%rip), %rdi     # 0x2e370
leaq 0x169d7(%rip), %rsi     # 0x32fa4
leaq 0x16b18(%rip), %rcx     # 0x330ec
movl $0x1a6, %edx            # imm = 0x1A6
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdi, %rdi
je 0x1c601
testq %rsi, %rsi
je 0x1c620
cmpl $0x1005, (%rsi)         # imm = 0x1005
jne 0x1c63f
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x10d1f
leaq 0x137bc(%rip), %rdi     # 0x2fdc4
leaq 0x16995(%rip), %rsi     # 0x32fa4
leaq 0x16b14(%rip), %rcx     # 0x3312a
movl $0x1b0, %edx            # imm = 0x1B0
callq 0xa0b0
leaq 0x10e93(%rip), %rdi     # 0x2d4ba
leaq 0x16976(%rip), %rsi     # 0x32fa4
leaq 0x16af5(%rip), %rcx     # 0x3312a
movl $0x1b1, %edx            # imm = 0x1B1
callq 0xa0b0
leaq 0x11d2a(%rip), %rdi     # 0x2e370
leaq 0x16957(%rip), %rsi     # 0x32fa4
leaq 0x16ad6(%rip), %rcx     # 0x3312a
movl $0x1b6, %edx            # imm = 0x1B6
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdi, %rdi
je 0x1c680
testq %rsi, %rsi
je 0x1c69f
testq %rdx, %rdx
je 0x1c6be
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
popq %rbp
jmp 0x10dd3
leaq 0x1373d(%rip), %rdi     # 0x2fdc4
leaq 0x16916(%rip), %rsi     # 0x32fa4
leaq 0x16acf(%rip), %rcx     # 0x33164
movl $0x1c2, %edx            # imm = 0x1C2
callq 0xa0b0
leaq 0x179e0(%rip), %rdi     # 0x34086
leaq 0x168f7(%rip), %rsi     # 0x32fa4
leaq 0x16ab0(%rip), %rcx     # 0x33164
movl $0x1c3, %edx            # imm = 0x1C3
callq 0xa0b0
leaq 0x10e71(%rip), %rdi     # 0x2d536
leaq 0x168d8(%rip), %rsi     # 0x32fa4
leaq 0x16a91(%rip), %rcx     # 0x33164
movl $0x1c4, %edx            # imm = 0x1C4
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdi, %rdi
je 0x1c709
testq %rsi, %rsi
je 0x1c728
movl (%rsi), %eax
andl $-0x4, %eax
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x1c747
movq 0x8(%rsi), %rax
movslq 0x4(%rsi), %rcx
cmpb $0x75, -0x1(%rax,%rcx)
sete %al
popq %rbp
retq
leaq 0x136b4(%rip), %rdi     # 0x2fdc4
leaq 0x1688d(%rip), %rsi     # 0x32fa4
leaq 0x16a9e(%rip), %rcx     # 0x331bc
movl $0x1cd, %edx            # imm = 0x1CD
callq 0xa0b0
leaq 0x10d8b(%rip), %rdi     # 0x2d4ba
leaq 0x1686e(%rip), %rsi     # 0x32fa4
leaq 0x16a7f(%rip), %rcx     # 0x331bc
movl $0x1ce, %edx            # imm = 0x1CE
callq 0xa0b0
leaq 0x16aae(%rip), %rdi     # 0x331fc
leaq 0x1684f(%rip), %rsi     # 0x32fa4
leaq 0x16a60(%rip), %rcx     # 0x331bc
movl $0x1d4, %edx            # imm = 0x1D4
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdi, %rdi
je 0x1c78e
testq %rsi, %rsi
je 0x1c7ad
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x1c7cc
movq 0x8(%rsi), %rax
movslq 0x4(%rsi), %rcx
cmpb $0x66, -0x1(%rax,%rcx)
sete %al
popq %rbp
retq
leaq 0x1362f(%rip), %rdi     # 0x2fdc4
leaq 0x16808(%rip), %rsi     # 0x32fa4
leaq 0x16b0a(%rip), %rcx     # 0x332ad
movl $0x1dd, %edx            # imm = 0x1DD
callq 0xa0b0
leaq 0x10d06(%rip), %rdi     # 0x2d4ba
leaq 0x167e9(%rip), %rsi     # 0x32fa4
leaq 0x16aeb(%rip), %rcx     # 0x332ad
movl $0x1de, %edx            # imm = 0x1DE
callq 0xa0b0
leaq 0x16b17(%rip), %rdi     # 0x332ea
leaq 0x167ca(%rip), %rsi     # 0x32fa4
leaq 0x16acc(%rip), %rcx     # 0x332ad
movl $0x1df, %edx            # imm = 0x1DF
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/main.c
// Function: error
static void _error(
	const char *fmt,
	...
) {
	va_list argptr;
    va_start(argptr, fmt);

	fputs("ERROR: ", stderr);
	vfprintf(stderr, fmt, argptr);
	fputc('\n', stderr);

	va_end(argptr);

	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq -0xe0(%rbp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x1e35e
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq -0x30(%rbp), %r14
movq %rdi, 0x10(%r14)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0x20c76(%rip), %r15     # 0x3eff8
movq (%r15), %rsi
leaq 0x15f01(%rip), %rdi     # 0x3428d
callq 0xa0c0
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xa160
movq (%r15), %rsi
movl $0xa, %edi
callq 0xa0d0
movl $0x1, %edi
callq 0xa170
nop
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_new_context
_RULE_END

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

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

	AsmParserContextData data;
	map_init(
		&data.symtable,
		map_rstr_comparer, NULL,
		(MapReleaser) rstr_delete, (MapReleaser) map_primitive_box_free
	);
	data.arch = ASM_ARCH_BIT16;
	data.out = NULL;
	data.address_counter = 0;
	data.step = ASM_STEP_SCAN;

	data.mem_without_oprd_size = false;

	data.default_oprd_size = false;

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

	return ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
testq %rdi, %rdi
je 0x1e441
testq %rsi, %rsi
je 0x1e460
testl %edx, %edx
js 0x1e47f
callq 0x1c2b8
movq %rax, %rbx
movq %rax, %rdi
callq 0xb717
leaq -0x11788(%rip), %rsi    # 0xcc68
leaq -0xfc3d(%rip), %rcx     # 0xe7ba
leaq -0x117b0(%rip), %r8     # 0xcc4e
leaq -0x78(%rbp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0xc400
movl $0x1, %eax
movl %eax, 0x48(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r14)
movl %eax, 0x60(%r14)
movw $0x0, 0x64(%r14)
movl $0x68, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xd008
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xf5c1(%rip), %rdi      # 0x2da09
leaq 0x16025(%rip), %rsi     # 0x34474
leaq 0x1603a(%rip), %rcx     # 0x34490
movl $0x987, %edx            # imm = 0x987
callq 0xa0b0
leaq 0xf0cf(%rip), %rdi      # 0x2d536
leaq 0x16006(%rip), %rsi     # 0x34474
leaq 0x1601b(%rip), %rcx     # 0x34490
movl $0x988, %edx            # imm = 0x988
callq 0xa0b0
leaq 0xf0b7(%rip), %rdi      # 0x2d53d
leaq 0x15fe7(%rip), %rsi     # 0x34474
leaq 0x15ffc(%rip), %rcx     # 0x34490
movl $0x989, %edx            # imm = 0x989
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_print_ast
void asm_parser_print_ast(
	ParserContext * ctx,
	FILE *file
) {
	assert(ctx);
	assert(ctx->ast);
	assert(file);

	_print_ast(ctx->ast, file, 0, '\t');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x203de
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x203fd
testq %rsi, %rsi
je 0x2041c
xorl %edx, %edx
popq %rbp
jmp 0x2043b
leaq 0xf9df(%rip), %rdi      # 0x2fdc4
leaq 0x14088(%rip), %rsi     # 0x34474
leaq 0x1414a(%rip), %rcx     # 0x3453d
movl $0xa20, %edx            # imm = 0xA20
callq 0xa0b0
leaq 0x15583(%rip), %rdi     # 0x35987
leaq 0x14069(%rip), %rsi     # 0x34474
leaq 0x1412b(%rip), %rcx     # 0x3453d
movl $0xa21, %edx            # imm = 0xA21
callq 0xa0b0
leaq 0xd5e6(%rip), %rdi      # 0x2da09
leaq 0x1404a(%rip), %rsi     # 0x34474
leaq 0x1410c(%rip), %rcx     # 0x3453d
movl $0xa22, %edx            # imm = 0xA22
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_set_symbol_by_rstr_key
void asm_parser_set_symbol_by_rstr_key(
	ParserContext *ctx,
	ResizableString *key,
	uint64_t value
) {
	assert(ctx);
	assert(key);

	Map *symtable = &ASM_PARSER_CONTEXT_DATA_GET_SYMTABLE(ctx);

	MapPrimitiveBox *box = map_primitive_box_uint64(value);

	map_set(symtable, key, box, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x206b0
movq %rsi, %rbx
testq %rsi, %rsi
je 0x206cf
movq %rdi, %r14
addq $0x68, %r14
movq %rdx, %rdi
callq 0xca5e
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movl $0x1, %ecx
popq %rbx
popq %r14
popq %rbp
jmp 0xc56c
leaq 0xf70d(%rip), %rdi      # 0x2fdc4
leaq 0x13db6(%rip), %rsi     # 0x34474
leaq 0x13eab(%rip), %rcx     # 0x34570
movl $0xa2c, %edx            # imm = 0xA2C
callq 0xa0b0
leaq 0xd6eb(%rip), %rdi      # 0x2ddc1
leaq 0x13d97(%rip), %rsi     # 0x34474
leaq 0x13e8c(%rip), %rcx     # 0x34570
movl $0xa2d, %edx            # imm = 0xA2D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_set_symbol_by_token_key
void asm_parser_set_symbol_by_token_key(
	ParserContext *ctx,
	LexerToken *key,
	uint64_t value
) {
	assert(ctx);
	assert(key);

	ResizableString *rstr_key = rstr_new_with_raw(key->content, key->len);
	asm_parser_set_symbol_by_rstr_key(ctx, rstr_key, value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x20723
testq %rsi, %rsi
je 0x20742
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
callq 0xe71b
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x20676
leaq 0xf69a(%rip), %rdi      # 0x2fdc4
leaq 0x13d43(%rip), %rsi     # 0x34474
leaq 0x13e8d(%rip), %rcx     # 0x345c5
movl $0xa3b, %edx            # imm = 0xA3B
callq 0xa0b0
leaq 0xd678(%rip), %rdi      # 0x2ddc1
leaq 0x13d24(%rip), %rsi     # 0x34474
leaq 0x13e6e(%rip), %rcx     # 0x345c5
movl $0xa3c, %edx            # imm = 0xA3C
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_get_symbol_by_rstr_key
uint64_t asm_parser_get_symbol_by_rstr_key(
	ParserContext *ctx,
	ResizableString *key
) {
	assert(ctx);
	assert(key);

	Map *symtable = &ASM_PARSER_CONTEXT_DATA_GET_SYMTABLE(ctx);

	MapPrimitiveBox *box = (MapPrimitiveBox *) map_get(symtable, key);
	if (box != NULL) {
		assert(box->type == MAP_PRIMITIVE_BOX_TYPE_UINT64);
		return box->value.u64;
	} else {
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2078c
testq %rsi, %rsi
je 0x207ab
addq $0x68, %rdi
callq 0xc6f2
testq %rax, %rax
je 0x20788
cmpb $0x5, (%rax)
jne 0x207ca
movq 0x8(%rax), %rax
jmp 0x2078a
xorl %eax, %eax
popq %rbp
retq
leaq 0xf631(%rip), %rdi      # 0x2fdc4
leaq 0x13cda(%rip), %rsi     # 0x34474
leaq 0x13e75(%rip), %rcx     # 0x34616
movl $0xa46, %edx            # imm = 0xA46
callq 0xa0b0
leaq 0xd60f(%rip), %rdi      # 0x2ddc1
leaq 0x13cbb(%rip), %rsi     # 0x34474
leaq 0x13e56(%rip), %rcx     # 0x34616
movl $0xa47, %edx            # imm = 0xA47
callq 0xa0b0
leaq 0x13e94(%rip), %rdi     # 0x34665
leaq 0x13c9c(%rip), %rsi     # 0x34474
leaq 0x13e37(%rip), %rcx     # 0x34616
movl $0xa4d, %edx            # imm = 0xA4D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_get_symbol_by_token_key
uint64_t asm_parser_get_symbol_by_token_key(
	ParserContext *ctx,
	LexerToken *key
) {
	assert(ctx);
	assert(key);

	ResizableString rstr_key;
	rstr_init_with_raw(&rstr_key, key->content, key->len);
	uint64_t value = asm_parser_get_symbol_by_rstr_key(ctx, &rstr_key);
	rstr_free(&rstr_key);

	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x20839
testq %rsi, %rsi
je 0x20858
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movl 0x4(%rsi), %edx
leaq -0x20(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xe41c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20761
movq %rax, %rbx
movq %r14, %rdi
callq 0xe772
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xf584(%rip), %rdi      # 0x2fdc4
leaq 0x13c2d(%rip), %rsi     # 0x34474
leaq 0x13e42(%rip), %rcx     # 0x34690
movl $0xa58, %edx            # imm = 0xA58
callq 0xa0b0
leaq 0xd562(%rip), %rdi      # 0x2ddc1
leaq 0x13c0e(%rip), %rsi     # 0x34474
leaq 0x13e23(%rip), %rcx     # 0x34690
movl $0xa59, %edx            # imm = 0xA59
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_get_uint32_val
uint32_t asm_parser_get_uint32_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == ASM_NODE_LITERAL_UINT);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2089a
testq %rsi, %rsi
je 0x208b9
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x208d8
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1c360
leaq 0xf523(%rip), %rdi      # 0x2fdc4
leaq 0x13bcc(%rip), %rsi     # 0x34474
leaq 0x13e2c(%rip), %rcx     # 0x346db
movl $0xa67, %edx            # imm = 0xA67
callq 0xa0b0
leaq 0x113eb(%rip), %rdi     # 0x31cab
leaq 0x13bad(%rip), %rsi     # 0x34474
leaq 0x13e0d(%rip), %rcx     # 0x346db
movl $0xa68, %edx            # imm = 0xA68
callq 0xa0b0
leaq 0x13e41(%rip), %rdi     # 0x34720
leaq 0x13b8e(%rip), %rsi     # 0x34474
leaq 0x13dee(%rip), %rcx     # 0x346db
movl $0xa69, %edx            # imm = 0xA69
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_get_uint64_val
uint64_t asm_parser_get_uint64_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == ASM_NODE_LITERAL_UINT);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2091a
testq %rsi, %rsi
je 0x20939
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x20958
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1c41f
leaq 0xf4a3(%rip), %rdi      # 0x2fdc4
leaq 0x13b4c(%rip), %rsi     # 0x34474
leaq 0x13e15(%rip), %rcx     # 0x34744
movl $0xa72, %edx            # imm = 0xA72
callq 0xa0b0
leaq 0x1136b(%rip), %rdi     # 0x31cab
leaq 0x13b2d(%rip), %rsi     # 0x34474
leaq 0x13df6(%rip), %rcx     # 0x34744
movl $0xa73, %edx            # imm = 0xA73
callq 0xa0b0
leaq 0x13dc1(%rip), %rdi     # 0x34720
leaq 0x13b0e(%rip), %rsi     # 0x34474
leaq 0x13dd7(%rip), %rcx     # 0x34744
movl $0xa74, %edx            # imm = 0xA74
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_get_float_val
float asm_parser_get_float_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == ASM_NODE_LITERAL_REAL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2099a
testq %rsi, %rsi
je 0x209b9
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x209d8
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1c4de
leaq 0xf423(%rip), %rdi      # 0x2fdc4
leaq 0x13acc(%rip), %rsi     # 0x34474
leaq 0x13dda(%rip), %rcx     # 0x34789
movl $0xa7d, %edx            # imm = 0xA7D
callq 0xa0b0
leaq 0x112eb(%rip), %rdi     # 0x31cab
leaq 0x13aad(%rip), %rsi     # 0x34474
leaq 0x13dbb(%rip), %rcx     # 0x34789
movl $0xa7e, %edx            # imm = 0xA7E
callq 0xa0b0
leaq 0x13deb(%rip), %rdi     # 0x347ca
leaq 0x13a8e(%rip), %rsi     # 0x34474
leaq 0x13d9c(%rip), %rcx     # 0x34789
movl $0xa7f, %edx            # imm = 0xA7F
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_get_double_val
double asm_parser_get_double_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == ASM_NODE_LITERAL_REAL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x20a1a
testq %rsi, %rsi
je 0x20a39
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x20a58
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1c55e
leaq 0xf3a3(%rip), %rdi      # 0x2fdc4
leaq 0x13a4c(%rip), %rsi     # 0x34474
leaq 0x13dbf(%rip), %rcx     # 0x347ee
movl $0xa88, %edx            # imm = 0xA88
callq 0xa0b0
leaq 0x1126b(%rip), %rdi     # 0x31cab
leaq 0x13a2d(%rip), %rsi     # 0x34474
leaq 0x13da0(%rip), %rcx     # 0x347ee
movl $0xa89, %edx            # imm = 0xA89
callq 0xa0b0
leaq 0x13d6b(%rip), %rdi     # 0x347ca
leaq 0x13a0e(%rip), %rsi     # 0x34474
leaq 0x13d81(%rip), %rcx     # 0x347ee
movl $0xa8a, %edx            # imm = 0xA8A
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_get_char_val
char asm_parser_get_char_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == ASM_NODE_LITERAL_CHAR);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x20a9a
testq %rsi, %rsi
je 0x20ab9
cmpl $0x302, (%rsi)          # imm = 0x302
jne 0x20ad8
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1c5de
leaq 0xf323(%rip), %rdi      # 0x2fdc4
leaq 0x139cc(%rip), %rsi     # 0x34474
leaq 0x13d82(%rip), %rcx     # 0x34831
movl $0xa93, %edx            # imm = 0xA93
callq 0xa0b0
leaq 0x111eb(%rip), %rdi     # 0x31cab
leaq 0x139ad(%rip), %rsi     # 0x34474
leaq 0x13d63(%rip), %rcx     # 0x34831
movl $0xa94, %edx            # imm = 0xA94
callq 0xa0b0
leaq 0x13d91(%rip), %rdi     # 0x34870
leaq 0x1398e(%rip), %rsi     # 0x34474
leaq 0x13d44(%rip), %rcx     # 0x34831
movl $0xa95, %edx            # imm = 0xA95
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_has_unsigned_mark
bool asm_parser_has_unsigned_mark(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == ASM_NODE_LITERAL_UINT);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x20b1a
testq %rsi, %rsi
je 0x20b39
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x20b58
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1c6dd
leaq 0xf2a3(%rip), %rdi      # 0x2fdc4
leaq 0x1394c(%rip), %rsi     # 0x34474
leaq 0x13d65(%rip), %rcx     # 0x34894
movl $0xa9e, %edx            # imm = 0xA9E
callq 0xa0b0
leaq 0x1116b(%rip), %rdi     # 0x31cab
leaq 0x1392d(%rip), %rsi     # 0x34474
leaq 0x13d46(%rip), %rcx     # 0x34894
movl $0xa9f, %edx            # imm = 0xA9F
callq 0xa0b0
leaq 0x13bc1(%rip), %rdi     # 0x34720
leaq 0x1390e(%rip), %rsi     # 0x34474
leaq 0x13d27(%rip), %rcx     # 0x34894
movl $0xaa0, %edx            # imm = 0xAA0
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_has_float_mark
bool asm_parser_has_float_mark(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == ASM_NODE_LITERAL_REAL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x20b9a
testq %rsi, %rsi
je 0x20bb9
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x20bd8
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1c766
leaq 0xf223(%rip), %rdi      # 0x2fdc4
leaq 0x138cc(%rip), %rsi     # 0x34474
leaq 0x13d2a(%rip), %rcx     # 0x348d9
movl $0xaa9, %edx            # imm = 0xAA9
callq 0xa0b0
leaq 0x110eb(%rip), %rdi     # 0x31cab
leaq 0x138ad(%rip), %rsi     # 0x34474
leaq 0x13d0b(%rip), %rcx     # 0x348d9
movl $0xaaa, %edx            # imm = 0xAAA
callq 0xa0b0
leaq 0x13beb(%rip), %rdi     # 0x347ca
leaq 0x1388e(%rip), %rsi     # 0x34474
leaq 0x13cec(%rip), %rcx     # 0x348d9
movl $0xaab, %edx            # imm = 0xAAB
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: rule_expr_mul
_RULE(expr_mul)
	_RULE_RETURNED_NODE(_RULE_NAME(expr_unary)(_RULE_PARSER_CTX))

	for (;_RULE_CURRENT_NODE != NULL;) {
		_RULE_PUSH_LEXCTX
		_RULE_NEXT_TOKEN
		if (_RULE_TOKEN_TYPE == ASM_TOKEN_PNCT_MUL) {
			_EXPR_BINARY_ITEM(ASM_NODE_EXPR_MUL, expr_unary)
		} else if (_RULE_TOKEN_TYPE == ASM_TOKEN_PNCT_DIV) {
			_EXPR_BINARY_ITEM(ASM_NODE_EXPR_DIV, expr_unary)
		} else if (_RULE_TOKEN_TYPE == ASM_TOKEN_PNCT_MOD) {
			_EXPR_BINARY_ITEM(ASM_NODE_EXPR_MOD, expr_unary)
		} else {
			_RULE_POP_LEXCTX
			break;
		}
		_RULE_ABANDON_LEXCTX
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x21ed1
callq 0xb5f9
movq %rbx, %rdi
callq 0x21ef0
testq %rax, %rax
je 0x21eaa
movq %rax, %r14
leaq 0x12f8c(%rip), %r12     # 0x34d55
leaq 0x12f73(%rip), %r13     # 0x34d43
movq (%rbx), %rdi
callq 0xb5f9
movq (%rbx), %rdi
callq 0xb36c
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x21eaf
movl (%rax), %eax
cmpl $0x4015, %eax           # imm = 0x4015
je 0x21e46
cmpl $0x4014, %eax           # imm = 0x4014
je 0x21e29
cmpl $0x4013, %eax           # imm = 0x4013
jne 0x21eaf
movq %rbx, %rdi
callq 0x21ef0
testq %rax, %rax
je 0x21eaf
movq %rax, %r15
movq %rbx, %rdi
movl $0xeb0, %esi            # imm = 0xEB0
movq %r13, %rdx
jmp 0x21e65
movq %rbx, %rdi
callq 0x21ef0
testq %rax, %rax
je 0x21eaf
movq %rax, %r15
movq %rbx, %rdi
movl $0xeb1, %esi            # imm = 0xEB1
movq %r12, %rdx
jmp 0x21e65
movq %rbx, %rdi
callq 0x21ef0
testq %rax, %rax
je 0x21eaf
movq %rax, %r15
movq %rbx, %rdi
movl $0xeb2, %esi            # imm = 0xEB2
leaq 0x12f02(%rip), %rdx     # 0x34d67
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xd511
movq %rax, 0x30(%r14)
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xd7ef
movq %rax, 0x30(%r15)
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xd7ef
movq %rax, %r14
movq (%rbx), %rdi
callq 0xb6c2
testq %r14, %r14
jne 0x21dd0
xorl %r14d, %r14d
jmp 0x21eb7
movq (%rbx), %rdi
callq 0xb661
movq (%rbx), %rdi
callq 0xb6c2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12a70(%rip), %rdi     # 0x34948
leaq 0x12595(%rip), %rsi     # 0x34474
leaq 0x12e2e(%rip), %rcx     # 0x34d14
movl $0x12e, %edx            # imm = 0x12E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: get_seg_reg_id
static int _get_seg_reg_id(
	LexerToken *token
) {
	assert(token);

	InsRegister *reg = _get_ins_reg_by_token(token);
	
	if (reg != NULL && reg->type == INS_REGISTER_SEG) {
		return reg->id;
	} else {
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2290e
movl 0x4(%rdi), %eax
movq 0x8(%rdi), %rsi
movl %eax, %edi
callq 0x22a33
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x2290c
cmpl $0x1, 0xc(%rcx)
jne 0x2290c
movl 0x8(%rcx), %eax
popq %rbp
retq
leaq 0xaba5(%rip), %rdi      # 0x2d4ba
leaq 0x11b58(%rip), %rsi     # 0x34474
leaq 0x12719(%rip), %rcx     # 0x3503c
movl $0x217, %edx            # imm = 0x217
callq 0xa0b0