LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/util.c
// Function: util_get_uint64_char_val
uint64_t util_get_uint64_char_val(const char *str, uint32_t len) {
	assert(str);
	
	if (!util_is_literal_char(str, len)) {
		assert(0);
		return UINT64_MAX;
	}

	if (len == 3) {
		return str[1];
	} else if (len == 4) {
		char chr = util_unescape(str[2]);
		if (chr == -1) {
			assert(0);
			return UINT64_MAX;
		}
		return chr;
	}

	assert(0);
	return UINT64_MAX;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13608
jmp 0x13627
leaq 0x3457b(%rip), %rdi     # 0x47b8a
leaq 0x34f2a(%rip), %rsi     # 0x48540
movl $0x173, %edx            # imm = 0x173
leaq 0x3520c(%rip), %rcx     # 0x4882e
callq 0xa0b0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x12d80
testb $0x1, %al
jne 0x13656
leaq 0x33e27(%rip), %rdi     # 0x47465
leaq 0x34efb(%rip), %rsi     # 0x48540
movl $0x176, %edx            # imm = 0x176
leaq 0x351dd(%rip), %rcx     # 0x4882e
callq 0xa0b0
cmpl $0x3, -0x14(%rbp)
jne 0x1366b
movq -0x10(%rbp), %rax
movsbq 0x1(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x136d5
cmpl $0x4, -0x14(%rbp)
jne 0x136b4
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %edi
callq 0x12d10
movb %al, -0x15(%rbp)
movsbl -0x15(%rbp), %eax
cmpl $-0x1, %eax
jne 0x136a9
leaq 0x33dd4(%rip), %rdi     # 0x47465
leaq 0x34ea8(%rip), %rsi     # 0x48540
movl $0x17f, %edx            # imm = 0x17F
leaq 0x3518a(%rip), %rcx     # 0x4882e
callq 0xa0b0
movsbq -0x15(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x136d5
jmp 0x136b6
leaq 0x33da8(%rip), %rdi     # 0x47465
leaq 0x34e7c(%rip), %rsi     # 0x48540
movl $0x185, %edx            # imm = 0x185
leaq 0x3515e(%rip), %rcx     # 0x4882e
callq 0xa0b0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/util.c
// Function: util_get_str_val
void util_get_str_val(
	ResizableString *rstr,
	const char *str,
	uint32_t len
) {
	assert(rstr);
	assert(str);
	assert(len >= 2);
	assert(str[0] == '"' && str[len - 1] == '"');

	util_unescape_string(rstr, str + 1, len - 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1378c
jmp 0x137ab
leaq 0x3438c(%rip), %rdi     # 0x47b1f
leaq 0x34da6(%rip), %rsi     # 0x48540
movl $0x19d, %edx            # imm = 0x19D
leaq 0x350c2(%rip), %rcx     # 0x48868
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x137b4
jmp 0x137d3
leaq 0x343cf(%rip), %rdi     # 0x47b8a
leaq 0x34d7e(%rip), %rsi     # 0x48540
movl $0x19e, %edx            # imm = 0x19E
leaq 0x3509a(%rip), %rcx     # 0x48868
callq 0xa0b0
cmpl $0x2, -0x14(%rbp)
jb 0x137db
jmp 0x137fa
leaq 0x350c7(%rip), %rdi     # 0x488a9
leaq 0x34d57(%rip), %rsi     # 0x48540
movl $0x19f, %edx            # imm = 0x19F
leaq 0x35073(%rip), %rcx     # 0x48868
callq 0xa0b0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x1381d
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x22, %eax
jne 0x1381d
jmp 0x1383c
leaq 0x3508e(%rip), %rdi     # 0x488b2
leaq 0x34d15(%rip), %rsi     # 0x48540
movl $0x1a0, %edx            # imm = 0x1A0
leaq 0x35031(%rip), %rcx     # 0x48868
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
movl -0x14(%rbp), %eax
subl $0x2, %eax
movl %eax, %eax
movl %eax, %edx
callq 0x13860
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/util.c
// Function: util_unescape_string
void util_unescape_string(
	ResizableString *target,
	const char *source,
	size_t source_len
) {
	for (size_t i = 0; i < source_len; i++) {
		char chr = source[i];
		if (chr != '\\') {
			rstr_append_with_char(target, chr);
		} else {
			if (i + 1 < source_len) {
				char next_char = source[++i];
				char unescaped_char = util_unescape(next_char);
				assert(unescaped_char != -1);
				rstr_append_with_char(target, unescaped_char);
			} else {
				assert(0);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x13954
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x5c, %eax
je 0x138b3
movq -0x8(%rbp), %rdi
movsbl -0x21(%rbp), %esi
callq 0xfeb0
jmp 0x13941
movq -0x20(%rbp), %rax
addq $0x1, %rax
cmpq -0x18(%rbp), %rax
jae 0x13920
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb 0x1(%rax,%rcx), %al
movb %al, -0x22(%rbp)
movsbl -0x22(%rbp), %edi
callq 0x12d10
movb %al, -0x23(%rbp)
movsbl -0x23(%rbp), %eax
cmpl $-0x1, %eax
je 0x138f2
jmp 0x13911
leaq 0x352d7(%rip), %rdi     # 0x48bd0
leaq 0x34c40(%rip), %rsi     # 0x48540
movl $0x2dc, %edx            # imm = 0x2DC
leaq 0x352d9(%rip), %rcx     # 0x48be5
callq 0xa0b0
movq -0x8(%rbp), %rdi
movsbl -0x23(%rbp), %esi
callq 0xfeb0
jmp 0x1393f
leaq 0x33b3e(%rip), %rdi     # 0x47465
leaq 0x34c12(%rip), %rsi     # 0x48540
movl $0x2df, %edx            # imm = 0x2DF
leaq 0x352ab(%rip), %rcx     # 0x48be5
callq 0xa0b0
jmp 0x13941
jmp 0x13943
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1387c
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/util.c
// Function: util_get_uint64_bin_val
uint64_t util_get_uint64_bin_val(const char *str, uint32_t len) {
	#define	_IS_BIN_DIGIT(chr)	((chr) >= '0' && (chr) <= '1')

	assert(str && len > 2 && str[0] == '0' && str[1] == 'b' && _IS_BIN_DIGIT(str[2]));

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

	uint64_t v = 0;
	uint32_t i = 0;
	while (s >= str) {
		const char chr = *(s--);
		if (_IS_BIN_DIGIT(chr)) {
			v |= (chr - '0') << (i++);
		} else if (chr == '_') {
			;
		} else if (chr == 'u') {
			continue;
		} else {
			assert(0);
		}
	}

	return v;

	#undef	_IS_BIN_DIGIT
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x139b1
cmpl $0x2, -0xc(%rbp)
jbe 0x139b1
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x139b1
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x62, %eax
jne 0x139b1
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x30, %eax
jl 0x139b1
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x31, %eax
jg 0x139b1
jmp 0x139d0
leaq 0x34f1f(%rip), %rdi     # 0x488d7
leaq 0x34b81(%rip), %rsi     # 0x48540
movl $0x1ab, %edx            # imm = 0x1AB
leaq 0x34f56(%rip), %rcx     # 0x48921
callq 0xa0b0
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
jb 0x13a8d
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %al
movb %al, -0x25(%rbp)
movsbl -0x25(%rbp), %eax
cmpl $0x30, %eax
jl 0x13a51
movsbl -0x25(%rbp), %eax
cmpl $0x31, %eax
jg 0x13a51
movsbl -0x25(%rbp), %eax
subl $0x30, %eax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
shll %cl, %eax
cltq
orq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x13a88
movsbl -0x25(%rbp), %eax
cmpl $0x5f, %eax
jne 0x13a5c
jmp 0x13a86
movsbl -0x25(%rbp), %eax
cmpl $0x75, %eax
jne 0x13a67
jmp 0x139fd
leaq 0x339f7(%rip), %rdi     # 0x47465
leaq 0x34acb(%rip), %rsi     # 0x48540
movl $0x1bb, %edx            # imm = 0x1BB
leaq 0x34ea0(%rip), %rcx     # 0x48921
callq 0xa0b0
jmp 0x13a88
jmp 0x139fd
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13b1e
cmpl $0x0, -0x14(%rbp)
jbe 0x13b1e
jmp 0x13b3d
leaq 0x34b7d(%rip), %rdi     # 0x486a2
leaq 0x34a14(%rip), %rsi     # 0x48540
movl $0x1cd, %edx            # imm = 0x1CD
leaq 0x34e22(%rip), %rcx     # 0x4895a
callq 0xa0b0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x13b62
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0x13960
movq %rax, -0x8(%rbp)
jmp 0x13b9f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x13b8f
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0x13960
movq %rax, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x13b9f
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x13960
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x13c61
cmpl $0x2, -0xc(%rbp)
jbe 0x13c61
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x13c61
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x6f, %eax
jne 0x13c61
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x30, %eax
jl 0x13c61
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x37, %eax
jg 0x13c61
jmp 0x13c80
leaq 0x34d29(%rip), %rdi     # 0x48991
leaq 0x348d1(%rip), %rsi     # 0x48540
movl $0x1e6, %edx            # imm = 0x1E6
leaq 0x34d60(%rip), %rcx     # 0x489db
callq 0xa0b0
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
jb 0x13d42
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %al
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %eax
cmpl $0x30, %eax
jl 0x13d06
movsbl -0x29(%rbp), %eax
cmpl $0x37, %eax
jg 0x13d06
movsbl -0x29(%rbp), %eax
subl $0x30, %eax
cltq
imulq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x28(%rbp)
jmp 0x13d3d
movsbl -0x29(%rbp), %eax
cmpl $0x5f, %eax
jne 0x13d11
jmp 0x13d3b
movsbl -0x29(%rbp), %eax
cmpl $0x75, %eax
jne 0x13d1c
jmp 0x13cae
leaq 0x33742(%rip), %rdi     # 0x47465
leaq 0x34816(%rip), %rsi     # 0x48540
movl $0x1f7, %edx            # imm = 0x1F7
leaq 0x34ca5(%rip), %rcx     # 0x489db
callq 0xa0b0
jmp 0x13d3d
jmp 0x13cae
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13dce
cmpl $0x0, -0x14(%rbp)
jbe 0x13dce
jmp 0x13ded
leaq 0x348cd(%rip), %rdi     # 0x486a2
leaq 0x34764(%rip), %rsi     # 0x48540
movl $0x209, %edx            # imm = 0x209
leaq 0x34c2c(%rip), %rcx     # 0x48a14
callq 0xa0b0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x13e12
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0x13c10
movq %rax, -0x8(%rbp)
jmp 0x13e4f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x13e3f
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0x13c10
movq %rax, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x13e4f
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x13c10
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x13ef6
cmpl $0x0, -0xc(%rbp)
jbe 0x13ef6
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x13ef6
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x13ef6
jmp 0x13f15
leaq 0x34b4e(%rip), %rdi     # 0x48a4b
leaq 0x3463c(%rip), %rsi     # 0x48540
movl $0x222, %edx            # imm = 0x222
leaq 0x34b63(%rip), %rcx     # 0x48a73
callq 0xa0b0
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
jb 0x13fc8
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %al
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %eax
cmpl $0x30, %eax
jl 0x13f8c
movsbl -0x29(%rbp), %eax
cmpl $0x39, %eax
jg 0x13f8c
movsbl -0x29(%rbp), %eax
subl $0x30, %eax
cltq
imulq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
imulq $0xa, -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x13fc3
movsbl -0x29(%rbp), %eax
cmpl $0x5f, %eax
jne 0x13f97
jmp 0x13fc1
movsbl -0x29(%rbp), %eax
cmpl $0x75, %eax
jne 0x13fa2
jmp 0x13f37
leaq 0x334bc(%rip), %rdi     # 0x47465
leaq 0x34590(%rip), %rsi     # 0x48540
movl $0x232, %edx            # imm = 0x232
leaq 0x34ab7(%rip), %rcx     # 0x48a73
callq 0xa0b0
jmp 0x13fc3
jmp 0x13f37
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1405e
cmpl $0x0, -0x14(%rbp)
jbe 0x1405e
jmp 0x1407d
leaq 0x3463d(%rip), %rdi     # 0x486a2
leaq 0x344d4(%rip), %rsi     # 0x48540
movl $0x244, %edx            # imm = 0x244
leaq 0x34a34(%rip), %rcx     # 0x48aac
callq 0xa0b0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x140a2
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0x13ec0
movq %rax, -0x8(%rbp)
jmp 0x140df
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x140cf
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0x13ec0
movq %rax, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x140df
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x13ec0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x143ce
cmpl $0x0, -0x14(%rbp)
jbe 0x143ce
jmp 0x143ed
leaq 0x342cd(%rip), %rdi     # 0x486a2
leaq 0x34164(%rip), %rsi     # 0x48540
movl $0x286, %edx            # imm = 0x286
leaq 0x3477e(%rip), %rcx     # 0x48b66
callq 0xa0b0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x14412
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0x14150
movq %rax, -0x8(%rbp)
jmp 0x1444f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x1443f
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0x14150
movq %rax, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x1444f
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x14150
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x147fc
jmp 0x1481b
leaq 0x3226b(%rip), %rdi     # 0x46a6e
leaq 0x3445e(%rip), %rsi     # 0x48c68
movl $0xad, %edx
leaq 0x34464(%rip), %rcx     # 0x48c7a
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x14824
jmp 0x14843
leaq 0x31d70(%rip), %rdi     # 0x4659b
leaq 0x34436(%rip), %rsi     # 0x48c68
movl $0xae, %edx
leaq 0x3443c(%rip), %rcx     # 0x48c7a
callq 0xa0b0
cmpl $0x0, -0x14(%rbp)
jl 0x1484b
jmp 0x1486a
leaq 0x31d50(%rip), %rdi     # 0x465a2
leaq 0x3440f(%rip), %rsi     # 0x48c68
movl $0xaf, %edx
leaq 0x34415(%rip), %rcx     # 0x48c7a
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq 0x43874(%rip), %rcx     # 0x580f0
callq 0xb170
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x148f9
jmp 0x14918
leaq 0x39261(%rip), %rdi     # 0x4db61
leaq 0x34361(%rip), %rsi     # 0x48c68
movl $0xbe, %edx
leaq 0x343e0(%rip), %rcx     # 0x48cf3
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x14921
jmp 0x14940
leaq 0x31c12(%rip), %rdi     # 0x4653a
leaq 0x34339(%rip), %rsi     # 0x48c68
movl $0xbf, %edx
leaq 0x343b8(%rip), %rcx     # 0x48cf3
callq 0xa0b0
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl $0x1000, %eax           # imm = 0x1000
jne 0x14969
jmp 0x1494f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x13fe0
addq $0x10, %rsp
popq %rbp
retq
leaq 0x32af5(%rip), %rdi     # 0x47465
leaq 0x342f1(%rip), %rsi     # 0x48c68
movl $0xc6, %edx
leaq 0x34370(%rip), %rcx     # 0x48cf3
callq 0xa0b0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x162b5
jmp 0x162d4
leaq 0x378a5(%rip), %rdi     # 0x4db61
leaq 0x332dd(%rip), %rsi     # 0x495a0
movl $0x523, %edx            # imm = 0x523
leaq 0x332ea(%rip), %rcx     # 0x495b9
callq 0xa0b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x162e1
jmp 0x16300
leaq 0x38c68(%rip), %rdi     # 0x4ef50
leaq 0x332b1(%rip), %rsi     # 0x495a0
movl $0x524, %edx            # imm = 0x524
leaq 0x332be(%rip), %rcx     # 0x495b9
callq 0xa0b0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x16340
movq -0x8(%rbp), %rax
movq $0x0, 0xc0(%rax)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x16340
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x180b9
jmp 0x180d8
leaq 0x35aa1(%rip), %rdi     # 0x4db61
leaq 0x314d9(%rip), %rsi     # 0x495a0
movl $0x1a7, %edx            # imm = 0x1A7
leaq 0x315ac(%rip), %rcx     # 0x4967f
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x180e1
jmp 0x18100
leaq 0x32f9f(%rip), %rdi     # 0x4b087
leaq 0x314b1(%rip), %rsi     # 0x495a0
movl $0x1a8, %edx            # imm = 0x1A8
leaq 0x31584(%rip), %rcx     # 0x4967f
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0xe00, (%rax)          # imm = 0xE00
jne 0x1810e
jmp 0x1812d
leaq 0x315a4(%rip), %rdi     # 0x496b9
leaq 0x31484(%rip), %rsi     # 0x495a0
movl $0x1a9, %edx            # imm = 0x1A9
leaq 0x31557(%rip), %rcx     # 0x4967f
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x18139
jmp 0x18158
leaq 0x32936(%rip), %rdi     # 0x4aa76
leaq 0x31459(%rip), %rsi     # 0x495a0
movl $0x1aa, %edx            # imm = 0x1AA
leaq 0x3152c(%rip), %rcx     # 0x4967f
callq 0xa0b0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x60, %rdx
callq 0x18190
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x18e40
jmp 0x18e5f
leaq 0x34d1a(%rip), %rdi     # 0x4db61
leaq 0x30752(%rip), %rsi     # 0x495a0
movl $0x5b, %edx
leaq 0x308dc(%rip), %rcx     # 0x49736
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x18e68
jmp 0x18e87
leaq 0x32218(%rip), %rdi     # 0x4b087
leaq 0x3072a(%rip), %rsi     # 0x495a0
movl $0x5c, %edx
leaq 0x308b4(%rip), %rcx     # 0x49736
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x18e90
jmp 0x18eaf
leaq 0x3078f(%rip), %rdi     # 0x49626
leaq 0x30702(%rip), %rsi     # 0x495a0
movl $0x5d, %edx
leaq 0x3088c(%rip), %rcx     # 0x49736
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x18190
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x18efa
leaq -0x420(%rbp), %rdi
leaq 0x308a8(%rip), %rsi     # 0x49782
movb $0x0, %al
callq 0xa170
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x420(%rbp), %rdx
callq *%rax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1a635
jmp 0x1a654
leaq 0x2e8ad(%rip), %rdi     # 0x48ee9
leaq 0x2f2b9(%rip), %rsi     # 0x498fc
movl $0x23a, %edx            # imm = 0x23A
leaq 0x2f2f4(%rip), %rcx     # 0x49943
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1a66b
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, (%rax)
jne 0x1a675
movq $0x0, -0x8(%rbp)
jmp 0x1a68a
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x18, %rdx
movq %rdx, (%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1a705
jmp 0x1a724
leaq 0x2f2cf(%rip), %rdi     # 0x499db
leaq 0x2f1e9(%rip), %rsi     # 0x498fc
movl $0x24f, %edx            # imm = 0x24F
leaq 0x2f288(%rip), %rcx     # 0x499a7
callq 0xa0b0
movq $0x0, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1a5d0
leaq -0x18(%rbp), %rdi
callq 0x1a620
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1a7a2
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1a755
jmp 0x1a774
leaq 0x2f27a(%rip), %rdi     # 0x499d6
leaq 0x2f199(%rip), %rsi     # 0x498fc
movl $0x256, %edx            # imm = 0x256
leaq 0x2f238(%rip), %rcx     # 0x499a7
callq 0xa0b0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xa0f0
cmpl $0x0, %eax
jne 0x1a791
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x1a793
leaq -0x18(%rbp), %rdi
callq 0x1a620
movq %rax, -0x20(%rbp)
jmp 0x1a742
leaq -0x18(%rbp), %rdi
callq 0x1a6a0
movq -0x10(%rbp), %rax
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_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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1a5d0
leaq -0x18(%rbp), %rdi
callq 0x1a620
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1a840
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1a7fc
jmp 0x1a81b
leaq 0x2f1d3(%rip), %rdi     # 0x499d6
leaq 0x2f0f2(%rip), %rsi     # 0x498fc
movl $0x269, %edx            # imm = 0x269
leaq 0x2f1ca(%rip), %rcx     # 0x499e0
callq 0xa0b0
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x1a82f
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x1a831
leaq -0x18(%rbp), %rdi
callq 0x1a620
movq %rax, -0x20(%rbp)
jmp 0x1a7e9
leaq -0x18(%rbp), %rdi
callq 0x1a6a0
movq -0x10(%rbp), %rax
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_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
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1a8d5
jmp 0x1a8f4
leaq 0x2e60d(%rip), %rdi     # 0x48ee9
leaq 0x2f019(%rip), %rsi     # 0x498fc
movl $0x295, %edx            # imm = 0x295
leaq 0x2f13f(%rip), %rcx     # 0x49a2e
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1a909
movq $0x0, -0x8(%rbp)
jmp 0x1a96f
jmp 0x1a90b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, (%rax)
jne 0x1a958
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
leaq 0x3df3b(%rip), %rax     # 0x58870
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1a956
movq $0x0, -0x8(%rbp)
jmp 0x1a96f
jmp 0x1a90b
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x28, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1aa01
jmp 0x1aa20
leaq 0x33159(%rip), %rdi     # 0x4db61
leaq 0x2eeed(%rip), %rsi     # 0x498fc
movl $0x2b9, %edx            # imm = 0x2B9
leaq 0x2f06f(%rip), %rcx     # 0x49a8a
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1aa29
jmp 0x1aa48
leaq 0x2f0d6(%rip), %rdi     # 0x49b06
leaq 0x2eec5(%rip), %rsi     # 0x498fc
movl $0x2ba, %edx            # imm = 0x2BA
leaq 0x2f047(%rip), %rcx     # 0x49a8a
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x1aa51
jmp 0x1aa70
leaq 0x3062f(%rip), %rdi     # 0x4b087
leaq 0x2ee9d(%rip), %rsi     # 0x498fc
movl $0x2bb, %edx            # imm = 0x2BB
leaq 0x2f01f(%rip), %rcx     # 0x49a8a
callq 0xa0b0
movq -0x18(%rbp), %rax
cmpl $0x400, (%rax)          # imm = 0x400
jne 0x1aa7e
jmp 0x1aa9d
leaq 0x2f05a(%rip), %rdi     # 0x49adf
leaq 0x2ee70(%rip), %rsi     # 0x498fc
movl $0x2bc, %edx            # imm = 0x2BC
leaq 0x2eff2(%rip), %rcx     # 0x49a8a
callq 0xa0b0
cmpq $0x0, -0x20(%rbp)
je 0x1aaa6
jmp 0x1aac5
leaq 0x2f055(%rip), %rdi     # 0x49b02
leaq 0x2ee48(%rip), %rsi     # 0x498fc
movl $0x2bd, %edx            # imm = 0x2BD
leaq 0x2efca(%rip), %rcx     # 0x49a8a
callq 0xa0b0
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x60, %edx
callq 0xa0d0
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x2(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x9(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0xa(%rax)
movq -0x10(%rbp), %rax
movb 0xc(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x12(%rax)
movq -0x10(%rbp), %rax
movb 0xd(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x13(%rax)
movq -0x10(%rbp), %rax
movb 0xe(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x14(%rax)
movq -0x10(%rbp), %rax
movb 0xf(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x15(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1b621
jmp 0x1b640
leaq 0x32539(%rip), %rdi     # 0x4db61
leaq 0x2e2cd(%rip), %rsi     # 0x498fc
movl $0x428, %edx            # imm = 0x428
leaq 0x2e5a2(%rip), %rcx     # 0x49bdd
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1b649
jmp 0x1b668
leaq 0x2e4b6(%rip), %rdi     # 0x49b06
leaq 0x2e2a5(%rip), %rsi     # 0x498fc
movl $0x429, %edx            # imm = 0x429
leaq 0x2e57a(%rip), %rcx     # 0x49bdd
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x1b671
jmp 0x1b690
leaq 0x2fa0f(%rip), %rdi     # 0x4b087
leaq 0x2e27d(%rip), %rsi     # 0x498fc
movl $0x42a, %edx            # imm = 0x42A
leaq 0x2e552(%rip), %rcx     # 0x49bdd
callq 0xa0b0
cmpq $0x0, -0x20(%rbp)
je 0x1b699
jmp 0x1b6b8
leaq 0x2e462(%rip), %rdi     # 0x49b02
leaq 0x2e255(%rip), %rsi     # 0x498fc
movl $0x42b, %edx            # imm = 0x42B
leaq 0x2e52a(%rip), %rcx     # 0x49bdd
callq 0xa0b0
movq -0x18(%rbp), %rax
cmpl $0x500, (%rax)          # imm = 0x500
je 0x1b6e3
leaq 0x2bd9a(%rip), %rdi     # 0x47465
leaq 0x2e22a(%rip), %rsi     # 0x498fc
movl $0x42e, %edx            # imm = 0x42E
leaq 0x2e4ff(%rip), %rcx     # 0x49bdd
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1ad40
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1b721
jmp 0x1b740
leaq 0x32439(%rip), %rdi     # 0x4db61
leaq 0x2e1cd(%rip), %rsi     # 0x498fc
movl $0x43f, %edx            # imm = 0x43F
leaq 0x2e4fa(%rip), %rcx     # 0x49c35
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1b749
jmp 0x1b768
leaq 0x2e3b6(%rip), %rdi     # 0x49b06
leaq 0x2e1a5(%rip), %rsi     # 0x498fc
movl $0x440, %edx            # imm = 0x440
leaq 0x2e4d2(%rip), %rcx     # 0x49c35
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x1b771
jmp 0x1b790
leaq 0x2f90f(%rip), %rdi     # 0x4b087
leaq 0x2e17d(%rip), %rsi     # 0x498fc
movl $0x441, %edx            # imm = 0x441
leaq 0x2e4aa(%rip), %rcx     # 0x49c35
callq 0xa0b0
cmpq $0x0, -0x20(%rbp)
je 0x1b799
jmp 0x1b7b8
leaq 0x2e362(%rip), %rdi     # 0x49b02
leaq 0x2e155(%rip), %rsi     # 0x498fc
movl $0x442, %edx            # imm = 0x442
leaq 0x2e482(%rip), %rcx     # 0x49c35
callq 0xa0b0
movq -0x18(%rbp), %rax
cmpl $0x600, (%rax)          # imm = 0x600
je 0x1b7e3
leaq 0x2bc9a(%rip), %rdi     # 0x47465
leaq 0x2e12a(%rip), %rsi     # 0x498fc
movl $0x445, %edx            # imm = 0x445
leaq 0x2e457(%rip), %rcx     # 0x49c35
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1ad40
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1b821
jmp 0x1b840
leaq 0x32339(%rip), %rdi     # 0x4db61
leaq 0x2e0cd(%rip), %rsi     # 0x498fc
movl $0x456, %edx            # imm = 0x456
leaq 0x2e452(%rip), %rcx     # 0x49c8d
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1b849
jmp 0x1b868
leaq 0x2e2b6(%rip), %rdi     # 0x49b06
leaq 0x2e0a5(%rip), %rsi     # 0x498fc
movl $0x457, %edx            # imm = 0x457
leaq 0x2e42a(%rip), %rcx     # 0x49c8d
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x1b871
jmp 0x1b890
leaq 0x2f80f(%rip), %rdi     # 0x4b087
leaq 0x2e07d(%rip), %rsi     # 0x498fc
movl $0x458, %edx            # imm = 0x458
leaq 0x2e402(%rip), %rcx     # 0x49c8d
callq 0xa0b0
movq -0x18(%rbp), %rax
cmpl $0xe00, (%rax)          # imm = 0xE00
jne 0x1b89e
jmp 0x1b8bd
leaq 0x2de14(%rip), %rdi     # 0x496b9
leaq 0x2e050(%rip), %rsi     # 0x498fc
movl $0x459, %edx            # imm = 0x459
leaq 0x2e3d5(%rip), %rcx     # 0x49c8d
callq 0xa0b0
cmpq $0x0, -0x20(%rbp)
je 0x1b8c6
jmp 0x1b8e5
leaq 0x2e235(%rip), %rdi     # 0x49b02
leaq 0x2e028(%rip), %rsi     # 0x498fc
movl $0x45a, %edx            # imm = 0x45A
leaq 0x2e3ad(%rip), %rcx     # 0x49c8d
callq 0xa0b0
movq -0x18(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1b8ff
jmp 0x1b91e
leaq 0x2dd27(%rip), %rdi     # 0x4962d
leaq 0x2dfef(%rip), %rsi     # 0x498fc
movl $0x45d, %edx            # imm = 0x45D
leaq 0x2e374(%rip), %rcx     # 0x49c8d
callq 0xa0b0
movq -0x20(%rbp), %rax
movb $0x1, 0x28(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
andq $0xff, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
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_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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1b971
jmp 0x1b990
leaq 0x321e9(%rip), %rdi     # 0x4db61
leaq 0x2df7d(%rip), %rsi     # 0x498fc
movl $0x469, %edx            # imm = 0x469
leaq 0x2e35c(%rip), %rcx     # 0x49ce7
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1b999
jmp 0x1b9b8
leaq 0x2e166(%rip), %rdi     # 0x49b06
leaq 0x2df55(%rip), %rsi     # 0x498fc
movl $0x46a, %edx            # imm = 0x46A
leaq 0x2e334(%rip), %rcx     # 0x49ce7
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x1b9c1
jmp 0x1b9e0
leaq 0x2f6bf(%rip), %rdi     # 0x4b087
leaq 0x2df2d(%rip), %rsi     # 0x498fc
movl $0x46b, %edx            # imm = 0x46B
leaq 0x2e30c(%rip), %rcx     # 0x49ce7
callq 0xa0b0
movq -0x18(%rbp), %rax
cmpl $0xe00, (%rax)          # imm = 0xE00
jne 0x1b9ee
jmp 0x1ba0d
leaq 0x2dcc4(%rip), %rdi     # 0x496b9
leaq 0x2df00(%rip), %rsi     # 0x498fc
movl $0x46c, %edx            # imm = 0x46C
leaq 0x2e2df(%rip), %rcx     # 0x49ce7
callq 0xa0b0
cmpq $0x0, -0x20(%rbp)
je 0x1ba16
jmp 0x1ba35
leaq 0x2e0e5(%rip), %rdi     # 0x49b02
leaq 0x2ded8(%rip), %rsi     # 0x498fc
movl $0x46d, %edx            # imm = 0x46D
leaq 0x2e2b7(%rip), %rcx     # 0x49ce7
callq 0xa0b0
movq -0x18(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1ba4f
jmp 0x1ba6e
leaq 0x2dbd7(%rip), %rdi     # 0x4962d
leaq 0x2de9f(%rip), %rsi     # 0x498fc
movl $0x470, %edx            # imm = 0x470
leaq 0x2e27e(%rip), %rcx     # 0x49ce7
callq 0xa0b0
movq -0x20(%rbp), %rax
movb $0x2, 0x28(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
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_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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1bac1
jmp 0x1bae0
leaq 0x32099(%rip), %rdi     # 0x4db61
leaq 0x2de2d(%rip), %rsi     # 0x498fc
movl $0x47c, %edx            # imm = 0x47C
leaq 0x2e267(%rip), %rcx     # 0x49d42
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1bae9
jmp 0x1bb08
leaq 0x2e016(%rip), %rdi     # 0x49b06
leaq 0x2de05(%rip), %rsi     # 0x498fc
movl $0x47d, %edx            # imm = 0x47D
leaq 0x2e23f(%rip), %rcx     # 0x49d42
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x1bb11
jmp 0x1bb30
leaq 0x2f56f(%rip), %rdi     # 0x4b087
leaq 0x2dddd(%rip), %rsi     # 0x498fc
movl $0x47e, %edx            # imm = 0x47E
leaq 0x2e217(%rip), %rcx     # 0x49d42
callq 0xa0b0
movq -0x18(%rbp), %rax
cmpl $0xe00, (%rax)          # imm = 0xE00
jne 0x1bb3e
jmp 0x1bb5d
leaq 0x2db74(%rip), %rdi     # 0x496b9
leaq 0x2ddb0(%rip), %rsi     # 0x498fc
movl $0x47f, %edx            # imm = 0x47F
leaq 0x2e1ea(%rip), %rcx     # 0x49d42
callq 0xa0b0
cmpq $0x0, -0x20(%rbp)
je 0x1bb66
jmp 0x1bb85
leaq 0x2df95(%rip), %rdi     # 0x49b02
leaq 0x2dd88(%rip), %rsi     # 0x498fc
movl $0x480, %edx            # imm = 0x480
leaq 0x2e1c2(%rip), %rcx     # 0x49d42
callq 0xa0b0
movq -0x18(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1bb9f
jmp 0x1bbbe
leaq 0x2da87(%rip), %rdi     # 0x4962d
leaq 0x2dd4f(%rip), %rsi     # 0x498fc
movl $0x483, %edx            # imm = 0x483
leaq 0x2e189(%rip), %rcx     # 0x49d42
callq 0xa0b0
movq -0x20(%rbp), %rax
movb $0x4, 0x28(%rax)
movq -0x28(%rbp), %rax
movabsq $0xffffffff, %rcx       # imm = 0xFFFFFFFF
andq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
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_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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1bc11
jmp 0x1bc30
leaq 0x31f49(%rip), %rdi     # 0x4db61
leaq 0x2dcdd(%rip), %rsi     # 0x498fc
movl $0x48f, %edx            # imm = 0x48F
leaq 0x2e172(%rip), %rcx     # 0x49d9d
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1bc39
jmp 0x1bc58
leaq 0x2dec6(%rip), %rdi     # 0x49b06
leaq 0x2dcb5(%rip), %rsi     # 0x498fc
movl $0x490, %edx            # imm = 0x490
leaq 0x2e14a(%rip), %rcx     # 0x49d9d
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x1bc61
jmp 0x1bc80
leaq 0x2f41f(%rip), %rdi     # 0x4b087
leaq 0x2dc8d(%rip), %rsi     # 0x498fc
movl $0x491, %edx            # imm = 0x491
leaq 0x2e122(%rip), %rcx     # 0x49d9d
callq 0xa0b0
movq -0x18(%rbp), %rax
cmpl $0xe00, (%rax)          # imm = 0xE00
jne 0x1bc8e
jmp 0x1bcad
leaq 0x2da24(%rip), %rdi     # 0x496b9
leaq 0x2dc60(%rip), %rsi     # 0x498fc
movl $0x492, %edx            # imm = 0x492
leaq 0x2e0f5(%rip), %rcx     # 0x49d9d
callq 0xa0b0
cmpq $0x0, -0x20(%rbp)
je 0x1bcb6
jmp 0x1bcd5
leaq 0x2de45(%rip), %rdi     # 0x49b02
leaq 0x2dc38(%rip), %rsi     # 0x498fc
movl $0x493, %edx            # imm = 0x493
leaq 0x2e0cd(%rip), %rcx     # 0x49d9d
callq 0xa0b0
movq -0x18(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1bcef
jmp 0x1bd0e
leaq 0x2d937(%rip), %rdi     # 0x4962d
leaq 0x2dbff(%rip), %rsi     # 0x498fc
movl $0x496, %edx            # imm = 0x496
leaq 0x2e094(%rip), %rcx     # 0x49d9d
callq 0xa0b0
movq -0x20(%rbp), %rax
movb $0x4, 0x28(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1bd52
jmp 0x1bd71
leaq 0x31e08(%rip), %rdi     # 0x4db61
leaq 0x2db9c(%rip), %rsi     # 0x498fc
movl $0x4a5, %edx            # imm = 0x4A5
leaq 0x2e08c(%rip), %rcx     # 0x49df8
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x1bd7a
jmp 0x1bd99
leaq 0x2dd85(%rip), %rdi     # 0x49b06
leaq 0x2db74(%rip), %rsi     # 0x498fc
movl $0x4a6, %edx            # imm = 0x4A6
leaq 0x2e064(%rip), %rcx     # 0x49df8
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x1bda2
jmp 0x1bdc1
leaq 0x2dd59(%rip), %rdi     # 0x49b02
leaq 0x2db4c(%rip), %rsi     # 0x498fc
movl $0x4a7, %edx            # imm = 0x4A7
leaq 0x2e03c(%rip), %rcx     # 0x49df8
callq 0xa0b0
movq -0x18(%rbp), %rax
movzbl 0x38(%rax), %eax
addl $0x1, %eax
cmpl $0x20, %eax
jle 0x1bdf0
leaq 0x2b68d(%rip), %rdi     # 0x47465
leaq 0x2db1d(%rip), %rsi     # 0x498fc
movl $0x4aa, %edx            # imm = 0x4AA
leaq 0x2e00d(%rip), %rcx     # 0x49df8
callq 0xa0b0
movb -0x19(%rbp), %dl
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rsi
movb 0x38(%rsi), %cl
movb %cl, %dil
addb $0x1, %dil
movb %dil, 0x38(%rsi)
movzbl %cl, %ecx
movb %dl, 0x39(%rax,%rcx)
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_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
subq $0x20, %rsp
movw %cx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x2, -0x20(%rbp)
jge 0x1be76
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movw -0x1a(%rbp), %ax
movzbl %al, %ecx
callq 0x1bd30
movzwl -0x1a(%rbp), %eax
sarl $0x8, %eax
movw %ax, -0x1a(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1be42
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)