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

	ParserASTNode *ins_node = data->ins_node;

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

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

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

	EncoderInstruction enc_ins;

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

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

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

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

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

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
testq %rdi, %rdi
je 0x19f18
movq %rsi, %rbx
testq %rsi, %rsi
je 0x19f21
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x19f2a
cmpl $0x3, 0x44(%rdx)
jne 0x19f33
movq %rdi, %r14
movq 0x48(%rdx), %rax
movq (%rax), %r13
movq 0x8(%rax), %r12
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rbx), %rdi
leaq -0x90(%rbp), %r15
movq %r14, %rsi
movq %r15, %rcx
callq 0x1470f
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x1480a
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x14948
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x15ae1
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq -0x30(%rbp), %rdx
movq %r15, %rcx
callq 0x15102
movq %rbx, %rdi
movq %r15, %rsi
callq 0x17180
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1581b(%rip), %rdi     # 0x2f73a
jmp 0x19f3a
leaq 0x1b6c3(%rip), %rdi     # 0x355eb
jmp 0x19f3a
leaq 0x16d80(%rip), %rdi     # 0x30cb1
jmp 0x19f3a
leaq 0x17932(%rip), %rdi     # 0x3186c
leaq 0x16d13(%rip), %rsi     # 0x30c54
leaq 0x17980(%rip), %rcx     # 0x318c8
movl $0x6f5, %edx            # imm = 0x6F5
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_INS_OUTS_W
void ins_enc_INS_OUTS_W(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(0);

	ParserASTNode *ins_node = data->ins_node;

	EncoderInstruction enc_ins;

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

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

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
testq %rdi, %rdi
je 0x19fb1
movq %rsi, %rbx
testq %rsi, %rsi
je 0x19fba
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x19fc3
cmpl $0x0, 0x44(%rdx)
jne 0x19fcc
movq %rdi, %rsi
movq 0x8(%rbx), %rdi
leaq -0x68(%rbp), %rcx
callq 0x1470f
movq 0x8(%rbx), %rax
movl 0xb0(%rax), %eax
cmpl $0x4, %eax
je 0x19f9a
cmpl $0x2, %eax
jne 0x19f9e
movb $0x1, -0x5d(%rbp)
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x17180
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
leaq 0x15782(%rip), %rdi     # 0x2f73a
jmp 0x19fd3
leaq 0x1b62a(%rip), %rdi     # 0x355eb
jmp 0x19fd3
leaq 0x16ce7(%rip), %rdi     # 0x30cb1
jmp 0x19fd3
leaq 0x170af(%rip), %rdi     # 0x31082
leaq 0x16c7a(%rip), %rsi     # 0x30c54
leaq 0x1792b(%rip), %rcx     # 0x3190c
movl $0x712, %edx            # imm = 0x712
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_POP_Ev
void ins_enc_POP_Ev(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(1);

	ParserASTNode *ins_node = data->ins_node;

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

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

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

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

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
testq %rdi, %rdi
je 0x1a3d8
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1a3e1
movq (%rbx), %r15
testq %r15, %r15
je 0x1a3ea
cmpl $0x1, 0x44(%r15)
jne 0x1a3f3
movq %rdi, %r14
movq 0x48(%r15), %rax
movq (%rax), %r12
movq 0x8(%rbx), %rdi
leaq -0x80(%rbp), %rcx
movq %r14, %rsi
movq %r15, %rdx
callq 0x1470f
movq 0x8(%rbx), %rdi
movq %r12, %rsi
callq 0x15a8f
movq 0x8(%rbx), %rdi
movl 0xb0(%rdi), %ecx
cmpl $0x4, %ecx
je 0x1a395
cmpl $0x2, %ecx
je 0x1a380
cmpl $0x1, %ecx
jne 0x1a412
cmpq $0x4, %rax
je 0x1a3a1
cmpq $0x2, %rax
je 0x1a3a1
leaq 0x16ae2(%rip), %rdx     # 0x30e60
jmp 0x1a3b9
cmpq $0x4, %rax
je 0x1a3a1
cmpq $0x2, %rax
je 0x1a3a1
leaq 0x16af7(%rip), %rdx     # 0x30e8a
jmp 0x1a3b9
cmpq $0x8, %rax
je 0x1a3a1
cmpq $0x2, %rax
jne 0x1a3b2
leaq -0x80(%rbp), %rcx
movq %r14, %rsi
movq %r12, %rdx
callq 0x14948
jmp 0x1a3bf
leaq 0x16bd9(%rip), %rdx     # 0x30f92
movq %r15, %rsi
callq *0x58(%rdi)
leaq -0x80(%rbp), %rsi
movq %rbx, %rdi
callq 0x17180
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1535b(%rip), %rdi     # 0x2f73a
jmp 0x1a3fa
leaq 0x1b203(%rip), %rdi     # 0x355eb
jmp 0x1a3fa
leaq 0x168c0(%rip), %rdi     # 0x30cb1
jmp 0x1a3fa
leaq 0x16b38(%rip), %rdi     # 0x30f32
leaq 0x16853(%rip), %rsi     # 0x30c54
leaq 0x17645(%rip), %rcx     # 0x31a4d
movl $0x78d, %edx            # imm = 0x78D
callq 0xa0b0
leaq 0x12f57(%rip), %rdi     # 0x2d370
leaq 0x16834(%rip), %rsi     # 0x30c54
leaq 0x17626(%rip), %rcx     # 0x31a4d
movl $0x7c2, %edx            # imm = 0x7C2
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_opcode_implicit_oprd64
void ins_enc_opcode_implicit_oprd64(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(0);

	ParserASTNode *ins_node = data->ins_node;

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

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

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
testq %rdi, %rdi
je 0x1a631
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1a63a
movq (%rbx), %r14
testq %r14, %r14
je 0x1a643
cmpl $0x0, 0x44(%r14)
jne 0x1a64c
movq %rdi, %rsi
movq 0x8(%rbx), %rdi
leaq -0x70(%rbp), %rcx
movq %r14, %rdx
callq 0x1470f
movq 0x8(%rbx), %rdi
movl 0xb0(%rdi), %eax
cmpl $0x4, %eax
je 0x1a616
cmpl $0x2, %eax
je 0x1a607
cmpl $0x1, %eax
jne 0x1a66b
leaq 0x1685b(%rip), %rdx     # 0x30e60
jmp 0x1a60e
leaq 0x1687c(%rip), %rdx     # 0x30e8a
movq %r14, %rsi
callq *0x58(%rdi)
jmp 0x1a61c
movw $0x101, -0x63(%rbp)     # imm = 0x101
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x17180
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x15102(%rip), %rdi     # 0x2f73a
jmp 0x1a653
leaq 0x1afaa(%rip), %rdi     # 0x355eb
jmp 0x1a653
leaq 0x16667(%rip), %rdi     # 0x30cb1
jmp 0x1a653
leaq 0x16a2f(%rip), %rdi     # 0x31082
leaq 0x165fa(%rip), %rsi     # 0x30c54
leaq 0x174c3(%rip), %rcx     # 0x31b24
movl $0x80c, %edx            # imm = 0x80C
callq 0xa0b0
leaq 0x12cfe(%rip), %rdi     # 0x2d370
leaq 0x165db(%rip), %rsi     # 0x30c54
leaq 0x174a4(%rip), %rcx     # 0x31b24
movl $0x82b, %edx            # imm = 0x82B
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_pushfd_popfd
void ins_enc_pushfd_popfd(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(0);

	ParserASTNode *ins_node = data->ins_node;

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

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

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

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
testq %rdi, %rdi
je 0x1a8ec
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1a8f5
movq (%rbx), %r14
testq %r14, %r14
je 0x1a8fe
cmpl $0x0, 0x44(%r14)
jne 0x1a907
movq %rdi, %rsi
movq 0x8(%rbx), %rdi
leaq -0x70(%rbp), %rcx
movq %r14, %rdx
callq 0x1470f
movq 0x8(%rbx), %rdi
movl 0xb0(%rdi), %eax
cmpl $0x4, %eax
je 0x1a8ca
cmpl $0x2, %eax
je 0x1a8d7
cmpl $0x1, %eax
jne 0x1a926
movb $0x1, -0x65(%rbp)
jmp 0x1a8d7
leaq 0x166c1(%rip), %rdx     # 0x30f92
movq %r14, %rsi
callq *0x58(%rdi)
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x17180
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x14e47(%rip), %rdi     # 0x2f73a
jmp 0x1a90e
leaq 0x1acef(%rip), %rdi     # 0x355eb
jmp 0x1a90e
leaq 0x163ac(%rip), %rdi     # 0x30cb1
jmp 0x1a90e
leaq 0x16774(%rip), %rdi     # 0x31082
leaq 0x1633f(%rip), %rsi     # 0x30c54
leaq 0x1728e(%rip), %rcx     # 0x31baa
movl $0x8a6, %edx            # imm = 0x8A6
callq 0xa0b0
leaq 0x12a43(%rip), %rdi     # 0x2d370
leaq 0x16320(%rip), %rsi     # 0x30c54
leaq 0x1726f(%rip), %rcx     # 0x31baa
movl $0x8c0, %edx            # imm = 0x8C0
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_pushfq_popfq
void ins_enc_pushfq_popfq(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(0);

	ParserASTNode *ins_node = data->ins_node;

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

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

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
testq %rdi, %rdi
je 0x1a9c3
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1a9cc
movq (%rbx), %r14
testq %r14, %r14
je 0x1a9d5
cmpl $0x0, 0x44(%r14)
jne 0x1a9de
movq %rdi, %rsi
movq 0x8(%rbx), %rdi
leaq -0x70(%rbp), %rcx
movq %r14, %rdx
callq 0x1470f
movq 0x8(%rbx), %rdi
movl 0xb0(%rdi), %eax
cmpl $0x1, %eax
je 0x1a9a1
cmpl $0x4, %eax
je 0x1a9ae
cmpl $0x2, %eax
jne 0x1a9fd
leaq 0x164eb(%rip), %rdx     # 0x30e8a
jmp 0x1a9a8
leaq 0x164b8(%rip), %rdx     # 0x30e60
movq %r14, %rsi
callq *0x58(%rdi)
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x17180
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x14d70(%rip), %rdi     # 0x2f73a
jmp 0x1a9e5
leaq 0x1ac18(%rip), %rdi     # 0x355eb
jmp 0x1a9e5
leaq 0x162d5(%rip), %rdi     # 0x30cb1
jmp 0x1a9e5
leaq 0x1669d(%rip), %rdi     # 0x31082
leaq 0x16268(%rip), %rsi     # 0x30c54
leaq 0x171fa(%rip), %rcx     # 0x31bed
movl $0x8cc, %edx            # imm = 0x8CC
callq 0xa0b0
leaq 0x1296c(%rip), %rdi     # 0x2d370
leaq 0x16249(%rip), %rsi     # 0x30c54
leaq 0x171db(%rip), %rcx     # 0x31bed
movl $0x8ea, %edx            # imm = 0x8EA
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_enter
void ins_enc_enter(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(2);

	ParserASTNode *ins_node = data->ins_node;

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

	EncoderInstruction enc_ins;

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

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

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
testq %rdi, %rdi
je 0x1aaaa
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1aab3
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1aabc
cmpl $0x2, 0x44(%rdx)
jne 0x1aac5
movq %rdi, %r14
movq 0x48(%rdx), %rax
movq (%rax), %r15
movq 0x8(%rax), %r12
movq 0x8(%rbx), %rdi
leaq -0x88(%rbp), %r13
movq %r14, %rsi
movq %r13, %rcx
callq 0x1470f
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x15723
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x1565c
movq %rbx, %rdi
movq %r13, %rsi
callq 0x17180
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14c89(%rip), %rdi     # 0x2f73a
jmp 0x1aacc
leaq 0x1ab31(%rip), %rdi     # 0x355eb
jmp 0x1aacc
leaq 0x161ee(%rip), %rdi     # 0x30cb1
jmp 0x1aacc
leaq 0x161f4(%rip), %rdi     # 0x30cc0
leaq 0x16181(%rip), %rsi     # 0x30c54
leaq 0x17156(%rip), %rcx     # 0x31c30
movl $0x8f6, %edx            # imm = 0x8F6
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
testq %rdi, %rdi
je 0x1ad97
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1ada0
movq (%rbx), %r12
testq %r12, %r12
je 0x1ada9
cmpl $0x1, 0x44(%r12)
jne 0x1adb2
movq %rdi, %r15
movq 0x48(%r12), %rax
movq (%rax), %rax
movq 0x8(%rbx), %rdi
movq 0x10(%rax), %rsi
callq 0x1fb4a
movq %rax, %r14
movq 0x8(%rbx), %rdi
leaq -0xb0(%rbp), %rcx
movq %r15, %rsi
movq %r12, %rdx
callq 0x1470f
movq 0x8(%rbx), %rax
movl 0xb0(%rax), %eax
cmpl $0x1, %eax
je 0x1ad13
cmpl $0x4, %eax
je 0x1ad0f
cmpl $0x2, %eax
jne 0x1add1
movb $0x4, %al
jmp 0x1ad15
movb $0x2, %al
leaq -0xb0(%rbp), %r15
movb %al, 0x1e(%r15)
andq $0x0, 0x20(%r15)
leaq -0x50(%rbp), %r12
pushq $0x20
popq %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x13adc
movq 0x8(%rbx), %rcx
addq 0xc0(%rcx), %rax
subq %rax, %r14
movq %r14, 0x20(%r15)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x13adc
movq 0x8(%rbx), %rcx
addq %rax, 0xc0(%rcx)
cmpl $0x1, 0xc8(%rcx)
je 0x1ad85
movq 0xb8(%rcx), %rcx
leaq -0x50(%rbp), %rdi
pushq $0x1
popq %rdx
movq %rax, %rsi
callq 0xa170
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1499c(%rip), %rdi     # 0x2f73a
jmp 0x1adb9
leaq 0x1a844(%rip), %rdi     # 0x355eb
jmp 0x1adb9
leaq 0x15f01(%rip), %rdi     # 0x30cb1
jmp 0x1adb9
leaq 0x16179(%rip), %rdi     # 0x30f32
leaq 0x15e94(%rip), %rsi     # 0x30c54
leaq 0x16f1d(%rip), %rcx     # 0x31ce4
movl $0x95f, %edx            # imm = 0x95F
callq 0xa0b0
leaq 0x12598(%rip), %rdi     # 0x2d370
leaq 0x15e75(%rip), %rsi     # 0x30c54
leaq 0x16efe(%rip), %rcx     # 0x31ce4
movl $0x976, %edx            # imm = 0x976
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1aecf
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1aed8
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1aee1
cmpl $0x2, 0x44(%rdx)
jne 0x1aeea
movq %rdi, %rsi
movq 0x48(%rdx), %rax
movq (%rax), %r14
movq 0x8(%rbx), %rdi
leaq -0x70(%rbp), %rcx
callq 0x1470f
movq 0x60(%r14), %rax
movq 0x8(%rbx), %rcx
movl 0xb0(%rcx), %ecx
cmpl $0x4, %ecx
je 0x1ae8a
cmpl $0x2, %ecx
je 0x1ae8a
cmpl $0x1, %ecx
jne 0x1af09
movl 0xc(%rax), %eax
cmpl $0x3, %eax
je 0x1aeba
cmpl $0x4, %eax
je 0x1aeb6
leaq 0x124fe(%rip), %rdi     # 0x2d370
leaq 0x15ddb(%rip), %rsi     # 0x30c54
leaq 0x16e9d(%rip), %rcx     # 0x31d1d
movl $0x9aa, %edx            # imm = 0x9AA
callq 0xa0b0
movl 0xc(%rax), %eax
cmpl $0x3, %eax
je 0x1aeb6
cmpl $0x4, %eax
je 0x1aeba
leaq 0x124d2(%rip), %rdi     # 0x2d370
leaq 0x15daf(%rip), %rsi     # 0x30c54
leaq 0x16e71(%rip), %rcx     # 0x31d1d
movl $0x9bc, %edx            # imm = 0x9BC
callq 0xa0b0
movb $0x1, -0x65(%rbp)
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x17180
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x14864(%rip), %rdi     # 0x2f73a
jmp 0x1aef1
leaq 0x1a70c(%rip), %rdi     # 0x355eb
jmp 0x1aef1
leaq 0x15dc9(%rip), %rdi     # 0x30cb1
jmp 0x1aef1
leaq 0x15dcf(%rip), %rdi     # 0x30cc0
leaq 0x15d5c(%rip), %rsi     # 0x30c54
leaq 0x16e1e(%rip), %rcx     # 0x31d1d
movl $0x992, %edx            # imm = 0x992
callq 0xa0b0
leaq 0x12460(%rip), %rdi     # 0x2d370
leaq 0x15d3d(%rip), %rsi     # 0x30c54
leaq 0x16dff(%rip), %rcx     # 0x31d1d
movl $0x9c3, %edx            # imm = 0x9C3
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1b008
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1b011
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1b01a
cmpl $0x2, 0x44(%rdx)
jne 0x1b023
movq %rdi, %rsi
movq 0x48(%rdx), %rax
movq 0x8(%rax), %r14
movq 0x8(%rbx), %rdi
leaq -0x70(%rbp), %rcx
callq 0x1470f
movq 0x60(%r14), %rax
movq 0x8(%rbx), %rcx
movl 0xb0(%rcx), %ecx
cmpl $0x4, %ecx
je 0x1afc3
cmpl $0x2, %ecx
je 0x1afc3
cmpl $0x1, %ecx
jne 0x1b042
movl 0xc(%rax), %eax
cmpl $0x3, %eax
je 0x1aff3
cmpl $0x4, %eax
je 0x1afef
leaq 0x123c5(%rip), %rdi     # 0x2d370
leaq 0x15ca2(%rip), %rsi     # 0x30c54
leaq 0x16da4(%rip), %rcx     # 0x31d5d
movl $0x9e7, %edx            # imm = 0x9E7
callq 0xa0b0
movl 0xc(%rax), %eax
cmpl $0x3, %eax
je 0x1afef
cmpl $0x4, %eax
je 0x1aff3
leaq 0x12399(%rip), %rdi     # 0x2d370
leaq 0x15c76(%rip), %rsi     # 0x30c54
leaq 0x16d78(%rip), %rcx     # 0x31d5d
movl $0x9f9, %edx            # imm = 0x9F9
callq 0xa0b0
movb $0x1, -0x65(%rbp)
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x17180
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1472b(%rip), %rdi     # 0x2f73a
jmp 0x1b02a
leaq 0x1a5d3(%rip), %rdi     # 0x355eb
jmp 0x1b02a
leaq 0x15c90(%rip), %rdi     # 0x30cb1
jmp 0x1b02a
leaq 0x15c96(%rip), %rdi     # 0x30cc0
leaq 0x15c23(%rip), %rsi     # 0x30c54
leaq 0x16d25(%rip), %rcx     # 0x31d5d
movl $0x9cf, %edx            # imm = 0x9CF
callq 0xa0b0
leaq 0x12327(%rip), %rdi     # 0x2d370
leaq 0x15c04(%rip), %rsi     # 0x30c54
leaq 0x16d06(%rip), %rcx     # 0x31d5d
movl $0xa00, %edx            # imm = 0xA00
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1b0e6
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1b0ef
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1b0f8
cmpl $0x1, 0x44(%rdx)
jne 0x1b101
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 0x1470f
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 0x14f78
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17180
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1464d(%rip), %rdi     # 0x2f73a
jmp 0x1b108
leaq 0x1a4f5(%rip), %rdi     # 0x355eb
jmp 0x1b108
leaq 0x15bb2(%rip), %rdi     # 0x30cb1
jmp 0x1b108
leaq 0x15e2a(%rip), %rdi     # 0x30f32
leaq 0x15b45(%rip), %rsi     # 0x30c54
leaq 0x16c88(%rip), %rcx     # 0x31d9e
movl $0xa0c, %edx            # imm = 0xA0C
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1b1a5
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1b1ae
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1b1b7
cmpl $0x1, 0x44(%rdx)
jne 0x1b1c0
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 0x1470f
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 0x1503d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17180
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1458e(%rip), %rdi     # 0x2f73a
jmp 0x1b1c7
leaq 0x1a436(%rip), %rdi     # 0x355eb
jmp 0x1b1c7
leaq 0x15af3(%rip), %rdi     # 0x30cb1
jmp 0x1b1c7
leaq 0x15d6b(%rip), %rdi     # 0x30f32
leaq 0x15a86(%rip), %rsi     # 0x30c54
leaq 0x16c11(%rip), %rcx     # 0x31de6
movl $0xa22, %edx            # imm = 0xA22
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1b3f4
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1b3fd
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1b406
cmpl $0x1, 0x44(%rdx)
jne 0x1b40f
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 0x1470f
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 0x14948
movb $0x0, 0xb(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17180
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1433f(%rip), %rdi     # 0x2f73a
jmp 0x1b416
leaq 0x1a1e7(%rip), %rdi     # 0x355eb
jmp 0x1b416
leaq 0x158a4(%rip), %rdi     # 0x30cb1
jmp 0x1b416
leaq 0x15b1c(%rip), %rdi     # 0x30f32
leaq 0x15837(%rip), %rsi     # 0x30c54
leaq 0x16a9a(%rip), %rcx     # 0x31ebe
movl $0xa68, %edx            # imm = 0xA68
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1b4b9
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1b4c2
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1b4cb
cmpl $0x1, 0x44(%rdx)
jne 0x1b4d4
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 0x1470f
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 0x1503d
movb $0x0, 0xb(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17180
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1427a(%rip), %rdi     # 0x2f73a
jmp 0x1b4db
leaq 0x1a122(%rip), %rdi     # 0x355eb
jmp 0x1b4db
leaq 0x157df(%rip), %rdi     # 0x30cb1
jmp 0x1b4db
leaq 0x15a57(%rip), %rdi     # 0x30f32
leaq 0x15772(%rip), %rsi     # 0x30c54
leaq 0x16a1d(%rip), %rcx     # 0x31f06
movl $0xa80, %edx            # imm = 0xA80
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1b575
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1b57e
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1b587
cmpl $0x0, 0x44(%rdx)
jne 0x1b590
movq %rdi, %r14
movq 0x8(%rbx), %rdi
leaq -0x78(%rbp), %r15
movq %r14, %rsi
movq %r15, %rcx
callq 0x1470f
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 0x1b554
movb $0x3, -0x61(%rbp)
shrb $0x5, %al
leaq -0x78(%rbp), %rsi
movb %al, 0x19(%rsi)
movb $0x0, 0xb(%rsi)
movq %rbx, %rdi
callq 0x17180
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x141be(%rip), %rdi     # 0x2f73a
jmp 0x1b597
leaq 0x1a066(%rip), %rdi     # 0x355eb
jmp 0x1b597
leaq 0x15723(%rip), %rdi     # 0x30cb1
jmp 0x1b597
leaq 0x15aeb(%rip), %rdi     # 0x31082
leaq 0x156b6(%rip), %rsi     # 0x30c54
leaq 0x169a9(%rip), %rcx     # 0x31f4e
movl $0xa98, %edx            # imm = 0xA98
callq 0xa0b0
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x1b5cf
testq %rsi, %rsi
je 0x1b5ee
testl %edx, %edx
js 0x1b60d
leaq 0x29787(%rip), %rcx     # 0x44d50
popq %rbp
jmp 0xac5c
leaq 0x11433(%rip), %rdi     # 0x2ca09
leaq 0x169d7(%rip), %rsi     # 0x31fb4
leaq 0x169eb(%rip), %rcx     # 0x31fcf
movl $0x145, %edx            # imm = 0x145
callq 0xa0b0
leaq 0x10f41(%rip), %rdi     # 0x2c536
leaq 0x169b8(%rip), %rsi     # 0x31fb4
leaq 0x169cc(%rip), %rcx     # 0x31fcf
movl $0x146, %edx            # imm = 0x146
callq 0xa0b0
leaq 0x10f29(%rip), %rdi     # 0x2c53d
leaq 0x16999(%rip), %rsi     # 0x31fb4
leaq 0x169ad(%rip), %rcx     # 0x31fcf
movl $0x147, %edx            # imm = 0x147
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1b6ba
testq %rsi, %rsi
je 0x1b6d9
movl $0xfffff000, %eax       # imm = 0xFFFFF000
addl (%rsi), %eax
cmpl $0x3, %eax
ja 0x1b6f8
leaq 0x16917(%rip), %rcx     # 0x31f94
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x10713
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x1093b
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x10ad7
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x1082f
leaq 0x13713(%rip), %rdi     # 0x2edd4
leaq 0x168ec(%rip), %rsi     # 0x31fb4
leaq 0x16971(%rip), %rcx     # 0x32040
movl $0x158, %edx            # imm = 0x158
callq 0xa0b0
leaq 0x10dda(%rip), %rdi     # 0x2c4ba
leaq 0x168cd(%rip), %rsi     # 0x31fb4
leaq 0x16952(%rip), %rcx     # 0x32040
movl $0x159, %edx            # imm = 0x159
callq 0xa0b0
leaq 0x11c71(%rip), %rdi     # 0x2d370
leaq 0x168ae(%rip), %rsi     # 0x31fb4
leaq 0x16933(%rip), %rcx     # 0x32040
movl $0x169, %edx            # imm = 0x169
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1b779
testq %rsi, %rsi
je 0x1b798
movl $0xfffff000, %eax       # imm = 0xFFFFF000
addl (%rsi), %eax
cmpl $0x3, %eax
ja 0x1b7b7
leaq 0x16868(%rip), %rcx     # 0x31fa4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x1066d
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x108aa
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x109b6
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x1078e
leaq 0x13654(%rip), %rdi     # 0x2edd4
leaq 0x1682d(%rip), %rsi     # 0x31fb4
leaq 0x168f2(%rip), %rcx     # 0x32080
movl $0x174, %edx            # imm = 0x174
callq 0xa0b0
leaq 0x10d1b(%rip), %rdi     # 0x2c4ba
leaq 0x1680e(%rip), %rsi     # 0x31fb4
leaq 0x168d3(%rip), %rcx     # 0x32080
movl $0x175, %edx            # imm = 0x175
callq 0xa0b0
leaq 0x11bb2(%rip), %rdi     # 0x2d370
leaq 0x167ef(%rip), %rsi     # 0x31fb4
leaq 0x168b4(%rip), %rcx     # 0x32080
movl $0x185, %edx            # imm = 0x185
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1b7f9
testq %rsi, %rsi
je 0x1b818
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x1b837
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x10c54
leaq 0x135d4(%rip), %rdi     # 0x2edd4
leaq 0x167ad(%rip), %rsi     # 0x31fb4
leaq 0x168b2(%rip), %rcx     # 0x320c0
movl $0x190, %edx            # imm = 0x190
callq 0xa0b0
leaq 0x10c9b(%rip), %rdi     # 0x2c4ba
leaq 0x1678e(%rip), %rsi     # 0x31fb4
leaq 0x16893(%rip), %rcx     # 0x320c0
movl $0x191, %edx            # imm = 0x191
callq 0xa0b0
leaq 0x11b32(%rip), %rdi     # 0x2d370
leaq 0x1676f(%rip), %rsi     # 0x31fb4
leaq 0x16874(%rip), %rcx     # 0x320c0
movl $0x196, %edx            # imm = 0x196
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1b879
testq %rsi, %rsi
je 0x1b898
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x1b8b7
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x10b52
leaq 0x13554(%rip), %rdi     # 0x2edd4
leaq 0x1672d(%rip), %rsi     # 0x31fb4
leaq 0x1686e(%rip), %rcx     # 0x320fc
movl $0x1a0, %edx            # imm = 0x1A0
callq 0xa0b0
leaq 0x10c1b(%rip), %rdi     # 0x2c4ba
leaq 0x1670e(%rip), %rsi     # 0x31fb4
leaq 0x1684f(%rip), %rcx     # 0x320fc
movl $0x1a1, %edx            # imm = 0x1A1
callq 0xa0b0
leaq 0x11ab2(%rip), %rdi     # 0x2d370
leaq 0x166ef(%rip), %rsi     # 0x31fb4
leaq 0x16830(%rip), %rcx     # 0x320fc
movl $0x1a6, %edx            # imm = 0x1A6
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1b8f9
testq %rsi, %rsi
je 0x1b918
cmpl $0x1005, (%rsi)         # imm = 0x1005
jne 0x1b937
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x10528
leaq 0x134d4(%rip), %rdi     # 0x2edd4
leaq 0x166ad(%rip), %rsi     # 0x31fb4
leaq 0x1682c(%rip), %rcx     # 0x3213a
movl $0x1b0, %edx            # imm = 0x1B0
callq 0xa0b0
leaq 0x10b9b(%rip), %rdi     # 0x2c4ba
leaq 0x1668e(%rip), %rsi     # 0x31fb4
leaq 0x1680d(%rip), %rcx     # 0x3213a
movl $0x1b1, %edx            # imm = 0x1B1
callq 0xa0b0
leaq 0x11a32(%rip), %rdi     # 0x2d370
leaq 0x1666f(%rip), %rsi     # 0x31fb4
leaq 0x167ee(%rip), %rcx     # 0x3213a
movl $0x1b6, %edx            # imm = 0x1B6
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1b978
testq %rsi, %rsi
je 0x1b997
testq %rdx, %rdx
je 0x1b9b6
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
popq %rbp
jmp 0x105dc
leaq 0x13455(%rip), %rdi     # 0x2edd4
leaq 0x1662e(%rip), %rsi     # 0x31fb4
leaq 0x167e7(%rip), %rcx     # 0x32174
movl $0x1c2, %edx            # imm = 0x1C2
callq 0xa0b0
leaq 0x176f8(%rip), %rdi     # 0x33096
leaq 0x1660f(%rip), %rsi     # 0x31fb4
leaq 0x167c8(%rip), %rcx     # 0x32174
movl $0x1c3, %edx            # imm = 0x1C3
callq 0xa0b0
leaq 0x10b79(%rip), %rdi     # 0x2c536
leaq 0x165f0(%rip), %rsi     # 0x31fb4
leaq 0x167a9(%rip), %rcx     # 0x32174
movl $0x1c4, %edx            # imm = 0x1C4
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1ba01
testq %rsi, %rsi
je 0x1ba20
movl (%rsi), %eax
andl $-0x4, %eax
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x1ba3f
movq 0x8(%rsi), %rax
movslq 0x4(%rsi), %rcx
cmpb $0x75, -0x1(%rax,%rcx)
sete %al
popq %rbp
retq
leaq 0x133cc(%rip), %rdi     # 0x2edd4
leaq 0x165a5(%rip), %rsi     # 0x31fb4
leaq 0x167b6(%rip), %rcx     # 0x321cc
movl $0x1cd, %edx            # imm = 0x1CD
callq 0xa0b0
leaq 0x10a93(%rip), %rdi     # 0x2c4ba
leaq 0x16586(%rip), %rsi     # 0x31fb4
leaq 0x16797(%rip), %rcx     # 0x321cc
movl $0x1ce, %edx            # imm = 0x1CE
callq 0xa0b0
leaq 0x167c6(%rip), %rdi     # 0x3220c
leaq 0x16567(%rip), %rsi     # 0x31fb4
leaq 0x16778(%rip), %rcx     # 0x321cc
movl $0x1d4, %edx            # imm = 0x1D4
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1ba86
testq %rsi, %rsi
je 0x1baa5
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x1bac4
movq 0x8(%rsi), %rax
movslq 0x4(%rsi), %rcx
cmpb $0x66, -0x1(%rax,%rcx)
sete %al
popq %rbp
retq
leaq 0x13347(%rip), %rdi     # 0x2edd4
leaq 0x16520(%rip), %rsi     # 0x31fb4
leaq 0x16822(%rip), %rcx     # 0x322bd
movl $0x1dd, %edx            # imm = 0x1DD
callq 0xa0b0
leaq 0x10a0e(%rip), %rdi     # 0x2c4ba
leaq 0x16501(%rip), %rsi     # 0x31fb4
leaq 0x16803(%rip), %rcx     # 0x322bd
movl $0x1de, %edx            # imm = 0x1DE
callq 0xa0b0
leaq 0x1682f(%rip), %rdi     # 0x322fa
leaq 0x164e2(%rip), %rsi     # 0x31fb4
leaq 0x167e4(%rip), %rcx     # 0x322bd
movl $0x1df, %edx            # imm = 0x1DF
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1d5b7
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 0x20a1d(%rip), %r15     # 0x3dff8
movq (%r15), %rsi
leaq 0x15cb8(%rip), %rdi     # 0x3329d
callq 0xa0c0
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xa150
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0xa0d0
pushq $0x1
popq %rdi
callq 0xa160
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x1d690
testq %rsi, %rsi
je 0x1d6af
testl %edx, %edx
js 0x1d6ce
callq 0x1b5b0
movq %rax, %rbx
movq %rax, %rdi
callq 0xb4d1
leaq -0x10d05(%rip), %rsi    # 0xc93f
leaq -0xf351(%rip), %rcx     # 0xe2fa
leaq -0x10d2d(%rip), %r8     # 0xc925
leaq -0x78(%rbp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0xc13c
pushq $0x1
popq %rax
movl %eax, 0x48(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r14)
movl %eax, 0x60(%r14)
andw $0x0, 0x64(%r14)
pushq $0x68
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xcc34
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xf372(%rip), %rdi      # 0x2ca09
leaq 0x15e12(%rip), %rsi     # 0x334b0
leaq 0x15e27(%rip), %rcx     # 0x334cc
movl $0x987, %edx            # imm = 0x987
callq 0xa0b0
leaq 0xee80(%rip), %rdi      # 0x2c536
leaq 0x15df3(%rip), %rsi     # 0x334b0
leaq 0x15e08(%rip), %rcx     # 0x334cc
movl $0x988, %edx            # imm = 0x988
callq 0xa0b0
leaq 0xee68(%rip), %rdi      # 0x2c53d
leaq 0x15dd4(%rip), %rsi     # 0x334b0
leaq 0x15de9(%rip), %rcx     # 0x334cc
movl $0x989, %edx            # imm = 0x989
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1f748
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1f767
testq %rsi, %rsi
je 0x1f786
xorl %edx, %edx
popq %rbp
jmp 0x1f7a5
leaq 0xf685(%rip), %rdi      # 0x2edd4
leaq 0x13d5a(%rip), %rsi     # 0x334b0
leaq 0x13e1c(%rip), %rcx     # 0x33579
movl $0xa20, %edx            # imm = 0xA20
callq 0xa0b0
leaq 0x152a9(%rip), %rdi     # 0x34a17
leaq 0x13d3b(%rip), %rsi     # 0x334b0
leaq 0x13dfd(%rip), %rcx     # 0x33579
movl $0xa21, %edx            # imm = 0xA21
callq 0xa0b0
leaq 0xd27c(%rip), %rdi      # 0x2ca09
leaq 0x13d1c(%rip), %rsi     # 0x334b0
leaq 0x13dde(%rip), %rcx     # 0x33579
movl $0xa22, %edx            # imm = 0xA22
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1fa11
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1fa30
movq %rdi, %r14
addq $0x68, %r14
movq %rdx, %rdi
callq 0xc743
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0xc29d
leaq 0xf3bc(%rip), %rdi      # 0x2edd4
leaq 0x13a91(%rip), %rsi     # 0x334b0
leaq 0x13b86(%rip), %rcx     # 0x335ac
movl $0xa2c, %edx            # imm = 0xA2C
callq 0xa0b0
leaq 0xd38a(%rip), %rdi      # 0x2cdc1
leaq 0x13a72(%rip), %rsi     # 0x334b0
leaq 0x13b67(%rip), %rcx     # 0x335ac
movl $0xa2d, %edx            # imm = 0xA2D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1fa84
testq %rsi, %rsi
je 0x1faa3
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
callq 0xe262
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x1f9d9
leaq 0xf349(%rip), %rdi      # 0x2edd4
leaq 0x13a1e(%rip), %rsi     # 0x334b0
leaq 0x13b68(%rip), %rcx     # 0x33601
movl $0xa3b, %edx            # imm = 0xA3B
callq 0xa0b0
leaq 0xd317(%rip), %rdi      # 0x2cdc1
leaq 0x139ff(%rip), %rsi     # 0x334b0
leaq 0x13b49(%rip), %rcx     # 0x33601
movl $0xa3c, %edx            # imm = 0xA3C
callq 0xa0b0