LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_new_recreate
GtBioseq* gt_bioseq_new_recreate(const char *sequence_file, GtError *err)
{
  GtBioseq *bs;
  GtStr *seqfile;
  gt_error_check(err);
  seqfile = gt_str_new_cstr(sequence_file);
  bs = bioseq_new_with_recreate_and_type(seqfile, true, err);
  gt_str_delete(seqfile);
  return bs;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0xbbc86
movq %rsi, %r14
movq %rsi, %rdi
callq 0x34fea
testb %al, %al
jne 0xbbcb6
movq %rbx, %rdi
callq 0x3b785
movq %rax, %rbx
movq %rax, %rdi
movl $0x1, %esi
movq %r14, %rdx
jmp 0xbbc9b
movq %rbx, %rdi
callq 0x3b785
movq %rax, %rbx
movq %rax, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0xbb792
movq %rax, %r14
movq %rbx, %rdi
callq 0x3c87b
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x28732
// File: /workspace/github_c_makefile_star2_O3/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 0xbbe19
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x3c87b
movq 0x28(%rbx), %rdi
callq 0xd7c78
cmpq $0x0, 0x18(%rbx)
je 0xbbd42
movq 0x20(%rbx), %rdi
callq 0xbff74
testq %rax, %rax
je 0xbbd2d
xorl %r15d, %r15d
leaq 0x457cf(%rip), %r14     # 0x1014d6
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
movl $0x11c, %edx            # imm = 0x11C
callq 0x35c27
incq %r15
movq 0x20(%rbx), %rdi
callq 0xbff74
cmpq %rax, %r15
jb 0xbbd07
movq 0x18(%rbx), %rdi
leaq 0x4579e(%rip), %rsi     # 0x1014d6
movl $0x11e, %edx            # imm = 0x11E
callq 0x35c27
movq 0x20(%rbx), %rdi
callq 0xc273d
cmpb $0x1, (%rbx)
jne 0xbbe00
leaq 0x45ca6(%rip), %rdi     # 0x101a01
callq 0x3b785
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3b92e
movq %r14, %rdi
callq 0x3bb5d
leaq 0x45c8b(%rip), %rdi     # 0x101a08
movq %rax, %rsi
callq 0xbc865
movq %r14, %rdi
callq 0x3bb5d
leaq 0x45c88(%rip), %rdi     # 0x101a1c
movq %rax, %rsi
callq 0xbc865
movq %r14, %rdi
callq 0x3bb5d
leaq 0x45cb2(%rip), %rdi     # 0x101a5d
movq %rax, %rsi
callq 0xbc865
movq %r14, %rdi
callq 0x3bb5d
leaq 0x45c50(%rip), %rdi     # 0x101a12
movq %rax, %rsi
callq 0xbc865
movq %r14, %rdi
callq 0x3bb5d
leaq 0x45c3e(%rip), %rdi     # 0x101a17
movq %rax, %rsi
callq 0xbc865
movq %r14, %rdi
callq 0x3bb5d
leaq 0x45c1d(%rip), %rdi     # 0x101a0d
movq %rax, %rsi
callq 0xbc865
movq %r14, %rdi
callq 0x3c87b
leaq 0x456cf(%rip), %rsi     # 0x1014d6
movq %rbx, %rdi
movl $0x123, %edx            # imm = 0x123
popq %rbx
popq %r14
popq %r15
jmp 0x35c27
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbbeab
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xbff74
cmpq %rbx, %rax
jbe 0xbbeb0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbbeb5
movq %rax, %r15
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0xc3d9a
movq %rax, %r12
movq 0x20(%r14), %rdi
callq 0xc40a1
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xd7f31
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbbf5f
movq %r15, %rdi
movq %rax, %rsi
callq 0xd7f3d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x287dd
callq 0x287a4
// File: /workspace/github_c_makefile_star2_O3/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 0xbbf41
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xbff74
cmpq %rbx, %rax
jbe 0xbbf46
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0xc3d9a
leaq 0x1(%rax), %rdi
leaq 0x455e9(%rip), %rdx     # 0x1014d6
movl $0x1, %esi
movl $0x176, %ecx            # imm = 0x176
callq 0x359a6
movq %rax, %r15
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0xc3ab6
movq %rax, %r12
movq 0x20(%r14), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc3d9a
leaq (%r12,%rax), %rcx
decq %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xc1686
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2884f
callq 0x28816
// File: /workspace/github_c_makefile_star2_O3/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 0xbbffa
movq %rdi, %r14
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0xbbffa
movq %rsi, %rbx
callq 0xbff74
cmpq %rbx, %rax
jbe 0xbbfff
movq 0x18(%r14), %rax
movq (%rax,%rbx,8), %r15
testq %r15, %r15
jne 0xbbfe9
movq 0x20(%r14), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
movq %rbx, %rdx
callq 0xc4566
movq %rax, %r13
movq (%r12), %rdi
incq %rdi
leaq 0x45516(%rip), %rdx     # 0x1014d6
movl $0x1, %esi
movl $0x150, %ecx            # imm = 0x150
callq 0x359a6
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 0x288fa
callq 0x288c1
// File: /workspace/github_c_makefile_star2_O3/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 0xbc09d
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xbff74
cmpq %rbx, %rax
jbe 0xbc0a2
movq %r15, %r13
subq %r12, %r13
jb 0xbc0a7
incq %r13
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0xc3d9a
cmpq %rax, %r13
jbe 0xbc0ac
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0xbc0b1
movq %rax, %r15
movq 0x20(%r14), %rdi
callq 0xc40a1
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xd7f31
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbbf5f
movq %r15, %rdi
movq %rax, %rsi
callq 0xd7f3d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x289de
callq 0x28933
callq 0x289a5
callq 0x2896c
// File: /workspace/github_c_makefile_star2_O3/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 0xbc12f
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x20(%rdi), %rdi
callq 0xbff74
movq %rbx, %rdi
subq %r14, %rdi
jb 0xbc134
cmpq %r12, %rax
jbe 0xbc134
addq $0x2, %rdi
leaq 0x453ea(%rip), %rdx     # 0x1014d6
movl $0x1, %esi
movl $0x185, %ecx            # imm = 0x185
callq 0x359a6
movq %rax, %r13
movq 0x20(%r15), %rdi
movq %r12, %rsi
callq 0xc3ab6
movq 0x20(%r15), %rdi
addq %rax, %r14
addq %rax, %rbx
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xc1686
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x28a50
callq 0x28a17
// File: /workspace/github_c_makefile_star2_O3/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 0xbc17c
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xbff74
cmpq %r15, %rax
jbe 0xbc181
movq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0xc3ab6
movq 0x20(%r14), %rdi
addq %rax, %rbx
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0xc0204
callq 0x28ac2
callq 0x28a89
// File: /workspace/github_c_makefile_star2_O3/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 0xc3d9a
movq %rax, %r14
movq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0xc3ab6
testq %r14, %r14
je 0xbc1de
movq %rax, %r15
movl $0x1, %r12d
movq 0x20(%rbx), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xc047a
testb %al, %al
jne 0xbc1e0
incq %r15
leaq 0x1(%r12), %rcx
cmpq %r14, %r12
movq %rcx, %r12
jb 0xbc1ba
jmp 0xbc1e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbc22f
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xbff74
cmpq %r15, %rax
jbe 0xbc234
movq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0xc3ab6
movq 0x20(%r14), %rdi
addq %rax, %rbx
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0xbff84
callq 0x28b34
callq 0x28afb
// File: /workspace/github_c_makefile_star2_O3/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 0xbc29b
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x20(%rdi), %rdi
callq 0xbff74
cmpq %r14, %rax
jbe 0xbc2a0
movq 0x20(%r15), %rdi
movq %r14, %rsi
callq 0xc3ab6
movq %rax, %r12
movq 0x20(%r15), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xc3d9a
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 0xc14ef
callq 0x28ba6
callq 0x28b6d
// File: /workspace/github_c_makefile_star2_O3/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 0xbc304
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movq 0x20(%rdi), %rdi
callq 0xbff74
cmpq %r14, %rbx
jb 0xbc309
cmpq %r13, %rax
jbe 0xbc309
movq 0x20(%r12), %rdi
movq %r13, %rsi
callq 0xc3ab6
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 0xc14ef
callq 0x28c18
callq 0x28bdf
// File: /workspace/github_c_makefile_star2_O3/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 0xbc366
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xbff74
cmpq %rbx, %rax
jbe 0xbc366
movq 0x28(%r14), %rdi
testq %rdi, %rdi
jne 0xbc346
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0xc4c5b
movq %rax, %rdi
movq %rax, 0x28(%r14)
movq %rbx, %rsi
callq 0xd7d20
testq %rax, %rax
je 0xbc36b
movq 0x28(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd7d20
callq 0x28c8a
callq 0x28c51
// File: /workspace/github_c_makefile_star2_O3/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 0xbc41a
movq %rsi, %rbx
testq %rsi, %rsi
je 0xbc41a
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xc4c8c
testb %al, %al
je 0xbc41a
movq 0x28(%r14), %rdi
testq %rdi, %rdi
jne 0xbc40b
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0xc4c5b
movq %rax, %rdi
movq %rax, 0x28(%r14)
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd7d4f
callq 0x28d6e
// File: /workspace/github_c_makefile_star2_O3/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 0xbc4bd
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x20(%rdi), %rdi
callq 0xbff74
testq %rax, %rax
je 0xbc4ae
xorl %r12d, %r12d
movq %r15, %rdi
movq %r12, %rsi
callq 0xbbeb5
movq %rax, %rbp
movq %r15, %rdi
movq %r12, %rsi
callq 0xbbf5f
movq %rax, %r13
movq 0x20(%r15), %rdi
movq %r12, %rsi
callq 0xc3d9a
movq %r13, %rdi
movq %rbp, %rsi
movq %rax, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x75498
movq %rbp, %rdi
leaq 0x45043(%rip), %rsi     # 0x1014d6
movl $0x1e6, %edx            # imm = 0x1E6
callq 0x35c27
incq %r12
movq 0x20(%r15), %rdi
callq 0xbff74
cmpq %rax, %r12
jb 0xbc44d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x28da7
// File: /workspace/github_c_makefile_star2_O3/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 0xbc54b
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x20(%rdi), %rdi
callq 0xbff74
cmpq %r15, %rax
jbe 0xbc550
movq %r12, %rdi
movq %r15, %rsi
callq 0xbbeb5
movq %rax, %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0xbbf5f
movq %rax, %rbp
movq 0x20(%r12), %rdi
movq %r15, %rsi
callq 0xc3d9a
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x75498
leaq 0x44fa6(%rip), %rsi     # 0x1014d6
movq %r13, %rdi
movl $0x1f6, %edx            # imm = 0x1F6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x35c27
callq 0x28e19
callq 0x28de0
// File: /workspace/github_c_makefile_star2_O3/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 0xbc684
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xc40a1
movq %rax, %rdi
callq 0xbad2d
testb %al, %al
je 0xbc675
movq %rbx, (%rsp)
callq 0x3b728
movq %rax, %r15
movq 0x20(%r14), %rdi
callq 0xbff64
movq %rax, %r12
movq 0x20(%r14), %rdi
callq 0xbff74
subq %rax, %r12
incq %r12
movq 0x20(%r14), %rdi
callq 0xbff74
testq %rax, %rax
je 0xbc601
xorl %r13d, %r13d
leaq 0x44f0f(%rip), %rbp     # 0x1014d6
movq %r14, %rdi
movq %r13, %rsi
callq 0xbbeb5
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
callq 0x3b7af
movq %rbx, %rdi
movq %rbp, %rsi
movl $0x205, %edx            # imm = 0x205
callq 0x35c27
incq %r13
movq 0x20(%r14), %rdi
callq 0xbff74
cmpq %rax, %r13
jb 0xbc5c7
movq %r15, %rdi
callq 0x3bb86
cmpq %r12, %rax
jne 0xbc689
movq 0x8(%r14), %rdi
callq 0x3bb5d
leaq 0x45284(%rip), %rsi     # 0x1018a2
movq (%rsp), %r13
movq %r13, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x75ce5
movq %r15, %rdi
callq 0x3bb5d
movq %rax, %rbx
movq %r15, %rdi
callq 0x3bb86
movq %rax, %r12
movq 0x20(%r14), %rdi
callq 0xc40a1
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r13, %rcx
callq 0xd5f9c
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3c87b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x28e8b
callq 0x28e52
// File: /workspace/github_c_makefile_star2_O3/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 0xbc752
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xbff74
movq %rax, %r15
movq 0x8(%r14), %rdi
callq 0x3bb5d
leaq 0x4521f(%rip), %rsi     # 0x1018e1
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x75ce5
leaq 0x45236(%rip), %rsi     # 0x10190c
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x75ce5
movq 0x20(%r14), %rdi
callq 0xbff64
movq %rax, %r12
movq 0x20(%r14), %rdi
callq 0xbff74
subq %rax, %r12
incq %r12
leaq 0x45221(%rip), %rsi     # 0x101926
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x75ce5
testq %r15, %r15
je 0xbc748
leaq 0x4521b(%rip), %r12     # 0x101939
xorl %esi, %esi
leaq 0x1(%rsi), %r13
movq 0x20(%r14), %rdi
callq 0xc3d9a
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x75ce5
movq %r13, %rsi
cmpq %r13, %r15
jne 0xbc720
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x28ec4
// File: /workspace/github_c_makefile_star2_O3/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 0xbc7da
movq %rsi, %rbx
movq %rdi, %r15
callq 0xbf330
movq %rax, %r14
movq 0x20(%r15), %rdi
callq 0xbff74
testq %rax, %rax
je 0xbc7ab
xorl %r12d, %r12d
movq 0x20(%r15), %rdi
movq %r12, %rsi
callq 0xc3d9a
movq %r14, %rdi
movq %rax, %rsi
callq 0xbf34b
incq %r12
movq 0x20(%r15), %rdi
callq 0xbff74
cmpq %rax, %r12
jb 0xbc783
leaq 0x451c1(%rip), %rsi     # 0x101973
movq %rbx, %rdi
xorl %eax, %eax
callq 0x75ce5
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbf427
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xbf8e3
callq 0x28efd
// File: /workspace/github_c_makefile_star2_O3/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 0x96597(%rip), %rsi     # 0x152d80
leaq 0x45218(%rip), %rdi     # 0x101a08
callq 0xbc865
movq 0x96584(%rip), %rsi     # 0x152d80
leaq 0x45219(%rip), %rdi     # 0x101a1c
callq 0xbc865
movq 0x96571(%rip), %rsi     # 0x152d80
leaq 0x45247(%rip), %rdi     # 0x101a5d
callq 0xbc865
movq 0x9655e(%rip), %rsi     # 0x152d80
leaq 0x451e9(%rip), %rdi     # 0x101a12
callq 0xbc865
movq 0x9654b(%rip), %rsi     # 0x152d80
leaq 0x451db(%rip), %rdi     # 0x101a17
callq 0xbc865
movq 0x96538(%rip), %rsi     # 0x152d80
leaq 0x451be(%rip), %rdi     # 0x101a0d
callq 0xbc865
movl %ebx, %edi
xorl %esi, %esi
callq 0x832e6
movl %ebx, %edi
popq %rbx
jmp 0x832d5
// File: /workspace/github_c_makefile_star2_O3/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 0x3b785
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3b7af
movq %rbx, %rdi
callq 0x3bb5d
movq %rax, %rdi
callq 0x76120
testb %al, %al
je 0xbc8a6
movq %rbx, %rdi
callq 0x3bb5d
movq %rax, %rdi
callq 0x83323
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3c87b
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0xbc97e
movq %rax, %rdi
movq %r12, %rsi
callq 0xd8196
testq %r14, %r14
je 0xbc96a
movq %rax, %r12
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0xbc96f
testq %r15, %r15
je 0xbc96a
testq %rbx, %rbx
je 0xbc96a
testq %r12, %r12
je 0xbc96a
movq %r15, %rdi
callq 0x3bb5d
movq %rax, %rdi
callq 0x7aa64
testb %al, %al
je 0xbc974
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xbca45
movl %eax, %ebp
testl %eax, %eax
jne 0xbc95b
movq 0x8(%rsp), %rsi
cmpq $-0x1, %rsi
je 0xbc979
movq (%rsp), %rdi
callq 0xbbf4b
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x28fe1
callq 0x28fa8
callq 0x28f36
callq 0x28f6f
// File: /workspace/github_c_makefile_star2_O3/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 0x72367
cmpq $0x0, 0x963f2(%rip)     # 0x152d88
jne 0xbca2a
leaq 0x993(%rip), %r14       # 0xbd336
leaq 0x941(%rip), %r15       # 0xbd2eb
leaq 0x8e3(%rip), %r12       # 0xbd294
leaq 0x899(%rip), %r13       # 0xbd251
leaq 0x854(%rip), %rbp       # 0xbd213
leaq 0x829(%rip), %rax       # 0xbd1ef
leaq -0x115(%rip), %rbx      # 0xbc8b8
leaq 0x74d(%rip), %r11       # 0xbd121
leaq 0x66c(%rip), %r10       # 0xbd047
leaq 0x19a(%rip), %rsi       # 0xbcb7c
leaq 0x208(%rip), %rdx       # 0xbcbf1
leaq 0x339(%rip), %rcx       # 0xbcd29
leaq 0x454(%rip), %r8        # 0xbce4b
movl $0x30, %edi
leaq 0x4fa(%rip), %r9        # 0xbcefd
pushq %r14
pushq %r15
pushq %r12
pushq %r13
pushq %rbp
pushq %rax
pushq %rbx
pushq %r11
pushq %r10
leaq 0x589(%rip), %rax       # 0xbcfa2
pushq %rax
callq 0xd80a4
addq $0x50, %rsp
movq %rax, 0x9635e(%rip)     # 0x152d88
callq 0x7237d
movq 0x96352(%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_O3/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 $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r13
movq %r8, %rdi
callq 0x34fea
testb %al, %al
jne 0xbcb72
testq %r15, %r15
je 0xbcb77
movq %r14, %rdi
callq 0x3bb86
movq %rax, %rbp
cmpq $0x25, %rax
jb 0xbcab2
movq %r14, %rdi
callq 0x3bb5d
cmpb $0x3a, 0x24(%rax)
jne 0xbcb3d
movq %rbp, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %rax, (%rsp)
movb $0x0, 0x24(%rax)
jmp 0xbcac4
movq %rbp, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq $0x0, (%rsp)
cmpq $0x0, 0x10(%r12)
je 0xbcb02
xorl %ebp, %ebp
movq 0x8(%r12), %rax
movq (%rax,%rbp,8), %rbx
movq %rbx, (%r13)
movq %r14, %rdi
callq 0x3bb5d
leaq 0x4(%rax), %rsi
movq %rbx, %rdi
callq 0xbc3cf
movq %rax, (%r15)
cmpq $-0x1, %rax
jne 0xbcb02
incq %rbp
cmpq 0x10(%r12), %rbp
jb 0xbcace
cmpq $0x25, 0x8(%rsp)
jb 0xbcb12
movq (%rsp), %rax
movb $0x3a, 0x24(%rax)
xorl %eax, %eax
cmpq $-0x1, (%r15)
movq 0x10(%rsp), %rbx
jne 0xbcb63
movq %r14, %rdi
callq 0x3bb5d
leaq 0x45060(%rip), %rsi     # 0x101b8e
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x34f1f
jmp 0xbcb5e
movq %r14, %rdi
callq 0x3bb5d
leaq 0x45016(%rip), %rsi     # 0x101b62
movq %rbx, %rdi
movq %rax, %rdx
movl $0x3a, %ecx
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29053
callq 0x2901a
// File: /workspace/github_c_makefile_star2_O3/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 0xbc97e
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd8196
testq %rax, %rax
je 0xbcbe9
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0xd83b6
movq 0x20(%rbx), %rdi
callq 0x77bab
cmpq $0x0, 0x10(%rbx)
je 0xbcbcd
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0xbbcc5
incq %r14
cmpq 0x10(%rbx), %r14
jb 0xbcbb7
movq 0x8(%rbx), %rdi
leaq 0x44eaf(%rip), %rsi     # 0x101a87
movl $0x35, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbcd24
movq %rdi, %rbx
callq 0xbc97e
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd8196
movq %rax, %rbx
movb $0x1, 0x28(%rax)
leaq 0x44f9e(%rip), %rsi     # 0x101bca
leaq 0x10(%rsp), %rdi
movl $0x1fff, %edx           # imm = 0x1FFF
xorl %eax, %eax
callq 0xb110
cmpq $0x0, 0x18(%rbx)
jne 0xbcc4d
callq 0xd8380
movq %rax, 0x18(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0xbcd12
leaq 0x10(%rsp), %r14
leaq 0x30(%rsp), %r15
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %r13
movq %r13, %rdi
callq 0xbc370
testq %rax, %rax
je 0xbcd05
xorl %ebp, %ebp
movq %r13, %rdi
movq %rbp, %rsi
callq 0xbbf5f
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 0xd83dd
testq %rax, %rax
je 0xbcce2
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
jne 0xbccd3
movl $0x1, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7740c
movq %rax, %rdi
movq %rax, 0x20(%rbx)
movl $0x1, %edx
movq %r15, %rsi
callq 0x77628
jmp 0xbccf1
movq 0x18(%rbx), %rdi
movq %r15, %rsi
movq %rsp, %rdx
callq 0xd83f0
incq %rbp
movq %r13, %rdi
callq 0xbc370
cmpq %rax, %rbp
jb 0xbcc80
incq %r12
cmpq 0x10(%rbx), %r12
jb 0xbcc65
addq $0x2038, %rsp           # imm = 0x2038
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2908c
// File: /workspace/github_c_makefile_star2_O3/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 $0x18, %rsp
movq %r9, %r15
movq %r8, %r13
movq %rcx, 0x10(%rsp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, (%rsp)
callq 0xbc97e
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd8196
movq %rax, %rbp
testq %r15, %r15
je 0xbcd7e
movq %r15, %rdi
callq 0x34fea
testb %al, %al
jne 0xbce46
testq %r13, %r13
je 0xbce41
testq %r12, %r12
je 0xbce41
testq %rbp, %rbp
je 0xbce41
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movq %rbp, %rdi
movq %r13, %rcx
movq %r15, %r8
callq 0xbd475
testl %eax, %eax
jne 0xbce32
movq 0x8(%rbp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rsp), %rsi
callq 0xbbf4b
movq %rax, %rbx
decq %rax
cmpq %r14, %rax
setae %dl
movq 0x10(%rsp), %rcx
cmpq %rcx, %rax
setae %al
testb %al, %dl
jne 0xbce13
movq %r13, %rdi
movq %rcx, %r12
callq 0x3bb5d
leaq 0x3edcf(%rip), %rsi     # 0xfbbc5
movq %r15, %rdi
movq %r14, %rdx
movq %r12, %rcx
movq %rax, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xbce32
movq 0x8(%rbp), %rax
movq 0x8(%rsp), %rdx
movq (%rax,%rdx,8), %rdi
movq (%rsp), %rsi
movq %r14, %rdx
callq 0xbc0b1
movq %rax, (%r12)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x290fe
callq 0x290c5
// File: /workspace/github_c_makefile_star2_O3/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 0xbc97e
movq %rax, %rdi
movq %r12, %rsi
callq 0xd8196
movq %rax, %r12
testq %r14, %r14
je 0xbce92
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0xbcef8
testq %r15, %r15
je 0xbcef3
testq %rbx, %rbx
je 0xbcef3
testq %r12, %r12
je 0xbcef3
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0xbd475
movl %eax, %ebp
testl %eax, %eax
jne 0xbcee4
movq 0x8(%r12), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rsp), %rsi
callq 0xbbf5f
testq %rax, %rax
je 0xbcee4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3b7af
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x29170
callq 0x29137
// File: /workspace/github_c_makefile_star2_O3/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 0xbc97e
movq %rax, %rdi
movq %r12, %rsi
callq 0xd8196
movq %rax, %r12
testq %r14, %r14
je 0xbcf44
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0xbcf9d
testq %r15, %r15
je 0xbcf98
testq %rbx, %rbx
je 0xbcf98
testq %r12, %r12
je 0xbcf98
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0xbd475
movl %eax, %ebp
testl %eax, %eax
jne 0xbcf89
movq 0x8(%r12), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rsp), %rsi
callq 0xbc30e
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x291e2
callq 0x291a9
// File: /workspace/github_c_makefile_star2_O3/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 0xbc97e
movq %rax, %rdi
movq %r12, %rsi
callq 0xd8196
movq %rax, %r12
testq %r14, %r14
je 0xbcfe9
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0xbd042
testq %r15, %r15
je 0xbd03d
testq %rbx, %rbx
je 0xbd03d
testq %r12, %r12
je 0xbd03d
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0xbd475
movl %eax, %ebp
testl %eax, %eax
jne 0xbd02e
movq 0x8(%r12), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rsp), %rsi
callq 0xbbf4b
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x29254
callq 0x2921b
// File: /workspace/github_c_makefile_star2_O3/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 0xbc97e
movq %rax, %rdi
movq %rbp, %rsi
callq 0xd8196
testq %r12, %r12
je 0xbd10d
movq %rax, %rbp
movq %r12, %rdi
callq 0x34fea
testb %al, %al
jne 0xbd112
testq %r13, %r13
je 0xbd10d
testq %rbx, %rbx
je 0xbd10d
testq %rbp, %rbp
je 0xbd10d
movq %r13, %rdi
callq 0x3bb5d
movq %rax, %rdi
callq 0x7aa64
testb %al, %al
je 0xbd117
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rbp, %rdx
movq %r13, %rcx
movq %r12, %r8
callq 0xbca45
movl %eax, %ebp
testl %eax, %eax
jne 0xbd0fc
movq 0x10(%rsp), %rsi
cmpq $-0x1, %rsi
je 0xbd11c
movq 0x8(%rsp), %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0xbc0b1
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29338
callq 0x292ff
callq 0x2928d
callq 0x292c6
// File: /workspace/github_c_makefile_star2_O3/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 0xbc97e
movq %rax, %rdi
movq %r12, %rsi
callq 0xd8196
testq %r14, %r14
je 0xbd1db
movq %rax, %r12
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0xbd1e0
testq %r15, %r15
je 0xbd1db
testq %rbx, %rbx
je 0xbd1db
testq %r12, %r12
je 0xbd1db
movq %r15, %rdi
callq 0x3bb5d
movq %rax, %rdi
callq 0x7aa64
testb %al, %al
je 0xbd1e5
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xbca45
movl %eax, %ebp
testl %eax, %eax
jne 0xbd1cc
movq 0x8(%rsp), %rsi
cmpq $-0x1, %rsi
je 0xbd1ea
movq (%rsp), %rdi
callq 0xbbf5f
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3b7af
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2941c
callq 0x293e3
callq 0x29371
callq 0x293aa
// File: /workspace/github_c_makefile_star2_O3/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 0xbc97e
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd8196
testq %rax, %rax
je 0xbd20e
movq 0x10(%rax), %rax
popq %rbx
retq
callq 0x29455