LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/string.c
// Function: rstr_append_with_raw
void rstr_append_with_raw(ResizableString *dst, const char *src, int len) {
	assert(dst);
	assert(src);
	assert(len >= 0);

	if (len == 0) {
		return;
	}

	if (dst->len + len > dst->size) {
		_inc_buffer_size(dst, len);
	}

	memcpy(dst->buffer + dst->len, src, len);
	dst->len += len;

	_append_null_terminated_char(dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xe6f7
movq %rsi, %r15
testq %rsi, %rsi
je 0xe716
movl %edx, %r14d
testl %edx, %edx
js 0xe735
je 0xe6ec
movq %rdi, %rbx
movl 0x4(%rdi), %eax
addl %r14d, %eax
cmpl (%rdi), %eax
jle 0xe6c4
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe9ef
movslq 0x4(%rbx), %rdi
addq 0x8(%rbx), %rdi
movl %r14d, %edx
movq %r15, %rsi
callq 0xa110
movslq 0x4(%rbx), %rax
movslq %r14d, %rcx
addq %rax, %rcx
movl %ecx, 0x4(%rbx)
movq 0x8(%rbx), %rax
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f96b(%rip), %rdi     # 0x2e069
leaq 0x21360(%rip), %rsi     # 0x2fa65
leaq 0x21526(%rip), %rcx     # 0x2fc32
movl $0xaa, %edx
callq 0xa0b0
leaq 0x217e0(%rip), %rdi     # 0x2fefd
leaq 0x21341(%rip), %rsi     # 0x2fa65
leaq 0x21507(%rip), %rcx     # 0x2fc32
movl $0xab, %edx
callq 0xa0b0
leaq 0x1fe11(%rip), %rdi     # 0x2e54d
leaq 0x21322(%rip), %rsi     # 0x2fa65
leaq 0x214e8(%rip), %rcx     # 0x2fc32
movl $0xac, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/string.c
// Function: rstr_init_with_rstr
void rstr_init_with_rstr(
	ResizableString *dst,
	ResizableString *src
) {
	assert(dst);
	assert(src);

	rstr_init(dst);
	rstr_append_with_rstr(dst, src);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xe76e
testq %rsi, %rsi
je 0xe78d
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
popq %rbp
jmp 0xe7ac
leaq 0x1f8f4(%rip), %rdi     # 0x2e069
leaq 0x212e9(%rip), %rsi     # 0x2fa65
leaq 0x213bc(%rip), %rcx     # 0x2fb3f
movl $0x3c, %edx
callq 0xa0b0
leaq 0x21769(%rip), %rdi     # 0x2fefd
leaq 0x212ca(%rip), %rsi     # 0x2fa65
leaq 0x2139d(%rip), %rcx     # 0x2fb3f
movl $0x3d, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/string.c
// Function: rstr_append_with_rstr
void rstr_append_with_rstr(ResizableString *dst, const ResizableString *src) {
	assert(dst);
	assert(src);

	if (src->len == 0) {
		return;
	}

	if (dst->len + src->len > dst->size) {
		_inc_buffer_size(dst, src->len);
	}

	memcpy(dst->buffer + dst->len, src->buffer, src->len);
	dst->len += src->len;

	_append_null_terminated_char(dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xe80c
movq %rsi, %r14
testq %rsi, %rsi
je 0xe82b
movl 0x4(%r14), %esi
testl %esi, %esi
je 0xe807
movq %rdi, %rbx
movl 0x4(%rdi), %eax
addl %esi, %eax
cmpl (%rdi), %eax
jle 0xe7dc
movq %rbx, %rdi
callq 0xe9ef
movslq 0x4(%rbx), %rdi
addq 0x8(%rbx), %rdi
movq 0x8(%r14), %rsi
movslq 0x4(%r14), %rdx
callq 0xa110
movslq 0x4(%r14), %rax
movslq 0x4(%rbx), %rcx
addq %rax, %rcx
movl %ecx, 0x4(%rbx)
movq 0x8(%rbx), %rax
movb $0x0, (%rax,%rcx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1f856(%rip), %rdi     # 0x2e069
leaq 0x2124b(%rip), %rsi     # 0x2fa65
leaq 0x21451(%rip), %rcx     # 0x2fc72
movl $0xbd, %edx
callq 0xa0b0
leaq 0x216cb(%rip), %rdi     # 0x2fefd
leaq 0x2122c(%rip), %rsi     # 0x2fa65
leaq 0x21432(%rip), %rcx     # 0x2fc72
movl $0xbe, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/string.c
// Function: rstr_new_with_cstr
ResizableString * rstr_new_with_cstr(const char *cstr) {
	assert(cstr);

	ResizableString *rstr = rstr_new();
	rstr_append_with_cstr(rstr, cstr);
	return rstr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xe8ae
movq %rdi, %rbx
callq 0xe84a
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe4ef
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x21215(%rip), %rdi     # 0x2faca
leaq 0x211a9(%rip), %rsi     # 0x2fa65
leaq 0x212bb(%rip), %rcx     # 0x2fb7e
movl $0x4d, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/string.c
// Function: rstr_free
void rstr_free(ResizableString *rstr) {
	assert(rstr);

	if (rstr->buffer != NULL) {
		free(rstr->buffer);
	}
	rstr->size = 0;
	rstr->len = 0;
	rstr->buffer = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xe981
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xe974
callq 0xa190
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x210d8(%rip), %rdi     # 0x2fa60
leaq 0x210d6(%rip), %rsi     # 0x2fa65
leaq 0x2121a(%rip), %rcx     # 0x2fbb0
movl $0x6d, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/string.c
// Function: inc_buffer_size
static void _inc_buffer_size(ResizableString *rstr, int inc_size) {
	assert(rstr);
	assert(inc_size > 0);

	rstr->size = rstr->size + 2 * inc_size;
	if (rstr->buffer == NULL) {
		rstr->buffer = (char *)malloc(rstr->size + 1);
	} else {
		rstr->buffer = (char *)realloc(rstr->buffer, rstr->size + 1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0xea32
movq %rdi, %rbx
movslq (%rdi), %rax
movslq %esi, %rcx
leaq (%rax,%rcx,2), %rdx
movl %edx, (%rdi)
movq 0x8(%rdi), %rdi
leaq (%rax,%rcx,2), %rsi
incq %rsi
testq %rdi, %rdi
je 0xea1f
callq 0xa130
jmp 0xea27
movq %rsi, %rdi
callq 0xa120
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x21a2c(%rip), %rdi     # 0x30465
leaq 0x21025(%rip), %rsi     # 0x2fa65
leaq 0x219f0(%rip), %rcx     # 0x30437
movl $0x81, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/string.c
// Function: rstr_appendf
void rstr_appendf(ResizableString *dst, const char *fmt, ...) {
	char buffer[64 * 1024];

	va_list argptr;
    va_start(argptr, fmt);

	vsnprintf(buffer, sizeof(buffer), fmt, argptr);
	rstr_append_with_cstr(dst, buffer);

	va_end(argptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x100d0, %rsp          # imm = 0x100D0
movq %rsi, %r10
movq %rdi, %rbx
leaq -0xe0(%rbp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0xeaa9
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq -0x30(%rbp), %rcx
movq %rsi, 0x10(%rcx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rcx)
leaq -0x100e0(%rbp), %r14
movl $0x10000, %esi          # imm = 0x10000
movq %r14, %rdi
movq %r10, %rdx
callq 0xa060
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe4ef
addq $0x100d0, %rsp          # imm = 0x100D0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/string.c
// Function: rstr_insert_with_cstr
void rstr_insert_with_cstr(ResizableString *dst, const char *src, int pos) {
	assert(dst);
	assert(src);
	assert(pos >= 0);

	int len_src = strlen(src);
	if (len_src == 0) {
		return;
	}

	if (dst->len + len_src > dst->size) {
		_inc_buffer_size(dst, len_src);
	}

	memcpy(dst->buffer + pos + len_src, dst->buffer + pos, dst->len - pos);
	memcpy(dst->buffer + pos, src, len_src);
	dst->len += len_src;

	_append_null_terminated_char(dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xeba5
movq %rsi, %r14
testq %rsi, %rsi
je 0xebc4
movl %edx, %r15d
testl %edx, %edx
js 0xebe3
movq %rdi, %rbx
movq %r14, %rdi
callq 0xa080
movq %rax, %r12
testl %r12d, %r12d
je 0xeb96
movq %r14, -0x30(%rbp)
movl 0x4(%rbx), %eax
addl %r12d, %eax
cmpl (%rbx), %eax
jle 0xeb4e
movq %rbx, %rdi
movl %r12d, %esi
callq 0xe9ef
movl %r15d, %r13d
movq 0x8(%rbx), %rsi
addq %r13, %rsi
movslq %r12d, %r14
leaq (%rsi,%r14), %rdi
movslq 0x4(%rbx), %rdx
movslq %r15d, %rax
subq %rax, %rdx
callq 0xa110
addq 0x8(%rbx), %r13
movq %r13, %rdi
movq -0x30(%rbp), %rsi
movq %r14, %rdx
callq 0xa110
movslq 0x4(%rbx), %rax
movslq %r12d, %rcx
addq %rax, %rcx
movl %ecx, 0x4(%rbx)
movq 0x8(%rbx), %rax
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f4bd(%rip), %rdi     # 0x2e069
leaq 0x20eb2(%rip), %rsi     # 0x2fa65
leaq 0x210ff(%rip), %rcx     # 0x2fcb9
movl $0xdb, %edx
callq 0xa0b0
leaq 0x21332(%rip), %rdi     # 0x2fefd
leaq 0x20e93(%rip), %rsi     # 0x2fa65
leaq 0x210e0(%rip), %rcx     # 0x2fcb9
movl $0xdc, %edx
callq 0xa0b0
leaq 0x21110(%rip), %rdi     # 0x2fcfa
leaq 0x20e74(%rip), %rsi     # 0x2fa65
leaq 0x210c1(%rip), %rcx     # 0x2fcb9
movl $0xdd, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/string.c
// Function: rstr_insert_with_raw
void rstr_insert_with_raw(ResizableString *dst, const char *src, unsigned int len, int pos) {
	assert(dst);
	assert(src);
	assert(len >= 0);
	assert(pos >= 0);

	if (len == 0) {
		return;
	}

	if (dst->len + len > dst->size) {
		_inc_buffer_size(dst, len);
	}

	memcpy(dst->buffer + pos + len, dst->buffer + pos, dst->len - pos);
	memcpy(dst->buffer + pos, src, len);
	dst->len += len;

	_append_null_terminated_char(dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xecc4
testq %rsi, %rsi
je 0xece3
movl %ecx, %r12d
testl %ecx, %ecx
js 0xed02
movl %edx, %ebx
testl %edx, %edx
je 0xecb5
movq %rdi, %r14
movq %rsi, -0x30(%rbp)
movl 0x4(%rdi), %eax
addl %ebx, %eax
cmpl (%rdi), %eax
jbe 0xec6f
movq %r14, %rdi
movl %ebx, %esi
callq 0xe9ef
movl %r12d, %r13d
movq 0x8(%r14), %rsi
addq %r13, %rsi
movl %ebx, %r15d
leaq (%rsi,%r15), %rdi
movslq 0x4(%r14), %rdx
movslq %r12d, %rax
subq %rax, %rdx
callq 0xa110
addq 0x8(%r14), %r13
movq %r13, %rdi
movq -0x30(%rbp), %rsi
movq %r15, %rdx
callq 0xa110
addl 0x4(%r14), %ebx
movl %ebx, 0x4(%r14)
movq 0x8(%r14), %rax
movslq %ebx, %rcx
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f39e(%rip), %rdi     # 0x2e069
leaq 0x20d93(%rip), %rsi     # 0x2fa65
leaq 0x2102a(%rip), %rcx     # 0x2fd03
movl $0xf7, %edx
callq 0xa0b0
leaq 0x21213(%rip), %rdi     # 0x2fefd
leaq 0x20d74(%rip), %rsi     # 0x2fa65
leaq 0x2100b(%rip), %rcx     # 0x2fd03
movl $0xf8, %edx
callq 0xa0b0
leaq 0x20ff1(%rip), %rdi     # 0x2fcfa
leaq 0x20d55(%rip), %rsi     # 0x2fa65
leaq 0x20fec(%rip), %rcx     # 0x2fd03
movl $0xfa, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/string.c
// Function: rstr_insert_with_rstr
void rstr_insert_with_rstr(ResizableString *dst, const ResizableString *src, int pos) {
	assert(dst);
	assert(src);
	assert(pos >= 0);

	if (src->len == 0) {
		return;
	}

	if (dst->len + src->len > dst->size) {
		_inc_buffer_size(dst, src->len);
	}

	memcpy(dst->buffer + pos + src->len, dst->buffer + pos, dst->len - pos);
	memcpy(dst->buffer + pos, src->buffer, src->len);
	dst->len += src->len;

	_append_null_terminated_char(dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xedbb
movq %rsi, %r14
testq %rsi, %rsi
je 0xedda
movl %edx, %r15d
testl %edx, %edx
js 0xedf9
movl 0x4(%r14), %esi
testl %esi, %esi
je 0xedb2
movq %rdi, %rbx
movl 0x4(%rdi), %eax
addl %esi, %eax
cmpl (%rdi), %eax
jle 0xed68
movq %rbx, %rdi
callq 0xe9ef
movl %r15d, %r12d
movq 0x8(%rbx), %rsi
addq %r12, %rsi
movslq 0x4(%r14), %rdi
addq %rsi, %rdi
movslq 0x4(%rbx), %rdx
movslq %r15d, %rax
subq %rax, %rdx
callq 0xa110
addq 0x8(%rbx), %r12
movq 0x8(%r14), %rsi
movslq 0x4(%r14), %rdx
movq %r12, %rdi
callq 0xa110
movslq 0x4(%r14), %rax
movslq 0x4(%rbx), %rcx
addq %rax, %rcx
movl %ecx, 0x4(%rbx)
movq 0x8(%rbx), %rax
movb $0x0, (%rax,%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f2a7(%rip), %rdi     # 0x2e069
leaq 0x20c9c(%rip), %rsi     # 0x2fa65
leaq 0x20f81(%rip), %rcx     # 0x2fd51
movl $0x10c, %edx            # imm = 0x10C
callq 0xa0b0
leaq 0x2111c(%rip), %rdi     # 0x2fefd
leaq 0x20c7d(%rip), %rsi     # 0x2fa65
leaq 0x20f62(%rip), %rcx     # 0x2fd51
movl $0x10d, %edx            # imm = 0x10D
callq 0xa0b0
leaq 0x20efa(%rip), %rdi     # 0x2fcfa
leaq 0x20c5e(%rip), %rsi     # 0x2fa65
leaq 0x20f43(%rip), %rcx     # 0x2fd51
movl $0x10e, %edx            # imm = 0x10E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x100c8, %rsp          # imm = 0x100C8
movl %esi, %ebx
movq %rdi, %r14
leaq -0xe0(%rbp), %rsi
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0xee6d
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq -0x30(%rbp), %rcx
movq %rsi, 0x10(%rcx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rcx)
leaq -0x100e0(%rbp), %r15
movl $0x10000, %esi          # imm = 0x10000
movq %r15, %rdi
callq 0xa060
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0xeaf4
addq $0x100c8, %rsp          # imm = 0x100C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xefdb
movl 0x4(%rdi), %eax
cmpl 0x4(%rsi), %eax
jne 0xefdb
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xefde
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rsi), %rsi
callq 0xa0e0
testl %eax, %eax
sete %al
popq %rbp
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/string.c
// Function: rstr_split
void rstr_split(
	LinkedList *llst,
	ResizableString *rstr,
	const char *seperator,
	bool ignore_empty
) {
	assert(llst);
	assert(rstr);
	assert(seperator);

	size_t sep_len = strlen(seperator);

	#define	_GET_STR(i) ((i) >= rstr->len ? NULL : &(rstr->buffer[(i)]))

	int idx = 0;
	while (_GET_STR(idx) != NULL) {
		ResizableString *item = rstr_new();

		while (_GET_STR(idx) != NULL && strncmp(_GET_STR(idx), seperator, sep_len) != 0) {
			rstr_append_with_char(item, *_GET_STR(idx));
			idx++;
		}

		if (_GET_STR(idx) != NULL && strncmp(_GET_STR(idx), seperator, sep_len) == 0) {
			idx += sep_len;
		}

		if (ignore_empty
				&& item->len == 0) {
			rstr_delete(item);
		} else {
			llst_append(llst, item);
		}
	}

	#undef	_GET_STR
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, -0x50(%rbp)
testq %rdi, %rdi
je 0xf128
movq %rsi, %r15
testq %rsi, %rsi
je 0xf147
testq %rdx, %rdx
je 0xf166
movl %ecx, %ebx
movq %rdx, -0x48(%rbp)
movq %rdx, %rdi
callq 0xa080
movq %rax, -0x40(%rbp)
cmpl $0x0, 0x4(%r15)
jle 0xf119
xorl %r12d, %r12d
movl %ebx, -0x30(%rbp)
cmpq $0x0, 0x8(%r15)
je 0xf119
callq 0xe84a
movq %rax, -0x38(%rbp)
cmpl 0x4(%r15), %r12d
setl %r13b
jge 0xf0e7
movslq %r12d, %r14
movq 0x8(%r15), %rbx
testq %rbx, %rbx
je 0xf0ad
leaq (%rbx,%r14), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0xa040
testl %eax, %eax
je 0xf0ad
movb (%rbx,%r14), %al
movw $0x0, -0x2a(%rbp)
movb %al, -0x2a(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x2a(%rbp), %rsi
callq 0xe4ef
incq %r14
movslq 0x4(%r15), %rax
cmpq %rax, %r14
setl %r13b
jge 0xf0e1
movq 0x8(%r15), %rbx
incl %r12d
jmp 0xf060
testb $0x1, %r13b
je 0xf0e4
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0xf0e4
movslq %r14d, %rax
addq %rax, %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rbx
movq %rbx, %rdx
callq 0xa040
testl %eax, %eax
movl $0x0, %eax
cmovel %ebx, %eax
addl %eax, %r12d
jmp 0xf0e4
incl %r12d
movl -0x30(%rbp), %ebx
testb %bl, %bl
je 0xf0f5
movq -0x38(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xf10e
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xbddf
cmpl 0x4(%r15), %r12d
jl 0xf037
jmp 0xf119
movq -0x38(%rbp), %rdi
callq 0xe9a0
jmp 0xf102
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1fad3(%rip), %rdi     # 0x2ec02
leaq 0x2092f(%rip), %rsi     # 0x2fa65
leaq 0x20c60(%rip), %rcx     # 0x2fd9d
movl $0x15a, %edx            # imm = 0x15A
callq 0xa0b0
leaq 0x20912(%rip), %rdi     # 0x2fa60
leaq 0x20910(%rip), %rsi     # 0x2fa65
leaq 0x20c41(%rip), %rcx     # 0x2fd9d
movl $0x15b, %edx            # imm = 0x15B
callq 0xa0b0
leaq 0x20c76(%rip), %rdi     # 0x2fde3
leaq 0x208f1(%rip), %rsi     # 0x2fa65
leaq 0x20c22(%rip), %rcx     # 0x2fd9d
movl $0x15c, %edx            # imm = 0x15C
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 $0x10, %rsp
testq %rdi, %rdi
je 0xf1b3
testq %rsi, %rsi
je 0xf1d2
leaq -0x2(%rbp), %rax
movw $0x0, (%rax)
movb %dl, (%rax)
movzbl %cl, %ecx
movq %rax, %rdx
callq 0xefe1
addq $0x10, %rsp
popq %rbp
retq
leaq 0x1fa48(%rip), %rdi     # 0x2ec02
leaq 0x208a4(%rip), %rsi     # 0x2fa65
leaq 0x20c25(%rip), %rcx     # 0x2fded
movl $0x180, %edx            # imm = 0x180
callq 0xa0b0
leaq 0x20887(%rip), %rdi     # 0x2fa60
leaq 0x20885(%rip), %rsi     # 0x2fa65
leaq 0x20c06(%rip), %rcx     # 0x2fded
movl $0x181, %edx            # imm = 0x181
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xf27c
movq %rsi, %rbx
testq %rsi, %rsi
je 0xf29b
movq %rdi, %r12
movq %rbx, %rdi
callq 0xa080
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testq %rax, %rax
je 0xf26a
movq %rax, %r15
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x2057e(%rip), %r12     # 0x2f7b6
cmovneq %rax, %r12
cmpb $0x0, (%r12)
je 0xf26a
xorl %r13d, %r13d
leaq (%r12,%r13), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xa040
testl %eax, %eax
je 0xf267
cmpb $0x0, 0x1(%r12,%r13)
leaq 0x1(%r13), %r13
jne 0xf246
jmp 0xf26a
movl %r13d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x207dd(%rip), %rdi     # 0x2fa60
leaq 0x207db(%rip), %rsi     # 0x2fa65
leaq 0x20ba2(%rip), %rcx     # 0x2fe33
movl $0x18d, %edx            # imm = 0x18D
callq 0xa0b0
leaq 0x20bc4(%rip), %rdi     # 0x2fe66
leaq 0x207bc(%rip), %rsi     # 0x2fa65
leaq 0x20b83(%rip), %rcx     # 0x2fe33
movl $0x18e, %edx            # imm = 0x18E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xf345
movq %rsi, %rbx
testq %rsi, %rsi
je 0xf364
movq %rdi, %r12
movq %rbx, %rdi
callq 0xa080
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testq %rax, %rax
je 0xf333
movslq 0x4(%r12), %r13
testq %r13, %r13
js 0xf333
movq %rax, %r15
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x204ab(%rip), %r12     # 0x2f7b6
cmovneq %rax, %r12
leaq (%r12,%r13), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xa040
testl %eax, %eax
je 0xf330
leaq -0x1(%r13), %rax
testq %r13, %r13
movq %rax, %r13
jg 0xf30f
jmp 0xf333
movl %r13d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20714(%rip), %rdi     # 0x2fa60
leaq 0x20712(%rip), %rsi     # 0x2fa65
leaq 0x20b19(%rip), %rcx     # 0x2fe73
movl $0x1a2, %edx            # imm = 0x1A2
callq 0xa0b0
leaq 0x20afb(%rip), %rdi     # 0x2fe66
leaq 0x206f3(%rip), %rsi     # 0x2fa65
leaq 0x20afa(%rip), %rcx     # 0x2fe73
movl $0x1a3, %edx            # imm = 0x1A3
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xf40b
movq %rsi, %r14
testq %rsi, %rsi
je 0xf42a
movq %rdi, %r15
cmpq %r14, %rdi
je 0xf449
movq %rcx, %rbx
addq %rdx, %rbx
movslq %edx, %r13
cmpq %r13, %rbx
jbe 0xf3fc
leaq 0x203f3(%rip), %r12     # 0x2f7b6
movslq 0x4(%r14), %rax
cmpq %rax, %r13
jge 0xf3fc
movq 0x8(%r14), %rax
testq %rax, %rax
cmoveq %r12, %rax
movb (%rax,%r13), %al
cmpb $-0x1, %al
je 0xf3fc
movw $0x0, -0x2a(%rbp)
movb %al, -0x2a(%rbp)
movq %r15, %rdi
leaq -0x2a(%rbp), %rsi
callq 0xe4ef
incq %r13
cmpq %r13, %rbx
ja 0xf3c3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ec57(%rip), %rdi     # 0x2e069
leaq 0x2064c(%rip), %rsi     # 0x2fa65
leaq 0x20a8b(%rip), %rcx     # 0x2feab
movl $0x1bb, %edx            # imm = 0x1BB
callq 0xa0b0
leaq 0x20acc(%rip), %rdi     # 0x2fefd
leaq 0x2062d(%rip), %rsi     # 0x2fa65
leaq 0x20a6c(%rip), %rcx     # 0x2feab
movl $0x1bc, %edx            # imm = 0x1BC
callq 0xa0b0
leaq 0x20aa6(%rip), %rdi     # 0x2fef6
leaq 0x2060e(%rip), %rsi     # 0x2fa65
leaq 0x20a4d(%rip), %rcx     # 0x2feab
movl $0x1bd, %edx            # imm = 0x1BD
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xf55b
movq %rsi, %rbx
testq %rsi, %rsi
je 0xf57a
movq %rdi, %r14
cmpq %rbx, %rdi
je 0xf599
movq %rdx, %r15
testq %rdx, %rdx
je 0xf5b8
cmpl $0x0, 0x4(%rbx)
jle 0xf532
xorl %r12d, %r12d
leaq 0x202a9(%rip), %r13     # 0x2f7b6
movq 0x8(%rbx), %rax
testq %rax, %rax
cmoveq %r13, %rax
movsbl (%rax,%r12), %edi
callq *%r15
testb %al, %al
je 0xf535
incq %r12
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jl 0xf50d
jmp 0xf535
xorl %r12d, %r12d
movl %r12d, %edx
movslq 0x4(%rbx), %rcx
movslq %r12d, %rax
subq %rax, %rcx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf383
leaq 0x1eb07(%rip), %rdi     # 0x2e069
leaq 0x204fc(%rip), %rsi     # 0x2fa65
leaq 0x209b4(%rip), %rcx     # 0x2ff24
movl $0x1d9, %edx            # imm = 0x1D9
callq 0xa0b0
leaq 0x2097c(%rip), %rdi     # 0x2fefd
leaq 0x204dd(%rip), %rsi     # 0x2fa65
leaq 0x20995(%rip), %rcx     # 0x2ff24
movl $0x1da, %edx            # imm = 0x1DA
callq 0xa0b0
leaq 0x20956(%rip), %rdi     # 0x2fef6
leaq 0x204be(%rip), %rsi     # 0x2fa65
leaq 0x20976(%rip), %rcx     # 0x2ff24
movl $0x1db, %edx            # imm = 0x1DB
callq 0xa0b0
leaq 0x1f708(%rip), %rdi     # 0x2ecc7
leaq 0x2049f(%rip), %rsi     # 0x2fa65
leaq 0x20957(%rip), %rcx     # 0x2ff24
movl $0x1dc, %edx            # imm = 0x1DC
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xf67e
movq %rsi, %rbx
testq %rsi, %rsi
je 0xf69d
cmpq %rbx, %rdi
je 0xf6bc
movq %rdx, %r15
testq %rdx, %rdx
je 0xf6db
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 0xf65c
movb $-0x1, %al
cmpl %r12d, 0x4(%rbx)
jl 0xf64a
movq 0x8(%rbx), %rax
testq %rax, %rax
leaq 0x20175(%rip), %rcx     # 0x2f7b6
cmoveq %rcx, %rax
movb -0x1(%rax,%r12), %al
movsbl %al, %edi
callq *%r15
decl %r13d
decq %r12
testb %al, %al
jne 0xf626
jmp 0xf65f
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 0xf383
leaq 0x1e9e4(%rip), %rdi     # 0x2e069
leaq 0x203d9(%rip), %rsi     # 0x2fa65
leaq 0x208dc(%rip), %rcx     # 0x2ff6f
movl $0x1e9, %edx            # imm = 0x1E9
callq 0xa0b0
leaq 0x20859(%rip), %rdi     # 0x2fefd
leaq 0x203ba(%rip), %rsi     # 0x2fa65
leaq 0x208bd(%rip), %rcx     # 0x2ff6f
movl $0x1ea, %edx            # imm = 0x1EA
callq 0xa0b0
leaq 0x20833(%rip), %rdi     # 0x2fef6
leaq 0x2039b(%rip), %rsi     # 0x2fa65
leaq 0x2089e(%rip), %rcx     # 0x2ff6f
movl $0x1eb, %edx            # imm = 0x1EB
callq 0xa0b0
leaq 0x1f5e5(%rip), %rdi     # 0x2ecc7
leaq 0x2037c(%rip), %rsi     # 0x2fa65
leaq 0x2087f(%rip), %rcx     # 0x2ff6f
movl $0x1ec, %edx            # imm = 0x1EC
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xf7e2
movq %rsi, %rbx
testq %rsi, %rsi
je 0xf801
cmpq %rbx, %rdi
je 0xf820
movq %rdx, %r15
testq %rdx, %rdx
je 0xf83f
movq %rdi, -0x38(%rbp)
cmpl $0x0, 0x4(%rbx)
leaq 0x20072(%rip), %r14     # 0x2f7b6
jle 0xf76e
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
testq %rax, %rax
cmoveq %r14, %rax
movsbl (%rax,%r12), %edi
callq *%r15
testb %al, %al
je 0xf771
incq %r12
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jl 0xf749
jmp 0xf771
xorl %r12d, %r12d
movl 0x4(%rbx), %r13d
movl %r13d, %eax
sarl $0x1f, %eax
andl %r13d, %eax
movl %eax, -0x2c(%rbp)
leal 0x1(%r13), %r14d
testl %r13d, %r13d
jle 0xf7bb
movb $-0x1, %al
cmpl %r13d, 0x4(%rbx)
jl 0xf7a9
movq 0x8(%rbx), %rax
testq %rax, %rax
leaq 0x20016(%rip), %rcx     # 0x2f7b6
cmoveq %rcx, %rax
movb -0x1(%rax,%r13), %al
movsbl %al, %edi
callq *%r15
decl %r14d
decq %r13
testb %al, %al
jne 0xf785
jmp 0xf7bf
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 0xf383
leaq 0x1e880(%rip), %rdi     # 0x2e069
leaq 0x20275(%rip), %rsi     # 0x2fa65
leaq 0x207c3(%rip), %rcx     # 0x2ffba
movl $0x1f9, %edx            # imm = 0x1F9
callq 0xa0b0
leaq 0x206f5(%rip), %rdi     # 0x2fefd
leaq 0x20256(%rip), %rsi     # 0x2fa65
leaq 0x207a4(%rip), %rcx     # 0x2ffba
movl $0x1fa, %edx            # imm = 0x1FA
callq 0xa0b0
leaq 0x206cf(%rip), %rdi     # 0x2fef6
leaq 0x20237(%rip), %rsi     # 0x2fa65
leaq 0x20785(%rip), %rcx     # 0x2ffba
movl $0x1fb, %edx            # imm = 0x1FB
callq 0xa0b0
leaq 0x1f481(%rip), %rdi     # 0x2ecc7
leaq 0x20218(%rip), %rsi     # 0x2fa65
leaq 0x20766(%rip), %rcx     # 0x2ffba
movl $0x1fc, %edx            # imm = 0x1FC
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xf8ad
testq %rsi, %rsi
je 0xf8cc
cmpq %rsi, %rdi
je 0xf8eb
movl 0x4(%rsi), %eax
testl %eax, %eax
jle 0xf89e
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
leaq 0x1ff30(%rip), %r8      # 0x2f7b6
cmovneq %rcx, %r8
xorl %ecx, %ecx
cmpb %dl, (%r8,%rcx)
jne 0xf8a0
incq %rcx
cmpq %rcx, %rax
jne 0xf88c
movl %eax, %ecx
jmp 0xf8a0
xorl %ecx, %ecx
movl %ecx, %edx
subl %ecx, %eax
movslq %eax, %rcx
popq %rbp
jmp 0xf383
leaq 0x1e7b5(%rip), %rdi     # 0x2e069
leaq 0x201aa(%rip), %rsi     # 0x2fa65
leaq 0x20742(%rip), %rcx     # 0x30004
movl $0x20c, %edx            # imm = 0x20C
callq 0xa0b0
leaq 0x2062a(%rip), %rdi     # 0x2fefd
leaq 0x2018b(%rip), %rsi     # 0x2fa65
leaq 0x20723(%rip), %rcx     # 0x30004
movl $0x20d, %edx            # imm = 0x20D
callq 0xa0b0
leaq 0x20604(%rip), %rdi     # 0x2fef6
leaq 0x2016c(%rip), %rsi     # 0x2fa65
leaq 0x20704(%rip), %rcx     # 0x30004
movl $0x20e, %edx            # imm = 0x20E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xf978
testq %rsi, %rsi
je 0xf997
cmpq %rsi, %rdi
je 0xf9b6
movl 0x4(%rsi), %eax
movsbl %dl, %edx
movl %eax, %ecx
sarl $0x1f, %ecx
andl %eax, %ecx
leal 0x1(%rax), %r8d
leaq 0x1fe7d(%rip), %r9      # 0x2f7b6
movq %rax, %r10
testl %r10d, %r10d
jle 0xf96a
movl $0xffffffff, %r11d      # imm = 0xFFFFFFFF
cmpl %r10d, %eax
jl 0xf95d
movq 0x8(%rsi), %r11
testq %r11, %r11
cmoveq %r9, %r11
movsbl -0x1(%r11,%r10), %r11d
decl %r8d
decq %r10
cmpl %edx, %r11d
je 0xf93c
jmp 0xf96d
movl %ecx, %r8d
movslq %r8d, %rcx
xorl %edx, %edx
popq %rbp
jmp 0xf383
leaq 0x1e6ea(%rip), %rdi     # 0x2e069
leaq 0x200df(%rip), %rsi     # 0x2fa65
leaq 0x206b3(%rip), %rcx     # 0x30040
movl $0x21b, %edx            # imm = 0x21B
callq 0xa0b0
leaq 0x2055f(%rip), %rdi     # 0x2fefd
leaq 0x200c0(%rip), %rsi     # 0x2fa65
leaq 0x20694(%rip), %rcx     # 0x30040
movl $0x21c, %edx            # imm = 0x21C
callq 0xa0b0
leaq 0x20539(%rip), %rdi     # 0x2fef6
leaq 0x200a1(%rip), %rsi     # 0x2fa65
leaq 0x20675(%rip), %rcx     # 0x30040
movl $0x21d, %edx            # imm = 0x21D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xfa7e
testq %rsi, %rsi
je 0xfa9d
cmpq %rsi, %rdi
je 0xfabc
movl 0x4(%rsi), %eax
leaq 0x1fdb6(%rip), %rcx     # 0x2f7b6
testl %eax, %eax
jle 0xfa25
movq 0x8(%rsi), %r9
testq %r9, %r9
cmoveq %rcx, %r9
xorl %r8d, %r8d
cmpb %dl, (%r9,%r8)
jne 0xfa28
incq %r8
cmpq %r8, %rax
jne 0xfa12
movl %eax, %r8d
jmp 0xfa28
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 0xfa67
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl %r11d, %eax
jl 0xfa5a
movq 0x8(%rsi), %rbx
testq %rbx, %rbx
cmoveq %rcx, %rbx
movsbl -0x1(%rbx,%r11), %ebx
decl %r9d
decq %r11
cmpl %r10d, %ebx
je 0xfa3a
jmp 0xfa6a
movl %edx, %r9d
movl %r8d, %edx
subl %r8d, %r9d
movslq %r9d, %rcx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xf383
leaq 0x1e5e4(%rip), %rdi     # 0x2e069
leaq 0x1ffd9(%rip), %rsi     # 0x2fa65
leaq 0x205e9(%rip), %rcx     # 0x3007c
movl $0x22a, %edx            # imm = 0x22A
callq 0xa0b0
leaq 0x20459(%rip), %rdi     # 0x2fefd
leaq 0x1ffba(%rip), %rsi     # 0x2fa65
leaq 0x205ca(%rip), %rcx     # 0x3007c
movl $0x22b, %edx            # imm = 0x22B
callq 0xa0b0
leaq 0x20433(%rip), %rdi     # 0x2fef6
leaq 0x1ff9b(%rip), %rsi     # 0x2fa65
leaq 0x205ab(%rip), %rcx     # 0x3007c
movl $0x22c, %edx            # imm = 0x22C
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x105e8
leaq -0x98(%rbp), %rbx
movq %rbx, %rsi
callq 0xa100
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 0x24989(%rip), %rdi     # 0x34f78
leaq 0x1fe92(%rip), %rsi     # 0x30488
leaq 0x1fe92(%rip), %rcx     # 0x3048f
movl $0x15, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x10678
movq %rsi, %r14
testq %rsi, %rsi
je 0x10697
movl %edx, %ebx
testl %edx, %edx
js 0x106b6
leaq 0x1fed4(%rip), %rsi     # 0x30503
callq 0xa140
testq %rax, %rax
je 0x10668
movq %rax, %r15
testl %ebx, %ebx
je 0x10658
movl %ebx, %edx
movl $0x1, %esi
movq %r14, %rdi
movq %r15, %rcx
callq 0xa170
subl %eax, %ebx
testl %ebx, %ebx
jg 0x10640
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 0x248f9(%rip), %rdi     # 0x34f78
leaq 0x1fe02(%rip), %rsi     # 0x30488
leaq 0x1fe2b(%rip), %rcx     # 0x304b8
movl $0x24, %edx
callq 0xa0b0
leaq 0x1fe5d(%rip), %rdi     # 0x304fb
leaq 0x1fde3(%rip), %rsi     # 0x30488
leaq 0x1fe0c(%rip), %rcx     # 0x304b8
movl $0x25, %edx
callq 0xa0b0
leaq 0x1de90(%rip), %rdi     # 0x2e54d
leaq 0x1fdc4(%rip), %rsi     # 0x30488
leaq 0x1fded(%rip), %rcx     # 0x304b8
movl $0x26, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x107a4
movq %rsi, %rbx
testq %rsi, %rsi
je 0x107c3
movq %rdi, %r14
leaq -0xa8(%rbp), %r15
movq %r15, %rsi
callq 0xa100
movq 0x30(%r15), %r15
cmpq $0x7fffffff, %r15       # imm = 0x7FFFFFFF
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmovgl %ecx, %r15d
testl %eax, %eax
cmovsl %ecx, %r15d
testl %r15d, %r15d
js 0x1077c
movl %r15d, (%rbx)
je 0x10791
movl %r15d, %edi
callq 0xa120
testq %rax, %rax
je 0x10782
movq %rax, %rbx
leaq 0x20dba(%rip), %rsi     # 0x31501
movq %r14, %rdi
callq 0xa140
testq %rax, %rax
je 0x10784
movq %rax, %r14
movl %r15d, %edx
movl $0x1, %esi
movq %rbx, %rdi
movq %r14, %rcx
callq 0xa050
subl %eax, %r15d
testl %r15d, %r15d
jg 0x10757
movq %r14, %rdi
callq 0xa070
jmp 0x10793
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x10791
movq %rbx, %rdi
callq 0xa190
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x247cd(%rip), %rdi     # 0x34f78
leaq 0x1fcd6(%rip), %rsi     # 0x30488
leaq 0x1fd4d(%rip), %rcx     # 0x30506
movl $0x3e, %edx
callq 0xa0b0
leaq 0x1fd77(%rip), %rdi     # 0x30541
leaq 0x1fcb7(%rip), %rsi     # 0x30488
leaq 0x1fd2e(%rip), %rcx     # 0x30506
movl $0x3f, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 $0x1, %al
cmpb $0x61, %dil
je 0x1089b
movl $0x1, %edx
leaq 0x1fcc6(%rip), %rcx     # 0x3054b
cmpq $0xa, %rdx
setne %al
je 0x1089b
leaq 0x1(%rdx), %rsi
cmpb %dil, (%rdx,%rcx)
movq %rsi, %rdx
jne 0x10885
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1099c
movq %rdi, %rbx
cmpl $0x4, %esi
je 0x10951
cmpl $0x3, %esi
jne 0x10995
cmpb $0x27, (%rbx)
jne 0x10995
movsbq 0x1(%rbx), %r14
cmpq $0x27, %r14
je 0x10995
callq 0xa180
movq (%rax), %rax
movzwl (%rax,%r14,2), %ecx
movl $0x2, %eax
testl $0x8001, %ecx           # imm = 0x8001
jne 0x10969
jmp 0x10995
cmpb $0x27, (%rbx)
jne 0x10995
cmpb $0x5c, 0x1(%rbx)
jne 0x10995
movb 0x2(%rbx), %cl
movl $0x3, %eax
cmpb $0x61, %cl
jne 0x10972
cmpb $0x27, (%rbx,%rax)
sete %al
jmp 0x10997
movl $0x1, %edi
leaq 0x1fbcd(%rip), %rdx     # 0x3054b
cmpq $0xa, %rdi
je 0x10995
movq %rdi, %rsi
incq %rdi
cmpb %cl, (%rsi,%rdx)
jne 0x1097e
cmpq $0xa, %rsi
jne 0x10969
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1f128(%rip), %rdi     # 0x2facb
leaq 0x1fade(%rip), %rsi     # 0x30488
leaq 0x1fbb0(%rip), %rcx     # 0x30561
movl $0xae, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x10a86
movl %esi, %ebx
cmpl $0x2, %esi
jb 0x10a6d
movq %rdi, %r14
cmpb $0x22, (%rdi)
jne 0x10a6d
leal -0x1(%rbx), %eax
cmpb $0x22, (%r14,%rax)
jne 0x10a6d
addl $-0x2, %ebx
cmpl $0x2, %ebx
setb %r15b
jb 0x10a70
movl $0x1, %r12d
movsbq (%r14,%r12), %r13
cmpq $0x22, %r13
je 0x10a2a
callq 0xa180
cmpb $0x5c, %r13b
je 0x10a5f
movq (%rax), %rax
movzwl (%rax,%r13,2), %eax
andl $0x8001, %eax           # imm = 0x8001
jne 0x10a5f
leaq 0x1(%r12), %rax
cmpq %rbx, %rax
jb 0x10a5f
movb (%r14,%rax), %al
cmpb $0x61, %al
je 0x10a5f
movl $0x1, %edx
leaq 0x1fb0e(%rip), %rsi     # 0x30556
cmpq $0xa, %rdx
je 0x10a70
movq %rdx, %rcx
incq %rdx
cmpb %al, (%rcx,%rsi)
jne 0x10a48
cmpq $0xa, %rcx
je 0x10a70
incq %r12
cmpq %rbx, %r12
setae %r15b
jne 0x10a05
jmp 0x10a70
xorl %r15d, %r15d
andb $0x1, %r15b
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f03e(%rip), %rdi     # 0x2facb
leaq 0x1f9f4(%rip), %rsi     # 0x30488
leaq 0x1faf9(%rip), %rcx     # 0x30594
movl $0xc2, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x10b17
cmpl $0x3, %esi
jb 0x10b12
cmpb $0x30, (%rdi)
jne 0x10b12
cmpb $0x62, 0x1(%rdi)
jne 0x10b12
movb 0x2(%rdi), %al
andb $-0x2, %al
cmpb $0x30, %al
jne 0x10b12
cmpl $0x3, %esi
sete %al
je 0x10b14
movl %esi, %ecx
movl $0x3, %edx
subq %rcx, %rdx
movl $0x4, %esi
movabsq $0x800000000003, %r8    # imm = 0x800000000003
movzbl -0x1(%rdi,%rsi), %r9d
addl $-0x30, %r9d
cmpl $0x2f, %r9d
ja 0x10b14
btq %r9, %r8
jae 0x10b14
cmpq %rcx, %rsi
setae %al
leaq (%rdx,%rsi), %r9
incq %r9
incq %rsi
cmpq $0x4, %r9
jne 0x10ae4
jmp 0x10b14
xorl %eax, %eax
andb $0x1, %al
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1efa9(%rip), %rdi     # 0x2facb
leaq 0x1f95f(%rip), %rsi     # 0x30488
leaq 0x1fa99(%rip), %rcx     # 0x305c9
movl $0xdd, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x10b5e
testl %esi, %esi
je 0x10b5e
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x10b54
cmpl $0x2b, %eax
jne 0x10aa5
incq %rdi
decl %esi
jmp 0x10aa5
pushq %rbp
movq %rsp, %rbp
leaq 0x1fa97(%rip), %rdi     # 0x30600
leaq 0x1f918(%rip), %rsi     # 0x30488
leaq 0x1fa98(%rip), %rcx     # 0x3060f
movl $0xf6, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x10bfc
cmpl $0x3, %esi
jb 0x10bf9
cmpb $0x30, (%rdi)
jne 0x10bf9
cmpb $0x6f, 0x1(%rdi)
jne 0x10bf9
movb 0x2(%rdi), %al
andb $-0x8, %al
cmpb $0x30, %al
jne 0x10bf9
cmpl $0x3, %esi
sete %al
je 0x10bfb
movb 0x3(%rdi), %cl
movl %ecx, %edx
andb $-0x8, %dl
cmpb $0x30, %dl
setne %dl
cmpb $0x5f, %cl
setne %cl
testb %dl, %cl
jne 0x10bfb
movl %esi, %eax
movl $0x4, %edx
movq %rdx, %rcx
cmpq %rdx, %rax
je 0x10bf2
movb (%rdi,%rcx), %dl
movl %edx, %esi
andb $-0x8, %sil
cmpb $0x30, %sil
sete %sil
cmpb $0x5f, %dl
sete %r8b
orb %sil, %r8b
leaq 0x1(%rcx), %rdx
testb %r8b, %r8b
jne 0x10bc6
cmpq %rax, %rcx
setae %al
retq
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1eec4(%rip), %rdi     # 0x2facb
leaq 0x1f87a(%rip), %rsi     # 0x30488
leaq 0x1fa30(%rip), %rcx     # 0x30645
movl $0x103, %edx            # imm = 0x103
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x10c43
testl %esi, %esi
je 0x10c43
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x10c39
cmpl $0x2b, %eax
jne 0x10b81
incq %rdi
decl %esi
jmp 0x10b81
pushq %rbp
movq %rsp, %rbp
leaq 0x1f9b2(%rip), %rdi     # 0x30600
leaq 0x1f833(%rip), %rsi     # 0x30488
leaq 0x1fa20(%rip), %rcx     # 0x3067c
movl $0x11c, %edx            # imm = 0x11C
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x10ccf
testl %esi, %esi
je 0x10ccc
movb (%rdi), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x10ccc
cmpl $0x1, %esi
sete %al
je 0x10ccb
movb 0x1(%rdi), %cl
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
setae %dl
cmpb $0x5f, %cl
setne %cl
testb %dl, %cl
jne 0x10ccb
movl %esi, %eax
movl $0x2, %edx
movq %rdx, %rcx
cmpq %rdx, %rax
je 0x10cc5
movb (%rdi,%rcx), %dl
leal -0x30(%rdx), %esi
cmpb $0xa, %sil
setb %sil
cmpb $0x5f, %dl
sete %r8b
orb %sil, %r8b
leaq 0x1(%rcx), %rdx
testb %r8b, %r8b
jne 0x10c9c
cmpq %rax, %rcx
setae %al
retq
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1edf1(%rip), %rdi     # 0x2facb
leaq 0x1f7a7(%rip), %rsi     # 0x30488
leaq 0x1f9ca(%rip), %rcx     # 0x306b2
movl $0x129, %edx            # imm = 0x129
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0x10d16
testl %esi, %esi
je 0x10d16
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x10d0c
cmpl $0x2b, %eax
jne 0x10c66
incq %rdi
decl %esi
jmp 0x10c66
pushq %rbp
movq %rsp, %rbp
leaq 0x1f8df(%rip), %rdi     # 0x30600
leaq 0x1f760(%rip), %rsi     # 0x30488
leaq 0x1f9ba(%rip), %rcx     # 0x306e9
movl $0x140, %edx            # imm = 0x140
callq 0xa0b0