LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0xe2dd
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xa190
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1f75c(%rip), %rdi     # 0x2da40
leaq 0x1f75a(%rip), %rsi     # 0x2da45
leaq 0x1f89e(%rip), %rcx     # 0x2db90
pushq $0x6d
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xe37b
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 0xe368
callq 0xa130
jmp 0xe370
movq %rsi, %rdi
callq 0xa120
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x200af(%rip), %rdi     # 0x2e431
leaq 0x1f6bc(%rip), %rsi     # 0x2da45
leaq 0x20073(%rip), %rcx     # 0x2e403
movl $0x81, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xe4ee
movq %rsi, %r14
testq %rsi, %rsi
je 0xe50d
movl %edx, %r15d
testl %edx, %edx
js 0xe52c
movq %rdi, %rbx
movq %r14, %rdi
callq 0xa080
movq %rax, %r12
testl %r12d, %r12d
je 0xe4df
movq %r14, -0x30(%rbp)
movl 0x4(%rbx), %eax
leal (%rax,%r12), %ecx
cmpl (%rbx), %ecx
jle 0xe49b
movq %rbx, %rdi
movl %r12d, %esi
callq 0xe338
movl 0x4(%rbx), %eax
movl %r15d, %r13d
movq 0x8(%rbx), %rsi
addq %r13, %rsi
movslq %r12d, %r14
leaq (%rsi,%r14), %rdi
subl %r15d, %eax
movslq %eax, %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 0x1db74(%rip), %rdi     # 0x2c069
leaq 0x1f549(%rip), %rsi     # 0x2da45
leaq 0x1f796(%rip), %rcx     # 0x2dc99
movl $0xdb, %edx
callq 0xa0b0
leaq 0x1f9c9(%rip), %rdi     # 0x2dedd
leaq 0x1f52a(%rip), %rsi     # 0x2da45
leaq 0x1f777(%rip), %rcx     # 0x2dc99
movl $0xdc, %edx
callq 0xa0b0
leaq 0x1f7a7(%rip), %rdi     # 0x2dcda
leaq 0x1f50b(%rip), %rsi     # 0x2da45
leaq 0x1f758(%rip), %rcx     # 0x2dc99
movl $0xdd, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xe60d
testq %rsi, %rsi
je 0xe62c
movl %ecx, %r12d
testl %ecx, %ecx
js 0xe64b
movl %edx, %ebx
testl %edx, %edx
je 0xe5fe
movq %rdi, %r14
movq %rsi, -0x30(%rbp)
movl 0x4(%rdi), %eax
leal (%rax,%rbx), %ecx
cmpl (%rdi), %ecx
jbe 0xe5bc
movq %r14, %rdi
movl %ebx, %esi
callq 0xe338
movl 0x4(%r14), %eax
movl %r12d, %r13d
movq 0x8(%r14), %rsi
addq %r13, %rsi
movl %ebx, %r15d
leaq (%rsi,%r15), %rdi
subl %r12d, %eax
movslq %eax, %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 0x1da55(%rip), %rdi     # 0x2c069
leaq 0x1f42a(%rip), %rsi     # 0x2da45
leaq 0x1f6c1(%rip), %rcx     # 0x2dce3
movl $0xf7, %edx
callq 0xa0b0
leaq 0x1f8aa(%rip), %rdi     # 0x2dedd
leaq 0x1f40b(%rip), %rsi     # 0x2da45
leaq 0x1f6a2(%rip), %rcx     # 0x2dce3
movl $0xf8, %edx
callq 0xa0b0
leaq 0x1f688(%rip), %rdi     # 0x2dcda
leaq 0x1f3ec(%rip), %rsi     # 0x2da45
leaq 0x1f683(%rip), %rcx     # 0x2dce3
movl $0xfa, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xe70a
movq %rsi, %r14
testq %rsi, %rsi
je 0xe729
movl %edx, %r15d
testl %edx, %edx
js 0xe748
movl 0x4(%r14), %esi
testl %esi, %esi
je 0xe701
movq %rdi, %rbx
movl 0x4(%rdi), %ecx
leal (%rcx,%rsi), %eax
cmpl (%rdi), %eax
jle 0xe6b9
movq %rbx, %rdi
callq 0xe338
movl 0x4(%r14), %esi
movl 0x4(%rbx), %ecx
movl %r15d, %r12d
movq 0x8(%rbx), %rax
addq %r12, %rax
movslq %esi, %rdi
addq %rax, %rdi
subl %r15d, %ecx
movslq %ecx, %rdx
movq %rax, %rsi
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 0x1d958(%rip), %rdi     # 0x2c069
leaq 0x1f32d(%rip), %rsi     # 0x2da45
leaq 0x1f612(%rip), %rcx     # 0x2dd31
movl $0x10c, %edx            # imm = 0x10C
callq 0xa0b0
leaq 0x1f7ad(%rip), %rdi     # 0x2dedd
leaq 0x1f30e(%rip), %rsi     # 0x2da45
leaq 0x1f5f3(%rip), %rcx     # 0x2dd31
movl $0x10d, %edx            # imm = 0x10D
callq 0xa0b0
leaq 0x1f58b(%rip), %rdi     # 0x2dcda
leaq 0x1f2ef(%rip), %rsi     # 0x2da45
leaq 0x1f5d4(%rip), %rcx     # 0x2dd31
movl $0x10e, %edx            # imm = 0x10E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xe7bc
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 0xe43d
addq $0x100c8, %rsp          # imm = 0x100C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe925
movl 0x4(%rdi), %eax
cmpl 0x4(%rsi), %eax
jne 0xe925
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xe928
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_O2/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
movl %ecx, -0x34(%rbp)
movq %rdi, -0x50(%rbp)
testq %rdi, %rdi
je 0xea4e
movq %rsi, %r15
testq %rsi, %rsi
je 0xea6d
testq %rdx, %rdx
je 0xea8c
movq %rdx, -0x48(%rbp)
movq %rdx, %rdi
callq 0xa080
movq %rax, -0x40(%rbp)
xorl %r13d, %r13d
cmpl 0x4(%r15), %r13d
jge 0xea3f
cmpq $0x0, 0x8(%r15)
je 0xea3f
callq 0xe1d5
movq %rax, -0x30(%rbp)
movslq %r13d, %r13
movq %r13, %r12
shlq $0x20, %r12
movslq 0x4(%r15), %rax
cmpq %rax, %r13
jge 0xea0f
movq 0x8(%r15), %rbx
testq %rbx, %rbx
je 0xea0f
leaq (%rbx,%r13), %r14
movq %r14, %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0xa040
testl %eax, %eax
je 0xe9e5
movsbl (%r14), %esi
movq -0x30(%rbp), %rdi
callq 0xdf81
incq %r13
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %r12
jmp 0xe99c
sarq $0x20, %r12
addq %r12, %rbx
movq %rbx, %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rbx
movq %rbx, %rdx
callq 0xa040
testl %eax, %eax
movl $0x0, %eax
cmovel %ebx, %eax
addl %r13d, %eax
movl %eax, %r13d
cmpb $0x0, -0x34(%rbp)
je 0xea1f
movq -0x30(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xea31
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xbb35
jmp 0xe974
movq -0x30(%rbp), %rdi
callq 0xe2fa
jmp 0xe974
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e19d(%rip), %rdi     # 0x2cbf2
leaq 0x1efe9(%rip), %rsi     # 0x2da45
leaq 0x1f31a(%rip), %rcx     # 0x2dd7d
movl $0x15a, %edx            # imm = 0x15A
callq 0xa0b0
leaq 0x1efcc(%rip), %rdi     # 0x2da40
leaq 0x1efca(%rip), %rsi     # 0x2da45
leaq 0x1f2fb(%rip), %rcx     # 0x2dd7d
movl $0x15b, %edx            # imm = 0x15B
callq 0xa0b0
leaq 0x1f330(%rip), %rdi     # 0x2ddc3
leaq 0x1efab(%rip), %rsi     # 0x2da45
leaq 0x1f2dc(%rip), %rcx     # 0x2dd7d
movl $0x15c, %edx            # imm = 0x15C
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xead8
testq %rsi, %rsi
je 0xeaf7
leaq -0x2(%rbp), %rax
andw $0x0, (%rax)
movb %dl, (%rax)
movzbl %cl, %ecx
movq %rax, %rdx
callq 0xe92b
addq $0x10, %rsp
popq %rbp
retq
leaq 0x1e113(%rip), %rdi     # 0x2cbf2
leaq 0x1ef5f(%rip), %rsi     # 0x2da45
leaq 0x1f2e0(%rip), %rcx     # 0x2ddcd
movl $0x180, %edx            # imm = 0x180
callq 0xa0b0
leaq 0x1ef42(%rip), %rdi     # 0x2da40
leaq 0x1ef40(%rip), %rsi     # 0x2da45
leaq 0x1f2c1(%rip), %rcx     # 0x2ddcd
movl $0x181, %edx            # imm = 0x181
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xeb96
movq %rsi, %rbx
testq %rsi, %rsi
je 0xebb5
movq %rdi, %r12
movq %rbx, %rdi
callq 0xa080
pushq $-0x1
popq %r14
testq %rax, %rax
je 0xeb84
movq %rax, %r15
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x1ec37(%rip), %r12     # 0x2d792
cmovneq %rax, %r12
xorl %r13d, %r13d
cmpb $0x0, (%r12,%r13)
je 0xeb84
leaq (%r12,%r13), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xa040
testl %eax, %eax
je 0xeb81
incq %r13
jmp 0xeb62
movl %r13d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1eea3(%rip), %rdi     # 0x2da40
leaq 0x1eea1(%rip), %rsi     # 0x2da45
leaq 0x1f268(%rip), %rcx     # 0x2de13
movl $0x18d, %edx            # imm = 0x18D
callq 0xa0b0
leaq 0x1f28a(%rip), %rdi     # 0x2de46
leaq 0x1ee82(%rip), %rsi     # 0x2da45
leaq 0x1f249(%rip), %rcx     # 0x2de13
movl $0x18e, %edx            # imm = 0x18E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xec55
movq %rsi, %rbx
testq %rsi, %rsi
je 0xec74
movq %rdi, %r14
movq %rbx, %rdi
callq 0xa080
movq %rax, %r12
pushq $-0x1
popq %rax
testq %r12, %r12
je 0xec46
movl 0x4(%r14), %r13d
leaq 0x1eb7e(%rip), %r15     # 0x2d792
testl %r13d, %r13d
js 0xec3e
movq 0x8(%r14), %rax
testq %rax, %rax
cmoveq %r15, %rax
movl %r13d, %edi
addq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xa040
testl %eax, %eax
je 0xec43
decl %r13d
jmp 0xec14
pushq $-0x1
popq %rax
jmp 0xec46
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ede4(%rip), %rdi     # 0x2da40
leaq 0x1ede2(%rip), %rsi     # 0x2da45
leaq 0x1f1e9(%rip), %rcx     # 0x2de53
movl $0x1a2, %edx            # imm = 0x1A2
callq 0xa0b0
leaq 0x1f1cb(%rip), %rdi     # 0x2de46
leaq 0x1edc3(%rip), %rsi     # 0x2da45
leaq 0x1f1ca(%rip), %rcx     # 0x2de53
movl $0x1a3, %edx            # imm = 0x1A3
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xed0a
movq %rsi, %r14
testq %rsi, %rsi
je 0xed29
movq %rdi, %r15
cmpq %r14, %rdi
je 0xed48
movq %rcx, %rbx
addq %rdx, %rbx
movslq %edx, %r12
leaq 0x1eac8(%rip), %r13     # 0x2d792
cmpq %r12, %rbx
jbe 0xecfb
movslq 0x4(%r14), %rax
cmpq %rax, %r12
jge 0xecfb
movq 0x8(%r14), %rax
testq %rax, %rax
cmoveq %r13, %rax
movb (%rax,%r12), %al
cmpb $-0x1, %al
je 0xecfb
movsbl %al, %esi
movq %r15, %rdi
callq 0xdf81
incq %r12
jmp 0xecca
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1d358(%rip), %rdi     # 0x2c069
leaq 0x1ed2d(%rip), %rsi     # 0x2da45
leaq 0x1f16c(%rip), %rcx     # 0x2de8b
movl $0x1bb, %edx            # imm = 0x1BB
callq 0xa0b0
leaq 0x1f1ad(%rip), %rdi     # 0x2dedd
leaq 0x1ed0e(%rip), %rsi     # 0x2da45
leaq 0x1f14d(%rip), %rcx     # 0x2de8b
movl $0x1bc, %edx            # imm = 0x1BC
callq 0xa0b0
leaq 0x1f187(%rip), %rdi     # 0x2ded6
leaq 0x1ecef(%rip), %rsi     # 0x2da45
leaq 0x1f12e(%rip), %rcx     # 0x2de8b
movl $0x1bd, %edx            # imm = 0x1BD
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xee49
movq %rsi, %rbx
testq %rsi, %rsi
je 0xee68
movq %rdi, %r14
cmpq %rbx, %rdi
je 0xee87
movq %rdx, %r15
testq %rdx, %rdx
je 0xeea6
xorl %r12d, %r12d
leaq 0x1e993(%rip), %r13     # 0x2d792
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jge 0xee27
movq 0x8(%rbx), %rax
testq %rax, %rax
cmoveq %r13, %rax
movsbl (%rax,%r12), %edi
callq *%r15
testb %al, %al
je 0xee24
incq %r12
jmp 0xedff
movl 0x4(%rbx), %eax
movslq %eax, %rcx
subq %r12, %rcx
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xec93
leaq 0x1d219(%rip), %rdi     # 0x2c069
leaq 0x1ebee(%rip), %rsi     # 0x2da45
leaq 0x1f0a6(%rip), %rcx     # 0x2df04
movl $0x1d9, %edx            # imm = 0x1D9
callq 0xa0b0
leaq 0x1f06e(%rip), %rdi     # 0x2dedd
leaq 0x1ebcf(%rip), %rsi     # 0x2da45
leaq 0x1f087(%rip), %rcx     # 0x2df04
movl $0x1da, %edx            # imm = 0x1DA
callq 0xa0b0
leaq 0x1f048(%rip), %rdi     # 0x2ded6
leaq 0x1ebb0(%rip), %rsi     # 0x2da45
leaq 0x1f068(%rip), %rcx     # 0x2df04
movl $0x1db, %edx            # imm = 0x1DB
callq 0xa0b0
leaq 0x1de0a(%rip), %rdi     # 0x2ccb7
leaq 0x1eb91(%rip), %rsi     # 0x2da45
leaq 0x1f049(%rip), %rcx     # 0x2df04
movl $0x1dc, %edx            # imm = 0x1DC
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xef6c
movq %rsi, %rbx
testq %rsi, %rsi
je 0xef8b
cmpq %rbx, %rdi
je 0xefaa
movq %rdx, %r15
testq %rdx, %rdx
je 0xefc9
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 0xef4a
movb $-0x1, %al
cmpl %r12d, 0x4(%rbx)
jl 0xef38
movq 0x8(%rbx), %rax
testq %rax, %rax
leaq 0x1e863(%rip), %rcx     # 0x2d792
cmoveq %rcx, %rax
movb -0x1(%rax,%r12), %al
movsbl %al, %edi
callq *%r15
decl %r13d
decq %r12
testb %al, %al
jne 0xef14
jmp 0xef4d
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 0xec93
leaq 0x1d0f6(%rip), %rdi     # 0x2c069
leaq 0x1eacb(%rip), %rsi     # 0x2da45
leaq 0x1efce(%rip), %rcx     # 0x2df4f
movl $0x1e9, %edx            # imm = 0x1E9
callq 0xa0b0
leaq 0x1ef4b(%rip), %rdi     # 0x2dedd
leaq 0x1eaac(%rip), %rsi     # 0x2da45
leaq 0x1efaf(%rip), %rcx     # 0x2df4f
movl $0x1ea, %edx            # imm = 0x1EA
callq 0xa0b0
leaq 0x1ef25(%rip), %rdi     # 0x2ded6
leaq 0x1ea8d(%rip), %rsi     # 0x2da45
leaq 0x1ef90(%rip), %rcx     # 0x2df4f
movl $0x1eb, %edx            # imm = 0x1EB
callq 0xa0b0
leaq 0x1dce7(%rip), %rdi     # 0x2ccb7
leaq 0x1ea6e(%rip), %rsi     # 0x2da45
leaq 0x1ef71(%rip), %rcx     # 0x2df4f
movl $0x1ec, %edx            # imm = 0x1EC
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xf0cb
movq %rsi, %rbx
testq %rsi, %rsi
je 0xf0ea
cmpq %rbx, %rdi
je 0xf109
movq %rdx, %r15
testq %rdx, %rdx
je 0xf128
movq %rdi, -0x38(%rbp)
xorl %r12d, %r12d
leaq 0x1e761(%rip), %r13     # 0x2d792
movslq 0x4(%rbx), %r14
cmpq %r14, %r12
jge 0xf05a
movq 0x8(%rbx), %rax
testq %rax, %rax
cmoveq %r13, %rax
movsbl (%rax,%r12), %edi
callq *%r15
testb %al, %al
je 0xf056
incq %r12
jmp 0xf031
movl 0x4(%rbx), %r14d
movl %r14d, %r13d
movl %r14d, %eax
sarl $0x1f, %eax
andl %r14d, %eax
movl %eax, -0x2c(%rbp)
incl %r14d
testl %r13d, %r13d
jle 0xf0a2
movb $-0x1, %al
cmpl %r13d, 0x4(%rbx)
jl 0xf090
movq 0x8(%rbx), %rax
testq %rax, %rax
leaq 0x1e70b(%rip), %rcx     # 0x2d792
cmoveq %rcx, %rax
movb -0x1(%rax,%r13), %al
movsbl %al, %edi
callq *%r15
decl %r14d
decq %r13
testb %al, %al
jne 0xf06c
jmp 0xf0a8
movl -0x2c(%rbp), %eax
movl %eax, %r14d
movslq %r14d, %rcx
subq %r12, %rcx
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xec93
leaq 0x1cf97(%rip), %rdi     # 0x2c069
leaq 0x1e96c(%rip), %rsi     # 0x2da45
leaq 0x1eeba(%rip), %rcx     # 0x2df9a
movl $0x1f9, %edx            # imm = 0x1F9
callq 0xa0b0
leaq 0x1edec(%rip), %rdi     # 0x2dedd
leaq 0x1e94d(%rip), %rsi     # 0x2da45
leaq 0x1ee9b(%rip), %rcx     # 0x2df9a
movl $0x1fa, %edx            # imm = 0x1FA
callq 0xa0b0
leaq 0x1edc6(%rip), %rdi     # 0x2ded6
leaq 0x1e92e(%rip), %rsi     # 0x2da45
leaq 0x1ee7c(%rip), %rcx     # 0x2df9a
movl $0x1fb, %edx            # imm = 0x1FB
callq 0xa0b0
leaq 0x1db88(%rip), %rdi     # 0x2ccb7
leaq 0x1e90f(%rip), %rsi     # 0x2da45
leaq 0x1ee5d(%rip), %rcx     # 0x2df9a
movl $0x1fc, %edx            # imm = 0x1FC
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xf1a8
testq %rsi, %rsi
je 0xf1c7
cmpq %rsi, %rdi
je 0xf1e6
movl 0x4(%rsi), %ecx
xorl %eax, %eax
testl %ecx, %ecx
movl $0x0, %r8d
cmovgl %ecx, %r8d
leaq 0x1e61c(%rip), %r9      # 0x2d792
cmpq %rax, %r8
je 0xf191
movq 0x8(%rsi), %r10
testq %r10, %r10
cmoveq %r9, %r10
cmpb %dl, (%r10,%rax)
jne 0xf196
incq %rax
jmp 0xf176
movq %r8, %rax
jmp 0xf199
movl %eax, %r8d
subl %r8d, %ecx
movslq %ecx, %rcx
movq %rax, %rdx
popq %rbp
jmp 0xec93
leaq 0x1ceba(%rip), %rdi     # 0x2c069
leaq 0x1e88f(%rip), %rsi     # 0x2da45
leaq 0x1ee27(%rip), %rcx     # 0x2dfe4
movl $0x20c, %edx            # imm = 0x20C
callq 0xa0b0
leaq 0x1ed0f(%rip), %rdi     # 0x2dedd
leaq 0x1e870(%rip), %rsi     # 0x2da45
leaq 0x1ee08(%rip), %rcx     # 0x2dfe4
movl $0x20d, %edx            # imm = 0x20D
callq 0xa0b0
leaq 0x1ece9(%rip), %rdi     # 0x2ded6
leaq 0x1e851(%rip), %rsi     # 0x2da45
leaq 0x1ede9(%rip), %rcx     # 0x2dfe4
movl $0x20e, %edx            # imm = 0x20E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xf27e
testq %rsi, %rsi
je 0xf29d
cmpq %rsi, %rdi
je 0xf2bc
movl 0x4(%rsi), %eax
movsbl %dl, %edx
movl %eax, %ecx
sarl $0x1f, %ecx
andl %eax, %ecx
leal 0x1(%rax), %r8d
pushq $-0x1
popq %r9
leaq 0x1e554(%rip), %r10     # 0x2d792
movq %rax, %r11
testl %r11d, %r11d
jle 0xf26b
movl %r9d, %ebx
cmpl %r11d, %eax
jl 0xf25f
movq 0x8(%rsi), %rbx
testq %rbx, %rbx
cmoveq %r10, %rbx
movsbl -0x1(%rbx,%r11), %ebx
decl %r8d
decq %r11
cmpl %edx, %ebx
je 0xf241
jmp 0xf26e
movl %ecx, %r8d
movslq %r8d, %rcx
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xec93
leaq 0x1cde4(%rip), %rdi     # 0x2c069
leaq 0x1e7b9(%rip), %rsi     # 0x2da45
leaq 0x1ed8d(%rip), %rcx     # 0x2e020
movl $0x21b, %edx            # imm = 0x21B
callq 0xa0b0
leaq 0x1ec39(%rip), %rdi     # 0x2dedd
leaq 0x1e79a(%rip), %rsi     # 0x2da45
leaq 0x1ed6e(%rip), %rcx     # 0x2e020
movl $0x21c, %edx            # imm = 0x21C
callq 0xa0b0
leaq 0x1ec13(%rip), %rdi     # 0x2ded6
leaq 0x1e77b(%rip), %rsi     # 0x2da45
leaq 0x1ed4f(%rip), %rcx     # 0x2e020
movl $0x21d, %edx            # imm = 0x21D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
testq %rdi, %rdi
je 0xf385
testq %rsi, %rsi
je 0xf3a4
cmpq %rsi, %rdi
je 0xf3c3
movl 0x4(%rsi), %ecx
xorl %r9d, %r9d
testl %ecx, %ecx
movl $0x0, %eax
cmovgl %ecx, %eax
leaq 0x1e47e(%rip), %r8      # 0x2d792
cmpq %r9, %rax
je 0xf332
movq 0x8(%rsi), %r10
testq %r10, %r10
cmoveq %r8, %r10
cmpb %dl, (%r10,%r9)
jne 0xf32f
incq %r9
jmp 0xf314
movl %r9d, %eax
movsbl %dl, %r10d
movl %ecx, %edx
sarl $0x1f, %edx
andl %ecx, %edx
leal 0x1(%rcx), %r9d
pushq $-0x1
popq %r11
movq %rcx, %rbx
testl %ebx, %ebx
jle 0xf371
movl %r11d, %r14d
cmpl %ebx, %ecx
jl 0xf364
movq 0x8(%rsi), %r14
testq %r14, %r14
cmoveq %r8, %r14
movsbl -0x1(%r14,%rbx), %r14d
decl %r9d
decq %rbx
cmpl %r10d, %r14d
je 0xf348
jmp 0xf374
movl %edx, %r9d
movl %eax, %edx
subl %eax, %r9d
movslq %r9d, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0xec93
leaq 0x1ccdd(%rip), %rdi     # 0x2c069
leaq 0x1e6b2(%rip), %rsi     # 0x2da45
leaq 0x1ecc2(%rip), %rcx     # 0x2e05c
movl $0x22a, %edx            # imm = 0x22A
callq 0xa0b0
leaq 0x1eb32(%rip), %rdi     # 0x2dedd
leaq 0x1e693(%rip), %rsi     # 0x2da45
leaq 0x1eca3(%rip), %rcx     # 0x2e05c
movl $0x22b, %edx            # imm = 0x22B
callq 0xa0b0
leaq 0x1eb0c(%rip), %rdi     # 0x2ded6
leaq 0x1e674(%rip), %rsi     # 0x2da45
leaq 0x1ec84(%rip), %rcx     # 0x2e05c
movl $0x22c, %edx            # imm = 0x22C
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xfd5e
leaq -0x98(%rbp), %rbx
movq %rbx, %rsi
callq 0xa100
movq 0x30(%rbx), %rcx
cmpq $0x7fffffff, %rcx       # imm = 0x7FFFFFFF
pushq $-0x1
popq %rdx
cmovgl %edx, %ecx
testl %eax, %eax
cmovsl %edx, %ecx
movl %ecx, %eax
addq $0x98, %rsp
popq %rbx
popq %rbp
retq
leaq 0x231d3(%rip), %rdi     # 0x32f38
leaq 0x1e6e4(%rip), %rsi     # 0x2e450
leaq 0x1e6e4(%rip), %rcx     # 0x2e457
pushq $0x15
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
testq %rdi, %rdi
je 0xfdeb
movq %rsi, %r14
testq %rsi, %rsi
je 0xfe04
movl %edx, %ebx
testl %edx, %edx
js 0xfe1d
leaq 0x1e727(%rip), %rsi     # 0x2e4cb
callq 0xa140
testq %rax, %rax
je 0xfddf
movq %rax, %r15
testl %ebx, %ebx
je 0xfdcf
pushq $0x1
popq %r12
movl %ebx, %edx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0xa170
subl %eax, %ebx
testl %ebx, %ebx
jg 0xfdb9
movq %r15, %rdi
callq 0xa070
movq %r15, %rdi
callq 0xa070
pushq $-0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23146(%rip), %rdi     # 0x32f38
leaq 0x1e657(%rip), %rsi     # 0x2e450
leaq 0x1e680(%rip), %rcx     # 0x2e480
pushq $0x24
jmp 0xfe34
leaq 0x1e6b8(%rip), %rdi     # 0x2e4c3
leaq 0x1e63e(%rip), %rsi     # 0x2e450
leaq 0x1e667(%rip), %rcx     # 0x2e480
pushq $0x25
jmp 0xfe34
leaq 0x1c719(%rip), %rdi     # 0x2c53d
leaq 0x1e625(%rip), %rsi     # 0x2e450
leaq 0x1e64e(%rip), %rcx     # 0x2e480
pushq $0x26
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
testq %rdi, %rdi
je 0xfed6
movq %rsi, %rbx
testq %rsi, %rsi
je 0xfeef
movq %rdi, %r15
callq 0xfd1c
testl %eax, %eax
js 0xfebb
movl %eax, %r14d
movl %eax, (%rbx)
je 0xfec8
movl %r14d, %edi
callq 0xa120
testq %rax, %rax
je 0xfebe
movq %rax, %rbx
leaq 0x1f63d(%rip), %rsi     # 0x2f4c1
movq %r15, %rdi
callq 0xa140
testq %rax, %rax
je 0xfec0
movq %rax, %r15
pushq $0x1
popq %r12
movl %r14d, %edx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0xa050
subl %eax, %r14d
testl %r14d, %r14d
jg 0xfe98
movq %r15, %rdi
callq 0xa070
jmp 0xfeca
orl $-0x1, (%rbx)
xorl %ebx, %ebx
movq %rbx, %rdi
callq 0xa190
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2305b(%rip), %rdi     # 0x32f38
leaq 0x1e56c(%rip), %rsi     # 0x2e450
leaq 0x1e5e3(%rip), %rcx     # 0x2e4ce
pushq $0x3e
jmp 0xff06
leaq 0x1e613(%rip), %rdi     # 0x2e509
leaq 0x1e553(%rip), %rsi     # 0x2e450
leaq 0x1e5ca(%rip), %rcx     # 0x2e4ce
pushq $0x3f
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/util.c
// Function: util_is_literal_char_esc
bool util_is_literal_char_esc(char chr) {
	static const char esc_list[] = {'a', 'b', 'f', 'n', 'r', 't', 'v', '\\', '\'', '0', 0};

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

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edx, %edx
leaq 0x1e571(%rip), %rax     # 0x2e513
movq %rdx, %rcx
cmpq $0xa, %rdx
je 0xffb5
leaq 0x1(%rcx), %rdx
cmpb %dil, (%rcx,%rax)
jne 0xffa2
cmpq $0xa, %rcx
setne %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
testq %rdi, %rdi
je 0x1006c
movq %rdi, %rbx
cmpl $0x4, %esi
je 0x1003f
cmpl $0x3, %esi
jne 0x10063
cmpb $0x27, (%rbx)
jne 0x10063
movsbl 0x1(%rbx), %edi
callq 0xff37
testb %al, %al
je 0x10063
pushq $0x2
jmp 0x10059
cmpb $0x27, (%rbx)
jne 0x10063
cmpb $0x5c, 0x1(%rbx)
jne 0x10063
movsbl 0x2(%rbx), %edi
callq 0xff95
testb %al, %al
je 0x10063
pushq $0x3
popq %rax
cmpb $0x27, (%rbx,%rax)
sete %al
jmp 0x10065
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1da38(%rip), %rdi     # 0x2daab
leaq 0x1e3d6(%rip), %rsi     # 0x2e450
leaq 0x1e4a8(%rip), %rcx     # 0x2e529
movl $0xae, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x10116
movl %esi, %ebx
cmpl $0x2, %esi
jb 0x10101
movq %rdi, %r14
cmpb $0x22, (%rdi)
jne 0x10101
leal -0x1(%rbx), %eax
cmpb $0x22, (%r14,%rax)
jne 0x10101
addl $-0x2, %ebx
pushq $0x2
popq %r12
leaq -0x1(%r12), %rax
cmpq %rbx, %rax
setae %r15b
jae 0x10104
movsbl -0x1(%r14,%r12), %edi
cmpl $0x5c, %edi
sete %r13b
callq 0xff66
cmpq %rbx, %r12
setb %cl
orb %al, %cl
orb %r13b, %cl
cmpb $0x1, %cl
je 0x100fc
movsbl (%r14,%r12), %edi
callq 0xffbe
testb %al, %al
je 0x10104
incq %r12
jmp 0x100be
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1d98e(%rip), %rdi     # 0x2daab
leaq 0x1e32c(%rip), %rsi     # 0x2e450
leaq 0x1e431(%rip), %rcx     # 0x2e55c
movl $0xc2, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x10187
cmpl $0x3, %esi
jb 0x10184
cmpb $0x30, (%rdi)
jne 0x10184
cmpb $0x62, 0x1(%rdi)
jne 0x10184
movb 0x2(%rdi), %al
andb $-0x2, %al
cmpb $0x30, %al
jne 0x10184
movl %esi, %ecx
pushq $0x3
popq %rdx
movabsq $0x800000000003, %rsi   # imm = 0x800000000003
cmpq %rdx, %rcx
sete %al
je 0x10186
movzbl (%rdi,%rdx), %r8d
addl $-0x30, %r8d
cmpl $0x2f, %r8d
ja 0x10186
btq %r8, %rsi
jae 0x10186
incq %rdx
jmp 0x10162
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1d919(%rip), %rdi     # 0x2daab
leaq 0x1e2b7(%rip), %rsi     # 0x2e450
leaq 0x1e3f1(%rip), %rcx     # 0x2e591
movl $0xdd, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x101ce
testl %esi, %esi
je 0x101ce
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x101c4
cmpl $0x2b, %eax
jne 0x10135
incq %rdi
decl %esi
jmp 0x10135
pushq %rbp
movq %rsp, %rbp
leaq 0x1e3ef(%rip), %rdi     # 0x2e5c8
leaq 0x1e270(%rip), %rsi     # 0x2e450
leaq 0x1e3f0(%rip), %rcx     # 0x2e5d7
movl $0xf6, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x10246
cmpl $0x3, %esi
jb 0x10243
cmpb $0x30, (%rdi)
jne 0x10243
cmpb $0x6f, 0x1(%rdi)
jne 0x10243
movb 0x2(%rdi), %al
andb $-0x8, %al
cmpb $0x30, %al
jne 0x10243
movl %esi, %ecx
pushq $0x3
popq %rdx
cmpq %rdx, %rcx
sete %al
je 0x10242
movb (%rdi,%rdx), %sil
movl %esi, %r8d
andb $-0x8, %r8b
cmpb $0x30, %r8b
sete %r8b
cmpb $0x5f, %sil
sete %sil
orb %r8b, %sil
incq %rdx
testb %sil, %sil
jne 0x10214
retq
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1d85a(%rip), %rdi     # 0x2daab
leaq 0x1e1f8(%rip), %rsi     # 0x2e450
leaq 0x1e3ae(%rip), %rcx     # 0x2e60d
movl $0x103, %edx            # imm = 0x103
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1028d
testl %esi, %esi
je 0x1028d
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x10283
cmpl $0x2b, %eax
jne 0x101f1
incq %rdi
decl %esi
jmp 0x101f1
pushq %rbp
movq %rsp, %rbp
leaq 0x1e330(%rip), %rdi     # 0x2e5c8
leaq 0x1e1b1(%rip), %rsi     # 0x2e450
leaq 0x1e39e(%rip), %rcx     # 0x2e644
movl $0x11c, %edx            # imm = 0x11C
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x102f5
testl %esi, %esi
je 0x102f2
movb (%rdi), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x102f2
movl %esi, %ecx
pushq $0x1
popq %rdx
cmpq %rdx, %rcx
sete %al
je 0x102f1
movb (%rdi,%rdx), %sil
leal -0x30(%rsi), %r8d
cmpb $0xa, %r8b
setb %r8b
cmpb $0x5f, %sil
sete %sil
orb %r8b, %sil
incq %rdx
testb %sil, %sil
jne 0x102c6
retq
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1d7ab(%rip), %rdi     # 0x2daab
leaq 0x1e149(%rip), %rsi     # 0x2e450
leaq 0x1e36c(%rip), %rcx     # 0x2e67a
movl $0x129, %edx            # imm = 0x129
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1033c
testl %esi, %esi
je 0x1033c
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x10332
cmpl $0x2b, %eax
jne 0x102b0
incq %rdi
decl %esi
jmp 0x102b0
pushq %rbp
movq %rsp, %rbp
leaq 0x1e281(%rip), %rdi     # 0x2e5c8
leaq 0x1e102(%rip), %rsi     # 0x2e450
leaq 0x1e35c(%rip), %rcx     # 0x2e6b1
movl $0x140, %edx            # imm = 0x140
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/util.c
// Function: util_is_literal_uint_hex
bool util_is_literal_uint_hex(
	const char *str,
	uint32_t len
) {
	assert(str);

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

// Assembly:
testq %rdi, %rdi
je 0x103ec
cmpl $0x3, %esi
jb 0x103e9
cmpb $0x30, (%rdi)
jne 0x103e9
cmpb $0x78, 0x1(%rdi)
jne 0x103e9
movb 0x2(%rdi), %al
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x103a0
movzbl %al, %ecx
xorl %eax, %eax
addl $-0x41, %ecx
cmpl $0x25, %ecx
ja 0x103eb
movabsq $0x3f0000003f, %rdx     # imm = 0x3F0000003F
btq %rcx, %rdx
jae 0x103eb
movl %esi, %ecx
pushq $0x3
popq %rdx
movl $0x4000003f, %esi       # imm = 0x4000003F
cmpq %rcx, %rdx
setae %al
jae 0x103eb
movzbl (%rdi,%rdx), %r8d
leal -0x30(%r8), %r9d
cmpb $0xa, %r9b
setb %r9b
leal -0x61(%r8), %r10d
cmpb $0x6, %r10b
setb %r10b
orb %r9b, %r10b
jne 0x103e4
addl $-0x41, %r8d
cmpl $0x1e, %r8d
ja 0x103eb
btl %r8d, %esi
jae 0x103eb
incq %rdx
jmp 0x103aa
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1d6b4(%rip), %rdi     # 0x2daab
leaq 0x1e052(%rip), %rsi     # 0x2e450
leaq 0x1e2e2(%rip), %rcx     # 0x2e6e7
movl $0x14d, %edx            # imm = 0x14D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/util.c
// Function: util_is_literal_int_hex
bool util_is_literal_int_hex(
	const char *str,
	uint32_t len
) {
	assert(str && len > 0);

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

// Assembly:
testq %rdi, %rdi
je 0x10433
testl %esi, %esi
je 0x10433
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x10429
cmpl $0x2b, %eax
jne 0x1035f
incq %rdi
decl %esi
jmp 0x1035f
pushq %rbp
movq %rsp, %rbp
leaq 0x1e18a(%rip), %rdi     # 0x2e5c8
leaq 0x1e00b(%rip), %rsi     # 0x2e450
leaq 0x1e2d2(%rip), %rcx     # 0x2e71e
movl $0x166, %edx            # imm = 0x166
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/util.c
// Function: util_get_uint64_char_val
uint64_t util_get_uint64_char_val(const char *str, uint32_t len) {
	assert(str);
	
	if (!util_is_literal_char(str, len)) {
		assert(0);
		return UINT64_MAX;
	}

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

	assert(0);
	return UINT64_MAX;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x10498
movl %esi, %r14d
movq %rdi, %rbx
callq 0x10011
testb %al, %al
je 0x104b7
cmpl $0x4, %r14d
je 0x10482
cmpl $0x3, %r14d
jne 0x104d6
movb 0x1(%rbx), %al
jmp 0x1048f
movsbl 0x2(%rbx), %edi
callq 0xffe7
cmpb $-0x1, %al
je 0x104f5
movsbq %al, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1d60c(%rip), %rdi     # 0x2daab
leaq 0x1dfaa(%rip), %rsi     # 0x2e450
leaq 0x1e2a7(%rip), %rcx     # 0x2e754
movl $0x173, %edx            # imm = 0x173
callq 0xa0b0
leaq 0x1ceb2(%rip), %rdi     # 0x2d370
leaq 0x1df8b(%rip), %rsi     # 0x2e450
leaq 0x1e288(%rip), %rcx     # 0x2e754
movl $0x176, %edx            # imm = 0x176
callq 0xa0b0
leaq 0x1ce93(%rip), %rdi     # 0x2d370
leaq 0x1df6c(%rip), %rsi     # 0x2e450
leaq 0x1e269(%rip), %rcx     # 0x2e754
movl $0x185, %edx            # imm = 0x185
callq 0xa0b0
leaq 0x1ce74(%rip), %rdi     # 0x2d370
leaq 0x1df4d(%rip), %rsi     # 0x2e450
leaq 0x1e24a(%rip), %rcx     # 0x2e754
movl $0x17f, %edx            # imm = 0x17F
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/util.c
// Function: util_get_str_val
void util_get_str_val(
	ResizableString *rstr,
	const char *str,
	uint32_t len
) {
	assert(rstr);
	assert(str);
	assert(len >= 2);
	assert(str[0] == '"' && str[len - 1] == '"');

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1057f
testq %rsi, %rsi
je 0x1059e
cmpl $0x1, %edx
jbe 0x105bd
cmpb $0x22, (%rsi)
jne 0x10560
leal -0x1(%rdx), %eax
cmpb $0x22, (%rsi,%rax)
jne 0x10560
incq %rsi
addl $-0x2, %edx
popq %rbp
jmp 0x105dc
leaq 0x1e271(%rip), %rdi     # 0x2e7d8
leaq 0x1dee2(%rip), %rsi     # 0x2e450
leaq 0x1e219(%rip), %rcx     # 0x2e78e
movl $0x1a0, %edx            # imm = 0x1A0
callq 0xa0b0
leaq 0x1d4ba(%rip), %rdi     # 0x2da40
leaq 0x1dec3(%rip), %rsi     # 0x2e450
leaq 0x1e1fa(%rip), %rcx     # 0x2e78e
movl $0x19d, %edx            # imm = 0x19D
callq 0xa0b0
leaq 0x1d506(%rip), %rdi     # 0x2daab
leaq 0x1dea4(%rip), %rsi     # 0x2e450
leaq 0x1e1db(%rip), %rcx     # 0x2e78e
movl $0x19e, %edx            # imm = 0x19E
callq 0xa0b0
leaq 0x1e20b(%rip), %rdi     # 0x2e7cf
leaq 0x1de85(%rip), %rsi     # 0x2e450
leaq 0x1e1bc(%rip), %rcx     # 0x2e78e
movl $0x19f, %edx            # imm = 0x19F
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/util.c
// Function: util_unescape_string
void util_unescape_string(
	ResizableString *target,
	const char *source,
	size_t source_len
) {
	for (size_t i = 0; i < source_len; i++) {
		char chr = source[i];
		if (chr != '\\') {
			rstr_append_with_char(target, chr);
		} else {
			if (i + 1 < source_len) {
				char next_char = source[++i];
				char unescaped_char = util_unescape(next_char);
				assert(unescaped_char != -1);
				rstr_append_with_char(target, unescaped_char);
			} else {
				assert(0);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
cmpq %rbx, %r12
jae 0x10626
movb (%r14,%r12), %al
cmpb $0x5c, %al
jne 0x10616
incq %r12
cmpq %rbx, %r12
jae 0x1062f
movsbl (%r14,%r12), %edi
callq 0xffe7
cmpb $-0x1, %al
je 0x1064e
movsbl %al, %esi
movq %r15, %rdi
callq 0xdf81
incq %r12
jmp 0x105f3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1cd3a(%rip), %rdi     # 0x2d370
leaq 0x1de13(%rip), %rsi     # 0x2e450
leaq 0x1e4c7(%rip), %rcx     # 0x2eb0b
movl $0x2df, %edx            # imm = 0x2DF
callq 0xa0b0
leaq 0x1e4a1(%rip), %rdi     # 0x2eaf6
leaq 0x1ddf4(%rip), %rsi     # 0x2e450
leaq 0x1e4a8(%rip), %rcx     # 0x2eb0b
movl $0x2dc, %edx            # imm = 0x2DC
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/util.c
// Function: util_get_uint64_bin_val
uint64_t util_get_uint64_bin_val(const char *str, uint32_t len) {
	#define	_IS_BIN_DIGIT(chr)	((chr) >= '0' && (chr) <= '1')

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

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

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

	return v;

	#undef	_IS_BIN_DIGIT
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x106f4
cmpl $0x3, %esi
jb 0x106f4
cmpb $0x30, (%rdi)
jne 0x106f4
cmpb $0x62, 0x1(%rdi)
jne 0x106f4
movb 0x2(%rdi), %al
andb $-0x2, %al
cmpb $0x30, %al
jne 0x106f4
movl %esi, %edx
xorl %eax, %eax
xorl %ecx, %ecx
cmpq $0x3, %rdx
jl 0x106d3
movzbl -0x1(%rdi,%rdx), %esi
movl %esi, %r8d
andb $-0x2, %r8b
cmpb $0x30, %r8b
je 0x106bc
cmpl $0x75, %esi
je 0x106b7
cmpl $0x5f, %esi
jne 0x106d5
decq %rdx
jmp 0x10695
addl $-0x30, %esi
leal 0x1(%rcx), %r8d
shll %cl, %esi
movslq %esi, %rcx
orq %rcx, %rax
decq %rdx
movl %r8d, %ecx
jmp 0x10695
popq %rbp
retq
leaq 0x1cc94(%rip), %rdi     # 0x2d370
leaq 0x1dd6d(%rip), %rsi     # 0x2e450
leaq 0x1e15d(%rip), %rcx     # 0x2e847
movl $0x1bb, %edx            # imm = 0x1BB
callq 0xa0b0
leaq 0x1e102(%rip), %rdi     # 0x2e7fd
leaq 0x1dd4e(%rip), %rsi     # 0x2e450
leaq 0x1e13e(%rip), %rcx     # 0x2e847
movl $0x1ab, %edx            # imm = 0x1AB
callq 0xa0b0