LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_delete
void gt_bioseq_delete(GtBioseq *bs)
{
  GtUword i;
  if (!bs) return;
  gt_str_delete(bs->sequence_file);
  gt_md5_tab_delete(bs->md5_tab);
  if (bs->descriptions) {
    for (i = 0; i < gt_encseq_num_of_sequences(bs->encseq); i++) {
      gt_free(bs->descriptions[i]);
    }
    gt_free(bs->descriptions);
  }
  gt_encseq_delete(bs->encseq);
  if (bs->use_stdin)
    remove_bioseq_files(bs);
  gt_free(bs);
}

// Assembly:
testq %rdi, %rdi
je 0xbad5c
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x3d1eb
movq 0x28(%rbx), %rdi
callq 0xd757b
cmpq $0x0, 0x18(%rbx)
je 0xbac85
movq 0x20(%rbx), %rdi
callq 0xbef6c
testq %rax, %rax
je 0xbac70
xorl %r15d, %r15d
leaq 0x46918(%rip), %r14     # 0x101562
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
movl $0x11c, %edx            # imm = 0x11C
callq 0x362a0
incq %r15
movq 0x20(%rbx), %rdi
callq 0xbef6c
cmpq %rax, %r15
jb 0xbac4a
movq 0x18(%rbx), %rdi
leaq 0x468e7(%rip), %rsi     # 0x101562
movl $0x11e, %edx            # imm = 0x11E
callq 0x362a0
movq 0x20(%rbx), %rdi
callq 0xc1690
cmpb $0x1, (%rbx)
jne 0xbad43
leaq 0x46def(%rip), %rdi     # 0x101a8d
callq 0x3c03d
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3c1dc
movq %r14, %rdi
callq 0x3c40b
leaq 0x46dd4(%rip), %rdi     # 0x101a94
movq %rax, %rsi
callq 0xbb7a6
movq %r14, %rdi
callq 0x3c40b
leaq 0x46dd1(%rip), %rdi     # 0x101aa8
movq %rax, %rsi
callq 0xbb7a6
movq %r14, %rdi
callq 0x3c40b
leaq 0x46dfb(%rip), %rdi     # 0x101ae9
movq %rax, %rsi
callq 0xbb7a6
movq %r14, %rdi
callq 0x3c40b
leaq 0x46d99(%rip), %rdi     # 0x101a9e
movq %rax, %rsi
callq 0xbb7a6
movq %r14, %rdi
callq 0x3c40b
leaq 0x46d87(%rip), %rdi     # 0x101aa3
movq %rax, %rsi
callq 0xbb7a6
movq %r14, %rdi
callq 0x3c40b
leaq 0x46d66(%rip), %rdi     # 0x101a99
movq %rax, %rsi
callq 0xbb7a6
movq %r14, %rdi
callq 0x3d1eb
leaq 0x46818(%rip), %rsi     # 0x101562
movq %rbx, %rdi
movl $0x123, %edx            # imm = 0x123
popq %rbx
popq %r14
popq %r15
jmp 0x362a0
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_seq
GtSeq* gt_bioseq_get_seq(GtBioseq *bs, GtUword idx)
{
  GtSeq *seq;
  gt_assert(bs);
  gt_assert(idx < gt_encseq_num_of_sequences(bs->encseq));
  seq = gt_seq_new_own(gt_bioseq_get_sequence(bs, idx),
                       gt_bioseq_get_sequence_length(bs, idx),
                       gt_encseq_alphabet(bs->encseq));
  gt_seq_set_description(seq, gt_bioseq_get_description(bs, idx));
  return seq;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xbadee
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xbef6c
cmpq %rbx, %rax
jbe 0xbadf3
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbadf8
movq %rax, %r15
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0xc2d57
movq %rax, %r12
movq 0x20(%r14), %rdi
callq 0xc305e
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xd782d
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbaea2
movq %r15, %rdi
movq %rax, %rsi
callq 0xd7839
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2899f
callq 0x28966
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_sequence
char* gt_bioseq_get_sequence(const GtBioseq *bs, GtUword idx)
{
  char *out;
  GtUword startpos;
  gt_assert(bs);
  gt_assert(idx < gt_encseq_num_of_sequences(bs->encseq));
  out = gt_calloc(gt_encseq_seqlength(bs->encseq, idx) + 1, sizeof (char));
  startpos = gt_encseq_seqstartpos(bs->encseq, idx);
  gt_encseq_extract_decoded(bs->encseq, out, startpos,
                            startpos
                              + gt_encseq_seqlength(bs->encseq, idx) - 1);
  return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xbae84
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xbef6c
cmpq %rbx, %rax
jbe 0xbae89
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0xc2d57
leaq 0x1(%rax), %rdi
leaq 0x46732(%rip), %rdx     # 0x101562
movl $0x1, %esi
movl $0x176, %ecx            # imm = 0x176
callq 0x3601f
movq %rax, %r15
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0xc2a64
movq %rax, %r12
movq 0x20(%r14), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc2d57
leaq (%r12,%rax), %rcx
decq %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xc05ff
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x28a11
callq 0x289d8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_description
const char* gt_bioseq_get_description(GtBioseq *bs, GtUword idx)
{
  const char *desc;
  char *mydesc;
  GtUword desclen;
  gt_assert(bs && bs->encseq);
  gt_assert(idx < gt_encseq_num_of_sequences(bs->encseq));
  if (!(mydesc = bs->descriptions[idx])) {
    desc = gt_encseq_description(bs->encseq, &desclen, idx);
    mydesc = gt_calloc(desclen + 1, sizeof (char));
    strncpy(mydesc, desc, desclen);
    bs->descriptions[idx] = mydesc;
  }
  return (const char*) mydesc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0xbaf3d
movq %rdi, %r14
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0xbaf3d
movq %rsi, %rbx
callq 0xbef6c
cmpq %rbx, %rax
jbe 0xbaf42
movq 0x18(%r14), %rax
movq (%rax,%rbx,8), %r15
testq %r15, %r15
jne 0xbaf2c
movq 0x20(%r14), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
movq %rbx, %rdx
callq 0xc3523
movq %rax, %r13
movq (%r12), %rdi
incq %rdi
leaq 0x4665f(%rip), %rdx     # 0x101562
movl $0x1, %esi
movl $0x150, %ecx            # imm = 0x150
callq 0x3601f
movq %rax, %r15
movq (%r12), %rdx
movq %rax, %rdi
movq %r13, %rsi
callq 0xb2d0
movq 0x18(%r14), %rax
movq %r15, (%rax,%rbx,8)
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x28abc
callq 0x28a83
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_seq_range
GtSeq* gt_bioseq_get_seq_range(GtBioseq *bs, GtUword idx,
                               GtUword start, GtUword end)
{
  GtSeq *seq;
  gt_assert(bs);
  gt_assert(idx < gt_encseq_num_of_sequences(bs->encseq));
  gt_assert(end >= start);
  gt_assert(end - start + 1 > gt_encseq_seqlength(bs->encseq, idx));
  seq = gt_seq_new_own(gt_bioseq_get_sequence_range(bs, idx, start, end),
                       end - start + 1,
                       gt_encseq_alphabet(bs->encseq));
  gt_seq_set_description(seq, gt_bioseq_get_description(bs, idx));
  return seq;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xbafe0
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xbef6c
cmpq %rbx, %rax
jbe 0xbafe5
movq %r15, %r13
subq %r12, %r13
jb 0xbafea
incq %r13
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0xc2d57
cmpq %rax, %r13
jbe 0xbafef
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0xbaff4
movq %rax, %r15
movq 0x20(%r14), %rdi
callq 0xc305e
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xd782d
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbaea2
movq %r15, %rdi
movq %rax, %rsi
callq 0xd7839
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x28ba0
callq 0x28af5
callq 0x28b67
callq 0x28b2e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_sequence_range
char* gt_bioseq_get_sequence_range(const GtBioseq *bs, GtUword idx,
                                   GtUword start, GtUword end)
{
  char *out;
  GtUword startpos;
  gt_assert(bs);
  gt_assert(idx < gt_encseq_num_of_sequences(bs->encseq) && end >= start);
  out = gt_calloc((end - start + 1) + 1, sizeof (char));
  startpos = gt_encseq_seqstartpos(bs->encseq, idx);
  gt_encseq_extract_decoded(bs->encseq, out, startpos + start, startpos + end);
  return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xbb072
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x20(%rdi), %rdi
callq 0xbef6c
movq %rbx, %rdi
subq %r14, %rdi
jb 0xbb077
cmpq %r12, %rax
jbe 0xbb077
addq $0x2, %rdi
leaq 0x46533(%rip), %rdx     # 0x101562
movl $0x1, %esi
movl $0x185, %ecx            # imm = 0x185
callq 0x3601f
movq %rax, %r13
movq 0x20(%r15), %rdi
movq %r12, %rsi
callq 0xc2a64
movq 0x20(%r15), %rdi
addq %rax, %r14
addq %rax, %rbx
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xc05ff
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x28c12
callq 0x28bd9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_char
char gt_bioseq_get_char(const GtBioseq *bs, GtUword index,
                        GtUword position)
{
  GtUword startpos;
  gt_assert(bs);
  gt_assert(index < gt_encseq_num_of_sequences(bs->encseq));
  startpos = gt_encseq_seqstartpos(bs->encseq, index);
  return gt_encseq_get_decoded_char(bs->encseq, startpos + position,
                                    GT_READMODE_FORWARD);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xbb0bf
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xbef6c
cmpq %r15, %rax
jbe 0xbb0c4
movq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0xc2a64
movq 0x20(%r14), %rdi
addq %rax, %rbx
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0xbf1fc
callq 0x28c84
callq 0x28c4b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_seq_has_wildcards
bool gt_bioseq_seq_has_wildcards(const GtBioseq* bioseq,
                                 GtUword idx) {
  bool has_wildcard = false;
  GtUword length = gt_encseq_seqlength(bioseq->encseq, idx),
          seqstart = gt_encseq_seqstartpos(bioseq->encseq, idx),
          i;
  for (i = 0; !has_wildcard && i < length; ++i) {
    has_wildcard = gt_encseq_position_is_wildcard(bioseq->encseq,
                                                  seqstart + i,
                                                  GT_READMODE_FORWARD);
  }
  return has_wildcard;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0xc2d57
movq %rax, %r14
movq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0xc2a64
testq %r14, %r14
je 0xbb121
movq %rax, %r15
movl $0x1, %r12d
movq 0x20(%rbx), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xbf46e
testb %al, %al
jne 0xbb123
incq %r15
leaq 0x1(%r12), %rcx
cmpq %r14, %r12
movq %rcx, %r12
jb 0xbb0fd
jmp 0xbb123
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_encoded_char
GtUchar gt_bioseq_get_encoded_char(const GtBioseq *bs, GtUword index,
                                   GtUword position)
{
  GtUword startpos;
  gt_assert(bs);
  gt_assert(index < gt_encseq_num_of_sequences(bs->encseq));
  startpos = gt_encseq_seqstartpos(bs->encseq, index);
  return gt_encseq_get_encoded_char(bs->encseq, startpos + position,
                                    GT_READMODE_FORWARD);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xbb172
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xbef6c
cmpq %r15, %rax
jbe 0xbb177
movq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0xc2a64
movq 0x20(%r14), %rdi
addq %rax, %rbx
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0xbef7c
callq 0x28cf6
callq 0x28cbd
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_encoded_sequence
void gt_bioseq_get_encoded_sequence(const GtBioseq *bs, GtUchar *out,
                                    GtUword idx)
{
  GtUword startpos;
  gt_assert(bs);
  gt_assert(idx < gt_encseq_num_of_sequences(bs->encseq));
  startpos = gt_encseq_seqstartpos(bs->encseq, idx);
  gt_encseq_extract_encoded(bs->encseq, out, startpos,
                            startpos
                              + gt_encseq_seqlength(bs->encseq, idx) - 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xbb1de
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x20(%rdi), %rdi
callq 0xbef6c
cmpq %r14, %rax
jbe 0xbb1e3
movq 0x20(%r15), %rdi
movq %r14, %rsi
callq 0xc2a64
movq %rax, %r12
movq 0x20(%r15), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xc2d57
leaq (%r12,%rax), %rcx
decq %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc0464
callq 0x28d68
callq 0x28d2f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_encoded_sequence_range
void gt_bioseq_get_encoded_sequence_range(const GtBioseq *bs, GtUchar *out,
                                          GtUword idx,
                                          GtUword start,
                                          GtUword end)
{
  GtUword startpos;
  gt_assert(bs);
  gt_assert(idx < gt_encseq_num_of_sequences(bs->encseq) && end >= start);
  startpos = gt_encseq_seqstartpos(bs->encseq, idx);
  gt_encseq_extract_encoded(bs->encseq, out, startpos + start, startpos + end);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xbb247
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movq 0x20(%rdi), %rdi
callq 0xbef6c
cmpq %r14, %rbx
jb 0xbb24c
cmpq %r13, %rax
jbe 0xbb24c
movq 0x20(%r12), %rdi
movq %r13, %rsi
callq 0xc2a64
movq 0x20(%r12), %rdi
addq %rax, %r14
addq %rax, %rbx
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xc0464
callq 0x28dda
callq 0x28da1
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_md5_fingerprint
const char* gt_bioseq_get_md5_fingerprint(GtBioseq *bs, GtUword idx)
{
  gt_assert(bs && idx < gt_bioseq_number_of_sequences(bs));
  if (!bs->md5_tab) {
    bs->md5_tab = gt_encseq_get_md5_tab(bs->encseq, NULL);
  }
  gt_assert(gt_md5_tab_get(bs->md5_tab, idx));
  return gt_md5_tab_get(bs->md5_tab, idx);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xbb2a8
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xbef6c
cmpq %rbx, %rax
jbe 0xbb2a8
cmpq $0x0, 0x28(%r14)
jne 0xbb284
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0xc3c16
movq %rax, 0x28(%r14)
movq 0x28(%r14), %rdi
movq %rbx, %rsi
callq 0xd7623
testq %rax, %rax
je 0xbb2ad
movq 0x28(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd7623
callq 0x28e4c
callq 0x28e13
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_md5_to_index
GtUword gt_bioseq_md5_to_index(GtBioseq *bs, const char *md5)
{
  gt_assert(bs && md5 && gt_encseq_has_md5_support(bs->encseq));
  if (!bs->md5_tab) {
    bs->md5_tab = gt_encseq_get_md5_tab(bs->encseq, NULL);
  }
  return gt_md5_tab_map(bs->md5_tab, md5);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xbb35b
movq %rsi, %rbx
testq %rsi, %rsi
je 0xbb35b
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xc3c47
testb %al, %al
je 0xbb35b
cmpq $0x0, 0x28(%r14)
jne 0xbb348
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0xc3c16
movq %rax, 0x28(%r14)
movq 0x28(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd7652
callq 0x28f30
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_show_as_fasta
void gt_bioseq_show_as_fasta(GtBioseq *bs, GtUword width, GtFile *outfp)
{
  GtUword i;

  gt_assert(bs);

  for (i = 0; i < gt_bioseq_number_of_sequences(bs); i++) {
    char *seq = gt_bioseq_get_sequence(bs, i);
    gt_fasta_show_entry(gt_bioseq_get_description(bs, i),
                        seq,
                        gt_bioseq_get_sequence_length(bs, i), width, outfp);
    gt_free(seq);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xbb3fe
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x20(%rdi), %rdi
callq 0xbef6c
testq %rax, %rax
je 0xbb3ef
xorl %r12d, %r12d
movq %r15, %rdi
movq %r12, %rsi
callq 0xbadf8
movq %rax, %rbp
movq %r15, %rdi
movq %r12, %rsi
callq 0xbaea2
movq %rax, %r13
movq 0x20(%r15), %rdi
movq %r12, %rsi
callq 0xc2d57
movq %r13, %rdi
movq %rbp, %rsi
movq %rax, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x74f5c
movq %rbp, %rdi
leaq 0x4618e(%rip), %rsi     # 0x101562
movl $0x1e6, %edx            # imm = 0x1E6
callq 0x362a0
incq %r12
movq 0x20(%r15), %rdi
callq 0xbef6c
cmpq %rax, %r12
jb 0xbb38e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x28f69
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_show_sequence_as_fasta
void gt_bioseq_show_sequence_as_fasta(GtBioseq *bs, GtUword seqnum,
                                      GtUword width, GtFile *outfp)
{
  char *seq = NULL;
  gt_assert(bs);
  gt_assert(seqnum < gt_bioseq_number_of_sequences(bs));
  seq = gt_bioseq_get_sequence(bs, seqnum);

  gt_fasta_show_entry(gt_bioseq_get_description(bs, seqnum),
                      seq,
                      gt_bioseq_get_sequence_length(bs, seqnum), width, outfp);

  gt_free(seq);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xbb48c
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x20(%rdi), %rdi
callq 0xbef6c
cmpq %r15, %rax
jbe 0xbb491
movq %r12, %rdi
movq %r15, %rsi
callq 0xbadf8
movq %rax, %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0xbaea2
movq %rax, %rbp
movq 0x20(%r12), %rdi
movq %r15, %rsi
callq 0xc2d57
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x74f5c
leaq 0x460f1(%rip), %rsi     # 0x101562
movq %r13, %rdi
movl $0x1f6, %edx            # imm = 0x1F6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x362a0
callq 0x28fdb
callq 0x28fa2
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_show_gc_content
void gt_bioseq_show_gc_content(GtBioseq *bs, GtFile *outfp)
{
  gt_assert(bs);
  if (gt_alphabet_is_dna(gt_encseq_alphabet(bs->encseq))) {
    GtUword i, GT_UNUSED purecharlen;
    GtStr *str = gt_str_new();
    purecharlen = gt_encseq_total_length(bs->encseq)
                    - gt_encseq_num_of_sequences(bs->encseq) + 1;
    for (i=0; i < gt_encseq_num_of_sequences(bs->encseq); i++) {
      char *tmp;
      tmp = gt_bioseq_get_sequence(bs, i);
      gt_str_append_cstr(str, tmp);
      gt_free(tmp);
    }
    gt_assert(gt_str_length(str) == purecharlen);
    gt_file_xprintf(outfp, "showing GC-content for sequence file \"%s\"\n",
                    gt_str_get(bs->sequence_file));
    gt_gc_content_show(gt_str_get(str),
                       gt_str_length(str),
                       gt_encseq_alphabet(bs->encseq),
                       outfp);
    gt_str_delete(str);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xbb5c5
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xc305e
movq %rax, %rdi
callq 0xb9c19
testb %al, %al
je 0xbb5b6
movq %rbx, (%rsp)
callq 0x3bfe0
movq %rax, %r15
movq 0x20(%r14), %rdi
callq 0xbef5c
movq %rax, %r12
movq 0x20(%r14), %rdi
callq 0xbef6c
subq %rax, %r12
incq %r12
movq 0x20(%r14), %rdi
callq 0xbef6c
testq %rax, %rax
je 0xbb542
xorl %r13d, %r13d
leaq 0x4605a(%rip), %rbp     # 0x101562
movq %r14, %rdi
movq %r13, %rsi
callq 0xbadf8
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
callq 0x3c067
movq %rbx, %rdi
movq %rbp, %rsi
movl $0x205, %edx            # imm = 0x205
callq 0x362a0
incq %r13
movq 0x20(%r14), %rdi
callq 0xbef6c
cmpq %rax, %r13
jb 0xbb508
movq %r15, %rdi
callq 0x3c434
cmpq %r12, %rax
jne 0xbb5ca
movq 0x8(%r14), %rdi
callq 0x3c40b
leaq 0x463cf(%rip), %rsi     # 0x10192e
movq (%rsp), %r13
movq %r13, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x757a1
movq %r15, %rdi
callq 0x3c40b
movq %rax, %rbx
movq %r15, %rdi
callq 0x3c434
movq %rax, %r12
movq 0x20(%r14), %rdi
callq 0xc305e
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r13, %rcx
callq 0xd5834
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3d1eb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2904d
callq 0x29014
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_show_stat
void gt_bioseq_show_stat(GtBioseq *bs, GtFile *outfp)
{
  GtUword i, num_of_seqs;
  gt_assert(bs);
  num_of_seqs = gt_bioseq_number_of_sequences(bs);
  gt_file_xprintf(outfp, "showing statistics for sequence file \"%s\"\n",
                  gt_str_get(bs->sequence_file));
  gt_file_xprintf(outfp, "number of sequences: "GT_WU"\n", num_of_seqs);
  gt_file_xprintf(outfp, "total length: "GT_WU"\n",
                    gt_encseq_total_length(bs->encseq)
                      - gt_encseq_num_of_sequences(bs->encseq) + 1);
  for (i = 0; i < num_of_seqs; i++) {
    gt_file_xprintf(outfp, "sequence #"GT_WU" length: "GT_WU"\n", i+1,
                    gt_bioseq_get_sequence_length(bs, i));
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xbb693
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xbef6c
movq %rax, %r15
movq 0x8(%r14), %rdi
callq 0x3c40b
leaq 0x4636a(%rip), %rsi     # 0x10196d
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x757a1
leaq 0x46381(%rip), %rsi     # 0x101998
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x757a1
movq 0x20(%r14), %rdi
callq 0xbef5c
movq %rax, %r12
movq 0x20(%r14), %rdi
callq 0xbef6c
subq %rax, %r12
incq %r12
leaq 0x4636c(%rip), %rsi     # 0x1019b2
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x757a1
testq %r15, %r15
je 0xbb689
leaq 0x46366(%rip), %r12     # 0x1019c5
xorl %esi, %esi
leaq 0x1(%rsi), %r13
movq 0x20(%r14), %rdi
callq 0xc2d57
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x757a1
movq %r13, %rsi
cmpq %r13, %r15
jne 0xbb661
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x29086
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_show_seqlengthdistri
void gt_bioseq_show_seqlengthdistri(GtBioseq *bs, GtFile *outfp)
{
  GtDiscDistri *d;
  GtUword i;
  gt_assert(bs);
  d = gt_disc_distri_new();
  for (i = 0; i < gt_bioseq_number_of_sequences(bs); i++)
    gt_disc_distri_add(d, gt_bioseq_get_sequence_length(bs, i));
  gt_file_xprintf(outfp, "sequence length distribution:\n");
  gt_disc_distri_show(d, outfp);
  gt_disc_distri_delete(d);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xbb71b
movq %rsi, %rbx
movq %rdi, %r15
callq 0xbe2a0
movq %rax, %r14
movq 0x20(%r15), %rdi
callq 0xbef6c
testq %rax, %rax
je 0xbb6ec
xorl %r12d, %r12d
movq 0x20(%r15), %rdi
movq %r12, %rsi
callq 0xc2d57
movq %r14, %rdi
movq %rax, %rsi
callq 0xbe2bb
incq %r12
movq 0x20(%r15), %rdi
callq 0xbef6c
cmpq %rax, %r12
jb 0xbb6c4
leaq 0x4630c(%rip), %rsi     # 0x1019ff
movq %rbx, %rdi
xorl %eax, %eax
callq 0x757a1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbe395
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xbe8ba
callq 0x290bf
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq.c
// Function: remove_bioseq_files_sig
static void remove_bioseq_files_sig(int sigraised)
{
  remove_indexfile(GT_ENCSEQFILESUFFIX, gt_bioseq_index_filename);
  remove_indexfile(GT_DESTABFILESUFFIX, gt_bioseq_index_filename);
  remove_indexfile(GT_SSPTABFILESUFFIX, gt_bioseq_index_filename);
  remove_indexfile(GT_SDSTABFILESUFFIX, gt_bioseq_index_filename);
  remove_indexfile(GT_MD5TABFILESUFFIX, gt_bioseq_index_filename);
  remove_indexfile(GT_OISTABFILESUFFIX, gt_bioseq_index_filename);
  (void) gt_xsignal(sigraised, SIG_DFL);
  gt_xraise(sigraised);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movq 0x97656(%rip), %rsi     # 0x152d80
leaq 0x46363(%rip), %rdi     # 0x101a94
callq 0xbb7a6
movq 0x97643(%rip), %rsi     # 0x152d80
leaq 0x46364(%rip), %rdi     # 0x101aa8
callq 0xbb7a6
movq 0x97630(%rip), %rsi     # 0x152d80
leaq 0x46392(%rip), %rdi     # 0x101ae9
callq 0xbb7a6
movq 0x9761d(%rip), %rsi     # 0x152d80
leaq 0x46334(%rip), %rdi     # 0x101a9e
callq 0xbb7a6
movq 0x9760a(%rip), %rsi     # 0x152d80
leaq 0x46326(%rip), %rdi     # 0x101aa3
callq 0xbb7a6
movq 0x975f7(%rip), %rsi     # 0x152d80
leaq 0x46309(%rip), %rdi     # 0x101a99
callq 0xbb7a6
movl %ebx, %edi
xorl %esi, %esi
callq 0x836fe
movl %ebx, %edi
popq %rbx
jmp 0x836ed
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq.c
// Function: remove_indexfile
static void remove_indexfile(const char *suffix, const char *base)
{
  GtStr *fn = gt_str_new_cstr(base);
  gt_str_append_cstr(fn, suffix);
  if (gt_file_exists(gt_str_get(fn)))
    gt_xunlink(gt_str_get(fn));
  gt_str_delete(fn);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3c03d
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3c067
movq %rbx, %rdi
callq 0x3c40b
movq %rax, %rdi
callq 0x75bdc
testb %al, %al
je 0xbb7e7
movq %rbx, %rdi
callq 0x3c40b
movq %rax, %rdi
callq 0x8373b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d1eb
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_md5_to_sequence_length
int gt_bioseq_col_md5_to_sequence_length(GtSeqCol *sc, GtUword *len,
                                         GtStr *md5_seqid, GtError *err)
{
  GtUword seqnum = GT_UNDEF_UWORD;
  GtBioseq *bioseq = NULL;
  GtBioseqCol *bsc;
  int had_err = 0;
  bsc = gt_bioseq_col_cast(sc);
  gt_error_check(err);
  gt_assert(bsc && len && md5_seqid && err);
  gt_assert(gt_md5_seqid_has_prefix(gt_str_get(md5_seqid)));
  if (!(had_err = md5_to_index(&bioseq, &seqnum, bsc, md5_seqid, err))) {
    gt_assert(seqnum != GT_UNDEF_UWORD);
    *len = gt_bioseq_get_sequence_length(bioseq, seqnum);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq $-0x1, 0x8(%rsp)
movq $0x0, (%rsp)
callq 0xbb8c3
movq %rax, %rdi
movq %r12, %rsi
callq 0xd7a8e
movq %rax, %r12
testq %r14, %r14
je 0xbb845
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0xbb8b9
testq %r14, %r14
je 0xbb8af
testq %r15, %r15
je 0xbb8af
testq %rbx, %rbx
je 0xbb8af
testq %r12, %r12
je 0xbb8af
movq %r15, %rdi
callq 0x3c40b
movq %rax, %rdi
callq 0x7a678
testb %al, %al
je 0xbb8b4
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xbb98a
movl %eax, %ebp
testl %eax, %eax
jne 0xbb8a0
movq 0x8(%rsp), %rsi
cmpq $-0x1, %rsi
je 0xbb8be
movq (%rsp), %rdi
callq 0xbae8e
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x290f8
callq 0x29131
callq 0x291a3
callq 0x2916a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_class
const GtSeqColClass* gt_bioseq_col_class(void)
{
  static const GtSeqColClass *bsc_class = NULL;
  gt_class_alloc_lock_enter();
  if (!bsc_class) {
      bsc_class = gt_seq_col_class_new(sizeof (GtBioseqCol),
                                       gt_bioseq_col_delete,
                                       gt_bioseq_col_enable_match_desc_start,
                                       gt_bioseq_col_grep_desc,
                                       gt_bioseq_col_grep_desc_desc,
                                       gt_bioseq_col_grep_desc_md5,
                                       gt_bioseq_col_grep_desc_sequence_length,
                                       gt_bioseq_col_md5_to_seq,
                                       gt_bioseq_col_md5_to_description,
                                       gt_bioseq_col_md5_to_sequence_length,
                                       gt_bioseq_col_num_of_files,
                                       gt_bioseq_col_num_of_seqs,
                                       gt_bioseq_col_get_md5_fingerprint,
                                       gt_bioseq_col_get_sequence,
                                       gt_bioseq_col_get_description,
                                       gt_bioseq_col_get_sequence_length);
  }
  gt_class_alloc_lock_leave();
  return bsc_class;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x71d9b
cmpq $0x0, 0x974ad(%rip)     # 0x152d88
jne 0xbb96f
leaq 0x9cd(%rip), %r14       # 0xbc2b5
leaq 0x97b(%rip), %r15       # 0xbc26a
leaq 0x91d(%rip), %r12       # 0xbc213
leaq 0x8d3(%rip), %r13       # 0xbc1d0
leaq 0x88e(%rip), %rbp       # 0xbc192
leaq 0x863(%rip), %rax       # 0xbc16e
leaq -0x11a(%rip), %rbx      # 0xbb7f8
leaq 0x782(%rip), %r11       # 0xbc09b
leaq 0x69c(%rip), %r10       # 0xbbfbc
leaq 0x1b7(%rip), %rsi       # 0xbbade
leaq 0x225(%rip), %rdx       # 0xbbb53
leaq 0x351(%rip), %rcx       # 0xbbc86
leaq 0x484(%rip), %r8        # 0xbbdc0
movl $0x30, %edi
leaq 0x52a(%rip), %r9        # 0xbbe72
pushq %r14
pushq %r15
pushq %r12
pushq %r13
pushq %rbp
pushq %rax
pushq %rbx
pushq %r11
pushq %r10
leaq 0x5b9(%rip), %rax       # 0xbbf17
pushq %rax
callq 0xd799c
addq $0x50, %rsp
movq %rax, 0x97419(%rip)     # 0x152d88
callq 0x71db1
movq 0x9740d(%rip), %rax     # 0x152d88
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq_col.c
// Function: md5_to_index
static int md5_to_index(GtBioseq **bioseq, GtUword *seqnum,
                        GtBioseqCol *bsc, GtStr *md5_seqid, GtError *err)
{
  bool seqid_changed = false;
  char *seqid = NULL;
  GtUword i;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(seqnum && bsc && md5_seqid);
  /* performance hack to avoid string duplication */
  if (gt_str_length(md5_seqid) >= GT_MD5_SEQID_TOTAL_LEN) {
    seqid = gt_str_get(md5_seqid);
    if (seqid[GT_MD5_SEQID_TOTAL_LEN-1] != GT_MD5_SEQID_SEPARATOR) {
      gt_error_set(err, "MD5 sequence id %s not terminated with '%c'",
                   gt_str_get(md5_seqid), GT_MD5_SEQID_SEPARATOR);
      had_err = -1;
    }
    if (!had_err) {
      seqid[GT_MD5_SEQID_TOTAL_LEN-1] = '\0';
      seqid_changed = true;
    }
  }
  for (i = 0; !had_err && i < bsc->num_of_seqfiles; i++) {
    *bioseq = bsc->bioseqs[i];
    *seqnum = gt_bioseq_md5_to_index(*bioseq, gt_str_get(md5_seqid) +
                                     GT_MD5_SEQID_PREFIX_LEN);
    if (*seqnum != GT_UNDEF_UWORD)
      break;
  }
  if (seqid_changed) /* reset seqid no matter what */
    seqid[GT_MD5_SEQID_TOTAL_LEN-1] = GT_MD5_SEQID_SEPARATOR;
  if (!had_err && *seqnum == GT_UNDEF_UWORD) {
    gt_error_set(err, "sequence %s not found", gt_str_get(md5_seqid));
    had_err = -1;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, 0x20(%rsp)
movq %r8, %rdi
callq 0x3566a
testb %al, %al
jne 0xbbad4
testq %r15, %r15
je 0xbbad9
movq %r14, %rdi
callq 0x3c434
cmpq $0x25, %rax
movq %rbx, 0x18(%rsp)
jb 0xbb9f8
movq %r14, %rdi
callq 0x3c40b
cmpb $0x3a, 0x24(%rax)
movq %rax, 0x10(%rsp)
jne 0xbba0f
movb $0x0, 0x24(%rax)
movb $0x1, %al
movq %rax, 0x8(%rsp)
movb $0x1, %bpl
jmp 0xbba3b
movb $0x1, %bpl
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
jmp 0xbba3b
movq %r14, %rdi
callq 0x3c40b
leaq 0x461d0(%rip), %rsi     # 0x101bee
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
movq %rax, %rdx
movl $0x3a, %ecx
xorl %eax, %eax
callq 0x3559f
xorl %ebp, %ebp
testb %bpl, %bpl
je 0xbba80
xorl %r13d, %r13d
cmpq 0x10(%r12), %r13
jae 0xbba80
movq 0x8(%r12), %rax
movq (%rax,%r13,8), %rbx
movq 0x20(%rsp), %rax
movq %rbx, (%rax)
movq %r14, %rdi
callq 0x3c40b
leaq 0x4(%rax), %rsi
movq %rbx, %rdi
callq 0xbb311
movq %rax, (%r15)
cmpq $-0x1, %rax
jne 0xbba80
incq %r13
testb %bpl, %bpl
jne 0xbba43
cmpb $0x0, 0x8(%rsp)
je 0xbba90
movq 0x10(%rsp), %rax
movb $0x3a, 0x24(%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %bpl, %bpl
je 0xbbac5
xorl %eax, %eax
cmpq $-0x1, (%r15)
jne 0xbbac5
movq %r14, %rdi
callq 0x3c40b
leaq 0x46169(%rip), %rsi     # 0x101c1a
movq 0x18(%rsp), %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29215
callq 0x291dc
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_delete
static void gt_bioseq_col_delete(GtSeqCol *sc)
{
  GtUword i;
  GtBioseqCol *bsc;
  bsc = gt_bioseq_col_cast(sc);
  if (!bsc) return;
  gt_seq_info_cache_delete(bsc->grep_cache);
  gt_hashmap_delete(bsc->duplicates);
  for (i = 0; i < bsc->num_of_seqfiles; i++)
    gt_bioseq_delete(bsc->bioseqs[i]);
  gt_free(bsc->bioseqs);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xbb8c3
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd7a8e
testq %rax, %rax
je 0xbbb4b
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0xd7cae
movq 0x20(%rbx), %rdi
callq 0x77675
cmpq $0x0, 0x10(%rbx)
je 0xbbb2f
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0xbac08
incq %r14
cmpq 0x10(%rbx), %r14
jb 0xbbb19
movq 0x8(%rbx), %rdi
leaq 0x45fd9(%rip), %rsi     # 0x101b13
movl $0x35, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_enable_match_desc_start
static void gt_bioseq_col_enable_match_desc_start(GtSeqCol *sc)
{
  GtBioseqCol *bsc;
  GtSeqInfo seq_info;
  GtUword i,j;
  char buf[BUFSIZ], fmt[32];
  gt_assert(sc);
  bsc = gt_bioseq_col_cast(sc);
  bsc->matchdescstart = true;
  (void) sprintf(fmt, "%%%ds", BUFSIZ-1);
  /* pre-cache seqids for faster search */
  if (!bsc->grep_cache)
    bsc->grep_cache = gt_seq_info_cache_new();
  for (i = 0; i < bsc->num_of_seqfiles; i++) {
    GtBioseq *bioseq = bsc->bioseqs[i];
    for (j = 0; j < gt_bioseq_number_of_sequences(bioseq); j++) {
      const char *desc = gt_bioseq_get_description(bioseq, j);
      (void) sscanf(desc, fmt, buf);
      seq_info.filenum = i;
      seq_info.seqnum = j;
      if (!gt_seq_info_cache_get(bsc->grep_cache, buf))
        gt_seq_info_cache_add(bsc->grep_cache, buf, &seq_info);
      else {
        if (!bsc->duplicates)
          bsc->duplicates = gt_hashmap_new(GT_HASH_STRING, NULL, NULL);
        gt_hashmap_add(bsc->duplicates, buf, (void*) 1);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2038, %rsp           # imm = 0x2038
testq %rdi, %rdi
je 0xbbc81
movq %rdi, %rbx
callq 0xbb8c3
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd7a8e
movq %rax, %rbx
movb $0x1, 0x28(%rax)
leaq 0x460c8(%rip), %rsi     # 0x101c56
leaq 0x10(%rsp), %rdi
movl $0x1fff, %edx           # imm = 0x1FFF
xorl %eax, %eax
callq 0xb110
cmpq $0x0, 0x18(%rbx)
jne 0xbbbaf
callq 0xd7c78
movq %rax, 0x18(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0xbbc6f
leaq 0x10(%rsp), %r14
leaq 0x30(%rsp), %r15
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %r13
movq %r13, %rdi
callq 0xbb2b2
testq %rax, %rax
je 0xbbc62
xorl %ebp, %ebp
movq %r13, %rdi
movq %rbp, %rsi
callq 0xbaea2
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xb680
movq %r12, (%rsp)
movq %rbp, 0x8(%rsp)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xd7cd5
testq %rax, %rax
je 0xbbc43
cmpq $0x0, 0x20(%rbx)
jne 0xbbc30
movl $0x1, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x76f28
movq %rax, 0x20(%rbx)
movq 0x20(%rbx), %rdi
movl $0x1, %edx
movq %r15, %rsi
callq 0x77144
jmp 0xbbc52
movq 0x18(%rbx), %rdi
movq %r15, %rsi
movq %rsp, %rdx
callq 0xd7ce8
incq %rbp
movq %r13, %rdi
callq 0xbb2b2
cmpq %rax, %rbp
jb 0xbbbe2
incq %r12
cmpq 0x10(%rbx), %r12
jb 0xbbbc7
addq $0x2038, %rsp           # imm = 0x2038
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2924e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_grep_desc
static int gt_bioseq_col_grep_desc(GtSeqCol *sc, char **seq,
                                   GtUword start, GtUword end,
                                   GtStr *seqid, GtError *err)
{
  GtUword filenum = 0, seqnum = 0, seqlength;
  int had_err;
  GtBioseqCol *bsc;
  bsc = gt_bioseq_col_cast(sc);
  gt_error_check(err);
  gt_assert(bsc && seq && seqid);
  had_err = grep_desc(bsc, &filenum, &seqnum, seqid, err);
  if (!had_err) {
    seqlength = gt_bioseq_get_sequence_length(bsc->bioseqs[filenum], seqnum);
    if (start > seqlength - 1 || end > seqlength - 1) {
      had_err = -1;
      gt_error_set(err, "trying to extract range "GT_WU"-"GT_WU" on sequence "
                         "``%s'' which is not covered by that sequence (only "
                         ""GT_WU" characters in size). Has the sequence-region "
                         "to sequence mapping been defined correctly?",
                         start, end, gt_str_get(seqid), seqlength);
    }
  }
  if (!had_err) {
    *seq = gt_bioseq_get_sequence_range(bsc->bioseqs[filenum], seqnum,
                                        start, end);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r12
movq %r8, %rbp
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movq %rax, 0x20(%rsp)
movq %rax, 0x18(%rsp)
callq 0xbb8c3
movq %rax, %rdi
movq %r14, %rsi
callq 0xd7a8e
movq %rax, %r13
testq %r12, %r12
je 0xbbcde
movq %r12, %rdi
callq 0x3566a
testb %al, %al
jne 0xbbdbb
testq %rbp, %rbp
je 0xbbdb6
testq %rbx, %rbx
je 0xbbdb6
testq %r13, %r13
je 0xbbdb6
leaq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %r13, %rdi
movq %rbp, %rcx
movq %r12, %r8
callq 0xbc3f4
movl %eax, %r14d
testl %eax, %eax
jne 0xbbd7b
movq 0x8(%r13), %rax
movq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x18(%rsp), %rsi
callq 0xbae8e
movq %rax, %r15
decq %rax
cmpq 0x8(%rsp), %rax
setae %cl
cmpq 0x10(%rsp), %rax
setae %al
xorl %r14d, %r14d
testb %al, %cl
jne 0xbbd7b
movq %rbp, %rdi
callq 0x3c40b
leaq 0x3fefa(%rip), %rsi     # 0xfbc55
movq %r12, %rdi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rax, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testl %r14d, %r14d
jne 0xbbda4
movq 0x8(%r13), %rax
movq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0xbaff4
movq %rax, (%rbx)
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x292c0
callq 0x29287
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_grep_desc_desc
static int gt_bioseq_col_grep_desc_desc(GtSeqCol *sc, GtStr *desc,
                                        GtStr *seqid, GtError *err)
{
  GtUword filenum = 0, seqnum = 0;
  int had_err;
  GtBioseqCol *bsc;
  bsc = gt_bioseq_col_cast(sc);
  gt_error_check(err);
  gt_assert(bsc && desc && seqid);
  had_err = grep_desc(bsc, &filenum, &seqnum, seqid, err);
  if (!had_err) {
    const char *mydesc = gt_bioseq_get_description(bsc->bioseqs[filenum],
                                                   seqnum);
    if (mydesc)
      gt_str_append_cstr(desc, mydesc);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, (%rsp)
callq 0xbb8c3
movq %rax, %rdi
movq %r12, %rsi
callq 0xd7a8e
movq %rax, %r12
testq %r14, %r14
je 0xbbe07
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0xbbe6d
testq %r15, %r15
je 0xbbe68
testq %rbx, %rbx
je 0xbbe68
testq %r12, %r12
je 0xbbe68
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0xbc3f4
movl %eax, %ebp
testl %eax, %eax
jne 0xbbe59
movq 0x8(%r12), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rsp), %rsi
callq 0xbaea2
testq %rax, %rax
je 0xbbe59
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3c067
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x29332
callq 0x292f9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_grep_desc_md5
static int gt_bioseq_col_grep_desc_md5(GtSeqCol *sc, const char **md5,
                                       GtStr *seqid, GtError *err)
{
  GtUword filenum = 0, seqnum = 0;
  int had_err;
  GtBioseqCol *bsc;
  bsc = gt_bioseq_col_cast(sc);
  gt_error_check(err);
  gt_assert(bsc && md5 && seqid);
  had_err = grep_desc(bsc, &filenum, &seqnum, seqid, err);
  if (!had_err)
    *md5 = gt_bioseq_get_md5_fingerprint(bsc->bioseqs[filenum], seqnum);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, (%rsp)
callq 0xbb8c3
movq %rax, %rdi
movq %r12, %rsi
callq 0xd7a8e
movq %rax, %r12
testq %r14, %r14
je 0xbbeb9
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0xbbf12
testq %r15, %r15
je 0xbbf0d
testq %rbx, %rbx
je 0xbbf0d
testq %r12, %r12
je 0xbbf0d
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0xbc3f4
movl %eax, %ebp
testl %eax, %eax
jne 0xbbefe
movq 0x8(%r12), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rsp), %rsi
callq 0xbb251
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x293a4
callq 0x2936b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_grep_desc_sequence_length
static int gt_bioseq_col_grep_desc_sequence_length(GtSeqCol *sc,
                                                   GtUword *length,
                                                   GtStr *seqid,
                                                   GtError *err)
{
  GtUword filenum = 0, seqnum = 0;
  int had_err;
  GtBioseqCol *bsc;
  bsc = gt_bioseq_col_cast(sc);
  gt_error_check(err);
  gt_assert(bsc && length && seqid);
  had_err = grep_desc(bsc, &filenum, &seqnum, seqid, err);
  if (!had_err)
    *length = gt_bioseq_get_sequence_length(bsc->bioseqs[filenum], seqnum);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, (%rsp)
callq 0xbb8c3
movq %rax, %rdi
movq %r12, %rsi
callq 0xd7a8e
movq %rax, %r12
testq %r14, %r14
je 0xbbf5e
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0xbbfb7
testq %r15, %r15
je 0xbbfb2
testq %rbx, %rbx
je 0xbbfb2
testq %r12, %r12
je 0xbbfb2
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0xbc3f4
movl %eax, %ebp
testl %eax, %eax
jne 0xbbfa3
movq 0x8(%r12), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rsp), %rsi
callq 0xbae8e
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x29416
callq 0x293dd
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_md5_to_seq
static int gt_bioseq_col_md5_to_seq(GtSeqCol *sc, char **seq,
                                    GtUword start, GtUword end,
                                    GtStr *md5_seqid, GtError *err)
{
  GtUword seqnum = GT_UNDEF_UWORD;
  GtBioseq *bioseq = NULL;
  GtBioseqCol *bsc;
  int had_err = 0;
  bsc = gt_bioseq_col_cast(sc);
  gt_error_check(err);
  gt_assert(bsc && seq && md5_seqid && err);
  gt_assert(gt_md5_seqid_has_prefix(gt_str_get(md5_seqid)));
  if (!(had_err = md5_to_index(&bioseq, &seqnum, bsc, md5_seqid, err))) {
    gt_assert(seqnum != GT_UNDEF_UWORD);
    *seq = gt_bioseq_get_sequence_range(bioseq, seqnum, start, end);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %rbp
movq $-0x1, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
callq 0xbb8c3
movq %rax, %rdi
movq %rbp, %rsi
callq 0xd7a8e
movq %rax, %rbp
testq %r12, %r12
je 0xbc012
movq %r12, %rdi
callq 0x3566a
testb %al, %al
jne 0xbc091
testq %r12, %r12
je 0xbc087
testq %r13, %r13
je 0xbc087
testq %rbx, %rbx
je 0xbc087
testq %rbp, %rbp
je 0xbc087
movq %r13, %rdi
callq 0x3c40b
movq %rax, %rdi
callq 0x7a678
testb %al, %al
je 0xbc08c
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rbp, %rdx
movq %r13, %rcx
movq %r12, %r8
callq 0xbb98a
movl %eax, %ebp
testl %eax, %eax
jne 0xbc076
movq 0x10(%rsp), %rsi
cmpq $-0x1, %rsi
je 0xbc096
movq 0x8(%rsp), %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0xbaff4
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2944f
callq 0x29488
callq 0x294fa
callq 0x294c1
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_md5_to_description
static int gt_bioseq_col_md5_to_description(GtSeqCol *sc, GtStr *desc,
                                            GtStr *md5_seqid, GtError *err)
{
  GtUword seqnum = GT_UNDEF_UWORD;
  GtBioseq *bioseq = NULL;
  GtBioseqCol *bsc;
  int had_err = 0;
  bsc = gt_bioseq_col_cast(sc);
  gt_error_check(err);
  gt_assert(bsc && desc && md5_seqid && err);
  gt_assert(gt_md5_seqid_has_prefix(gt_str_get(md5_seqid)));
  if (!(had_err = md5_to_index(&bioseq, &seqnum, bsc, md5_seqid, err))) {
    gt_assert(seqnum != GT_UNDEF_UWORD);
    gt_str_append_cstr(desc, gt_bioseq_get_description(bioseq, seqnum));
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq $-0x1, 0x8(%rsp)
movq $0x0, (%rsp)
callq 0xbb8c3
movq %rax, %rdi
movq %r12, %rsi
callq 0xd7a8e
movq %rax, %r12
testq %r14, %r14
je 0xbc0e8
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0xbc164
testq %r14, %r14
je 0xbc15a
testq %r15, %r15
je 0xbc15a
testq %rbx, %rbx
je 0xbc15a
testq %r12, %r12
je 0xbc15a
movq %r15, %rdi
callq 0x3c40b
movq %rax, %rdi
callq 0x7a678
testb %al, %al
je 0xbc15f
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xbb98a
movl %eax, %ebp
testl %eax, %eax
jne 0xbc14b
movq 0x8(%rsp), %rsi
cmpq $-0x1, %rsi
je 0xbc169
movq (%rsp), %rdi
callq 0xbaea2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3c067
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x29533
callq 0x2956c
callq 0x295de
callq 0x295a5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_num_of_files
static GtUword gt_bioseq_col_num_of_files(const GtSeqCol *sc)
{
  const GtBioseqCol *bsc;
  bsc = gt_bioseq_col_cast(sc);
  gt_assert(bsc);
  return bsc->num_of_seqfiles;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xbb8c3
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd7a8e
testq %rax, %rax
je 0xbc18d
movq 0x10(%rax), %rax
popq %rbx
retq
callq 0x29617
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_num_of_seqs
static GtUword gt_bioseq_col_num_of_seqs(const GtSeqCol *sc,
                                               GtUword filenum)
{
  GtBioseqCol *bsc;
  bsc = gt_bioseq_col_cast(sc);
  gt_assert(bsc && filenum < bsc->num_of_seqfiles);
  return gt_bioseq_number_of_sequences(bsc->bioseqs[filenum]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xbb8c3
movq %rax, %rdi
movq %r14, %rsi
callq 0xd7a8e
testq %rax, %rax
je 0xbc1cb
cmpq %rbx, 0x10(%rax)
jbe 0xbc1cb
movq 0x8(%rax), %rax
movq (%rax,%rbx,8), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbb2b2
callq 0x29650