LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_reg_iter_next
InsRegister * ins_reg_iter_next(
	InsRegisterIterator *iter
) {
	assert(iter);

	if (iter->next == NULL
			|| iter->next->name == NULL) {
		return NULL;
	}

	return iter->next++;
}

// Assembly:
testq %rdi, %rdi
je 0x15041
movq (%rdi), %rax
testq %rax, %rax
je 0x1503e
cmpq $0x0, (%rax)
je 0x1503e
leaq 0x18(%rax), %rcx
movq %rcx, (%rdi)
retq
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1ad8d(%rip), %rdi     # 0x2fdd9
leaq 0x1b4cd(%rip), %rsi     # 0x30520
leaq 0x1b50d(%rip), %rcx     # 0x30567
movl $0x23a, %edx            # imm = 0x23A
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_reg_get_by_name
InsRegister * ins_reg_get_by_name(
	const char *name
) {
	assert(name);

	InsRegister *ins_reg = NULL;

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

		if (strcmp(reg->name, name) == 0) {
			ins_reg = reg;
		}
	}
	ins_reg_iter_free(&iter);

	return ins_reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1510e
movq %rdi, %rbx
movq 0x2a083(%rip), %rdi     # 0x3f130
testq %rdi, %rdi
je 0x150fd
leaq 0x2a077(%rip), %r15     # 0x3f130
xorl %r14d, %r14d
movq %rbx, %rsi
callq 0xa0f0
testl %eax, %eax
cmoveq %r15, %r14
cmpq $0x0, 0x18(%r15)
je 0x15100
movq 0x18(%r15), %rdi
addq $0x18, %r15
testq %rdi, %rdi
jne 0x150bc
leaq 0x1b515(%rip), %rdi     # 0x305fa
leaq 0x1b434(%rip), %rsi     # 0x30520
leaq 0x1b4d8(%rip), %rcx     # 0x305cb
movl $0x256, %edx            # imm = 0x256
callq 0xa0b0
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b4ea(%rip), %rdi     # 0x305ff
leaq 0x1b404(%rip), %rsi     # 0x30520
leaq 0x1b4a8(%rip), %rcx     # 0x305cb
movl $0x24f, %edx            # imm = 0x24F
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_reg_get_by_id
InsRegister * ins_reg_get_by_id(
	int id
) {
	InsRegister *ins_reg = NULL;

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

		if (reg->id == id) {
			ins_reg = reg;
		}
	}
	ins_reg_iter_free(&iter);

	return ins_reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x29ff7(%rip)     # 0x3f130
