LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/string.c
// Function: rstr_rtrim_ex
void rstr_rtrim_ex(
	ResizableString *dst,
	ResizableString *src,
	RstrCharComparer comparer
) {
	assert(dst);
	assert(src);
	assert(dst != src);
	assert(comparer);

	int len = RSTR_LEN(src);
	for (; len > 0 && comparer(RSTR_CHAR(src, len - 1)); len--);

	rstr_sub_string(dst, src, 0, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xf48b
movq %rsi, %rbx
testq %rsi, %rsi
je 0xf4aa
cmpq %rbx, %rdi
je 0xf4c9
movq %rdx, %r15
testq %rdx, %rdx
je 0xf4e8
movq %rdi, -0x30(%rbp)
movl 0x4(%rbx), %r12d
movl %r12d, %r14d
sarl $0x1f, %r14d
andl %r12d, %r14d
leal 0x1(%r12), %r13d
testl %r12d, %r12d
jle 0xf469
movb $-0x1, %al
cmpl %r12d, 0x4(%rbx)
jl 0xf457
movq 0x8(%rbx), %rax
testq %rax, %rax
leaq 0x1f344(%rip), %rcx     # 0x2e792
cmoveq %rcx, %rax
movb -0x1(%rax,%r12), %al
movsbl %al, %edi
callq *%r15
decl %r13d
decq %r12
testb %al, %al
jne 0xf433
jmp 0xf46c
movl %r14d, %r13d
movslq %r13d, %rcx
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf19a
leaq 0x1dbd7(%rip), %rdi     # 0x2d069
leaq 0x1f5ac(%rip), %rsi     # 0x2ea45
leaq 0x1faaf(%rip), %rcx     # 0x2ef4f
movl $0x1e9, %edx            # imm = 0x1E9
callq 0xa0b0
leaq 0x1fa2c(%rip), %rdi     # 0x2eedd
leaq 0x1f58d(%rip), %rsi     # 0x2ea45
leaq 0x1fa90(%rip), %rcx     # 0x2ef4f
movl $0x1ea, %edx            # imm = 0x1EA
callq 0xa0b0
leaq 0x1fa06(%rip), %rdi     # 0x2eed6
leaq 0x1f56e(%rip), %rsi     # 0x2ea45
leaq 0x1fa71(%rip), %rcx     # 0x2ef4f
movl $0x1eb, %edx            # imm = 0x1EB
callq 0xa0b0
leaq 0x1e7c8(%rip), %rdi     # 0x2dcb7
leaq 0x1f54f(%rip), %rsi     # 0x2ea45
leaq 0x1fa52(%rip), %rcx     # 0x2ef4f
movl $0x1ec, %edx            # imm = 0x1EC
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/string.c
// Function: rstr_trim_ex
void rstr_trim_ex(
	ResizableString *dst,
	ResizableString *src,
	RstrCharComparer comparer
) {
	assert(dst);
	assert(src);
	assert(dst != src);
	assert(comparer);

	int start = 0;
	for (; start < RSTR_LEN(src) && comparer(RSTR_CHAR(src, start)); start++);

	int len = RSTR_LEN(src);
	for (; len > 0 && comparer(RSTR_CHAR(src, len - 1)); len--);

	rstr_sub_string(dst, src, start, len - start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0xf5ee
movq %rsi, %rbx
testq %rsi, %rsi
je 0xf60d
cmpq %rbx, %rdi
je 0xf62c
movq %rdx, %r15
testq %rdx, %rdx
je 0xf64b
movq %rdi, -0x38(%rbp)
movl 0x4(%rbx), %r14d
leaq 0x1f241(%rip), %r13     # 0x2e792
xorl %r12d, %r12d
testl %r14d, %r14d
jle 0xf57f
movq 0x8(%rbx), %rax
testq %rax, %rax
cmoveq %r13, %rax
movsbl (%rax,%r12), %edi
callq *%r15
movl 0x4(%rbx), %r14d
testb %al, %al
je 0xf57f
movslq %r14d, %rax
incq %r12
cmpq %rax, %r12
jl 0xf559
movl %r14d, %r13d
movl %r14d, %eax
sarl $0x1f, %eax
andl %r14d, %eax
movl %eax, -0x2c(%rbp)
incl %r14d
testl %r13d, %r13d
jle 0xf5c7
movb $-0x1, %al
cmpl %r13d, 0x4(%rbx)
jl 0xf5b5
movq 0x8(%rbx), %rax
testq %rax, %rax
leaq 0x1f1e6(%rip), %rcx     # 0x2e792
cmoveq %rcx, %rax
movb -0x1(%rax,%r13), %al
movsbl %al, %edi
callq *%r15
decl %r14d
decq %r13
testb %al, %al
jne 0xf591
jmp 0xf5cb
movl -0x2c(%rbp), %r14d
movl %r12d, %edx
subl %r12d, %r14d
movslq %r14d, %rcx
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf19a
leaq 0x1da74(%rip), %rdi     # 0x2d069
leaq 0x1f449(%rip), %rsi     # 0x2ea45
leaq 0x1f997(%rip), %rcx     # 0x2ef9a
movl $0x1f9, %edx            # imm = 0x1F9
callq 0xa0b0
leaq 0x1f8c9(%rip), %rdi     # 0x2eedd
leaq 0x1f42a(%rip), %rsi     # 0x2ea45
leaq 0x1f978(%rip), %rcx     # 0x2ef9a
movl $0x1fa, %edx            # imm = 0x1FA
callq 0xa0b0
leaq 0x1f8a3(%rip), %rdi     # 0x2eed6
leaq 0x1f40b(%rip), %rsi     # 0x2ea45
leaq 0x1f959(%rip), %rcx     # 0x2ef9a
movl $0x1fb, %edx            # imm = 0x1FB
callq 0xa0b0
leaq 0x1e665(%rip), %rdi     # 0x2dcb7
leaq 0x1f3ec(%rip), %rsi     # 0x2ea45
leaq 0x1f93a(%rip), %rcx     # 0x2ef9a
movl $0x1fc, %edx            # imm = 0x1FC
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/string.c
// Function: rstr_ltrim
void rstr_ltrim(
	ResizableString *dst,
	ResizableString *src,
	char chr
) {
	assert(dst);
	assert(src);
	assert(dst != src);

	int start = 0;
	for (; start < RSTR_LEN(src) && RSTR_CHAR(src, start) == chr; start++);

	rstr_sub_string(dst, src, start, RSTR_LEN(src) - start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xf6b9
testq %rsi, %rsi
je 0xf6d8
cmpq %rsi, %rdi
je 0xf6f7
movl 0x4(%rsi), %eax
testl %eax, %eax
jle 0xf6aa
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
leaq 0x1f100(%rip), %r8      # 0x2e792
cmovneq %rcx, %r8
xorl %ecx, %ecx
cmpb %dl, (%r8,%rcx)
jne 0xf6ac
incq %rcx
cmpq %rcx, %rax
jne 0xf698
movl %eax, %ecx
jmp 0xf6ac
xorl %ecx, %ecx
movl %ecx, %edx
subl %ecx, %eax
movslq %eax, %rcx
popq %rbp
jmp 0xf19a
leaq 0x1d9a9(%rip), %rdi     # 0x2d069
leaq 0x1f37e(%rip), %rsi     # 0x2ea45
leaq 0x1f916(%rip), %rcx     # 0x2efe4
movl $0x20c, %edx            # imm = 0x20C
callq 0xa0b0
leaq 0x1f7fe(%rip), %rdi     # 0x2eedd
leaq 0x1f35f(%rip), %rsi     # 0x2ea45
leaq 0x1f8f7(%rip), %rcx     # 0x2efe4
movl $0x20d, %edx            # imm = 0x20D
callq 0xa0b0
leaq 0x1f7d8(%rip), %rdi     # 0x2eed6
leaq 0x1f340(%rip), %rsi     # 0x2ea45
leaq 0x1f8d8(%rip), %rcx     # 0x2efe4
movl $0x20e, %edx            # imm = 0x20E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/string.c
// Function: rstr_rtrim
void rstr_rtrim(
	ResizableString *dst,
	ResizableString *src,
	char chr
) {
	assert(dst);
	assert(src);
	assert(dst != src);

	int len = RSTR_LEN(src);
	for (; len > 0 && RSTR_CHAR(src, len - 1) == chr; len--);

	rstr_sub_string(dst, src, 0, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xf784
testq %rsi, %rsi
je 0xf7a3
cmpq %rsi, %rdi
je 0xf7c2
movl 0x4(%rsi), %eax
movsbl %dl, %edx
movl %eax, %ecx
sarl $0x1f, %ecx
andl %eax, %ecx
leal 0x1(%rax), %r8d
leaq 0x1f04d(%rip), %r9      # 0x2e792
movq %rax, %r10
testl %r10d, %r10d
jle 0xf776
movl $0xffffffff, %r11d      # imm = 0xFFFFFFFF
cmpl %r10d, %eax
jl 0xf769
movq 0x8(%rsi), %r11
testq %r11, %r11
cmoveq %r9, %r11
movsbl -0x1(%r11,%r10), %r11d
decl %r8d
decq %r10
cmpl %edx, %r11d
je 0xf748
jmp 0xf779
movl %ecx, %r8d
movslq %r8d, %rcx
xorl %edx, %edx
popq %rbp
jmp 0xf19a
leaq 0x1d8de(%rip), %rdi     # 0x2d069
leaq 0x1f2b3(%rip), %rsi     # 0x2ea45
leaq 0x1f887(%rip), %rcx     # 0x2f020
movl $0x21b, %edx            # imm = 0x21B
callq 0xa0b0
leaq 0x1f733(%rip), %rdi     # 0x2eedd
leaq 0x1f294(%rip), %rsi     # 0x2ea45
leaq 0x1f868(%rip), %rcx     # 0x2f020
movl $0x21c, %edx            # imm = 0x21C
callq 0xa0b0
leaq 0x1f70d(%rip), %rdi     # 0x2eed6
leaq 0x1f275(%rip), %rsi     # 0x2ea45
leaq 0x1f849(%rip), %rcx     # 0x2f020
movl $0x21d, %edx            # imm = 0x21D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/string.c
// Function: rstr_trim
void rstr_trim(
	ResizableString *dst,
	ResizableString *src,
	char chr
) {
	assert(dst);
	assert(src);
	assert(dst != src);

	int start = 0;
	for (; start < RSTR_LEN(src) && RSTR_CHAR(src, start) == chr; start++);

	int len = RSTR_LEN(src);
	for (; len > 0 && RSTR_CHAR(src, len - 1) == chr; len--);

	rstr_sub_string(dst, src, start, len - start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xf88a
testq %rsi, %rsi
je 0xf8a9
cmpq %rsi, %rdi
je 0xf8c8
movl 0x4(%rsi), %eax
leaq 0x1ef86(%rip), %rcx     # 0x2e792
testl %eax, %eax
jle 0xf831
movq 0x8(%rsi), %r9
testq %r9, %r9
cmoveq %rcx, %r9
xorl %r8d, %r8d
cmpb %dl, (%r9,%r8)
jne 0xf834
incq %r8
cmpq %r8, %rax
jne 0xf81e
movl %eax, %r8d
jmp 0xf834
xorl %r8d, %r8d
movsbl %dl, %r10d
movl %eax, %edx
sarl $0x1f, %edx
andl %eax, %edx
leal 0x1(%rax), %r9d
movq %rax, %r11
testl %r11d, %r11d
jle 0xf873
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl %r11d, %eax
jl 0xf866
movq 0x8(%rsi), %rbx
testq %rbx, %rbx
cmoveq %rcx, %rbx
movsbl -0x1(%rbx,%r11), %ebx
decl %r9d
decq %r11
cmpl %r10d, %ebx
je 0xf846
jmp 0xf876
movl %edx, %r9d
movl %r8d, %edx
subl %r8d, %r9d
movslq %r9d, %rcx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xf19a
leaq 0x1d7d8(%rip), %rdi     # 0x2d069
leaq 0x1f1ad(%rip), %rsi     # 0x2ea45
leaq 0x1f7bd(%rip), %rcx     # 0x2f05c
movl $0x22a, %edx            # imm = 0x22A
callq 0xa0b0
leaq 0x1f62d(%rip), %rdi     # 0x2eedd
leaq 0x1f18e(%rip), %rsi     # 0x2ea45
leaq 0x1f79e(%rip), %rcx     # 0x2f05c
movl $0x22b, %edx            # imm = 0x22B
callq 0xa0b0
leaq 0x1f607(%rip), %rdi     # 0x2eed6
leaq 0x1f16f(%rip), %rsi     # 0x2ea45
leaq 0x1f77f(%rip), %rcx     # 0x2f05c
movl $0x22c, %edx            # imm = 0x22C
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/util.c
// Function: util_get_file_size
int32_t util_get_file_size(const char *path) {
	assert(path);

	struct stat statbuff;
	if (stat(path, &statbuff) < 0) {
		return -1;
	}
	
	if (statbuff.st_size > INT_MAX) {
		return -1;
	}

	return (int32_t)statbuff.st_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x98, %rsp
testq %rdi, %rdi
je 0x103d8
leaq -0x98(%rbp), %rbx
movq %rbx, %rsi
callq 0xa110
movq 0x30(%rbx), %rcx
cmpq $0x7fffffff, %rcx       # imm = 0x7FFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmovgl %edx, %ecx
testl %eax, %eax
cmovsl %edx, %ecx
movl %ecx, %eax
addq $0x98, %rsp
popq %rbx
popq %rbp
retq
leaq 0x23b49(%rip), %rdi     # 0x33f28
leaq 0x1f05a(%rip), %rsi     # 0x2f440
leaq 0x1f05a(%rip), %rcx     # 0x2f447
movl $0x15, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/util.c
// Function: util_put_file_content
int32_t util_put_file_content(const char *path, const char *content, int32_t len) {
	assert(path);
	assert(content);
	assert(len >= 0);

	FILE *file = NULL;

	file = fopen(path, "w+");
	if (file == NULL) {
		goto err;
	}

	if (len > 0) {
		int32_t c = len;
		while ((c -= fwrite(content, sizeof(char), c, file)) > 0);
	}

	fclose(file);

err:
	if (file != NULL) {
		fclose(file);
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x10468
movq %rsi, %r14
testq %rsi, %rsi
je 0x10487
movl %edx, %ebx
testl %edx, %edx
js 0x104a6
leaq 0x1f09c(%rip), %rsi     # 0x2f4bb
callq 0xa150
testq %rax, %rax
je 0x10458
movq %rax, %r15
testl %ebx, %ebx
je 0x10448
movl %ebx, %edx
movl $0x1, %esi
movq %r14, %rdi
movq %r15, %rcx
callq 0xa180
subl %eax, %ebx
testl %ebx, %ebx
jg 0x10430
movq %r15, %rdi
callq 0xa070
movq %r15, %rdi
callq 0xa070
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23ab9(%rip), %rdi     # 0x33f28
leaq 0x1efca(%rip), %rsi     # 0x2f440
leaq 0x1eff3(%rip), %rcx     # 0x2f470
movl $0x24, %edx
callq 0xa0b0
leaq 0x1f025(%rip), %rdi     # 0x2f4b3
leaq 0x1efab(%rip), %rsi     # 0x2f440
leaq 0x1efd4(%rip), %rcx     # 0x2f470
movl $0x25, %edx
callq 0xa0b0
leaq 0x1d090(%rip), %rdi     # 0x2d53d
leaq 0x1ef8c(%rip), %rsi     # 0x2f440
leaq 0x1efb5(%rip), %rcx     # 0x2f470
movl $0x26, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/util.c
// Function: util_get_file_content
const char * util_get_file_content(const char *path, int32_t *file_size) {
	assert(path);
	assert(file_size);

	char *content = NULL;
	FILE *file = NULL;

	int32_t fsize = util_get_file_size(path);
	if (fsize < 0) {
		*file_size = -1;
		goto err;
	} else {
		*file_size = fsize;
		if (fsize == 0) {
			return NULL;
		}
	}

	content = (char *)malloc(fsize);
	if (content == NULL) {
		goto err;
	}

	file = fopen(path, "r");
	if (file == NULL) {
		goto err;
	}

	int32_t c = fsize;
	while ((c -= fread(content, sizeof(char), c, file)) > 0);

	fclose(file);

	return content;

err:
	if (content != NULL) {
		free(content);
	}
	if (file != NULL) {
		fclose(file);
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
testq %rdi, %rdi
je 0x1058c
movq %rsi, %rbx
testq %rsi, %rsi
je 0x105ab
movq %rdi, %r14
leaq -0xa8(%rbp), %r15
movq %r15, %rsi
callq 0xa110
movq 0x30(%r15), %r15
cmpq $0x7fffffff, %r15       # imm = 0x7FFFFFFF
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmovgl %ecx, %r15d
testl %eax, %eax
cmovnsl %r15d, %ecx
testl %ecx, %ecx
js 0x10569
movl %ecx, (%rbx)
je 0x1056f
movl %ecx, %edi
callq 0xa130
testq %rax, %rax
je 0x1056f
movq %rax, %rbx
leaq 0x1ff7d(%rip), %rsi     # 0x304b1
movq %r14, %rdi
callq 0xa150
testq %rax, %rax
je 0x10582
movq %rax, %r14
movl %r15d, %edx
movl $0x1, %esi
movq %rbx, %rdi
movq %r14, %rcx
callq 0xa050
subl %eax, %r15d
testl %r15d, %r15d
jg 0x10544
movq %r14, %rdi
callq 0xa070
jmp 0x10571
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0xa1a0
jmp 0x1056f
leaq 0x23995(%rip), %rdi     # 0x33f28
leaq 0x1eea6(%rip), %rsi     # 0x2f440
leaq 0x1ef1d(%rip), %rcx     # 0x2f4be
movl $0x3e, %edx
callq 0xa0b0
leaq 0x1ef47(%rip), %rdi     # 0x2f4f9
leaq 0x1ee87(%rip), %rsi     # 0x2f440
leaq 0x1eefe(%rip), %rcx     # 0x2f4be
movl $0x3f, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/util.c
// Function: util_is_literal_char_esc
bool util_is_literal_char_esc(char chr) {
	static const char esc_list[] = {'a', 'b', 'f', 'n', 'r', 't', 'v', '\\', '\'', '0', 0};

	for (int i = 0; esc_list[i] != 0; i++) {
		if (esc_list[i] == chr) {
			return true;
		}
	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
leaq 0x1eea1(%rip), %rcx     # 0x2f503
movb (%rax,%rcx), %dl
cmpb %dil, %dl
je 0x10677
leaq 0x1(%rax), %rsi
cmpq $0x9, %rax
movq %rsi, %rax
jne 0x10662
cmpb %dil, %dl
sete %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/util.c
// Function: util_is_literal_char
bool util_is_literal_char(
	const char *str,
	uint32_t len
) {
	assert(str);

	if (len == 3) {
		return str[0] == '\''
			&& util_is_literal_char_item(str[1])
			&& str[2] == '\'';
	} else if (len == 4) {
		return str[0] == '\''
			&& str[1] == '\\'
			&& util_is_literal_char_esc(str[2])
			&& str[3] == '\'';
	} else {
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1076f
movq %rdi, %rbx
cmpl $0x4, %esi
je 0x10728
cmpl $0x3, %esi
jne 0x10768
cmpb $0x27, (%rbx)
jne 0x10768
movsbq 0x1(%rbx), %r14
cmpq $0x27, %r14
je 0x10768
callq 0xa190
movq (%rax), %rax
movzwl (%rax,%r14,2), %eax
movl $0x2, %ecx
testl $0x8001, %eax           # imm = 0x8001
jne 0x1075f
jmp 0x10768
cmpb $0x27, (%rbx)
jne 0x10768
cmpb $0x5c, 0x1(%rbx)
jne 0x10768
movb 0x2(%rbx), %al
xorl %ecx, %ecx
leaq 0x1edc4(%rip), %rdx     # 0x2f503
movb (%rcx,%rdx), %sil
cmpb %al, %sil
je 0x10755
leaq 0x1(%rcx), %rdi
cmpq $0x9, %rcx
movq %rdi, %rcx
jne 0x1073f
movl $0x3, %ecx
cmpb %al, %sil
jne 0x10768
cmpb $0x27, (%rbx,%rcx)
sete %al
jmp 0x1076a
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1e335(%rip), %rdi     # 0x2eaab
leaq 0x1ecc3(%rip), %rsi     # 0x2f440
leaq 0x1ed95(%rip), %rcx     # 0x2f519
movl $0xae, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/util.c
// Function: util_is_literal_string
bool util_is_literal_string(
	const char *str,
	uint32_t len
) {
	assert(str);

	if (len >= 2) {
		if (str[0] != '"'
				|| str[len - 1] != '"') {
			return false;
		}

		for (size_t i = 1; i < len - 2; i++) {
			if (!util_is_literal_string_item(str[i])
					&& str[i] != '\\'
					&& i + 1 >= len - 2
					&& !util_is_literal_string_esc(str[i + 1])) {
				return false;
			}
		}

		return true;
	} else {
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x10846
movl %esi, %r14d
cmpl $0x2, %esi
jb 0x10835
movq %rdi, %r15
cmpb $0x22, (%rdi)
jne 0x10835
leal -0x1(%r14), %eax
cmpb $0x22, (%r15,%rax)
jne 0x10835
addl $-0x2, %r14d
movb $0x1, %al
cmpl $0x2, %r14d
jb 0x10837
movl $0x1, %r12d
leaq 0x1ed31(%rip), %r13     # 0x2f50e
movsbq (%r15,%r12), %rbx
cmpq $0x22, %rbx
je 0x10800
callq 0xa190
cmpb $0x5c, %bl
je 0x10829
movq (%rax), %rax
movzwl (%rax,%rbx,2), %eax
andl $0x8001, %eax           # imm = 0x8001
jne 0x10829
incq %r12
cmpq %r14, %r12
jb 0x1082c
movb (%r15,%r12), %al
xorl %ecx, %ecx
movb (%rcx,%r13), %dl
cmpb %al, %dl
je 0x10823
leaq 0x1(%rcx), %rsi
cmpq $0x9, %rcx
movq %rsi, %rcx
jne 0x1080e
cmpb %al, %dl
je 0x1082c
jmp 0x10835
incq %r12
cmpq %r14, %r12
jne 0x107dd
movb $0x1, %al
jmp 0x10837
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e25e(%rip), %rdi     # 0x2eaab
leaq 0x1ebec(%rip), %rsi     # 0x2f440
leaq 0x1ecf1(%rip), %rcx     # 0x2f54c
movl $0xc2, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/util.c
// Function: util_is_literal_uint_bin
bool util_is_literal_uint_bin(
	const char *str,
	uint32_t len
) {
	assert(str);

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

// Assembly:
testq %rdi, %rdi
je 0x108be
cmpl $0x3, %esi
jb 0x108bb
cmpb $0x30, (%rdi)
jne 0x108bb
cmpb $0x62, 0x1(%rdi)
jne 0x108bb
movb 0x2(%rdi), %al
andb $-0x2, %al
cmpb $0x30, %al
jne 0x108bb
cmpl $0x3, %esi
je 0x108b8
movl %esi, %ecx
movl $0x3, %edx
movabsq $0x800000000003, %rsi   # imm = 0x800000000003
xorl %eax, %eax
movzbl (%rdi,%rdx), %r8d
addl $-0x30, %r8d
cmpl $0x2f, %r8d
ja 0x108ba
btq %r8, %rsi
jae 0x108ba
incq %rdx
cmpq %rdx, %rcx
jne 0x1089b
movb $0x1, %al
retq
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1e1e2(%rip), %rdi     # 0x2eaab
leaq 0x1eb70(%rip), %rsi     # 0x2f440
leaq 0x1ecaa(%rip), %rcx     # 0x2f581
movl $0xdd, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/util.c
// Function: util_is_literal_int_bin
bool util_is_literal_int_bin(
	const char *str,
	uint32_t len
) {
	assert(str && len > 0);

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

// Assembly:
testq %rdi, %rdi
je 0x10905
testl %esi, %esi
je 0x10905
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x108fb
cmpl $0x2b, %eax
jne 0x10865
incq %rdi
decl %esi
jmp 0x10865
pushq %rbp
movq %rsp, %rbp
leaq 0x1eca8(%rip), %rdi     # 0x2f5b8
leaq 0x1eb29(%rip), %rsi     # 0x2f440
leaq 0x1eca9(%rip), %rcx     # 0x2f5c7
movl $0xf6, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/util.c
// Function: util_is_literal_uint_oct
bool util_is_literal_uint_oct(
	const char *str,
	uint32_t len
) {
	assert(str);

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

// Assembly:
testq %rdi, %rdi
je 0x10984
cmpl $0x3, %esi
jb 0x10981
cmpb $0x30, (%rdi)
jne 0x10981
cmpb $0x6f, 0x1(%rdi)
jne 0x10981
movb 0x2(%rdi), %al
andb $-0x8, %al
cmpb $0x30, %al
jne 0x10981
movb $0x1, %al
cmpl $0x3, %esi
je 0x10983
movl %esi, %ecx
addq $-0x4, %rcx
xorl %edx, %edx
movb 0x3(%rdi,%rdx), %al
movl %eax, %esi
andb $-0x8, %sil
cmpb $0x30, %sil
sete %sil
cmpb $0x5f, %al
sete %al
orb %sil, %al
cmpb $0x1, %al
jne 0x10983
leaq 0x1(%rdx), %rsi
cmpq %rdx, %rcx
movq %rsi, %rdx
jne 0x10955
jmp 0x10983
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1e11c(%rip), %rdi     # 0x2eaab
leaq 0x1eaaa(%rip), %rsi     # 0x2f440
leaq 0x1ec60(%rip), %rcx     # 0x2f5fd
movl $0x103, %edx            # imm = 0x103
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/util.c
// Function: util_is_literal_int_oct
bool util_is_literal_int_oct(
	const char *str,
	uint32_t len
) {
	assert(str && len > 0);

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

// Assembly:
testq %rdi, %rdi
je 0x109cb
testl %esi, %esi
je 0x109cb
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x109c1
cmpl $0x2b, %eax
jne 0x10928
incq %rdi
decl %esi
jmp 0x10928
pushq %rbp
movq %rsp, %rbp
leaq 0x1ebe2(%rip), %rdi     # 0x2f5b8
leaq 0x1ea63(%rip), %rsi     # 0x2f440
leaq 0x1ec50(%rip), %rcx     # 0x2f634
movl $0x11c, %edx            # imm = 0x11C
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/util.c
// Function: util_is_literal_uint_dec
bool util_is_literal_uint_dec(
	const char *str,
	uint32_t len
) {
	assert(str);

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

// Assembly:
testq %rdi, %rdi
je 0x10a39
testl %esi, %esi
je 0x10a36
movb (%rdi), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x10a36
movb $0x1, %al
cmpl $0x1, %esi
je 0x10a35
movl %esi, %ecx
addq $-0x2, %rcx
xorl %edx, %edx
movb 0x1(%rdi,%rdx), %al
leal -0x30(%rax), %esi
cmpb $0xa, %sil
setb %sil
cmpb $0x5f, %al
sete %al
orb %sil, %al
cmpb $0x1, %al
jne 0x10a35
leaq 0x1(%rdx), %rsi
cmpq %rdx, %rcx
movq %rsi, %rdx
jne 0x10a0e
retq
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1e067(%rip), %rdi     # 0x2eaab
leaq 0x1e9f5(%rip), %rsi     # 0x2f440
leaq 0x1ec18(%rip), %rcx     # 0x2f66a
movl $0x129, %edx            # imm = 0x129
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/util.c
// Function: util_is_literal_int_dec
bool util_is_literal_int_dec(
	const char *str,
	uint32_t len
) {
	assert(str && len > 0);

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

// Assembly:
testq %rdi, %rdi
je 0x10afd
testl %esi, %esi
je 0x10afd
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x10a7a
cmpl $0x2b, %eax
jne 0x10abc
decl %esi
je 0x10afa
movb 0x1(%rdi), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x10afa
movb $0x1, %al
cmpl $0x1, %esi
je 0x10abb
movl %esi, %ecx
movl $0x2, %edx
movb (%rdi,%rdx), %al
leal -0x30(%rax), %esi
cmpb $0xa, %sil
setb %sil
cmpb $0x5f, %al
sete %al
orb %sil, %al
cmpb $0x1, %al
jne 0x10abb
leaq 0x1(%rdx), %rsi
cmpq %rdx, %rcx
movq %rsi, %rdx
jne 0x10a95
retq
addb $-0x30, %al
cmpb $0x9, %al
ja 0x10afa
movb $0x1, %al
cmpl $0x1, %esi
je 0x10abb
movl %esi, %ecx
addq $-0x2, %rcx
xorl %edx, %edx
movb 0x1(%rdi,%rdx), %al
leal -0x30(%rax), %esi
cmpb $0xa, %sil
setb %sil
cmpb $0x5f, %al
sete %al
orb %sil, %al
cmpb $0x1, %al
jne 0x10abb
leaq 0x1(%rdx), %rsi
cmpq %rdx, %rcx
movq %rsi, %rdx
jne 0x10ad1
jmp 0x10abb
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1eab0(%rip), %rdi     # 0x2f5b8
leaq 0x1e931(%rip), %rsi     # 0x2f440
leaq 0x1eb8b(%rip), %rcx     # 0x2f6a1
movl $0x140, %edx            # imm = 0x140
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x10bad
cmpl $0x3, %esi
jb 0x10ba6
cmpb $0x30, (%rdi)
jne 0x10ba6
cmpb $0x78, 0x1(%rdi)
jne 0x10ba6
movb 0x2(%rdi), %al
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x10b61
movzbl %al, %ecx
xorl %eax, %eax
addl $-0x41, %ecx
cmpl $0x25, %ecx
ja 0x10ba8
movabsq $0x3f0000003f, %rdx     # imm = 0x3F0000003F
btq %rcx, %rdx
jae 0x10ba8
movb $0x1, %al
cmpl $0x3, %esi
je 0x10ba8
movl %esi, %eax
movl $0x3, %ecx
movzbl (%rdi,%rcx), %edx
leal -0x30(%rdx), %esi
cmpb $0xa, %sil
setb %sil
leal -0x61(%rdx), %r8d
cmpb $0x6, %r8b
setb %r8b
orb %sil, %r8b
jne 0x10b97
leal -0x41(%rdx), %esi
cmpl $0x6, %esi
jae 0x10ba1
incq %rcx
cmpq %rcx, %rax
jne 0x10b6f
jmp 0x10ba9
cmpl $0x5f, %edx
je 0x10b97
xorl %eax, %eax
retq
setbe %al
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1def3(%rip), %rdi     # 0x2eaab
leaq 0x1e881(%rip), %rsi     # 0x2f440
leaq 0x1eb11(%rip), %rcx     # 0x2f6d7
movl $0x14d, %edx            # imm = 0x14D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x10bf4
testl %esi, %esi
je 0x10bf4
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x10bea
cmpl $0x2b, %eax
jne 0x10b20
incq %rdi
decl %esi
jmp 0x10b20
pushq %rbp
movq %rsp, %rbp
leaq 0x1e9b9(%rip), %rdi     # 0x2f5b8
leaq 0x1e83a(%rip), %rsi     # 0x2f440
leaq 0x1eb01(%rip), %rcx     # 0x2f70e
movl $0x166, %edx            # imm = 0x166
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x10cae
movl %esi, %r14d
movq %rdi, %rbx
callq 0x106e4
testb %al, %al
je 0x10ccd
cmpl $0x4, %r14d
je 0x10c4f
cmpl $0x3, %r14d
jne 0x10cec
movb 0x1(%rbx), %al
jmp 0x10c86
movb 0x2(%rbx), %cl
cmpb $0x61, %cl
jne 0x10c60
leaq 0x1eee2(%rip), %rax     # 0x2fb40
jmp 0x10c7f
xorl %edx, %edx
leaq 0x1eed7(%rip), %rax     # 0x2fb40
cmpq $0x14, %rdx
je 0x10c8f
leaq 0x2(%rdx), %rsi
cmpb %cl, 0x2(%rdx,%rax)
movq %rsi, %rdx
jne 0x10c69
addq %rsi, %rax
movb 0x1(%rax), %al
cmpb $-0x1, %al
je 0x10c8f
movsbq %al, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1d6da(%rip), %rdi     # 0x2e370
leaq 0x1e7a3(%rip), %rsi     # 0x2f440
leaq 0x1eaa0(%rip), %rcx     # 0x2f744
movl $0x17f, %edx            # imm = 0x17F
callq 0xa0b0
leaq 0x1ddf6(%rip), %rdi     # 0x2eaab
leaq 0x1e784(%rip), %rsi     # 0x2f440
leaq 0x1ea81(%rip), %rcx     # 0x2f744
movl $0x173, %edx            # imm = 0x173
callq 0xa0b0
leaq 0x1d69c(%rip), %rdi     # 0x2e370
leaq 0x1e765(%rip), %rsi     # 0x2f440
leaq 0x1ea62(%rip), %rcx     # 0x2f744
movl $0x176, %edx            # imm = 0x176
callq 0xa0b0
leaq 0x1d67d(%rip), %rdi     # 0x2e370
leaq 0x1e746(%rip), %rsi     # 0x2f440
leaq 0x1ea43(%rip), %rcx     # 0x2f744
movl $0x185, %edx            # imm = 0x185
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x10d76
testq %rsi, %rsi
je 0x10d95
cmpl $0x1, %edx
jbe 0x10db4
cmpb $0x22, (%rsi)
jne 0x10d57
leal -0x1(%rdx), %eax
cmpb $0x22, (%rsi,%rax)
jne 0x10d57
incq %rsi
addl $-0x2, %edx
popq %rbp
jmp 0x10dd3
leaq 0x1ea6a(%rip), %rdi     # 0x2f7c8
leaq 0x1e6db(%rip), %rsi     # 0x2f440
leaq 0x1ea12(%rip), %rcx     # 0x2f77e
movl $0x1a0, %edx            # imm = 0x1A0
callq 0xa0b0
leaq 0x1dcc3(%rip), %rdi     # 0x2ea40
leaq 0x1e6bc(%rip), %rsi     # 0x2f440
leaq 0x1e9f3(%rip), %rcx     # 0x2f77e
movl $0x19d, %edx            # imm = 0x19D
callq 0xa0b0
leaq 0x1dd0f(%rip), %rdi     # 0x2eaab
leaq 0x1e69d(%rip), %rsi     # 0x2f440
leaq 0x1e9d4(%rip), %rcx     # 0x2f77e
movl $0x19e, %edx            # imm = 0x19E
callq 0xa0b0
leaq 0x1ea04(%rip), %rdi     # 0x2f7bf
leaq 0x1e67e(%rip), %rsi     # 0x2f440
leaq 0x1e9b5(%rip), %rcx     # 0x2f77e
movl $0x19f, %edx            # imm = 0x19F
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x10e47
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
leaq 0x1ed47(%rip), %r13     # 0x2fb40
movb (%r14,%r12), %al
cmpb $0x5c, %al
jne 0x10e34
incq %r12
cmpq %rbx, %r12
jae 0x10e75
movb (%r14,%r12), %al
movq %r13, %rcx
cmpb $0x61, %al
je 0x10e2d
xorl %edx, %edx
cmpq $0x14, %rdx
je 0x10e56
leaq 0x2(%rdx), %rcx
cmpb %al, 0x2(%rdx,%r13)
movq %rcx, %rdx
jne 0x10e16
addq %r13, %rcx
movb 0x1(%rcx), %al
cmpb $-0x1, %al
je 0x10e56
movsbl %al, %esi
movq %r15, %rdi
callq 0xe3fa
incq %r12
cmpq %rbx, %r12
jb 0x10df9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ec89(%rip), %rdi     # 0x2fae6
leaq 0x1e5dc(%rip), %rsi     # 0x2f440
leaq 0x1ec90(%rip), %rcx     # 0x2fafb
movl $0x2dc, %edx            # imm = 0x2DC
callq 0xa0b0
leaq 0x1d4f4(%rip), %rdi     # 0x2e370
leaq 0x1e5bd(%rip), %rsi     # 0x2f440
leaq 0x1ec71(%rip), %rcx     # 0x2fafb
movl $0x2df, %edx            # imm = 0x2DF
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x10f14
cmpl $0x3, %esi
jb 0x10f14
cmpb $0x30, (%rdi)
jne 0x10f14
cmpb $0x62, 0x1(%rdi)
jne 0x10f14
movb 0x2(%rdi), %al
andb $-0x2, %al
cmpb $0x30, %al
jne 0x10f14
movl %esi, %edx
incq %rdx
xorl %ecx, %ecx
xorl %eax, %eax
movzbl -0x2(%rdi,%rdx), %esi
movl %esi, %r8d
andb $-0x2, %r8b
cmpb $0x30, %r8b
jne 0x10ee0
addl $-0x30, %esi
shll %cl, %esi
incl %ecx
movslq %esi, %rsi
orq %rsi, %rax
jmp 0x10eea
cmpl $0x5f, %esi
je 0x10eea
cmpl $0x75, %esi
jne 0x10ef5
decq %rdx
cmpq $0x3, %rdx
ja 0x10ebf
popq %rbp
retq
leaq 0x1d474(%rip), %rdi     # 0x2e370
leaq 0x1e53d(%rip), %rsi     # 0x2f440
leaq 0x1e92d(%rip), %rcx     # 0x2f837
movl $0x1bb, %edx            # imm = 0x1BB
callq 0xa0b0
leaq 0x1e8d2(%rip), %rdi     # 0x2f7ed
leaq 0x1e51e(%rip), %rsi     # 0x2f440
leaq 0x1e90e(%rip), %rcx     # 0x2f837
movl $0x1ab, %edx            # imm = 0x1AB
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x10f7b
testl %esi, %esi
je 0x10f7b
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x10f6c
cmpl $0x2b, %eax
jne 0x10f66
incq %rdi
decl %esi
popq %rbp
jmp 0x10e94
incq %rdi
decl %esi
callq 0x10e94
negq %rax
popq %rbp
retq
leaq 0x1e636(%rip), %rdi     # 0x2f5b8
leaq 0x1e4b7(%rip), %rsi     # 0x2f440
leaq 0x1e8e0(%rip), %rcx     # 0x2f870
movl $0x1cd, %edx            # imm = 0x1CD
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x11033
cmpl $0x3, %esi
jb 0x11033
cmpb $0x30, (%rdi)
jne 0x11033
cmpb $0x6f, 0x1(%rdi)
jne 0x11033
movb 0x2(%rdi), %al
andb $-0x8, %al
cmpb $0x30, %al
jne 0x11033
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 0x10ffe
andl $0x7, %esi
imulq %rdx, %rsi
addq %rsi, %rax
shlq $0x3, %rdx
jmp 0x11009
cmpq $0x5f, %rsi
je 0x11009
cmpl $0x75, %esi
jne 0x11014
decq %rcx
cmpq $0x3, %rcx
ja 0x10fdc
popq %rbp
retq
leaq 0x1d355(%rip), %rdi     # 0x2e370
leaq 0x1e41e(%rip), %rsi     # 0x2f440
leaq 0x1e8c8(%rip), %rcx     # 0x2f8f1
movl $0x1f7, %edx            # imm = 0x1F7
callq 0xa0b0
leaq 0x1e86d(%rip), %rdi     # 0x2f8a7
leaq 0x1e3ff(%rip), %rsi     # 0x2f440
leaq 0x1e8a9(%rip), %rcx     # 0x2f8f1
movl $0x1e6, %edx            # imm = 0x1E6
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x1109a
testl %esi, %esi
je 0x1109a
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x1108b
cmpl $0x2b, %eax
jne 0x11085
incq %rdi
decl %esi
popq %rbp
jmp 0x10fae
incq %rdi
decl %esi
callq 0x10fae
negq %rax
popq %rbp
retq
leaq 0x1e517(%rip), %rdi     # 0x2f5b8
leaq 0x1e398(%rip), %rsi     # 0x2f440
leaq 0x1e87b(%rip), %rcx     # 0x2f92a
movl $0x209, %edx            # imm = 0x209
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x11146
testl %esi, %esi
je 0x11146
movb (%rdi), %al
addb $-0x30, %al
cmpb $0xa, %al
jae 0x11146
movl %esi, %eax
leaq (%rdi,%rax), %rcx
decq %rcx
movl $0x1, %edx
xorl %eax, %eax
movzbl (%rcx), %esi
leal -0x30(%rsi), %r8d
cmpb $0x9, %r8b
ja 0x11112
andl $0xf, %esi
imulq %rdx, %rsi
addq %rsi, %rax
addq %rdx, %rdx
leaq (%rdx,%rdx,4), %rdx
jmp 0x1111d
cmpq $0x5f, %rsi
je 0x1111d
cmpl $0x75, %esi
jne 0x11127
decq %rcx
cmpq %rdi, %rcx
jae 0x110f2
popq %rbp
retq
leaq 0x1d242(%rip), %rdi     # 0x2e370
leaq 0x1e30b(%rip), %rsi     # 0x2f440
leaq 0x1e84d(%rip), %rcx     # 0x2f989
movl $0x232, %edx            # imm = 0x232
callq 0xa0b0
leaq 0x1e814(%rip), %rdi     # 0x2f961
leaq 0x1e2ec(%rip), %rsi     # 0x2f440
leaq 0x1e82e(%rip), %rcx     # 0x2f989
movl $0x222, %edx            # imm = 0x222
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x111ad
testl %esi, %esi
je 0x111ad
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x1119e
cmpl $0x2b, %eax
jne 0x11198
incq %rdi
decl %esi
popq %rbp
jmp 0x110cd
incq %rdi
decl %esi
callq 0x110cd
negq %rax
popq %rbp
retq
leaq 0x1e404(%rip), %rdi     # 0x2f5b8
leaq 0x1e285(%rip), %rsi     # 0x2f440
leaq 0x1e800(%rip), %rcx     # 0x2f9c2
movl $0x244, %edx            # imm = 0x244
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/util.c
// Function: util_get_uint64_hex_val
uint64_t util_get_uint64_hex_val(const char *str, uint32_t len) {
	#define	_IS_HEX_DIGIT(chr)	(((chr) >= '0' && (chr) <= '9') || ((chr) >= 'a' && (chr) <= 'f') || ((chr) >= 'A' && (chr) <= 'F'))

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

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

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

	return v;

	#undef	_IS_HEX_DIGIT
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x112e4
cmpl $0x3, %esi
jb 0x112e4
cmpb $0x30, (%rdi)
jne 0x112e4
cmpb $0x78, 0x1(%rdi)
jne 0x112e4
movb 0x2(%rdi), %al
leal -0x30(%rax), %edx
movabsq $0x3f0000003f, %rcx     # imm = 0x3F0000003F
cmpb $0xa, %dl
jb 0x1123d
movzbl %al, %eax
addl $-0x41, %eax
cmpl $0x25, %eax
ja 0x112e4
btq %rax, %rcx
jae 0x112e4
movl $0xffffffa9, %r9d       # imm = 0xFFFFFFA9
movl %esi, %edx
incq %rdx
movl $0x1, %esi
xorl %eax, %eax
leaq 0x27(%r9), %r8
addq $0x20, %r9
movabsq $0x10000040000000, %r10 # imm = 0x10000040000000
movb -0x2(%rdi,%rdx), %bl
movsbq %bl, %r11
leal -0x30(%rbx), %r15d
movq %r8, %r14
cmpb $0xa, %r15b
jb 0x1129b
movzbl %r11b, %r14d
addl $-0x41, %r14d
cmpl $0x34, %r14d
ja 0x112ba
btq %r14, %rcx
jae 0x112b4
addb $-0x61, %bl
movl $0xffffffa9, %r14d      # imm = 0xFFFFFFA9
cmpb $0x6, %bl
jb 0x1129b
movq %r9, %r14
addl %r11d, %r14d
imulq %rsi, %r14
addq %r14, %rax
shlq $0x4, %rsi
decq %rdx
cmpq $0x3, %rdx
ja 0x11261
jmp 0x112d9
btq %r14, %r10
jb 0x112a9
leaq 0x1d0af(%rip), %rdi     # 0x2e370
leaq 0x1e178(%rip), %rsi     # 0x2f440
leaq 0x1e774(%rip), %rcx     # 0x2fa43
movl $0x274, %edx            # imm = 0x274
callq 0xa0b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e70e(%rip), %rdi     # 0x2f9f9
leaq 0x1e14e(%rip), %rsi     # 0x2f440
leaq 0x1e74a(%rip), %rcx     # 0x2fa43
movl $0x25d, %edx            # imm = 0x25D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x1134b
testl %esi, %esi
je 0x1134b
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x1133c
cmpl $0x2b, %eax
jne 0x11336
incq %rdi
decl %esi
popq %rbp
jmp 0x111e0
incq %rdi
decl %esi
callq 0x111e0
negq %rax
popq %rbp
retq
leaq 0x1e266(%rip), %rdi     # 0x2f5b8
leaq 0x1e0e7(%rip), %rsi     # 0x2f440
leaq 0x1e71c(%rip), %rcx     # 0x2fa7c
movl $0x286, %edx            # imm = 0x286
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x1144d
testl %esi, %esi
je 0x1146c
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd 0x1e08f(%rip), %xmm1    # 0x2f430
movslq %edx, %rcx
addq %rdi, %rcx
movl %edx, %eax
movb (%rcx), %dl
cmpb $0x30, %dl
jl 0x113ec
cmpb $0x3a, %dl
jb 0x113c8
cmpb $0x5f, %dl
jne 0x113f8
incl %eax
incq %rcx
cmpl %esi, %eax
jb 0x113a9
jmp 0x1144b
movapd %xmm0, %xmm2
movzbl %dl, %ecx
addl $-0x30, %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
leal 0x1(%rax), %edx
cmpl %esi, %edx
jb 0x113a1
incl %eax
jmp 0x113f8
xorl %ecx, %ecx
cmpb $0x2e, %dl
sete %cl
addl %eax, %ecx
movl %ecx, %eax
cmpl %esi, %eax
jae 0x1144b
movsd 0x1e034(%rip), %xmm1    # 0x2f438
movapd %xmm1, %xmm2
movslq %eax, %rcx
leal 0x1(%rcx), %eax
addq %rdi, %rcx
movsbl (%rcx), %edx
cmpl $0x30, %edx
jl 0x1144b
cmpb $0x3a, %dl
jb 0x11431
cmpb $0x5f, %dl
jne 0x1144b
leal 0x1(%rax), %edx
incq %rcx
cmpl %esi, %eax
movl %edx, %eax
jb 0x11411
jmp 0x1144b
addl $-0x30, %edx
xorps %xmm3, %xmm3
cvtsi2sd %edx, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm0
mulsd %xmm1, %xmm2
cmpl %esi, %eax
jb 0x11408
popq %rbp
retq
leaq 0x1d657(%rip), %rdi     # 0x2eaab
leaq 0x1dfe5(%rip), %rsi     # 0x2f440
leaq 0x1e651(%rip), %rcx     # 0x2fab3
movl $0x29d, %edx            # imm = 0x29D
callq 0xa0b0
leaq 0x1e14c(%rip), %rdi     # 0x2f5bf
leaq 0x1dfc6(%rip), %rsi     # 0x2f440
leaq 0x1e632(%rip), %rcx     # 0x2fab3
movl $0x29e, %edx            # imm = 0x29E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x114bb
testq %rsi, %rsi
je 0x114da
testl %edx, %edx
js 0x114f9
leaq 0x2dc2b(%rip), %rcx     # 0x3f0e0
popq %rbp
jmp 0xae18
leaq 0x1c547(%rip), %rdi     # 0x2da09
leaq 0x1e68f(%rip), %rsi     # 0x2fb58
leaq 0x1e69a(%rip), %rcx     # 0x2fb6a
movl $0xad, %edx
callq 0xa0b0
leaq 0x1c055(%rip), %rdi     # 0x2d536
leaq 0x1e670(%rip), %rsi     # 0x2fb58
leaq 0x1e67b(%rip), %rcx     # 0x2fb6a
movl $0xae, %edx
callq 0xa0b0
leaq 0x1c03d(%rip), %rdi     # 0x2d53d
leaq 0x1e651(%rip), %rsi     # 0x2fb58
leaq 0x1e65c(%rip), %rcx     # 0x2fb6a
movl $0xaf, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x11567
testq %rsi, %rsi
je 0x11586
cmpl $0x1000, (%rsi)         # imm = 0x1000
jne 0x115a5
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x11165
leaq 0x1e856(%rip), %rdi     # 0x2fdc4
leaq 0x1e5e3(%rip), %rsi     # 0x2fb58
leaq 0x1e667(%rip), %rcx     # 0x2fbe3
movl $0xbe, %edx
callq 0xa0b0
leaq 0x1bf2d(%rip), %rdi     # 0x2d4ba
leaq 0x1e5c4(%rip), %rsi     # 0x2fb58
leaq 0x1e648(%rip), %rcx     # 0x2fbe3
movl $0xbf, %edx
callq 0xa0b0
leaq 0x1cdc4(%rip), %rdi     # 0x2e370
leaq 0x1e5a5(%rip), %rsi     # 0x2fb58
leaq 0x1e629(%rip), %rcx     # 0x2fbe3
movl $0xc6, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x12731
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x12750
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1276f
movq $0x0, 0xc0(%rbx)
movq %rbx, %rdi
movl $0x2, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1276f
leaq 0x1d68c(%rip), %rdi     # 0x2fdc4
leaq 0x1da89(%rip), %rsi     # 0x301c8
leaq 0x1da9b(%rip), %rcx     # 0x301e1
movl $0x523, %edx            # imm = 0x523
callq 0xa0b0
leaq 0x23230(%rip), %rdi     # 0x35987
leaq 0x1da6a(%rip), %rsi     # 0x301c8
leaq 0x1da7c(%rip), %rcx     # 0x301e1
movl $0x524, %edx            # imm = 0x524
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x13995
movq %rsi, %rdx
cmpl $0xe00, (%rsi)          # imm = 0xE00
jne 0x139b4
cmpl $0x1, 0x44(%rdx)
jne 0x139d3
movq 0x48(%rdx), %rax
movq (%rax), %rsi
addq $0x60, %rdx
popq %rbp
jmp 0x139f2
leaq 0x1e30f(%rip), %rdi     # 0x31cab
leaq 0x1c825(%rip), %rsi     # 0x301c8
leaq 0x1c8fd(%rip), %rcx     # 0x302a7
movl $0x1a8, %edx            # imm = 0x1A8
callq 0xa0b0
leaq 0x1c926(%rip), %rdi     # 0x302e1
leaq 0x1c806(%rip), %rsi     # 0x301c8
leaq 0x1c8de(%rip), %rcx     # 0x302a7
movl $0x1a9, %edx            # imm = 0x1A9
callq 0xa0b0
leaq 0x1dcc0(%rip), %rdi     # 0x3169a
leaq 0x1c7e7(%rip), %rsi     # 0x301c8
leaq 0x1c8bf(%rip), %rcx     # 0x302a7
movl $0x1aa, %edx            # imm = 0x1AA
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0x14605
movq %rdx, %r15
testq %rdx, %rdx
je 0x14624
movq %rsi, %r14
movq %rdi, %rbx
movq %r15, %rdx
callq 0x139f2
cmpb $0x1, (%r15)
je 0x145f7
movups 0x1bdc6(%rip), %xmm0    # 0x303aa
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 0x1d69f(%rip), %rdi     # 0x31cab
leaq 0x1bbb5(%rip), %rsi     # 0x301c8
leaq 0x1bd44(%rip), %rcx     # 0x3035e
movl $0x5c, %edx
callq 0xa0b0
leaq 0x1bc23(%rip), %rdi     # 0x3024e
leaq 0x1bb96(%rip), %rsi     # 0x301c8
leaq 0x1bd25(%rip), %rcx     # 0x3035e
movl $0x5d, %edx
callq 0xa0b0
nop