LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x9ddc0
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x9dbb9
cmpq %rax, %r12
jae 0x9ddb1
movq %r15, %rdi
movq %r12, %rsi
callq 0x9d339
movq %rax, %rbp
movq %r15, %rdi
movq %r12, %rsi
callq 0x9d478
movq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x9d431
movq %r13, %rdi
movq %rbp, %rsi
movq %rax, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x537a0
movq %rbp, %rdi
leaq 0x4c9b0(%rip), %rsi     # 0xea752
movl $0x1e6, %edx            # imm = 0x1E6
callq 0xd249
incq %r12
jmp 0x9dd50
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x901f1(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2c295(%rip), %rsi     # 0xca066
leaq 0x4863f(%rip), %rdx     # 0xe6417
leaq 0x4cc9f(%rip), %rcx     # 0xeaa7e
leaq 0x4c96c(%rip), %r8      # 0xea752
movl $0x1df, %r9d            # imm = 0x1DF
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x9de7f
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x9dbb9
cmpq %r15, %rax
jbe 0x9dead
movq %r12, %rdi
movq %r15, %rsi
callq 0x9d339
movq %rax, %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0x9d478
movq %rax, %rbp
movq %r12, %rdi
movq %r15, %rsi
callq 0x9d431
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x537a0
leaq 0x4c8ee(%rip), %rsi     # 0xea752
movq %r13, %rdi
movl $0x1f6, %edx            # imm = 0x1F6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd249
movq 0x90132(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2c1d6(%rip), %rsi     # 0xca066
leaq 0x48580(%rip), %rdx     # 0xe6417
leaq 0x4cbf8(%rip), %rcx     # 0xeaa96
leaq 0x4c8ad(%rip), %r8      # 0xea752
movl $0x1ee, %r9d            # imm = 0x1EE
jmp 0x9ded9
movq 0x90104(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2c1a8(%rip), %rsi     # 0xca066
leaq 0x4cbf2(%rip), %rdx     # 0xeaab7
leaq 0x4cbca(%rip), %rcx     # 0xeaa96
leaq 0x4c87f(%rip), %r8      # 0xea752
movl $0x1ef, %r9d            # imm = 0x1EF
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
testq %rdi, %rdi
je 0x9e017
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xa6ec9
movq %rax, %rdi
callq 0x9bd27
testb %al, %al
je 0x9e008
movq %rbx, 0x8(%rsp)
callq 0x13d5c
movq %rax, %r15
movq 0x20(%r14), %rdi
callq 0xa1f4a
movq %rax, %r12
movq 0x20(%r14), %rdi
callq 0xa1f8d
movq %rax, 0x10(%rsp)
incq %r12
xorl %ebp, %ebp
leaq 0x4c804(%rip), %rbx     # 0xea752
movq 0x20(%r14), %rdi
callq 0xa1f8d
cmpq %rax, %rbp
jae 0x9df8a
movq %r14, %rdi
movq %rbp, %rsi
callq 0x9d339
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
callq 0x13dd3
movq %r13, %rdi
movq %rbx, %rsi
movl $0x205, %edx            # imm = 0x205
callq 0xd249
incq %rbp
jmp 0x9df4e
subq 0x10(%rsp), %r12
movq %r15, %rdi
callq 0x14461
cmpq %r12, %rax
jne 0x9e045
movq 0x8(%r14), %rdi
callq 0x143d2
leaq 0x4cb6e(%rip), %rsi     # 0xeab1e
movq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x542da
movq %r15, %rdi
callq 0x143d2
movq %rax, %rbx
movq %r15, %rdi
callq 0x14461
movq %rax, %r12
movq 0x20(%r14), %rdi
callq 0xa6ec9
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r13, %rcx
callq 0xbced0
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x152db
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8ff9a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2c03e(%rip), %rsi     # 0xca066
leaq 0x483e8(%rip), %rdx     # 0xe6417
leaq 0x4caac(%rip), %rcx     # 0xeaae2
leaq 0x4c715(%rip), %r8      # 0xea752
movl $0x1fb, %r9d            # imm = 0x1FB
jmp 0x9e071
movq 0x8ff6c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2c010(%rip), %rsi     # 0xca066
leaq 0x4ca9f(%rip), %rdx     # 0xeaafc
leaq 0x4ca7e(%rip), %rcx     # 0xeaae2
leaq 0x4c6e7(%rip), %r8      # 0xea752
movl $0x207, %r9d            # imm = 0x207
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x9e139
movq %rsi, %rbx
movq %rdi, %r14
callq 0x9dbb9
movq %rax, %r15
movq 0x8(%r14), %rdi
callq 0x143d2
leaq 0x4cab0(%rip), %rsi     # 0xeab5d
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x542da
leaq 0x4cac7(%rip), %rsi     # 0xeab88
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x542da
movq 0x20(%r14), %rdi
callq 0xa1f4a
movq %rax, %r12
movq 0x20(%r14), %rdi
callq 0xa1f8d
subq %rax, %r12
incq %r12
leaq 0x4cab2(%rip), %rsi     # 0xeaba2
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x542da
leaq 0x4cab1(%rip), %r12     # 0xeabb5
xorl %esi, %esi
cmpq %rsi, %r15
je 0x9e12f
leaq 0x1(%rsi), %r13
movq %r14, %rdi
callq 0x9d431
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x542da
movq %r13, %rsi
jmp 0x9e106
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x8fe78(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2bf1c(%rip), %rsi     # 0xca066
leaq 0x482c6(%rip), %rdx     # 0xe6417
leaq 0x4c9f1(%rip), %rcx     # 0xeab49
leaq 0x4c5f3(%rip), %r8      # 0xea752
movl $0x215, %r9d            # imm = 0x215
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x9e1e6
movq %rsi, %rbx
movq %rdi, %r15
xorl %r12d, %r12d
callq 0xa12bc
movq %rax, %r14
movq %r15, %rdi
callq 0x9dbb9
cmpq %rax, %r12
jae 0x9e1b7
movq %r15, %rdi
movq %r12, %rsi
callq 0x9d431
movq %r14, %rdi
movq %rax, %rsi
callq 0xa12d1
incq %r12
jmp 0x9e18f
leaq 0x4ca31(%rip), %rsi     # 0xeabef
movq %rbx, %rdi
xorl %eax, %eax
callq 0x542da
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa1419
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa19c8
movq 0x8fdcb(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2be6f(%rip), %rsi     # 0xca066
leaq 0x48219(%rip), %rdx     # 0xe6417
leaq 0x4c9cb(%rip), %rcx     # 0xeabd0
leaq 0x4c546(%rip), %r8      # 0xea752
movl $0x227, %r9d            # imm = 0x227
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x91b48(%rip), %rsi     # 0x12fd70
leaq 0x4ca55(%rip), %rdi     # 0xeac84
callq 0x9e2a4
movq 0x91b35(%rip), %rsi     # 0x12fd70
leaq 0x4ca56(%rip), %rdi     # 0xeac98
callq 0x9e2a4
movq 0x91b22(%rip), %rsi     # 0x12fd70
leaq 0x4ca84(%rip), %rdi     # 0xeacd9
callq 0x9e2a4
movq 0x91b0f(%rip), %rsi     # 0x12fd70
leaq 0x4ca26(%rip), %rdi     # 0xeac8e
callq 0x9e2a4
movq 0x91afc(%rip), %rsi     # 0x12fd70
leaq 0x4ca18(%rip), %rdi     # 0xeac93
callq 0x9e2a4
movq 0x91ae9(%rip), %rsi     # 0x12fd70
leaq 0x4c9fb(%rip), %rdi     # 0xeac89
callq 0x9e2a4
movl %ebx, %edi
xorl %esi, %esi
callq 0x62597
movl %ebx, %edi
popq %rbx
jmp 0x62577
// File: /workspace/github_c_makefile_star2_O2/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 0x13da9
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x13dd3
movq %rbx, %rdi
callq 0x143d2
movq %rax, %rdi
callq 0x54940
testb %al, %al
je 0x9e2e5
movq %rbx, %rdi
callq 0x143d2
movq %rax, %rdi
callq 0x62628
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x152db
// File: /workspace/github_c_makefile_star2_O2/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
orq $-0x1, 0x8(%rsp)
movq %rdi, %r12
andq $0x0, (%rsp)
callq 0x9e472
movq %rax, %rdi
movq %r12, %rsi
callq 0xbfaea
movq %rax, %r12
testq %r14, %r14
je 0x9e33f
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x9e40c
testq %r14, %r14
je 0x9e3ad
testq %r15, %r15
je 0x9e3ad
testq %rbx, %rbx
je 0x9e3ad
testq %r12, %r12
je 0x9e3ad
movq %r15, %rdi
callq 0x143d2
movq %rax, %rdi
callq 0x59a50
testb %al, %al
je 0x9e3de
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x9e537
movl %eax, %ebp
testl %eax, %eax
jne 0x9e39e
movq 0x8(%rsp), %rsi
cmpq $-0x1, %rsi
je 0x9e43a
movq (%rsp), %rdi
callq 0x9d431
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8fc04(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2bca8(%rip), %rsi     # 0xca066
leaq 0x4c954(%rip), %rdx     # 0xead19
leaq 0x4c912(%rip), %rcx     # 0xeacde
leaq 0x4c930(%rip), %r8      # 0xead03
movl $0x13f, %r9d            # imm = 0x13F
jmp 0x9e466
movq 0x8fbd3(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2bc77(%rip), %rsi     # 0xca066
leaq 0x4c942(%rip), %rdx     # 0xead38
leaq 0x4c8e1(%rip), %rcx     # 0xeacde
leaq 0x4c8ff(%rip), %r8      # 0xead03
movl $0x140, %r9d            # imm = 0x140
jmp 0x9e466
movq 0x8fba5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2bc49(%rip), %rsi     # 0xca066
leaq 0x2c235(%rip), %rdx     # 0xca659
leaq 0x4c8b3(%rip), %rcx     # 0xeacde
leaq 0x4c8d1(%rip), %r8      # 0xead03
movl $0x13e, %r9d            # imm = 0x13E
jmp 0x9e466
movq 0x8fb77(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2bc1b(%rip), %rsi     # 0xca066
leaq 0x4c915(%rip), %rdx     # 0xead67
leaq 0x4c885(%rip), %rcx     # 0xeacde
leaq 0x4c8a3(%rip), %r8      # 0xead03
movl $0x142, %r9d            # imm = 0x142
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4f21f
cmpq $0x0, 0x918ee(%rip)     # 0x12fd78
jne 0x9e51c
leaq 0xdda(%rip), %r15       # 0x9f271
leaq 0xd55(%rip), %r12       # 0x9f1f3
leaq 0xcc4(%rip), %r13       # 0x9f169
leaq 0xc47(%rip), %rbp       # 0x9f0f3
leaq 0xbcf(%rip), %rax       # 0x9f082
leaq 0xb71(%rip), %r14       # 0x9f02b
leaq -0x1cd(%rip), %rbx      # 0x9e2f4
leaq 0x9dd(%rip), %r11       # 0x9eea5
leaq 0x840(%rip), %r10       # 0x9ed0f
leaq 0x1e8(%rip), %rsi       # 0x9e6be
leaq 0x24b(%rip), %rdx       # 0x9e728
leaq 0x393(%rip), %rcx       # 0x9e877
leaq 0x508(%rip), %r8        # 0x9e9f3
leaq 0x613(%rip), %r9        # 0x9eb05
pushq $0x30
popq %rdi
pushq %r15
pushq %r12
pushq %r13
pushq %rbp
pushq %rax
pushq %r14
pushq %rbx
pushq %r11
pushq %r10
leaq 0x6ff(%rip), %rax       # 0x9ec0a
pushq %rax
callq 0xbf99c
addq $0x50, %rsp
movq %rax, 0x9185c(%rip)     # 0x12fd78
callq 0x4f266
movq 0x91850(%rip), %rax     # 0x12fd78
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9e472
movq %rax, %rdi
movq %rbx, %rsi
callq 0xbfaea
testq %rax, %rax
je 0x9e720
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0xbfff4
movq 0x20(%rbx), %rdi
callq 0x563a7
xorl %r14d, %r14d
movq 0x8(%rbx), %rdi
cmpq 0x10(%rbx), %r14
jae 0x9e70a
movq (%rdi,%r14,8), %rdi
callq 0x9d0c7
incq %r14
jmp 0x9e6f2
leaq 0x4c5f2(%rip), %rsi     # 0xead03
pushq $0x35
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9e83f
movq %rdi, %rbx
callq 0x9e472
movq %rax, %rdi
movq %rbx, %rsi
callq 0xbfaea
movq %rax, %rbx
movb $0x1, 0x28(%rax)
leaq 0x4c6e3(%rip), %rsi     # 0xeae46
leaq 0x10(%rsp), %rdi
movl $0x1fff, %edx           # imm = 0x1FFF
xorl %eax, %eax
callq 0xb110
cmpq $0x0, 0x18(%rbx)
jne 0x9e784
callq 0xbffc4
movq %rax, 0x18(%rbx)
leaq 0x10(%rsp), %r14
leaq 0x30(%rsp), %r15
xorl %r13d, %r13d
cmpq 0x10(%rbx), %r13
jae 0x9e82d
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rbp
xorl %r12d, %r12d
movq %rbp, %rdi
callq 0x9dbb9
cmpq %rax, %r12
jae 0x9e825
movq %rbp, %rdi
movq %r12, %rsi
callq 0x9d478
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xb680
movq %r13, (%rsp)
movq %r12, 0x8(%rsp)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0xc0019
testq %rax, %rax
je 0x9e811
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
jne 0x9e804
pushq $0x1
popq %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x55da4
movq %rax, %rdi
movq %rax, 0x20(%rbx)
movq %r15, %rsi
pushq $0x1
popq %rdx
callq 0x55f31
jmp 0x9e820
movq 0x18(%rbx), %rdi
movq %r15, %rsi
movq %rsp, %rdx
callq 0xc005d
incq %r12
jmp 0x9e7a6
incq %r13
jmp 0x9e791
addq $0x2038, %rsp           # imm = 0x2038
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8f772(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2b816(%rip), %rsi     # 0xca066
leaq 0x4c7d8(%rip), %rdx     # 0xeb02f
leaq 0x4c5c2(%rip), %rcx     # 0xeae20
leaq 0x4c49e(%rip), %r8      # 0xead03
movl $0x82, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0x8(%rsp)
movq %rdi, %rbx
andq $0x0, (%rsp)
callq 0x9e472
movq %rax, %rdi
movq %rbx, %rsi
callq 0xbfaea
movq %rax, %rbp
testq %r15, %r15
je 0x9e8cc
movq %r15, %rdi
callq 0xc103
testb %al, %al
jne 0x9e9bb
testq %r13, %r13
je 0x9e98d
testq %r12, %r12
je 0x9e98d
testq %rbp, %rbp
je 0x9e98d
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movq %rbp, %rdi
movq %r13, %rcx
movq %r15, %r8
callq 0x9f470
testl %eax, %eax
jne 0x9e97e
movq 0x8(%rbp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rsp), %rsi
callq 0x9d431
movq %rax, %rbx
decq %rax
cmpq %r14, %rax
setae %dl
movq 0x10(%rsp), %rcx
cmpq %rcx, %rax
setae %al
testb %al, %dl
jne 0x9e95f
movq %r13, %rdi
movq %rcx, %r12
callq 0x143d2
leaq 0x46591(%rip), %rsi     # 0xe4ed5
movq %r15, %rdi
movq %r14, %rdx
movq %r12, %rcx
movq %rax, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rax
jmp 0x9e97e
movq 0x8(%rbp), %rax
movq 0x8(%rsp), %rdx
movq (%rax,%rdx,8), %rdi
movq (%rsp), %rsi
movq %r14, %rdx
callq 0x9d6e5
movq %rax, (%r12)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8f624(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2b6c8(%rip), %rsi     # 0xca066
leaq 0x4c4bf(%rip), %rdx     # 0xeae64
leaq 0x4c4a0(%rip), %rcx     # 0xeae4c
leaq 0x4c350(%rip), %r8      # 0xead03
movl $0xa4, %r9d
jmp 0x9e9e7
movq 0x8f5f6(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2b69a(%rip), %rsi     # 0xca066
leaq 0x2bc86(%rip), %rdx     # 0xca659
leaq 0x4c472(%rip), %rcx     # 0xeae4c
leaq 0x4c322(%rip), %r8      # 0xead03
movl $0xa3, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0x8(%rsp)
movq %rdi, %r12
andq $0x0, (%rsp)
callq 0x9e472
movq %rax, %rdi
movq %r12, %rsi
callq 0xbfaea
movq %rax, %r12
testq %r14, %r14
je 0x9ea3e
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x9eacd
testq %r15, %r15
je 0x9ea9f
testq %rbx, %rbx
je 0x9ea9f
testq %r12, %r12
je 0x9ea9f
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x9f470
movl %eax, %ebp
testl %eax, %eax
jne 0x9ea90
movq 0x8(%r12), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rsp), %rsi
callq 0x9d478
testq %rax, %rax
je 0x9ea90
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13dd3
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8f512(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2b5b6(%rip), %rsi     # 0xca066
leaq 0x4c47a(%rip), %rdx     # 0xeaf31
leaq 0x4c456(%rip), %rcx     # 0xeaf14
leaq 0x4c23e(%rip), %r8      # 0xead03
movl $0xcf, %r9d
jmp 0x9eaf9
movq 0x8f4e4(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2b588(%rip), %rsi     # 0xca066
leaq 0x2bb74(%rip), %rdx     # 0xca659
leaq 0x4c428(%rip), %rcx     # 0xeaf14
leaq 0x4c210(%rip), %r8      # 0xead03
movl $0xce, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0x8(%rsp)
movq %rdi, %r12
andq $0x0, (%rsp)
callq 0x9e472
movq %rax, %rdi
movq %r12, %rsi
callq 0xbfaea
movq %rax, %r12
testq %r14, %r14
je 0x9eb50
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x9ebd2
testq %r15, %r15
je 0x9eba4
testq %rbx, %rbx
je 0x9eba4
testq %r12, %r12
je 0x9eba4
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x9f470
movl %eax, %ebp
testl %eax, %eax
jne 0x9eb95
movq 0x8(%r12), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rsp), %rsi
callq 0x9daff
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8f40d(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2b4b1(%rip), %rsi     # 0xca066
leaq 0x4c3a6(%rip), %rdx     # 0xeaf62
leaq 0x4c383(%rip), %rcx     # 0xeaf46
leaq 0x4c139(%rip), %r8      # 0xead03
movl $0xc0, %r9d
jmp 0x9ebfe
movq 0x8f3df(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2b483(%rip), %rsi     # 0xca066
leaq 0x2ba6f(%rip), %rdx     # 0xca659
leaq 0x4c355(%rip), %rcx     # 0xeaf46
leaq 0x4c10b(%rip), %r8      # 0xead03
movl $0xbf, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0x8(%rsp)
movq %rdi, %r12
andq $0x0, (%rsp)
callq 0x9e472
movq %rax, %rdi
movq %r12, %rsi
callq 0xbfaea
movq %rax, %r12
testq %r14, %r14
je 0x9ec55
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x9ecd7
testq %r15, %r15
je 0x9eca9
testq %rbx, %rbx
je 0x9eca9
testq %r12, %r12
je 0x9eca9
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x9f470
movl %eax, %ebp
testl %eax, %eax
jne 0x9ec9a
movq 0x8(%r12), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rsp), %rsi
callq 0x9d431
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8f308(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2b3ac(%rip), %rsi     # 0xca066
leaq 0x4c2dd(%rip), %rdx     # 0xeaf9e
leaq 0x4c2ae(%rip), %rcx     # 0xeaf76
leaq 0x4c034(%rip), %r8      # 0xead03
movl $0xe4, %r9d
jmp 0x9ed03
movq 0x8f2da(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2b37e(%rip), %rsi     # 0xca066
leaq 0x2b96a(%rip), %rdx     # 0xca659
leaq 0x4c280(%rip), %rcx     # 0xeaf76
leaq 0x4c006(%rip), %r8      # 0xead03
movl $0xe3, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
orq $-0x1, 0x10(%rsp)
movq %rdi, %rbp
andq $0x0, 0x8(%rsp)
callq 0x9e472
movq %rax, %rdi
movq %rbp, %rsi
callq 0xbfaea
movq %rax, %rbp
testq %r12, %r12
je 0x9ed63
movq %r12, %rdi
callq 0xc103
testb %al, %al
jne 0x9ee3f
testq %r12, %r12
je 0x9ede0
testq %r13, %r13
je 0x9ede0
testq %rbx, %rbx
je 0x9ede0
testq %rbp, %rbp
je 0x9ede0
movq %r13, %rdi
callq 0x143d2
movq %rax, %rdi
callq 0x59a50
testb %al, %al
je 0x9ee11
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rbp, %rdx
movq %r13, %rcx
movq %r12, %r8
callq 0x9e537
movl %eax, %ebp
testl %eax, %eax
jne 0x9edcf
movq 0x10(%rsp), %rsi
cmpq $-0x1, %rsi
je 0x9ee6d
movq 0x8(%rsp), %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x9d6e5
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8f1d1(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2b275(%rip), %rsi     # 0xca066
leaq 0x4c1d6(%rip), %rdx     # 0xeafce
leaq 0x4c1b6(%rip), %rcx     # 0xeafb5
leaq 0x4befd(%rip), %r8      # 0xead03
movl $0x11b, %r9d            # imm = 0x11B
jmp 0x9ee99
movq 0x8f1a0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2b244(%rip), %rsi     # 0xca066
leaq 0x4bf0f(%rip), %rdx     # 0xead38
leaq 0x4c185(%rip), %rcx     # 0xeafb5
leaq 0x4becc(%rip), %r8      # 0xead03
movl $0x11c, %r9d            # imm = 0x11C
jmp 0x9ee99
movq 0x8f172(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2b216(%rip), %rsi     # 0xca066
leaq 0x2b802(%rip), %rdx     # 0xca659
leaq 0x4c157(%rip), %rcx     # 0xeafb5
leaq 0x4be9e(%rip), %r8      # 0xead03
movl $0x11a, %r9d            # imm = 0x11A
jmp 0x9ee99
movq 0x8f144(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2b1e8(%rip), %rsi     # 0xca066
leaq 0x4bee2(%rip), %rdx     # 0xead67
leaq 0x4c129(%rip), %rcx     # 0xeafb5
leaq 0x4be70(%rip), %r8      # 0xead03
movl $0x11e, %r9d            # imm = 0x11E
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
orq $-0x1, 0x8(%rsp)
movq %rdi, %r12
andq $0x0, (%rsp)
callq 0x9e472
movq %rax, %rdi
movq %r12, %rsi
callq 0xbfaea
movq %rax, %r12
testq %r14, %r14
je 0x9eef0
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x9efc5
testq %r14, %r14
je 0x9ef66
testq %r15, %r15
je 0x9ef66
testq %rbx, %rbx
je 0x9ef66
testq %r12, %r12
je 0x9ef66
movq %r15, %rdi
callq 0x143d2
movq %rax, %rdi
callq 0x59a50
testb %al, %al
je 0x9ef97
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x9e537
movl %eax, %ebp
testl %eax, %eax
jne 0x9ef57
movq 0x8(%rsp), %rsi
cmpq $-0x1, %rsi
je 0x9eff3
movq (%rsp), %rdi
callq 0x9d478
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13dd3
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8f04b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2b0ef(%rip), %rsi     # 0xca066
leaq 0x4c090(%rip), %rdx     # 0xeb00e
leaq 0x4c068(%rip), %rcx     # 0xeafed
leaq 0x4bd77(%rip), %r8      # 0xead03
movl $0x12d, %r9d            # imm = 0x12D
jmp 0x9f01f
movq 0x8f01a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2b0be(%rip), %rsi     # 0xca066
leaq 0x4bd89(%rip), %rdx     # 0xead38
leaq 0x4c037(%rip), %rcx     # 0xeafed
leaq 0x4bd46(%rip), %r8      # 0xead03
movl $0x12e, %r9d            # imm = 0x12E
jmp 0x9f01f
movq 0x8efec(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2b090(%rip), %rsi     # 0xca066
leaq 0x2b67c(%rip), %rdx     # 0xca659
leaq 0x4c009(%rip), %rcx     # 0xeafed
leaq 0x4bd18(%rip), %r8      # 0xead03
movl $0x12c, %r9d            # imm = 0x12C
jmp 0x9f01f
movq 0x8efbe(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2b062(%rip), %rsi     # 0xca066
leaq 0x4bd5c(%rip), %rdx     # 0xead67
leaq 0x4bfdb(%rip), %rcx     # 0xeafed
leaq 0x4bcea(%rip), %r8      # 0xead03
movl $0x130, %r9d            # imm = 0x130
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x9e472
movq %rax, %rdi
movq %rbx, %rsi
callq 0xbfaea
testq %rax, %rax
je 0x9f04a
movq 0x10(%rax), %rax
popq %rbx
retq
movq 0x8ef67(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2b00b(%rip), %rsi     # 0xca066
leaq 0x4bfcc(%rip), %rdx     # 0xeb02e
leaq 0x4bfc9(%rip), %rcx     # 0xeb032
leaq 0x4bc93(%rip), %r8      # 0xead03
movl $0x14c, %r9d            # imm = 0x14C
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x9e472
movq %rax, %rdi
movq %r14, %rsi
callq 0xbfaea
testq %rax, %rax
je 0x9f0bb
cmpq %rbx, 0x10(%rax)
jbe 0x9f0bb
movq 0x8(%rax), %rax
movq (%rax,%rbx,8), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9dbb9
movq 0x8eef6(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2af9a(%rip), %rsi     # 0xca066
leaq 0x4bf7a(%rip), %rdx     # 0xeb04d
leaq 0x4bf99(%rip), %rcx     # 0xeb073
leaq 0x4bc22(%rip), %r8      # 0xead03
movl $0x155, %r9d            # imm = 0x155
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_get_md5_fingerprint
static const char* gt_bioseq_col_get_md5_fingerprint(const GtSeqCol *sc,
                                                     GtUword filenum,
                                                     GtUword seqnum)
{
  GtBioseqCol *bsc;
  bsc = gt_bioseq_col_cast(sc);
  gt_assert(bsc && filenum < bsc->num_of_seqfiles);
  return gt_bioseq_get_md5_fingerprint(bsc->bioseqs[filenum], seqnum);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x9e472
movq %rax, %rdi
movq %r15, %rsi
callq 0xbfaea
testq %rax, %rax
je 0x9f131
cmpq %r14, 0x10(%rax)
jbe 0x9f131
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x9daff
movq 0x8ee80(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2af24(%rip), %rsi     # 0xca066
leaq 0x4bf04(%rip), %rdx     # 0xeb04d
leaq 0x4bf3d(%rip), %rcx     # 0xeb08d
leaq 0x4bbac(%rip), %r8      # 0xead03
movl $0x15f, %r9d            # imm = 0x15F
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_get_sequence
static char* gt_bioseq_col_get_sequence(const GtSeqCol *sc,
                                        GtUword filenum,
                                        GtUword seqnum,
                                        GtUword start,
                                        GtUword end)
{
  GtBioseqCol *bsc;
  bsc = gt_bioseq_col_cast(sc);
  gt_assert(bsc && filenum < bsc->num_of_seqfiles);
  return gt_bioseq_get_sequence_range(bsc->bioseqs[filenum], seqnum, start,
                                      end);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
callq 0x9e472
movq %rax, %rdi
movq %r13, %rsi
callq 0xbfaea
testq %rax, %rax
je 0x9f1bb
cmpq %r12, 0x10(%rax)
jbe 0x9f1bb
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x9d6e5
movq 0x8edf6(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2ae9a(%rip), %rsi     # 0xca066
leaq 0x4be7a(%rip), %rdx     # 0xeb04d
leaq 0x4bed5(%rip), %rcx     # 0xeb0af
leaq 0x4bb22(%rip), %r8      # 0xead03
movl $0x16b, %r9d            # imm = 0x16B
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_get_description
static char* gt_bioseq_col_get_description(const GtSeqCol *sc,
                                           GtUword filenum,
                                           GtUword seqnum)
{
  GtBioseqCol *bsc;
  bsc = gt_bioseq_col_cast(sc);
  gt_assert(bsc && filenum < bsc->num_of_seqfiles);
  return gt_cstr_dup(gt_bioseq_get_description(bsc->bioseqs[filenum], seqnum));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x9e472
movq %rax, %rdi
movq %r15, %rsi
callq 0xbfaea
testq %rax, %rax
je 0x9f239
cmpq %r14, 0x10(%rax)
jbe 0x9f239
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %rdi
movq %rbx, %rsi
callq 0x9d478
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4f8ae
movq 0x8ed78(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2ae1c(%rip), %rsi     # 0xca066
leaq 0x4bdfc(%rip), %rdx     # 0xeb04d
leaq 0x4be72(%rip), %rcx     # 0xeb0ca
leaq 0x4baa4(%rip), %r8      # 0xead03
movl $0x176, %r9d            # imm = 0x176
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_get_sequence_length
static GtUword gt_bioseq_col_get_sequence_length(const GtSeqCol *sc,
                                                       GtUword filenum,
                                                       GtUword seqnum)
{
  GtBioseqCol *bsc;
  bsc = gt_bioseq_col_cast(sc);
  gt_assert(bsc && filenum < bsc->num_of_seqfiles);
  return gt_bioseq_get_sequence_length(bsc->bioseqs[filenum], seqnum);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x9e472
movq %rax, %rdi
movq %r15, %rsi
callq 0xbfaea
testq %rax, %rax
je 0x9f2af
cmpq %r14, 0x10(%rax)
jbe 0x9f2af
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x9d431
movq 0x8ed02(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2ada6(%rip), %rsi     # 0xca066
leaq 0x4bd86(%rip), %rdx     # 0xeb04d
leaq 0x4be1a(%rip), %rcx     # 0xeb0e8
leaq 0x4ba2e(%rip), %r8      # 0xead03
movl $0x180, %r9d            # imm = 0x180
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_new
GtSeqCol* gt_bioseq_col_new(GtStrArray *sequence_files, GtError *err)
{
  GtSeqCol *sc;
  GtBioseqCol *bsc;
  GtUword i;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(sequence_files);
  gt_assert(gt_str_array_size(sequence_files));
  sc = gt_seq_col_create(gt_bioseq_col_class());
  bsc = gt_bioseq_col_cast(sc);
  bsc->duplicates = NULL;
  bsc->num_of_seqfiles = gt_str_array_size(sequence_files);
  bsc->bioseqs = gt_calloc(bsc->num_of_seqfiles, sizeof (GtBioseq*));
  for (i = 0; !had_err && i < bsc->num_of_seqfiles; i++) {
    bsc->bioseqs[i] = gt_bioseq_new(gt_str_array_get(sequence_files, i), err);
    if (!bsc->bioseqs[i])
      had_err = -1;
  }
  if (had_err) {
    gt_bioseq_col_delete(sc);
    return NULL;
  }
  bsc->matchdescstart = false;
  return sc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x9f30b
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x9f438
testq %r14, %r14
je 0x9f3dc
movq %r14, %rdi
callq 0x157f4
testq %rax, %rax
je 0x9f40a
callq 0x9e472
movq %rax, %rdi
callq 0xbfa22
movq %rax, %r15
callq 0x9e472
movq %rax, %rdi
movq %r15, %rsi
callq 0xbfaea
movq %rax, %r12
andq $0x0, 0x20(%rax)
movq %r14, %rdi
callq 0x157f4
movq %rax, 0x10(%r12)
leaq 0x4b9a2(%rip), %rdx     # 0xead03
pushq $0x8
popq %rsi
movq %rax, %rdi
movl $0x1ab, %ecx            # imm = 0x1AB
callq 0xce9a
movq %rax, 0x8(%r12)
xorl %r13d, %r13d
xorl %eax, %eax
testl %eax, %eax
jne 0x9f3bc
cmpq 0x10(%r12), %r13
jae 0x9f3c9
movq %r14, %rdi
movq %r13, %rsi
callq 0x1555e
movq %rax, %rdi
movq %rbx, %rsi
callq 0x9c9a8
movq 0x8(%r12), %rcx
movq %rax, (%rcx,%r13,8)
movq 0x8(%r12), %rax
cmpq $0x1, (%rax,%r13,8)
leaq 0x1(%r13), %r13
movl $0x0, %eax
sbbl %eax, %eax
jmp 0x9f37b
movq %r15, %rdi
callq 0x9e6be
xorl %r15d, %r15d
jmp 0x9f3cf
movb $0x0, 0x28(%r12)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x8ebd5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2ac79(%rip), %rsi     # 0xca066
leaq 0x4b99e(%rip), %rdx     # 0xead92
leaq 0x4b985(%rip), %rcx     # 0xead80
leaq 0x4b901(%rip), %r8      # 0xead03
movl $0x1a5, %r9d            # imm = 0x1A5
jmp 0x9f464
movq 0x8eba7(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2ac4b(%rip), %rsi     # 0xca066
leaq 0x4b97f(%rip), %rdx     # 0xeada1
leaq 0x4b957(%rip), %rcx     # 0xead80
leaq 0x4b8d3(%rip), %r8      # 0xead03
movl $0x1a6, %r9d            # imm = 0x1A6
jmp 0x9f464
movq 0x8eb79(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2ac1d(%rip), %rsi     # 0xca066
leaq 0x2b209(%rip), %rdx     # 0xca659
leaq 0x4b929(%rip), %rcx     # 0xead80
leaq 0x4b8a5(%rip), %r8      # 0xead03
movl $0x1a4, %r9d            # imm = 0x1A4
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bsearch.c
// Function: cmp
static int cmp(const void *a_ptr, const void *b_ptr, GT_UNUSED void *unused)
{
  int a, b;
  gt_assert(a_ptr && b_ptr);
  a = *(int*) a_ptr;
  b = *(int*) b_ptr;
  if (a == b)
    return 0;
  if (a < b)
    return -1;
  return 1;
}

// Assembly:
testq %rdi, %rdi
je 0xa0b7e
testq %rsi, %rsi
je 0xa0b7e
movl (%rdi), %eax
xorl %ecx, %ecx
xorl %edx, %edx
cmpl (%rsi), %eax
setge %dl
leal -0x1(%rdx,%rdx), %eax
cmovel %ecx, %eax
retq
pushq %rax
movq 0x8d432(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x294d6(%rip), %rsi     # 0xca066
leaq 0x4a837(%rip), %rdx     # 0xeb3ce
leaq 0x3989d(%rip), %rcx     # 0xda43b
leaq 0x4a57c(%rip), %r8      # 0xeb121
pushq $0x65
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/disc_distri.c
// Function: gt_disc_distri_add_multi
void gt_disc_distri_add_multi(GtDiscDistri *d, GtUword key,
                              GtUint64 occurrences)
{
  GtUint64 *valueptr;
  gt_assert(d);

  if (!d->hashdist)
    d->hashdist = ul_ull_gt_hashmap_new();

  valueptr = ul_ull_gt_hashmap_get(d->hashdist, key);
  if (!valueptr) {
    ul_ull_gt_hashmap_add(d->hashdist, key, occurrences);
  }
  else
    (*valueptr) += occurrences;

  d->num_of_occurrences += occurrences;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
testq %rdi, %rdi
je 0xa1370
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0xa132a
movups 0x8e45d(%rip), %xmm0    # 0x12f760
movups %xmm0, 0x20(%rsp)
movups 0x8e441(%rip), %xmm0    # 0x12f750
movups %xmm0, 0x10(%rsp)
movups 0x8e425(%rip), %xmm0    # 0x12f740
movups %xmm0, (%rsp)
callq 0x5653b
movq %rax, %rdi
movq %rax, (%r14)
movq %r15, %rsi
callq 0xa13a6
testq %rax, %rax
je 0xa133c
addq %rbx, (%rax)
jmp 0xa1362
movq (%r14), %rdi
leaq 0x40(%rsp), %rsi
movq %r15, (%rsi)
movq %rbx, 0x8(%rsi)
leaq 0x38(%rsp), %rdx
callq 0x5697b
testl %eax, %eax
jne 0xa1362
movq 0x38(%rsp), %rax
movq %rbx, 0x8(%rax)
addq %rbx, 0x8(%r14)
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8cc41(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x28ce5(%rip), %rsi     # 0xca066
leaq 0x4c8cb(%rip), %rdx     # 0xedc53
leaq 0x4a3e8(%rip), %rcx     # 0xeb777
leaq 0x4a3ca(%rip), %r8      # 0xeb760
pushq $0x38
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/disc_distri.c
// Function: gt_disc_distri_get
GtUint64 gt_disc_distri_get(const GtDiscDistri *d, GtUword key)
{
  GtUint64 *valueptr;
  gt_assert(d);
  if (!d->hashdist || !(valueptr = ul_ull_gt_hashmap_get(d->hashdist, key)))
    return 0;
  return *valueptr;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xa13e3
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xa13df
callq 0xa13a6
testq %rax, %rax
je 0xa13df
movq (%rax), %rax
jmp 0xa13e1
xorl %eax, %eax
popq %rcx
retq
movq 0x8cbce(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x28c72(%rip), %rsi     # 0xca066
leaq 0x4c858(%rip), %rdx     # 0xedc53
leaq 0x4a38e(%rip), %rcx     # 0xeb790
leaq 0x4a357(%rip), %r8      # 0xeb760
pushq $0x4a
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300