LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x1638a
shrq $0x8, %rbx
decl %r13d
jne 0x164e1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1654e
testq %rsi, %rsi
je 0x1656d
testq %rdx, %rdx
je 0x1658c
testq %rcx, %rcx
je 0x165ab
cmpb $0x1, 0x60(%rcx)
jne 0x165ca
movzbl 0x38(%rdx), %eax
cmpq $0x20, %rax
jae 0x165e9
movb 0x68(%rcx), %cl
leal 0x1(%rax), %esi
movb %sil, 0x38(%rdx)
movb %cl, 0x39(%rdx,%rax)
popq %rbp
retq
leaq 0x20201(%rip), %rdi     # 0x36756
leaq 0x1b014(%rip), %rsi     # 0x31570
leaq 0x1b562(%rip), %rcx     # 0x31ac5
movl $0x4ec, %edx            # imm = 0x4EC
callq 0xa0b0
leaq 0x1b206(%rip), %rdi     # 0x3177a
leaq 0x1aff5(%rip), %rsi     # 0x31570
leaq 0x1b543(%rip), %rcx     # 0x31ac5
movl $0x4ed, %edx            # imm = 0x4ED
callq 0xa0b0
leaq 0x1b1e3(%rip), %rdi     # 0x31776
leaq 0x1afd6(%rip), %rsi     # 0x31570
leaq 0x1b524(%rip), %rcx     # 0x31ac5
movl $0x4ee, %edx            # imm = 0x4EE
callq 0xa0b0
leaq 0x1b579(%rip), %rdi     # 0x31b2b
leaq 0x1afb7(%rip), %rsi     # 0x31570
leaq 0x1b505(%rip), %rcx     # 0x31ac5
movl $0x4ef, %edx            # imm = 0x4EF
callq 0xa0b0
leaq 0x1acd4(%rip), %rdi     # 0x312a5
leaq 0x1af98(%rip), %rsi     # 0x31570
leaq 0x1b4e6(%rip), %rcx     # 0x31ac5
movl $0x4f2, %edx            # imm = 0x4F2
callq 0xa0b0
leaq 0x18da4(%rip), %rdi     # 0x2f394
leaq 0x1af79(%rip), %rsi     # 0x31570
leaq 0x1b46e(%rip), %rcx     # 0x31a6c
movl $0x4aa, %edx            # imm = 0x4AA
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x1667e
movq %rsi, %r14
testq %rsi, %rsi
je 0x1669d
movq %rdx, %rbx
testq %rdx, %rdx
je 0x166bc
testq %rcx, %rcx
je 0x166db
cmpb $0x1, 0x60(%rcx)
jne 0x166fa
movq %rdi, %r15
movzwl 0x68(%rcx), %r12d
movl $0x1, %r13d
movzwl %r12w, %r12d
movzbl %r12b, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1638a
shrl $0x8, %r12d
decl %r13d
je 0x16650
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x200d1(%rip), %rdi     # 0x36756
leaq 0x1aee4(%rip), %rsi     # 0x31570
leaq 0x1b4a2(%rip), %rcx     # 0x31b35
movl $0x502, %edx            # imm = 0x502
callq 0xa0b0
leaq 0x1b0d6(%rip), %rdi     # 0x3177a
leaq 0x1aec5(%rip), %rsi     # 0x31570
leaq 0x1b483(%rip), %rcx     # 0x31b35
movl $0x503, %edx            # imm = 0x503
callq 0xa0b0
leaq 0x1b0b3(%rip), %rdi     # 0x31776
leaq 0x1aea6(%rip), %rsi     # 0x31570
leaq 0x1b464(%rip), %rcx     # 0x31b35
movl $0x504, %edx            # imm = 0x504
callq 0xa0b0
leaq 0x1b449(%rip), %rdi     # 0x31b2b
leaq 0x1ae87(%rip), %rsi     # 0x31570
leaq 0x1b445(%rip), %rcx     # 0x31b35
movl $0x505, %edx            # imm = 0x505
callq 0xa0b0
leaq 0x1aba4(%rip), %rdi     # 0x312a5
leaq 0x1ae68(%rip), %rsi     # 0x31570
leaq 0x1b426(%rip), %rcx     # 0x31b35
movl $0x508, %edx            # imm = 0x508
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x1678a
movq %rsi, %r14
testq %rsi, %rsi
je 0x167a9
movq %rdx, %rbx
testq %rdx, %rdx
je 0x167c8
testq %rcx, %rcx
je 0x167e7
cmpb $0x1, 0x60(%rcx)
jne 0x16806
movq %rdi, %r15
movl 0x68(%rcx), %r12d
movl $0x4, %r13d
movzbl %r12b, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1638a
shrl $0x8, %r12d
decl %r13d
jne 0x16760
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ffc5(%rip), %rdi     # 0x36756
leaq 0x1add8(%rip), %rsi     # 0x31570
leaq 0x1b3fd(%rip), %rcx     # 0x31b9c
movl $0x518, %edx            # imm = 0x518
callq 0xa0b0
leaq 0x1afca(%rip), %rdi     # 0x3177a
leaq 0x1adb9(%rip), %rsi     # 0x31570
leaq 0x1b3de(%rip), %rcx     # 0x31b9c
movl $0x519, %edx            # imm = 0x519
callq 0xa0b0
leaq 0x1afa7(%rip), %rdi     # 0x31776
leaq 0x1ad9a(%rip), %rsi     # 0x31570
leaq 0x1b3bf(%rip), %rcx     # 0x31b9c
movl $0x51a, %edx            # imm = 0x51A
callq 0xa0b0
leaq 0x1b33d(%rip), %rdi     # 0x31b2b
leaq 0x1ad7b(%rip), %rsi     # 0x31570
leaq 0x1b3a0(%rip), %rcx     # 0x31b9c
movl $0x51b, %edx            # imm = 0x51B
callq 0xa0b0
leaq 0x1aa98(%rip), %rdi     # 0x312a5
leaq 0x1ad5c(%rip), %rsi     # 0x31570
leaq 0x1b381(%rip), %rcx     # 0x31b9c
movl $0x51e, %edx            # imm = 0x51E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x16896
movq %rsi, %r14
testq %rsi, %rsi
je 0x168b5
movq %rdx, %rbx
testq %rdx, %rdx
je 0x168d4
testq %rcx, %rcx
je 0x168f3
cmpb $0x1, 0x60(%rcx)
jne 0x16912
movq %rdi, %r15
movq 0x68(%rcx), %r12
movl $0x8, %r13d
movzbl %r12b, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1638a
shrq $0x8, %r12
decl %r13d
jne 0x1686c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1feb9(%rip), %rdi     # 0x36756
leaq 0x1accc(%rip), %rsi     # 0x31570
leaq 0x1b358(%rip), %rcx     # 0x31c03
movl $0x52e, %edx            # imm = 0x52E
callq 0xa0b0
leaq 0x1aebe(%rip), %rdi     # 0x3177a
leaq 0x1acad(%rip), %rsi     # 0x31570
leaq 0x1b339(%rip), %rcx     # 0x31c03
movl $0x52f, %edx            # imm = 0x52F
callq 0xa0b0
leaq 0x1ae9b(%rip), %rdi     # 0x31776
leaq 0x1ac8e(%rip), %rsi     # 0x31570
leaq 0x1b31a(%rip), %rcx     # 0x31c03
movl $0x530, %edx            # imm = 0x530
callq 0xa0b0
leaq 0x1b231(%rip), %rdi     # 0x31b2b
leaq 0x1ac6f(%rip), %rsi     # 0x31570
leaq 0x1b2fb(%rip), %rcx     # 0x31c03
movl $0x531, %edx            # imm = 0x531
callq 0xa0b0
leaq 0x1a98c(%rip), %rdi     # 0x312a5
leaq 0x1ac50(%rip), %rsi     # 0x31570
leaq 0x1b2dc(%rip), %rcx     # 0x31c03
movl $0x534, %edx            # imm = 0x534
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x169ae
testq %rsi, %rsi
je 0x169cd
movl (%rsi), %eax
cmpl $0x600, %eax            # imm = 0x600
je 0x1698e
cmpl $0x500, %eax            # imm = 0x500
jne 0x169ec
movq 0x60(%rsi), %rax
testq %rax, %rax
je 0x16a0b
movl 0xc(%rax), %eax
addl $-0x2, %eax
cmpl $0x4, %eax
jb 0x1699c
leaq 0x18a1e(%rip), %rdi     # 0x2f394
leaq 0x1abf3(%rip), %rsi     # 0x31570
leaq 0x1b2e6(%rip), %rcx     # 0x31c6a
movl $0x559, %edx            # imm = 0x559
callq 0xa0b0
movl 0x64(%rsi), %eax
decl %eax
cmpl $0x4, %eax
jae 0x16a2a
movl %eax, %eax
leaq 0x1b53b(%rip), %rcx     # 0x31ee0
leaq (%rcx,%rax,8), %rax
movq (%rax), %rax
popq %rbp
retq
leaq 0x1fda1(%rip), %rdi     # 0x36756
leaq 0x1abb4(%rip), %rsi     # 0x31570
leaq 0x1b2a7(%rip), %rcx     # 0x31c6a
movl $0x544, %edx            # imm = 0x544
callq 0xa0b0
leaq 0x1c327(%rip), %rdi     # 0x32cfb
leaq 0x1ab95(%rip), %rsi     # 0x31570
leaq 0x1b288(%rip), %rcx     # 0x31c6a
movl $0x545, %edx            # imm = 0x545
callq 0xa0b0
leaq 0x189a1(%rip), %rdi     # 0x2f394
leaq 0x1ab76(%rip), %rsi     # 0x31570
leaq 0x1b269(%rip), %rcx     # 0x31c6a
movl $0x573, %edx            # imm = 0x573
callq 0xa0b0
leaq 0x1addf(%rip), %rdi     # 0x317f1
leaq 0x1ab57(%rip), %rsi     # 0x31570
leaq 0x1b24a(%rip), %rcx     # 0x31c6a
movl $0x549, %edx            # imm = 0x549
callq 0xa0b0
leaq 0x18963(%rip), %rdi     # 0x2f394
leaq 0x1ab38(%rip), %rsi     # 0x31570
leaq 0x1b22b(%rip), %rcx     # 0x31c6a
movl $0x56e, %edx            # imm = 0x56E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x16b4d
testq %rsi, %rsi
je 0x16b6c
movq %rdx, %r15
testq %rdx, %rdx
je 0x16b8b
movq %rcx, %r12
testq %rcx, %rcx
je 0x16baa
movq %r8, %rbx
movq %rdi, %r14
movq %r15, %rsi
callq 0x16931
movq %rax, %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0x16931
movq %rax, %r12
cmpq %rax, %r13
je 0x16b08
leaq 0x1b249(%rip), %rdx     # 0x31d47
movq %r14, %rdi
movq %r15, %rsi
callq *0x58(%r14)
testq %rbx, %rbx
je 0x16b1d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x16931
cmpq %rax, %r12
jne 0x16b2c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x58(%r14), %rax
leaq 0x1b210(%rip), %rdx     # 0x31d47
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
leaq 0x1fc02(%rip), %rdi     # 0x36756
leaq 0x1aa15(%rip), %rsi     # 0x31570
leaq 0x1b176(%rip), %rcx     # 0x31cd8
movl $0x589, %edx            # imm = 0x589
callq 0xa0b0
leaq 0x1ac07(%rip), %rdi     # 0x3177a
leaq 0x1a9f6(%rip), %rsi     # 0x31570
leaq 0x1b157(%rip), %rcx     # 0x31cd8
movl $0x58a, %edx            # imm = 0x58A
callq 0xa0b0
leaq 0x20a65(%rip), %rdi     # 0x375f7
leaq 0x1a9d7(%rip), %rsi     # 0x31570
leaq 0x1b138(%rip), %rcx     # 0x31cd8
movl $0x58b, %edx            # imm = 0x58B
callq 0xa0b0
leaq 0x1959d(%rip), %rdi     # 0x3014e
leaq 0x1a9b8(%rip), %rsi     # 0x31570
leaq 0x1b119(%rip), %rcx     # 0x31cd8
movl $0x58c, %edx            # imm = 0x58C
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x16caa
movq %rdi, %rbx
leaq 0x2fde2(%rip), %rax     # 0x46a00
leaq 0x2907b(%rip), %r15     # 0x3fca0
xorl %r12d, %r12d
cmpq $0x0, (%rax)
jne 0x16c49
movq 0x8(%r15,%r12,8), %rax
incq %r12
cmpq $0x7, %r12
jne 0x16c28
movl $0x7, %r12d
movq %rax, %r13
xorl %eax, %eax
jmp 0x16c4d
leaq 0x28(%rax), %r13
testq %rax, %rax
je 0x16c9b
leaq 0x17878(%rip), %r14     # 0x2e4d1
movq (%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xa0f0
testq %r13, %r13
je 0x16c8e
movq %r13, %rax
cmpq $0x0, (%rax)
jne 0x16c92
movq 0x8(%r15,%r12,8), %rax
incq %r12
cmpq $0x7, %r12
jne 0x16c71
movl $0x7, %r12d
movq %rax, %r13
xorl %eax, %eax
jmp 0x16c96
leaq 0x28(%rax), %r13
testq %rax, %rax
jne 0x16c59
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17d68(%rip), %rdi     # 0x2ea19
leaq 0x1a8b8(%rip), %rsi     # 0x31570
leaq 0x1b104(%rip), %rcx     # 0x31dc3
movl $0x5b2, %edx            # imm = 0x5B2
callq 0xa0b0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x16e2b
testq %rsi, %rsi
je 0x16e4a
movq (%rsi), %rcx
cmpl $0x1, 0x44(%rcx)
jne 0x16e69
movq 0x8(%rsi), %rax
incq 0xc0(%rax)
cmpl $0x1, 0xc8(%rax)
jne 0x16e0d
popq %rbp
retq
movq 0x48(%rcx), %rcx
movq (%rcx), %rcx
cmpb $0x1, 0x60(%rcx)
jne 0x16e88
movq 0xb8(%rax), %rsi
movsbl 0x68(%rcx), %edi
popq %rbp
jmp 0xa0d0
leaq 0x1a948(%rip), %rdi     # 0x3177a
leaq 0x1b791(%rip), %rsi     # 0x325ca
leaq 0x1b865(%rip), %rcx     # 0x326a5
movl $0x32, %edx
callq 0xa0b0
leaq 0x207a3(%rip), %rdi     # 0x375f4
leaq 0x1b772(%rip), %rsi     # 0x325ca
leaq 0x1b846(%rip), %rcx     # 0x326a5
movl $0x33, %edx
callq 0xa0b0
leaq 0x1b870(%rip), %rdi     # 0x326e0
leaq 0x1b753(%rip), %rsi     # 0x325ca
leaq 0x1b827(%rip), %rcx     # 0x326a5
movl $0x34, %edx
callq 0xa0b0
leaq 0x1a416(%rip), %rdi     # 0x312a5
leaq 0x1b734(%rip), %rsi     # 0x325ca
leaq 0x1b808(%rip), %rcx     # 0x326a5
movl $0x3e, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x16efd
testq %rsi, %rsi
je 0x16f1c
movq (%rsi), %rcx
cmpl $0x1, 0x44(%rcx)
jne 0x16f3b
movq 0x8(%rsi), %rax
addq $0x2, 0xc0(%rax)
cmpl $0x1, 0xc8(%rax)
jne 0x16ed5
popq %rbp
retq
movq 0x48(%rcx), %rcx
movq (%rcx), %rdi
cmpb $0x1, 0x60(%rdi)
jne 0x16f5a
addq $0x68, %rdi
movq 0xb8(%rax), %rcx
movl $0x2, %esi
movl $0x1, %edx
popq %rbp
jmp 0xa170
leaq 0x1a876(%rip), %rdi     # 0x3177a
leaq 0x1b6bf(%rip), %rsi     # 0x325ca
leaq 0x1b7eb(%rip), %rcx     # 0x326fd
movl $0x47, %edx
callq 0xa0b0
leaq 0x206d1(%rip), %rdi     # 0x375f4
leaq 0x1b6a0(%rip), %rsi     # 0x325ca
leaq 0x1b7cc(%rip), %rcx     # 0x326fd
movl $0x48, %edx
callq 0xa0b0
leaq 0x1b79e(%rip), %rdi     # 0x326e0
leaq 0x1b681(%rip), %rsi     # 0x325ca
leaq 0x1b7ad(%rip), %rcx     # 0x326fd
movl $0x49, %edx
callq 0xa0b0
leaq 0x1a344(%rip), %rdi     # 0x312a5
leaq 0x1b662(%rip), %rsi     # 0x325ca
leaq 0x1b78e(%rip), %rcx     # 0x326fd
movl $0x53, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x16fcf
testq %rsi, %rsi
je 0x16fee
movq (%rsi), %rcx
cmpl $0x1, 0x44(%rcx)
jne 0x1700d
movq 0x8(%rsi), %rax
addq $0x4, 0xc0(%rax)
cmpl $0x1, 0xc8(%rax)
jne 0x16fa7
popq %rbp
retq
movq 0x48(%rcx), %rcx
movq (%rcx), %rdi
cmpb $0x1, 0x60(%rdi)
jne 0x1702c
addq $0x68, %rdi
movq 0xb8(%rax), %rcx
movl $0x4, %esi
movl $0x1, %edx
popq %rbp
jmp 0xa170
leaq 0x1a7a4(%rip), %rdi     # 0x3177a
leaq 0x1b5ed(%rip), %rsi     # 0x325ca
leaq 0x1b755(%rip), %rcx     # 0x32739
movl $0x5c, %edx
callq 0xa0b0
leaq 0x205ff(%rip), %rdi     # 0x375f4
leaq 0x1b5ce(%rip), %rsi     # 0x325ca
leaq 0x1b736(%rip), %rcx     # 0x32739
movl $0x5d, %edx
callq 0xa0b0
leaq 0x1b6cc(%rip), %rdi     # 0x326e0
leaq 0x1b5af(%rip), %rsi     # 0x325ca
leaq 0x1b717(%rip), %rcx     # 0x32739
movl $0x5e, %edx
callq 0xa0b0
leaq 0x1a272(%rip), %rdi     # 0x312a5
leaq 0x1b590(%rip), %rsi     # 0x325ca
leaq 0x1b6f8(%rip), %rcx     # 0x32739
movl $0x68, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x170a1
testq %rsi, %rsi
je 0x170c0
movq (%rsi), %rcx
cmpl $0x1, 0x44(%rcx)
jne 0x170df
movq 0x8(%rsi), %rax
addq $0x8, 0xc0(%rax)
cmpl $0x1, 0xc8(%rax)
jne 0x17079
popq %rbp
retq
movq 0x48(%rcx), %rcx
movq (%rcx), %rdi
cmpb $0x1, 0x60(%rdi)
jne 0x170fe
addq $0x68, %rdi
movq 0xb8(%rax), %rcx
movl $0x8, %esi
movl $0x1, %edx
popq %rbp
jmp 0xa170
leaq 0x1a6d2(%rip), %rdi     # 0x3177a
leaq 0x1b51b(%rip), %rsi     # 0x325ca
leaq 0x1b6bf(%rip), %rcx     # 0x32775
movl $0x71, %edx
callq 0xa0b0
leaq 0x2052d(%rip), %rdi     # 0x375f4
leaq 0x1b4fc(%rip), %rsi     # 0x325ca
leaq 0x1b6a0(%rip), %rcx     # 0x32775
movl $0x72, %edx
callq 0xa0b0
leaq 0x1b5fa(%rip), %rdi     # 0x326e0
leaq 0x1b4dd(%rip), %rsi     # 0x325ca
leaq 0x1b681(%rip), %rcx     # 0x32775
movl $0x73, %edx
callq 0xa0b0
leaq 0x1a1a0(%rip), %rdi     # 0x312a5
leaq 0x1b4be(%rip), %rsi     # 0x325ca
leaq 0x1b662(%rip), %rcx     # 0x32775
movl $0x7d, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x1718b
testq %rsi, %rsi
je 0x171aa
movq (%rsi), %rcx
cmpl $0x1, 0x44(%rcx)
jne 0x171c9
movq 0x8(%rsi), %rax
addq $0x4, 0xc0(%rax)
cmpl $0x1, 0xc8(%rax)
je 0x17185
movq 0x48(%rcx), %rcx
movq (%rcx), %rcx
cmpb $0x2, 0x60(%rcx)
jne 0x171e8
cvtsd2ss 0x68(%rcx), %xmm0
leaq -0x4(%rbp), %rdi
movss %xmm0, (%rdi)
movq 0xb8(%rax), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0xa170
addq $0x10, %rsp
popq %rbp
retq
leaq 0x1a5e8(%rip), %rdi     # 0x3177a
leaq 0x1b431(%rip), %rsi     # 0x325ca
leaq 0x1b611(%rip), %rcx     # 0x327b1
movl $0x86, %edx
callq 0xa0b0
leaq 0x20443(%rip), %rdi     # 0x375f4
leaq 0x1b412(%rip), %rsi     # 0x325ca
leaq 0x1b5f2(%rip), %rcx     # 0x327b1
movl $0x87, %edx
callq 0xa0b0
leaq 0x1b510(%rip), %rdi     # 0x326e0
leaq 0x1b3f3(%rip), %rsi     # 0x325ca
leaq 0x1b5d3(%rip), %rcx     # 0x327b1
movl $0x88, %edx
callq 0xa0b0
leaq 0x1b5fe(%rip), %rdi     # 0x327ed
leaq 0x1b3d4(%rip), %rsi     # 0x325ca
leaq 0x1b5b4(%rip), %rcx     # 0x327b1
movl $0x92, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x1725d
testq %rsi, %rsi
je 0x1727c
movq (%rsi), %rcx
cmpl $0x1, 0x44(%rcx)
jne 0x1729b
movq 0x8(%rsi), %rax
addq $0x8, 0xc0(%rax)
cmpl $0x1, 0xc8(%rax)
jne 0x17235
popq %rbp
retq
movq 0x48(%rcx), %rcx
movq (%rcx), %rdi
cmpb $0x2, 0x60(%rdi)
jne 0x172ba
addq $0x68, %rdi
movq 0xb8(%rax), %rcx
movl $0x8, %esi
movl $0x1, %edx
popq %rbp
jmp 0xa170
leaq 0x1a516(%rip), %rdi     # 0x3177a
leaq 0x1b35f(%rip), %rsi     # 0x325ca
leaq 0x1b5ac(%rip), %rcx     # 0x3281e
movl $0x9d, %edx
callq 0xa0b0
leaq 0x20371(%rip), %rdi     # 0x375f4
leaq 0x1b340(%rip), %rsi     # 0x325ca
leaq 0x1b58d(%rip), %rcx     # 0x3281e
movl $0x9e, %edx
callq 0xa0b0
leaq 0x1b43e(%rip), %rdi     # 0x326e0
leaq 0x1b321(%rip), %rsi     # 0x325ca
leaq 0x1b56e(%rip), %rcx     # 0x3281e
movl $0x9f, %edx
callq 0xa0b0
leaq 0x1b52c(%rip), %rdi     # 0x327ed
leaq 0x1b302(%rip), %rsi     # 0x325ca
leaq 0x1b54f(%rip), %rcx     # 0x3281e
movl $0xa9, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x17339
testq %rsi, %rsi
je 0x17358
movq (%rsi), %rax
cmpl $0x1, 0x44(%rax)
jne 0x17377
movq 0x48(%rax), %rax
movq (%rax), %rax
cmpb $0x3, 0x60(%rax)
jne 0x17396
movq 0x70(%rax), %rdx
movq 0x8(%rsi), %rcx
addq %rdx, 0xc0(%rcx)
cmpl $0x1, 0xc8(%rcx)
jne 0x1731f
popq %rbp
retq
movq 0x68(%rax), %rdi
movq 0x70(%rax), %rsi
movq 0xb8(%rcx), %rcx
movl $0x1, %edx
popq %rbp
jmp 0xa170
leaq 0x1a43a(%rip), %rdi     # 0x3177a
leaq 0x1b283(%rip), %rsi     # 0x325ca
leaq 0x1b50d(%rip), %rcx     # 0x3285b
movl $0xb2, %edx
callq 0xa0b0
leaq 0x20295(%rip), %rdi     # 0x375f4
leaq 0x1b264(%rip), %rsi     # 0x325ca
leaq 0x1b4ee(%rip), %rcx     # 0x3285b
movl $0xb3, %edx
callq 0xa0b0
leaq 0x1b362(%rip), %rdi     # 0x326e0
leaq 0x1b245(%rip), %rsi     # 0x325ca
leaq 0x1b4cf(%rip), %rcx     # 0x3285b
movl $0xb4, %edx
callq 0xa0b0
leaq 0x1b4fb(%rip), %rdi     # 0x32898
leaq 0x1b226(%rip), %rsi     # 0x325ca
leaq 0x1b4b0(%rip), %rcx     # 0x3285b
movl $0xb9, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_directive_enc.c
// Function: ins_enc_int8s
void ins_enc_int8s(
	Instruction *ins,
	InstructionEncoderData *data
) {
	assert(ins);
	assert(data);
	assert(data->ins_node->nchilds == 2);

	ParserASTNode *node_count = data->ins_node->childs[0];
	assert(node_count->type == ASM_NODE_EXPR);

	AsmExprEvalResult *result_count = &ASM_EXPR_AST_NODE_GET_RESULT(node_count);
	assert(result_count->type == ASM_EXPR_EVAL_RESULT_TYPE_UINT64);

	ASM_PARSER_CONTEXT_DATA_INC_ADDRESS_COUNTER(data->ctx, result_count->value.u64 * 1);
	if (ASM_PARSER_CONTEXT_DATA_GET_STEP(data->ctx) == ASM_STEP_SCAN) {
		return;
	}

	ParserASTNode *node_val = data->ins_node->childs[1];
	assert(node_val->type == ASM_NODE_EXPR);

	AsmExprEvalResult *result_val = &ASM_EXPR_AST_NODE_GET_RESULT(node_val);
	assert(result_val->type == ASM_EXPR_EVAL_RESULT_TYPE_UINT64);

	for (uint64_t i = 0; i < result_count->value.u64; i++) {
		fwrite(&result_val->value.u64, 1, 1, ASM_PARSER_CONTEXT_DATA_GET_OUT(data->ctx));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x17466
movq %rsi, %rbx
testq %rsi, %rsi
je 0x17485
movq (%rbx), %rax
cmpl $0x2, 0x44(%rax)
jne 0x174a4
movq 0x48(%rax), %rax
movq (%rax), %r14
cmpl $0xe00, (%r14)          # imm = 0xE00
jne 0x174c3
cmpb $0x1, 0x60(%r14)
jne 0x174e2
movq 0x68(%r14), %rcx
movq 0x8(%rbx), %rdx
addq %rcx, 0xc0(%rdx)
cmpl $0x1, 0xc8(%rdx)
je 0x1745d
movq 0x8(%rax), %r15
cmpl $0xe00, (%r15)          # imm = 0xE00
jne 0x17501
cmpb $0x1, 0x60(%r15)
jne 0x17520
cmpq $0x0, 0x68(%r14)
je 0x1745d
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movq 0xb8(%rax), %rsi
movsbl 0x68(%r15), %edi
callq 0xa0d0
incq %r12
cmpq 0x68(%r14), %r12
jb 0x1743f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a30d(%rip), %rdi     # 0x3177a
leaq 0x1b156(%rip), %rsi     # 0x325ca
leaq 0x1b44e(%rip), %rcx     # 0x328c9
movl $0xc7, %edx
callq 0xa0b0
leaq 0x20168(%rip), %rdi     # 0x375f4
leaq 0x1b137(%rip), %rsi     # 0x325ca
leaq 0x1b42f(%rip), %rcx     # 0x328c9
movl $0xc8, %edx
callq 0xa0b0
leaq 0x1b45a(%rip), %rdi     # 0x32905
leaq 0x1b118(%rip), %rsi     # 0x325ca
leaq 0x1b410(%rip), %rcx     # 0x328c9
movl $0xc9, %edx
callq 0xa0b0
leaq 0x1b458(%rip), %rdi     # 0x32922
leaq 0x1b0f9(%rip), %rsi     # 0x325ca
leaq 0x1b3f1(%rip), %rcx     # 0x328c9
movl $0xcc, %edx
callq 0xa0b0
leaq 0x1b45b(%rip), %rdi     # 0x32944
leaq 0x1b0da(%rip), %rsi     # 0x325ca
leaq 0x1b3d2(%rip), %rcx     # 0x328c9
movl $0xcf, %edx
callq 0xa0b0
leaq 0x1b473(%rip), %rdi     # 0x3297b
leaq 0x1b0bb(%rip), %rsi     # 0x325ca
leaq 0x1b3b3(%rip), %rcx     # 0x328c9
movl $0xd7, %edx
callq 0xa0b0
leaq 0x1b474(%rip), %rdi     # 0x3299b
leaq 0x1b09c(%rip), %rsi     # 0x325ca
leaq 0x1b394(%rip), %rcx     # 0x328c9
movl $0xda, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_directive_enc.c
// Function: ins_enc_int64s
void ins_enc_int64s(
	Instruction *ins,
	InstructionEncoderData *data
) {
	assert(ins);
	assert(data);
	assert(data->ins_node->nchilds == 2);

	ParserASTNode *node_count = data->ins_node->childs[0];
	assert(node_count->type == ASM_NODE_EXPR);

	AsmExprEvalResult *result_count = &ASM_EXPR_AST_NODE_GET_RESULT(node_count);
	assert(result_count->type == ASM_EXPR_EVAL_RESULT_TYPE_UINT64);

	ASM_PARSER_CONTEXT_DATA_INC_ADDRESS_COUNTER(data->ctx, result_count->value.u64 * 8);
	if (ASM_PARSER_CONTEXT_DATA_GET_STEP(data->ctx) == ASM_STEP_SCAN) {
		return;
	}

	ParserASTNode *node_val = data->ins_node->childs[1];
	assert(node_val->type == ASM_NODE_EXPR);

	AsmExprEvalResult *result_val = &ASM_EXPR_AST_NODE_GET_RESULT(node_val);
	assert(result_val->type == ASM_EXPR_EVAL_RESULT_TYPE_UINT64);

	for (uint64_t i = 0; i < result_count->value.u64; i++) {
		fwrite(&result_val->value.u64, 8, 1, ASM_PARSER_CONTEXT_DATA_GET_OUT(data->ctx));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x17933
movq %rsi, %rbx
testq %rsi, %rsi
je 0x17952
movq (%rbx), %rax
cmpl $0x2, 0x44(%rax)
jne 0x17971
movq 0x48(%rax), %rax
movq (%rax), %r15
cmpl $0xe00, (%r15)          # imm = 0xE00
jne 0x17990
cmpb $0x1, 0x60(%r15)
jne 0x179af
movq 0x68(%r15), %rcx
shlq $0x3, %rcx
movq 0x8(%rbx), %rdx
addq %rcx, 0xc0(%rdx)
cmpl $0x1, 0xc8(%rdx)
je 0x1792a
movq 0x8(%rax), %r14
cmpl $0xe00, (%r14)          # imm = 0xE00
jne 0x179ce
cmpb $0x1, 0x60(%r14)
jne 0x179ed
cmpq $0x0, 0x68(%r15)
je 0x1792a
addq $0x68, %r14
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movq 0xb8(%rax), %rcx
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rdi
callq 0xa170
incq %r12
cmpq 0x68(%r15), %r12
jb 0x17904
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19e40(%rip), %rdi     # 0x3177a
leaq 0x1ac89(%rip), %rsi     # 0x325ca
leaq 0x1b102(%rip), %rcx     # 0x32a4a
movl $0x121, %edx            # imm = 0x121
callq 0xa0b0
leaq 0x1fc9b(%rip), %rdi     # 0x375f4
leaq 0x1ac6a(%rip), %rsi     # 0x325ca
leaq 0x1b0e3(%rip), %rcx     # 0x32a4a
movl $0x122, %edx            # imm = 0x122
callq 0xa0b0
leaq 0x1af8d(%rip), %rdi     # 0x32905
leaq 0x1ac4b(%rip), %rsi     # 0x325ca
leaq 0x1b0c4(%rip), %rcx     # 0x32a4a
movl $0x123, %edx            # imm = 0x123
callq 0xa0b0
leaq 0x1af8b(%rip), %rdi     # 0x32922
leaq 0x1ac2c(%rip), %rsi     # 0x325ca
leaq 0x1b0a5(%rip), %rcx     # 0x32a4a
movl $0x126, %edx            # imm = 0x126
callq 0xa0b0
leaq 0x1af8e(%rip), %rdi     # 0x32944
leaq 0x1ac0d(%rip), %rsi     # 0x325ca
leaq 0x1b086(%rip), %rcx     # 0x32a4a
movl $0x129, %edx            # imm = 0x129
callq 0xa0b0
leaq 0x1afa6(%rip), %rdi     # 0x3297b
leaq 0x1abee(%rip), %rsi     # 0x325ca
leaq 0x1b067(%rip), %rcx     # 0x32a4a
movl $0x131, %edx            # imm = 0x131
callq 0xa0b0
leaq 0x1afa7(%rip), %rdi     # 0x3299b
leaq 0x1abcf(%rip), %rsi     # 0x325ca
leaq 0x1b048(%rip), %rcx     # 0x32a4a
movl $0x134, %edx            # imm = 0x134
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_directive_enc.c
// Function: ins_enc_strings
void ins_enc_strings(
	Instruction *ins,
	InstructionEncoderData *data
) {
	assert(ins);
	assert(data);
	assert(data->ins_node->nchilds == 2);

	ParserASTNode *node_count = data->ins_node->childs[0];
	assert(node_count->type == ASM_NODE_EXPR);

	AsmExprEvalResult *result_count = &ASM_EXPR_AST_NODE_GET_RESULT(node_count);
	assert(result_count->type == ASM_EXPR_EVAL_RESULT_TYPE_UINT64);

	ParserASTNode *node_val = data->ins_node->childs[1];
	assert(node_val->type == ASM_NODE_EXPR);

	AsmExprEvalResult *result_val = &ASM_EXPR_AST_NODE_GET_RESULT(node_val);
	assert(result_val->type == ASM_EXPR_EVAL_RESULT_TYPE_STRING);

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

	for (uint64_t i = 0; i < result_count->value.u64; i++) {
		fwrite(
			result_val->value.str.ptr,
			result_val->value.str.len,
			1,
			ASM_PARSER_CONTEXT_DATA_GET_OUT(data->ctx)
		);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x17e0e
movq %rsi, %rbx
testq %rsi, %rsi
je 0x17e2d
movq (%rbx), %rax
cmpl $0x2, 0x44(%rax)
jne 0x17e4c
movq 0x48(%rax), %rax
movq (%rax), %r14
cmpl $0xe00, (%r14)          # imm = 0xE00
jne 0x17e6b
cmpb $0x1, 0x60(%r14)
jne 0x17e8a
movq 0x8(%rax), %r15
cmpl $0xe00, (%r15)          # imm = 0xE00
jne 0x17ea9
cmpb $0x3, 0x60(%r15)
jne 0x17ec8
movq 0x70(%r15), %rax
imulq 0x68(%r14), %rax
movq 0x8(%rbx), %rcx
addq %rax, 0xc0(%rcx)
cmpl $0x1, 0xc8(%rcx)
je 0x17e05
cmpq $0x0, 0x68(%r14)
je 0x17e05
xorl %r12d, %r12d
movq 0x68(%r15), %rdi
movq 0x70(%r15), %rsi
movq 0x8(%rbx), %rax
movq 0xb8(%rax), %rcx
movl $0x1, %edx
callq 0xa170
incq %r12
cmpq 0x68(%r14), %r12
jb 0x17ddf
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19965(%rip), %rdi     # 0x3177a
leaq 0x1a7ae(%rip), %rsi     # 0x325ca
leaq 0x1ad14(%rip), %rcx     # 0x32b37
movl $0x17d, %edx            # imm = 0x17D
callq 0xa0b0
leaq 0x1f7c0(%rip), %rdi     # 0x375f4
leaq 0x1a78f(%rip), %rsi     # 0x325ca
leaq 0x1acf5(%rip), %rcx     # 0x32b37
movl $0x17e, %edx            # imm = 0x17E
callq 0xa0b0
leaq 0x1aab2(%rip), %rdi     # 0x32905
leaq 0x1a770(%rip), %rsi     # 0x325ca
leaq 0x1acd6(%rip), %rcx     # 0x32b37
movl $0x17f, %edx            # imm = 0x17F
callq 0xa0b0
leaq 0x1aab0(%rip), %rdi     # 0x32922
leaq 0x1a751(%rip), %rsi     # 0x325ca
leaq 0x1acb7(%rip), %rcx     # 0x32b37
movl $0x182, %edx            # imm = 0x182
callq 0xa0b0
leaq 0x1aab3(%rip), %rdi     # 0x32944
leaq 0x1a732(%rip), %rsi     # 0x325ca
leaq 0x1ac98(%rip), %rcx     # 0x32b37
movl $0x185, %edx            # imm = 0x185
callq 0xa0b0
leaq 0x1aacb(%rip), %rdi     # 0x3297b
leaq 0x1a713(%rip), %rsi     # 0x325ca
leaq 0x1ac79(%rip), %rcx     # 0x32b37
movl $0x188, %edx            # imm = 0x188
callq 0xa0b0
leaq 0x1aca6(%rip), %rdi     # 0x32b75
leaq 0x1a6f4(%rip), %rsi     # 0x325ca
leaq 0x1ac5a(%rip), %rcx     # 0x32b37
movl $0x18b, %edx            # imm = 0x18B
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_directive_enc.c
// Function: ins_enc_label
void ins_enc_label(
	Instruction *ins,
	InstructionEncoderData *data
) {
	assert(ins);
	assert(data);
	assert(data->ins_node->nchilds == 1);

	if (ASM_PARSER_CONTEXT_DATA_GET_STEP(data->ctx) == ASM_STEP_SCAN) {
		ParserASTNode *node_id = data->ins_node->childs[0];
		assert(node_id->type == ASM_NODE_IDENTIFIER);

		asm_parser_set_symbol_by_token_key(
			data->ctx, node_id->token, ASM_PARSER_CONTEXT_DATA_GET_ADDRESS_COUNTER(data->ctx)
		);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x17f2d
testq %rsi, %rsi
je 0x17f4c
movq (%rsi), %rax
cmpl $0x1, 0x44(%rax)
jne 0x17f6b
movq 0x8(%rsi), %rdi
cmpl $0x1, 0xc8(%rdi)
jne 0x17f2b
movq 0x48(%rax), %rax
movq (%rax), %rax
cmpl $0x200, (%rax)          # imm = 0x200
jne 0x17f8a
movq 0x10(%rax), %rsi
movq 0xc0(%rdi), %rdx
popq %rbp
jmp 0x1efb4
popq %rbp
retq
leaq 0x19846(%rip), %rdi     # 0x3177a
leaq 0x1a68f(%rip), %rsi     # 0x325ca
leaq 0x1ac68(%rip), %rcx     # 0x32baa
movl $0x1aa, %edx            # imm = 0x1AA
callq 0xa0b0
leaq 0x1f6a1(%rip), %rdi     # 0x375f4
leaq 0x1a670(%rip), %rsi     # 0x325ca
leaq 0x1ac49(%rip), %rcx     # 0x32baa
movl $0x1ab, %edx            # imm = 0x1AB
callq 0xa0b0
leaq 0x1a76e(%rip), %rdi     # 0x326e0
leaq 0x1a651(%rip), %rsi     # 0x325ca
leaq 0x1ac2a(%rip), %rcx     # 0x32baa
movl $0x1ac, %edx            # imm = 0x1AC
callq 0xa0b0
leaq 0x1ac55(%rip), %rdi     # 0x32be6
leaq 0x1a632(%rip), %rsi     # 0x325ca
leaq 0x1ac0b(%rip), %rcx     # 0x32baa
movl $0x1b0, %edx            # imm = 0x1B0
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_directive_enc.c
// Function: ins_enc_set
void ins_enc_set(
	Instruction *ins,
	InstructionEncoderData *data
) {
	assert(ins);
	assert(data);
	assert(data->ins_node->nchilds == 2);

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

	ParserASTNode *node_id = data->ins_node->childs[0];
	assert(node_id->type == ASM_NODE_IDENTIFIER);

	ParserASTNode *node_val = data->ins_node->childs[1];
	assert(node_val->type == ASM_NODE_EXPR);

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

	asm_parser_set_symbol_by_token_key(
		data->ctx, node_id->token, result->value.u64
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1800e
testq %rsi, %rsi
je 0x1802d
movq (%rsi), %rax
cmpl $0x2, 0x44(%rax)
jne 0x1804c
movq 0x8(%rsi), %rdi
cmpl $0x1, 0xc8(%rdi)
jne 0x17fd3
popq %rbp
retq
movq 0x48(%rax), %rcx
movq (%rcx), %rax
cmpl $0x200, (%rax)          # imm = 0x200
jne 0x1806b
movq 0x8(%rcx), %rcx
cmpl $0xe00, (%rcx)          # imm = 0xE00
jne 0x1808a
cmpb $0x1, 0x60(%rcx)
jne 0x180a9
movq 0x10(%rax), %rsi
movq 0x68(%rcx), %rdx
popq %rbp
jmp 0x1efb4
leaq 0x19765(%rip), %rdi     # 0x3177a
leaq 0x1a5ae(%rip), %rsi     # 0x325ca
leaq 0x1abe8(%rip), %rcx     # 0x32c0b
movl $0x1bc, %edx            # imm = 0x1BC
callq 0xa0b0
leaq 0x1f5c0(%rip), %rdi     # 0x375f4
leaq 0x1a58f(%rip), %rsi     # 0x325ca
leaq 0x1abc9(%rip), %rcx     # 0x32c0b
movl $0x1bd, %edx            # imm = 0x1BD
callq 0xa0b0
leaq 0x1a8b2(%rip), %rdi     # 0x32905
leaq 0x1a570(%rip), %rsi     # 0x325ca
leaq 0x1abaa(%rip), %rcx     # 0x32c0b
movl $0x1be, %edx            # imm = 0x1BE
callq 0xa0b0
leaq 0x1ab74(%rip), %rdi     # 0x32be6
leaq 0x1a551(%rip), %rsi     # 0x325ca
leaq 0x1ab8b(%rip), %rcx     # 0x32c0b
movl $0x1c5, %edx            # imm = 0x1C5
callq 0xa0b0
leaq 0x1a8ea(%rip), %rdi     # 0x3297b
leaq 0x1a532(%rip), %rsi     # 0x325ca
leaq 0x1ab6c(%rip), %rcx     # 0x32c0b
movl $0x1c8, %edx            # imm = 0x1C8
callq 0xa0b0
leaq 0x191f5(%rip), %rdi     # 0x312a5
leaq 0x1a513(%rip), %rsi     # 0x325ca
leaq 0x1ab4d(%rip), %rcx     # 0x32c0b
movl $0x1cb, %edx            # imm = 0x1CB
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_directive_enc.c
// Function: ins_enc_print
void ins_enc_print(
	Instruction *ins,
	InstructionEncoderData *data
) {
	assert(ins);
	assert(data);
	assert(data->ins_node->nchilds == 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);

	switch (result->type) {
		case ASM_EXPR_EVAL_RESULT_TYPE_UINT64: {
			printf("0x%llx, %llu\n", result->value.u64, result->value.u64);
			break;
		}
		case ASM_EXPR_EVAL_RESULT_TYPE_DOUBLE: {
			printf("%lf\n", result->value.d);
			break;
		}
		case ASM_EXPR_EVAL_RESULT_TYPE_STRING: {
			for (size_t i = 0; i < result->value.str.len; i++) {
				putchar(result->value.str.ptr[i]);
			}
			putchar('\n');
			break;
		}
		default: {
			assert(0);
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1817d
testq %rsi, %rsi
je 0x1819c
movq (%rsi), %rax
cmpl $0x1, 0x44(%rax)
jne 0x181bb
movq 0x8(%rsi), %rcx
cmpl $0x1, 0xc8(%rcx)
jne 0x18100
popq %rbx
popq %r14
popq %rbp
retq
movq 0x48(%rax), %rax
movq (%rax), %rbx
movzbl 0x60(%rbx), %eax
cmpl $0x1, %eax
je 0x18164
cmpl $0x2, %eax
je 0x1814d
cmpl $0x3, %eax
jne 0x181da
cmpq $0x0, 0x70(%rbx)
je 0x1813f
xorl %r14d, %r14d
movq 0x68(%rbx), %rax
movsbl (%rax,%r14), %edi
callq 0xa030
incq %r14
cmpq 0x70(%rbx), %r14
jb 0x18128
movl $0xa, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0xa030
movsd 0x68(%rbx), %xmm0
leaq 0x1ab36(%rip), %rdi     # 0x32c8f
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
jmp 0xa090
movq 0x68(%rbx), %rdx
leaq 0x1ab12(%rip), %rdi     # 0x32c81
movq %rdx, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0xa090
leaq 0x195f6(%rip), %rdi     # 0x3177a
leaq 0x1a43f(%rip), %rsi     # 0x325ca
leaq 0x1aab3(%rip), %rcx     # 0x32c45
movl $0x1d6, %edx            # imm = 0x1D6
callq 0xa0b0
leaq 0x1f451(%rip), %rdi     # 0x375f4
leaq 0x1a420(%rip), %rsi     # 0x325ca
leaq 0x1aa94(%rip), %rcx     # 0x32c45
movl $0x1d7, %edx            # imm = 0x1D7
callq 0xa0b0
leaq 0x1a51e(%rip), %rdi     # 0x326e0
leaq 0x1a401(%rip), %rsi     # 0x325ca
leaq 0x1aa75(%rip), %rcx     # 0x32c45
movl $0x1d8, %edx            # imm = 0x1D8
callq 0xa0b0
leaq 0x171b3(%rip), %rdi     # 0x2f394
leaq 0x1a3e2(%rip), %rsi     # 0x325ca
leaq 0x1aa56(%rip), %rcx     # 0x32c45
movl $0x1f3, %edx            # imm = 0x1F3
callq 0xa0b0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: output
void _output(
	InstructionEncoderData *data,
	EncoderInstruction *enc_ins
) {
	uint8_t buffer[32];
	size_t 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 %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq -0x30(%rbp), %rsi
movl $0x20, %edx
movq %rax, %rdi
callq 0x148c4
movq 0x8(%rbx), %rcx
addq %rax, 0xc0(%rcx)
cmpl $0x1, 0xc8(%rcx)
je 0x18248
movq 0xb8(%rcx), %rcx
leaq -0x30(%rbp), %rdi
movl $0x1, %edx
movq %rax, %rsi
callq 0xa170
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_XXX_Eb_Gb
void ins_enc_XXX_Eb_Gb(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(2);

	ParserASTNode *ins_node = data->ins_node;

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

	ParserASTNode *gb_node = data->ins_node->childs[1];

	ins_check_operand_type(data->ctx, ins, eb_node, gb_node, NULL);

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

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

	ins_fill_GX(data->ctx, ins, gb_node, &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 0x18308
movq %rsi, %rbx
testq %rsi, %rsi
je 0x18311
movq (%rbx), %r12
testq %r12, %r12
je 0x1831a
cmpl $0x2, 0x44(%r12)
jne 0x18323
movq %rdi, %r14
movq 0x48(%r12), %rax
movq (%rax), %r13
movq 0x8(%rax), %r15
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x16a9b
movq 0x8(%rbx), %rdi
leaq -0x88(%rbp), %rcx
movq %r14, %rsi
movq %r12, %rdx
movq %rcx, %r12
callq 0x155a6
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x157df
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x156a1
movq %rbx, %rdi
movq %r12, %rsi
callq 0x181fc
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1946b(%rip), %rdi     # 0x3177a
jmp 0x1832a
leaq 0x1f2dc(%rip), %rdi     # 0x375f4
jmp 0x1832a
leaq 0x1a9d0(%rip), %rdi     # 0x32cf1
jmp 0x1832a
leaq 0x1a9d6(%rip), %rdi     # 0x32d00
leaq 0x1a963(%rip), %rsi     # 0x32c94
leaq 0x1a979(%rip), %rcx     # 0x32cb1
movl $0x32, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_XXX_Ev_Gv
void ins_enc_XXX_Ev_Gv(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(2);

	ParserASTNode *ins_node = data->ins_node;

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

	ParserASTNode *gv_node = data->ins_node->childs[1];

	ins_check_operand_type(data->ctx, ins, ev_node, gv_node, NULL);

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

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

	ins_fill_GX(data->ctx, ins, gv_node, &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 0x183fb
movq %rsi, %rbx
testq %rsi, %rsi
je 0x18404
movq (%rbx), %r12
testq %r12, %r12
je 0x1840d
cmpl $0x2, 0x44(%r12)
jne 0x18416
movq %rdi, %r14
movq 0x48(%r12), %rax
movq (%rax), %r13
movq 0x8(%rax), %r15
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x16a9b
movq 0x8(%rbx), %rdi
leaq -0x88(%rbp), %rcx
movq %r14, %rsi
movq %r12, %rdx
movq %rcx, %r12
callq 0x155a6
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x157df
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x156a1
movq %rbx, %rdi
movq %r12, %rsi
callq 0x181fc
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19378(%rip), %rdi     # 0x3177a
jmp 0x1841d
leaq 0x1f1e9(%rip), %rdi     # 0x375f4
jmp 0x1841d
leaq 0x1a8dd(%rip), %rdi     # 0x32cf1
jmp 0x1841d
leaq 0x1a8e3(%rip), %rdi     # 0x32d00
leaq 0x1a870(%rip), %rsi     # 0x32c94
leaq 0x1a8f4(%rip), %rcx     # 0x32d1f
movl $0x4b, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_XXX_Gb_Eb
void ins_enc_XXX_Gb_Eb(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(2);

	ParserASTNode *ins_node = data->ins_node;

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

	ParserASTNode *eb_node = data->ins_node->childs[1];

	ins_check_operand_type(data->ctx, ins, gb_node, eb_node, NULL);

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

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

	ins_fill_EX(data->ctx, ins, eb_node, &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 0x184ee
movq %rsi, %rbx
testq %rsi, %rsi
je 0x184f7
movq (%rbx), %r12
testq %r12, %r12
je 0x18500
cmpl $0x2, 0x44(%r12)
jne 0x18509
movq %rdi, %r14
movq 0x48(%r12), %rax
movq (%rax), %r13
movq 0x8(%rax), %r15
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x16a9b
movq 0x8(%rbx), %rdi
leaq -0x88(%rbp), %rcx
movq %r14, %rsi
movq %r12, %rdx
movq %rcx, %r12
callq 0x155a6
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x156a1
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x157df
movq %rbx, %rdi
movq %r12, %rsi
callq 0x181fc
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19285(%rip), %rdi     # 0x3177a
jmp 0x18510
leaq 0x1f0f6(%rip), %rdi     # 0x375f4
jmp 0x18510
leaq 0x1a7ea(%rip), %rdi     # 0x32cf1
jmp 0x18510
leaq 0x1a7f0(%rip), %rdi     # 0x32d00
leaq 0x1a77d(%rip), %rsi     # 0x32c94
leaq 0x1a841(%rip), %rcx     # 0x32d5f
movl $0x64, %edx
callq 0xa0b0