LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/string.c
// Function: rstr_insertf
void rstr_insertf(ResizableString *dst, int pos, const char *fmt, ...) {
	char buffer[64 * 1024];

	va_list argptr;
    va_start(argptr, fmt);

	vsnprintf(buffer, sizeof(buffer), fmt, argptr);
	rstr_insert_with_cstr(dst, buffer, pos);

	va_end(argptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10100, %rsp          # imm = 0x10100
testb %al, %al
je 0x10a17
movaps %xmm0, -0x100c0(%rbp)
movaps %xmm1, -0x100b0(%rbp)
movaps %xmm2, -0x100a0(%rbp)
movaps %xmm3, -0x10090(%rbp)
movaps %xmm4, -0x10080(%rbp)
movaps %xmm5, -0x10070(%rbp)
movaps %xmm6, -0x10060(%rbp)
movaps %xmm7, -0x10050(%rbp)
movq %r9, -0x100c8(%rbp)
movq %r8, -0x100d0(%rbp)
movq %rcx, -0x100d8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x100f0(%rbp), %rax
movq %rax, -0x10030(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x10038(%rbp)
movl $0x30, -0x1003c(%rbp)
movl $0x18, -0x10040(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x10020(%rbp), %rdi
movq %rdi, -0x100f8(%rbp)
movl $0x10000, %esi          # imm = 0x10000
leaq -0x10040(%rbp), %rcx
callq 0xa060
movq -0x100f8(%rbp), %rsi
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
callq 0x105c0
addq $0x10100, %rsp          # imm = 0x10100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/string.c
// Function: rstr_compare
bool rstr_compare(ResizableString *a, ResizableString *b) {
	return a != NULL
		&& b != NULL
		&& a->len == b->len
		&& (a->buffer == NULL || strcmp(a->buffer, b->buffer) == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x11(%rbp)
je 0x10cd1
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x10cd1
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl 0x4(%rdx), %ecx
movb %al, -0x11(%rbp)
jne 0x10cd1
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpq $0x0, 0x8(%rcx)
movb %al, -0x12(%rbp)
je 0x10ccb
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xa0f0
cmpl $0x0, %eax
sete %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/string.c
// Function: rstr_split_by_char
void rstr_split_by_char(
	LinkedList *llst,
	ResizableString *rstr,
	char seperator,
	bool ignore_empty
) {
	assert(llst);
	assert(rstr);

	char temp[2] = {'\0', '\0'};
	temp[0] = seperator;

	rstr_split(llst, rstr, temp, ignore_empty);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x10f75
jmp 0x10f94
leaq 0x35d2e(%rip), %rdi     # 0x46caa
leaq 0x36ba1(%rip), %rsi     # 0x47b24
movl $0x180, %edx            # imm = 0x180
leaq 0x36f1d(%rip), %rcx     # 0x47eac
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x10f9d
jmp 0x10fbc
leaq 0x36b7b(%rip), %rdi     # 0x47b1f
leaq 0x36b79(%rip), %rsi     # 0x47b24
movl $0x181, %edx            # imm = 0x181
leaq 0x36ef5(%rip), %rcx     # 0x47eac
callq 0xa0b0
leaq -0x14(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xa0d0
movb -0x11(%rbp), %al
movb %al, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x14(%rbp), %rdx
movb -0x12(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x10ce0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/string.c
// Function: rstr_index_of
int rstr_index_of(
	ResizableString *rstr,
	const char *search_value
) {
	assert(rstr);
	assert(search_value);

	size_t search_value_len = strlen(search_value);
	if (search_value_len == 0) {
		return -1;
	}

	for (int i = 0; RSTR_CSTR(rstr)[i] != '\0'; i++) {
		if (strncmp(&(RSTR_CSTR(rstr)[i]), search_value, search_value_len) == 0) {
			return i;
		}
	}

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x11019
jmp 0x11038
leaq 0x36aff(%rip), %rdi     # 0x47b1f
leaq 0x36afd(%rip), %rsi     # 0x47b24
movl $0x18d, %edx            # imm = 0x18D
leaq 0x36ebf(%rip), %rcx     # 0x47ef2
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x11041
jmp 0x11060
leaq 0x36edd(%rip), %rdi     # 0x47f25
leaq 0x36ad5(%rip), %rsi     # 0x47b24
movl $0x18e, %edx            # imm = 0x18E
leaq 0x36e97(%rip), %rcx     # 0x47ef2
callq 0xa0b0
movq -0x18(%rbp), %rdi
callq 0xa080
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x11080
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1111c
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1109f
leaq 0x367ee(%rip), %rax     # 0x47887
movq %rax, -0x30(%rbp)
jmp 0x110ab
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x11115
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x110d4
leaq 0x367b9(%rip), %rax     # 0x47887
movq %rax, -0x38(%rbp)
jmp 0x110e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x24(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xa040
cmpl $0x0, %eax
jne 0x11105
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1111c
jmp 0x11107
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x11087
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/string.c
// Function: rstr_last_index_of
int rstr_last_index_of(
	ResizableString *rstr,
	const char *search_value
) {
	assert(rstr);
	assert(search_value);

	size_t search_value_len = strlen(search_value);
	if (search_value_len == 0) {
		return -1;
	}

	size_t len = RSTR_LEN(rstr);

	for (int i = len; i >= 0; i--) {
		if (strncmp(&(RSTR_CSTR(rstr)[i]), search_value, search_value_len) == 0) {
			return i;
		}
	}

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x11149
jmp 0x11168
leaq 0x369cf(%rip), %rdi     # 0x47b1f
leaq 0x369cd(%rip), %rsi     # 0x47b24
movl $0x1a2, %edx            # imm = 0x1A2
leaq 0x36dcf(%rip), %rcx     # 0x47f32
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x11171
jmp 0x11190
leaq 0x36dad(%rip), %rdi     # 0x47f25
leaq 0x369a5(%rip), %rsi     # 0x47b24
movl $0x1a3, %edx            # imm = 0x1A3
leaq 0x36da7(%rip), %rcx     # 0x47f32
callq 0xa0b0
movq -0x18(%rbp), %rdi
callq 0xa080
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x111ad
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11223
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x1121c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x111de
leaq 0x366af(%rip), %rax     # 0x47887
movq %rax, -0x38(%rbp)
jmp 0x111ea
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x2c(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xa040
cmpl $0x0, %eax
jne 0x1120f
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x11223
jmp 0x11211
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x111c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/string.c
// Function: rstr_sub_string
void rstr_sub_string(
	ResizableString *dst,
	ResizableString *src,
	size_t start,
	size_t len
) {
	assert(dst);
	assert(src);
	assert(dst != src);

	for (int i = start; i < start + len && RSTR_CHAR(src, i) != -1; i++) {
		rstr_append_with_char(dst, RSTR_CHAR(src, i));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x11251
jmp 0x11270
leaq 0x34e11(%rip), %rdi     # 0x46069
leaq 0x368c5(%rip), %rsi     # 0x47b24
movl $0x1bb, %edx            # imm = 0x1BB
leaq 0x36cff(%rip), %rcx     # 0x47f6a
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x11279
jmp 0x11298
leaq 0x36d3c(%rip), %rdi     # 0x47fbc
leaq 0x3689d(%rip), %rsi     # 0x47b24
movl $0x1bc, %edx            # imm = 0x1BC
leaq 0x36cd7(%rip), %rcx     # 0x47f6a
callq 0xa0b0
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x112a4
jmp 0x112c3
leaq 0x36d0a(%rip), %rdi     # 0x47fb5
leaq 0x36872(%rip), %rsi     # 0x47b24
movl $0x1bd, %edx            # imm = 0x1BD
leaq 0x36cac(%rip), %rcx     # 0x47f6a
callq 0xa0b0
movq -0x18(%rbp), %rax
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rcx
movq -0x18(%rbp), %rdx
addq -0x20(%rbp), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x25(%rbp)
jae 0x11335
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jl 0x112f6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x2c(%rbp)
jmp 0x11329
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1130e
leaq 0x3657f(%rip), %rax     # 0x47887
movq %rax, -0x38(%rbp)
jmp 0x1131a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl $-0x1, %eax
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x1133e
jmp 0x113ac
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jl 0x1135c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x44(%rbp)
jmp 0x1138f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x11374
leaq 0x36519(%rip), %rax     # 0x47887
movq %rax, -0x50(%rbp)
jmp 0x11380
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rdi
movl -0x44(%rbp), %eax
movsbl %al, %esi
callq 0xfeb0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x112ca
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/string.c
// Function: rstr_space_char_comparer
bool rstr_space_char_comparer(char chr) {
	if (isspace(chr)) {
		return true;
	} else {
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
callq 0xa1a0
movq (%rax), %rax
movsbl -0x2(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x11441
movb $0x1, -0x1(%rbp)
jmp 0x11445
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/string.c
// Function: rstr_ltrim_ex
void rstr_ltrim_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++);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1146d
jmp 0x1148c
leaq 0x34bf5(%rip), %rdi     # 0x46069
leaq 0x366a9(%rip), %rsi     # 0x47b24
movl $0x1d9, %edx            # imm = 0x1D9
leaq 0x36b5c(%rip), %rcx     # 0x47fe3
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x11495
jmp 0x114b4
leaq 0x36b20(%rip), %rdi     # 0x47fbc
leaq 0x36681(%rip), %rsi     # 0x47b24
movl $0x1da, %edx            # imm = 0x1DA
leaq 0x36b34(%rip), %rcx     # 0x47fe3
callq 0xa0b0
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x114c0
jmp 0x114df
leaq 0x36aee(%rip), %rdi     # 0x47fb5
leaq 0x36656(%rip), %rsi     # 0x47b24
movl $0x1db, %edx            # imm = 0x1DB
leaq 0x36b09(%rip), %rcx     # 0x47fe3
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x114e8
jmp 0x11507
leaq 0x35880(%rip), %rdi     # 0x46d6f
leaq 0x3662e(%rip), %rsi     # 0x47b24
movl $0x1dc, %edx            # imm = 0x1DC
leaq 0x36ae1(%rip), %rcx     # 0x47fe3
callq 0xa0b0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl 0x4(%rdx), %ecx
movb %al, -0x1d(%rbp)
jge 0x1157f
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jl 0x1153d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x2c(%rbp)
jmp 0x11570
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x11555
leaq 0x36338(%rip), %rax     # 0x47887
movq %rax, -0x38(%rbp)
jmp 0x11561
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
movsbl %cl, %edi
callq *%rax
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x11588
jmp 0x11598
jmp 0x1158a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1150e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
subl -0x1c(%rbp), %eax
movslq %eax, %rcx
callq 0x11230
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x115dd
jmp 0x115fc
leaq 0x34a85(%rip), %rdi     # 0x46069
leaq 0x36539(%rip), %rsi     # 0x47b24
movl $0x1e9, %edx            # imm = 0x1E9
leaq 0x36a37(%rip), %rcx     # 0x4802e
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x11605
jmp 0x11624
leaq 0x369b0(%rip), %rdi     # 0x47fbc
leaq 0x36511(%rip), %rsi     # 0x47b24
movl $0x1ea, %edx            # imm = 0x1EA
leaq 0x36a0f(%rip), %rcx     # 0x4802e
callq 0xa0b0
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x11630
jmp 0x1164f
leaq 0x3697e(%rip), %rdi     # 0x47fb5
leaq 0x364e6(%rip), %rsi     # 0x47b24
movl $0x1eb, %edx            # imm = 0x1EB
leaq 0x369e4(%rip), %rcx     # 0x4802e
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x11658
jmp 0x11677
leaq 0x35710(%rip), %rdi     # 0x46d6f
leaq 0x364be(%rip), %rsi     # 0x47b24
movl $0x1ec, %edx            # imm = 0x1EC
leaq 0x369bc(%rip), %rcx     # 0x4802e
callq 0xa0b0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
jle 0x116f4
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jl 0x116ad
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x2c(%rbp)
jmp 0x116e5
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x116c5
leaq 0x361c8(%rip), %rax     # 0x47887
movq %rax, -0x38(%rbp)
jmp 0x116d1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
movsbl %cl, %edi
callq *%rax
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x116fd
jmp 0x1170d
jmp 0x116ff
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x11681
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x11230
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1194e
jmp 0x1196d
leaq 0x34714(%rip), %rdi     # 0x46069
leaq 0x361c8(%rip), %rsi     # 0x47b24
movl $0x20c, %edx            # imm = 0x20C
leaq 0x3675b(%rip), %rcx     # 0x480c3
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x11976
jmp 0x11995
leaq 0x3663f(%rip), %rdi     # 0x47fbc
leaq 0x361a0(%rip), %rsi     # 0x47b24
movl $0x20d, %edx            # imm = 0x20D
leaq 0x36733(%rip), %rcx     # 0x480c3
callq 0xa0b0
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x119a1
jmp 0x119c0
leaq 0x3660d(%rip), %rdi     # 0x47fb5
leaq 0x36175(%rip), %rsi     # 0x47b24
movl $0x20e, %edx            # imm = 0x20E
leaq 0x36708(%rip), %rcx     # 0x480c3
callq 0xa0b0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl 0x4(%rdx), %ecx
movb %al, -0x19(%rbp)
jge 0x11a30
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jl 0x119ee
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x20(%rbp)
jmp 0x11a21
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x11a06
leaq 0x35e87(%rip), %rax     # 0x47887
movq %rax, -0x28(%rbp)
jmp 0x11a12
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x11a39
jmp 0x11a46
jmp 0x11a3b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x119c7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
subl -0x18(%rbp), %eax
movslq %eax, %rcx
callq 0x11230
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x11a8e
jmp 0x11aad
leaq 0x345d4(%rip), %rdi     # 0x46069
leaq 0x36088(%rip), %rsi     # 0x47b24
movl $0x21b, %edx            # imm = 0x21B
leaq 0x36657(%rip), %rcx     # 0x480ff
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x11ab6
jmp 0x11ad5
leaq 0x364ff(%rip), %rdi     # 0x47fbc
leaq 0x36060(%rip), %rsi     # 0x47b24
movl $0x21c, %edx            # imm = 0x21C
leaq 0x3662f(%rip), %rcx     # 0x480ff
callq 0xa0b0
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x11ae1
jmp 0x11b00
leaq 0x364cd(%rip), %rdi     # 0x47fb5
leaq 0x36035(%rip), %rsi     # 0x47b24
movl $0x21d, %edx            # imm = 0x21D
leaq 0x36604(%rip), %rcx     # 0x480ff
callq 0xa0b0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
jle 0x11b75
movl -0x18(%rbp), %eax
subl $0x1, %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jl 0x11b2e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x20(%rbp)
jmp 0x11b66
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x11b46
leaq 0x35d47(%rip), %rax     # 0x47887
movq %rax, -0x28(%rbp)
jmp 0x11b52
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x11b7e
jmp 0x11b8e
jmp 0x11b80
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x11b0a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x11230
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x11bce
jmp 0x11bed
leaq 0x34494(%rip), %rdi     # 0x46069
leaq 0x35f48(%rip), %rsi     # 0x47b24
movl $0x22a, %edx            # imm = 0x22A
leaq 0x36553(%rip), %rcx     # 0x4813b
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x11bf6
jmp 0x11c15
leaq 0x363bf(%rip), %rdi     # 0x47fbc
leaq 0x35f20(%rip), %rsi     # 0x47b24
movl $0x22b, %edx            # imm = 0x22B
leaq 0x3652b(%rip), %rcx     # 0x4813b
callq 0xa0b0
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x11c21
jmp 0x11c40
leaq 0x3638d(%rip), %rdi     # 0x47fb5
leaq 0x35ef5(%rip), %rsi     # 0x47b24
movl $0x22c, %edx            # imm = 0x22C
leaq 0x36500(%rip), %rcx     # 0x4813b
callq 0xa0b0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl 0x4(%rdx), %ecx
movb %al, -0x1d(%rbp)
jge 0x11cb0
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jl 0x11c6e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x24(%rbp)
jmp 0x11ca1
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x11c86
leaq 0x35c07(%rip), %rax     # 0x47887
movq %rax, -0x30(%rbp)
jmp 0x11c92
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x11cb9
jmp 0x11cc6
jmp 0x11cbb
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x11c47
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x31(%rbp)
jle 0x11d3b
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jl 0x11cf4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x38(%rbp)
jmp 0x11d2c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x11d0c
leaq 0x35b81(%rip), %rax     # 0x47887
movq %rax, -0x40(%rbp)
jmp 0x11d18
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x11d44
jmp 0x11d54
jmp 0x11d46
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x11cd0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %eax
subl -0x18(%rbp), %eax
movslq %eax, %rcx
callq 0x11230
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12848
jmp 0x12867
leaq 0x3aae5(%rip), %rdi     # 0x4d334
leaq 0x35cea(%rip), %rsi     # 0x48540
movl $0x15, %edx
leaq 0x35ce5(%rip), %rcx     # 0x48547
callq 0xa0b0
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xa110
cmpl $0x0, %eax
jge 0x12885
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1289f
cmpq $0x7fffffff, -0x70(%rbp) # imm = 0x7FFFFFFF
jle 0x12898
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1289f
movq -0x70(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x128cc
jmp 0x128eb
leaq 0x3aa61(%rip), %rdi     # 0x4d334
leaq 0x35c66(%rip), %rsi     # 0x48540
movl $0x24, %edx
leaq 0x35c8a(%rip), %rcx     # 0x48570
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x128f4
jmp 0x12913
leaq 0x35cb8(%rip), %rdi     # 0x485b3
leaq 0x35c3e(%rip), %rsi     # 0x48540
movl $0x25, %edx
leaq 0x35c62(%rip), %rcx     # 0x48570
callq 0xa0b0
cmpl $0x0, -0x14(%rbp)
jl 0x1291b
jmp 0x1293a
leaq 0x33c80(%rip), %rdi     # 0x465a2
leaq 0x35c17(%rip), %rsi     # 0x48540
movl $0x26, %edx
leaq 0x35c3b(%rip), %rcx     # 0x48570
callq 0xa0b0
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x35c6e(%rip), %rsi     # 0x485bb
callq 0xa150
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1295f
jmp 0x129a0
cmpl $0x0, -0x14(%rbp)
jle 0x12997
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0xa190
movq %rax, %rcx
movslq -0x24(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jle 0x12995
jmp 0x1296b
jmp 0x12997
movq -0x20(%rbp), %rdi
callq 0xa070
cmpq $0x0, -0x20(%rbp)
je 0x129b0
movq -0x20(%rbp), %rdi
callq 0xa070
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x129d9
jmp 0x129f8
leaq 0x3a954(%rip), %rdi     # 0x4d334
leaq 0x35b59(%rip), %rsi     # 0x48540
movl $0x3e, %edx
leaq 0x35bcb(%rip), %rcx     # 0x485be
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x12a01
jmp 0x12a20
leaq 0x35bf1(%rip), %rdi     # 0x485f9
leaq 0x35b31(%rip), %rsi     # 0x48540
movl $0x3f, %edx
leaq 0x35ba3(%rip), %rcx     # 0x485be
callq 0xa0b0
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12830
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x12a51
movq -0x18(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0x12ae5
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x2c(%rbp)
jne 0x12a6d
movq $0x0, -0x8(%rbp)
jmp 0x12b0d
jmp 0x12a6f
movslq -0x2c(%rbp), %rdi
callq 0xa130
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x12a85
jmp 0x12ae5
movq -0x10(%rbp), %rdi
leaq 0x36e19(%rip), %rsi     # 0x498a9
callq 0xa150
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x12aa2
jmp 0x12ae5
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0xa050
movq %rax, %rcx
movslq -0x30(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x30(%rbp)
cmpl $0x0, %eax
jle 0x12ad2
jmp 0x12aa8
movq -0x28(%rbp), %rdi
callq 0xa070
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12b0d
cmpq $0x0, -0x20(%rbp)
je 0x12af5
movq -0x20(%rbp), %rdi
callq 0xa1b0
cmpq $0x0, -0x28(%rbp)
je 0x12b05
movq -0x28(%rbp), %rdi
callq 0xa070
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/util.c
// Function: util_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
movb %dil, %al
movb %al, -0x2(%rbp)
movl $0x0, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x35fc4(%rip), %rax     # 0x48c30
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x12c9f
movslq -0x8(%rbp), %rcx
leaq 0x35fb0(%rip), %rax     # 0x48c30
movsbl (%rax,%rcx), %eax
movsbl -0x2(%rbp), %ecx
cmpl %ecx, %eax
jne 0x12c92
movb $0x1, -0x1(%rbp)
jmp 0x12ca3
jmp 0x12c94
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x12c61
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/util.c
// Function: util_unescape
char util_unescape(char chr) {
	static const char esc_map[][2] = {
		{'a', '\a'},
		{'b', '\b'},
		{'f', '\f'},
		{'n', '\n'},
		{'r', '\r'},
		{'t', '\t'},
		{'v', '\v'},
		{'\\', '\\'},
		{'\'', '\''},
		{'"', '"'},
		{'0', '\0'},
		{-1, -1}
	};

	for (int i = 0; esc_map[i][0] != -1; i++) {
		if (esc_map[i][0] == chr) {
			return esc_map[i][1];
		}
	}

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movl $0x0, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x35f24(%rip), %rax     # 0x48c50
movsbl (%rax,%rcx,2), %eax
cmpl $-0x1, %eax
je 0x12d6d
movslq -0x8(%rbp), %rcx
leaq 0x35f10(%rip), %rax     # 0x48c50
movsbl (%rax,%rcx,2), %eax
movsbl -0x2(%rbp), %ecx
cmpl %ecx, %eax
jne 0x12d60
movslq -0x8(%rbp), %rcx
leaq 0x35ef9(%rip), %rax     # 0x48c50
movb 0x1(%rax,%rcx,2), %al
movb %al, -0x1(%rbp)
jmp 0x12d71
jmp 0x12d62
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x12d21
movb $-0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12d98
jmp 0x12db7
leaq 0x34deb(%rip), %rdi     # 0x47b8a
leaq 0x3579a(%rip), %rsi     # 0x48540
movl $0xae, %edx
leaq 0x35851(%rip), %rcx     # 0x48603
callq 0xa0b0
cmpl $0x3, -0x14(%rbp)
jne 0x12e04
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x27, %ecx
movb %al, -0x15(%rbp)
jne 0x12dfa
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %edi
callq 0x12b70
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x15(%rbp)
jne 0x12de9
jmp 0x12dfa
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x27, %eax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x12e67
cmpl $0x4, -0x14(%rbp)
jne 0x12e63
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x27, %ecx
movb %al, -0x16(%rbp)
jne 0x12e59
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %ecx
xorl %eax, %eax
cmpl $0x5c, %ecx
movb %al, -0x16(%rbp)
jne 0x12e59
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %edi
callq 0x12c50
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x16(%rbp)
jne 0x12e48
jmp 0x12e59
movq -0x10(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $0x27, %eax
sete %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x12e67
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12e98
jmp 0x12eb7
leaq 0x34ceb(%rip), %rdi     # 0x47b8a
leaq 0x3569a(%rip), %rsi     # 0x48540
movl $0xc2, %edx
leaq 0x35784(%rip), %rcx     # 0x48636
callq 0xa0b0
cmpl $0x2, -0x14(%rbp)
jb 0x12f71
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x12ee2
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x22, %eax
je 0x12eeb
movb $0x0, -0x1(%rbp)
jmp 0x12f75
movq $0x1, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x2, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x12f6b
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x12be0
testb $0x1, %al
jne 0x12f5b
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
je 0x12f5b
movq -0x20(%rbp), %rax
addq $0x1, %rax
movl -0x14(%rbp), %ecx
subl $0x2, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jb 0x12f5b
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl 0x1(%rax,%rcx), %edi
callq 0x12cb0
testb $0x1, %al
jne 0x12f5b
movb $0x0, -0x1(%rbp)
jmp 0x12f75
jmp 0x12f5d
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x12ef3
movb $0x1, -0x1(%rbp)
jmp 0x12f75
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12f98
jmp 0x12fb7
leaq 0x34beb(%rip), %rdi     # 0x47b8a
leaq 0x3559a(%rip), %rsi     # 0x48540
movl $0xdd, %edx
leaq 0x356b9(%rip), %rcx     # 0x4866b
callq 0xa0b0
cmpl $0x3, -0x14(%rbp)
jb 0x13059
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x13053
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x62, %eax
jne 0x13053
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x30, %eax
je 0x12ff8
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x31, %eax
jne 0x13053
movl $0x3, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x1304d
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
je 0x13040
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x31, %eax
je 0x13040
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5f, %eax
je 0x13040
movb $0x0, -0x1(%rbp)
jmp 0x1305d
jmp 0x13042
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x12fff
movb $0x1, -0x1(%rbp)
jmp 0x1305d
movb $0x0, -0x1(%rbp)
jmp 0x1305d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1308e
cmpl $0x0, -0x14(%rbp)
jbe 0x1308e
jmp 0x130ad
leaq 0x3560d(%rip), %rdi     # 0x486a2
leaq 0x354a4(%rip), %rsi     # 0x48540
movl $0xf6, %edx
leaq 0x35609(%rip), %rcx     # 0x486b1
callq 0xa0b0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
je 0x130c5
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x130df
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0x12f80
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x130f0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x12f80
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13118
jmp 0x13137
leaq 0x34a6b(%rip), %rdi     # 0x47b8a
leaq 0x3541a(%rip), %rsi     # 0x48540
movl $0x103, %edx            # imm = 0x103
leaq 0x355b5(%rip), %rcx     # 0x486e7
callq 0xa0b0
cmpl $0x3, -0x14(%rbp)
jb 0x131d9
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x131d3
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x6f, %eax
jne 0x131d3
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x30, %eax
jl 0x131d3
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x37, %eax
jg 0x131d3
movl $0x3, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x131cd
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x131a9
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x37, %eax
jle 0x131c0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5f, %eax
je 0x131c0
movb $0x0, -0x1(%rbp)
jmp 0x131dd
jmp 0x131c2
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1317f
movb $0x1, -0x1(%rbp)
jmp 0x131dd
movb $0x0, -0x1(%rbp)
jmp 0x131dd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1320e
cmpl $0x0, -0x14(%rbp)
jbe 0x1320e
jmp 0x1322d
leaq 0x3548d(%rip), %rdi     # 0x486a2
leaq 0x35324(%rip), %rsi     # 0x48540
movl $0x11c, %edx            # imm = 0x11C
leaq 0x354f6(%rip), %rcx     # 0x4871e
callq 0xa0b0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
je 0x13245
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x1325f
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0x13100
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x13270
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x13100
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13298
jmp 0x132b7
leaq 0x348eb(%rip), %rdi     # 0x47b8a
leaq 0x3529a(%rip), %rsi     # 0x48540
movl $0x129, %edx            # imm = 0x129
leaq 0x354a2(%rip), %rcx     # 0x48754
callq 0xa0b0
cmpl $0x1, -0x14(%rbp)
jb 0x13336
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x13330
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x13330
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x1332a
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x13306
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jle 0x1331d
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5f, %eax
je 0x1331d
movb $0x0, -0x1(%rbp)
jmp 0x1333a
jmp 0x1331f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x132dc
movb $0x1, -0x1(%rbp)
jmp 0x1333a
movb $0x0, -0x1(%rbp)
jmp 0x1333a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1336e
cmpl $0x0, -0x14(%rbp)
jbe 0x1336e
jmp 0x1338d
leaq 0x3532d(%rip), %rdi     # 0x486a2
leaq 0x351c4(%rip), %rsi     # 0x48540
movl $0x140, %edx            # imm = 0x140
leaq 0x35403(%rip), %rcx     # 0x4878b
callq 0xa0b0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
je 0x133a5
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x133bf
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0x13280
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x133d0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x13280
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x133f8
jmp 0x13417
leaq 0x3478b(%rip), %rdi     # 0x47b8a
leaq 0x3513a(%rip), %rsi     # 0x48540
movl $0x14d, %edx            # imm = 0x14D
leaq 0x353af(%rip), %rcx     # 0x487c1
callq 0xa0b0
cmpl $0x3, -0x14(%rbp)
jb 0x13544
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x1353e
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x78, %eax
jne 0x1353e
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x30, %eax
jl 0x1345c
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x39, %eax
jle 0x13498
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x61, %eax
jl 0x13476
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x66, %eax
jle 0x13498
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x41, %eax
jl 0x1353e
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x46, %eax
jg 0x1353e
movl $0x3, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x13538
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x134cd
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jle 0x13528
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x61, %eax
jl 0x134ef
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x66, %eax
jle 0x13528
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x41, %eax
jl 0x13511
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x46, %eax
jle 0x13528
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5f, %eax
je 0x13528
movb $0x0, -0x1(%rbp)
jmp 0x13548
jmp 0x1352a
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1349f
movb $0x1, -0x1(%rbp)
jmp 0x13548
movb $0x0, -0x1(%rbp)
jmp 0x13548
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1357e
cmpl $0x0, -0x14(%rbp)
jbe 0x1357e
jmp 0x1359d
leaq 0x3511d(%rip), %rdi     # 0x486a2
leaq 0x34fb4(%rip), %rsi     # 0x48540
movl $0x166, %edx            # imm = 0x166
leaq 0x35260(%rip), %rcx     # 0x487f8
callq 0xa0b0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
je 0x135b5
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x135cf
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0x133e0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x135e0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x133e0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)