je 0x1517c
leaq 0x29fee(%rip), %rcx     # 0x3f130
xorl %eax, %eax
cmpl %edi, 0x8(%rcx)
cmoveq %rcx, %rax
cmpq $0x0, 0x18(%rcx)
je 0x1517e
cmpq $0x0, 0x18(%rcx)
leaq 0x18(%rcx), %rcx
jne 0x15144
leaq 0x1b496(%rip), %rdi     # 0x305fa
leaq 0x1b3b5(%rip), %rsi     # 0x30520
leaq 0x1b492(%rip), %rcx     # 0x30604
movl $0x269, %edx            # imm = 0x269
callq 0xa0b0
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_iter_next
Instruction * ins_iter_next(
	InstructionIterator *iter
) {
	assert(iter);

	// 检测是否到达ins_table的结尾。
	if (iter->next == NULL) {
		return NULL;
	}

	// 一直更换ins_table里的ins_*，直到取出一个mnemonic不为NULL的项。
	// ins_*列表的最后一项的mnemonic为NULL。
	// 有的ins_*可能只有一个mnemonic为NULL的项，所以要用循环跳过去。
	while (iter->next->mnemonic == NULL) {
		iter->ins_table_index += 1;
		iter->next = ins_table[iter->ins_table_index];
		if (iter->next == NULL) {
			return NULL;
		}
	}

	return iter->next++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x15201
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x151f3
leaq 0x29acc(%rip), %rcx     # 0x3eca0
cmpq $0x0, (%rax)
jne 0x151f7
movq (%rdi), %rax
leaq 0x1(%rax), %rdx
movq %rdx, (%rdi)
movq 0x8(%rcx,%rax,8), %rax
movq %rax, 0x8(%rdi)
cmpq $0x7, %rdx
jne 0x151d4
xorl %eax, %eax
jmp 0x151ff
leaq 0x28(%rax), %rcx
movq %rcx, 0x8(%rdi)
popq %rbp
retq
leaq 0x1abd1(%rip), %rdi     # 0x2fdd9
leaq 0x1b311(%rip), %rsi     # 0x30520
leaq 0x1b43c(%rip), %rcx     # 0x30652
movl $0x295, %edx            # imm = 0x295
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_init
void ins_init(
	ParserContext *ctx,
	Instruction *ins,
	ParserASTNode *node,
	EncoderInstruction *enc_ins
) {
	assert(ctx);
	assert(ins);
	assert(node);
	assert(node->type == ASM_NODE_INSTRUCTION);
	assert(enc_ins);

	memset(enc_ins, 0, sizeof(EncoderInstruction));

	enc_ins->legacy_prefix.lock = false;
	enc_ins->legacy_prefix.repne = false;
	enc_ins->legacy_prefix.rep = false;

	enc_ins->legacy_prefix.branch_not_taken = false;
	enc_ins->legacy_prefix.branch_taken = false;

	enc_ins->opcode_len = ins->opcode.len;
	enc_ins->opcode[0] = ins->opcode.o1;
	enc_ins->opcode[1] = ins->opcode.o2;
	enc_ins->opcode[2] = ins->opcode.o3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x152af
testq %rsi, %rsi
je 0x152ce
testq %rdx, %rdx
je 0x152ed
cmpl $0x400, (%rdx)          # imm = 0x400
jne 0x1530c
testq %rcx, %rcx
je 0x1532b
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rcx)
movups %xmm0, 0x40(%rcx)
movups %xmm0, 0x30(%rcx)
movups %xmm0, 0x20(%rcx)
movups %xmm0, 0x10(%rcx)
movups %xmm0, (%rcx)
movb 0xc(%rsi), %al
movb %al, 0x12(%rcx)
movb 0xd(%rsi), %al
movb %al, 0x13(%rcx)
movb 0xe(%rsi), %al
movb %al, 0x14(%rcx)
movb 0xf(%rsi), %al
movb %al, 0x15(%rcx)
popq %rbp
retq
leaq 0x1ab0e(%rip), %rdi     # 0x2fdc4
leaq 0x1b263(%rip), %rsi     # 0x30520
leaq 0x1b3ea(%rip), %rcx     # 0x306ae
movl $0x2b9, %edx            # imm = 0x2B9
callq 0xa0b0
leaq 0x1b455(%rip), %rdi     # 0x3072a
leaq 0x1b244(%rip), %rsi     # 0x30520
leaq 0x1b3cb(%rip), %rcx     # 0x306ae
movl $0x2ba, %edx            # imm = 0x2BA
callq 0xa0b0
leaq 0x1c9b7(%rip), %rdi     # 0x31cab
leaq 0x1b225(%rip), %rsi     # 0x30520
leaq 0x1b3ac(%rip), %rcx     # 0x306ae
movl $0x2bb, %edx            # imm = 0x2BB
callq 0xa0b0
leaq 0x1b3f0(%rip), %rdi     # 0x30703
leaq 0x1b206(%rip), %rsi     # 0x30520
leaq 0x1b38d(%rip), %rcx     # 0x306ae
movl $0x2bc, %edx            # imm = 0x2BC
callq 0xa0b0
leaq 0x1b3f4(%rip), %rdi     # 0x30726
leaq 0x1b1e7(%rip), %rsi     # 0x30520
leaq 0x1b36e(%rip), %rcx     # 0x306ae
movl $0x2bd, %edx            # imm = 0x2BD
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_fill_GX
void ins_fill_GX(
	ParserContext *ctx,
	Instruction *ins,
	ParserASTNode *node,
	EncoderInstruction *enc_ins
) {
	assert(ctx);
	assert(ins);
	assert(node);
	assert(node->type == ASM_NODE_REG);
	assert(enc_ins);

	int arch = ASM_PARSER_CONTEXT_DATA_GET_ARCH(ctx);

	InsRegister *ins_reg = ASM_REG_AST_NODE_GET_REG(node);
	assert(ins_reg);

	enc_ins->mod_rm.reg = ins_reg->index & 0x7;	// 0x7 == 0b0111

	if (ins_reg->index & 0x08) {	// 0x8 == 0b1000
		enc_ins->rex_prefix_used = true;
		enc_ins->rex_prefix.r = true;
	}

	if (arch == ASM_ARCH_BIT16) {
		// Operand size
		if (ins_reg->type == INS_REGISTER_GENERAL_4BYTE) {
			enc_ins->legacy_prefix.operand_size_override = true;
		}
	} else if (arch == ASM_ARCH_BIT32) {
		// Operand size
		if (ins_reg->type == INS_REGISTER_GENERAL_2BYTE) {
			enc_ins->legacy_prefix.operand_size_override = true;
		}
	} else if (arch == ASM_ARCH_BIT64) {
		// Operand size
		if (ins->superscript | INS_SS_d64) {
			if (ins_reg->type == INS_REGISTER_GENERAL_2BYTE) {
				enc_ins->legacy_prefix.operand_size_override = true;
			}
		} else {
			if (ins_reg->type == INS_REGISTER_GENERAL_2BYTE) {
				enc_ins->legacy_prefix.operand_size_override = true;
			} else if (ins_reg->type == INS_REGISTER_GENERAL_8BYTE) {
				enc_ins->rex_prefix_used = true;
				enc_ins->rex_prefix.w = true;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x153ce
testq %rsi, %rsi
je 0x153ed
testq %rdx, %rdx
je 0x1540c
cmpl $0x500, (%rdx)          # imm = 0x500
jne 0x1542b
testq %rcx, %rcx
je 0x1544a
movq 0x60(%rdx), %rax
testq %rax, %rax
je 0x15469
movl 0xb0(%rdi), %edx
movl 0x10(%rax), %esi
movl %esi, %edi
andb $0x7, %dil
movb %dil, 0x18(%rcx)
testb $0x8, %sil
je 0x153ab
movb $0x1, %sil
movb %sil, 0xd(%rcx)
movb %sil, 0xf(%rcx)
cmpl $0x4, %edx
je 0x153c2
cmpl $0x2, %edx
je 0x153c2
cmpl $0x1, %edx
jne 0x153cc
cmpl $0x4, 0xc(%rax)
je 0x153c8
jmp 0x153cc
cmpl $0x3, 0xc(%rax)
jne 0x153cc
movb $0x1, 0xb(%rcx)
popq %rbp
retq
leaq 0x1a9ef(%rip), %rdi     # 0x2fdc4
leaq 0x1b144(%rip), %rsi     # 0x30520
leaq 0x1b34b(%rip), %rcx     # 0x3072e
movl $0x2d4, %edx            # imm = 0x2D4
callq 0xa0b0
leaq 0x1b336(%rip), %rdi     # 0x3072a
leaq 0x1b125(%rip), %rsi     # 0x30520
leaq 0x1b32c(%rip), %rcx     # 0x3072e
movl $0x2d5, %edx            # imm = 0x2D5
callq 0xa0b0
leaq 0x1c898(%rip), %rdi     # 0x31cab
leaq 0x1b106(%rip), %rsi     # 0x30520
leaq 0x1b30d(%rip), %rcx     # 0x3072e
movl $0x2d6, %edx            # imm = 0x2D6
callq 0xa0b0
leaq 0x1b354(%rip), %rdi     # 0x30786
leaq 0x1b0e7(%rip), %rsi     # 0x30520
leaq 0x1b2ee(%rip), %rcx     # 0x3072e
movl $0x2d7, %edx            # imm = 0x2D7
callq 0xa0b0
leaq 0x1b2d5(%rip), %rdi     # 0x30726
leaq 0x1b0c8(%rip), %rsi     # 0x30520
leaq 0x1b2cf(%rip), %rcx     # 0x3072e
movl $0x2d8, %edx            # imm = 0x2D8
callq 0xa0b0
leaq 0x1b331(%rip), %rdi     # 0x307a1
leaq 0x1b0a9(%rip), %rsi     # 0x30520
leaq 0x1b2b0(%rip), %rcx     # 0x3072e
movl $0x2dd, %edx            # imm = 0x2DD
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_fill_RX
void ins_fill_RX(
	ParserContext *ctx,
	Instruction *ins,
	ParserASTNode *node,
	EncoderInstruction *enc_ins
) {
	assert(ctx);
	assert(ins);
	assert(node);
	assert(enc_ins);

	if (node->type != ASM_NODE_REG) {
		assert(0);
	}

	ins_fill_EX(
		ctx,
		ins,
		node,
		enc_ins
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x15af1
testq %rsi, %rsi
je 0x15b10
testq %rdx, %rdx
je 0x15b2f
testq %rcx, %rcx
je 0x15b4e
cmpl $0x500, (%rdx)          # imm = 0x500
jne 0x15b6d
popq %rbp
jmp 0x15488
leaq 0x1a2cc(%rip), %rdi     # 0x2fdc4
leaq 0x1aa21(%rip), %rsi     # 0x30520
leaq 0x1acfb(%rip), %rcx     # 0x30801
movl $0x428, %edx            # imm = 0x428
callq 0xa0b0
leaq 0x1ac13(%rip), %rdi     # 0x3072a
leaq 0x1aa02(%rip), %rsi     # 0x30520
leaq 0x1acdc(%rip), %rcx     # 0x30801
movl $0x429, %edx            # imm = 0x429
callq 0xa0b0
leaq 0x1c175(%rip), %rdi     # 0x31cab
leaq 0x1a9e3(%rip), %rsi     # 0x30520
leaq 0x1acbd(%rip), %rcx     # 0x30801
movl $0x42a, %edx            # imm = 0x42A
callq 0xa0b0
leaq 0x1abd1(%rip), %rdi     # 0x30726
leaq 0x1a9c4(%rip), %rsi     # 0x30520
leaq 0x1ac9e(%rip), %rcx     # 0x30801
movl $0x42b, %edx            # imm = 0x42B
callq 0xa0b0
leaq 0x187fc(%rip), %rdi     # 0x2e370
leaq 0x1a9a5(%rip), %rsi     # 0x30520
leaq 0x1ac7f(%rip), %rcx     # 0x30801
movl $0x42e, %edx            # imm = 0x42E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_fill_MX
void ins_fill_MX(
	ParserContext *ctx,
	Instruction *ins,
	ParserASTNode *node,
	EncoderInstruction *enc_ins
) {
	assert(ctx);
	assert(ins);
	assert(node);
	assert(enc_ins);

	if (node->type != ASM_NODE_MEM) {
		assert(0);
	}

	ins_fill_EX(
		ctx,
		ins,
		node,
		enc_ins
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x15bb6
testq %rsi, %rsi
je 0x15bd5
testq %rdx, %rdx
je 0x15bf4
testq %rcx, %rcx
je 0x15c13
cmpl $0x600, (%rdx)          # imm = 0x600
jne 0x15c32
popq %rbp
jmp 0x15488
leaq 0x1a207(%rip), %rdi     # 0x2fdc4
leaq 0x1a95c(%rip), %rsi     # 0x30520
leaq 0x1ac8e(%rip), %rcx     # 0x30859
movl $0x43f, %edx            # imm = 0x43F
callq 0xa0b0
leaq 0x1ab4e(%rip), %rdi     # 0x3072a
leaq 0x1a93d(%rip), %rsi     # 0x30520
leaq 0x1ac6f(%rip), %rcx     # 0x30859
movl $0x440, %edx            # imm = 0x440
callq 0xa0b0
leaq 0x1c0b0(%rip), %rdi     # 0x31cab
leaq 0x1a91e(%rip), %rsi     # 0x30520
leaq 0x1ac50(%rip), %rcx     # 0x30859
movl $0x441, %edx            # imm = 0x441
callq 0xa0b0
leaq 0x1ab0c(%rip), %rdi     # 0x30726
leaq 0x1a8ff(%rip), %rsi     # 0x30520
leaq 0x1ac31(%rip), %rcx     # 0x30859
movl $0x442, %edx            # imm = 0x442
callq 0xa0b0
leaq 0x18737(%rip), %rdi     # 0x2e370
leaq 0x1a8e0(%rip), %rsi     # 0x30520
leaq 0x1ac12(%rip), %rcx     # 0x30859
movl $0x445, %edx            # imm = 0x445
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_fill_imm8
void ins_fill_imm8(
	ParserContext *ctx,
	Instruction *ins,
	ParserASTNode *node,
	EncoderInstruction *enc_ins
) {
	assert(ctx);
	assert(ins);
	assert(node);
	assert(node->type == ASM_NODE_EXPR);
	assert(enc_ins);

	AsmExprEvalResult *result = &ASM_EXPR_AST_NODE_GET_RESULT(node);
	assert(result->type == ASM_EXPR_EVAL_RESULT_TYPE_UINT64);

	enc_ins->imm_len = 1;
	enc_ins->imm = result->value.u64 & 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x15c8d
testq %rsi, %rsi
je 0x15cac
testq %rdx, %rdx
je 0x15ccb
cmpl $0xe00, (%rdx)          # imm = 0xE00
jne 0x15cea
testq %rcx, %rcx
je 0x15d09
cmpb $0x1, 0x60(%rdx)
jne 0x15d28
movb $0x1, 0x28(%rcx)
movzbl 0x68(%rdx), %eax
movq %rax, 0x30(%rcx)
popq %rbp
retq
leaq 0x1a130(%rip), %rdi     # 0x2fdc4
leaq 0x1a885(%rip), %rsi     # 0x30520
leaq 0x1ac0f(%rip), %rcx     # 0x308b1
movl $0x456, %edx            # imm = 0x456
callq 0xa0b0
leaq 0x1aa77(%rip), %rdi     # 0x3072a
leaq 0x1a866(%rip), %rsi     # 0x30520
leaq 0x1abf0(%rip), %rcx     # 0x308b1
movl $0x457, %edx            # imm = 0x457
callq 0xa0b0
leaq 0x1bfd9(%rip), %rdi     # 0x31cab
leaq 0x1a847(%rip), %rsi     # 0x30520
leaq 0x1abd1(%rip), %rcx     # 0x308b1
movl $0x458, %edx            # imm = 0x458
callq 0xa0b0
leaq 0x1a5f0(%rip), %rdi     # 0x302e1
leaq 0x1a828(%rip), %rsi     # 0x30520
leaq 0x1abb2(%rip), %rcx     # 0x308b1
movl $0x459, %edx            # imm = 0x459
callq 0xa0b0
leaq 0x1aa16(%rip), %rdi     # 0x30726
leaq 0x1a809(%rip), %rsi     # 0x30520
leaq 0x1ab93(%rip), %rcx     # 0x308b1
movl $0x45a, %edx            # imm = 0x45A
callq 0xa0b0
leaq 0x1a526(%rip), %rdi     # 0x30255
leaq 0x1a7ea(%rip), %rsi     # 0x30520
leaq 0x1ab74(%rip), %rcx     # 0x308b1
movl $0x45d, %edx            # imm = 0x45D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_fill_imm16
void ins_fill_imm16(
	ParserContext *ctx,
	Instruction *ins,
	ParserASTNode *node,
	EncoderInstruction *enc_ins
) {
	assert(ctx);
	assert(ins);
	assert(node);
	assert(node->type == ASM_NODE_EXPR);
	assert(enc_ins);

	AsmExprEvalResult *result = &ASM_EXPR_AST_NODE_GET_RESULT(node);
	assert(result->type == ASM_EXPR_EVAL_RESULT_TYPE_UINT64);

	enc_ins->imm_len = 2;
	enc_ins->imm = result->value.u64 & 0xffff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x15d83
testq %rsi, %rsi
je 0x15da2
testq %rdx, %rdx
je 0x15dc1
cmpl $0xe00, (%rdx)          # imm = 0xE00
jne 0x15de0
testq %rcx, %rcx
je 0x15dff
cmpb $0x1, 0x60(%rdx)
jne 0x15e1e
movb $0x2, 0x28(%rcx)
movzwl 0x68(%rdx), %eax
movq %rax, 0x30(%rcx)
popq %rbp
retq
leaq 0x1a03a(%rip), %rdi     # 0x2fdc4
leaq 0x1a78f(%rip), %rsi     # 0x30520
leaq 0x1ab73(%rip), %rcx     # 0x3090b
movl $0x469, %edx            # imm = 0x469
callq 0xa0b0
leaq 0x1a981(%rip), %rdi     # 0x3072a
leaq 0x1a770(%rip), %rsi     # 0x30520
leaq 0x1ab54(%rip), %rcx     # 0x3090b
movl $0x46a, %edx            # imm = 0x46A
callq 0xa0b0
leaq 0x1bee3(%rip), %rdi     # 0x31cab
leaq 0x1a751(%rip), %rsi     # 0x30520
leaq 0x1ab35(%rip), %rcx     # 0x3090b
movl $0x46b, %edx            # imm = 0x46B
callq 0xa0b0
leaq 0x1a4fa(%rip), %rdi     # 0x302e1
leaq 0x1a732(%rip), %rsi     # 0x30520
leaq 0x1ab16(%rip), %rcx     # 0x3090b
movl $0x46c, %edx            # imm = 0x46C
callq 0xa0b0
leaq 0x1a920(%rip), %rdi     # 0x30726
leaq 0x1a713(%rip), %rsi     # 0x30520
leaq 0x1aaf7(%rip), %rcx     # 0x3090b
movl $0x46d, %edx            # imm = 0x46D
callq 0xa0b0
leaq 0x1a430(%rip), %rdi     # 0x30255
leaq 0x1a6f4(%rip), %rsi     # 0x30520
leaq 0x1aad8(%rip), %rcx     # 0x3090b
movl $0x470, %edx            # imm = 0x470
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_fill_imm32
void ins_fill_imm32(
	ParserContext *ctx,
	Instruction *ins,
	ParserASTNode *node,
	EncoderInstruction *enc_ins
) {
	assert(ctx);
	assert(ins);
	assert(node);
	assert(node->type == ASM_NODE_EXPR);
	assert(enc_ins);

	AsmExprEvalResult *result = &ASM_EXPR_AST_NODE_GET_RESULT(node);
	assert(result->type == ASM_EXPR_EVAL_RESULT_TYPE_UINT64);

	enc_ins->imm_len = 4;
	enc_ins->imm = result->value.u64 & 0xffffffff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x15e78
testq %rsi, %rsi
je 0x15e97
testq %rdx, %rdx
je 0x15eb6
cmpl $0xe00, (%rdx)          # imm = 0xE00
jne 0x15ed5
testq %rcx, %rcx
je 0x15ef4
cmpb $0x1, 0x60(%rdx)
jne 0x15f13
movb $0x4, 0x28(%rcx)
movl 0x68(%rdx), %eax
movq %rax, 0x30(%rcx)
popq %rbp
retq
leaq 0x19f45(%rip), %rdi     # 0x2fdc4
leaq 0x1a69a(%rip), %rsi     # 0x30520
leaq 0x1aad9(%rip), %rcx     # 0x30966
movl $0x47c, %edx            # imm = 0x47C
callq 0xa0b0
leaq 0x1a88c(%rip), %rdi     # 0x3072a
leaq 0x1a67b(%rip), %rsi     # 0x30520
leaq 0x1aaba(%rip), %rcx     # 0x30966
movl $0x47d, %edx            # imm = 0x47D
callq 0xa0b0
leaq 0x1bdee(%rip), %rdi     # 0x31cab
leaq 0x1a65c(%rip), %rsi     # 0x30520
leaq 0x1aa9b(%rip), %rcx     # 0x30966
movl $0x47e, %edx            # imm = 0x47E
callq 0xa0b0
leaq 0x1a405(%rip), %rdi     # 0x302e1
leaq 0x1a63d(%rip), %rsi     # 0x30520
leaq 0x1aa7c(%rip), %rcx     # 0x30966
movl $0x47f, %edx            # imm = 0x47F
callq 0xa0b0
leaq 0x1a82b(%rip), %rdi     # 0x30726
leaq 0x1a61e(%rip), %rsi     # 0x30520
leaq 0x1aa5d(%rip), %rcx     # 0x30966
movl $0x480, %edx            # imm = 0x480
callq 0xa0b0
leaq 0x1a33b(%rip), %rdi     # 0x30255
leaq 0x1a5ff(%rip), %rsi     # 0x30520
leaq 0x1aa3e(%rip), %rcx     # 0x30966
movl $0x483, %edx            # imm = 0x483
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_fill_imm64
void ins_fill_imm64(
	ParserContext *ctx,
	Instruction *ins,
	ParserASTNode *node,
	EncoderInstruction *enc_ins
) {
	assert(ctx);
	assert(ins);
	assert(node);
	assert(node->type == ASM_NODE_EXPR);
	assert(enc_ins);

	AsmExprEvalResult *result = &ASM_EXPR_AST_NODE_GET_RESULT(node);
	assert(result->type == ASM_EXPR_EVAL_RESULT_TYPE_UINT64);

	enc_ins->imm_len = 4;
	enc_ins->imm = result->value.u64;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x15f6e
testq %rsi, %rsi
je 0x15f8d
testq %rdx, %rdx
je 0x15fac
cmpl $0xe00, (%rdx)          # imm = 0xE00
jne 0x15fcb
testq %rcx, %rcx
je 0x15fea
cmpb $0x1, 0x60(%rdx)
jne 0x16009
movb $0x4, 0x28(%rcx)
movq 0x68(%rdx), %rax
movq %rax, 0x30(%rcx)
popq %rbp
retq
leaq 0x19e4f(%rip), %rdi     # 0x2fdc4
leaq 0x1a5a4(%rip), %rsi     # 0x30520
leaq 0x1aa3e(%rip), %rcx     # 0x309c1
movl $0x48f, %edx            # imm = 0x48F
callq 0xa0b0
leaq 0x1a796(%rip), %rdi     # 0x3072a
leaq 0x1a585(%rip), %rsi     # 0x30520
leaq 0x1aa1f(%rip), %rcx     # 0x309c1
movl $0x490, %edx            # imm = 0x490
callq 0xa0b0
leaq 0x1bcf8(%rip), %rdi     # 0x31cab
leaq 0x1a566(%rip), %rsi     # 0x30520
leaq 0x1aa00(%rip), %rcx     # 0x309c1
movl $0x491, %edx            # imm = 0x491
callq 0xa0b0
leaq 0x1a30f(%rip), %rdi     # 0x302e1
leaq 0x1a547(%rip), %rsi     # 0x30520
leaq 0x1a9e1(%rip), %rcx     # 0x309c1
movl $0x492, %edx            # imm = 0x492
callq 0xa0b0
leaq 0x1a735(%rip), %rdi     # 0x30726
leaq 0x1a528(%rip), %rsi     # 0x30520
leaq 0x1a9c2(%rip), %rcx     # 0x309c1
movl $0x493, %edx            # imm = 0x493
callq 0xa0b0
leaq 0x1a245(%rip), %rdi     # 0x30255
leaq 0x1a509(%rip), %rsi     # 0x30520
leaq 0x1a9a3(%rip), %rcx     # 0x309c1
movl $0x496, %edx            # imm = 0x496
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_add_uint8_to_ext
void ins_add_uint8_to_ext(
	ParserContext *ctx,
	Instruction *ins,
	EncoderInstruction *enc_ins,
	uint8_t value
) {
	assert(ctx);
	assert(ins);
	assert(enc_ins);

	if (enc_ins->ext_len + 1 > ENCODER_INSTRUCTION_EXT_MAX_LEN) {
		assert(0);
	}

	enc_ins->ext[enc_ins->ext_len++] = value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x16052
testq %rsi, %rsi
je 0x16071
testq %rdx, %rdx
je 0x16090
movzbl 0x38(%rdx), %eax
cmpq $0x20, %rax
jae 0x160af
leal 0x1(%rax), %esi
movb %sil, 0x38(%rdx)
movb %cl, 0x39(%rdx,%rax)
popq %rbp
retq
leaq 0x19d6b(%rip), %rdi     # 0x2fdc4
leaq 0x1a4c0(%rip), %rsi     # 0x30520
leaq 0x1a9b5(%rip), %rcx     # 0x30a1c
movl $0x4a5, %edx            # imm = 0x4A5
callq 0xa0b0
leaq 0x1a6b2(%rip), %rdi     # 0x3072a
leaq 0x1a4a1(%rip), %rsi     # 0x30520
leaq 0x1a996(%rip), %rcx     # 0x30a1c
movl $0x4a6, %edx            # imm = 0x4A6
callq 0xa0b0
leaq 0x1a68f(%rip), %rdi     # 0x30726
leaq 0x1a482(%rip), %rsi     # 0x30520
leaq 0x1a977(%rip), %rcx     # 0x30a1c
movl $0x4a7, %edx            # imm = 0x4A7
callq 0xa0b0
leaq 0x182ba(%rip), %rdi     # 0x2e370
leaq 0x1a463(%rip), %rsi     # 0x30520
leaq 0x1a958(%rip), %rcx     # 0x30a1c
movl $0x4aa, %edx            # imm = 0x4AA
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_add_uint16_to_ext
void ins_add_uint16_to_ext(
	ParserContext *ctx,
	Instruction *ins,
	EncoderInstruction *enc_ins,
	uint16_t value
) {
	for (int i = 0; i < 2; i++) {
		ins_add_uint8_to_ext(
			ctx,
			ins,
			enc_ins,
			(uint8_t) value
		);

		value >>= 8;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movb $0x1, %r13b
movzwl %bx, %ebx
movzbl %bl, %ecx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x16028
shrl $0x8, %ebx
testb $0x1, %r13b
movl $0x0, %r13d
jne 0x160ea
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_add_uint64_to_ext
void ins_add_uint64_to_ext(
	ParserContext *ctx,
	Instruction *ins,
	EncoderInstruction *enc_ins,
	uint64_t value
) {
	for (int i = 0; i < 8; i++) {
		ins_add_uint8_to_ext(
			ctx,
			ins,
			enc_ins,
			(uint8_t) value
		);

		value >>= 8;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x8, %r13d
movzbl %bl, %ecx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x16028
shrq $0x8, %rbx
decl %r13d
jne 0x16183
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_add_uint8_expr_to_ext
void ins_add_uint8_expr_to_ext(
	ParserContext *ctx,
	Instruction *ins,
	EncoderInstruction *enc_ins,
	ParserASTNode *node_expr
) {
	assert(ctx);
	assert(ins);
	assert(enc_ins);
	assert(node_expr);

	AsmExprEvalResult *result = &ASM_EXPR_AST_NODE_GET_RESULT(node_expr);
	assert(result->type == ASM_EXPR_EVAL_RESULT_TYPE_UINT64);

	ins_add_uint8_to_ext(
		ctx,
		ins,
		enc_ins,
		(uint8_t) result->value.u64
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x161f0
testq %rsi, %rsi
je 0x1620f
testq %rdx, %rdx
je 0x1622e
testq %rcx, %rcx
je 0x1624d
cmpb $0x1, 0x60(%rcx)
jne 0x1626c
movzbl 0x38(%rdx), %eax
cmpq $0x20, %rax
jae 0x1628b
movb 0x68(%rcx), %cl
leal 0x1(%rax), %esi
movb %sil, 0x38(%rdx)
movb %cl, 0x39(%rdx,%rax)
popq %rbp
retq
leaq 0x19bcd(%rip), %rdi     # 0x2fdc4
leaq 0x1a322(%rip), %rsi     # 0x30520
leaq 0x1a870(%rip), %rcx     # 0x30a75
movl $0x4ec, %edx            # imm = 0x4EC
callq 0xa0b0
leaq 0x1a514(%rip), %rdi     # 0x3072a
leaq 0x1a303(%rip), %rsi     # 0x30520
leaq 0x1a851(%rip), %rcx     # 0x30a75
movl $0x4ed, %edx            # imm = 0x4ED
callq 0xa0b0
leaq 0x1a4f1(%rip), %rdi     # 0x30726
leaq 0x1a2e4(%rip), %rsi     # 0x30520
leaq 0x1a832(%rip), %rcx     # 0x30a75
movl $0x4ee, %edx            # imm = 0x4EE
callq 0xa0b0
leaq 0x1a887(%rip), %rdi     # 0x30adb
leaq 0x1a2c5(%rip), %rsi     # 0x30520
leaq 0x1a813(%rip), %rcx     # 0x30a75
movl $0x4ef, %edx            # imm = 0x4EF
callq 0xa0b0
leaq 0x19fe2(%rip), %rdi     # 0x30255
leaq 0x1a2a6(%rip), %rsi     # 0x30520
leaq 0x1a7f4(%rip), %rcx     # 0x30a75
movl $0x4f2, %edx            # imm = 0x4F2
callq 0xa0b0
leaq 0x180de(%rip), %rdi     # 0x2e370
leaq 0x1a287(%rip), %rsi     # 0x30520
leaq 0x1a77c(%rip), %rcx     # 0x30a1c
movl $0x4aa, %edx            # imm = 0x4AA
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_add_uint16_expr_to_ext
void ins_add_uint16_expr_to_ext(
	ParserContext *ctx,
	Instruction *ins,
	EncoderInstruction *enc_ins,
	ParserASTNode *node_expr
) {
	assert(ctx);
	assert(ins);
	assert(enc_ins);
	assert(node_expr);

	AsmExprEvalResult *result = &ASM_EXPR_AST_NODE_GET_RESULT(node_expr);
	assert(result->type == ASM_EXPR_EVAL_RESULT_TYPE_UINT64);

	ins_add_uint16_to_ext(
		ctx,
		ins,
		enc_ins,
		(uint16_t) result->value.u64
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16324
movq %rsi, %r14
testq %rsi, %rsi
je 0x16343
movq %rdx, %rbx
testq %rdx, %rdx
je 0x16362
testq %rcx, %rcx
je 0x16381
cmpb $0x1, 0x60(%rcx)
jne 0x163a0
movq %rdi, %r15
movzwl 0x68(%rcx), %r12d
movb $0x1, %r13b
movzwl %r12w, %r12d
movzbl %r12b, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x16028
shrl $0x8, %r12d
testb $0x1, %r13b
movl $0x0, %r13d
jne 0x162ef
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19a99(%rip), %rdi     # 0x2fdc4
leaq 0x1a1ee(%rip), %rsi     # 0x30520
leaq 0x1a7ac(%rip), %rcx     # 0x30ae5
movl $0x502, %edx            # imm = 0x502
callq 0xa0b0
leaq 0x1a3e0(%rip), %rdi     # 0x3072a
leaq 0x1a1cf(%rip), %rsi     # 0x30520
leaq 0x1a78d(%rip), %rcx     # 0x30ae5
movl $0x503, %edx            # imm = 0x503
callq 0xa0b0
leaq 0x1a3bd(%rip), %rdi     # 0x30726
leaq 0x1a1b0(%rip), %rsi     # 0x30520
leaq 0x1a76e(%rip), %rcx     # 0x30ae5
movl $0x504, %edx            # imm = 0x504
callq 0xa0b0
leaq 0x1a753(%rip), %rdi     # 0x30adb
leaq 0x1a191(%rip), %rsi     # 0x30520
leaq 0x1a74f(%rip), %rcx     # 0x30ae5
movl $0x505, %edx            # imm = 0x505
callq 0xa0b0
leaq 0x19eae(%rip), %rdi     # 0x30255
leaq 0x1a172(%rip), %rsi     # 0x30520
leaq 0x1a730(%rip), %rcx     # 0x30ae5
movl $0x508, %edx            # imm = 0x508
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_add_uint32_expr_to_ext
void ins_add_uint32_expr_to_ext(
	ParserContext *ctx,
	Instruction *ins,
	EncoderInstruction *enc_ins,
	ParserASTNode *node_expr
) {
	assert(ctx);
	assert(ins);
	assert(enc_ins);
	assert(node_expr);

	AsmExprEvalResult *result = &ASM_EXPR_AST_NODE_GET_RESULT(node_expr);
	assert(result->type == ASM_EXPR_EVAL_RESULT_TYPE_UINT64);

	ins_add_uint32_to_ext(
		ctx,
		ins,
		enc_ins,
		(uint32_t) result->value.u64
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16430
movq %rsi, %r14
testq %rsi, %rsi
je 0x1644f
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1646e
testq %rcx, %rcx
je 0x1648d
cmpb $0x1, 0x60(%rcx)
jne 0x164ac
movq %rdi, %r15
movl 0x68(%rcx), %r12d
movl $0x4, %r13d
movzbl %r12b, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x16028
shrl $0x8, %r12d
decl %r13d
jne 0x16406
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1998d(%rip), %rdi     # 0x2fdc4
leaq 0x1a0e2(%rip), %rsi     # 0x30520
leaq 0x1a707(%rip), %rcx     # 0x30b4c
movl $0x518, %edx            # imm = 0x518
callq 0xa0b0
leaq 0x1a2d4(%rip), %rdi     # 0x3072a
leaq 0x1a0c3(%rip), %rsi     # 0x30520
leaq 0x1a6e8(%rip), %rcx     # 0x30b4c
movl $0x519, %edx            # imm = 0x519
callq 0xa0b0
leaq 0x1a2b1(%rip), %rdi     # 0x30726
leaq 0x1a0a4(%rip), %rsi     # 0x30520
leaq 0x1a6c9(%rip), %rcx     # 0x30b4c
movl $0x51a, %edx            # imm = 0x51A
callq 0xa0b0
leaq 0x1a647(%rip), %rdi     # 0x30adb
leaq 0x1a085(%rip), %rsi     # 0x30520
leaq 0x1a6aa(%rip), %rcx     # 0x30b4c
movl $0x51b, %edx            # imm = 0x51B
callq 0xa0b0
leaq 0x19da2(%rip), %rdi     # 0x30255
leaq 0x1a066(%rip), %rsi     # 0x30520
leaq 0x1a68b(%rip), %rcx     # 0x30b4c
movl $0x51e, %edx            # imm = 0x51E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_add_uint64_expr_to_ext
void ins_add_uint64_expr_to_ext(
	ParserContext *ctx,
	Instruction *ins,
	EncoderInstruction *enc_ins,
	ParserASTNode *node_expr
) {
	assert(ctx);
	assert(ins);
	assert(enc_ins);
	assert(node_expr);

	AsmExprEvalResult *result = &ASM_EXPR_AST_NODE_GET_RESULT(node_expr);
	assert(result->type == ASM_EXPR_EVAL_RESULT_TYPE_UINT64);

	ins_add_uint64_to_ext(
		ctx,
		ins,
		enc_ins,
		result->value.u64
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1653c
movq %rsi, %r14
testq %rsi, %rsi
je 0x1655b
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1657a
testq %rcx, %rcx
je 0x16599
cmpb $0x1, 0x60(%rcx)
jne 0x165b8
movq %rdi, %r15
movq 0x68(%rcx), %r12
movl $0x8, %r13d
movzbl %r12b, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x16028
shrq $0x8, %r12
decl %r13d
jne 0x16512
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19881(%rip), %rdi     # 0x2fdc4
leaq 0x19fd6(%rip), %rsi     # 0x30520
leaq 0x1a662(%rip), %rcx     # 0x30bb3
movl $0x52e, %edx            # imm = 0x52E
callq 0xa0b0
leaq 0x1a1c8(%rip), %rdi     # 0x3072a
leaq 0x19fb7(%rip), %rsi     # 0x30520
leaq 0x1a643(%rip), %rcx     # 0x30bb3
movl $0x52f, %edx            # imm = 0x52F
callq 0xa0b0
leaq 0x1a1a5(%rip), %rdi     # 0x30726
leaq 0x19f98(%rip), %rsi     # 0x30520
leaq 0x1a624(%rip), %rcx     # 0x30bb3
movl $0x530, %edx            # imm = 0x530
callq 0xa0b0
leaq 0x1a53b(%rip), %rdi     # 0x30adb
leaq 0x19f79(%rip), %rsi     # 0x30520
leaq 0x1a605(%rip), %rcx     # 0x30bb3
movl $0x531, %edx            # imm = 0x531
callq 0xa0b0
leaq 0x19c96(%rip), %rdi     # 0x30255
leaq 0x19f5a(%rip), %rsi     # 0x30520
leaq 0x1a5e6(%rip), %rcx     # 0x30bb3
movl $0x534, %edx            # imm = 0x534
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: get_size
size_t _get_size(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	if (node->type == ASM_NODE_REG) {
		InsRegister *ins_reg = ASM_REG_AST_NODE_GET_REG(node);
		assert(ins_reg);

		switch (ins_reg->type) {
			case INS_REGISTER_GENERAL_1BYTE: {
				return 1;
			}
			case INS_REGISTER_GENERAL_2BYTE: {
				return 2;
			}
			case INS_REGISTER_GENERAL_4BYTE: {
				return 4;
			}
			case INS_REGISTER_GENERAL_8BYTE: {
				return 8;
			}
			default: {
				assert(0);
				return 0;
			}
		}
	} else if (node->type == ASM_NODE_MEM) {
		int type = ASM_MEM_AST_NODE_GET_TYPE(node);

		switch (type) {
			case ASM_MEM_TYPE_BYTE: {
				return 1;
			}
			case ASM_MEM_TYPE_WORD: {
				return 2;
			}
			case ASM_MEM_TYPE_DWORD: {
				return 4;
			}
			case ASM_MEM_TYPE_QWORD: {
				return 8;
			}
			default: {
				assert(0);
				return 0;
			}
		}
	} else {
		assert(0);
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x16654
testq %rsi, %rsi
je 0x16673
movl (%rsi), %eax
cmpl $0x600, %eax            # imm = 0x600
je 0x16634
cmpl $0x500, %eax            # imm = 0x500
jne 0x16692
movq 0x60(%rsi), %rax
testq %rax, %rax
je 0x166b1
movl 0xc(%rax), %eax
addl $-0x2, %eax
cmpl $0x4, %eax
jb 0x16642
leaq 0x17d54(%rip), %rdi     # 0x2e370
leaq 0x19efd(%rip), %rsi     # 0x30520
leaq 0x1a5f0(%rip), %rcx     # 0x30c1a
movl $0x559, %edx            # imm = 0x559
callq 0xa0b0
movl 0x64(%rsi), %eax
decl %eax
cmpl $0x4, %eax
jae 0x166d0
movl %eax, %eax
leaq 0x1a845(%rip), %rcx     # 0x30e90
leaq (%rcx,%rax,8), %rax
movq (%rax), %rax
popq %rbp
retq
leaq 0x19769(%rip), %rdi     # 0x2fdc4
leaq 0x19ebe(%rip), %rsi     # 0x30520
leaq 0x1a5b1(%rip), %rcx     # 0x30c1a
movl $0x544, %edx            # imm = 0x544
callq 0xa0b0
leaq 0x1b631(%rip), %rdi     # 0x31cab
leaq 0x19e9f(%rip), %rsi     # 0x30520
leaq 0x1a592(%rip), %rcx     # 0x30c1a
movl $0x545, %edx            # imm = 0x545
callq 0xa0b0
leaq 0x17cd7(%rip), %rdi     # 0x2e370
leaq 0x19e80(%rip), %rsi     # 0x30520
leaq 0x1a573(%rip), %rcx     # 0x30c1a
movl $0x573, %edx            # imm = 0x573
callq 0xa0b0
leaq 0x1a0e9(%rip), %rdi     # 0x307a1
leaq 0x19e61(%rip), %rsi     # 0x30520
leaq 0x1a554(%rip), %rcx     # 0x30c1a
movl $0x549, %edx            # imm = 0x549
callq 0xa0b0
leaq 0x17c99(%rip), %rdi     # 0x2e370
leaq 0x19e42(%rip), %rsi     # 0x30520
leaq 0x1a535(%rip), %rcx     # 0x30c1a
movl $0x56e, %edx            # imm = 0x56E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_check_operand_type
void ins_check_operand_type(
	ParserContext *ctx,
	Instruction *ins,
	ParserASTNode *a,
	ParserASTNode *b,
	ParserASTNode *c
) {
	assert(ctx);
	assert(ins);
	assert(a);
	assert(b);

	size_t sz_a = _get_size(ctx, a);
	size_t sz_b = _get_size(ctx, b);
	if (sz_a != sz_b) {
		ctx->syntax_error_node_msg(ctx, a, "operand type not matched.");
	}

	if (c != NULL) {
		size_t sz_c = _get_size(ctx, c);
		if (sz_b != sz_c) {
			ctx->syntax_error_node_msg(ctx, c, "operand type not matched.");
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x167f3
testq %rsi, %rsi
je 0x16812
movq %rdx, %r15
testq %rdx, %rdx
je 0x16831
movq %rcx, %r12
testq %rcx, %rcx
je 0x16850
movq %r8, %rbx
movq %rdi, %r14
movq %r15, %rsi
callq 0x165d7
movq %rax, %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0x165d7
movq %rax, %r12
cmpq %rax, %r13
je 0x167ae
leaq 0x1a553(%rip), %rdx     # 0x30cf7
movq %r14, %rdi
movq %r15, %rsi
callq *0x58(%r14)
testq %rbx, %rbx
je 0x167c3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x165d7
cmpq %rax, %r12
jne 0x167d2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x58(%r14), %rax
leaq 0x1a51a(%rip), %rdx     # 0x30cf7
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
leaq 0x195ca(%rip), %rdi     # 0x2fdc4
leaq 0x19d1f(%rip), %rsi     # 0x30520
leaq 0x1a480(%rip), %rcx     # 0x30c88
movl $0x589, %edx            # imm = 0x589
callq 0xa0b0
leaq 0x19f11(%rip), %rdi     # 0x3072a
leaq 0x19d00(%rip), %rsi     # 0x30520
leaq 0x1a461(%rip), %rcx     # 0x30c88
movl $0x58a, %edx            # imm = 0x58A
callq 0xa0b0
leaq 0x1fd26(%rip), %rdi     # 0x3655e
leaq 0x19ce1(%rip), %rsi     # 0x30520
leaq 0x1a442(%rip), %rcx     # 0x30c88
movl $0x58b, %edx            # imm = 0x58B
callq 0xa0b0
leaq 0x188af(%rip), %rdi     # 0x2f106
leaq 0x19cc2(%rip), %rsi     # 0x30520
leaq 0x1a423(%rip), %rcx     # 0x30c88
movl $0x58c, %edx            # imm = 0x58C
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_print_all_ins_list
void ins_print_all_ins_list(
	FILE *file
) {
	assert(file);

	InstructionIterator iter;
	ins_iter_init(&iter);
	for (Instruction *ins = ins_iter_next(&iter); ins != NULL; ins = ins_iter_next(&iter)) {
		_print_ins(ins, file);
	}
	ins_iter_free(&iter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16921
movq %rdi, %rbx
leaq 0x2f140(%rip), %r12     # 0x45a00
xorl %r15d, %r15d
leaq 0x283d6(%rip), %r13     # 0x3eca0
cmpq $0x0, (%r12)
jne 0x168e1
movq 0x8(%r13,%r15,8), %r12
incq %r15
cmpq $0x7, %r15
jne 0x168ca
jmp 0x16912
leaq 0x16bd9(%rip), %r14     # 0x2d4c1
movq (%r12), %rdx
addq $0x28, %r12
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xa100
cmpq $0x0, (%r12)
jne 0x168e8
movq 0x8(%r13,%r15,8), %r12
incq %r15
cmpq $0x7, %r15
jne 0x168fd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x170e1(%rip), %rdi     # 0x2da09
leaq 0x19bf1(%rip), %rsi     # 0x30520
leaq 0x1a43d(%rip), %rcx     # 0x30d73
movl $0x5b2, %edx            # imm = 0x5B2
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins_directive_enc.c
// Function: ins_enc_int8
void ins_enc_int8(
	Instruction *ins,
	InstructionEncoderData *data
) {
	assert(ins);
	assert(data);
	assert(data->ins_node->nchilds == 1);

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

	ParserASTNode *child = data->ins_node->childs[0];
	
	AsmExprEvalResult *result = &ASM_EXPR_AST_NODE_GET_RESULT(child);
	assert(result->type == ASM_EXPR_EVAL_RESULT_TYPE_UINT64);

	fwrite(&result->value.u64, 1, 1, ASM_PARSER_CONTEXT_DATA_GET_OUT(data->ctx));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x16a9f
testq %rsi, %rsi
je 0x16abe
movq (%rsi), %rcx
cmpl $0x1, 0x44(%rcx)
jne 0x16add
movq 0x8(%rsi), %rax
incq 0xc0(%rax)
cmpl $0x1, 0xc8(%rax)
jne 0x16a81
popq %rbp
retq
movq 0x48(%rcx), %rcx
movq (%rcx), %rcx
cmpb $0x1, 0x60(%rcx)
jne 0x16afc
movq 0xb8(%rax), %rsi
movsbl 0x68(%rcx), %edi
popq %rbp
jmp 0xa0d0
leaq 0x19c84(%rip), %rdi     # 0x3072a
leaq 0x1aacd(%rip), %rsi     # 0x3157a
leaq 0x1aba1(%rip), %rcx     # 0x31655
movl $0x32, %edx
callq 0xa0b0
leaq 0x1fa96(%rip), %rdi     # 0x3655b
leaq 0x1aaae(%rip), %rsi     # 0x3157a
leaq 0x1ab82(%rip), %rcx     # 0x31655
movl $0x33, %edx
callq 0xa0b0
leaq 0x1abac(%rip), %rdi     # 0x31690
leaq 0x1aa8f(%rip), %rsi     # 0x3157a
leaq 0x1ab63(%rip), %rcx     # 0x31655
movl $0x34, %edx
callq 0xa0b0
leaq 0x19752(%rip), %rdi     # 0x30255
leaq 0x1aa70(%rip), %rsi     # 0x3157a
leaq 0x1ab44(%rip), %rcx     # 0x31655
movl $0x3e, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins_directive_enc.c
// Function: ins_enc_int16
void ins_enc_int16(
	Instruction *ins,
	InstructionEncoderData *data
) {
	assert(ins);
	assert(data);
	assert(data->ins_node->nchilds == 1);

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

	ParserASTNode *child = data->ins_node->childs[0];
	
	AsmExprEvalResult *result = &ASM_EXPR_AST_NODE_GET_RESULT(child);
	assert(result->type == ASM_EXPR_EVAL_RESULT_TYPE_UINT64);

	fwrite(&result->value.u64, 2, 1, ASM_PARSER_CONTEXT_DATA_GET_OUT(data->ctx));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x16b71
testq %rsi, %rsi
je 0x16b90
movq (%rsi), %rcx
cmpl $0x1, 0x44(%rcx)
jne 0x16baf
movq 0x8(%rsi), %rax
addq $0x2, 0xc0(%rax)
cmpl $0x1, 0xc8(%rax)
jne 0x16b49
popq %rbp
retq
movq 0x48(%rcx), %rcx
movq (%rcx), %rdi
cmpb $0x1, 0x60(%rdi)
jne 0x16bce
addq $0x68, %rdi
movq 0xb8(%rax), %rcx
movl $0x2, %esi
movl $0x1, %edx
popq %rbp
jmp 0xa180
leaq 0x19bb2(%rip), %rdi     # 0x3072a
leaq 0x1a9fb(%rip), %rsi     # 0x3157a
leaq 0x1ab27(%rip), %rcx     # 0x316ad
movl $0x47, %edx
callq 0xa0b0
leaq 0x1f9c4(%rip), %rdi     # 0x3655b
leaq 0x1a9dc(%rip), %rsi     # 0x3157a
leaq 0x1ab08(%rip), %rcx     # 0x316ad
movl $0x48, %edx
callq 0xa0b0
leaq 0x1aada(%rip), %rdi     # 0x31690
leaq 0x1a9bd(%rip), %rsi     # 0x3157a
leaq 0x1aae9(%rip), %rcx     # 0x316ad
movl $0x49, %edx
callq 0xa0b0
leaq 0x19680(%rip), %rdi     # 0x30255
leaq 0x1a99e(%rip), %rsi     # 0x3157a
leaq 0x1aaca(%rip), %rcx     # 0x316ad
movl $0x53, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins_directive_enc.c
// Function: ins_enc_int32
void ins_enc_int32(
	Instruction *ins,
	InstructionEncoderData *data
) {
	assert(ins);
	assert(data);
	assert(data->ins_node->nchilds == 1);

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

	ParserASTNode *child = data->ins_node->childs[0];
	
	AsmExprEvalResult *result = &ASM_EXPR_AST_NODE_GET_RESULT(child);
	assert(result->type == ASM_EXPR_EVAL_RESULT_TYPE_UINT64);

	fwrite(&result->value.u64, 4, 1, ASM_PARSER_CONTEXT_DATA_GET_OUT(data->ctx));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x16c43
testq %rsi, %rsi
je 0x16c62
movq (%rsi), %rcx
cmpl $0x1, 0x44(%rcx)
jne 0x16c81
movq 0x8(%rsi), %rax
addq $0x4, 0xc0(%rax)
cmpl $0x1, 0xc8(%rax)
jne 0x16c1b
popq %rbp
retq
movq 0x48(%rcx), %rcx
movq (%rcx), %rdi
cmpb $0x1, 0x60(%rdi)
jne 0x16ca0
addq $0x68, %rdi
movq 0xb8(%rax), %rcx
movl $0x4, %esi
movl $0x1, %edx
popq %rbp
jmp 0xa180
leaq 0x19ae0(%rip), %rdi     # 0x3072a
leaq 0x1a929(%rip), %rsi     # 0x3157a
leaq 0x1aa91(%rip), %rcx     # 0x316e9
movl $0x5c, %edx
callq 0xa0b0
leaq 0x1f8f2(%rip), %rdi     # 0x3655b
leaq 0x1a90a(%rip), %rsi     # 0x3157a
leaq 0x1aa72(%rip), %rcx     # 0x316e9
movl $0x5d, %edx
callq 0xa0b0
leaq 0x1aa08(%rip), %rdi     # 0x31690
leaq 0x1a8eb(%rip), %rsi     # 0x3157a
leaq 0x1aa53(%rip), %rcx     # 0x316e9
movl $0x5e, %edx
callq 0xa0b0
leaq 0x195ae(%rip), %rdi     # 0x30255
leaq 0x1a8cc(%rip), %rsi     # 0x3157a
leaq 0x1aa34(%rip), %rcx     # 0x316e9
movl $0x68, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins_directive_enc.c
// Function: ins_enc_int64
void ins_enc_int64(
	Instruction *ins,
	InstructionEncoderData *data
) {
	assert(ins);
	assert(data);
	assert(data->ins_node->nchilds == 1);

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

	ParserASTNode *child = data->ins_node->childs[0];
	
	AsmExprEvalResult *result = &ASM_EXPR_AST_NODE_GET_RESULT(child);
	assert(result->type == ASM_EXPR_EVAL_RESULT_TYPE_UINT64);

	fwrite(&result->value.u64, 8, 1, ASM_PARSER_CONTEXT_DATA_GET_OUT(data->ctx));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x16d15
testq %rsi, %rsi
je 0x16d34
movq (%rsi), %rcx
cmpl $0x1, 0x44(%rcx)
jne 0x16d53
movq 0x8(%rsi), %rax
addq $0x8, 0xc0(%rax)
cmpl $0x1, 0xc8(%rax)
jne 0x16ced
popq %rbp
retq
movq 0x48(%rcx), %rcx
movq (%rcx), %rdi
cmpb $0x1, 0x60(%rdi)
jne 0x16d72
addq $0x68, %rdi
movq 0xb8(%rax), %rcx
movl $0x8, %esi
movl $0x1, %edx
popq %rbp
jmp 0xa180
leaq 0x19a0e(%rip), %rdi     # 0x3072a
leaq 0x1a857(%rip), %rsi     # 0x3157a
leaq 0x1a9fb(%rip), %rcx     # 0x31725
movl $0x71, %edx
callq 0xa0b0
leaq 0x1f820(%rip), %rdi     # 0x3655b
leaq 0x1a838(%rip), %rsi     # 0x3157a
leaq 0x1a9dc(%rip), %rcx     # 0x31725
movl $0x72, %edx
callq 0xa0b0
leaq 0x1a936(%rip), %rdi     # 0x31690
leaq 0x1a819(%rip), %rsi     # 0x3157a
leaq 0x1a9bd(%rip), %rcx     # 0x31725
movl $0x73, %edx
callq 0xa0b0
leaq 0x194dc(%rip), %rdi     # 0x30255
leaq 0x1a7fa(%rip), %rsi     # 0x3157a
leaq 0x1a99e(%rip), %rcx     # 0x31725
movl $0x7d, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins_directive_enc.c
// Function: ins_enc_float
void ins_enc_float(
	Instruction *ins,
	InstructionEncoderData *data
) {
	assert(ins);
	assert(data);
	assert(data->ins_node->nchilds == 1);

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

	ParserASTNode *child = data->ins_node->childs[0];
	
	AsmExprEvalResult *result = &ASM_EXPR_AST_NODE_GET_RESULT(child);
	assert(result->type == ASM_EXPR_EVAL_RESULT_TYPE_DOUBLE);

	float f = (float) result->value.d;

	fwrite(&f, 4, 1, ASM_PARSER_CONTEXT_DATA_GET_OUT(data->ctx));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testq %rdi, %rdi
je 0x16dff
testq %rsi, %rsi
je 0x16e1e
movq (%rsi), %rcx
cmpl $0x1, 0x44(%rcx)
jne 0x16e3d
movq 0x8(%rsi), %rax
addq $0x4, 0xc0(%rax)
cmpl $0x1, 0xc8(%rax)
je 0x16df9
movq 0x48(%rcx), %rcx
movq (%rcx), %rcx
cmpb $0x2, 0x60(%rcx)
jne 0x16e5c
cvtsd2ss 0x68(%rcx), %xmm0
leaq -0x4(%rbp), %rdi
movss %xmm0, (%rdi)
movq 0xb8(%rax), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0xa180
addq $0x10, %rsp
popq %rbp
retq
leaq 0x19924(%rip), %rdi     # 0x3072a
leaq 0x1a76d(%rip), %rsi     # 0x3157a
leaq 0x1a94d(%rip), %rcx     # 0x31761
movl $0x86, %edx
callq 0xa0b0
leaq 0x1f736(%rip), %rdi     # 0x3655b
leaq 0x1a74e(%rip), %rsi     # 0x3157a
leaq 0x1a92e(%rip), %rcx     # 0x31761
movl $0x87, %edx
callq 0xa0b0
leaq 0x1a84c(%rip), %rdi     # 0x31690
leaq 0x1a72f(%rip), %rsi     # 0x3157a
leaq 0x1a90f(%rip), %rcx     # 0x31761
movl $0x88, %edx
callq 0xa0b0
leaq 0x1a93a(%rip), %rdi     # 0x3179d
leaq 0x1a710(%rip), %rsi     # 0x3157a
leaq 0x1a8f0(%rip), %rcx     # 0x31761
movl $0x92, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins_directive_enc.c
// Function: ins_enc_double
void ins_enc_double(
	Instruction *ins,
	InstructionEncoderData *data
) {
	assert(ins);
	assert(data);
	assert(data->ins_node->nchilds == 1);

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

	ParserASTNode *child = data->ins_node->childs[0];
	
	AsmExprEvalResult *result = &ASM_EXPR_AST_NODE_GET_RESULT(child);
	assert(result->type == ASM_EXPR_EVAL_RESULT_TYPE_DOUBLE);

	fwrite(&result->value.d, 8, 1, ASM_PARSER_CONTEXT_DATA_GET_OUT(data->ctx));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x16ed1
testq %rsi, %rsi
je 0x16ef0
movq (%rsi), %rcx
cmpl $0x1, 0x44(%rcx)
jne 0x16f0f
movq 0x8(%rsi), %rax
addq $0x8, 0xc0(%rax)
cmpl $0x1, 0xc8(%rax)
jne 0x16ea9
popq %rbp
retq
movq 0x48(%rcx), %rcx
movq (%rcx), %rdi
cmpb $0x2, 0x60(%rdi)
jne 0x16f2e
addq $0x68, %rdi
movq 0xb8(%rax), %rcx
movl $0x8, %esi
movl $0x1, %edx
popq %rbp
jmp 0xa180
leaq 0x19852(%rip), %rdi     # 0x3072a
leaq 0x1a69b(%rip), %rsi     # 0x3157a
leaq 0x1a8e8(%rip), %rcx     # 0x317ce
movl $0x9d, %edx
callq 0xa0b0
leaq 0x1f664(%rip), %rdi     # 0x3655b
leaq 0x1a67c(%rip), %rsi     # 0x3157a
leaq 0x1a8c9(%rip), %rcx     # 0x317ce
movl $0x9e, %edx
callq 0xa0b0
leaq 0x1a77a(%rip), %rdi     # 0x31690
leaq 0x1a65d(%rip), %rsi     # 0x3157a
leaq 0x1a8aa(%rip), %rcx     # 0x317ce
movl $0x9f, %edx
callq 0xa0b0
leaq 0x1a868(%rip), %rdi     # 0x3179d
leaq 0x1a63e(%rip), %rsi     # 0x3157a
leaq 0x1a88b(%rip), %rcx     # 0x317ce
movl $0xa9, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/assembler/ins_directive_enc.c
// Function: ins_enc_string
void ins_enc_string(
	Instruction *ins,
	InstructionEncoderData *data
) {
	assert(ins);
	assert(data);
	assert(data->ins_node->nchilds == 1);

	ParserASTNode *child = data->ins_node->childs[0];
	
	AsmExprEvalResult *result = &ASM_EXPR_AST_NODE_GET_RESULT(child);
	assert(result->type == ASM_EXPR_EVAL_RESULT_TYPE_STRING);

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

	fwrite(result->value.str.ptr, result->value.str.len, 1, ASM_PARSER_CONTEXT_DATA_GET_OUT(data->ctx));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x16fad
testq %rsi, %rsi
je 0x16fcc
movq (%rsi), %rax
cmpl $0x1, 0x44(%rax)
jne 0x16feb
movq 0x48(%rax), %rax
movq (%rax), %rax
cmpb $0x3, 0x60(%rax)
jne 0x1700a
movq 0x70(%rax), %rdx
movq 0x8(%rsi), %rcx
addq %rdx, 0xc0(%rcx)
cmpl $0x1, 0xc8(%rcx)
jne 0x16f93
popq %rbp
retq
movq 0x68(%rax), %rdi
movq 0x70(%rax), %rsi
movq 0xb8(%rcx), %rcx
movl $0x1, %edx
popq %rbp
jmp 0xa180
leaq 0x19776(%rip), %rdi     # 0x3072a
leaq 0x1a5bf(%rip), %rsi     # 0x3157a
leaq 0x1a849(%rip), %rcx     # 0x3180b
movl $0xb2, %edx
callq 0xa0b0
leaq 0x1f588(%rip), %rdi     # 0x3655b
leaq 0x1a5a0(%rip), %rsi     # 0x3157a
leaq 0x1a82a(%rip), %rcx     # 0x3180b
movl $0xb3, %edx
callq 0xa0b0
leaq 0x1a69e(%rip), %rdi     # 0x31690
leaq 0x1a581(%rip), %rsi     # 0x3157a
leaq 0x1a80b(%rip), %rcx     # 0x3180b
movl $0xb4, %edx
callq 0xa0b0
leaq 0x1a837(%rip), %rdi     # 0x31848
leaq 0x1a562(%rip), %rsi     # 0x3157a
leaq 0x1a7ec(%rip), %rcx     # 0x3180b
movl $0xb9, %edx
callq 0xa0b0