LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/util.c
// Function: util_is_literal_uint_hex
bool util_is_literal_uint_hex(
	const char *str,
	uint32_t len
) {
	assert(str);

	if (len >= 3) {
		if (str[0] == '0'
				&& str[1] == 'x'
				&& UTIL_IS_LITERAL_UINT_HEX_CHAR(str[2])) {
			for (int i = 3; i < len; i++) {
				if (!UTIL_IS_LITERAL_UINT_HEX_CHAR(str[i])
						&& str[i] != '_') {
					return false;
				}
			}
			return true;
		} else {
			return false;
		}
	} else {
		return false;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x10e00
cmpl $0x3, %esi
jb 0x10dfb
cmpb $0x30, (%rdi)
jne 0x10dfb
cmpb $0x78, 0x1(%rdi)
jne 0x10dfb
movb 0x2(%rdi), %al
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x10d8a
movzbl %al, %ecx
xorl %eax, %eax
addl $-0x41, %ecx
cmpl $0x25, %ecx
ja 0x10dfd
movabsq $0x3f0000003f, %rdx     # imm = 0x3F0000003F
btq %rcx, %rdx
jae 0x10dfd
cmpl $0x3, %esi
sete %al
je 0x10dfd
cmpl $0x5, %esi
movl $0x4, %r8d
cmovael %esi, %r8d
movl %esi, %ecx
movl $0x3, %edx
subq %r8, %rdx
movl $0x4, %esi
movzbl -0x1(%rdi,%rsi), %r8d
leal -0x30(%r8), %r9d
cmpb $0xa, %r9b
setb %r9b
leal -0x61(%r8), %r10d
cmpb $0x6, %r10b
setb %r10b
orb %r9b, %r10b
jne 0x10ddb
leal -0x41(%r8), %r9d
cmpl $0x6, %r9d
jae 0x10df3
cmpq %rcx, %rsi
setae %al
leaq (%rdx,%rsi), %r8
incq %r8
incq %rsi
cmpq $0x4, %r8
jne 0x10dae
jmp 0x10dfd
cmpl $0x5f, %r8d
je 0x10ddb
jmp 0x10dfd
xorl %eax, %eax
andb $0x1, %al
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1ecc0(%rip), %rdi     # 0x2facb
leaq 0x1f676(%rip), %rsi     # 0x30488
leaq 0x1f906(%rip), %rcx     # 0x3071f
movl $0x14d, %edx            # imm = 0x14D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/util.c
// Function: util_is_literal_int_hex
bool util_is_literal_int_hex(
	const char *str,
	uint32_t len
) {
	assert(str && len > 0);

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

// Assembly:
testq %rdi, %rdi
je 0x10e47
testl %esi, %esi
je 0x10e47
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x10e3d
cmpl $0x2b, %eax
jne 0x10d39
incq %rdi
decl %esi
jmp 0x10d39
pushq %rbp
movq %rsp, %rbp
leaq 0x1f7ae(%rip), %rdi     # 0x30600
leaq 0x1f62f(%rip), %rsi     # 0x30488
leaq 0x1f8f6(%rip), %rcx     # 0x30756
movl $0x166, %edx            # imm = 0x166
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x10ede
movl %esi, %r14d
movq %rdi, %rbx
callq 0x10908
testb %al, %al
je 0x10efd
cmpl $0x4, %r14d
je 0x10e9a
cmpl $0x3, %r14d
jne 0x10f1c
movb 0x1(%rbx), %al
jmp 0x10ed5
movb 0x2(%rbx), %cl
cmpb $0x61, %cl
jne 0x10eab
leaq 0x1fce7(%rip), %rax     # 0x30b90
jmp 0x10eca
xorl %edx, %edx
leaq 0x1fcdc(%rip), %rax     # 0x30b90
cmpq $0x14, %rdx
je 0x10ecf
leaq 0x2(%rdx), %rsi
cmpb %cl, 0x2(%rdx,%rax)
movq %rsi, %rdx
jne 0x10eb4
addq %rsi, %rax
movb 0x1(%rax), %al
jmp 0x10ed1
movb $-0x1, %al
cmpb $-0x1, %al
je 0x10f3b
movsbq %al, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1ebe6(%rip), %rdi     # 0x2facb
leaq 0x1f59c(%rip), %rsi     # 0x30488
leaq 0x1f899(%rip), %rcx     # 0x3078c
movl $0x173, %edx            # imm = 0x173
callq 0xa0b0
leaq 0x1e490(%rip), %rdi     # 0x2f394
leaq 0x1f57d(%rip), %rsi     # 0x30488
leaq 0x1f87a(%rip), %rcx     # 0x3078c
movl $0x176, %edx            # imm = 0x176
callq 0xa0b0
leaq 0x1e471(%rip), %rdi     # 0x2f394
leaq 0x1f55e(%rip), %rsi     # 0x30488
leaq 0x1f85b(%rip), %rcx     # 0x3078c
movl $0x185, %edx            # imm = 0x185
callq 0xa0b0
leaq 0x1e452(%rip), %rdi     # 0x2f394
leaq 0x1f53f(%rip), %rsi     # 0x30488
leaq 0x1f83c(%rip), %rcx     # 0x3078c
movl $0x17f, %edx            # imm = 0x17F
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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
testq %rdi, %rdi
je 0x10fc5
testq %rsi, %rsi
je 0x10fe4
cmpl $0x1, %edx
jbe 0x11003
cmpb $0x22, (%rsi)
jne 0x10fa6
leal -0x1(%rdx), %eax
cmpb $0x22, (%rsi,%rax)
jne 0x10fa6
incq %rsi
addl $-0x2, %edx
popq %rbp
jmp 0x11022
leaq 0x1f863(%rip), %rdi     # 0x30810
leaq 0x1f4d4(%rip), %rsi     # 0x30488
leaq 0x1f80b(%rip), %rcx     # 0x307c6
movl $0x1a0, %edx            # imm = 0x1A0
callq 0xa0b0
leaq 0x1ea94(%rip), %rdi     # 0x2fa60
leaq 0x1f4b5(%rip), %rsi     # 0x30488
leaq 0x1f7ec(%rip), %rcx     # 0x307c6
movl $0x19d, %edx            # imm = 0x19D
callq 0xa0b0
leaq 0x1eae0(%rip), %rdi     # 0x2facb
leaq 0x1f496(%rip), %rsi     # 0x30488
leaq 0x1f7cd(%rip), %rcx     # 0x307c6
movl $0x19e, %edx            # imm = 0x19E
callq 0xa0b0
leaq 0x1f7fd(%rip), %rdi     # 0x30807
leaq 0x1f477(%rip), %rsi     # 0x30488
leaq 0x1f7ae(%rip), %rcx     # 0x307c6
movl $0x19f, %edx            # imm = 0x19F
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x1109a
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
leaq 0x1fb48(%rip), %r13     # 0x30b90
movb (%r14,%r12), %al
cmpb $0x5c, %al
jne 0x11087
incq %r12
cmpq %rbx, %r12
jae 0x110c8
movb (%r14,%r12), %al
movq %r13, %rcx
cmpb $0x61, %al
je 0x1107c
xorl %edx, %edx
cmpq $0x14, %rdx
je 0x11081
leaq 0x2(%rdx), %rcx
cmpb %al, 0x2(%rdx,%r13)
movq %rcx, %rdx
jne 0x11065
addq %r13, %rcx
movb 0x1(%rcx), %al
jmp 0x11083
movb $-0x1, %al
cmpb $-0x1, %al
je 0x110a9
movsbl %al, %esi
movq %r15, %rdi
callq 0xe5eb
incq %r12
cmpq %rbx, %r12
jb 0x11048
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1fa7e(%rip), %rdi     # 0x30b2e
leaq 0x1f3d1(%rip), %rsi     # 0x30488
leaq 0x1fa85(%rip), %rcx     # 0x30b43
movl $0x2dc, %edx            # imm = 0x2DC
callq 0xa0b0
leaq 0x1e2c5(%rip), %rdi     # 0x2f394
leaq 0x1f3b2(%rip), %rsi     # 0x30488
leaq 0x1fa66(%rip), %rcx     # 0x30b43
movl $0x2df, %edx            # imm = 0x2DF
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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
testq %rdi, %rdi
je 0x11151
cmpl $0x3, %esi
jb 0x11151
cmpb $0x30, (%rdi)
jne 0x11151
cmpb $0x62, 0x1(%rdi)
jne 0x11151
movb 0x2(%rdi), %al
andb $-0x2, %al
cmpb $0x30, %al
jne 0x11151
xorl %ecx, %ecx
cmpl $0x3, %esi
jae 0x11114
xorl %eax, %eax
jmp 0x1114f
movl %esi, %edx
incq %rdx
xorl %eax, %eax
movzbl -0x2(%rdi,%rdx), %esi
movl %esi, %r8d
andb $-0x2, %r8b
cmpb $0x30, %r8b
jne 0x1113c
addl $-0x30, %esi
shll %cl, %esi
incl %ecx
movslq %esi, %rsi
orq %rsi, %rax
jmp 0x11146
cmpl $0x5f, %esi
je 0x11146
cmpl $0x75, %esi
jne 0x11170
decq %rdx
cmpq $0x3, %rdx
jg 0x1111b
popq %rbp
retq
leaq 0x1f6dd(%rip), %rdi     # 0x30835
leaq 0x1f329(%rip), %rsi     # 0x30488
leaq 0x1f719(%rip), %rcx     # 0x3087f
movl $0x1ab, %edx            # imm = 0x1AB
callq 0xa0b0
leaq 0x1e21d(%rip), %rdi     # 0x2f394
leaq 0x1f30a(%rip), %rsi     # 0x30488
leaq 0x1f6fa(%rip), %rcx     # 0x3087f
movl $0x1bb, %edx            # imm = 0x1BB
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x111d7
testl %esi, %esi
je 0x111d7
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x111c8
cmpl $0x2b, %eax
jne 0x111c2
incq %rdi
decl %esi
popq %rbp
jmp 0x110e7
incq %rdi
decl %esi
callq 0x110e7
negq %rax
popq %rbp
retq
leaq 0x1f422(%rip), %rdi     # 0x30600
leaq 0x1f2a3(%rip), %rsi     # 0x30488
leaq 0x1f6cc(%rip), %rcx     # 0x308b8
movl $0x1cd, %edx            # imm = 0x1CD
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x11279
cmpl $0x3, %esi
jb 0x11279
cmpb $0x30, (%rdi)
jne 0x11279
cmpb $0x6f, 0x1(%rdi)
jne 0x11279
movb 0x2(%rdi), %al
andb $-0x8, %al
cmpb $0x30, %al
jne 0x11279
cmpl $0x3, %esi
jae 0x11235
xorl %eax, %eax
jmp 0x11277
movl %esi, %ecx
incq %rcx
movl $0x1, %edx
xorl %eax, %eax
movzbl -0x2(%rdi,%rcx), %esi
movl %esi, %r8d
andb $-0x8, %r8b
cmpb $0x30, %r8b
jne 0x11263
andl $0x7, %esi
imulq %rdx, %rsi
addq %rsi, %rax
shlq $0x3, %rdx
jmp 0x1126e
cmpq $0x5f, %rsi
je 0x1126e
cmpl $0x75, %esi
jne 0x11298
decq %rcx
cmpq $0x3, %rcx
jg 0x11241
popq %rbp
retq
leaq 0x1f66f(%rip), %rdi     # 0x308ef
leaq 0x1f201(%rip), %rsi     # 0x30488
leaq 0x1f6ab(%rip), %rcx     # 0x30939
movl $0x1e6, %edx            # imm = 0x1E6
callq 0xa0b0
leaq 0x1e0f5(%rip), %rdi     # 0x2f394
leaq 0x1f1e2(%rip), %rsi     # 0x30488
leaq 0x1f68c(%rip), %rcx     # 0x30939
movl $0x1f7, %edx            # imm = 0x1F7
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x112ff
testl %esi, %esi
je 0x112ff
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x112f0
cmpl $0x2b, %eax
jne 0x112ea
incq %rdi
decl %esi
popq %rbp
jmp 0x1120a
incq %rdi
decl %esi
callq 0x1120a
negq %rax
popq %rbp
retq
leaq 0x1f2fa(%rip), %rdi     # 0x30600
leaq 0x1f17b(%rip), %rsi     # 0x30488
leaq 0x1f65e(%rip), %rcx     # 0x30972
movl $0x209, %edx            # imm = 0x209
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x113b4
testl %esi, %esi
je 0x113b4
movb (%rdi), %al
addb $-0x30, %al
cmpb $0xa, %al
jae 0x113b4
movl %esi, %eax
leaq (%rdi,%rax), %rcx
decq %rcx
cmpq %rdi, %rcx
jae 0x11359
xorl %eax, %eax
jmp 0x11393
movl $0x1, %edx
xorl %eax, %eax
movzbl (%rcx), %esi
leal -0x30(%rsi), %r8d
cmpb $0x9, %r8b
ja 0x11380
andl $0xf, %esi
imulq %rdx, %rsi
addq %rsi, %rax
addq %rdx, %rdx
leaq (%rdx,%rdx,4), %rdx
jmp 0x1138b
cmpq $0x5f, %rsi
je 0x1138b
cmpl $0x75, %esi
jne 0x11395
decq %rcx
cmpq %rdi, %rcx
jae 0x11360
popq %rbp
retq
leaq 0x1dff8(%rip), %rdi     # 0x2f394
leaq 0x1f0e5(%rip), %rsi     # 0x30488
leaq 0x1f627(%rip), %rcx     # 0x309d1
movl $0x232, %edx            # imm = 0x232
callq 0xa0b0
leaq 0x1f5ee(%rip), %rdi     # 0x309a9
leaq 0x1f0c6(%rip), %rsi     # 0x30488
leaq 0x1f608(%rip), %rcx     # 0x309d1
movl $0x222, %edx            # imm = 0x222
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x1141b
testl %esi, %esi
je 0x1141b
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x1140c
cmpl $0x2b, %eax
jne 0x11406
incq %rdi
decl %esi
popq %rbp
jmp 0x11332
incq %rdi
decl %esi
callq 0x11332
negq %rax
popq %rbp
retq
leaq 0x1f1de(%rip), %rdi     # 0x30600
leaq 0x1f05f(%rip), %rsi     # 0x30488
leaq 0x1f5da(%rip), %rcx     # 0x30a0a
movl $0x244, %edx            # imm = 0x244
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
testq %rdi, %rdi
je 0x11558
cmpl $0x3, %esi
jb 0x11558
cmpb $0x30, (%rdi)
jne 0x11558
cmpb $0x78, 0x1(%rdi)
jne 0x11558
movb 0x2(%rdi), %al
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x114a7
movzbl %al, %eax
addl $-0x41, %eax
cmpl $0x25, %eax
ja 0x11558
movabsq $0x3f0000003f, %rcx     # imm = 0x3F0000003F
btq %rax, %rcx
jae 0x11558
cmpl $0x3, %esi
jae 0x114b5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %esi, %ecx
incq %rcx
movl $0x1, %edx
xorl %eax, %eax
movabsq $0x3f0000003f, %rsi     # imm = 0x3F0000003F
movabsq $0x10000040000000, %r8  # imm = 0x10000040000000
movb -0x2(%rdi,%rcx), %r10b
movsbl %r10b, %r9d
leal -0x30(%r10), %r11d
cmpb $0xa, %r11b
jb 0x11500
movzbl %r10b, %ebx
addl $-0x41, %ebx
cmpl $0x34, %ebx
ja 0x11539
btq %rbx, %rsi
jae 0x11533
cmpb $0x9, %r11b
ja 0x1151a
addl $-0x30, %r9d
imulq %rdx, %r9
addq %r9, %rax
shlq $0x4, %rdx
decq %rcx
cmpq $0x3, %rcx
jg 0x114d5
jmp 0x114ae
addb $-0x61, %r10b
cmpb $0x5, %r10b
ja 0x1152a
addl $-0x57, %r9d
jmp 0x11504
addl $-0x37, %r9d
movslq %r9d, %r9
jmp 0x11504
btq %rbx, %r8
jb 0x1150f
leaq 0x1de54(%rip), %rdi     # 0x2f394
leaq 0x1ef41(%rip), %rsi     # 0x30488
leaq 0x1f53d(%rip), %rcx     # 0x30a8b
movl $0x274, %edx            # imm = 0x274
callq 0xa0b0
leaq 0x1f4e2(%rip), %rdi     # 0x30a41
leaq 0x1ef22(%rip), %rsi     # 0x30488
leaq 0x1f51e(%rip), %rcx     # 0x30a8b
movl $0x25d, %edx            # imm = 0x25D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x115bf
testl %esi, %esi
je 0x115bf
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x115b0
cmpl $0x2b, %eax
jne 0x115aa
incq %rdi
decl %esi
popq %rbp
jmp 0x1144e
incq %rdi
decl %esi
callq 0x1144e
negq %rax
popq %rbp
retq
leaq 0x1f03a(%rip), %rdi     # 0x30600
leaq 0x1eebb(%rip), %rsi     # 0x30488
leaq 0x1f4f0(%rip), %rcx     # 0x30ac4
movl $0x286, %edx            # imm = 0x286
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x116d4
testl %esi, %esi
je 0x116f3
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd 0x1ee63(%rip), %xmm1    # 0x30478
movslq %edx, %rcx
addq %rdi, %rcx
movl %edx, %eax
movzbl (%rcx), %edx
cmpl $0x5f, %edx
setne %r8b
leal -0x30(%rdx), %r9d
cmpb $0xa, %r9b
setae %r9b
testb %r9b, %r8b
jne 0x1166b
cmpl $0x5f, %edx
jne 0x11648
incl %eax
incq %rcx
cmpl %esi, %eax
jb 0x1161d
jmp 0x11667
movapd %xmm0, %xmm2
addl $-0x30, %edx
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
leal 0x1(%rax), %edx
cmpl %esi, %edx
jb 0x11615
incl %eax
xorl %ecx, %ecx
jmp 0x11673
xorl %ecx, %ecx
cmpl $0x2e, %edx
sete %cl
addl %ecx, %eax
cmpl %esi, %eax
jae 0x116d2
movsd 0x1edff(%rip), %xmm1    # 0x30480
movapd %xmm1, %xmm2
movslq %eax, %rcx
addq %rdi, %rcx
movzbl (%rcx), %edx
cmpl $0x5f, %edx
setne %r8b
leal -0x30(%rdx), %r9d
cmpb $0xa, %r9b
setae %r9b
testb %r9b, %r8b
jne 0x116d2
cmpl $0x5f, %edx
jne 0x116b6
incl %eax
incq %rcx
cmpl %esi, %eax
jb 0x1168b
jmp 0x116d2
addl $-0x30, %edx
xorps %xmm3, %xmm3
cvtsi2sd %edx, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm0
mulsd %xmm1, %xmm2
incl %eax
cmpl %esi, %eax
jb 0x11685
popq %rbp
retq
leaq 0x1e3f0(%rip), %rdi     # 0x2facb
leaq 0x1eda6(%rip), %rsi     # 0x30488
leaq 0x1f412(%rip), %rcx     # 0x30afb
movl $0x29d, %edx            # imm = 0x29D
callq 0xa0b0
leaq 0x1ef0d(%rip), %rdi     # 0x30607
leaq 0x1ed87(%rip), %rsi     # 0x30488
leaq 0x1f3f3(%rip), %rcx     # 0x30afb
movl $0x29e, %edx            # imm = 0x29E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x11743
testq %rsi, %rsi
je 0x11762
testl %edx, %edx
js 0x11781
leaq 0x2e9a3(%rip), %rcx     # 0x400e0
popq %rbp
jmp 0xae24
leaq 0x1d2cf(%rip), %rdi     # 0x2ea19
leaq 0x1f457(%rip), %rsi     # 0x30ba8
leaq 0x1f462(%rip), %rcx     # 0x30bba
movl $0xad, %edx
callq 0xa0b0
leaq 0x1cddd(%rip), %rdi     # 0x2e546
leaq 0x1f438(%rip), %rsi     # 0x30ba8
leaq 0x1f443(%rip), %rcx     # 0x30bba
movl $0xae, %edx
callq 0xa0b0
leaq 0x1cdc5(%rip), %rdi     # 0x2e54d
leaq 0x1f419(%rip), %rsi     # 0x30ba8
leaq 0x1f424(%rip), %rcx     # 0x30bba
movl $0xaf, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x117ef
testq %rsi, %rsi
je 0x1180e
cmpl $0x1000, (%rsi)         # imm = 0x1000
jne 0x1182d
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x113d3
leaq 0x24f60(%rip), %rdi     # 0x36756
leaq 0x1f3ab(%rip), %rsi     # 0x30ba8
leaq 0x1f42f(%rip), %rcx     # 0x30c33
movl $0xbe, %edx
callq 0xa0b0
leaq 0x1ccb5(%rip), %rdi     # 0x2e4ca
leaq 0x1f38c(%rip), %rsi     # 0x30ba8
leaq 0x1f410(%rip), %rcx     # 0x30c33
movl $0xbf, %edx
callq 0xa0b0
leaq 0x1db60(%rip), %rdi     # 0x2f394
leaq 0x1f36d(%rip), %rsi     # 0x30ba8
leaq 0x1f3f1(%rip), %rcx     # 0x30c33
movl $0xc6, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x129b9
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x129d8
movq %rbx, %rdi
movl $0x1, %esi
callq 0x129f7
movq $0x0, 0xc0(%rbx)
movq %rbx, %rdi
movl $0x2, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x129f7
leaq 0x23d96(%rip), %rdi     # 0x36756
leaq 0x1e851(%rip), %rsi     # 0x31218
leaq 0x1e863(%rip), %rcx     # 0x31231
movl $0x523, %edx            # imm = 0x523
callq 0xa0b0
leaq 0x24000(%rip), %rdi     # 0x369df
leaq 0x1e832(%rip), %rsi     # 0x31218
leaq 0x1e844(%rip), %rcx     # 0x31231
movl $0x524, %edx            # imm = 0x524
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x13c13
movq %rsi, %rdx
cmpl $0xe00, (%rsi)          # imm = 0xE00
jne 0x13c32
cmpl $0x1, 0x44(%rdx)
jne 0x13c51
movq 0x48(%rdx), %rax
movq (%rax), %rsi
addq $0x60, %rdx
popq %rbp
jmp 0x13c70
leaq 0x1f0e1(%rip), %rdi     # 0x32cfb
leaq 0x1d5f7(%rip), %rsi     # 0x31218
leaq 0x1d6cf(%rip), %rcx     # 0x312f7
movl $0x1a8, %edx            # imm = 0x1A8
callq 0xa0b0
leaq 0x1d6f8(%rip), %rdi     # 0x31331
leaq 0x1d5d8(%rip), %rsi     # 0x31218
leaq 0x1d6b0(%rip), %rcx     # 0x312f7
movl $0x1a9, %edx            # imm = 0x1A9
callq 0xa0b0
leaq 0x1ea92(%rip), %rdi     # 0x326ea
leaq 0x1d5b9(%rip), %rsi     # 0x31218
leaq 0x1d691(%rip), %rcx     # 0x312f7
movl $0x1aa, %edx            # imm = 0x1AA
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x14883
movq %rdx, %r15
testq %rdx, %rdx
je 0x148a2
movq %rsi, %r14
movq %rdi, %rbx
movq %r15, %rdx
callq 0x13c70
cmpb $0x1, (%r15)
je 0x14875
movups 0x1cb98(%rip), %xmm0    # 0x313fa
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 0x1e471(%rip), %rdi     # 0x32cfb
leaq 0x1c987(%rip), %rsi     # 0x31218
leaq 0x1cb16(%rip), %rcx     # 0x313ae
movl $0x5c, %edx
callq 0xa0b0
leaq 0x1c9f5(%rip), %rdi     # 0x3129e
leaq 0x1c968(%rip), %rsi     # 0x31218
leaq 0x1caf7(%rip), %rcx     # 0x313ae
movl $0x5d, %edx
callq 0xa0b0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x15351
movq (%rdi), %rax
testq %rax, %rax
je 0x1534e
cmpq $0x0, (%rax)
je 0x1534e
leaq 0x18(%rax), %rcx
movq %rcx, (%rdi)
retq
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1bacd(%rip), %rdi     # 0x30e29
leaq 0x1c20d(%rip), %rsi     # 0x31570
leaq 0x1c24d(%rip), %rcx     # 0x315b7
movl $0x23a, %edx            # imm = 0x23A
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
testq %rdi, %rdi
je 0x15442
cmpq $0x0, 0x2ad70(%rip)     # 0x40130
je 0x15414
movq %rdi, %rbx
leaq 0x2ad7c(%rip), %r15     # 0x40148
leaq 0x2ad5d(%rip), %r12     # 0x40130
xorl %r14d, %r14d
movq (%r12), %rdi
testq %rdi, %rdi
je 0x15423
movq %rbx, %rsi
callq 0xa0e0
testl %eax, %eax
cmoveq %r12, %r14
testq %r15, %r15
je 0x1540a
movq (%r15), %r12
testq %r12, %r12
movl $0x18, %eax
cmoveq %r12, %rax
cmovneq %r15, %r12
addq %rax, %r15
jmp 0x1540d
xorl %r12d, %r12d
testq %r12, %r12
jne 0x153d6
jmp 0x15417
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c220(%rip), %rdi     # 0x3164a
leaq 0x1c13f(%rip), %rsi     # 0x31570
leaq 0x1c1e3(%rip), %rcx     # 0x3161b
movl $0x256, %edx            # imm = 0x256
callq 0xa0b0
leaq 0x1c206(%rip), %rdi     # 0x3164f
leaq 0x1c120(%rip), %rsi     # 0x31570
leaq 0x1c1c4(%rip), %rcx     # 0x3161b
movl $0x24f, %edx            # imm = 0x24F
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_reg_get_by_id
InsRegister * ins_reg_get_by_id(
	int id
) {
	InsRegister *ins_reg = NULL;

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

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

	return ins_reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x2acc3(%rip)     # 0x40130
je 0x154b2
leaq 0x2acd2(%rip), %rcx     # 0x40148
leaq 0x2acb3(%rip), %rdx     # 0x40130
xorl %eax, %eax
cmpq $0x0, (%rdx)
je 0x154b6
cmpl %edi, 0x8(%rdx)
cmoveq %rdx, %rax
testq %rcx, %rcx
je 0x154a9
movq (%rcx), %rdx
testq %rdx, %rdx
movl $0x18, %esi
cmoveq %rdx, %rsi
cmovneq %rcx, %rdx
addq %rsi, %rcx
jmp 0x154ab
xorl %edx, %edx
testq %rdx, %rdx
jne 0x1547f
jmp 0x154b4
xorl %eax, %eax
popq %rbp
retq
leaq 0x1c18d(%rip), %rdi     # 0x3164a
leaq 0x1c0ac(%rip), %rsi     # 0x31570
leaq 0x1c189(%rip), %rcx     # 0x31654
movl $0x269, %edx            # imm = 0x269
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x15558
cmpq $0x0, 0x8(%rdi)
je 0x1554a
movq 0x8(%rdi), %rax
leaq 0x2a775(%rip), %rcx     # 0x3fca0
cmpq $0x0, (%rax)
jne 0x1554e
movq (%rdi), %rax
leaq 0x1(%rax), %rdx
movq %rdx, (%rdi)
movq 0x8(%rcx,%rax,8), %rax
movq %rax, 0x8(%rdi)
cmpq $0x7, %rdx
jne 0x1552b
xorl %eax, %eax
jmp 0x15556
leaq 0x28(%rax), %rcx
movq %rcx, 0x8(%rdi)
popq %rbp
retq
leaq 0x1b8ca(%rip), %rdi     # 0x30e29
leaq 0x1c00a(%rip), %rsi     # 0x31570
leaq 0x1c135(%rip), %rcx     # 0x316a2
movl $0x295, %edx            # imm = 0x295
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x15606
testq %rsi, %rsi
je 0x15625
testq %rdx, %rdx
je 0x15644
cmpl $0x400, (%rdx)          # imm = 0x400
jne 0x15663
testq %rcx, %rcx
je 0x15682
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 0x21149(%rip), %rdi     # 0x36756
leaq 0x1bf5c(%rip), %rsi     # 0x31570
leaq 0x1c0e3(%rip), %rcx     # 0x316fe
movl $0x2b9, %edx            # imm = 0x2B9
callq 0xa0b0
leaq 0x1c14e(%rip), %rdi     # 0x3177a
leaq 0x1bf3d(%rip), %rsi     # 0x31570
leaq 0x1c0c4(%rip), %rcx     # 0x316fe
movl $0x2ba, %edx            # imm = 0x2BA
callq 0xa0b0
leaq 0x1d6b0(%rip), %rdi     # 0x32cfb
leaq 0x1bf1e(%rip), %rsi     # 0x31570
leaq 0x1c0a5(%rip), %rcx     # 0x316fe
movl $0x2bb, %edx            # imm = 0x2BB
callq 0xa0b0
leaq 0x1c0e9(%rip), %rdi     # 0x31753
leaq 0x1beff(%rip), %rsi     # 0x31570
leaq 0x1c086(%rip), %rcx     # 0x316fe
movl $0x2bc, %edx            # imm = 0x2BC
callq 0xa0b0
leaq 0x1c0ed(%rip), %rdi     # 0x31776
leaq 0x1bee0(%rip), %rsi     # 0x31570
leaq 0x1c067(%rip), %rcx     # 0x316fe
movl $0x2bd, %edx            # imm = 0x2BD
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x15725
testq %rsi, %rsi
je 0x15744
testq %rdx, %rdx
je 0x15763
cmpl $0x500, (%rdx)          # imm = 0x500
jne 0x15782
testq %rcx, %rcx
je 0x157a1
movq 0x60(%rdx), %rax
testq %rax, %rax
je 0x157c0
movl 0xb0(%rdi), %edx
movl 0x10(%rax), %esi
movl %esi, %edi
andb $0x7, %dil
movb %dil, 0x18(%rcx)
testb $0x8, %sil
je 0x15702
movb $0x1, %sil
movb %sil, 0xd(%rcx)
movb %sil, 0xf(%rcx)
cmpl $0x4, %edx
je 0x15719
cmpl $0x2, %edx
je 0x15719
cmpl $0x1, %edx
jne 0x15723
cmpl $0x4, 0xc(%rax)
je 0x1571f
jmp 0x15723
cmpl $0x3, 0xc(%rax)
jne 0x15723
movb $0x1, 0xb(%rcx)
popq %rbp
retq
leaq 0x2102a(%rip), %rdi     # 0x36756
leaq 0x1be3d(%rip), %rsi     # 0x31570
leaq 0x1c044(%rip), %rcx     # 0x3177e
movl $0x2d4, %edx            # imm = 0x2D4
callq 0xa0b0
leaq 0x1c02f(%rip), %rdi     # 0x3177a
leaq 0x1be1e(%rip), %rsi     # 0x31570
leaq 0x1c025(%rip), %rcx     # 0x3177e
movl $0x2d5, %edx            # imm = 0x2D5
callq 0xa0b0
leaq 0x1d591(%rip), %rdi     # 0x32cfb
leaq 0x1bdff(%rip), %rsi     # 0x31570
leaq 0x1c006(%rip), %rcx     # 0x3177e
movl $0x2d6, %edx            # imm = 0x2D6
callq 0xa0b0
leaq 0x1c04d(%rip), %rdi     # 0x317d6
leaq 0x1bde0(%rip), %rsi     # 0x31570
leaq 0x1bfe7(%rip), %rcx     # 0x3177e
movl $0x2d7, %edx            # imm = 0x2D7
callq 0xa0b0
leaq 0x1bfce(%rip), %rdi     # 0x31776
leaq 0x1bdc1(%rip), %rsi     # 0x31570
leaq 0x1bfc8(%rip), %rcx     # 0x3177e
movl $0x2d8, %edx            # imm = 0x2D8
callq 0xa0b0
leaq 0x1c02a(%rip), %rdi     # 0x317f1
leaq 0x1bda2(%rip), %rsi     # 0x31570
leaq 0x1bfa9(%rip), %rcx     # 0x3177e
movl $0x2dd, %edx            # imm = 0x2DD
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x15e53
testq %rsi, %rsi
je 0x15e72
testq %rdx, %rdx
je 0x15e91
testq %rcx, %rcx
je 0x15eb0
cmpl $0x500, (%rdx)          # imm = 0x500
jne 0x15ecf
popq %rbp
jmp 0x157df
leaq 0x208fc(%rip), %rdi     # 0x36756
leaq 0x1b70f(%rip), %rsi     # 0x31570
leaq 0x1b9e9(%rip), %rcx     # 0x31851
movl $0x428, %edx            # imm = 0x428
callq 0xa0b0
leaq 0x1b901(%rip), %rdi     # 0x3177a
leaq 0x1b6f0(%rip), %rsi     # 0x31570
leaq 0x1b9ca(%rip), %rcx     # 0x31851
movl $0x429, %edx            # imm = 0x429
callq 0xa0b0
leaq 0x1ce63(%rip), %rdi     # 0x32cfb
leaq 0x1b6d1(%rip), %rsi     # 0x31570
leaq 0x1b9ab(%rip), %rcx     # 0x31851
movl $0x42a, %edx            # imm = 0x42A
callq 0xa0b0
leaq 0x1b8bf(%rip), %rdi     # 0x31776
leaq 0x1b6b2(%rip), %rsi     # 0x31570
leaq 0x1b98c(%rip), %rcx     # 0x31851
movl $0x42b, %edx            # imm = 0x42B
callq 0xa0b0
leaq 0x194be(%rip), %rdi     # 0x2f394
leaq 0x1b693(%rip), %rsi     # 0x31570
leaq 0x1b96d(%rip), %rcx     # 0x31851
movl $0x42e, %edx            # imm = 0x42E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x15f18
testq %rsi, %rsi
je 0x15f37
testq %rdx, %rdx
je 0x15f56
testq %rcx, %rcx
je 0x15f75
cmpl $0x600, (%rdx)          # imm = 0x600
jne 0x15f94
popq %rbp
jmp 0x157df
leaq 0x20837(%rip), %rdi     # 0x36756
leaq 0x1b64a(%rip), %rsi     # 0x31570
leaq 0x1b97c(%rip), %rcx     # 0x318a9
movl $0x43f, %edx            # imm = 0x43F
callq 0xa0b0
leaq 0x1b83c(%rip), %rdi     # 0x3177a
leaq 0x1b62b(%rip), %rsi     # 0x31570
leaq 0x1b95d(%rip), %rcx     # 0x318a9
movl $0x440, %edx            # imm = 0x440
callq 0xa0b0
leaq 0x1cd9e(%rip), %rdi     # 0x32cfb
leaq 0x1b60c(%rip), %rsi     # 0x31570
leaq 0x1b93e(%rip), %rcx     # 0x318a9
movl $0x441, %edx            # imm = 0x441
callq 0xa0b0
leaq 0x1b7fa(%rip), %rdi     # 0x31776
leaq 0x1b5ed(%rip), %rsi     # 0x31570
leaq 0x1b91f(%rip), %rcx     # 0x318a9
movl $0x442, %edx            # imm = 0x442
callq 0xa0b0
leaq 0x193f9(%rip), %rdi     # 0x2f394
leaq 0x1b5ce(%rip), %rsi     # 0x31570
leaq 0x1b900(%rip), %rcx     # 0x318a9
movl $0x445, %edx            # imm = 0x445
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x15fef
testq %rsi, %rsi
je 0x1600e
testq %rdx, %rdx
je 0x1602d
cmpl $0xe00, (%rdx)          # imm = 0xE00
jne 0x1604c
testq %rcx, %rcx
je 0x1606b
cmpb $0x1, 0x60(%rdx)
jne 0x1608a
movb $0x1, 0x28(%rcx)
movzbl 0x68(%rdx), %eax
movq %rax, 0x30(%rcx)
popq %rbp
retq
leaq 0x20760(%rip), %rdi     # 0x36756
leaq 0x1b573(%rip), %rsi     # 0x31570
leaq 0x1b8fd(%rip), %rcx     # 0x31901
movl $0x456, %edx            # imm = 0x456
callq 0xa0b0
leaq 0x1b765(%rip), %rdi     # 0x3177a
leaq 0x1b554(%rip), %rsi     # 0x31570
leaq 0x1b8de(%rip), %rcx     # 0x31901
movl $0x457, %edx            # imm = 0x457
callq 0xa0b0
leaq 0x1ccc7(%rip), %rdi     # 0x32cfb
leaq 0x1b535(%rip), %rsi     # 0x31570
leaq 0x1b8bf(%rip), %rcx     # 0x31901
movl $0x458, %edx            # imm = 0x458
callq 0xa0b0
leaq 0x1b2de(%rip), %rdi     # 0x31331
leaq 0x1b516(%rip), %rsi     # 0x31570
leaq 0x1b8a0(%rip), %rcx     # 0x31901
movl $0x459, %edx            # imm = 0x459
callq 0xa0b0
leaq 0x1b704(%rip), %rdi     # 0x31776
leaq 0x1b4f7(%rip), %rsi     # 0x31570
leaq 0x1b881(%rip), %rcx     # 0x31901
movl $0x45a, %edx            # imm = 0x45A
callq 0xa0b0
leaq 0x1b214(%rip), %rdi     # 0x312a5
leaq 0x1b4d8(%rip), %rsi     # 0x31570
leaq 0x1b862(%rip), %rcx     # 0x31901
movl $0x45d, %edx            # imm = 0x45D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x160e5
testq %rsi, %rsi
je 0x16104
testq %rdx, %rdx
je 0x16123
cmpl $0xe00, (%rdx)          # imm = 0xE00
jne 0x16142
testq %rcx, %rcx
je 0x16161
cmpb $0x1, 0x60(%rdx)
jne 0x16180
movb $0x2, 0x28(%rcx)
movzwl 0x68(%rdx), %eax
movq %rax, 0x30(%rcx)
popq %rbp
retq
leaq 0x2066a(%rip), %rdi     # 0x36756
leaq 0x1b47d(%rip), %rsi     # 0x31570
leaq 0x1b861(%rip), %rcx     # 0x3195b
movl $0x469, %edx            # imm = 0x469
callq 0xa0b0
leaq 0x1b66f(%rip), %rdi     # 0x3177a
leaq 0x1b45e(%rip), %rsi     # 0x31570
leaq 0x1b842(%rip), %rcx     # 0x3195b
movl $0x46a, %edx            # imm = 0x46A
callq 0xa0b0
leaq 0x1cbd1(%rip), %rdi     # 0x32cfb
leaq 0x1b43f(%rip), %rsi     # 0x31570
leaq 0x1b823(%rip), %rcx     # 0x3195b
movl $0x46b, %edx            # imm = 0x46B
callq 0xa0b0
leaq 0x1b1e8(%rip), %rdi     # 0x31331
leaq 0x1b420(%rip), %rsi     # 0x31570
leaq 0x1b804(%rip), %rcx     # 0x3195b
movl $0x46c, %edx            # imm = 0x46C
callq 0xa0b0
leaq 0x1b60e(%rip), %rdi     # 0x31776
leaq 0x1b401(%rip), %rsi     # 0x31570
leaq 0x1b7e5(%rip), %rcx     # 0x3195b
movl $0x46d, %edx            # imm = 0x46D
callq 0xa0b0
leaq 0x1b11e(%rip), %rdi     # 0x312a5
leaq 0x1b3e2(%rip), %rsi     # 0x31570
leaq 0x1b7c6(%rip), %rcx     # 0x3195b
movl $0x470, %edx            # imm = 0x470
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x161da
testq %rsi, %rsi
je 0x161f9
testq %rdx, %rdx
je 0x16218
cmpl $0xe00, (%rdx)          # imm = 0xE00
jne 0x16237
testq %rcx, %rcx
je 0x16256
cmpb $0x1, 0x60(%rdx)
jne 0x16275
movb $0x4, 0x28(%rcx)
movl 0x68(%rdx), %eax
movq %rax, 0x30(%rcx)
popq %rbp
retq
leaq 0x20575(%rip), %rdi     # 0x36756
leaq 0x1b388(%rip), %rsi     # 0x31570
leaq 0x1b7c7(%rip), %rcx     # 0x319b6
movl $0x47c, %edx            # imm = 0x47C
callq 0xa0b0
leaq 0x1b57a(%rip), %rdi     # 0x3177a
leaq 0x1b369(%rip), %rsi     # 0x31570
leaq 0x1b7a8(%rip), %rcx     # 0x319b6
movl $0x47d, %edx            # imm = 0x47D
callq 0xa0b0
leaq 0x1cadc(%rip), %rdi     # 0x32cfb
leaq 0x1b34a(%rip), %rsi     # 0x31570
leaq 0x1b789(%rip), %rcx     # 0x319b6
movl $0x47e, %edx            # imm = 0x47E
callq 0xa0b0
leaq 0x1b0f3(%rip), %rdi     # 0x31331
leaq 0x1b32b(%rip), %rsi     # 0x31570
leaq 0x1b76a(%rip), %rcx     # 0x319b6
movl $0x47f, %edx            # imm = 0x47F
callq 0xa0b0
leaq 0x1b519(%rip), %rdi     # 0x31776
leaq 0x1b30c(%rip), %rsi     # 0x31570
leaq 0x1b74b(%rip), %rcx     # 0x319b6
movl $0x480, %edx            # imm = 0x480
callq 0xa0b0
leaq 0x1b029(%rip), %rdi     # 0x312a5
leaq 0x1b2ed(%rip), %rsi     # 0x31570
leaq 0x1b72c(%rip), %rcx     # 0x319b6
movl $0x483, %edx            # imm = 0x483
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x162d0
testq %rsi, %rsi
je 0x162ef
testq %rdx, %rdx
je 0x1630e
cmpl $0xe00, (%rdx)          # imm = 0xE00
jne 0x1632d
testq %rcx, %rcx
je 0x1634c
cmpb $0x1, 0x60(%rdx)
jne 0x1636b
movb $0x4, 0x28(%rcx)
movq 0x68(%rdx), %rax
movq %rax, 0x30(%rcx)
popq %rbp
retq
leaq 0x2047f(%rip), %rdi     # 0x36756
leaq 0x1b292(%rip), %rsi     # 0x31570
leaq 0x1b72c(%rip), %rcx     # 0x31a11
movl $0x48f, %edx            # imm = 0x48F
callq 0xa0b0
leaq 0x1b484(%rip), %rdi     # 0x3177a
leaq 0x1b273(%rip), %rsi     # 0x31570
leaq 0x1b70d(%rip), %rcx     # 0x31a11
movl $0x490, %edx            # imm = 0x490
callq 0xa0b0
leaq 0x1c9e6(%rip), %rdi     # 0x32cfb
leaq 0x1b254(%rip), %rsi     # 0x31570
leaq 0x1b6ee(%rip), %rcx     # 0x31a11
movl $0x491, %edx            # imm = 0x491
callq 0xa0b0
leaq 0x1affd(%rip), %rdi     # 0x31331
leaq 0x1b235(%rip), %rsi     # 0x31570
leaq 0x1b6cf(%rip), %rcx     # 0x31a11
movl $0x492, %edx            # imm = 0x492
callq 0xa0b0
leaq 0x1b423(%rip), %rdi     # 0x31776
leaq 0x1b216(%rip), %rsi     # 0x31570
leaq 0x1b6b0(%rip), %rcx     # 0x31a11
movl $0x493, %edx            # imm = 0x493
callq 0xa0b0
leaq 0x1af33(%rip), %rdi     # 0x312a5
leaq 0x1b1f7(%rip), %rsi     # 0x31570
leaq 0x1b691(%rip), %rcx     # 0x31a11
movl $0x496, %edx            # imm = 0x496
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x163b4
testq %rsi, %rsi
je 0x163d3
testq %rdx, %rdx
je 0x163f2
movzbl 0x38(%rdx), %eax
cmpq $0x20, %rax
jae 0x16411
leal 0x1(%rax), %esi
movb %sil, 0x38(%rdx)
movb %cl, 0x39(%rdx,%rax)
popq %rbp
retq
leaq 0x2039b(%rip), %rdi     # 0x36756
leaq 0x1b1ae(%rip), %rsi     # 0x31570
leaq 0x1b6a3(%rip), %rcx     # 0x31a6c
movl $0x4a5, %edx            # imm = 0x4A5
callq 0xa0b0
leaq 0x1b3a0(%rip), %rdi     # 0x3177a
leaq 0x1b18f(%rip), %rsi     # 0x31570
leaq 0x1b684(%rip), %rcx     # 0x31a6c
movl $0x4a6, %edx            # imm = 0x4A6
callq 0xa0b0
leaq 0x1b37d(%rip), %rdi     # 0x31776
leaq 0x1b170(%rip), %rsi     # 0x31570
leaq 0x1b665(%rip), %rcx     # 0x31a6c
movl $0x4a7, %edx            # imm = 0x4A7
callq 0xa0b0
leaq 0x18f7c(%rip), %rdi     # 0x2f394
leaq 0x1b151(%rip), %rsi     # 0x31570
leaq 0x1b646(%rip), %rcx     # 0x31a6c
movl $0x4aa, %edx            # imm = 0x4AA
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_add_uint16_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
movl $0x1, %r13d
movzwl %bx, %ebx
movzbl %bl, %ecx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1638a
shrl $0x8, %ebx
decl %r13d
je 0x1644f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/ins.c
// Function: ins_add_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
movl $0x4, %r13d
movzbl %bl, %ecx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1638a
shrl $0x8, %ebx
decl %r13d
jne 0x16499
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq