LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/aligned_segment.c
// Function: gt_aligned_segment_fetch_s_and_q_from_sa
static void gt_aligned_segment_fetch_s_and_q_from_sa(GtAlignedSegment *as,
    GtSamAlignment *sa)
{
  GtUword alen = as->alen, slen = gt_sam_alignment_read_length(sa);
  GtUchar *s = (GtUchar*) (as->s + (alen - slen)),
          *q = (GtUchar*) (as->q + (alen - slen));
  GtAlphabet *alpha;
  gt_sam_alignment_sequence_external_buffer(sa, &s, &alen);
  gt_assert(as->alen == alen);
  gt_assert(s == (GtUchar*) (as->s + (alen - slen)));
  gt_sam_alignment_qualitystring_external_buffer(sa, &q,
      &alen);
  gt_assert(as->alen == alen);
  gt_assert(q == (GtUchar*) (as->q + (alen - slen)));
  alpha = gt_alphabet_new_dna();
  gt_alphabet_decode_seq_to_cstr(alpha, (char*) s, s, slen);
  gt_alphabet_delete(alpha);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rdi), %rax
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
movq %rsi, %rdi
callq 0x178583
movq %rax, %rbx
movq (%r12), %rax
subq %rbx, %rax
movq (%r14), %rcx
addq %rax, %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
addq 0x8(%r14), %rax
movq %rax, (%rsp)
movq %r15, %rdi
movq %r12, %rdx
callq 0x1785fe
movq (%r12), %rax
cmpq %rax, 0x20(%r14)
jne 0x30494a
subq %rbx, %rax
addq (%r14), %rax
cmpq %rax, 0x8(%rsp)
jne 0x30494f
movq %rsp, %rsi
leaq 0x10(%rsp), %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x178717
movq (%r12), %rax
cmpq %rax, 0x20(%r14)
jne 0x304954
subq %rbx, %rax
addq 0x8(%r14), %rax
cmpq %rax, (%rsp)
jne 0x304959
callq 0xd340f
movq %rax, %r14
movq 0x8(%rsp), %rdx
movq %rax, %rdi
movq %rdx, %rsi
movq %rbx, %rcx
callq 0xd39cd
movq %r14, %rdi
callq 0xd335d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x8c129
callq 0x8c160
callq 0x8c197
callq 0x8c1ce
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/bitinstream.c
// Function: gt_bitinstream_new
GtBitInStream *gt_bitinstream_new(const char* path,
                                  size_t offset,
                                  GtUword pages_to_map)
{
  GtBitInStream *bitstream = gt_malloc(sizeof (*bitstream));

  bitstream->pagesize = gt_pagesize();
  bitstream->last_chunk = false;
  gt_safe_assign(bitstream->filesize, gt_file_estimate_size(path));
  bitstream->path = gt_cstr_dup(path);
  bitstream->pages_to_map = pages_to_map;

  if ((GtUword) bitstream->filesize <
      (bitstream->pages_to_map * bitstream->pagesize))
    bitstream->pages_to_map =
      (GtUword) ((bitstream->filesize / bitstream->pagesize) + 1);

  bitstream->bitseqbuffer = NULL;
  bitstream->read_bits = 0;
  gt_bitinstream_reinit(bitstream,
                        offset);

  bitstream->bufferlength = (bitstream->pages_to_map * bitstream->pagesize) /
                            sizeof (*bitstream->bitseqbuffer);
  return bitstream;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0xe1579(%rip), %rsi     # 0x3e5ef1
movl $0x50, %edi
movl $0x31, %edx
callq 0x1092b2
movq %rax, %rbx
callq 0xe837d
movq %rax, 0x28(%rbx)
movb $0x0, 0x4c(%rbx)
movq %r12, %rdi
callq 0x1045d1
testq %rax, %rax
js 0x304a0a
movq %rax, 0x8(%rbx)
movq %r12, %rdi
callq 0xe8760
movq %rax, 0x38(%rbx)
movq %r15, 0x20(%rbx)
movq 0x8(%rbx), %rax
movq 0x28(%rbx), %rcx
imulq %rcx, %r15
cmpq %r15, %rax
jae 0x3049d5
xorl %edx, %edx
divq %rcx
incq %rax
movq %rax, 0x20(%rbx)
xorl %eax, %eax
movq %rax, 0x40(%rbx)
movq %rax, 0x30(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x304a0f
movq 0x28(%rbx), %rax
imulq 0x20(%rbx), %rax
shrq $0x3, %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x8c205
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/bitinstream.c
// Function: gt_bitinstream_reinit
void gt_bitinstream_reinit(GtBitInStream *bitstream,
                           size_t offset)
{
  size_t mapsize = (size_t) (bitstream->pagesize * bitstream->pages_to_map);

  gt_assert(offset < bitstream->filesize);
  gt_assert((offset % bitstream->pagesize) == 0);

  bitstream->cur_filepos = offset;

  gt_fa_xmunmap(bitstream->bitseqbuffer);

  if (bitstream->cur_filepos + mapsize > bitstream->filesize) {
    mapsize = bitstream->filesize - bitstream->cur_filepos;
    bitstream->bufferlength = (GtUword)  mapsize /
                                sizeof (*bitstream->bitseqbuffer);
    bitstream->last_chunk = true;
  }
  bitstream->bitseqbuffer =
    gt_fa_xmmap_read_range(bitstream->path,
                           mapsize,
                           offset);

  gt_assert(bitstream->bitseqbuffer != NULL);

  bitstream->cur_bit = 0;
  bitstream->cur_bitseq = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq %rsi, 0x8(%rdi)
jbe 0x304aa5
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %r15
movq %rsi, %rax
xorl %edx, %edx
divq %r15
testq %rdx, %rdx
jne 0x304aaa
imulq 0x20(%rbx), %r15
movq %r14, (%rbx)
movq 0x40(%rbx), %rdi
callq 0x102b12
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
leaq (%rcx,%r15), %rdx
cmpq %rax, %rdx
jbe 0x304a6b
subq %rcx, %rax
movq %rax, %rcx
shrq $0x3, %rcx
movq %rcx, 0x10(%rbx)
movb $0x1, 0x4c(%rbx)
movq %rax, %r15
movq 0x38(%rbx), %rdi
leaq 0xe147b(%rip), %rcx     # 0x3e5ef1
movq %r15, %rsi
movq %r14, %rdx
movl $0x5d, %r8d
callq 0x102a6a
movq %rax, 0x40(%rbx)
testq %rax, %rax
je 0x304aaf
movl $0x0, 0x48(%rbx)
movq $0x0, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x8c230
callq 0x8c267
callq 0x8c29e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/bitinstream.c
// Function: gt_bitinstream_get_next_bit
int gt_bitinstream_get_next_bit(GtBitInStream *bitstream,
                                bool * bit)
{
  const int eof = 0, more_to_read = 1;
  if (bitstream->cur_bit == GT_INTWORDSIZE) {
    if (bitstream->cur_bitseq < bitstream->bufferlength - 1) {
      bitstream->cur_bit = 0;
      bitstream->cur_bitseq++;
    }
    else {
      if (bitstream->last_chunk) {
        return eof;
      }
      else {
        gt_bitinstream_reinit(bitstream,
                              bitstream->cur_filepos +
                                bitstream->pagesize *
                                bitstream->pages_to_map);
      }
    }
  }
  gt_assert(bitstream->cur_bitseq != bitstream->bufferlength);
  *bit = GT_ISBITSET(bitstream->bitseqbuffer[bitstream->cur_bitseq],
                     bitstream->cur_bit++) != 0;
  bitstream->read_bits++;
  return more_to_read;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x40, 0x48(%rdi)
jne 0x304b00
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
decq %rcx
cmpq %rcx, %rax
jae 0x304ae4
movl $0x0, 0x48(%rbx)
incq %rax
movq %rax, 0x18(%rbx)
jmp 0x304b00
xorl %eax, %eax
cmpb $0x0, 0x4c(%rbx)
jne 0x304b2d
movq 0x20(%rbx), %rsi
imulq 0x28(%rbx), %rsi
addq (%rbx), %rsi
movq %rbx, %rdi
callq 0x304a0f
movq 0x18(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x304b35
movq 0x40(%rbx), %rcx
movq (%rcx,%rax,8), %rax
movl 0x48(%rbx), %ecx
shlq %cl, %rax
incl %ecx
movl %ecx, 0x48(%rbx)
shrq $0x3f, %rax
movb %al, (%r14)
incq 0x30(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x8c2d5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/bitinstream.c
// Function: gt_bitinstream_delete
void gt_bitinstream_delete(GtBitInStream *bitstream)
{
  if (bitstream != NULL) {
    gt_log_log("read "GT_WU" bits", bitstream->read_bits);
    gt_fa_xmunmap(bitstream->bitseqbuffer);
    gt_free(bitstream->path);
    gt_free(bitstream);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x304b90
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rsi
leaq 0xe147f(%rip), %rdi     # 0x3e5fd0
xorl %eax, %eax
callq 0x108e02
movq 0x40(%rbx), %rdi
callq 0x102b12
movq 0x38(%rbx), %rdi
leaq 0xe1385(%rip), %r14     # 0x3e5ef1
movq %r14, %rsi
movl $0x86, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x87, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/bitoutstream.c
// Function: gt_bitoutstream_new
GtBitOutStream* gt_bitoutstream_new(FILE *fp)
{
  GtBitOutStream *bitstream;
  gt_assert(fp);

  bitstream = gt_calloc((size_t) 1, sizeof (GtBitOutStream));
  bitstream->bits_left = GT_INTWORDSIZE;
  bitstream->fp = fp;
  bitstream->bitseqbuffer = 0;
  bitstream->written_bits = 0;
  bitstream->pagesize = gt_pagesize();
  return bitstream;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x304be6
movq %rdi, %rbx
leaq 0xe144b(%rip), %rdx     # 0x3e5ff2
movl $0x1, %edi
movl $0x28, %esi
movl $0x27, %ecx
callq 0x1093ef
movq %rax, %r14
movl $0x40, 0x20(%rax)
movq %rbx, (%rax)
xorl %eax, %eax
movq %rax, 0x18(%r14)
movq %rax, 0x8(%r14)
callq 0xe837d
movq %rax, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x8c30c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/bitoutstream.c
// Function: gt_bitoutstream_append
void gt_bitoutstream_append(GtBitOutStream *bitstream,
                            GtBitsequence code,
                            unsigned bits_to_write)
{
  if ((unsigned) bitstream->bits_left < bits_to_write) {
    unsigned overhang = bits_to_write - bitstream->bits_left;
    bitstream->bitseqbuffer |= code >> overhang;
    gt_xfwrite(&bitstream->bitseqbuffer,
               sizeof (GtBitsequence),
               (size_t) 1, bitstream->fp);
    bitstream->bitseqbuffer = 0;
    bitstream->bits_left = GT_INTWORDSIZE - overhang;
    bitstream->written_bits += GT_INTWORDSIZE;
  }
  else {
    bitstream->bits_left -= bits_to_write;
  }
  bitstream->bitseqbuffer |= code << bitstream->bits_left;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x20(%rdi), %eax
movl %eax, %ecx
subl %edx, %ecx
jae 0x304c3e
movl %edx, %ebp
subl %eax, %ebp
movq %rbx, %rax
movl %ebp, %ecx
shrq %cl, %rax
leaq 0x18(%r14), %rdi
orq %rax, 0x18(%r14)
movq (%r14), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x125658
movq $0x0, 0x18(%r14)
movl $0x40, %eax
subl %ebp, %eax
movl %eax, 0x20(%r14)
addq $0x40, 0x8(%r14)
jmp 0x304c42
movl %ecx, 0x20(%r14)
movb 0x20(%r14), %cl
shlq %cl, %rbx
orq %rbx, 0x18(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/bitoutstream.c
// Function: gt_bitoutstream_append_bittab
void gt_bitoutstream_append_bittab(GtBitOutStream *bitstream,
                                   GtBittab *tab) {
  GtUword j,
                size = gt_bittab_size(tab);
  for (j = 0; j < size; j++) {
    if (bitstream->bits_left == 0) {
      gt_xfwrite(&bitstream->bitseqbuffer,
                 sizeof (GtBitsequence),
                 (size_t) 1, bitstream->fp);
      bitstream->bitseqbuffer = 0;
      bitstream->bits_left = GT_INTWORDSIZE;
      bitstream->written_bits += GT_INTWORDSIZE;
    }
    bitstream->bits_left--;
    if (gt_bittab_bit_is_set(tab, j))
      bitstream->bitseqbuffer |= ((GtBitsequence) 1) << (bitstream->bits_left);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xd9585
testq %rax, %rax
je 0x304cd4
movq %rax, %r15
leaq 0x18(%r14), %r12
xorl %r13d, %r13d
cmpl $0x0, 0x20(%r14)
jne 0x304ca9
movq (%r14), %rcx
movl $0x8, %esi
movl $0x1, %edx
movq %r12, %rdi
callq 0x125658
movq $0x0, 0x18(%r14)
movl $0x40, 0x20(%r14)
addq $0x40, 0x8(%r14)
decl 0x20(%r14)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xd94c7
testb %al, %al
je 0x304ccc
movb 0x20(%r14), %cl
movl $0x1, %eax
shlq %cl, %rax
orq %rax, 0x18(%r14)
incq %r13
cmpq %r13, %r15
jne 0x304c78
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/bitoutstream.c
// Function: gt_bitoutstream_flush
void gt_bitoutstream_flush(GtBitOutStream *bitstream)
{
  gt_assert(bitstream);
  gt_xfwrite(&bitstream->bitseqbuffer, sizeof (GtBitsequence),
             (size_t) 1, bitstream->fp);
  bitstream->written_bits += (GT_INTWORDSIZE - bitstream->bits_left);

  bitstream->bitseqbuffer = 0;
  bitstream->bits_left = GT_INTWORDSIZE;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x304d21
movq %rdi, %rbx
addq $0x18, %rdi
movq (%rbx), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x125658
movslq 0x20(%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
addq $0x40, %rcx
movq %rcx, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movl $0x40, 0x20(%rbx)
popq %rbx
retq
callq 0x8c343
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/bitoutstream.c
// Function: gt_bitoutstream_flush_advance
void gt_bitoutstream_flush_advance(GtBitOutStream *bitstream)
{
  GtWord fpos;
  bool is_not_at_pageborder = (ftell(bitstream->fp) % bitstream->pagesize) != 0;

  gt_assert(bitstream);

  gt_bitoutstream_flush(bitstream);

  if (is_not_at_pageborder) {
    fpos = (ftell(bitstream->fp) / bitstream->pagesize + 1) *
           bitstream->pagesize;
    gt_xfseek(bitstream->fp, fpos, SEEK_SET);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x17030
xorl %edx, %edx
divq 0x10(%rbx)
movq %rdx, %r14
leaq 0x18(%rbx), %rdi
movq (%rbx), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x125658
movslq 0x20(%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
addq $0x40, %rcx
movq %rcx, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movl $0x40, 0x20(%rbx)
testq %r14, %r14
je 0x304da5
movq (%rbx), %rdi
callq 0x17030
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
xorl %edx, %edx
divq %rcx
leaq 0x1(%rax), %rsi
imulq %rcx, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x125636
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/chain.c
// Function: gt_chain_set_fragnum
void gt_chain_set_fragnum(GtChain *chain, GtUword idx,
                          GtUword fragnum)
{
  GtUword *fragments;
  gt_assert(chain);
  gt_assert(idx < gt_array_size(chain->fragments));
  fragments = gt_array_get_space(chain->fragments);
  fragments[idx] = fragnum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3059b7
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0xd4a9a
cmpq %r14, %rax
jbe 0x3059bc
movq (%r15), %rdi
callq 0xd49a9
movq %rbx, (%rax,%r14,8)
popq %rbx
popq %r14
popq %r15
retq
callq 0x8c84a
callq 0x8c813
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/clustered_set.c
// Function: gt_clustered_set_class_new
const GtClusteredSetClass* gt_clustered_set_class_new(
  size_t size,
  GtClusteredSetNumberOfClustersFunc number_of_clusters,
  GtClusteredSetMergeClustersFunc merge_clusters,
  GtClusteredSetFreeFunc free,
  GtClusteredSetIteratorFunc iterator,
  GtClusteredSetNumberOfElementsFunc number_of_elements,
  GtClusteredSetClusterNumFunc cluster_num)
{
  GtClusteredSetClass  *c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->number_of_clusters = number_of_clusters;
  c_class->merge_clusters = merge_clusters;
  c_class->free = free;
  c_class->iterator = iterator;
  c_class->number_of_elements = number_of_elements;
  c_class->cluster_num = cluster_num;
  return c_class;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movl $0x38, %edi
callq 0x301854
movq %rbp, (%rax)
movq %r13, 0x10(%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/clustered_set.c
// Function: gt_clustered_set_create
GtClusteredSet* gt_clustered_set_create(const GtClusteredSetClass *csc)
{
  GtClusteredSet *cs;
  gt_assert(csc && csc->size);
  cs = gt_calloc(1, csc->size) ;
  cs->c_class = csc;
  return cs;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x305aba
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x305aba
leaq 0xe097c(%rip), %rdx     # 0x3e6422
movl $0x1, %edi
movl $0x2f, %ecx
callq 0x1093ef
movq %rbx, (%rax)
popq %rbx
retq
callq 0x8c926
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/clustered_set.c
// Function: gt_clustered_set_delete
void gt_clustered_set_delete(GtClusteredSet *cs, GtError *err)
{
 if (!cs) return;
 if (cs->c_class->free)
  cs->c_class->free(cs, err);
 gt_free(cs);
}

// Assembly:
testq %rdi, %rdi
je 0x305aee
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x305ad9
movq %rbx, %rdi
callq *%rax
leaq 0xe0942(%rip), %rsi     # 0x3e6422
movq %rbx, %rdi
movl $0x39, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/clustered_set_uf.c
// Function: gt_clustered_set_union_find_iterator_new
GtClusteredSetIterator*
gt_clustered_set_union_find_iterator_new(GtClusteredSet *cs,
                                         GtUword c,
                                         GT_UNUSED GtError *err)
{
  gt_assert(cs);
  GtClusteredSetUF *cs_uf = (GtClusteredSetUF*) cs;
  GtClusteredSetIterator *cs_i = gt_calloc(1, sizeof (GtClusteredSetIterator));
  GtUword i = 0, j = 0;
  if (SINGLETON(c)) {
    cs_i->length = (GtUword) 1;
    cs_i->curpos = (GtUword) 0;
    cs_i->elems = gt_calloc(1, sizeof (GtUword));
    cs_i->elems[j] = c;
  }
  else {
    if (CINFO(c)->cluster_size > 0) {
      GtClusteredSetUFClusterInfo *cluster_info;
      cluster_info = CINFO(c);
      cs_i->length = cluster_info->cluster_size;
      cs_i->curpos = (GtUword) 0;
      cs_i->elems = gt_calloc(cluster_info->cluster_size,
                              sizeof (GtUword));
      i = cluster_info->first_elem;

      do {
        cs_i->elems[j] = i;
        j++;
      } while ((i = cs_uf->cluster_elems[i].next_elem) < cs_uf->num_of_elems);

    } else {
      gt_free(cs_i);
      return NULL;
    }
  }
  return cs_i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x305c82
movq %rsi, %r15
movq %rdi, %r14
leaq 0xe08cd(%rip), %rdx     # 0x3e6468
movl $0x1, %edi
movl $0x18, %esi
movl $0x97, %ecx
callq 0x1093ef
movq %rax, %rbx
movq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0xd94c7
testb %al, %al
je 0x305c30
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0xd47ba
cmpq $0x0, 0x10(%rax)
je 0x305c63
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0xd47ba
movq %rax, %r15
movq 0x10(%rax), %rdi
movq %rdi, 0x8(%rbx)
movq $0x0, (%rbx)
leaq 0xe086a(%rip), %rdx     # 0x3e6468
movl $0x8, %esi
movl $0xa6, %ecx
callq 0x1093ef
movq %rax, 0x10(%rbx)
movq (%r15), %rcx
movq 0x10(%r14), %rdx
movq %rcx, (%rax)
shlq $0x4, %rcx
movq 0x8(%rdx,%rcx), %rcx
addq $0x8, %rax
cmpq 0x28(%r14), %rcx
jb 0x305c18
jmp 0x305c79
movq $0x1, 0x8(%rbx)
movq $0x0, (%rbx)
leaq 0xe0822(%rip), %rdx     # 0x3e6468
movl $0x1, %edi
movl $0x8, %esi
movl $0x9c, %ecx
callq 0x1093ef
movq %rax, 0x10(%rbx)
movq %r15, (%rax)
jmp 0x305c79
leaq 0xe07fe(%rip), %rsi     # 0x3e6468
movq %rbx, %rdi
movl $0xaf, %edx
callq 0x109670
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x8c95d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/clustered_set_uf.c
// Function: gt_clustered_set_union_find_delete
void gt_clustered_set_union_find_delete(GtClusteredSet *cs,
                                        GT_UNUSED GtError *err)
{
  if (!cs) return;
  GtClusteredSetUF *cs_uf = (GtClusteredSetUF*) cs;
  gt_free(cs_uf->cluster_elems);
  gt_array_delete(cs_uf->cluster_info);
  gt_bittab_delete(cs_uf->in_cluster);
}

// Assembly:
testq %rdi, %rdi
je 0x305cb8
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0xe07cd(%rip), %rsi     # 0x3e6468
movl $0xbb, %edx
callq 0x109670
movq 0x18(%rbx), %rdi
callq 0xd4ef4
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0xd97e0
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/clustered_set_uf.c
// Function: gt_clustered_set_union_find_cluster_num
GtUword gt_clustered_set_union_find_cluster_num(GtClusteredSet *cs,
                                                      GtUword e,
                                                      GT_UNUSED GtError *err
                                                      )
{
  gt_assert(cs);
  GtClusteredSetUF *cs_uf = (GtClusteredSetUF*) cs;
  if (SINGLETON(e))
    return CLUSTERNIL;
  else
    return cs_uf->cluster_elems[e].cluster_num;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x305d11
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0xd94c7
testb %al, %al
je 0x305d02
shlq $0x4, %r14
addq 0x10(%rbx), %r14
movq %r14, %rbx
jmp 0x305d06
addq $0x28, %rbx
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x8ca08
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/clustered_set_uf.c
// Function: gt_clustered_set_union_find_class
const GtClusteredSetClass* gt_clustered_set_union_find_class(void)
{

  static const GtClusteredSetClass *csc = NULL;
  gt_class_alloc_lock_enter();
  if (!csc) {
    csc = gt_clustered_set_class_new(sizeof (GtClusteredSetUF),
      gt_clustered_set_union_find_num_of_clusters,
      gt_clustered_set_union_find_merge_clusters,
      gt_clustered_set_union_find_delete,
      gt_clustered_set_union_find_iterator_new,
      gt_clustered_set_union_find_num_of_elements,
      gt_clustered_set_union_find_cluster_num);
  }
  gt_class_alloc_lock_leave();
  return csc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x1c3f46(%rip)    # 0x4c9fc8
jne 0x3060c3
leaq -0x3b2(%rip), %rax      # 0x305cd9
movq %rax, (%rsp)
leaq -0x3dd(%rip), %rsi      # 0x305cb9
leaq -0x387(%rip), %rdx      # 0x305d16
leaq -0x41d(%rip), %rcx      # 0x305c87
leaq -0x52b(%rip), %r8       # 0x305b80
leaq -0x3e9(%rip), %r9       # 0x305cc9
movl $0x38, %edi
callq 0x305a38
movq %rax, 0x1c3f05(%rip)    # 0x4c9fc8
callq 0xe6a19
movq 0x1c3ef9(%rip), %rax    # 0x4c9fc8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/clustered_set_uf.c
// Function: gt_clustered_set_union_find_new
GtClusteredSet*
gt_clustered_set_union_find_new(GtUword num_of_elems,
                                GT_UNUSED GtError *err)
{
  GtClusteredSet *cs;
  GtClusteredSetUF *cs_uf;
  cs = gt_clustered_set_create(gt_clustered_set_union_find_class());
  cs_uf = (GtClusteredSetUF*) cs;
  cs_uf->num_of_elems = num_of_elems;
  cs_uf->cluster_elems = gt_calloc(num_of_elems, sizeof (GtClusteredSetUFElem));
  cs_uf->cluster_info = gt_array_new(sizeof (GtClusteredSetUFClusterInfo));
  cs_uf->in_cluster = gt_bittab_new(num_of_elems);
  cs_uf->next_free_cluster_info = (GtUword) 0;

  return cs;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x306074
movq %rax, %rdi
callq 0x305a8e
movq %rax, %r14
movq %rbx, 0x28(%rax)
leaq 0xe0375(%rip), %rdx     # 0x3e6468
movl $0x10, %esi
movq %rbx, %rdi
movl $0x139, %ecx            # imm = 0x139
callq 0x1093ef
movq %rax, 0x10(%r14)
movl $0x18, %edi
callq 0xd46fc
movq %rax, 0x18(%r14)
movq %rbx, %rdi
callq 0xd90d0
movq %rax, 0x20(%r14)
movq $0x0, 0x30(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/coin_hmm.c
// Function: gt_coin_hmm_loaded
GtHMM* gt_coin_hmm_loaded(void)
{
  GtHMM *hmm;

  /* create the GtHMM */
  hmm = gt_hmm_new(COIN_NUM_OF_STATES, COIN_NUM_OF_SYMBOLS);

  /* set emmission probabilities */
  gt_hmm_set_emission_probability(hmm, COIN_FAIR, HEAD, 0.5);
  gt_hmm_set_emission_probability(hmm, COIN_FAIR, TAIL, 0.5);
  gt_hmm_set_emission_probability(hmm, COIN_LOADED, HEAD, 0.75);
  gt_hmm_set_emission_probability(hmm, COIN_LOADED, TAIL, 0.25);

  /* set transition probabilities */
  gt_hmm_set_transition_probability(hmm, COIN_FAIR, COIN_LOADED, 0.1);
  gt_hmm_set_transition_probability(hmm, COIN_LOADED, COIN_FAIR, 0.1);
  gt_hmm_set_missing_transition_probabilities(hmm);
  gt_assert(gt_hmm_is_valid(hmm));

  return hmm;
}

// Assembly:
pushq %rbx
movl $0x2, %edi
movl $0x2, %esi
callq 0x1582b8
movq %rax, %rbx
movsd 0x587b9(%rip), %xmm0    # 0x35ee78
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x15854c
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
movsd 0x5879b(%rip), %xmm0    # 0x35ee78
callq 0x15854c
movsd 0x7f786(%rip), %xmm0    # 0x385e70
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x15854c
movsd 0x5400f(%rip), %xmm0    # 0x35a710
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x15854c
movsd 0x50ae5(%rip), %xmm0    # 0x357200
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x1584d5
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
movsd 0x50ac4(%rip), %xmm0    # 0x357200
callq 0x1584d5
movq %rbx, %rdi
callq 0x158650
movq %rbx, %rdi
callq 0x1587b0
testb %al, %al
je 0x30675a
movq %rbx, %rax
popq %rbx
retq
callq 0x8ca7a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/coin_hmm.c
// Function: gt_coin_hmm_fair
GtHMM* gt_coin_hmm_fair(void)
{
  GtHMM *hmm;

  /* create the GtHMM */
  hmm = gt_hmm_new(COIN_NUM_OF_STATES, COIN_NUM_OF_SYMBOLS);

  /* set emmission probabilities */
  gt_hmm_set_emission_probability(hmm, COIN_FAIR, HEAD, 0.5);
  gt_hmm_set_emission_probability(hmm, COIN_FAIR, TAIL, 0.5);
  gt_hmm_set_emission_probability(hmm, COIN_LOADED, HEAD, 0.5);
  gt_hmm_set_emission_probability(hmm, COIN_LOADED, TAIL, 0.5);

  /* set transition probabilities */
  gt_hmm_set_transition_probability(hmm, COIN_FAIR, COIN_LOADED, 0.5);
  gt_hmm_set_transition_probability(hmm, COIN_LOADED, COIN_FAIR, 0.5);
  gt_hmm_set_missing_transition_probabilities(hmm);
  gt_assert(gt_hmm_is_valid(hmm));

  return hmm;
}

// Assembly:
pushq %rbx
movl $0x2, %edi
movl $0x2, %esi
callq 0x1582b8
movq %rax, %rbx
movsd 0x586fe(%rip), %xmm0    # 0x35ee78
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x15854c
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
movsd 0x586e0(%rip), %xmm0    # 0x35ee78
callq 0x15854c
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
movsd 0x586c9(%rip), %xmm0    # 0x35ee78
callq 0x15854c
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
movsd 0x586af(%rip), %xmm0    # 0x35ee78
callq 0x15854c
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
movsd 0x58698(%rip), %xmm0    # 0x35ee78
callq 0x1584d5
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
movsd 0x58681(%rip), %xmm0    # 0x35ee78
callq 0x1584d5
movq %rbx, %rdi
callq 0x158650
movq %rbx, %rdi
callq 0x1587b0
testb %al, %al
je 0x306815
movq %rbx, %rax
popq %rbx
retq
callq 0x8cab1
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/coin_hmm.c
// Function: gt_coin_hmm_alphabet
GtAlphabet* gt_coin_hmm_alphabet(void)
{
  GtAlphabet *a = gt_alphabet_new_empty();
  gt_alphabet_add_mapping(a, "Hh");
  gt_alphabet_add_mapping(a, "Tt");
  gt_assert(gt_alphabet_size(a) == 2);
  return a;
}

// Assembly:
pushq %rbx
callq 0xd32fd
movq %rax, %rbx
leaq 0xe0164(%rip), %rsi     # 0x3e698e
movq %rax, %rdi
callq 0xd30d9
leaq 0x756f5(%rip), %rsi     # 0x37bf2e
movq %rbx, %rdi
callq 0xd30d9
movq %rbx, %rdi
callq 0xd3724
cmpl $0x2, %eax
jne 0x306853
movq %rbx, %rax
popq %rbx
retq
callq 0x8cae8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/cstr_iterator.c
// Function: gt_cstr_iterator_reset
int gt_cstr_iterator_reset(GtCstrIterator *cstr_iterator,
                           GtError *err)
{
  gt_error_check(err);
  gt_assert(cstr_iterator && cstr_iterator->c_class);
  if (cstr_iterator->c_class->reset_func != NULL)
    return cstr_iterator->c_class->reset_func(cstr_iterator, err);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x3070eb
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x30711f
testq %r14, %r14
je 0x30711a
movq (%r14), %rax
testq %rax, %rax
je 0x30711a
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x307110
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x8d191
callq 0x8d15a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/cstr_iterator.c
// Function: gt_cstr_iterator_next
int gt_cstr_iterator_next(GtCstrIterator *cstr_iterator,
                          const char **string,
                          GtError *err)
{
  gt_error_check(err);
  gt_assert(cstr_iterator && cstr_iterator->c_class);
  if (cstr_iterator->c_class->next_func != NULL)
    return cstr_iterator->c_class->next_func(cstr_iterator,
                                             string,
                                             err);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x307143
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x307175
testq %r15, %r15
je 0x307170
movq (%r15), %rax
testq %rax, %rax
je 0x307170
movq (%rax), %rax
testq %rax, %rax
je 0x307168
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x8d1ff
callq 0x8d1c8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/cstr_iterator.c
// Function: gt_cstr_iterator_delete
void gt_cstr_iterator_delete(GtCstrIterator *cstr_iterator)
{
  if (cstr_iterator != NULL) {
    gt_assert(cstr_iterator->c_class != NULL);
    if (cstr_iterator->c_class->delete_func != NULL)
      cstr_iterator->c_class->delete_func(cstr_iterator);
    gt_free(cstr_iterator);
  }
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x3071ae
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x3071b0
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x307199
movq %rbx, %rdi
callq *%rax
leaq 0xdfcc7(%rip), %rsi     # 0x3e6e67
movq %rbx, %rdi
movl $0x36, %edx
popq %rbx
jmp 0x109670
popq %rbx
retq
callq 0x8d236
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/cstr_iterator.c
// Function: gt_cstr_iterator_class_new
GtCstrIteratorClass *
gt_cstr_iterator_class_new(size_t size,
                           GtCstrIteratorNextFunc next,
                           GtCstrIteratorResetFunc reset,
                           GtCstrIteratorDeleteFunc delete)
{
  GtCstrIteratorClass *cstr_iterator_c;
  gt_assert(size != 0);
  cstr_iterator_c = gt_class_alloc(sizeof (*cstr_iterator_c));
  cstr_iterator_c->size = size;
  cstr_iterator_c->next_func = next;
  cstr_iterator_c->reset_func = reset;
  cstr_iterator_c->delete_func = delete;
  return cstr_iterator_c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3071f3
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x20, %edi
callq 0x301854
movq %r12, 0x18(%rax)
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x8d26d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/cstr_iterator.c
// Function: gt_cstr_iterator_create
GtCstrIterator *
gt_cstr_iterator_create(const GtCstrIteratorClass *cstr_iterator_c)
{
  GtCstrIterator *cstr_iterator;
  gt_assert(cstr_iterator_c && cstr_iterator_c->size);
  cstr_iterator = gt_calloc((size_t) 1, cstr_iterator_c->size);
  cstr_iterator->c_class = cstr_iterator_c;
  return cstr_iterator;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x307225
movq %rdi, %rbx
movq 0x18(%rdi), %rsi
testq %rsi, %rsi
je 0x307225
leaq 0xdfc56(%rip), %rdx     # 0x3e6e67
movl $0x1, %edi
movl $0x4f, %ecx
callq 0x1093ef
movq %rbx, (%rax)
popq %rbx
retq
callq 0x8d2a4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/dice_hmm.c
// Function: gt_dice_hmm_alphabet
GtAlphabet* gt_dice_hmm_alphabet(void)
{
  GtAlphabet *a = gt_alphabet_new_empty();
  gt_alphabet_add_mapping(a, "1");
  gt_alphabet_add_mapping(a, "2");
  gt_alphabet_add_mapping(a, "3");
  gt_alphabet_add_mapping(a, "4");
  gt_alphabet_add_mapping(a, "5");
  gt_alphabet_add_mapping(a, "6");
  gt_assert(gt_alphabet_size(a) == 6);
  return a;
}

// Assembly:
pushq %rbx
callq 0xd32fd
movq %rax, %rbx
leaq 0x706c4(%rip), %rsi     # 0x377c6a
movq %rax, %rdi
callq 0xd30d9
leaq 0x8ed10(%rip), %rsi     # 0x3962c5
movq %rbx, %rdi
callq 0xd30d9
leaq 0x8ee6f(%rip), %rsi     # 0x396433
movq %rbx, %rdi
callq 0xd30d9
leaq 0x697a5(%rip), %rsi     # 0x370d78
movq %rbx, %rdi
callq 0xd30d9
leaq 0x8ef2d(%rip), %rsi     # 0x39650f
movq %rbx, %rdi
callq 0xd30d9
leaq 0xb0edc(%rip), %rsi     # 0x3b84cd
movq %rbx, %rdi
callq 0xd30d9
movq %rbx, %rdi
callq 0xd3724
cmpl $0x6, %eax
jne 0x30760b
movq %rbx, %rax
popq %rbx
retq
callq 0x8d3b7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/fasta_header_iterator.c
// Function: gt_fasta_header_iterator_class
const GtCstrIteratorClass* gt_fasta_header_iterator_class(void)
{
  static const GtCstrIteratorClass *sic = NULL;
  gt_class_alloc_lock_enter();
  if (sic == NULL) {
    sic = gt_cstr_iterator_class_new(sizeof (GtFastaHeaderIterator),
                                     gt_fasta_header_iterator_next,
                                     gt_fasta_header_iterator_reset,
                                     gt_fasta_header_iterator_delete);
  }
  gt_class_alloc_lock_leave();
  return sic;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x1c221a(%rip)    # 0x4c9fe0
jne 0x307dee
leaq 0x2d(%rip), %rsi        # 0x307dfc
leaq 0x68(%rip), %rdx        # 0x307e3e
leaq 0xcf(%rip), %rcx        # 0x307eac
movl $0x20, %edi
callq 0x3071b5
movq %rax, 0x1c21f2(%rip)    # 0x4c9fe0
callq 0xe6a19
movq 0x1c21e6(%rip), %rax    # 0x4c9fe0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/fasta_header_iterator.c
// Function: gt_fasta_header_iterator_reset
static int gt_fasta_header_iterator_reset(GtCstrIterator *cstr_iterator,
                                    GtError *err)
{
  GtFastaHeaderIterator *fhi = gt_fasta_header_iterator_cast(cstr_iterator);
  gt_error_check(err);
  gt_seq_iterator_delete(fhi->seq_iter);
  fhi->seq_iter = gt_seq_iterator_sequence_buffer_new(fhi->filenametab, err);
  if (fhi->seq_iter == NULL)
    return -1;
  gt_seq_iterator_set_sequence_output(fhi->seq_iter, false);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x307db8
movq %rax, %rdi
movq %r14, %rsi
callq 0x30722a
movq %rax, %r14
testq %rbx, %rbx
je 0x307e6c
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x307ea7
movq 0x10(%r14), %rdi
callq 0x119a53
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x11a648
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x307e98
xorl %ebx, %ebx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1199ec
jmp 0x307e9d
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x8d5ac
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/fasta_header_iterator.c
// Function: gt_fasta_header_iterator_new
GtCstrIterator* gt_fasta_header_iterator_new(GtStrArray *filenametab,
                                               GtError *err)
{
  GtCstrIterator *cstr_iterator =
    gt_cstr_iterator_create(gt_fasta_header_iterator_class());
  GtFastaHeaderIterator *fhi = gt_fasta_header_iterator_cast(cstr_iterator);
  fhi->filenametab = gt_str_array_ref(filenametab);
  if (gt_fasta_header_iterator_reset(cstr_iterator, err) != 0)
    return NULL;
  return cstr_iterator;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x307db8
movq %rax, %rdi
callq 0x3071f8
movq %rax, %r15
callq 0x307db8
movq %rax, %rdi
movq %r15, %rsi
callq 0x30722a
movq %rax, %r12
movq %r14, %rdi
callq 0x121b87
movq %rax, 0x18(%r12)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x307e3e
xorl %ecx, %ecx
testl %eax, %eax
cmoveq %r15, %rcx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/globalchaining.c
// Function: retracepreviousinchain
static void retracepreviousinchain(GtChain *chain, GtChaininfo *chaininfo,
                                   GtUword num_of_fragments,
                                   GtUword retracestart)
{
  GtUword fragnum, idx, lengthofchain;

  for (lengthofchain = 0, fragnum = retracestart;
       fragnum != UNDEFPREVIOUS; lengthofchain++) {
    gt_chain_add_fragnum(chain, UNDEFPREVIOUS); /* add dummy */
    fragnum = chaininfo[fragnum].previousinchain;
  }
  fragnum = retracestart;
  idx = lengthofchain;
  while (fragnum != UNDEFPREVIOUS) {
    gt_assert(idx != 0);
    idx--;
    gt_chain_set_fragnum(chain, idx, fragnum); /* set dummy */
    fragnum = chaininfo[fragnum].previousinchain;
  }
  gt_assert(idx == 0);
  gt_assert(gt_chain_size(chain) == lengthofchain);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %ebp, %ebp
cmpq %rdx, %rcx
je 0x30906b
movq %r14, %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0x305964
shlq $0x4, %r13
movq (%r12,%r13), %r13
incq %rbp
cmpq %r15, %r13
jne 0x309050
movq %rbp, %r13
cmpq %r15, %r14
je 0x309097
movq %rbp, %r13
subq $0x1, %r13
jb 0x3090b8
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x305985
shlq $0x4, %r14
movq (%r12,%r14), %r14
cmpq %r15, %r14
jne 0x309076
testq %r13, %r13
jne 0x3090bd
movq %rbx, %rdi
callq 0x3059fd
cmpq %rbp, %rax
jne 0x3090c2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x8db8b
callq 0x8dbc4
callq 0x8dbfd
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/intset_16.c
// Function: gt_intset_16_new
GtIntset* gt_intset_16_new(GtUword maxelement, GtUword num_of_elems)
{
  GtIntset *intset;
  GtIntset16 *intset_16;
  GtIntsetMembers *members;
  GtUword idx;

  gt_assert(num_of_elems != 0);

  intset = gt_intset_create(gt_intset_16_class());
  intset_16 = gt_intset_16_cast(intset);
  members = intset->members;

  members->currentsectionnum = 0;
  members->maxelement = maxelement;
  members->nextfree = 0;
  members->num_of_elems = num_of_elems;
  members->previouselem = ULONG_MAX;
  members->refcount = 0;

  members->logsectionsize = GT_BITS_FOR_TYPE(uint16_t);
  members->numofsections = GT_ELEM2SECTION_M(maxelement) + 1;

  intset_16->elements =
    gt_malloc(sizeof (*intset_16->elements) * num_of_elems);

  members->sectionstart = gt_malloc(sizeof (*members->sectionstart) *
                                    (members->numofsections + 1));

  members->sectionstart[0] = 0;
  for (idx = (GtUword) 1; idx <= members->numofsections; idx++) {
    members->sectionstart[idx] = num_of_elems;
  }
  return intset;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x3091a1
movq %rsi, %rbx
movq %rdi, %r15
callq 0x3091a6
movq %rax, %rdi
callq 0x15e23c
movq %rax, %r14
callq 0x3091a6
movq %rax, %rdi
movq %r14, %rsi
callq 0x15e2b0
movq %rax, %r12
movq 0x8(%r14), %r13
xorl %ebp, %ebp
movq %rbp, 0x10(%r13)
movq %r15, 0x18(%r13)
movq %rbp, 0x20(%r13)
movq %rbx, 0x28(%r13)
movq $-0x1, 0x38(%r13)
movq %rbp, 0x40(%r13)
movq $0x10, 0x8(%r13)
shrq $0x10, %r15
incq %r15
movq %r15, 0x30(%r13)
leaq (%rbx,%rbx), %rdi
leaq 0xde64b(%rip), %r15     # 0x3e7790
movq %r15, %rsi
movl $0x4c, %edx
callq 0x1092b2
movq %rax, 0x10(%r12)
movq 0x30(%r13), %rax
leaq 0x8(,%rax,8), %rdi
movq %r15, %rsi
movl $0x4f, %edx
callq 0x1092b2
movq %rax, (%r13)
movq %rbp, (%rax)
cmpq %rbp, 0x30(%r13)
je 0x30918f
movl $0x1, %ecx
movq %rbx, (%rax,%rcx,8)
incq %rcx
cmpq 0x30(%r13), %rcx
jbe 0x309182
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x8dc36
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/intset_16.c
// Function: gt_intset_16_write
GtIntset *gt_intset_16_write(GtIntset *intset, FILE *fp, GtError *err)
{
  gt_assert(intset != NULL);
  gt_assert(fp != NULL);
  gt_error_check(err);
  return gt_intset_16_io(intset, fp, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x30990e
movq %rsi, %r14
testq %rsi, %rsi
je 0x309913
movq %rdx, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x3098fb
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x309918
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x309469
callq 0x8ddfc
callq 0x8ddc3
callq 0x8dd8a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/intset_16.c
// Function: gt_intset_16_add
void gt_intset_16_add(GtIntset *intset, GtUword elem)
{
  GtIntset16 *intset_16 = gt_intset_16_cast(intset);
  GtIntsetMembers *members = intset->members;
  GtUword *sectionstart = members->sectionstart;
  gt_assert(members->nextfree < members->num_of_elems);
  gt_assert(elem <= members->maxelement);
  gt_assert(members->previouselem == ULONG_MAX || members->previouselem < elem);
  while (elem >= GT_SECTIONMINELEM(members->currentsectionnum + 1)) {
    gt_assert(members->currentsectionnum < members->numofsections);
    sectionstart[members->currentsectionnum + 1] = members->nextfree;
    members->currentsectionnum++;
  }
  gt_assert(GT_SECTIONMINELEM(members->currentsectionnum) <= elem &&
            elem < GT_SECTIONMINELEM(members->currentsectionnum+1) &&
            GT_ELEM2SECTION_M(elem) == members->currentsectionnum);
  intset_16->elements[members->nextfree++] = (uint16_t) elem;
  members->previouselem = elem;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3091a6
movq %rax, %rdi
movq %r14, %rsi
callq 0x15e2b0
movq 0x8(%r14), %rdx
movq 0x20(%rdx), %rcx
cmpq 0x28(%rdx), %rcx
jae 0x3099f0
cmpq %rbx, 0x18(%rdx)
jb 0x3099f5
movq 0x38(%rdx), %rcx
cmpq $-0x1, %rcx
setne %sil
cmpq %rbx, %rcx
setae %cl
testb %cl, %sil
jne 0x3099fa
movq 0x8(%rdx), %rcx
movq 0x10(%rdx), %rsi
leaq 0x1(%rsi), %rdi
movq %rdi, %r8
shlq %cl, %r8
cmpq %rbx, %r8
ja 0x3099b5
movq (%rdx), %r8
cmpq 0x30(%rdx), %rsi
jae 0x3099eb
movq 0x20(%rdx), %rcx
movq %rcx, (%r8,%rdi,8)
movq 0x8(%rdx), %rcx
movq 0x10(%rdx), %rdi
leaq 0x1(%rdi), %rsi
movq %rsi, 0x10(%rdx)
addq $0x2, %rdi
movq %rdi, %r9
shlq %cl, %r9
cmpq %rbx, %r9
jbe 0x309988
movq %rsi, %r8
shlq %cl, %r8
movq %rbx, %rdi
shrq %cl, %rdi
cmpq %rbx, %r8
ja 0x3099ff
cmpq %rsi, %rdi
jne 0x3099ff
movq 0x10(%rax), %rax
movq 0x20(%rdx), %rcx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x20(%rdx)
movw %bx, (%rax,%rcx,2)
movq %rbx, 0x38(%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x8dea7
callq 0x8de35
callq 0x8df19
callq 0x8de6e
callq 0x8dee0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/intset_16.c
// Function: gt_intset_16_get
GtUword gt_intset_16_get(GtIntset *intset, GtUword idx)
{
  GtUword quotient;
  GtIntset16 *intset_16 = gt_intset_16_cast(intset);
  GtIntsetMembers *members = intset->members;
  GtUword *sectionstart = members->sectionstart;
  gt_assert(idx < members->nextfree);

  quotient = gt_intset_16_binarysearch_sec_idx_largest_leq(
                                      sectionstart,
                                      sectionstart + members->numofsections - 1,
                                      idx);
  return (quotient << members->logsectionsize) +
         intset_16->elements[idx];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3091a6
movq %rax, %rdi
movq %r14, %rsi
callq 0x15e2b0
movq 0x8(%r14), %rcx
cmpq %rbx, 0x20(%rcx)
jbe 0x309ab7
movq (%rcx), %rsi
movq 0x30(%rcx), %rdx
leaq (%rsi,%rdx,8), %rdi
addq $-0x8, %rdi
xorl %edx, %edx
cmpq %rbx, (%rsi)
cmovbeq %rsi, %rdx
cmpq %rdi, %rsi
jae 0x309a77
movq %rsi, %r8
movq %rdi, %r9
subq %r8, %r9
sarq $0x4, %r9
cmpq %rbx, (%r8,%r9,8)
jb 0x309a66
leaq (%r8,%r9,8), %rdi
addq $-0x8, %rdi
jmp 0x309a72
leaq (%r8,%r9,8), %rdx
leaq (%r8,%r9,8), %r8
addq $0x8, %r8
cmpq %rdi, %r8
jb 0x309a4c
testq %rdx, %rdx
je 0x309abc
movq %rdx, %rdi
subq %rsi, %rdi
addq $-0x8, %rdi
addq $0x8, %rdx
addq $0x8, %rdi
leaq 0x8(%rdx), %rsi
cmpq %rbx, (%rdx)
movq %rsi, %rdx
jbe 0x309a8a
sarq $0x3, %rdi
movb 0x8(%rcx), %cl
shlq %cl, %rdi
movq 0x10(%rax), %rax
movzwl (%rax,%rbx,2), %eax
addq %rdi, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x8df52
callq 0x8df8b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/intset_16.c
// Function: gt_intset_16_is_member
bool gt_intset_16_is_member(GtIntset *intset, GtUword elem)
{
  GtIntset16 *intset_16 = gt_intset_16_cast(intset);
  GtIntsetMembers *members = intset->members;
  GtUword *sectionstart = members->sectionstart;
  if (elem <= members->maxelement)
  {
    const GtUword sectionnum = GT_ELEM2SECTION_M(elem);

    if (sectionstart[sectionnum] < sectionstart[sectionnum+1]) {
      return gt_intset_16_binarysearch_is_member(
                           intset_16->elements + sectionstart[sectionnum],
                           intset_16->elements + sectionstart[sectionnum+1] - 1,
                           (uint64_t) elem);
    }
  }
  return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3091a6
movq %rax, %rdi
movq %r14, %rsi
callq 0x15e2b0
movq %rax, %rdx
movq 0x8(%r14), %rax
cmpq %rbx, 0x18(%rax)
jb 0x309b65
movb 0x8(%rax), %cl
movq %rbx, %rsi
shrq %cl, %rsi
movq (%rax), %rax
movq (%rax,%rsi,8), %rcx
movq 0x8(%rax,%rsi,8), %rsi
cmpq %rsi, %rcx
jae 0x309b60
movq 0x10(%rdx), %rax
leaq (%rax,%rcx,2), %rdi
leaq (%rax,%rsi,2), %rdx
addq $-0x2, %rdx
cmpq %rdx, %rdi
setbe %al
ja 0x309b60
movq %rdx, %r8
subq %rdi, %r8
sarq $0x2, %r8
leaq (%rdi,%r8,2), %r8
cmpw %bx, (%r8)
jbe 0x309b55
addq $-0x2, %r8
movq %r8, %rdx
jmp 0x309b30
jae 0x309b60
addq $0x2, %r8
movq %r8, %rdi
jmp 0x309b30
cmpq %rsi, %rcx
jb 0x309b67
xorl %eax, %eax
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/intset_16.c
// Function: gt_intset_16_get_idx_smallest_geq
GtUword gt_intset_16_get_idx_smallest_geq(GtIntset *intset, GtUword value)
{
  GtIntset16 *intset_16 = gt_intset_16_cast(intset);
  GtIntsetMembers *members = intset->members;

  GtUword sectionnum = GT_ELEM2SECTION_M(value);

  if (value > members->previouselem)
    return members->num_of_elems;

  gt_assert(value <= members->maxelement);

  if (members->sectionstart[sectionnum] < members->sectionstart[sectionnum+1]) {
    return members->sectionstart[sectionnum] +
           gt_intset_16_binarysearch_idx_sm_geq(
                  intset_16->elements + members->sectionstart[sectionnum],
                  intset_16->elements + members->sectionstart[sectionnum+1] - 1,
                  (uint16_t) value);
  }
  return members->sectionstart[sectionnum];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3091a6
movq %rax, %rdi
movq %r14, %rsi
callq 0x15e2b0
movq 0x8(%r14), %rdx
movb 0x8(%rdx), %cl
movq %rbx, %rsi
shrq %cl, %rsi
cmpq %rbx, 0x38(%rdx)
jae 0x309ba7
movq 0x28(%rdx), %rax
jmp 0x309c2d
cmpq %rbx, 0x18(%rdx)
jb 0x309c35
movq %rax, %rcx
movq (%rdx), %rdx
movq (%rdx,%rsi,8), %rax
movq 0x8(%rdx,%rsi,8), %rdx
cmpq %rdx, %rax
jae 0x309c2d
movq 0x10(%rcx), %rsi
leaq (%rsi,%rax,2), %rcx
leaq (%rsi,%rdx,2), %rdx
addq $-0x2, %rdx
cmpq %rdx, %rcx
ja 0x309c3a
cmpw %bx, (%rcx)
jae 0x309bf2
cmpw %bx, (%rdx)
jae 0x309bf6
subq %rcx, %rdx
sarq %rdx
incq %rdx
movq %rdx, %rsi
jmp 0x309c2a
xorl %esi, %esi
jmp 0x309c2a
movq %rcx, %rsi
cmpq %rdx, %rcx
jae 0x309c24
movq %rcx, %rsi
movq %rdx, %rdi
subq %rsi, %rdi
sarq $0x2, %rdi
cmpw %bx, (%rsi,%rdi,2)
jb 0x309c17
leaq (%rsi,%rdi,2), %rdx
jmp 0x309c1f
leaq (%rsi,%rdi,2), %rsi
addq $0x2, %rsi
cmpq %rdx, %rsi
jb 0x309c01
subq %rcx, %rsi
sarq %rsi
addq %rsi, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x8dffd
callq 0x8dfc4