LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_new_prot
GtBlastProcessCall *gt_blast_process_call_new_prot(void)
{
  GtBlastProcessCall *call =
    gt_blast_process_call_new("blastp");
  call->version_call = "blastp -version";
  call->nucl = call->all = false;
  return call;
}

// Assembly:
pushq %rax
leaq 0x412e5c(%rip), %rdi    # 0x549ea4
callq 0x136eb0
movq %rax, (%rsp)
movq (%rsp), %rax
leaq 0x412e4f(%rip), %rcx    # 0x549eab
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movb $0x0, 0x10(%rax)
movq (%rsp), %rax
movb $0x0, 0x15(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_query
void gt_blast_process_call_set_query(GtBlastProcessCall *call,
                                     const char *query)
{
  gt_assert(!call->query);
  call->query = true;
  if (call->all)
    gt_str_append_cstr(call->str, " -i ");
  else
    gt_str_append_cstr(call->str, " -query ");
  gt_str_append_cstr(call->str, query);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x19(%rax)
je 0x1370d1
movq 0x504f00(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3def69(%rip), %rsi    # 0x516013
leaq 0x412e0a(%rip), %rdx    # 0x549ebb
leaq 0x412e10(%rip), %rcx    # 0x549ec8
leaq 0x412e29(%rip), %r8     # 0x549ee8
movl $0x7a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1370d3
movq 0x10(%rsp), %rax
movb $0x1, 0x19(%rax)
movq 0x10(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x1370fd
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x412e14(%rip), %rsi    # 0x549f0a
callq 0x11d550
jmp 0x137111
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x412e03(%rip), %rsi    # 0x549f0f
callq 0x11d550
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x11d550
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_db
void gt_blast_process_call_set_db(GtBlastProcessCall *call, const char *db)
{
  gt_assert(!call->db);
  call->db = true;
  if (call->all)
    gt_str_append_cstr(call->str, " -d ");
  else
    gt_str_append_cstr(call->str, " -db ");
  gt_str_append_cstr(call->str, db);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x11(%rax)
je 0x137181
movq 0x504e50(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3deeb9(%rip), %rsi    # 0x516013
leaq 0x412db7(%rip), %rdx    # 0x549f18
leaq 0x412dba(%rip), %rcx    # 0x549f22
leaq 0x412d79(%rip), %r8     # 0x549ee8
movl $0x85, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x137183
movq 0x10(%rsp), %rax
movb $0x1, 0x11(%rax)
movq 0x10(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x1371ad
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x412d99(%rip), %rsi    # 0x549f3f
callq 0x11d550
jmp 0x1371c1
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x412d88(%rip), %rsi    # 0x549f44
callq 0x11d550
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x11d550
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_evalue
void gt_blast_process_call_set_evalue(GtBlastProcessCall *call, double evalue)
{
  gt_assert(!call->evalue);
  call->evalue = true;
  if (call->all)
    gt_str_append_cstr(call->str, " -e ");
  else
    gt_str_append_cstr(call->str, " -evalue ");
  gt_str_append_sci_double(call->str, evalue, 6);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x12(%rax)
je 0x137232
movq 0x504d9f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3dee08(%rip), %rsi    # 0x516013
leaq 0x412d38(%rip), %rdx    # 0x549f4a
leaq 0x412d3f(%rip), %rcx    # 0x549f58
leaq 0x412cc8(%rip), %r8     # 0x549ee8
movl $0x90, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x137234
movq 0x10(%rsp), %rax
movb $0x1, 0x12(%rax)
movq 0x10(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x13725e
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x412d22(%rip), %rsi    # 0x549f79
callq 0x11d550
jmp 0x137272
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x412d11(%rip), %rsi    # 0x549f7e
callq 0x11d550
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
movl $0x6, %esi
callq 0x11db40
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_wordsize
void gt_blast_process_call_set_wordsize(GtBlastProcessCall *call, int word_size)
{
  gt_assert(!call->word_size);
  call->word_size = true;
  if (call->all)
    gt_str_append_cstr(call->str, " -W ");
  else
    gt_str_append_cstr(call->str, " -word_size ");
  gt_str_append_int(call->str, word_size);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x1b(%rax)
je 0x1372e0
movq 0x504cf1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3ded5a(%rip), %rsi    # 0x516013
leaq 0x412cc8(%rip), %rdx    # 0x549f88
leaq 0x412cd2(%rip), %rcx    # 0x549f99
leaq 0x412c1a(%rip), %r8     # 0x549ee8
movl $0x9b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1372e2
movq 0x10(%rsp), %rax
movb $0x1, 0x1b(%rax)
movq 0x10(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x13730c
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x412cb7(%rip), %rsi    # 0x549fbc
callq 0x11d550
jmp 0x137320
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x412ca6(%rip), %rsi    # 0x549fc1
callq 0x11d550
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl 0xc(%rsp), %esi
callq 0x11dd20
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_gapopen
void gt_blast_process_call_set_gapopen(GtBlastProcessCall *call, int gapopen)
{
  gt_assert(!call->gapopen);
  call->gapopen = true;
  if (call->all)
    gt_str_append_cstr(call->str, " -G ");
  else
    gt_str_append_cstr(call->str, " -gapopen ");
  gt_str_append_int(call->str, gapopen);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x14(%rax)
je 0x137390
movq 0x504c41(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3decaa(%rip), %rsi    # 0x516013
leaq 0x412c5e(%rip), %rdx    # 0x549fce
leaq 0x412c66(%rip), %rcx    # 0x549fdd
leaq 0x412b6a(%rip), %r8     # 0x549ee8
movl $0xa6, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x137392
movq 0x10(%rsp), %rax
movb $0x1, 0x14(%rax)
movq 0x10(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x1373bc
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x412c4a(%rip), %rsi    # 0x549fff
callq 0x11d550
jmp 0x1373d0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x412c39(%rip), %rsi    # 0x54a004
callq 0x11d550
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl 0xc(%rsp), %esi
callq 0x11dd20
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_gapextend
void gt_blast_process_call_set_gapextend(GtBlastProcessCall *call,
                                         int gapextend)
{
  gt_assert(!call->gapextend);
  call->gapextend = true;
  if (call->all)
    gt_str_append_cstr(call->str, " -E ");
  else
    gt_str_append_cstr(call->str, " -gapextend ");
  gt_str_append_int(call->str, gapextend);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x13(%rax)
je 0x137440
movq 0x504b91(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3debfa(%rip), %rsi    # 0x516013
leaq 0x412bef(%rip), %rdx    # 0x54a00f
leaq 0x412bf9(%rip), %rcx    # 0x54a020
leaq 0x412aba(%rip), %r8     # 0x549ee8
movl $0xb2, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x137442
movq 0x10(%rsp), %rax
movb $0x1, 0x13(%rax)
movq 0x10(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x13746c
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x412bdf(%rip), %rsi    # 0x54a044
callq 0x11d550
jmp 0x137480
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x412bce(%rip), %rsi    # 0x54a049
callq 0x11d550
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl 0xc(%rsp), %esi
callq 0x11dd20
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_penalty
void gt_blast_process_call_set_penalty(GtBlastProcessCall *call, int penalty)
{
  gt_assert(!call->penalty);
  call->penalty = true;
  gt_assert(call->nucl);
  if (call->all)
    gt_str_append_cstr(call->str, " -q ");
  else
    gt_str_append_cstr(call->str, " -penalty ");
  gt_str_append_int(call->str, penalty);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x18(%rax)
je 0x1374f0
movq 0x504ae1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3deb4a(%rip), %rsi    # 0x516013
leaq 0x412b86(%rip), %rdx    # 0x54a056
leaq 0x412b8e(%rip), %rcx    # 0x54a065
leaq 0x412a0a(%rip), %r8     # 0x549ee8
movl $0xbd, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1374f2
movq 0x10(%rsp), %rax
movb $0x1, 0x18(%rax)
movq 0x10(%rsp), %rax
testb $0x1, 0x15(%rax)
jne 0x13753e
movq 0x504a93(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3deafc(%rip), %rsi    # 0x516013
leaq 0x412b69(%rip), %rdx    # 0x54a087
leaq 0x412b40(%rip), %rcx    # 0x54a065
leaq 0x4129bc(%rip), %r8     # 0x549ee8
movl $0xbf, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x137540
movq 0x10(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x137561
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x412b38(%rip), %rsi    # 0x54a092
callq 0x11d550
jmp 0x137575
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x412b27(%rip), %rsi    # 0x54a097
callq 0x11d550
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl 0xc(%rsp), %esi
callq 0x11dd20
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_reward
void gt_blast_process_call_set_reward(GtBlastProcessCall *call, int reward)
{
  gt_assert(!call->reward);
  call->reward = true;
  gt_assert(call->nucl);
  if (call->all)
    gt_str_append_cstr(call->str, " -r ");
  else
    gt_str_append_cstr(call->str, " -reward ");
  gt_str_append_int(call->str, reward);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x1a(%rax)
je 0x1375e0
movq 0x5049f1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3dea5a(%rip), %rsi    # 0x516013
leaq 0x412ae2(%rip), %rdx    # 0x54a0a2
leaq 0x412ae9(%rip), %rcx    # 0x54a0b0
leaq 0x41291a(%rip), %r8     # 0x549ee8
movl $0xc9, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1375e2
movq 0x10(%rsp), %rax
movb $0x1, 0x1a(%rax)
movq 0x10(%rsp), %rax
testb $0x1, 0x15(%rax)
jne 0x13762e
movq 0x5049a3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3dea0c(%rip), %rsi    # 0x516013
leaq 0x412a79(%rip), %rdx    # 0x54a087
leaq 0x412a9b(%rip), %rcx    # 0x54a0b0
leaq 0x4128cc(%rip), %r8     # 0x549ee8
movl $0xcb, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x137630
movq 0x10(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x137651
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x412a87(%rip), %rsi    # 0x54a0d1
callq 0x11d550
jmp 0x137665
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x412a76(%rip), %rsi    # 0x54a0d6
callq 0x11d550
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl 0xc(%rsp), %esi
callq 0x11dd20
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_num_threads
void gt_blast_process_call_set_num_threads(GtBlastProcessCall *call,
                                           int num_threads)
{
  gt_assert(!call->num_threads);
  call->num_threads = true;
  if (call->all)
    gt_str_append_cstr(call->str, " -a ");
  else
    gt_str_append_cstr(call->str, " -num_threads ");
  gt_str_append_int(call->str, num_threads);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x16(%rax)
je 0x1376d0
movq 0x504901(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3de96a(%rip), %rsi    # 0x516013
leaq 0x412a30(%rip), %rdx    # 0x54a0e0
leaq 0x412a3c(%rip), %rcx    # 0x54a0f3
leaq 0x41282a(%rip), %r8     # 0x549ee8
movl $0xd6, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1376d2
movq 0x10(%rsp), %rax
movb $0x1, 0x16(%rax)
movq 0x10(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x1376fc
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x412a24(%rip), %rsi    # 0x54a119
callq 0x11d550
jmp 0x137710
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x412a13(%rip), %rsi    # 0x54a11e
callq 0x11d550
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl 0xc(%rsp), %esi
callq 0x11dd20
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_xdrop_gap_final
void gt_blast_process_call_set_xdrop_gap_final(GtBlastProcessCall *call,
                                               double xdrop_gap_final)
{
  gt_assert(!call->xdrop_gap_final);
  call->xdrop_gap_final = true;
  gt_assert(call->nucl);
  if (call->all)
    gt_str_append_cstr(call->str, " -Z ");
  else
    gt_str_append_cstr(call->str, " -xdrop_gap_final ");
  gt_str_append_double(call->str, xdrop_gap_final, 2);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x1c(%rax)
je 0x137782
movq 0x50484f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3de8b8(%rip), %rsi    # 0x516013
leaq 0x4129cb(%rip), %rdx    # 0x54a12d
leaq 0x4129db(%rip), %rcx    # 0x54a144
leaq 0x412778(%rip), %r8     # 0x549ee8
movl $0xe2, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x137784
movq 0x10(%rsp), %rax
movb $0x1, 0x1c(%rax)
movq 0x10(%rsp), %rax
testb $0x1, 0x15(%rax)
jne 0x1377d0
movq 0x504801(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3de86a(%rip), %rsi    # 0x516013
leaq 0x4128d7(%rip), %rdx    # 0x54a087
leaq 0x41298d(%rip), %rcx    # 0x54a144
leaq 0x41272a(%rip), %r8     # 0x549ee8
movl $0xe4, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1377d2
movq 0x10(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x1377f3
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x412982(%rip), %rsi    # 0x54a16e
callq 0x11d550
jmp 0x137807
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x412971(%rip), %rsi    # 0x54a173
callq 0x11d550
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
movl $0x2, %esi
callq 0x11dc30
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_outfmt
void gt_blast_process_call_set_outfmt(GtBlastProcessCall *call,
                                      int outfmt)
{
  gt_assert(!call->outfmt);
  call->outfmt = true;
  if (call->all)
    gt_str_append_cstr(call->str, " -m ");
  else
    gt_str_append_cstr(call->str, " -outfmt ");
  gt_str_append_int(call->str, outfmt);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x17(%rax)
je 0x137880
movq 0x504751(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3de7ba(%rip), %rsi    # 0x516013
leaq 0x412926(%rip), %rdx    # 0x54a186
leaq 0x41292d(%rip), %rcx    # 0x54a194
leaq 0x41267a(%rip), %r8     # 0x549ee8
movl $0xef, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x137882
movq 0x10(%rsp), %rax
movb $0x1, 0x17(%rax)
movq 0x10(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x1378ac
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x412910(%rip), %rsi    # 0x54a1b5
callq 0x11d550
jmp 0x1378c0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x4128ff(%rip), %rsi    # 0x54a1ba
callq 0x11d550
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl 0xc(%rsp), %esi
callq 0x11dd20
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/blast_process_call.c
// Function: gt_blast_process_call_set_outfmt_tabular
void gt_blast_process_call_set_outfmt_tabular(GtBlastProcessCall *call)
{
  gt_assert(!call->outfmt);
  call->outfmt = true;
  if (call->all)
    gt_str_append_cstr(call->str, " -m 8");
  else
    gt_str_append_cstr(call->str, " -outfmt 6");
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
testb $0x1, 0x17(%rax)
je 0x137927
movq 0x5046aa(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3de713(%rip), %rsi    # 0x516013
leaq 0x41287f(%rip), %rdx    # 0x54a186
leaq 0x4128b6(%rip), %rcx    # 0x54a1c4
leaq 0x4125d3(%rip), %r8     # 0x549ee8
movl $0xfa, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x137929
movq (%rsp), %rax
movb $0x1, 0x17(%rax)
movq (%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x137950
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x4128a4(%rip), %rsi    # 0x54a1ed
callq 0x11d550
jmp 0x137963
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x412895(%rip), %rsi    # 0x54a1f3
callq 0x11d550
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/check_boundaries_visitor.c
// Function: gt_check_boundaries_visitor_class
const GtNodeVisitorClass* gt_check_boundaries_visitor_class()
{
  static GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtCheckBoundariesVisitor),
                                    NULL,
                                    NULL,
                                    check_boundaries_visitor_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0x9f220
cmpq $0x0, 0x509992(%rip)    # 0x642d30
jne 0x1393ce
movl $0x10, %edi
xorl %eax, %eax
movl %eax, %r9d
leaq 0x2f(%rip), %rcx        # 0x1393e0
movq %r9, %rsi
movq %r9, %rdx
movq %r9, %r8
movq $0x0, (%rsp)
callq 0x1b2170
movq %rax, 0x509962(%rip)    # 0x642d30
callq 0x9f280
movq 0x509956(%rip), %rax    # 0x642d30
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/check_boundaries_visitor.c
// Function: check_boundaries_visitor_feature_node
static int check_boundaries_visitor_feature_node(GT_UNUSED GtNodeVisitor *nv,
                                                 GtFeatureNode *fn,
                                                 GT_UNUSED GtError *err)
{
  GtFeatureNodeIterator *fni;
  GtFeatureNode *node;
  int had_err = 0;

  fni = gt_feature_node_iterator_new_direct(fn);
  while (!had_err && (node = gt_feature_node_iterator_next(fni))) {
    had_err = check_boundaries_visitor_check_rec(fn, node, err);
  }
  gt_feature_node_iterator_delete(fni);

  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x28(%rsp), %rdi
callq 0x170ce0
movq %rax, 0x18(%rsp)
xorl %eax, %eax
cmpl $0x0, 0xc(%rsp)
movb %al, 0xb(%rsp)
jne 0x139431
movq 0x18(%rsp), %rdi
callq 0x170e30
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
setne %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x13943b
jmp 0x139455
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x139490
movl %eax, 0xc(%rsp)
jmp 0x13940a
movq 0x18(%rsp), %rdi
callq 0x170f50
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/chseqids_stream.c
// Function: gt_chseqids_stream_class
const GtNodeStreamClass* gt_chseqids_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtChseqidsStream),
                                   chseqids_stream_free,
                                   chseqids_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x9f220
cmpq $0x0, 0x50968a(%rip)    # 0x642d38
jne 0x1396cf
movl $0x38, %edi
leaq 0x24(%rip), %rsi        # 0x1396e0
leaq 0xcd(%rip), %rdx        # 0x139790
callq 0x1b1ae0
movq %rax, 0x509669(%rip)    # 0x642d38
callq 0x9f280
movq 0x50965d(%rip), %rax    # 0x642d38
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/chseqids_stream.c
// Function: chseqids_stream_free
static void chseqids_stream_free(GtNodeStream *ns)
{
  GtChseqidsStream *cs;
  GtUword i;
  cs = chseqids_stream_cast(ns);
  gt_mapping_delete(cs->chseqids_mapping);
  for (i = cs->buffer_index; i < gt_array_size(cs->node_buffer); i++)
    gt_genome_node_delete(*(GtGenomeNode**) gt_array_get(cs->node_buffer, i));
  gt_array_delete(cs->node_buffer);
  gt_node_stream_delete(cs->in_stream);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
callq 0x1396a0
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x1b20f0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1a5b20
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x81370
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x13976c
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x80b60
movq (%rax), %rdi
callq 0x173180
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x13971c
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x81f80
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1b1cb0
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/chseqids_stream.c
// Function: gt_chseqids_stream_new
GtNodeStream* gt_chseqids_stream_new(GtNodeStream *in_stream,
                                     GtStr *chseqids_file, GtError *err)
{
  GtNodeStream *ns;
  GtChseqidsStream *cs;
  gt_error_check(err);
  gt_assert(in_stream && chseqids_file);
  gt_assert(gt_node_stream_is_sorted(in_stream));
  ns = gt_node_stream_create(gt_chseqids_stream_class(), false);
  cs = chseqids_stream_cast(ns);
  cs->in_stream = gt_node_stream_ref(in_stream);
  cs->chseqids_mapping = gt_mapping_new(chseqids_file, "chseqids",
                                        GT_MAPPINGTYPE_STRING, err);
  if (!cs->chseqids_mapping) {
    gt_node_stream_delete(ns);
    return NULL;
  }
  cs->node_buffer = gt_array_new(sizeof (GtGenomeNode*));
  return ns;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x139e23
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x139deb
jmp 0x139e23
movq 0x5021ae(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3dc217(%rip), %rsi    # 0x516013
leaq 0x3dc3bc(%rip), %rdx    # 0x5161bf
leaq 0x4106f3(%rip), %rcx    # 0x54a4fd
leaq 0x410703(%rip), %r8     # 0x54a514
movl $0xb1, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x139e25
jmp 0x139e27
cmpq $0x0, 0x28(%rsp)
je 0x139e37
cmpq $0x0, 0x20(%rsp)
jne 0x139e6f
movq 0x502162(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3dc1cb(%rip), %rsi    # 0x516013
leaq 0x4106e4(%rip), %rdx    # 0x54a533
leaq 0x4106a7(%rip), %rcx    # 0x54a4fd
leaq 0x4106b7(%rip), %r8     # 0x54a514
movl $0xb2, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x139e71
jmp 0x139e73
movq 0x28(%rsp), %rdi
callq 0x1b2090
testb $0x1, %al
jne 0x139eb9
movq 0x502118(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3dc181(%rip), %rsi    # 0x516013
leaq 0x4352c4(%rip), %rdx    # 0x56f15d
leaq 0x41065d(%rip), %rcx    # 0x54a4fd
leaq 0x41066d(%rip), %r8     # 0x54a514
movl $0xb3, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x139ebb
callq 0x1396a0
movq %rax, %rdi
xorl %esi, %esi
callq 0x1b1b80
movq %rax, 0x10(%rsp)
callq 0x1396a0
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x1b20f0
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1b1c50
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rcx
leaq 0x3dc7d7(%rip), %rsi    # 0x5166e4
xorl %edx, %edx
callq 0x1a56e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x139f41
movq 0x10(%rsp), %rdi
callq 0x1b1cb0
movq $0x0, 0x30(%rsp)
jmp 0x139f61
movl $0x8, %edi
callq 0x80990
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/chseqids_stream.c
// Function: change_sequence_id
static int change_sequence_id(GtFeatureNode *fn, void *data,
                              GT_UNUSED GtError *err)
{
  GtStr *changed_seqid = data;
  gt_error_check(err);
  gt_assert(changed_seqid);
  gt_genome_node_change_seqid((GtGenomeNode*) fn, changed_seqid);
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x139fdd
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x139fa5
jmp 0x139fdd
movq 0x501ff4(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3dc05d(%rip), %rsi    # 0x516013
leaq 0x3dc202(%rip), %rdx    # 0x5161bf
leaq 0x4105ad(%rip), %rcx    # 0x54a571
leaq 0x410549(%rip), %r8     # 0x54a514
movl $0x2d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x139fdf
jmp 0x139fe1
cmpq $0x0, 0x8(%rsp)
jne 0x13a021
movq 0x501fb0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3dc019(%rip), %rsi    # 0x516013
leaq 0x410562(%rip), %rdx    # 0x54a563
leaq 0x410569(%rip), %rcx    # 0x54a571
leaq 0x410505(%rip), %r8     # 0x54a514
movl $0x2e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x13a023
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x171f00
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/collect_ids_visitor.c
// Function: gt_collect_ids_visitor_class
const GtNodeVisitorClass* gt_collect_ids_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtCollectIDsVisitor),
                                    NULL,
                                    NULL,
                                    collect_ids_visitor_feature_node,
                                    collect_ids_visitor_region_node,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0x9f220
cmpq $0x0, 0x508cf2(%rip)    # 0x642d40
jne 0x13a082
movl $0x18, %edi
xorl %eax, %eax
movl %eax, %r9d
leaq 0x2f(%rip), %rcx        # 0x13a090
leaq 0xa8(%rip), %r8         # 0x13a110
movq %r9, %rsi
movq %r9, %rdx
movq $0x0, (%rsp)
callq 0x1b2170
movq %rax, 0x508cbe(%rip)    # 0x642d40
callq 0x9f280
movq 0x508cb2(%rip), %rax    # 0x642d40
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/collect_ids_visitor.c
// Function: collect_ids_visitor_feature_node
static int collect_ids_visitor_feature_node(GtNodeVisitor *nv,
                                            GtFeatureNode *fn,
                                            GT_UNUSED GtError *err)
{
  GtCollectIDsVisitor *civ;
  const char *seqid;
  civ = collect_ids_visitor_cast(nv);
  seqid = gt_str_get(gt_genome_node_get_seqid((GtGenomeNode*) fn));
  if (!gt_cstr_table_get(civ->seqids, seqid))
    gt_cstr_table_add(civ->seqids, seqid);
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
callq 0x13a040
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x1b2350
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x171b70
movq %rax, %rdi
callq 0x11dee0
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rsp), %rsi
callq 0xa3b80
cmpq $0x0, %rax
jne 0x13a0fa
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rsp), %rsi
callq 0xa3a60
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/collect_ids_visitor.c
// Function: collect_ids_visitor_region_node
static int collect_ids_visitor_region_node(GtNodeVisitor *nv, GtRegionNode *rn,
                                           GT_UNUSED GtError *err)
{
  GtCollectIDsVisitor *civ;
  const char *seqid;
  int had_err = 0;
  gt_error_check(err);
  civ = collect_ids_visitor_cast(nv);
  seqid = gt_str_get(gt_genome_node_get_seqid((GtGenomeNode*) rn));
  if (!gt_cstr_table_get(civ->seqids, seqid))
    gt_cstr_table_add(civ->seqids, seqid);
  return had_err;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x13a17b
movq 0x20(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x13a143
jmp 0x13a17b
movq 0x501e56(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3dbebf(%rip), %rsi    # 0x516013
leaq 0x3dc064(%rip), %rdx    # 0x5161bf
leaq 0x410422(%rip), %rcx    # 0x54a584
leaq 0x41043b(%rip), %r8     # 0x54a5a4
movl $0x37, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x13a17d
callq 0x13a040
movq %rax, %rdi
movq 0x30(%rsp), %rsi
callq 0x1b2350
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x171b70
movq %rax, %rdi
callq 0x11dee0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xa3b80
cmpq $0x0, %rax
jne 0x13a1d7
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xa3a60
movl 0xc(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/collect_ids_visitor.c
// Function: gt_collect_ids_visitor_new
GtNodeVisitor* gt_collect_ids_visitor_new(GtCstrTable *cst)
{
  GtNodeVisitor *nv = gt_node_visitor_create(gt_collect_ids_visitor_class());
  GtCollectIDsVisitor *collect_ids_visitor = collect_ids_visitor_cast(nv);
  collect_ids_visitor->seqids = cst;
  return nv;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x13a040
movq %rax, %rdi
callq 0x1b22c0
movq %rax, 0x8(%rsp)
callq 0x13a040
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x1b2350
movq %rax, (%rsp)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_new
GtCompressedBitsequence *
gt_compressed_bitsequence_new(GtBitsequence *bitseq,
                              unsigned int samplerate,
                              GtUword num_of_bits)
{
  GtCompressedBitsequence *cbs;

  gt_assert(samplerate != 0);

  cbs = gt_compressed_bitsequence_new_empty();
  gt_compressed_bitsequence_init(cbs, samplerate, num_of_bits);

  gt_compressed_bitsequence_init_c_tab(cbs);
  gt_compressed_bitsequence_fill_c_tab_init_o_tab(cbs, bitseq);
  gt_compressed_bitsequence_init_s_tabs(cbs);
  gt_compressed_bitsequence_fill_tabs(cbs, bitseq);
  cbs->from_file = false;
  gt_log_log("new cbs:\n"
             "blzise: %u\n"
             "offsize: " GT_WU "\n"
             "cbits: %u\n"
             "csize: " GT_WU "\n"
             "lastblen: %u\n",
             cbs->blocksize,
             cbs->c_offsets_size,
             cbs->class_bits,
             cbs->classes_size,
             cbs->last_block_len);
  return cbs;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x13a281
movq 0x501d50(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3dbdb9(%rip), %rsi    # 0x516013
leaq 0x410577(%rip), %rdx    # 0x54a7d8
leaq 0x410580(%rip), %rcx    # 0x54a7e8
leaq 0x410597(%rip), %r8     # 0x54a806
movl $0x1ad, %r9d            # imm = 0x1AD
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x13a283
callq 0x13a330
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0x13a380
movq 0x8(%rsp), %rdi
callq 0x13a440
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x13a5c0
movq 0x8(%rsp), %rdi
callq 0x13a7c0
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x13aa70
movq 0x8(%rsp), %rax
movb $0x0, 0xf0(%rax)
movq 0x8(%rsp), %rax
movl 0xd8(%rax), %esi
movq 0x8(%rsp), %rax
movq 0xa0(%rax), %rdx
movq 0x8(%rsp), %rax
movl 0xdc(%rax), %ecx
movq 0x8(%rsp), %rax
movq 0xa8(%rax), %r8
movq 0x8(%rsp), %rax
movl 0xe0(%rax), %r9d
leaq 0x41050d(%rip), %rdi    # 0x54a82c
movb $0x0, %al
callq 0xe7740
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_new_empty
static GtCompressedBitsequence* gt_compressed_bitsequence_new_empty(void)
{
  GtCompressedBitsequence *cbs;

  cbs = gt_calloc((size_t) 1, sizeof (*cbs));
  cbs->blocksize = GT_COMP_BITSEQ_BLOCKSIZE;
  cbs->mmapped = NULL;
  return cbs;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0xf8, %esi
leaq 0x4104c4(%rip), %rdx    # 0x54a806
movl $0x192, %ecx            # imm = 0x192
callq 0xe83c0
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0xf, 0xd8(%rax)
movq (%rsp), %rax
movq $0x0, 0x98(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_init
static inline void gt_compressed_bitsequence_init(GtCompressedBitsequence *cbs,
                                                  unsigned int samplerate,
                                                  GtUword num_of_bits)
{
  cbs->superblocksize = samplerate;
  cbs->popcount_tab = gt_popcount_tab_new(cbs->blocksize);
  cbs->c_offsets_size = 0;
  cbs->num_of_bits = num_of_bits;
  cbs->last_block_len = (unsigned int) (cbs->num_of_bits % cbs->blocksize);
  if (cbs->last_block_len == 0)
    cbs->last_block_len = cbs->blocksize;
  cbs->mmapped = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq %rdx, (%rsp)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xec(%rax)
movq 0x10(%rsp), %rax
movl 0xd8(%rax), %edi
callq 0x1b4470
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x68(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0xa0(%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0xb0(%rax)
movq 0x10(%rsp), %rax
movq 0xb0(%rax), %rax
movq 0x10(%rsp), %rcx
movl 0xd8(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xe0(%rax)
movq 0x10(%rsp), %rax
cmpl $0x0, 0xe0(%rax)
jne 0x13a429
movq 0x10(%rsp), %rax
movl 0xd8(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xe0(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x98(%rax)
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_init_c_tab
static void gt_compressed_bitsequence_init_c_tab(GtCompressedBitsequence *cbs)
{
  GtUword classes_bits;
  cbs->num_of_blocks = cbs->num_of_bits / cbs->blocksize;
  if (cbs->num_of_bits % cbs->blocksize != 0 || cbs->num_of_blocks == 0)
    cbs->num_of_blocks++;
#ifdef __SSE4_2__
  cbs->class_bits = (unsigned int)
    (sizeof (unsigned int) * CHAR_BIT - __builtin_clz(cbs->blocksize));
#else
  cbs->class_bits = gt_determinebitspervalue((GtUword) cbs->blocksize);
#endif
  classes_bits = cbs->num_of_blocks * cbs->class_bits;
  cbs->classes_size = (GtUword) GT_NUMOFINTSFORBITS(classes_bits);
  GT_INITBITTAB(cbs->classes, classes_bits);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0xb0(%rax), %rax
movq 0x20(%rsp), %rcx
movl 0xd8(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0xb8(%rax)
movq 0x20(%rsp), %rax
movq 0xb0(%rax), %rax
movq 0x20(%rsp), %rcx
movl 0xd8(%rcx), %ecx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jne 0x13a4a5
movq 0x20(%rsp), %rax
cmpq $0x0, 0xb8(%rax)
jne 0x13a4bc
movq 0x20(%rsp), %rax
movq 0xb8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xb8(%rax)
movq 0x20(%rsp), %rax
movl 0xd8(%rax), %eax
movl %eax, %edi
callq 0xec660
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0xdc(%rax)
movq 0x20(%rsp), %rax
movq 0xb8(%rax), %rax
movq 0x20(%rsp), %rcx
movl 0xdc(%rcx), %ecx
imulq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
shrq $0x6, %rax
cmpq $0x0, %rax
jne 0x13a516
movl $0x1, %eax
movq %rax, 0x8(%rsp)
jmp 0x13a52c
movq 0x18(%rsp), %rax
subq $0x1, %rax
shrq $0x6, %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0xa8(%rax)
movq 0x18(%rsp), %rax
shrq $0x6, %rax
cmpq $0x0, %rax
jne 0x13a557
movl $0x1, %eax
movq %rax, (%rsp)
jmp 0x13a56c
movq 0x18(%rsp), %rax
subq $0x1, %rax
shrq $0x6, %rax
addq $0x1, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
shlq $0x3, %rsi
xorl %eax, %eax
movl %eax, %edi
leaq 0x41027d(%rip), %rdx    # 0x54a806
movl $0x169, %ecx            # imm = 0x169
callq 0xe8540
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x78(%rax)
movq 0x20(%rsp), %rax
movq 0x78(%rax), %rdi
movq 0x10(%rsp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x19360
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_access
int gt_compressed_bitsequence_access(GtCompressedBitsequence *cbs,
                                     GtUword position)
{
  int bit;
  unsigned int pos_in_block;
  GtUword block;
  GtCompressedBitsequenceBlockInfo *cbs_bi;

  gt_assert(cbs != NULL);
  gt_assert(position < cbs->num_of_bits);

  pos_in_block = (unsigned int) position % cbs->blocksize;

  gt_compressed_bitsequence_calc_block_info(cbs, position);
  cbs_bi = cbs->cbs_bi;
  if (cbs_bi->class == 0 || cbs_bi->class == cbs->blocksize)
    return cbs_bi->class == 0 ? 0 : 1;

  block = gt_popcount_tab_get(cbs->popcount_tab,
                              cbs_bi->class,
                              cbs_bi->block_offset);

  /* account for shorter blocks at the end */
  block <<= (cbs->blocksize - cbs_bi->block_len);

  bit = (int) ((block >> (cbs->blocksize - pos_in_block - 1)) & 1UL);
  return bit;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x13ad5e
movq 0x501273(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3db2dc(%rip), %rsi    # 0x516013
leaq 0x40fb32(%rip), %rdx    # 0x54a870
leaq 0x40fb37(%rip), %rcx    # 0x54a87c
leaq 0x40faba(%rip), %r8     # 0x54a806
movl $0x205, %r9d            # imm = 0x205
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x13ad60
jmp 0x13ad62
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0xb0(%rcx), %rax
jb 0x13adad
movq 0x501224(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3db28d(%rip), %rsi    # 0x516013
leaq 0x40fb10(%rip), %rdx    # 0x54a89d
leaq 0x40fae8(%rip), %rcx    # 0x54a87c
leaq 0x40fa6b(%rip), %r8     # 0x54a806
movl $0x206, %r9d            # imm = 0x206
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x13adaf
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
xorl %edx, %edx
divl 0xd8(%rcx)
movl %edx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x13aea0
movq 0x28(%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x18(%rax)
je 0x13ae05
movq 0x8(%rsp), %rax
movl 0x18(%rax), %eax
movq 0x28(%rsp), %rcx
cmpl 0xd8(%rcx), %eax
jne 0x13ae20
movq 0x8(%rsp), %rax
movl 0x18(%rax), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, 0x34(%rsp)
jmp 0x13ae91
movq 0x28(%rsp), %rax
movq 0x68(%rax), %rdi
movq 0x8(%rsp), %rax
movl 0x18(%rax), %esi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
callq 0x1b4820
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movl 0xd8(%rax), %ecx
movq 0x8(%rsp), %rax
subl 0x1c(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movl 0xd8(%rcx), %ecx
subl 0x18(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
shrq %cl, %rax
andq $0x1, %rax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_rank_1
GtUword gt_compressed_bitsequence_rank_1(GtCompressedBitsequence *cbs,
                                         GtUword position)
{
  unsigned int pos_in_block;
  GtCompressedBitsequenceBlockInfo *cbs_bi;

  gt_assert(cbs != NULL);
  gt_assert(position < cbs->num_of_bits);

  pos_in_block = (unsigned int) position % cbs->blocksize;

  gt_compressed_bitsequence_calc_block_info(cbs, position);
  cbs_bi = cbs->cbs_bi;

  pos_in_block += cbs->blocksize - cbs_bi->block_len;
  if (cbs_bi->class == 0)
    return cbs_bi->rank_sum;
  if (cbs_bi->class == cbs->blocksize)
    return cbs_bi->rank_sum + pos_in_block + 1;

  return cbs_bi->rank_sum + gt_popcount_tab_rank_1(cbs->popcount_tab,
                                                   cbs_bi->class,
                                                   cbs_bi->block_offset,
                                                   pos_in_block);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x13b17e
movq 0x500e53(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3daebc(%rip), %rsi    # 0x516013
leaq 0x40f712(%rip), %rdx    # 0x54a870
leaq 0x40f754(%rip), %rcx    # 0x54a8b9
leaq 0x40f69a(%rip), %r8     # 0x54a806
movl $0x220, %r9d            # imm = 0x220
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x13b180
jmp 0x13b182
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0xb0(%rcx), %rax
jb 0x13b1cd
movq 0x500e04(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3dae6d(%rip), %rsi    # 0x516013
leaq 0x40f6f0(%rip), %rdx    # 0x54a89d
leaq 0x40f705(%rip), %rcx    # 0x54a8b9
leaq 0x40f64b(%rip), %r8     # 0x54a806
movl $0x221, %r9d            # imm = 0x221
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x13b1cf
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
xorl %edx, %edx
divl 0xd8(%rcx)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x13aea0
movq 0x28(%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movl 0xd8(%rax), %eax
movq 0x10(%rsp), %rcx
subl 0x1c(%rcx), %eax
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x13b23b
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x13b2ac
movq 0x10(%rsp), %rax
movl 0x18(%rax), %eax
movq 0x28(%rsp), %rcx
cmpl 0xd8(%rcx), %eax
jne 0x13b26b
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rsp), %ecx
addq %rcx, %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x13b2ac
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x68(%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x18(%rax), %esi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movl 0x1c(%rsp), %ecx
callq 0x1b4d20
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_get_variable_field
static inline GtBitsequence gt_compressed_bitsequence_get_variable_field(
                                                          GtBitsequence *bitseq,
                                                          GtUword start,
                                                          unsigned int len)
{
  GtBitsequence result = 0;
  gt_assert(len <= (unsigned int) GT_INTWORDSIZE);
  if (len != 0) {
    const unsigned int bit_offset = (unsigned int) GT_MODWORDSIZE(start);
    const GtUword word_offset = GT_DIVWORDSIZE(start);

    result = bitseq[word_offset] << (GtBitsequence) bit_offset;
    if ((unsigned int) bit_offset + len > (unsigned int) GT_INTWORDSIZE)
      result |= bitseq[word_offset + 1] >>
                                  (GtBitsequence) (GT_INTWORDSIZE - bit_offset);
    result >>= (GtBitsequence) (GT_INTWORDSIZE-len);
  }
  return result;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq $0x0, 0x18(%rsp)
cmpl $0x40, 0x24(%rsp)
jbe 0x13bb8a
movq 0x500447(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3da4b0(%rip), %rsi    # 0x516013
leaq 0x40f0db(%rip), %rdx    # 0x54ac45
leaq 0x40f0f9(%rip), %rcx    # 0x54ac6a
leaq 0x40ec8e(%rip), %r8     # 0x54a806
movl $0xbd, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x13bb8c
cmpl $0x0, 0x24(%rsp)
je 0x13bc1a
movq 0x28(%rsp), %rax
andq $0x3f, %rax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
shrq $0x6, %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x14(%rsp), %ecx
shlq %cl, %rax
movq %rax, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl 0x24(%rsp), %eax
cmpl $0x40, %eax
jbe 0x13bc00
movq 0x30(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movl $0x40, %ecx
subl 0x14(%rsp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
orq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x40, %eax
subl 0x24(%rsp), %eax
movl %eax, %eax
movl %eax, %ecx
movq 0x18(%rsp), %rax
shrq %cl, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_get_class
static inline unsigned int
gt_compressed_bitsequence_get_class(GtCompressedBitsequence *cbs,
                                    GtUword idx)
{
  gt_assert(cbs != NULL);
  gt_assert(cbs->classes != NULL);
  return (unsigned int)
    gt_compressed_bitsequence_get_variable_field(cbs->classes,
                                                 idx * cbs->class_bits,
                                                 cbs->class_bits);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x13bc7e
movq 0x500353(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3da3bc(%rip), %rsi    # 0x516013
leaq 0x40ec12(%rip), %rdx    # 0x54a870
leaq 0x40f032(%rip), %rcx    # 0x54ac97
leaq 0x40eb9a(%rip), %r8     # 0x54a806
movl $0xf6, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x13bc80
jmp 0x13bc82
movq 0x10(%rsp), %rax
cmpq $0x0, 0x78(%rax)
jne 0x13bcc6
movq 0x50030b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3da374(%rip), %rsi    # 0x516013
leaq 0x40f015(%rip), %rdx    # 0x54acbb
leaq 0x40efea(%rip), %rcx    # 0x54ac97
leaq 0x40eb52(%rip), %r8     # 0x54a806
movl $0xf7, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x13bcc8
movq 0x10(%rsp), %rax
movq 0x78(%rax), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movl 0xdc(%rax), %eax
imulq %rax, %rsi
movq 0x10(%rsp), %rax
movl 0xdc(%rax), %edx
callq 0x13bb30
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_file_size
size_t gt_compressed_bitsequence_file_size(const GtCompressedBitsequence *cbs)
{
  size_t size = gt_compressed_bitsequence_header_size(cbs);

  size += sizeof (cbs->c_offsets[0]) * cbs->c_offsets_size;
  size += sizeof (cbs->classes[0]) * cbs->classes_size;
  size += sizeof (cbs->superblockoffsets[0]) * cbs->superblockoffsets_size;
  size += sizeof (cbs->superblockranks[0]) * cbs->superblockranks_size;

  return size;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x13c6c0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0xa0(%rax), %rax
shlq $0x3, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0xa8(%rax), %rax
shlq $0x3, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0xc8(%rax), %rax
shlq $0x3, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0xd0(%rax), %rax
shlq $0x3, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)