LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_add_uint32_to_ext
void ins_add_uint32_to_ext(
	ParserContext *ctx,
	Instruction *ins,
	EncoderInstruction *enc_ins,
	uint32_t value
) {
	for (int i = 0; i < 4; i++) {
		ins_add_uint8_to_ext(
			ctx,
			ins,
			enc_ins,
			(uint8_t) value
		);

		value >>= 8;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jge 0x1becf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %eax
movzbl %al, %ecx
callq 0x1bd30
movl -0x1c(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1be9e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x8, -0x24(%rbp)
jge 0x1bf34
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movzbl %al, %ecx
callq 0x1bd30
movq -0x20(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1beff
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1bf61
jmp 0x1bf80
leaq 0x31bf9(%rip), %rdi     # 0x4db61
leaq 0x2d98d(%rip), %rsi     # 0x498fc
movl $0x4ec, %edx            # imm = 0x4EC
leaq 0x2ded6(%rip), %rcx     # 0x49e51
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1bf89
jmp 0x1bfa8
leaq 0x2db76(%rip), %rdi     # 0x49b06
leaq 0x2d965(%rip), %rsi     # 0x498fc
movl $0x4ed, %edx            # imm = 0x4ED
leaq 0x2deae(%rip), %rcx     # 0x49e51
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x1bfb1
jmp 0x1bfd0
leaq 0x2db4a(%rip), %rdi     # 0x49b02
leaq 0x2d93d(%rip), %rsi     # 0x498fc
movl $0x4ee, %edx            # imm = 0x4EE
leaq 0x2de86(%rip), %rcx     # 0x49e51
callq 0xa0b0
cmpq $0x0, -0x20(%rbp)
je 0x1bfd9
jmp 0x1bff8
leaq 0x2ded7(%rip), %rdi     # 0x49eb7
leaq 0x2d915(%rip), %rsi     # 0x498fc
movl $0x4ef, %edx            # imm = 0x4EF
leaq 0x2de5e(%rip), %rcx     # 0x49e51
callq 0xa0b0
movq -0x20(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1c012
jmp 0x1c031
leaq 0x2d614(%rip), %rdi     # 0x4962d
leaq 0x2d8dc(%rip), %rsi     # 0x498fc
movl $0x4f2, %edx            # imm = 0x4F2
leaq 0x2de25(%rip), %rcx     # 0x49e51
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movzbl %al, %ecx
callq 0x1bd30
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1c081
jmp 0x1c0a0
leaq 0x31ad9(%rip), %rdi     # 0x4db61
leaq 0x2d86d(%rip), %rsi     # 0x498fc
movl $0x502, %edx            # imm = 0x502
leaq 0x2de26(%rip), %rcx     # 0x49ec1
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1c0a9
jmp 0x1c0c8
leaq 0x2da56(%rip), %rdi     # 0x49b06
leaq 0x2d845(%rip), %rsi     # 0x498fc
movl $0x503, %edx            # imm = 0x503
leaq 0x2ddfe(%rip), %rcx     # 0x49ec1
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x1c0d1
jmp 0x1c0f0
leaq 0x2da2a(%rip), %rdi     # 0x49b02
leaq 0x2d81d(%rip), %rsi     # 0x498fc
movl $0x504, %edx            # imm = 0x504
leaq 0x2ddd6(%rip), %rcx     # 0x49ec1
callq 0xa0b0
cmpq $0x0, -0x20(%rbp)
je 0x1c0f9
jmp 0x1c118
leaq 0x2ddb7(%rip), %rdi     # 0x49eb7
leaq 0x2d7f5(%rip), %rsi     # 0x498fc
movl $0x505, %edx            # imm = 0x505
leaq 0x2ddae(%rip), %rcx     # 0x49ec1
callq 0xa0b0
movq -0x20(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1c132
jmp 0x1c151
leaq 0x2d4f4(%rip), %rdi     # 0x4962d
leaq 0x2d7bc(%rip), %rsi     # 0x498fc
movl $0x508, %edx            # imm = 0x508
leaq 0x2dd75(%rip), %rcx     # 0x49ec1
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movzwl %ax, %ecx
callq 0x1be20
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1c1a1
jmp 0x1c1c0
leaq 0x319b9(%rip), %rdi     # 0x4db61
leaq 0x2d74d(%rip), %rsi     # 0x498fc
movl $0x518, %edx            # imm = 0x518
leaq 0x2dd6d(%rip), %rcx     # 0x49f28
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1c1c9
jmp 0x1c1e8
leaq 0x2d936(%rip), %rdi     # 0x49b06
leaq 0x2d725(%rip), %rsi     # 0x498fc
movl $0x519, %edx            # imm = 0x519
leaq 0x2dd45(%rip), %rcx     # 0x49f28
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x1c1f1
jmp 0x1c210
leaq 0x2d90a(%rip), %rdi     # 0x49b02
leaq 0x2d6fd(%rip), %rsi     # 0x498fc
movl $0x51a, %edx            # imm = 0x51A
leaq 0x2dd1d(%rip), %rcx     # 0x49f28
callq 0xa0b0
cmpq $0x0, -0x20(%rbp)
je 0x1c219
jmp 0x1c238
leaq 0x2dc97(%rip), %rdi     # 0x49eb7
leaq 0x2d6d5(%rip), %rsi     # 0x498fc
movl $0x51b, %edx            # imm = 0x51B
leaq 0x2dcf5(%rip), %rcx     # 0x49f28
callq 0xa0b0
movq -0x20(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1c252
jmp 0x1c271
leaq 0x2d3d4(%rip), %rdi     # 0x4962d
leaq 0x2d69c(%rip), %rsi     # 0x498fc
movl $0x51e, %edx            # imm = 0x51E
leaq 0x2dcbc(%rip), %rcx     # 0x49f28
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %ecx
callq 0x1be80
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1c2c1
jmp 0x1c2e0
leaq 0x31899(%rip), %rdi     # 0x4db61
leaq 0x2d62d(%rip), %rsi     # 0x498fc
movl $0x52e, %edx            # imm = 0x52E
leaq 0x2dcb4(%rip), %rcx     # 0x49f8f
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1c2e9
jmp 0x1c308
leaq 0x2d816(%rip), %rdi     # 0x49b06
leaq 0x2d605(%rip), %rsi     # 0x498fc
movl $0x52f, %edx            # imm = 0x52F
leaq 0x2dc8c(%rip), %rcx     # 0x49f8f
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x1c311
jmp 0x1c330
leaq 0x2d7ea(%rip), %rdi     # 0x49b02
leaq 0x2d5dd(%rip), %rsi     # 0x498fc
movl $0x530, %edx            # imm = 0x530
leaq 0x2dc64(%rip), %rcx     # 0x49f8f
callq 0xa0b0
cmpq $0x0, -0x20(%rbp)
je 0x1c339
jmp 0x1c358
leaq 0x2db77(%rip), %rdi     # 0x49eb7
leaq 0x2d5b5(%rip), %rsi     # 0x498fc
movl $0x531, %edx            # imm = 0x531
leaq 0x2dc3c(%rip), %rcx     # 0x49f8f
callq 0xa0b0
movq -0x20(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1c372
jmp 0x1c391
leaq 0x2d2b4(%rip), %rdi     # 0x4962d
leaq 0x2d57c(%rip), %rsi     # 0x498fc
movl $0x534, %edx            # imm = 0x534
leaq 0x2dc03(%rip), %rcx     # 0x49f8f
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
callq 0x1bee0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1c625
jmp 0x1c644
leaq 0x31535(%rip), %rdi     # 0x4db61
leaq 0x2d2c9(%rip), %rsi     # 0x498fc
movl $0x589, %edx            # imm = 0x589
leaq 0x2da25(%rip), %rcx     # 0x4a064
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1c64d
jmp 0x1c66c
leaq 0x2d4b2(%rip), %rdi     # 0x49b06
leaq 0x2d2a1(%rip), %rsi     # 0x498fc
movl $0x58a, %edx            # imm = 0x58A
leaq 0x2d9fd(%rip), %rcx     # 0x4a064
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x1c675
jmp 0x1c694
leaq 0x33976(%rip), %rdi     # 0x4fff2
leaq 0x2d279(%rip), %rsi     # 0x498fc
movl $0x58b, %edx            # imm = 0x58B
leaq 0x2d9d5(%rip), %rcx     # 0x4a064
callq 0xa0b0
cmpq $0x0, -0x20(%rbp)
je 0x1c69d
jmp 0x1c6bc
leaq 0x2bb69(%rip), %rdi     # 0x4820d
leaq 0x2d251(%rip), %rsi     # 0x498fc
movl $0x58c, %edx            # imm = 0x58C
leaq 0x2d9ad(%rip), %rcx     # 0x4a064
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c3b0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1c3b0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x1c701
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x2d9d4(%rip), %rdx     # 0x4a0d3
callq *%rax
cmpq $0x0, -0x28(%rbp)
je 0x1c73e
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1c3b0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x1c73c
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq 0x2d999(%rip), %rdx     # 0x4a0d3
callq *%rax
jmp 0x1c73e
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1c7b5
jmp 0x1c7d4
leaq 0x2a2b2(%rip), %rdi     # 0x46a6e
leaq 0x2d139(%rip), %rsi     # 0x498fc
movl $0x5b2, %edx            # imm = 0x5B2
leaq 0x2d980(%rip), %rcx     # 0x4a14f
callq 0xa0b0
leaq -0x18(%rbp), %rdi
callq 0x1a860
leaq -0x18(%rbp), %rdi
callq 0x1a8c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1c80d
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1c820
leaq -0x18(%rbp), %rdi
callq 0x1a8c0
movq %rax, -0x20(%rbp)
jmp 0x1c7ea
leaq -0x18(%rbp), %rdi
callq 0x1a980
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1ca39
jmp 0x1ca58
leaq 0x2d0c6(%rip), %rdi     # 0x49b06
leaq 0x2df0f(%rip), %rsi     # 0x4a956
movl $0x32, %edx
leaq 0x2dfde(%rip), %rcx     # 0x4aa31
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1ca61
jmp 0x1ca80
leaq 0x33587(%rip), %rdi     # 0x4ffef
leaq 0x2dee7(%rip), %rsi     # 0x4a956
movl $0x33, %edx
leaq 0x2dfb6(%rip), %rcx     # 0x4aa31
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x44(%rax)
jne 0x1ca8f
jmp 0x1caae
leaq 0x2dfd6(%rip), %rdi     # 0x4aa6c
leaq 0x2deb9(%rip), %rsi     # 0x4a956
movl $0x34, %edx
leaq 0x2df88(%rip), %rcx     # 0x4aa31
callq 0xa0b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xc0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xc0(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, 0xc8(%rax)
jne 0x1cadb
jmp 0x1cb4a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1cb07
jmp 0x1cb26
leaq 0x2cb1f(%rip), %rdi     # 0x4962d
leaq 0x2de41(%rip), %rsi     # 0x4a956
movl $0x3e, %edx
leaq 0x2df10(%rip), %rcx     # 0x4aa31
callq 0xa0b0
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xb8(%rax), %rcx
movl $0x1, %edx
movq %rdx, %rsi
callq 0xa190
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1cb69
jmp 0x1cb88
leaq 0x2cf96(%rip), %rdi     # 0x49b06
leaq 0x2dddf(%rip), %rsi     # 0x4a956
movl $0x47, %edx
leaq 0x2df06(%rip), %rcx     # 0x4aa89
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1cb91
jmp 0x1cbb0
leaq 0x33457(%rip), %rdi     # 0x4ffef
leaq 0x2ddb7(%rip), %rsi     # 0x4a956
movl $0x48, %edx
leaq 0x2dede(%rip), %rcx     # 0x4aa89
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x44(%rax)
jne 0x1cbbf
jmp 0x1cbde
leaq 0x2dea6(%rip), %rdi     # 0x4aa6c
leaq 0x2dd89(%rip), %rsi     # 0x4a956
movl $0x49, %edx
leaq 0x2deb0(%rip), %rcx     # 0x4aa89
callq 0xa0b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xc0(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0xc0(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, 0xc8(%rax)
jne 0x1cc0b
jmp 0x1cc7c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1cc37
jmp 0x1cc56
leaq 0x2c9ef(%rip), %rdi     # 0x4962d
leaq 0x2dd11(%rip), %rsi     # 0x4a956
movl $0x53, %edx
leaq 0x2de38(%rip), %rcx     # 0x4aa89
callq 0xa0b0
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xb8(%rax), %rcx
movl $0x2, %esi
movl $0x1, %edx
callq 0xa190
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1cca9
jmp 0x1ccc8
leaq 0x2ce56(%rip), %rdi     # 0x49b06
leaq 0x2dc9f(%rip), %rsi     # 0x4a956
movl $0x5c, %edx
leaq 0x2de02(%rip), %rcx     # 0x4aac5
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1ccd1
jmp 0x1ccf0
leaq 0x33317(%rip), %rdi     # 0x4ffef
leaq 0x2dc77(%rip), %rsi     # 0x4a956
movl $0x5d, %edx
leaq 0x2ddda(%rip), %rcx     # 0x4aac5
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x44(%rax)
jne 0x1ccff
jmp 0x1cd1e
leaq 0x2dd66(%rip), %rdi     # 0x4aa6c
leaq 0x2dc49(%rip), %rsi     # 0x4a956
movl $0x5e, %edx
leaq 0x2ddac(%rip), %rcx     # 0x4aac5
callq 0xa0b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xc0(%rax), %rcx
addq $0x4, %rcx
movq %rcx, 0xc0(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, 0xc8(%rax)
jne 0x1cd4b
jmp 0x1cdbc
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1cd77
jmp 0x1cd96
leaq 0x2c8af(%rip), %rdi     # 0x4962d
leaq 0x2dbd1(%rip), %rsi     # 0x4a956
movl $0x68, %edx
leaq 0x2dd34(%rip), %rcx     # 0x4aac5
callq 0xa0b0
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xb8(%rax), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0xa190
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1cde9
jmp 0x1ce08
leaq 0x2cd16(%rip), %rdi     # 0x49b06
leaq 0x2db5f(%rip), %rsi     # 0x4a956
movl $0x71, %edx
leaq 0x2dcfe(%rip), %rcx     # 0x4ab01
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1ce11
jmp 0x1ce30
leaq 0x331d7(%rip), %rdi     # 0x4ffef
leaq 0x2db37(%rip), %rsi     # 0x4a956
movl $0x72, %edx
leaq 0x2dcd6(%rip), %rcx     # 0x4ab01
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x44(%rax)
jne 0x1ce3f
jmp 0x1ce5e
leaq 0x2dc26(%rip), %rdi     # 0x4aa6c
leaq 0x2db09(%rip), %rsi     # 0x4a956
movl $0x73, %edx
leaq 0x2dca8(%rip), %rcx     # 0x4ab01
callq 0xa0b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xc0(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0xc0(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, 0xc8(%rax)
jne 0x1ce8b
jmp 0x1cefc
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1ceb7
jmp 0x1ced6
leaq 0x2c76f(%rip), %rdi     # 0x4962d
leaq 0x2da91(%rip), %rsi     # 0x4a956
movl $0x7d, %edx
leaq 0x2dc30(%rip), %rcx     # 0x4ab01
callq 0xa0b0
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xb8(%rax), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0xa190
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1cf29
jmp 0x1cf48
leaq 0x2cbd6(%rip), %rdi     # 0x49b06
leaq 0x2da1f(%rip), %rsi     # 0x4a956
movl $0x86, %edx
leaq 0x2dbfa(%rip), %rcx     # 0x4ab3d
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1cf51
jmp 0x1cf70
leaq 0x33097(%rip), %rdi     # 0x4ffef
leaq 0x2d9f7(%rip), %rsi     # 0x4a956
movl $0x87, %edx
leaq 0x2dbd2(%rip), %rcx     # 0x4ab3d
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x44(%rax)
jne 0x1cf7f
jmp 0x1cf9e
leaq 0x2dae6(%rip), %rdi     # 0x4aa6c
leaq 0x2d9c9(%rip), %rsi     # 0x4a956
movl $0x88, %edx
leaq 0x2dba4(%rip), %rcx     # 0x4ab3d
callq 0xa0b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xc0(%rax), %rcx
addq $0x4, %rcx
movq %rcx, 0xc0(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, 0xc8(%rax)
jne 0x1cfcb
jmp 0x1d04a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x2, %eax
jne 0x1cff7
jmp 0x1d016
leaq 0x2db7b(%rip), %rdi     # 0x4ab79
leaq 0x2d951(%rip), %rsi     # 0x4a956
movl $0x92, %edx
leaq 0x2db2c(%rip), %rcx     # 0x4ab3d
callq 0xa0b0
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xb8(%rax), %rcx
leaq -0x24(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0xa190
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1d069
jmp 0x1d088
leaq 0x2ca96(%rip), %rdi     # 0x49b06
leaq 0x2d8df(%rip), %rsi     # 0x4a956
movl $0x9d, %edx
leaq 0x2db27(%rip), %rcx     # 0x4abaa
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1d091
jmp 0x1d0b0
leaq 0x32f57(%rip), %rdi     # 0x4ffef
leaq 0x2d8b7(%rip), %rsi     # 0x4a956
movl $0x9e, %edx
leaq 0x2daff(%rip), %rcx     # 0x4abaa
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x44(%rax)
jne 0x1d0bf
jmp 0x1d0de
leaq 0x2d9a6(%rip), %rdi     # 0x4aa6c
leaq 0x2d889(%rip), %rsi     # 0x4a956
movl $0x9f, %edx
leaq 0x2dad1(%rip), %rcx     # 0x4abaa
callq 0xa0b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xc0(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0xc0(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, 0xc8(%rax)
jne 0x1d10b
jmp 0x1d17c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x2, %eax
jne 0x1d137
jmp 0x1d156
leaq 0x2da3b(%rip), %rdi     # 0x4ab79
leaq 0x2d811(%rip), %rsi     # 0x4a956
movl $0xa9, %edx
leaq 0x2da59(%rip), %rcx     # 0x4abaa
callq 0xa0b0
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xb8(%rax), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0xa190
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1d1a9
jmp 0x1d1c8
leaq 0x2c956(%rip), %rdi     # 0x49b06
leaq 0x2d79f(%rip), %rsi     # 0x4a956
movl $0xb2, %edx
leaq 0x2da24(%rip), %rcx     # 0x4abe7
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1d1d1
jmp 0x1d1f0
leaq 0x32e17(%rip), %rdi     # 0x4ffef
leaq 0x2d777(%rip), %rsi     # 0x4a956
movl $0xb3, %edx
leaq 0x2d9fc(%rip), %rcx     # 0x4abe7
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x44(%rax)
jne 0x1d1ff
jmp 0x1d21e
leaq 0x2d866(%rip), %rdi     # 0x4aa6c
leaq 0x2d749(%rip), %rsi     # 0x4a956
movl $0xb4, %edx
leaq 0x2d9ce(%rip), %rcx     # 0x4abe7
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x3, %eax
jne 0x1d24a
jmp 0x1d269
leaq 0x2d9d3(%rip), %rdi     # 0x4ac24
leaq 0x2d6fe(%rip), %rsi     # 0x4a956
movl $0xb9, %edx
leaq 0x2d983(%rip), %rcx     # 0x4abe7
callq 0xa0b0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq 0xc0(%rax), %rcx
movq %rcx, 0xc0(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, 0xc8(%rax)
jne 0x1d29a
jmp 0x1d2c3
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xb8(%rax), %rcx
movl $0x1, %edx
callq 0xa190
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1e169
jmp 0x1e188
leaq 0x2b996(%rip), %rdi     # 0x49b06
leaq 0x2c7df(%rip), %rsi     # 0x4a956
movl $0x1aa, %edx            # imm = 0x1AA
leaq 0x2cdb3(%rip), %rcx     # 0x4af36
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1e191
jmp 0x1e1b0
leaq 0x31e57(%rip), %rdi     # 0x4ffef
leaq 0x2c7b7(%rip), %rsi     # 0x4a956
movl $0x1ab, %edx            # imm = 0x1AB
leaq 0x2cd8b(%rip), %rcx     # 0x4af36
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x44(%rax)
jne 0x1e1bf
jmp 0x1e1de
leaq 0x2c8a6(%rip), %rdi     # 0x4aa6c
leaq 0x2c789(%rip), %rsi     # 0x4a956
movl $0x1ac, %edx            # imm = 0x1AC
leaq 0x2cd5d(%rip), %rcx     # 0x4af36
callq 0xa0b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, 0xc8(%rax)
jne 0x1e252
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x200, (%rax)          # imm = 0x200
jne 0x1e20f
jmp 0x1e22e
leaq 0x2cd5c(%rip), %rdi     # 0x4af72
leaq 0x2c739(%rip), %rsi     # 0x4a956
movl $0x1b0, %edx            # imm = 0x1B0
leaq 0x2cd0d(%rip), %rcx     # 0x4af36
callq 0xa0b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xc0(%rax), %rdx
callq 0x2a670
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1e279
jmp 0x1e298
leaq 0x2b886(%rip), %rdi     # 0x49b06
leaq 0x2c6cf(%rip), %rsi     # 0x4a956
movl $0x1bc, %edx            # imm = 0x1BC
leaq 0x2cd04(%rip), %rcx     # 0x4af97
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1e2a1
jmp 0x1e2c0
leaq 0x31d47(%rip), %rdi     # 0x4ffef
leaq 0x2c6a7(%rip), %rsi     # 0x4a956
movl $0x1bd, %edx            # imm = 0x1BD
leaq 0x2ccdc(%rip), %rcx     # 0x4af97
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x2, 0x44(%rax)
jne 0x1e2cf
jmp 0x1e2ee
leaq 0x2c9bb(%rip), %rdi     # 0x4ac91
leaq 0x2c679(%rip), %rsi     # 0x4a956
movl $0x1be, %edx            # imm = 0x1BE
leaq 0x2ccae(%rip), %rcx     # 0x4af97
callq 0xa0b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, 0xc8(%rax)
jne 0x1e304
jmp 0x1e3d9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x200, (%rax)          # imm = 0x200
jne 0x1e324
jmp 0x1e343
leaq 0x2cc47(%rip), %rdi     # 0x4af72
leaq 0x2c624(%rip), %rsi     # 0x4a956
movl $0x1c5, %edx            # imm = 0x1C5
leaq 0x2cc59(%rip), %rcx     # 0x4af97
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0xe00, (%rax)          # imm = 0xE00
jne 0x1e364
jmp 0x1e383
leaq 0x2c99c(%rip), %rdi     # 0x4ad07
leaq 0x2c5e4(%rip), %rsi     # 0x4a956
movl $0x1c8, %edx            # imm = 0x1C8
leaq 0x2cc19(%rip), %rcx     # 0x4af97
callq 0xa0b0
movq -0x20(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1e39d
jmp 0x1e3bc
leaq 0x2b289(%rip), %rdi     # 0x4962d
leaq 0x2c5ab(%rip), %rsi     # 0x4a956
movl $0x1cb, %edx            # imm = 0x1CB
leaq 0x2cbe0(%rip), %rcx     # 0x4af97
callq 0xa0b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x2a670
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1e3f9
jmp 0x1e418
leaq 0x2b706(%rip), %rdi     # 0x49b06
leaq 0x2c54f(%rip), %rsi     # 0x4a956
movl $0x1d6, %edx            # imm = 0x1D6
leaq 0x2cbbe(%rip), %rcx     # 0x4afd1
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1e421
jmp 0x1e440
leaq 0x31bc7(%rip), %rdi     # 0x4ffef
leaq 0x2c527(%rip), %rsi     # 0x4a956
movl $0x1d7, %edx            # imm = 0x1D7
leaq 0x2cb96(%rip), %rcx     # 0x4afd1
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x44(%rax)
jne 0x1e44f
jmp 0x1e46e
leaq 0x2c616(%rip), %rdi     # 0x4aa6c
leaq 0x2c4f9(%rip), %rsi     # 0x4a956
movl $0x1d8, %edx            # imm = 0x1D8
leaq 0x2cb68(%rip), %rcx     # 0x4afd1
callq 0xa0b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, 0xc8(%rax)
jne 0x1e484
jmp 0x1e564
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x1, %eax
je 0x1e4c7
jmp 0x1e4b3
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x1e4e7
jmp 0x1e4bd
movl -0x2c(%rbp), %eax
subl $0x3, %eax
je 0x1e500
jmp 0x1e545
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x2cb2f(%rip), %rdi     # 0x4b00d
movb $0x0, %al
callq 0xa090
jmp 0x1e564
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
leaq 0x2cb24(%rip), %rdi     # 0x4b01b
movb $0x1, %al
callq 0xa090
jmp 0x1e564
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x1e539
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0xa030
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1e508
movl $0xa, %edi
callq 0xa030
jmp 0x1e564
leaq 0x28f19(%rip), %rdi     # 0x47465
leaq 0x2c403(%rip), %rsi     # 0x4a956
movl $0x1f3, %edx            # imm = 0x1F3
leaq 0x2ca72(%rip), %rcx     # 0x4afd1
callq 0xa0b0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x20, %edx
callq 0x19210
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq 0xc0(%rax), %rcx
movq %rcx, 0xc0(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, 0xc8(%rax)
jne 0x1e5c3
jmp 0x1e5e4
leaq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xb8(%rax), %rcx
movl $0x1, %edx
callq 0xa190
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1e60c
jmp 0x1e62b
leaq 0x2b4f3(%rip), %rdi     # 0x49b06
leaq 0x2ca06(%rip), %rsi     # 0x4b020
movl $0x32, %edx
leaq 0x2ca17(%rip), %rcx     # 0x4b03d
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1e634
jmp 0x1e653
leaq 0x319b4(%rip), %rdi     # 0x4ffef
leaq 0x2c9de(%rip), %rsi     # 0x4b020
movl $0x32, %edx
leaq 0x2c9ef(%rip), %rcx     # 0x4b03d
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1e65f
jmp 0x1e67e
leaq 0x2ca17(%rip), %rdi     # 0x4b07d
leaq 0x2c9b3(%rip), %rsi     # 0x4b020
movl $0x32, %edx
leaq 0x2c9c4(%rip), %rcx     # 0x4b03d
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x2, 0x44(%rax)
jne 0x1e68d
jmp 0x1e6ac
leaq 0x2c9f8(%rip), %rdi     # 0x4b08c
leaq 0x2c985(%rip), %rsi     # 0x4b020
movl $0x32, %edx
leaq 0x2c996(%rip), %rcx     # 0x4b03d
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x1c600
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1a9e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1ad40
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1ab40
movq -0x10(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1e570
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1e78c
jmp 0x1e7ab
leaq 0x2b373(%rip), %rdi     # 0x49b06
leaq 0x2c886(%rip), %rsi     # 0x4b020
movl $0x4b, %edx
leaq 0x2c905(%rip), %rcx     # 0x4b0ab
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1e7b4
jmp 0x1e7d3
leaq 0x31834(%rip), %rdi     # 0x4ffef
leaq 0x2c85e(%rip), %rsi     # 0x4b020
movl $0x4b, %edx
leaq 0x2c8dd(%rip), %rcx     # 0x4b0ab
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1e7df
jmp 0x1e7fe
leaq 0x2c897(%rip), %rdi     # 0x4b07d
leaq 0x2c833(%rip), %rsi     # 0x4b020
movl $0x4b, %edx
leaq 0x2c8b2(%rip), %rcx     # 0x4b0ab
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x2, 0x44(%rax)
jne 0x1e80d
jmp 0x1e82c
leaq 0x2c878(%rip), %rdi     # 0x4b08c
leaq 0x2c805(%rip), %rsi     # 0x4b020
movl $0x4b, %edx
leaq 0x2c884(%rip), %rcx     # 0x4b0ab
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x1c600
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1a9e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1ad40
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1ab40
movq -0x10(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1e570
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1e90c
jmp 0x1e92b
leaq 0x2b1f3(%rip), %rdi     # 0x49b06
leaq 0x2c706(%rip), %rsi     # 0x4b020
movl $0x64, %edx
leaq 0x2c7c5(%rip), %rcx     # 0x4b0eb
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1e934
jmp 0x1e953
leaq 0x316b4(%rip), %rdi     # 0x4ffef
leaq 0x2c6de(%rip), %rsi     # 0x4b020
movl $0x64, %edx
leaq 0x2c79d(%rip), %rcx     # 0x4b0eb
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1e95f
jmp 0x1e97e
leaq 0x2c717(%rip), %rdi     # 0x4b07d
leaq 0x2c6b3(%rip), %rsi     # 0x4b020
movl $0x64, %edx
leaq 0x2c772(%rip), %rcx     # 0x4b0eb
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x2, 0x44(%rax)
jne 0x1e98d
jmp 0x1e9ac
leaq 0x2c6f8(%rip), %rdi     # 0x4b08c
leaq 0x2c685(%rip), %rsi     # 0x4b020
movl $0x64, %edx
leaq 0x2c744(%rip), %rcx     # 0x4b0eb
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x1c600
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1a9e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1ab40
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1ad40
movq -0x10(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1e570
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/assembler/ins_enc.c
// Function: ins_enc_XXX_Gv_Ev
void ins_enc_XXX_Gv_Ev(
	Instruction *ins,
	InstructionEncoderData *data
) {
	_CHECK_PARAMS(2);

	ParserASTNode *ins_node = data->ins_node;

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

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

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

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

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

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

	_output(data, &enc_ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1ea8c
jmp 0x1eaab
leaq 0x2b073(%rip), %rdi     # 0x49b06
leaq 0x2c586(%rip), %rsi     # 0x4b020
movl $0x7d, %edx
leaq 0x2c685(%rip), %rcx     # 0x4b12b
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1eab4
jmp 0x1ead3
leaq 0x31534(%rip), %rdi     # 0x4ffef
leaq 0x2c55e(%rip), %rsi     # 0x4b020
movl $0x7d, %edx
leaq 0x2c65d(%rip), %rcx     # 0x4b12b
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1eadf
jmp 0x1eafe
leaq 0x2c597(%rip), %rdi     # 0x4b07d
leaq 0x2c533(%rip), %rsi     # 0x4b020
movl $0x7d, %edx
leaq 0x2c632(%rip), %rcx     # 0x4b12b
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x2, 0x44(%rax)
jne 0x1eb0d
jmp 0x1eb2c
leaq 0x2c578(%rip), %rdi     # 0x4b08c
leaq 0x2c505(%rip), %rsi     # 0x4b020
movl $0x7d, %edx
leaq 0x2c604(%rip), %rcx     # 0x4b12b
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x1c600
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1a9e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1ab40
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1ad40
movq -0x10(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1e570
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)