LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/DReichLab[P]adna/trim.c
// Function: bseq_read
bseq1_t *bseq_read(kseq_t *ks, int chunk_size, int *n_)
{
	int size = 0, m, n;
	bseq1_t *seqs;
	m = n = 0; seqs = 0;
	while (kseq_read(ks) >= 0) {
		bseq1_t *s;
		if (n >= m) {
			m = m? m<<1 : 256;
			seqs = realloc(seqs, m * sizeof(bseq1_t));
		}
		s = &seqs[n];
		s->name = strdup(ks->name.s);
		s->seq = strdup(ks->seq.s);
		s->qual = ks->qual.l? strdup(ks->qual.s) : 0;
		s->bc = 0;
		s->l_seq = ks->seq.l;
		s->dbl_bind = 0;
		s->type = AD_UNKNOWN;
		size += seqs[n++].l_seq;
		if (size >= chunk_size && (n&1) == 0) break;
	}
	*n_ = n;
	return seqs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3ab0
cmpl $0x0, %eax
jl 0x3a98
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jl 0x399f
cmpl $0x0, -0x20(%rbp)
je 0x397a
movl -0x20(%rbp), %eax
shll %eax
movl %eax, -0x3c(%rbp)
jmp 0x3984
movl $0x100, %eax            # imm = 0x100
movl %eax, -0x3c(%rbp)
jmp 0x3984
movl -0x3c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x20(%rbp), %rax
imulq $0x30, %rax, %rsi
callq 0x21e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2260
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2260
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x39ff
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2260
movq %rax, -0x48(%rbp)
jmp 0x3a07
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x3a07
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edx
movq -0x38(%rbp), %rax
movl (%rax), %ecx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
andl $0x80000000, %ecx       # imm = 0x80000000
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movl (%rax), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movslq %ecx, %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x3a93
movl -0x24(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x3a93
jmp 0x3a98
jmp 0x3950
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DReichLab[P]adna/trim.c
// Function: lt_opt_init
static void lt_opt_init(lt_opt_t *opt)
{
	memset(opt, 0, sizeof(lt_opt_t));
	opt->n_threads = 2;
	opt->chunk_size = 10000000;
	opt->max_qual = 50;
	opt->min_seq_len = 30;
	opt->max_ovlp_pen = 3;
	opt->min_ovlp_len = 10;
	opt->max_adap_pen = 2;
	opt->min_adap_len = 5;
	opt->bc_len[0] = opt->bc_len[1] = 0;
	opt->trim_len = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x34, %edx
callq 0x2110
movq -0x8(%rbp), %rax
movl $0x2, (%rax)
movq -0x8(%rbp), %rax
movl $0x989680, 0x4(%rax)    # imm = 0x989680
movq -0x8(%rbp), %rax
movl $0x32, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x1e, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x3, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0xa, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x5, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DReichLab[P]adna/trim.c
// Function: trim_bseq_5
static inline void trim_bseq_5(bseq1_t *s, int l)
{
	memmove(s->seq, s->seq + l, s->l_seq - l);
	memmove(s->qual, s->qual + l, s->l_seq - l);
	s->l_seq -= l;
	s->seq[s->l_seq] = s->qual[s->l_seq] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movslq -0xc(%rbp), %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
subl -0xc(%rbp), %eax
movslq %eax, %rdx
callq 0x2200
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movslq -0xc(%rbp), %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
subl -0xc(%rbp), %eax
movslq %eax, %rdx
callq 0x2200
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl (%rax), %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
subl %ecx, %edx
movl (%rax), %ecx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
andl $0x80000000, %ecx       # imm = 0x80000000
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DReichLab[P]adna/trim.c
// Function: merge_base
static inline int merge_base(int max_qual, char fc, char fq, char rc, char rq)
{
	int y;
	if (fc == rc) {
		int q = fq > rq? fq - 33 : rq - 33;
		y = toupper(fc) | (33 + (q < max_qual? q : max_qual)) << 8;
	} else {
		if (fq > rq) y = toupper(fc) | (33 + (fq - rq)) << 8;
		else y = toupper(rc) | (33 + (rq - fq)) << 8;
	}
	return y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %r8b, %al
movl %edi, -0x4(%rbp)
movb %sil, -0x5(%rbp)
movb %dl, -0x6(%rbp)
movb %cl, -0x7(%rbp)
movb %al, -0x8(%rbp)
movsbl -0x5(%rbp), %eax
movsbl -0x7(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5414
movsbl -0x6(%rbp), %eax
movsbl -0x8(%rbp), %ecx
cmpl %ecx, %eax
jle 0x53cf
movsbl -0x6(%rbp), %eax
subl $0x21, %eax
movl %eax, -0x14(%rbp)
jmp 0x53d9
movsbl -0x8(%rbp), %eax
subl $0x21, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movsbl -0x5(%rbp), %edi
callq 0x2080
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x53fb
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x5401
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl -0x1c(%rbp), %ecx
addl $0x21, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x5460
movsbl -0x6(%rbp), %eax
movsbl -0x8(%rbp), %ecx
cmpl %ecx, %eax
jle 0x5440
movsbl -0x5(%rbp), %edi
callq 0x2080
movsbl -0x6(%rbp), %ecx
movsbl -0x8(%rbp), %edx
subl %edx, %ecx
addl $0x21, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x545e
movsbl -0x7(%rbp), %edi
callq 0x2080
movsbl -0x8(%rbp), %ecx
movsbl -0x6(%rbp), %edx
subl %edx, %ecx
addl $0x21, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x5460
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DReichLab[P]adna/./kstring.h
// Function: kputc
static inline int kputc(int c, kstring_t *s)
{
	if (s->l + 1 >= s->m) {
		s->m = s->l + 2;
		kroundup32(s->m);
		s->s = (char*)realloc(s->s, s->m);
	}
	s->s[s->l++] = c;
	s->s[s->l] = 0;
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jb 0x6fa3
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x2, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
shrl %ecx
movq -0x10(%rbp), %rax
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
shrl $0x2, %ecx
movq -0x10(%rbp), %rax
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
shrl $0x4, %ecx
movq -0x10(%rbp), %rax
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
shrl $0x8, %ecx
movq -0x10(%rbp), %rax
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
shrl $0x10, %ecx
movq -0x10(%rbp), %rax
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %esi
callq 0x21e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x4(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movb $0x0, (%rax,%rcx)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DReichLab[P]adna/./kstring.h
// Function: kputsn
static inline int kputsn(const char *p, int l, kstring_t *s)
{
	if (s->l + l + 1 >= s->m) {
		s->m = s->l + l + 2;
		kroundup32(s->m);
		s->s = (char*)realloc(s->s, s->m);
	}
	memcpy(s->s + s->l, p, l);
	s->l += l;
	s->s[s->l] = 0;
	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl -0xc(%rbp), %eax
addl $0x1, %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jb 0x70bd
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl -0xc(%rbp), %ecx
addl $0x2, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
shrl %ecx
movq -0x18(%rbp), %rax
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
shrl $0x2, %ecx
movq -0x18(%rbp), %rax
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
shrl $0x4, %ecx
movq -0x18(%rbp), %rax
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
shrl $0x8, %ecx
movq -0x18(%rbp), %rax
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
shrl $0x10, %ecx
movq -0x18(%rbp), %rax
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %esi
callq 0x21e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %eax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x2170
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movb $0x0, (%rax,%rcx)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/ac_automaton/ac_automaton.c
// Function: ac_init
ac_automaton *ac_init() {
    ac_automaton *ac = mp_new(sizeof(ac_automaton));
    ac->root = ac_tree_node_init('\0');
    ac->match = ac->root;
    return ac;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x32d0
movq %rax, -0x8(%rbp)
xorl %edi, %edi
callq 0x1380
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/ac_automaton/ac_automaton.c
// Function: ac_tree_node_init
ac_tree_node *ac_tree_node_init(char value) {
    ac_tree_node *actn = mp_new(sizeof(ac_tree_node));
    actn->children = mp_new(256 * sizeof(ac_tree_node *));
    actn->is_pattern_end = F;
    // actn->value = value;
    actn->failed = NULL;
    actn->next = NULL;
    actn->match_number = 0;
    memset(actn->children, 0, 256 * sizeof(ac_tree_node *));
    return actn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl $0x20, %edi
callq 0x32d0
movq %rax, -0x10(%rbp)
movl $0x800, %edi            # imm = 0x800
callq 0x32d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
leaq 0x3ce9(%rip), %rax      # 0x50a0
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
movl $0x800, %edx            # imm = 0x800
callq 0x10b0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/ac_automaton/ac_automaton.c
// Function: ac_tree_node_add
ac_tree_node *ac_tree_node_add(ac_tree_node *actn, char *s) {
    int idx = char2int(*s);
    if (compare_char('\0', *(s)) == 0) {
        return actn;
    }
    if (actn->children[idx] == NULL) {
        actn->children[idx] = ac_tree_node_init(*s);
    }
    if (compare_char('\0', *(s + 1)) == 0) {
        actn->children[idx]->is_pattern_end = T;
        return actn->children[idx];
    }
    return ac_tree_node_add(actn->children[idx], s + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x1310
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
xorl %edi, %edi
movsbl (%rax), %esi
callq 0x2d80
cmpl $0x0, %eax
jne 0x146f
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1503
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x149f
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x1380
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
xorl %edi, %edi
movsbl 0x1(%rax), %esi
callq 0x2d80
cmpl $0x0, %eax
jne 0x14e3
leaq 0x3be2(%rip), %rax      # 0x509c
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x1503
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x1430
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/ac_automaton/ac_automaton.c
// Function: ac_match_char
void ac_match_char(ac_automaton *ac, char c) {
    int idx = char2int(c);
    ++compare_number;
    while (ac->match->children[idx] == NULL && ac->match != ac->root) {
        ac->match = ac->match->failed;
        ++compare_number;
    }
    if (ac->match->children[idx] != NULL) {
        ac->match = ac->match->children[idx];
        ac_tree_node *p = ac->match;
        while (p != ac->root) {
            ++p->match_number;
            p = p->next;
            ++compare_number;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %edi
callq 0x1310
movl %eax, -0x10(%rbp)
leaq 0x6a43(%rip), %rax      # 0x8168
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x6a35(%rip), %rax      # 0x8168
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
movslq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq $0x0, (%rcx,%rdx,8)
movb %al, -0x19(%rbp)
jne 0x1766
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x176f
jmp 0x179d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq 0x69de(%rip), %rax      # 0x8168
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x69d0(%rip), %rax      # 0x8168
movq %rcx, (%rax)
jmp 0x1736
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x181c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
je 0x181a
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x6961(%rip), %rax      # 0x8168
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x6953(%rip), %rax      # 0x8168
movq %rcx, (%rax)
jmp 0x17da
jmp 0x181c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/ac_automaton/ac_automaton.c
// Function: ac_tree_node_print
void ac_tree_node_print(ac_tree_node *actn, ac_tree_node *parent, int value) {
    if (actn != NULL) {
        printf("%1c %3d (%p) failed->%p parent=%p\n", value, value, actn,
               actn->failed, parent);
        for (int i = 0; i < 256; ++i) {
            ac_tree_node_print(actn->children[i], actn, i);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x18d6
movl -0x14(%rbp), %esi
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
movq -0x10(%rbp), %r9
leaq 0x376d(%rip), %rdi      # 0x5004
movb $0x0, %al
callq 0x10a0
movl $0x0, -0x18(%rbp)
cmpl $0x100, -0x18(%rbp)     # imm = 0x100
jge 0x18d4
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x1860
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x18a5
jmp 0x18d6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/bits/bits.c
// Function: bits_init
bits *bits_init() {
    ++_bits_num;
    _bits_mem += sizeof(bits);

    bits *b = mp_new(sizeof(bits));
    b->value = NULL;
    b->start = 0;
    b->end = 0;
    return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x684e(%rip), %eax      # 0x813c
addl $0x1, %eax
movl %eax, 0x6845(%rip)      # 0x813c
movslq 0x6842(%rip), %rax      # 0x8140
addq $0x10, %rax
movl %eax, 0x6838(%rip)      # 0x8140
movl $0x10, %edi
callq 0x32d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/bits/bits.c
// Function: bits_init_with_minimum_bytes
bits *bits_init_with_minimum_bytes(void *value, int start, int end) {
    bits *b = bits_init();
    int   start_byte = start / 8;
    int   end_byte = end / 8 + (end % 8 ? 1 : 0);
    b->value = mp_new(end_byte - start_byte);
    b->start = start - start_byte * 8;
    b->end = end - start_byte * 8;
    memcpy(b->value, value + start_byte, end_byte - start_byte);

    _bits_string_mem += end_byte - start_byte;
    ++_bits_string_num;

    return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
callq 0x18e0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
movl -0x10(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl -0x24(%rbp), %eax
movl %edx, %esi
xorl %ecx, %ecx
movl $0x1, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
addl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
subl -0x1c(%rbp), %edi
callq 0x32d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl -0x1c(%rbp), %eax
shll $0x3, %eax
subl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movl -0x1c(%rbp), %eax
shll $0x3, %eax
subl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
movslq -0x1c(%rbp), %rax
addq %rax, %rsi
movl -0x20(%rbp), %eax
subl -0x1c(%rbp), %eax
movslq %eax, %rdx
callq 0x1120
movl -0x20(%rbp), %eax
subl -0x1c(%rbp), %eax
addl 0x672a(%rip), %eax      # 0x8138
movl %eax, 0x6724(%rip)      # 0x8138
movl 0x671a(%rip), %eax      # 0x8134
addl $0x1, %eax
movl %eax, 0x6711(%rip)      # 0x8134
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/bits/bits.c
// Function: bits_sub
bits *bits_sub(bits *b, int start, int end) {
    if (end + b->start >= b->end || start + b->start >= b->end) {
        print_err("bits overflow in bits_sub()\n");
        exit(1);
    }
    bits *bb = bits_init();
    bb->value = b->value;
    bb->start = b->start + start;
    bb->end = b->start + end;
    return bb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
addl 0x8(%rcx), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x1b48
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
addl 0x8(%rcx), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jl 0x1b60
leaq 0x34d8(%rip), %rdi      # 0x5027
movb $0x0, %al
callq 0x3b70
movl $0x1, %edi
callq 0x11b0
callq 0x18e0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/bits/bits.c
// Function: bits_get
int bits_get(bits *b, int pos) {
    pos += b->start;
    if (pos >= b->end || pos < 0) {
        print_err("bits overflow in bits_get()\n");
        exit(1);
    }
    return (b->value[pos >> 3] >> (pos & 7)) & 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x1bde
cmpl $0x0, -0xc(%rbp)
jge 0x1bf6
leaq 0x345f(%rip), %rdi      # 0x5044
movb $0x0, %al
callq 0x3b70
movl $0x1, %edi
callq 0x11b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl -0xc(%rbp), %ecx
andl $0x7, %ecx
sarl %cl, %eax
andl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/bits/bits.c
// Function: bits_prefix
int bits_prefix(bits *b1, bits *b2, int group_length) {
    int l1 = bits_len(b1);
    int l2 = bits_len(b2);
    int lmin = l1 < l2 ? l1 : l2;
    int prefix = 0;
    for (int i = 0; i < lmin; i += group_length) {
        int group_match = 0;
        for (int j = i; j - i < group_length && j < lmin; ++j) {
            if (bits_get(b1, j) == bits_get(b2, j)) {
                ++group_match;
            } else {
                break;
            }
        }
        if (group_match == group_length) {
            prefix += group_match;
        } else {
            break;
        }
    }
    return prefix;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c20
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c20
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1c7b
movl -0x18(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x1c81
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x1d36
movl $0x0, -0x2c(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %ecx
subl -0x28(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x35(%rbp)
jge 0x1cca
movl -0x30(%rbp), %eax
cmpl -0x20(%rbp), %eax
setl %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x1cd3
jmp 0x1d11
movq -0x8(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x1bb0
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x1bb0
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jne 0x1d02
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1d04
jmp 0x1d11
jmp 0x1d06
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1cae
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x1d24
movl -0x2c(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x1d26
jmp 0x1d36
jmp 0x1d28
movl -0x14(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x1c95
movl -0x24(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/blanced_binary_tree/avl_tree.c
// Function: at_init
avl_tree *at_init(compare_function compare) {
    avl_tree *at = mp_new(sizeof(avl_tree));
    at->root = NULL;
    at->compare = compare;
    return at;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x32d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/blanced_binary_tree/tree_node.c
// Function: avl_tn_init
avl_tree_node *avl_tn_init(void *value, int size) {
    ++_avl_tree_node_number;

    char *s = mp_new(size);
    memcpy(s, value, size);
    ++_avl_tree_strnum;
    _avl_tree_strmem += size;

    avl_tree_node *avl_tn = mp_new(sizeof(avl_tree_node));
    _avl_tree_nodemem += sizeof(avl_tree_node);

    avl_tn->value = s;
    // avl_tn->parent = NULL;
    avl_tn->left = NULL;
    avl_tn->right = NULL;
    avl_tn->deep = 1;
    return avl_tn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl 0x628f(%rip), %eax      # 0x8144
addl $0x1, %eax
movl %eax, 0x6286(%rip)      # 0x8144
movl -0xc(%rbp), %edi
callq 0x32d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x1120
movl 0x626f(%rip), %eax      # 0x8150
addl $0x1, %eax
movl %eax, 0x6266(%rip)      # 0x8150
movl -0xc(%rbp), %eax
addl 0x6255(%rip), %eax      # 0x8148
movl %eax, 0x624f(%rip)      # 0x8148
movl $0x20, %edi
callq 0x32d0
movq %rax, -0x20(%rbp)
movslq 0x623e(%rip), %rax      # 0x814c
addq $0x20, %rax
movl %eax, 0x6234(%rip)      # 0x814c
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/blanced_binary_tree/tree_node.c
// Function: avl_tn_search
avl_tree_node *avl_tn_search(avl_tree_node *avl_tn, void *value,
                             compare_function compare) {
    if (avl_tn == NULL) {
        return NULL;
    }
    ++compare_number;

    int res = compare(avl_tn->value, value);
    if (res == 0) {
        return avl_tn;
    } else if (res > 0) {
        return avl_tn_search(avl_tn->left, value, compare);
    } else {
        return avl_tn_search(avl_tn->right, value, compare);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1f75
movq $0x0, -0x8(%rbp)
jmp 0x1feb
leaq 0x61ec(%rip), %rax      # 0x8168
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x61de(%rip), %rax      # 0x8168
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x1fb1
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1feb
cmpl $0x0, -0x24(%rbp)
jle 0x1fd2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1f50
movq %rax, -0x8(%rbp)
jmp 0x1feb
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1f50
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/blanced_binary_tree/tree_node.c
// Function: avl_tn_right
avl_tree_node *avl_tn_right(avl_tree_node *avl_tn) {
    // printf("%s r\n", (char *)avl_tn->value);
    avl_tree_node *a = avl_tn;
    avl_tree_node *b = a->left;
    avl_tree_node *c = b->right;

    avl_tree_node *root = b;
    // b->parent = a->parent;

    b->right = a;
    // a->parent = b;

    a->left = c;
    // if (c)
    // c->parent = a;

    avl_tn_update_deep(c);
    avl_tn_update_deep(a);
    avl_tn_update_deep(b);

    return root;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdi
callq 0x22f0
movq -0x10(%rbp), %rdi
callq 0x22f0
movq -0x18(%rbp), %rdi
callq 0x22f0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/blanced_binary_tree/tree_node.c
// Function: avl_tn_print
char *avl_tn_print(avl_tree_node *avl_tn) {
    if (avl_tn == NULL) {
        return "NULL";
    } else {
        char *t = (char *)(avl_tn->value);
        char *l = avl_tn_print(avl_tn->left);
        char *r = avl_tn_print(avl_tn->right);
        printf("    %s(%d)\n    ↙    ↘\n%s    %s\n\n", t, avl_tn->deep, l, r);
        return t;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2290
leaq 0x2de5(%rip), %rax      # 0x506f
movq %rax, -0x8(%rbp)
jmp 0x22e6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2270
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2270
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq 0x2d9d(%rip), %rdi      # 0x5074
movb $0x0, %al
callq 0x10a0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/blanced_binary_tree/tree_node.c
// Function: avl_tn_update_deep
void avl_tn_update_deep(avl_tree_node *avl_tn) {
    if (avl_tn != NULL) {
        int l = avl_tn->left ? avl_tn->left->deep : 0;
        int r = avl_tn->right ? avl_tn->right->deep : 0;
        avl_tn->deep = (l > r ? l : r) + 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2372
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x231a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x2321
xorl %eax, %eax
movl %eax, -0x14(%rbp)
jmp 0x2321
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2342
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x2349
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x2349
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x235f
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x2365
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/bplus_tree/bplus_tree.c
// Function: bpt_init
bplus_tree *bpt_init(int m, compare_function compare) {
    bplus_tree *bpt = mp_new(sizeof(bplus_tree));
    bpt->m = m;
    bpt->root = NULL;
    bpt->compare = compare;
    return bpt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x32d0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/bplus_tree/bplus_tree.c
// Function: bpt_add
void bpt_add(bplus_tree *bpt, void *value, int size) {
    if (bpt->root == NULL) {
        extern int _bplus_string_mem;
        void *     p = mp_new(size);
        memcpy(p, value, size);
        _bplus_string_mem += size;

        bplus_tree_node *root = bptn_init(bpt->m);
        root->keys[0] = p;
        root->pointers[0] = NULL;

        root->is_leaf = T;
        root->num = 1;

        bpt->root = root;
    } else {
        bplus_tree_node *split_node =
            bptn_add(bpt->root, value, bpt->m, bpt->compare);
        if (split_node != NULL) {
            bplus_tree_node *root = bptn_init(bpt->m);
            root->keys[0] = bptn_get_extremum(bpt->root);
            root->pointers[0] = bpt->root;
            root->keys[1] = bptn_get_extremum(split_node);
            root->pointers[1] = split_node;

            root->is_leaf = F;
            root->num = 2;

            bpt->root = root;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x247c
movl -0x14(%rbp), %edi
callq 0x32d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x1120
movl -0x14(%rbp), %ecx
leaq 0x5d43(%rip), %rax      # 0x815c
addl (%rax), %ecx
leaq 0x5d3a(%rip), %rax      # 0x815c
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x25a0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, (%rax)
leaq 0x2c44(%rip), %rax      # 0x509c
movl (%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x2537
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
callq 0x29c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x2535
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x25a0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x29a0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rdi
callq 0x29a0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
leaq 0x2b8a(%rip), %rax      # 0x50a0
movl (%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movl $0x2, 0x4(%rax)
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x2537
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/bplus_tree/bplus_tree_node.c
// Function: bptn_init
bplus_tree_node *bptn_init(int max_length) {
    ++_bplus_node_number;
    bplus_tree_node *bptn = mp_new(sizeof(bplus_tree_node));
    bptn->keys = mp_new(sizeof(void *) * (max_length + 1));
    bptn->pointers = mp_new(sizeof(void *) * (max_length + 1));

    _bplus_node_mem +=
        (sizeof(bplus_tree_node) + sizeof(void *) * (max_length + 1) +
         sizeof(void *) * (max_length + 1));
    memset(bptn->pointers, 0, sizeof(void *) * (max_length + 1));
    bptn->num = 0;
    bptn->is_leaf = T;
    return bptn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x5ba3(%rip), %eax      # 0x8154
addl $0x1, %eax
movl %eax, 0x5b9a(%rip)      # 0x8154
movl $0x18, %edi
callq 0x32d0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
cltq
shlq $0x3, %rax
movl %eax, %edi
callq 0x32d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
cltq
shlq $0x3, %rax
movl %eax, %edi
callq 0x32d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
shlq $0x3, %rcx
addq $0x18, %rcx
movl -0x4(%rbp), %eax
addl $0x1, %eax
cltq
shlq $0x3, %rax
addq %rax, %rcx
movslq 0x5b2d(%rip), %rax      # 0x8158
addq %rcx, %rax
movl %eax, 0x5b24(%rip)      # 0x8158
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x10b0
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
leaq 0x2a3a(%rip), %rax      # 0x509c
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/bplus_tree/bplus_tree_node.c
// Function: bptn_add_to_node
int bptn_add_to_node(bplus_tree_node *bptn, void *value,
                     compare_function compare) {
    int i = 0;

    // this value has been inserted
    for (i = 0; i < bptn->num; ++i) {
        if (compare(value, bptn->keys[i]) == 0) {
            return -1;
        }
    }

    for (i = bptn->num; i >= 1; --i) {
        int res = compare(value, bptn->keys[i - 1]);
        if (res > 0) {
            break;
        } else {
            bptn->keys[i] = bptn->keys[i - 1];
            bptn->pointers[i] = bptn->pointers[i - 1];
        }
    }
    bptn->keys[i] = value;
    bptn->pointers[i] = i == bptn->num ? NULL : bptn->pointers[i + 1];
    ++bptn->num;
    return i;
    // printf("unexcepted error: can find a appropriate space to add.\n");
    // exit(1);
    // return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x2706
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x24(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x26f9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2806
jmp 0x26fb
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x26c2
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jl 0x279e
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movl -0x24(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rsi
callq *%rax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jle 0x2744
jmp 0x279e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x2790
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2710
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x27c6
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x27df
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/bplus_tree/bplus_tree_node.c
// Function: bptn_split
bplus_tree_node *bptn_split(bplus_tree_node *bptn, int max_length) {
    if (bptn->num > max_length) {
        // need split
        bplus_tree_node *bptn2 = bptn_init(max_length);
        bptn->num = ((max_length + 1) / 2) + ((max_length + 1) % 2);
        bptn2->num = max_length - bptn->num + 1;

        // move data to the new node
        for (int i = 0; i < bptn2->num; ++i) {
            bptn2->keys[i] = bptn->keys[bptn->num + i];
            bptn2->pointers[i] = bptn->pointers[bptn->num + i];
        }

        return bptn2;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
jle 0x28f0
movl -0x14(%rbp), %edi
callq 0x25a0
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl $0x2, %esi
cltd
idivl %esi
addl %edx, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
subl 0x4(%rax), %ecx
addl $0x1, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x28e6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x287d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x28f8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/bplus_tree/bplus_tree_node.c
// Function: bptn_search_index
int bptn_search_index(bplus_tree_node *bptn, void *value,
                      compare_function compare) {
    int i = 0;
    for (i = 0; i < bptn->num; ++i) {
        // find the first bigger value and insert
#ifdef MIN_VALUE
        // keys[i] > value
        if (compare(bptn->keys[i], value) > 0) {
            if (i == 0) {
                return 0;
            }
            return i - 1;
        }
#else
        // keys[i] >= value
        if (compare(bptn->keys[i], value) >= 0) {
            if (i == 0) {
                return 0;
            }
            return i;
        }
#endif
    }
    return bptn->num - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x2984
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x24(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jle 0x2977
cmpl $0x0, -0x24(%rbp)
jne 0x296c
movl $0x0, -0x4(%rbp)
jmp 0x2991
movl -0x24(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2991
jmp 0x2979
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2932
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/array_search/../../utils/bplus_tree/bplus_tree_node.c
// Function: bptn_print
void bptn_print(bplus_tree_node *bptn) {
    if (bptn == NULL)
        return;
    printf("Node %p | num %d | leaf %d\n", bptn, bptn->num, bptn->is_leaf);
    for (int i = 0; i < bptn->num; ++i) {
        printf("\t%s(%p)  ", (char *)bptn->keys[i], bptn->pointers[i]);
    }
    printf("\n");
    if (!bptn->is_leaf) {
        for (int i = 0; i < bptn->num; ++i) {
            bptn_print(bptn->pointers[i]);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2b98
jmp 0x2c4f
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
leaq 0x24f4(%rip), %rdi      # 0x50a4
movb $0x0, %al
callq 0x10a0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x2c03
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x24cf(%rip), %rdi      # 0x50c0
movb $0x0, %al
callq 0x10a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2bbe
leaq 0x248d(%rip), %rdi      # 0x5097
movb $0x0, %al
callq 0x10a0
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x2c4f
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x2c4d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2b80
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2c21
jmp 0x2c4f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)