LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/util.c
// Function: util_get_int64_bin_val
int64_t util_get_int64_bin_val(const char *str, uint32_t len) {
	assert(str && len > 0);

	if (*str == '+') {
		return (int64_t) util_get_uint64_bin_val(str + 1, len - 1);
	} else if (*str == '-') {
		return -(int64_t) util_get_uint64_bin_val(str + 1, len - 1);
	} else {
		return (int64_t) util_get_uint64_bin_val(str, len);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1075b
testl %esi, %esi
je 0x1075b
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x1074c
cmpl $0x2b, %eax
jne 0x10746
incq %rdi
decl %esi
popq %rbp
jmp 0x1066d
incq %rdi
decl %esi
callq 0x1066d
negq %rax
popq %rbp
retq
leaq 0x1de66(%rip), %rdi     # 0x2e5c8
leaq 0x1dce7(%rip), %rsi     # 0x2e450
leaq 0x1e110(%rip), %rcx     # 0x2e880
movl $0x1cd, %edx            # imm = 0x1CD
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/util.c
// Function: util_get_uint64_oct_val
uint64_t util_get_uint64_oct_val(const char *str, uint32_t len) {
	#define	_IS_OCT_DIGIT(chr)	((chr) >= '0' && (chr) <= '7')

	assert(str && len > 2 && str[0] == '0' && str[1] == 'o' && _IS_OCT_DIGIT(str[2]));

	const char *s = str + len - 1;
	str += 2;

	uint64_t v = 0;
	uint64_t base = 1;
	while (s >= str) {
		const char chr = *(s--);
		if (_IS_OCT_DIGIT(chr)) {
			v += (chr - '0') * base;
			base *= 8;
		} else if (chr == '_') {
			;
		} else if (chr == 'u') {
			continue;
		} else {
			assert(0);
		}
	}

	return v;

	#undef	_IS_OCT_DIGIT
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x10810
cmpl $0x3, %esi
jb 0x10810
cmpb $0x30, (%rdi)
jne 0x10810
cmpb $0x6f, 0x1(%rdi)
jne 0x10810
movb 0x2(%rdi), %al
andb $-0x8, %al
cmpb $0x30, %al
jne 0x10810
movl %esi, %ecx
pushq $0x1
popq %rdx
xorl %eax, %eax
cmpq $0x3, %rcx
jl 0x107ef
movzbl -0x1(%rdi,%rcx), %esi
movl %esi, %r8d
andb $-0x8, %r8b
cmpb $0x30, %r8b
je 0x107df
cmpq $0x75, %rsi
je 0x107da
cmpl $0x5f, %esi
jne 0x107f1
decq %rcx
jmp 0x107b7
andl $0x7, %esi
imulq %rdx, %rsi
addq %rsi, %rax
shlq $0x3, %rdx
jmp 0x107da
popq %rbp
retq
leaq 0x1cb78(%rip), %rdi     # 0x2d370
leaq 0x1dc51(%rip), %rsi     # 0x2e450
leaq 0x1e0fb(%rip), %rcx     # 0x2e901
movl $0x1f7, %edx            # imm = 0x1F7
callq 0xa0b0
leaq 0x1e0a0(%rip), %rdi     # 0x2e8b7
leaq 0x1dc32(%rip), %rsi     # 0x2e450
leaq 0x1e0dc(%rip), %rcx     # 0x2e901
movl $0x1e6, %edx            # imm = 0x1E6
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/util.c
// Function: uint_get_int64_oct_val
int64_t uint_get_int64_oct_val(const char *str, uint32_t len) {
	assert(str && len > 0);

	if (*str == '+') {
		return (int64_t) util_get_uint64_oct_val(str + 1, len - 1);
	} else if (*str == '-') {
		return -(int64_t) util_get_uint64_oct_val(str + 1, len - 1);
	} else {
		return (int64_t) util_get_uint64_oct_val(str, len);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x10877
testl %esi, %esi
je 0x10877
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x10868
cmpl $0x2b, %eax
jne 0x10862
incq %rdi
decl %esi
popq %rbp
jmp 0x1078e
incq %rdi
decl %esi
callq 0x1078e
negq %rax
popq %rbp
retq
leaq 0x1dd4a(%rip), %rdi     # 0x2e5c8
leaq 0x1dbcb(%rip), %rsi     # 0x2e450
leaq 0x1e0ae(%rip), %rcx     # 0x2e93a
movl $0x209, %edx            # imm = 0x209
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/util.c
// Function: util_get_uint64_dec_val
uint64_t util_get_uint64_dec_val(const char *str, uint32_t len) {
	#define	_IS_DEC_DIGIT(chr)	((chr) >= '0' && (chr) <= '9')

	assert(str && len > 0 && _IS_DEC_DIGIT(str[0]));

	const char *s = str + len - 1;

	uint64_t v = 0;
	uint64_t base = 1;
	while (s >= str) {
		const char chr = *(s--);
		if (_IS_DEC_DIGIT(chr)) {
			v += (chr - '0') * base;
			base *= 10;
		} else if (chr == '_') {
			;
		} else if (chr == 'u') {
			continue;
		} else {
			assert(0);
		}
	}

	return v;

	#undef	_IS_DEC_DIGIT
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1091c
testl %esi, %esi
je 0x1091c
movb (%rdi), %al
addb $-0x30, %al
cmpb $0xa, %al
jae 0x1091c
movl %esi, %ecx
addq %rdi, %rcx
pushq $0x1
popq %rdx
xorl %eax, %eax
decq %rcx
cmpq %rdi, %rcx
jb 0x108fb
movzbl (%rcx), %esi
leal -0x30(%rsi), %r8d
cmpb $0x9, %r8b
jbe 0x108eb
cmpq $0x75, %rsi
je 0x108c9
cmpl $0x5f, %esi
je 0x108c9
jmp 0x108fd
andl $0xf, %esi
imulq %rdx, %rsi
addq %rsi, %rax
imulq $0xa, %rdx, %rdx
jmp 0x108c9
popq %rbp
retq
leaq 0x1ca6c(%rip), %rdi     # 0x2d370
leaq 0x1db45(%rip), %rsi     # 0x2e450
leaq 0x1e087(%rip), %rcx     # 0x2e999
movl $0x232, %edx            # imm = 0x232
callq 0xa0b0
leaq 0x1e04e(%rip), %rdi     # 0x2e971
leaq 0x1db26(%rip), %rsi     # 0x2e450
leaq 0x1e068(%rip), %rcx     # 0x2e999
movl $0x222, %edx            # imm = 0x222
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/util.c
// Function: util_get_int64_dec_val
int64_t util_get_int64_dec_val(const char *str, uint32_t len) {
	assert(str && len > 0);

	if (*str == '+') {
		return (int64_t) util_get_uint64_dec_val(str + 1, len - 1);
	} else if (*str == '-') {
		return -(int64_t) util_get_uint64_dec_val(str + 1, len - 1);
	} else {
		return (int64_t) util_get_uint64_dec_val(str, len);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x10983
testl %esi, %esi
je 0x10983
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x10974
cmpl $0x2b, %eax
jne 0x1096e
incq %rdi
decl %esi
popq %rbp
jmp 0x108aa
incq %rdi
decl %esi
callq 0x108aa
negq %rax
popq %rbp
retq
leaq 0x1dc3e(%rip), %rdi     # 0x2e5c8
leaq 0x1dabf(%rip), %rsi     # 0x2e450
leaq 0x1e03a(%rip), %rcx     # 0x2e9d2
movl $0x244, %edx            # imm = 0x244
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/util.c
// Function: util_get_uint64_hex_val
uint64_t util_get_uint64_hex_val(const char *str, uint32_t len) {
	#define	_IS_HEX_DIGIT(chr)	(((chr) >= '0' && (chr) <= '9') || ((chr) >= 'a' && (chr) <= 'f') || ((chr) >= 'A' && (chr) <= 'F'))

	assert(str && len > 2 && str[0] == '0' && str[1] == 'x' && _IS_HEX_DIGIT(str[2]));

	const char *s = str + len - 1;
	str += 2;

	uint64_t v = 0;
	uint64_t base = 1;
	while (s >= str) {
		const char chr = *(s--);
		if (_IS_HEX_DIGIT(chr)) {
			if (chr >= '0' && chr <= '9') {
				v += (chr - '0') * base;
			} else if (chr >= 'a' && chr <= 'f') {
				v += (10 + (chr - 'a')) * base;
			} else {
				v += (10 + (chr - 'A')) * base;
			}
			base *= 16;
		} else if (chr == '_') {
			;
		} else if (chr == 'u') {
			continue;
		} else {
			assert(0);
		}
	}

	return v;

	#undef	_IS_HEX_DIGIT
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x10ab8
cmpl $0x3, %esi
jb 0x10ab8
cmpb $0x30, (%rdi)
jne 0x10ab8
cmpb $0x78, 0x1(%rdi)
jne 0x10ab8
movb 0x2(%rdi), %al
leal -0x30(%rax), %edx
movabsq $0x3f0000003f, %rcx     # imm = 0x3F0000003F
cmpb $0xa, %dl
jb 0x10a13
movzbl %al, %eax
addl $-0x41, %eax
cmpl $0x25, %eax
ja 0x10ab8
btq %rax, %rcx
jae 0x10ab8
movl $0xffffffa9, %edx       # imm = 0xFFFFFFA9
movl %esi, %esi
pushq $0x1
popq %r8
xorl %eax, %eax
leaq 0x27(%rdx), %r9
movabsq $0x10000040000000, %r10 # imm = 0x10000040000000
leaq 0x20(%rdx), %r11
cmpq $0x3, %rsi
jl 0x10a8e
movb -0x1(%rdi,%rsi), %r14b
leal -0x30(%r14), %r15d
movsbq %r14b, %rbx
cmpb $0xa, %r15b
jb 0x10a89
movzbl %r14b, %r15d
addl $-0x41, %r15d
cmpl $0x34, %r15d
ja 0x10a99
btq %r15, %r10
jae 0x10a64
decq %rsi
jmp 0x10a32
btq %r15, %rcx
jae 0x10a99
addb $-0x61, %r14b
cmpb $0x6, %r14b
movq %r11, %r14
cmovbq %rdx, %r14
addl %ebx, %r14d
imulq %r8, %r14
addq %r14, %rax
shlq $0x4, %r8
jmp 0x10a5f
movq %r9, %r14
jmp 0x10a79
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c8d0(%rip), %rdi     # 0x2d370
leaq 0x1d9a9(%rip), %rsi     # 0x2e450
leaq 0x1dfa5(%rip), %rcx     # 0x2ea53
movl $0x274, %edx            # imm = 0x274
callq 0xa0b0
leaq 0x1df4a(%rip), %rdi     # 0x2ea09
leaq 0x1d98a(%rip), %rsi     # 0x2e450
leaq 0x1df86(%rip), %rcx     # 0x2ea53
movl $0x25d, %edx            # imm = 0x25D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/util.c
// Function: util_get_int64_hex_val
int64_t util_get_int64_hex_val(const char *str, uint32_t len) {
	assert(str && len > 0);

	if (*str == '+') {
		return (int64_t) util_get_uint64_hex_val(str + 1, len - 1);
	} else if (*str == '-') {
		return -(int64_t) util_get_uint64_hex_val(str + 1, len - 1);
	} else {
		return (int64_t) util_get_uint64_hex_val(str, len);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x10b1f
testl %esi, %esi
je 0x10b1f
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x10b10
cmpl $0x2b, %eax
jne 0x10b0a
incq %rdi
decl %esi
popq %rbp
jmp 0x109b6
incq %rdi
decl %esi
callq 0x109b6
negq %rax
popq %rbp
retq
leaq 0x1daa2(%rip), %rdi     # 0x2e5c8
leaq 0x1d923(%rip), %rsi     # 0x2e450
leaq 0x1df58(%rip), %rcx     # 0x2ea8c
movl $0x286, %edx            # imm = 0x286
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/util.c
// Function: util_get_double_val
double util_get_double_val(const char *str, uint32_t len) {
	assert(str);
	assert(len > 0);

	double v = 0.0;
	double base = 1.0;

	#define	_GET_CHAR(idx)	((idx) >= len ? '\0' : str[(idx)])

	int idx = 0;
	
	while ((_GET_CHAR(idx) >= '0' && _GET_CHAR(idx) <= '9') || _GET_CHAR(idx) == '_') {
		if (_GET_CHAR(idx) == '_') {
			idx++;
			continue;
		}

		v *= 10.0;
		v += _GET_CHAR(idx) - '0';
		idx++;
	}

	if (_GET_CHAR(idx) == '.') {
		idx++;
	}

	base = 0.1;

	while ((_GET_CHAR(idx) >= '0' && _GET_CHAR(idx) <= '9') || _GET_CHAR(idx) == '_') {
		if (_GET_CHAR(idx) == '_') {
			idx++;
			continue;
		}

		v += (_GET_CHAR(idx) - '0') * base;
		base *= 0.1;
		idx++;
	}

	return v;

	#undef	_GET_CHAR
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x10c16
testl %esi, %esi
je 0x10c35
xorl %eax, %eax
xorpd %xmm0, %xmm0
movsd 0x1d8d3(%rip), %xmm1    # 0x2e448
movl %eax, %ecx
movslq %eax, %rdx
addq %rdi, %rdx
cmpl %esi, %ecx
jae 0x10bb6
movb (%rdx), %r8b
cmpb $0x30, %r8b
jl 0x10bbd
cmpb $0x3a, %r8b
jb 0x10b9d
incq %rdx
incl %ecx
cmpb $0x5f, %r8b
je 0x10b7d
jmp 0x10bca
movzbl %r8b, %eax
addl $-0x30, %eax
cvtsi2sd %eax, %xmm2
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
incl %ecx
movl %ecx, %eax
jmp 0x10b77
cmpl %esi, %eax
cmovbel %esi, %eax
jmp 0x10bce
xorl %eax, %eax
cmpb $0x2e, %r8b
sete %al
addl %ecx, %eax
jmp 0x10bce
decl %ecx
movl %ecx, %eax
movsd 0x1d86a(%rip), %xmm1    # 0x2e440
movapd %xmm1, %xmm2
movslq %eax, %rcx
addq %rdi, %rcx
cmpl %esi, %eax
jae 0x10c14
movsbl (%rcx), %edx
cmpl $0x30, %edx
jl 0x10c14
cmpb $0x3a, %dl
jb 0x10bfd
incq %rcx
incl %eax
cmpb $0x5f, %dl
je 0x10be0
jmp 0x10c14
addl $-0x30, %edx
cvtsi2sd %edx, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm0
mulsd %xmm1, %xmm2
incl %eax
jmp 0x10bda
popq %rbp
retq
leaq 0x1ce8e(%rip), %rdi     # 0x2daab
leaq 0x1d82c(%rip), %rsi     # 0x2e450
leaq 0x1de98(%rip), %rcx     # 0x2eac3
movl $0x29d, %edx            # imm = 0x29D
callq 0xa0b0
leaq 0x1d993(%rip), %rdi     # 0x2e5cf
leaq 0x1d80d(%rip), %rsi     # 0x2e450
leaq 0x1de79(%rip), %rcx     # 0x2eac3
movl $0x29e, %edx            # imm = 0x29E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/lexcmd.c
// Function: common_lexcmd_new_context
LexerContext * common_lexcmd_new_context(
	const char *file,
	const char *source,
	int len
) {
	assert(file);
	assert(source);
	assert(len >= 0);

	return lexer_new_context(file, source, len, _matchers);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x10c83
testq %rsi, %rsi
je 0x10ca2
testl %edx, %edx
js 0x10cc1
leaq 0x2d463(%rip), %rcx     # 0x3e0e0
popq %rbp
jmp 0xac5c
leaq 0x1bd7f(%rip), %rdi     # 0x2ca09
leaq 0x1ded7(%rip), %rsi     # 0x2eb68
leaq 0x1dee2(%rip), %rcx     # 0x2eb7a
movl $0xad, %edx
callq 0xa0b0
leaq 0x1b88d(%rip), %rdi     # 0x2c536
leaq 0x1deb8(%rip), %rsi     # 0x2eb68
leaq 0x1dec3(%rip), %rcx     # 0x2eb7a
movl $0xae, %edx
callq 0xa0b0
leaq 0x1b875(%rip), %rdi     # 0x2c53d
leaq 0x1de99(%rip), %rsi     # 0x2eb68
leaq 0x1dea4(%rip), %rcx     # 0x2eb7a
movl $0xaf, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/lexcmd.c
// Function: common_lexcmd_get_uint32_val
uint32_t common_lexcmd_get_uint32_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	switch (token->type) {
		case COMMON_LEXCMD_TOKEN_LITERAL_UINT_DEC: {
			return util_get_uint32_dec_val(token->content, token->len);
		}
		default: {
			assert(0);
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x10d2f
testq %rsi, %rsi
je 0x10d4e
cmpl $0x1000, (%rsi)         # imm = 0x1000
jne 0x10d6d
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x1093b
leaq 0x1e09e(%rip), %rdi     # 0x2edd4
leaq 0x1de2b(%rip), %rsi     # 0x2eb68
leaq 0x1deaf(%rip), %rcx     # 0x2ebf3
movl $0xbe, %edx
callq 0xa0b0
leaq 0x1b765(%rip), %rdi     # 0x2c4ba
leaq 0x1de0c(%rip), %rsi     # 0x2eb68
leaq 0x1de90(%rip), %rcx     # 0x2ebf3
movl $0xbf, %edx
callq 0xa0b0
leaq 0x1c5fc(%rip), %rdi     # 0x2d370
leaq 0x1dded(%rip), %rsi     # 0x2eb68
leaq 0x1de71(%rip), %rcx     # 0x2ebf3
movl $0xc6, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/enc.c
// Function: enc_encode
void enc_encode(
	ParserContext *ctx
) {
	assert(ctx);
	assert(ctx->ast);

	_encode(ctx, ASM_STEP_SCAN);

	ASM_PARSER_CONTEXT_DATA_SET_ADDRESS_COUNTER(ctx, 0);

	_encode(ctx, ASM_STEP_ENCODE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x11d56
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x11d75
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x11d94
andq $0x0, 0xc0(%rbx)
pushq $0x2
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x11d94
leaq 0x1d077(%rip), %rdi     # 0x2edd4
leaq 0x1d474(%rip), %rsi     # 0x2f1d8
leaq 0x1d486(%rip), %rcx     # 0x2f1f1
movl $0x523, %edx            # imm = 0x523
callq 0xa0b0
leaq 0x22c9b(%rip), %rdi     # 0x34a17
leaq 0x1d455(%rip), %rsi     # 0x2f1d8
leaq 0x1d467(%rip), %rcx     # 0x2f1f1
movl $0x524, %edx            # imm = 0x524
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/enc.c
// Function: eval_expr_wrapper
static void _eval_expr_wrapper(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == ASM_NODE_EXPR);
	assert(node->nchilds == 1);

	ParserASTNode *child = node->childs[0];

	_eval_expr(ctx, child, &ASM_EXPR_AST_NODE_GET_RESULT(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0x12e8d
movq %rsi, %rdx
cmpl $0xe00, (%rsi)          # imm = 0xE00
jne 0x12eac
cmpl $0x1, 0x44(%rdx)
jne 0x12ecb
movq 0x48(%rdx), %rax
movq (%rax), %rsi
addq $0x60, %rdx
popq %rbp
jmp 0x12eea
leaq 0x1de27(%rip), %rdi     # 0x30cbb
leaq 0x1c33d(%rip), %rsi     # 0x2f1d8
leaq 0x1c415(%rip), %rcx     # 0x2f2b7
movl $0x1a8, %edx            # imm = 0x1A8
callq 0xa0b0
leaq 0x1c43e(%rip), %rdi     # 0x2f2f1
leaq 0x1c31e(%rip), %rsi     # 0x2f1d8
leaq 0x1c3f6(%rip), %rcx     # 0x2f2b7
movl $0x1a9, %edx            # imm = 0x1A9
callq 0xa0b0
leaq 0x1d7d8(%rip), %rdi     # 0x306aa
leaq 0x1c2ff(%rip), %rsi     # 0x2f1d8
leaq 0x1c3d7(%rip), %rcx     # 0x2f2b7
movl $0x1aa, %edx            # imm = 0x1AA
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/enc.c
// Function: expect_integer
static void _expect_integer(
	ParserContext *ctx,
	ParserASTNode *node,
	AsmExprEvalResult *result
) {
	assert(ctx);
	assert(node);
	assert(result);

	_eval_expr(ctx, node, result);
	if (result->type != ASM_EXPR_EVAL_RESULT_TYPE_UINT64) {
		_SYNERR_NODE(ctx, node, "expect integer!");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
testq %rsi, %rsi
je 0x13aa6
movq %rdx, %r15
testq %rdx, %rdx
je 0x13abf
movq %rsi, %r14
movq %rdi, %rbx
movq %r15, %rdx
callq 0x12eea
cmpb $0x1, (%r15)
je 0x13a98
movups 0x1b935(%rip), %xmm0    # 0x2f3ba
leaq -0x420(%rbp), %rdx
movaps %xmm0, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq *0x58(%rbx)
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1d20e(%rip), %rdi     # 0x30cbb
leaq 0x1b724(%rip), %rsi     # 0x2f1d8
leaq 0x1b8b3(%rip), %rcx     # 0x2f36e
pushq $0x5c
jmp 0x13ad6
leaq 0x1b798(%rip), %rdi     # 0x2f25e
leaq 0x1b70b(%rip), %rsi     # 0x2f1d8
leaq 0x1b89a(%rip), %rcx     # 0x2f36e
pushq $0x5d
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_reg_iter_next
InsRegister * ins_reg_iter_next(
	InsRegisterIterator *iter
) {
	assert(iter);

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

	return iter->next++;
}

// Assembly:
testq %rdi, %rdi
je 0x14499
movq (%rdi), %rax
testq %rax, %rax
je 0x14496
cmpq $0x0, (%rax)
je 0x14496
leaq 0x18(%rax), %rcx
movq %rcx, (%rdi)
retq
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1a945(%rip), %rdi     # 0x2ede9
leaq 0x1b085(%rip), %rsi     # 0x2f530
leaq 0x1b0c5(%rip), %rcx     # 0x2f577
movl $0x23a, %edx            # imm = 0x23A
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_reg_get_by_name
InsRegister * ins_reg_get_by_name(
	const char *name
) {
	assert(name);

	InsRegister *ins_reg = NULL;

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

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

	return ins_reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x145a0
movq %rdi, %rbx
leaq 0x29c26(%rip), %r15     # 0x3e130
movq 0x29c1f(%rip), %rcx     # 0x3e130
testq %rcx, %rcx
leaq 0x29c2d(%rip), %rax     # 0x3e148
cmoveq %r15, %rax
cmoveq %rcx, %r15
xorl %r14d, %r14d
pushq $0x18
popq %r12
testq %r15, %r15
je 0x1456f
movq (%r15), %rdi
testq %rdi, %rdi
je 0x14581
movq %rax, %r13
movq %rbx, %rsi
callq 0xa0e0
testl %eax, %eax
cmoveq %r15, %r14
movl $0x0, %eax
movl $0x0, %r15d
testq %r13, %r13
je 0x1452a
movq (%r13), %r15
testq %r15, %r15
movq %r12, %rax
cmoveq %r15, %rax
cmovneq %r13, %r15
addq %r13, %rax
jmp 0x1452a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b082(%rip), %rdi     # 0x2f60a
leaq 0x1afa1(%rip), %rsi     # 0x2f530
leaq 0x1b045(%rip), %rcx     # 0x2f5db
movl $0x256, %edx            # imm = 0x256
callq 0xa0b0
leaq 0x1b068(%rip), %rdi     # 0x2f60f
leaq 0x1af82(%rip), %rsi     # 0x2f530
leaq 0x1b026(%rip), %rcx     # 0x2f5db
movl $0x24f, %edx            # imm = 0x24F
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_reg_get_by_id
InsRegister * ins_reg_get_by_id(
	int id
) {
	InsRegister *ins_reg = NULL;

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

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

	return ins_reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x29b66(%rip), %rcx     # 0x3e130
movq 0x29b5f(%rip), %rax     # 0x3e130
testq %rax, %rax
leaq 0x29b6d(%rip), %rsi     # 0x3e148
cmoveq %rcx, %rsi
cmoveq %rax, %rcx
xorl %eax, %eax
pushq $0x18
popq %rdx
testq %rcx, %rcx
je 0x14622
cmpq $0x0, (%rcx)
je 0x14624
movq %rsi, %r8
cmpl %edi, 0x8(%rcx)
cmoveq %rcx, %rax
movl $0x0, %esi
movl $0x0, %ecx
testq %r8, %r8
je 0x145e8
movq (%r8), %rcx
testq %rcx, %rcx
movq %rdx, %rsi
cmoveq %rcx, %rsi
cmovneq %r8, %rcx
addq %r8, %rsi
jmp 0x145e8
popq %rbp
retq
leaq 0x1afdf(%rip), %rdi     # 0x2f60a
leaq 0x1aefe(%rip), %rsi     # 0x2f530
leaq 0x1afdb(%rip), %rcx     # 0x2f614
movl $0x269, %edx            # imm = 0x269
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_iter_next
Instruction * ins_iter_next(
	InstructionIterator *iter
) {
	assert(iter);

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

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

	return iter->next++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x146c1
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x146b3
leaq 0x2960c(%rip), %rcx     # 0x3dca0
cmpq $0x0, (%rax)
jne 0x146b7
movq (%rdi), %rax
leaq 0x1(%rax), %rdx
movq %rdx, (%rdi)
movq 0x8(%rcx,%rax,8), %rax
movq %rax, 0x8(%rdi)
cmpq $0x7, %rdx
jne 0x14694
xorl %eax, %eax
jmp 0x146bf
leaq 0x28(%rax), %rcx
movq %rcx, 0x8(%rdi)
popq %rbp
retq
leaq 0x1a721(%rip), %rdi     # 0x2ede9
leaq 0x1ae61(%rip), %rsi     # 0x2f530
leaq 0x1af8c(%rip), %rcx     # 0x2f662
movl $0x295, %edx            # imm = 0x295
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_init
void ins_init(
	ParserContext *ctx,
	Instruction *ins,
	ParserASTNode *node,
	EncoderInstruction *enc_ins
) {
	assert(ctx);
	assert(ins);
	assert(node);
	assert(node->type == ASM_NODE_INSTRUCTION);
	assert(enc_ins);

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1476f
testq %rsi, %rsi
je 0x1478e
testq %rdx, %rdx
je 0x147ad
cmpl $0x400, (%rdx)          # imm = 0x400
jne 0x147cc
testq %rcx, %rcx
je 0x147eb
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rcx)
movups %xmm0, 0x40(%rcx)
movups %xmm0, 0x30(%rcx)
movups %xmm0, 0x20(%rcx)
movups %xmm0, 0x10(%rcx)
movups %xmm0, (%rcx)
movb 0xc(%rsi), %al
movb %al, 0x12(%rcx)
movb 0xd(%rsi), %al
movb %al, 0x13(%rcx)
movb 0xe(%rsi), %al
movb %al, 0x14(%rcx)
movb 0xf(%rsi), %al
movb %al, 0x15(%rcx)
popq %rbp
retq
leaq 0x1a65e(%rip), %rdi     # 0x2edd4
leaq 0x1adb3(%rip), %rsi     # 0x2f530
leaq 0x1af3a(%rip), %rcx     # 0x2f6be
movl $0x2b9, %edx            # imm = 0x2B9
callq 0xa0b0
leaq 0x1afa5(%rip), %rdi     # 0x2f73a
leaq 0x1ad94(%rip), %rsi     # 0x2f530
leaq 0x1af1b(%rip), %rcx     # 0x2f6be
movl $0x2ba, %edx            # imm = 0x2BA
callq 0xa0b0
leaq 0x1c507(%rip), %rdi     # 0x30cbb
leaq 0x1ad75(%rip), %rsi     # 0x2f530
leaq 0x1aefc(%rip), %rcx     # 0x2f6be
movl $0x2bb, %edx            # imm = 0x2BB
callq 0xa0b0
leaq 0x1af40(%rip), %rdi     # 0x2f713
leaq 0x1ad56(%rip), %rsi     # 0x2f530
leaq 0x1aedd(%rip), %rcx     # 0x2f6be
movl $0x2bc, %edx            # imm = 0x2BC
callq 0xa0b0
leaq 0x1af44(%rip), %rdi     # 0x2f736
leaq 0x1ad37(%rip), %rsi     # 0x2f530
leaq 0x1aebe(%rip), %rcx     # 0x2f6be
movl $0x2bd, %edx            # imm = 0x2BD
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_fill_GX
void ins_fill_GX(
	ParserContext *ctx,
	Instruction *ins,
	ParserASTNode *node,
	EncoderInstruction *enc_ins
) {
	assert(ctx);
	assert(ins);
	assert(node);
	assert(node->type == ASM_NODE_REG);
	assert(enc_ins);

	int arch = ASM_PARSER_CONTEXT_DATA_GET_ARCH(ctx);

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1488e
testq %rsi, %rsi
je 0x148ad
testq %rdx, %rdx
je 0x148cc
cmpl $0x500, (%rdx)          # imm = 0x500
jne 0x148eb
testq %rcx, %rcx
je 0x1490a
movq 0x60(%rdx), %rax
testq %rax, %rax
je 0x14929
movl 0xb0(%rdi), %edx
movl 0x10(%rax), %esi
movl %esi, %edi
andb $0x7, %dil
movb %dil, 0x18(%rcx)
testb $0x8, %sil
je 0x1486b
movb $0x1, %sil
movb %sil, 0xd(%rcx)
movb %sil, 0xf(%rcx)
cmpl $0x4, %edx
je 0x14882
cmpl $0x2, %edx
je 0x14882
cmpl $0x1, %edx
jne 0x1488c
cmpl $0x4, 0xc(%rax)
je 0x14888
jmp 0x1488c
cmpl $0x3, 0xc(%rax)
jne 0x1488c
movb $0x1, 0xb(%rcx)
popq %rbp
retq
leaq 0x1a53f(%rip), %rdi     # 0x2edd4
leaq 0x1ac94(%rip), %rsi     # 0x2f530
leaq 0x1ae9b(%rip), %rcx     # 0x2f73e
movl $0x2d4, %edx            # imm = 0x2D4
callq 0xa0b0
leaq 0x1ae86(%rip), %rdi     # 0x2f73a
leaq 0x1ac75(%rip), %rsi     # 0x2f530
leaq 0x1ae7c(%rip), %rcx     # 0x2f73e
movl $0x2d5, %edx            # imm = 0x2D5
callq 0xa0b0
leaq 0x1c3e8(%rip), %rdi     # 0x30cbb
leaq 0x1ac56(%rip), %rsi     # 0x2f530
leaq 0x1ae5d(%rip), %rcx     # 0x2f73e
movl $0x2d6, %edx            # imm = 0x2D6
callq 0xa0b0
leaq 0x1aea4(%rip), %rdi     # 0x2f796
leaq 0x1ac37(%rip), %rsi     # 0x2f530
leaq 0x1ae3e(%rip), %rcx     # 0x2f73e
movl $0x2d7, %edx            # imm = 0x2D7
callq 0xa0b0
leaq 0x1ae25(%rip), %rdi     # 0x2f736
leaq 0x1ac18(%rip), %rsi     # 0x2f530
leaq 0x1ae1f(%rip), %rcx     # 0x2f73e
movl $0x2d8, %edx            # imm = 0x2D8
callq 0xa0b0
leaq 0x1ae81(%rip), %rdi     # 0x2f7b1
leaq 0x1abf9(%rip), %rsi     # 0x2f530
leaq 0x1ae00(%rip), %rcx     # 0x2f73e
movl $0x2dd, %edx            # imm = 0x2DD
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_fill_RX
void ins_fill_RX(
	ParserContext *ctx,
	Instruction *ins,
	ParserASTNode *node,
	EncoderInstruction *enc_ins
) {
	assert(ctx);
	assert(ins);
	assert(node);
	assert(enc_ins);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x14fa2
testq %rsi, %rsi
je 0x14fc1
testq %rdx, %rdx
je 0x14fe0
testq %rcx, %rcx
je 0x14fff
cmpl $0x500, (%rdx)          # imm = 0x500
jne 0x1501e
popq %rbp
jmp 0x14948
leaq 0x19e2b(%rip), %rdi     # 0x2edd4
leaq 0x1a580(%rip), %rsi     # 0x2f530
leaq 0x1a85a(%rip), %rcx     # 0x2f811
movl $0x428, %edx            # imm = 0x428
callq 0xa0b0
leaq 0x1a772(%rip), %rdi     # 0x2f73a
leaq 0x1a561(%rip), %rsi     # 0x2f530
leaq 0x1a83b(%rip), %rcx     # 0x2f811
movl $0x429, %edx            # imm = 0x429
callq 0xa0b0
leaq 0x1bcd4(%rip), %rdi     # 0x30cbb
leaq 0x1a542(%rip), %rsi     # 0x2f530
leaq 0x1a81c(%rip), %rcx     # 0x2f811
movl $0x42a, %edx            # imm = 0x42A
callq 0xa0b0
leaq 0x1a730(%rip), %rdi     # 0x2f736
leaq 0x1a523(%rip), %rsi     # 0x2f530
leaq 0x1a7fd(%rip), %rcx     # 0x2f811
movl $0x42b, %edx            # imm = 0x42B
callq 0xa0b0
leaq 0x1834b(%rip), %rdi     # 0x2d370
leaq 0x1a504(%rip), %rsi     # 0x2f530
leaq 0x1a7de(%rip), %rcx     # 0x2f811
movl $0x42e, %edx            # imm = 0x42E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_fill_MX
void ins_fill_MX(
	ParserContext *ctx,
	Instruction *ins,
	ParserASTNode *node,
	EncoderInstruction *enc_ins
) {
	assert(ctx);
	assert(ins);
	assert(node);
	assert(enc_ins);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x15067
testq %rsi, %rsi
je 0x15086
testq %rdx, %rdx
je 0x150a5
testq %rcx, %rcx
je 0x150c4
cmpl $0x600, (%rdx)          # imm = 0x600
jne 0x150e3
popq %rbp
jmp 0x14948
leaq 0x19d66(%rip), %rdi     # 0x2edd4
leaq 0x1a4bb(%rip), %rsi     # 0x2f530
leaq 0x1a7ed(%rip), %rcx     # 0x2f869
movl $0x43f, %edx            # imm = 0x43F
callq 0xa0b0
leaq 0x1a6ad(%rip), %rdi     # 0x2f73a
leaq 0x1a49c(%rip), %rsi     # 0x2f530
leaq 0x1a7ce(%rip), %rcx     # 0x2f869
movl $0x440, %edx            # imm = 0x440
callq 0xa0b0
leaq 0x1bc0f(%rip), %rdi     # 0x30cbb
leaq 0x1a47d(%rip), %rsi     # 0x2f530
leaq 0x1a7af(%rip), %rcx     # 0x2f869
movl $0x441, %edx            # imm = 0x441
callq 0xa0b0
leaq 0x1a66b(%rip), %rdi     # 0x2f736
leaq 0x1a45e(%rip), %rsi     # 0x2f530
leaq 0x1a790(%rip), %rcx     # 0x2f869
movl $0x442, %edx            # imm = 0x442
callq 0xa0b0
leaq 0x18286(%rip), %rdi     # 0x2d370
leaq 0x1a43f(%rip), %rsi     # 0x2f530
leaq 0x1a771(%rip), %rcx     # 0x2f869
movl $0x445, %edx            # imm = 0x445
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_fill_imm8
void ins_fill_imm8(
	ParserContext *ctx,
	Instruction *ins,
	ParserASTNode *node,
	EncoderInstruction *enc_ins
) {
	assert(ctx);
	assert(ins);
	assert(node);
	assert(node->type == ASM_NODE_EXPR);
	assert(enc_ins);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1513e
testq %rsi, %rsi
je 0x1515d
testq %rdx, %rdx
je 0x1517c
cmpl $0xe00, (%rdx)          # imm = 0xE00
jne 0x1519b
testq %rcx, %rcx
je 0x151ba
cmpb $0x1, 0x60(%rdx)
jne 0x151d9
movb $0x1, 0x28(%rcx)
movzbl 0x68(%rdx), %eax
movq %rax, 0x30(%rcx)
popq %rbp
retq
leaq 0x19c8f(%rip), %rdi     # 0x2edd4
leaq 0x1a3e4(%rip), %rsi     # 0x2f530
leaq 0x1a76e(%rip), %rcx     # 0x2f8c1
movl $0x456, %edx            # imm = 0x456
callq 0xa0b0
leaq 0x1a5d6(%rip), %rdi     # 0x2f73a
leaq 0x1a3c5(%rip), %rsi     # 0x2f530
leaq 0x1a74f(%rip), %rcx     # 0x2f8c1
movl $0x457, %edx            # imm = 0x457
callq 0xa0b0
leaq 0x1bb38(%rip), %rdi     # 0x30cbb
leaq 0x1a3a6(%rip), %rsi     # 0x2f530
leaq 0x1a730(%rip), %rcx     # 0x2f8c1
movl $0x458, %edx            # imm = 0x458
callq 0xa0b0
leaq 0x1a14f(%rip), %rdi     # 0x2f2f1
leaq 0x1a387(%rip), %rsi     # 0x2f530
leaq 0x1a711(%rip), %rcx     # 0x2f8c1
movl $0x459, %edx            # imm = 0x459
callq 0xa0b0
leaq 0x1a575(%rip), %rdi     # 0x2f736
leaq 0x1a368(%rip), %rsi     # 0x2f530
leaq 0x1a6f2(%rip), %rcx     # 0x2f8c1
movl $0x45a, %edx            # imm = 0x45A
callq 0xa0b0
leaq 0x1a085(%rip), %rdi     # 0x2f265
leaq 0x1a349(%rip), %rsi     # 0x2f530
leaq 0x1a6d3(%rip), %rcx     # 0x2f8c1
movl $0x45d, %edx            # imm = 0x45D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_fill_imm16
void ins_fill_imm16(
	ParserContext *ctx,
	Instruction *ins,
	ParserASTNode *node,
	EncoderInstruction *enc_ins
) {
	assert(ctx);
	assert(ins);
	assert(node);
	assert(node->type == ASM_NODE_EXPR);
	assert(enc_ins);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x15234
testq %rsi, %rsi
je 0x15253
testq %rdx, %rdx
je 0x15272
cmpl $0xe00, (%rdx)          # imm = 0xE00
jne 0x15291
testq %rcx, %rcx
je 0x152b0
cmpb $0x1, 0x60(%rdx)
jne 0x152cf
movb $0x2, 0x28(%rcx)
movzwl 0x68(%rdx), %eax
movq %rax, 0x30(%rcx)
popq %rbp
retq
leaq 0x19b99(%rip), %rdi     # 0x2edd4
leaq 0x1a2ee(%rip), %rsi     # 0x2f530
leaq 0x1a6d2(%rip), %rcx     # 0x2f91b
movl $0x469, %edx            # imm = 0x469
callq 0xa0b0
leaq 0x1a4e0(%rip), %rdi     # 0x2f73a
leaq 0x1a2cf(%rip), %rsi     # 0x2f530
leaq 0x1a6b3(%rip), %rcx     # 0x2f91b
movl $0x46a, %edx            # imm = 0x46A
callq 0xa0b0
leaq 0x1ba42(%rip), %rdi     # 0x30cbb
leaq 0x1a2b0(%rip), %rsi     # 0x2f530
leaq 0x1a694(%rip), %rcx     # 0x2f91b
movl $0x46b, %edx            # imm = 0x46B
callq 0xa0b0
leaq 0x1a059(%rip), %rdi     # 0x2f2f1
leaq 0x1a291(%rip), %rsi     # 0x2f530
leaq 0x1a675(%rip), %rcx     # 0x2f91b
movl $0x46c, %edx            # imm = 0x46C
callq 0xa0b0
leaq 0x1a47f(%rip), %rdi     # 0x2f736
leaq 0x1a272(%rip), %rsi     # 0x2f530
leaq 0x1a656(%rip), %rcx     # 0x2f91b
movl $0x46d, %edx            # imm = 0x46D
callq 0xa0b0
leaq 0x19f8f(%rip), %rdi     # 0x2f265
leaq 0x1a253(%rip), %rsi     # 0x2f530
leaq 0x1a637(%rip), %rcx     # 0x2f91b
movl $0x470, %edx            # imm = 0x470
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_fill_imm32
void ins_fill_imm32(
	ParserContext *ctx,
	Instruction *ins,
	ParserASTNode *node,
	EncoderInstruction *enc_ins
) {
	assert(ctx);
	assert(ins);
	assert(node);
	assert(node->type == ASM_NODE_EXPR);
	assert(enc_ins);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x15329
testq %rsi, %rsi
je 0x15348
testq %rdx, %rdx
je 0x15367
cmpl $0xe00, (%rdx)          # imm = 0xE00
jne 0x15386
testq %rcx, %rcx
je 0x153a5
cmpb $0x1, 0x60(%rdx)
jne 0x153c4
movb $0x4, 0x28(%rcx)
movl 0x68(%rdx), %eax
movq %rax, 0x30(%rcx)
popq %rbp
retq
leaq 0x19aa4(%rip), %rdi     # 0x2edd4
leaq 0x1a1f9(%rip), %rsi     # 0x2f530
leaq 0x1a638(%rip), %rcx     # 0x2f976
movl $0x47c, %edx            # imm = 0x47C
callq 0xa0b0
leaq 0x1a3eb(%rip), %rdi     # 0x2f73a
leaq 0x1a1da(%rip), %rsi     # 0x2f530
leaq 0x1a619(%rip), %rcx     # 0x2f976
movl $0x47d, %edx            # imm = 0x47D
callq 0xa0b0
leaq 0x1b94d(%rip), %rdi     # 0x30cbb
leaq 0x1a1bb(%rip), %rsi     # 0x2f530
leaq 0x1a5fa(%rip), %rcx     # 0x2f976
movl $0x47e, %edx            # imm = 0x47E
callq 0xa0b0
leaq 0x19f64(%rip), %rdi     # 0x2f2f1
leaq 0x1a19c(%rip), %rsi     # 0x2f530
leaq 0x1a5db(%rip), %rcx     # 0x2f976
movl $0x47f, %edx            # imm = 0x47F
callq 0xa0b0
leaq 0x1a38a(%rip), %rdi     # 0x2f736
leaq 0x1a17d(%rip), %rsi     # 0x2f530
leaq 0x1a5bc(%rip), %rcx     # 0x2f976
movl $0x480, %edx            # imm = 0x480
callq 0xa0b0
leaq 0x19e9a(%rip), %rdi     # 0x2f265
leaq 0x1a15e(%rip), %rsi     # 0x2f530
leaq 0x1a59d(%rip), %rcx     # 0x2f976
movl $0x483, %edx            # imm = 0x483
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_fill_imm64
void ins_fill_imm64(
	ParserContext *ctx,
	Instruction *ins,
	ParserASTNode *node,
	EncoderInstruction *enc_ins
) {
	assert(ctx);
	assert(ins);
	assert(node);
	assert(node->type == ASM_NODE_EXPR);
	assert(enc_ins);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1541f
testq %rsi, %rsi
je 0x1543e
testq %rdx, %rdx
je 0x1545d
cmpl $0xe00, (%rdx)          # imm = 0xE00
jne 0x1547c
testq %rcx, %rcx
je 0x1549b
cmpb $0x1, 0x60(%rdx)
jne 0x154ba
movb $0x4, 0x28(%rcx)
movq 0x68(%rdx), %rax
movq %rax, 0x30(%rcx)
popq %rbp
retq
leaq 0x199ae(%rip), %rdi     # 0x2edd4
leaq 0x1a103(%rip), %rsi     # 0x2f530
leaq 0x1a59d(%rip), %rcx     # 0x2f9d1
movl $0x48f, %edx            # imm = 0x48F
callq 0xa0b0
leaq 0x1a2f5(%rip), %rdi     # 0x2f73a
leaq 0x1a0e4(%rip), %rsi     # 0x2f530
leaq 0x1a57e(%rip), %rcx     # 0x2f9d1
movl $0x490, %edx            # imm = 0x490
callq 0xa0b0
leaq 0x1b857(%rip), %rdi     # 0x30cbb
leaq 0x1a0c5(%rip), %rsi     # 0x2f530
leaq 0x1a55f(%rip), %rcx     # 0x2f9d1
movl $0x491, %edx            # imm = 0x491
callq 0xa0b0
leaq 0x19e6e(%rip), %rdi     # 0x2f2f1
leaq 0x1a0a6(%rip), %rsi     # 0x2f530
leaq 0x1a540(%rip), %rcx     # 0x2f9d1
movl $0x492, %edx            # imm = 0x492
callq 0xa0b0
leaq 0x1a294(%rip), %rdi     # 0x2f736
leaq 0x1a087(%rip), %rsi     # 0x2f530
leaq 0x1a521(%rip), %rcx     # 0x2f9d1
movl $0x493, %edx            # imm = 0x493
callq 0xa0b0
leaq 0x19da4(%rip), %rdi     # 0x2f265
leaq 0x1a068(%rip), %rsi     # 0x2f530
leaq 0x1a502(%rip), %rcx     # 0x2f9d1
movl $0x496, %edx            # imm = 0x496
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_add_uint8_to_ext
void ins_add_uint8_to_ext(
	ParserContext *ctx,
	Instruction *ins,
	EncoderInstruction *enc_ins,
	uint8_t value
) {
	assert(ctx);
	assert(ins);
	assert(enc_ins);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x15503
testq %rsi, %rsi
je 0x15522
testq %rdx, %rdx
je 0x15541
movzbl 0x38(%rdx), %eax
cmpq $0x20, %rax
jae 0x15560
leal 0x1(%rax), %esi
movb %sil, 0x38(%rdx)
movb %cl, 0x39(%rdx,%rax)
popq %rbp
retq
leaq 0x198ca(%rip), %rdi     # 0x2edd4
leaq 0x1a01f(%rip), %rsi     # 0x2f530
leaq 0x1a514(%rip), %rcx     # 0x2fa2c
movl $0x4a5, %edx            # imm = 0x4A5
callq 0xa0b0
leaq 0x1a211(%rip), %rdi     # 0x2f73a
leaq 0x1a000(%rip), %rsi     # 0x2f530
leaq 0x1a4f5(%rip), %rcx     # 0x2fa2c
movl $0x4a6, %edx            # imm = 0x4A6
callq 0xa0b0
leaq 0x1a1ee(%rip), %rdi     # 0x2f736
leaq 0x19fe1(%rip), %rsi     # 0x2f530
leaq 0x1a4d6(%rip), %rcx     # 0x2fa2c
movl $0x4a7, %edx            # imm = 0x4A7
callq 0xa0b0
leaq 0x17e09(%rip), %rdi     # 0x2d370
leaq 0x19fc2(%rip), %rsi     # 0x2f530
leaq 0x1a4b7(%rip), %rcx     # 0x2fa2c
movl $0x4aa, %edx            # imm = 0x4AA
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_add_uint16_to_ext
void ins_add_uint16_to_ext(
	ParserContext *ctx,
	Instruction *ins,
	EncoderInstruction *enc_ins,
	uint16_t value
) {
	for (int i = 0; i < 2; i++) {
		ins_add_uint8_to_ext(
			ctx,
			ins,
			enc_ins,
			(uint8_t) value
		);

		value >>= 8;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x2
popq %r13
subl $0x1, %r13d
jb 0x155bb
movzwl %bx, %ebx
movzbl %bl, %ecx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x154d9
shrl $0x8, %ebx
jmp 0x1559c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x4
popq %r13
subl $0x1, %r13d
jb 0x15603
movzbl %bl, %ecx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x154d9
shrl $0x8, %ebx
jmp 0x155e7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x8
popq %r13
subl $0x1, %r13d
jb 0x1564d
movzbl %bl, %ecx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x154d9
shrq $0x8, %rbx
jmp 0x15630
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x15688
testq %rsi, %rsi
je 0x156a7
testq %rdx, %rdx
je 0x156c6
testq %rcx, %rcx
je 0x156e5
cmpb $0x1, 0x60(%rcx)
jne 0x15704
movzbl 0x68(%rcx), %ecx
popq %rbp
jmp 0x154d9
leaq 0x19745(%rip), %rdi     # 0x2edd4
leaq 0x19e9a(%rip), %rsi     # 0x2f530
leaq 0x1a3e8(%rip), %rcx     # 0x2fa85
movl $0x4ec, %edx            # imm = 0x4EC
callq 0xa0b0
leaq 0x1a08c(%rip), %rdi     # 0x2f73a
leaq 0x19e7b(%rip), %rsi     # 0x2f530
leaq 0x1a3c9(%rip), %rcx     # 0x2fa85
movl $0x4ed, %edx            # imm = 0x4ED
callq 0xa0b0
leaq 0x1a069(%rip), %rdi     # 0x2f736
leaq 0x19e5c(%rip), %rsi     # 0x2f530
leaq 0x1a3aa(%rip), %rcx     # 0x2fa85
movl $0x4ee, %edx            # imm = 0x4EE
callq 0xa0b0
leaq 0x1a3ff(%rip), %rdi     # 0x2faeb
leaq 0x19e3d(%rip), %rsi     # 0x2f530
leaq 0x1a38b(%rip), %rcx     # 0x2fa85
movl $0x4ef, %edx            # imm = 0x4EF
callq 0xa0b0
leaq 0x19b5a(%rip), %rdi     # 0x2f265
leaq 0x19e1e(%rip), %rsi     # 0x2f530
leaq 0x1a36c(%rip), %rcx     # 0x2fa85
movl $0x4f2, %edx            # imm = 0x4F2
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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
testq %rdi, %rdi
je 0x1574f
testq %rsi, %rsi
je 0x1576e
testq %rdx, %rdx
je 0x1578d
testq %rcx, %rcx
je 0x157ac
cmpb $0x1, 0x60(%rcx)
jne 0x157cb
movzwl 0x68(%rcx), %ecx
popq %rbp
jmp 0x1557f
leaq 0x1967e(%rip), %rdi     # 0x2edd4
leaq 0x19dd3(%rip), %rsi     # 0x2f530
leaq 0x1a391(%rip), %rcx     # 0x2faf5
movl $0x502, %edx            # imm = 0x502
callq 0xa0b0
leaq 0x19fc5(%rip), %rdi     # 0x2f73a
leaq 0x19db4(%rip), %rsi     # 0x2f530
leaq 0x1a372(%rip), %rcx     # 0x2faf5
movl $0x503, %edx            # imm = 0x503
callq 0xa0b0
leaq 0x19fa2(%rip), %rdi     # 0x2f736
leaq 0x19d95(%rip), %rsi     # 0x2f530
leaq 0x1a353(%rip), %rcx     # 0x2faf5
movl $0x504, %edx            # imm = 0x504
callq 0xa0b0
leaq 0x1a338(%rip), %rdi     # 0x2faeb
leaq 0x19d76(%rip), %rsi     # 0x2f530
leaq 0x1a334(%rip), %rcx     # 0x2faf5
movl $0x505, %edx            # imm = 0x505
callq 0xa0b0
leaq 0x19a93(%rip), %rdi     # 0x2f265
leaq 0x19d57(%rip), %rsi     # 0x2f530
leaq 0x1a315(%rip), %rcx     # 0x2faf5
movl $0x508, %edx            # imm = 0x508
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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
testq %rdi, %rdi
je 0x15815
testq %rsi, %rsi
je 0x15834
testq %rdx, %rdx
je 0x15853
testq %rcx, %rcx
je 0x15872
cmpb $0x1, 0x60(%rcx)
jne 0x15891
movl 0x68(%rcx), %ecx
popq %rbp
jmp 0x155ca
leaq 0x195b8(%rip), %rdi     # 0x2edd4
leaq 0x19d0d(%rip), %rsi     # 0x2f530
leaq 0x1a332(%rip), %rcx     # 0x2fb5c
movl $0x518, %edx            # imm = 0x518
callq 0xa0b0
leaq 0x19eff(%rip), %rdi     # 0x2f73a
leaq 0x19cee(%rip), %rsi     # 0x2f530
leaq 0x1a313(%rip), %rcx     # 0x2fb5c
movl $0x519, %edx            # imm = 0x519
callq 0xa0b0
leaq 0x19edc(%rip), %rdi     # 0x2f736
leaq 0x19ccf(%rip), %rsi     # 0x2f530
leaq 0x1a2f4(%rip), %rcx     # 0x2fb5c
movl $0x51a, %edx            # imm = 0x51A
callq 0xa0b0
leaq 0x1a272(%rip), %rdi     # 0x2faeb
leaq 0x19cb0(%rip), %rsi     # 0x2f530
leaq 0x1a2d5(%rip), %rcx     # 0x2fb5c
movl $0x51b, %edx            # imm = 0x51B
callq 0xa0b0
leaq 0x199cd(%rip), %rdi     # 0x2f265
leaq 0x19c91(%rip), %rsi     # 0x2f530
leaq 0x1a2b6(%rip), %rcx     # 0x2fb5c
movl $0x51e, %edx            # imm = 0x51E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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
testq %rdi, %rdi
je 0x158dc
testq %rsi, %rsi
je 0x158fb
testq %rdx, %rdx
je 0x1591a
testq %rcx, %rcx
je 0x15939
cmpb $0x1, 0x60(%rcx)
jne 0x15958
movq 0x68(%rcx), %rcx
popq %rbp
jmp 0x15612
leaq 0x194f1(%rip), %rdi     # 0x2edd4
leaq 0x19c46(%rip), %rsi     # 0x2f530
leaq 0x1a2d2(%rip), %rcx     # 0x2fbc3
movl $0x52e, %edx            # imm = 0x52E
callq 0xa0b0
leaq 0x19e38(%rip), %rdi     # 0x2f73a
leaq 0x19c27(%rip), %rsi     # 0x2f530
leaq 0x1a2b3(%rip), %rcx     # 0x2fbc3
movl $0x52f, %edx            # imm = 0x52F
callq 0xa0b0
leaq 0x19e15(%rip), %rdi     # 0x2f736
leaq 0x19c08(%rip), %rsi     # 0x2f530
leaq 0x1a294(%rip), %rcx     # 0x2fbc3
movl $0x530, %edx            # imm = 0x530
callq 0xa0b0
leaq 0x1a1ab(%rip), %rdi     # 0x2faeb
leaq 0x19be9(%rip), %rsi     # 0x2f530
leaq 0x1a275(%rip), %rcx     # 0x2fbc3
movl $0x531, %edx            # imm = 0x531
callq 0xa0b0
leaq 0x19906(%rip), %rdi     # 0x2f265
leaq 0x19bca(%rip), %rsi     # 0x2f530
leaq 0x1a256(%rip), %rcx     # 0x2fbc3
movl $0x534, %edx            # imm = 0x534
callq 0xa0b0