LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/aligned_segment.c
// Function: gt_aligned_segment_ungap_refregion
void gt_aligned_segment_ungap_refregion(GtAlignedSegment *as)
{
  GtUword pos, srcpos;
  gt_assert(as != NULL);
  gt_assert(as->r != NULL);
  for (srcpos = 0, pos = 0; srcpos < as->alen; srcpos++)
  {
    if (as->r[srcpos] != '-')
    {
      if (pos != srcpos)
      {
        gt_assert(pos < srcpos);
        as->r[pos] = as->r[srcpos];
      }
      pos++;
    }
  }
  gt_assert(pos <= as->alen + 1UL);
  if (pos <= as->alen)
    as->r[pos] = '\0';
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x2fa965
cmpq $0x0, 0x10(%rdi)
je 0x2fa96a
movq 0x20(%rdi), %rcx
testq %rcx, %rcx
je 0x2fa954
xorl %edx, %edx
xorl %eax, %eax
movq 0x10(%rdi), %rsi
movb (%rsi,%rdx), %r8b
cmpb $0x2d, %r8b
je 0x2fa93c
cmpq %rax, %rdx
je 0x2fa939
jbe 0x2fa960
movb %r8b, (%rsi,%rax)
movq 0x20(%rdi), %rcx
incq %rax
incq %rdx
cmpq %rcx, %rdx
jb 0x2fa91c
leaq 0x1(%rcx), %rdx
cmpq %rdx, %rax
ja 0x2fa96f
cmpq %rcx, %rax
jbe 0x2fa956
jmp 0x2fa95e
xorl %eax, %eax
movq 0x10(%rdi), %rcx
movb $0x0, (%rcx,%rax)
popq %rax
retq
callq 0x8a07d
callq 0x8a128
callq 0x8a0ef
callq 0x8a0b6
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/aligned_segment.c
// Function: gt_aligned_segment_ungap_seq_and_qual
void gt_aligned_segment_ungap_seq_and_qual(GtAlignedSegment *as)
{
  GtUword pos, srcpos;
  gt_assert(as != NULL);
  for (srcpos = 0, pos = 0; srcpos < as->alen; srcpos++)
  {
    if (as->s[srcpos] != '-')
    {
      if (pos != srcpos)
      {
        gt_assert(pos < srcpos);
        as->s[pos] = as->s[srcpos];
        gt_assert(as->q[srcpos] != GT_UNDEF_CHAR);
        as->q[pos] = as->q[srcpos];
      }
      pos++;
    }
  }
  gt_assert(pos <= as->alen + 1UL);
  if (pos <= as->alen)
  {
    as->s[pos] = '\0';
    as->q[pos] = '\0';
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x2fa9ed
movq 0x20(%rdi), %rdx
testq %rdx, %rdx
je 0x2fa9d0
xorl %ecx, %ecx
xorl %eax, %eax
movq (%rdi), %rsi
movb (%rsi,%rcx), %r8b
cmpb $0x2d, %r8b
je 0x2fa9b8
cmpq %rax, %rcx
je 0x2fa9b5
jbe 0x2fa9e3
movb %r8b, (%rsi,%rax)
movq 0x8(%rdi), %rdx
movb (%rdx,%rcx), %sil
cmpb $0x7f, %sil
je 0x2fa9e8
movb %sil, (%rdx,%rax)
movq 0x20(%rdi), %rdx
incq %rax
incq %rcx
cmpq %rdx, %rcx
jb 0x2fa987
leaq 0x1(%rdx), %rcx
cmpq %rcx, %rax
ja 0x2fa9f2
cmpq %rdx, %rax
jbe 0x2fa9d2
jmp 0x2fa9e1
xorl %eax, %eax
movq (%rdi), %rcx
xorl %edx, %edx
movb %dl, (%rcx,%rax)
movq 0x8(%rdi), %rcx
movb %dl, (%rcx,%rax)
popq %rax
retq
callq 0x8a161
callq 0x8a19a
callq 0x8a20c
callq 0x8a1d3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/aligned_segment.c
// Function: gt_aligned_segment_delete
void gt_aligned_segment_delete(GtAlignedSegment *as)
{
  if (as != NULL)
  {
    gt_free(as->s);
    gt_free(as->q);
    gt_free(as->r);
    gt_free(as->d);
    gt_free(as->s_orig);
    gt_free(as);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x2faad2
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xe189a(%rip), %r14     # 0x3dc304
movq %r14, %rsi
movl $0x1a1, %edx            # imm = 0x1A1
callq 0x1045eb
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x1a2, %edx            # imm = 0x1A2
callq 0x1045eb
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0x1a3, %edx            # imm = 0x1A3
callq 0x1045eb
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movl $0x1a4, %edx            # imm = 0x1A4
callq 0x1045eb
movq 0x40(%rbx), %rdi
movq %r14, %rsi
movl $0x1a5, %edx            # imm = 0x1A5
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1a6, %edx            # imm = 0x1A6
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/aligned_segment.c
// Function: gt_aligned_segment_assign_refregion_chars
void gt_aligned_segment_assign_refregion_chars(GtAlignedSegment *as,
    GtEncseq *encseq)
{
  GtUword i, pos;
  gt_assert(as != NULL);
  gt_assert(as->r != NULL);
  for (pos = as->r_left, i = 0; i < as->alen; i++)
  {
    if (as->r[i] == '?')
    {
      as->r[i] = gt_encseq_get_decoded_char(encseq, pos, GT_READMODE_FORWARD);
    }
    if (as->r[i] != '-')
      pos++;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2fab49
movq %rdi, %r14
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x2fab4e
movq 0x20(%r14), %rcx
testq %rcx, %rcx
je 0x2fab3d
movq %rsi, %rbx
movq 0x28(%r14), %r15
xorl %r12d, %r12d
movb (%rax,%r12), %dl
cmpb $0x3f, %dl
jne 0x2fab29
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xe7e3c
movq 0x10(%r14), %rcx
movb %al, (%rcx,%r12)
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movb (%rax,%r12), %dl
xorl %esi, %esi
cmpb $0x2d, %dl
setne %sil
addq %rsi, %r15
incq %r12
cmpq %rcx, %r12
jb 0x2faaff
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x8a3d4
callq 0x8a39b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/aligned_segment.c
// Function: gt_aligned_segment_show
void gt_aligned_segment_show(GtAlignedSegment *as, GtFile *outfp)
{
  gt_assert(as != NULL);
  if (as->d != NULL)
    gt_file_xprintf(outfp, "D: %s\n", as->d);
  if (as->r != NULL)
    gt_file_xprintf(outfp, "R: %s\n", as->r);
  if (as->s_orig != NULL)
    gt_file_xprintf(outfp, "O: %s\n", as->s_orig);
  gt_file_xprintf(outfp, "S: %s\n", as->s);
  gt_file_xprintf(outfp, "Q: %s\n", as->q);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2fabe4
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdx
testq %rdx, %rdx
je 0x2fab80
leaq 0xe1b50(%rip), %rsi     # 0x3dc6c6
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfee51
movq 0x10(%r14), %rdx
testq %rdx, %rdx
je 0x2fab9a
leaq 0xe1b3d(%rip), %rsi     # 0x3dc6cd
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfee51
movq 0x40(%r14), %rdx
testq %rdx, %rdx
je 0x2fabb4
leaq 0xe1b2a(%rip), %rsi     # 0x3dc6d4
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfee51
movq (%r14), %rdx
leaq 0x704fe(%rip), %rsi     # 0x36b0bc
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfee51
movq 0x8(%r14), %rdx
leaq 0xe1b08(%rip), %rsi     # 0x3dc6db
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xfee51
callq 0x8a40d
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rdi), %r13
leaq 0x18(%rsp), %r12
movq %r13, (%r12)
movq %rsi, %rdi
callq 0x1701e2
movq %rax, %rbx
subq %rax, %r13
movq (%r14), %rax
addq %r13, %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
addq 0x8(%r14), %r13
movq %r13, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rdx
callq 0x17025c
movq 0x20(%r14), %rax
cmpq (%r12), %rax
jne 0x2facae
subq %rbx, %rax
addq (%r14), %rax
cmpq %rax, 0x10(%rsp)
jne 0x2facb3
leaq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x170377
movq 0x20(%r14), %rax
cmpq (%r12), %rax
jne 0x2facb8
subq %rbx, %rax
addq 0x8(%r14), %rax
cmpq %rax, 0x8(%rsp)
jne 0x2facbd
callq 0xd0ece
movq %rax, %r14
movq 0x10(%rsp), %rdx
movq %rax, %rdi
movq %rdx, %rsi
movq %rbx, %rcx
callq 0xd1494
movq %r14, %rdi
callq 0xd0e1c
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x8a446
callq 0x8a47d
callq 0x8a4b4
callq 0x8a4eb
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xe1b15(%rip), %rsi     # 0x3dc7f1
movl $0x50, %edi
movl $0x31, %edx
callq 0x104226
movq %rax, %rbx
callq 0xe3e95
movq %rax, 0x28(%rbx)
movb $0x0, 0x4c(%rbx)
movq %r12, %rdi
callq 0xff6cf
testq %rax, %rax
js 0x2fad6e
movq %rax, 0x8(%rbx)
movq %r12, %rdi
callq 0xe4290
movq %rax, 0x38(%rbx)
movq %r15, 0x20(%rbx)
movq 0x8(%rbx), %rax
movq 0x28(%rbx), %rcx
imulq %rcx, %r15
cmpq %r15, %rax
jae 0x2fad39
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 0x2fad73
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 0x8a522
// File: /workspace/github_c_makefile_star2_O3/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 0x2fae09
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %r15
movq %rsi, %rax
xorl %edx, %edx
divq %r15
testq %rdx, %rdx
jne 0x2fae0e
imulq 0x20(%rbx), %r15
movq %r14, (%rbx)
movq 0x40(%rbx), %rdi
callq 0xfdc54
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
leaq (%rcx,%r15), %rdx
cmpq %rax, %rdx
jbe 0x2fadcf
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 0xe1a17(%rip), %rcx     # 0x3dc7f1
movq %r15, %rsi
movq %r14, %rdx
movl $0x5d, %r8d
callq 0xfdbac
movq %rax, 0x40(%rbx)
testq %rax, %rax
je 0x2fae13
movl $0x0, 0x48(%rbx)
movq $0x0, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x8a54d
callq 0x8a584
callq 0x8a5bb
// File: /workspace/github_c_makefile_star2_O3/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 0x2fae64
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
decq %rcx
cmpq %rcx, %rax
jae 0x2fae48
movl $0x0, 0x48(%rbx)
incq %rax
movq %rax, 0x18(%rbx)
jmp 0x2fae64
xorl %eax, %eax
cmpb $0x0, 0x4c(%rbx)
jne 0x2fae91
movq 0x20(%rbx), %rsi
imulq 0x28(%rbx), %rsi
addq (%rbx), %rsi
movq %rbx, %rdi
callq 0x2fad73
movq 0x18(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x2fae99
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 0x8a5f2
// File: /workspace/github_c_makefile_star2_O3/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 0x2faef4
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rsi
leaq 0xe1a1b(%rip), %rdi     # 0x3dc8d0
xorl %eax, %eax
callq 0x103d72
movq 0x40(%rbx), %rdi
callq 0xfdc54
movq 0x38(%rbx), %rdi
leaq 0xe1921(%rip), %r14     # 0x3dc7f1
movq %r14, %rsi
movl $0x86, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x87, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x2faf4a
movq %rdi, %rbx
leaq 0xe19e7(%rip), %rdx     # 0x3dc8f2
movl $0x1, %edi
movl $0x28, %esi
movl $0x27, %ecx
callq 0x10436a
movq %rax, %r14
movl $0x40, 0x20(%rax)
movq %rbx, (%rax)
xorl %eax, %eax
movq %rax, 0x18(%r14)
movq %rax, 0x8(%r14)
callq 0xe3e95
movq %rax, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x8a629
// File: /workspace/github_c_makefile_star2_O3/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 0x2faf98
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 0x11f89c
movl $0x40, %ecx
subl %ebp, %ecx
addq $0x40, 0x8(%r14)
xorl %eax, %eax
jmp 0x2faf9c
movq 0x18(%r14), %rax
shlq %cl, %rbx
movl %ecx, 0x20(%r14)
orq %rax, %rbx
movq %rbx, 0x18(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd6f10
testq %rax, %rax
je 0x2fb031
movq %rax, %r15
leaq 0x18(%r14), %r12
xorl %r13d, %r13d
movl 0x20(%r14), %eax
testl %eax, %eax
jne 0x2fb004
movq (%r14), %rcx
movl $0x8, %esi
movl $0x1, %edx
movq %r12, %rdi
callq 0x11f89c
movq $0x0, 0x18(%r14)
addq $0x40, 0x8(%r14)
movl $0x40, %eax
decl %eax
movl %eax, 0x20(%r14)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xd6e4a
testb %al, %al
je 0x2fb029
movb 0x20(%r14), %cl
movl $0x1, %eax
shlq %cl, %rax
orq %rax, 0x18(%r14)
incq %r13
cmpq %r13, %r15
jne 0x2fafd5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2fb07e
movq %rdi, %rbx
addq $0x18, %rdi
movq (%rbx), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x11f89c
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 0x8a660
// File: /workspace/github_c_makefile_star2_O3/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 0x11f89c
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 0x2fb102
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 0x11f87a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2fbcbb
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0xd24e0
cmpq %r14, %rax
jbe 0x2fbcc0
movq (%r15), %rdi
callq 0xd23eb
movq %rbx, (%rax,%r14,8)
popq %rbx
popq %r14
popq %r15
retq
callq 0x8ab67
callq 0x8ab30
// File: /workspace/github_c_makefile_star2_O3/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 0x2f7c10
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_O3/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 0x2fbdbe
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x2fbdbe
leaq 0xe0f78(%rip), %rdx     # 0x3dcd22
movl $0x1, %edi
movl $0x2f, %ecx
callq 0x10436a
movq %rbx, (%rax)
popq %rbx
retq
callq 0x8ac43
// File: /workspace/github_c_makefile_star2_O3/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 0x2fbdf2
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x2fbddd
movq %rbx, %rdi
callq *%rax
leaq 0xe0f3e(%rip), %rsi     # 0x3dcd22
movq %rbx, %rdi
movl $0x39, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2fbf86
movq %rsi, %r15
movq %rdi, %r14
leaq 0xe0ec9(%rip), %rdx     # 0x3dcd68
movl $0x1, %edi
movl $0x18, %esi
movl $0x97, %ecx
callq 0x10436a
movq %rax, %rbx
movq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0xd6e4a
testb %al, %al
je 0x2fbf34
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0xd2207
cmpq $0x0, 0x10(%rax)
je 0x2fbf67
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0xd2207
movq %rax, %r15
movq 0x10(%rax), %rdi
movq %rdi, 0x8(%rbx)
movq $0x0, (%rbx)
leaq 0xe0e66(%rip), %rdx     # 0x3dcd68
movl $0x8, %esi
movl $0xa6, %ecx
callq 0x10436a
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 0x2fbf1c
jmp 0x2fbf7d
movq $0x1, 0x8(%rbx)
movq $0x0, (%rbx)
leaq 0xe0e1e(%rip), %rdx     # 0x3dcd68
movl $0x1, %edi
movl $0x8, %esi
movl $0x9c, %ecx
callq 0x10436a
movq %rax, 0x10(%rbx)
movq %r15, (%rax)
jmp 0x2fbf7d
leaq 0xe0dfa(%rip), %rsi     # 0x3dcd68
movq %rbx, %rdi
movl $0xaf, %edx
callq 0x1045eb
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x8ac7a
// File: /workspace/github_c_makefile_star2_O3/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 0x2fbfbc
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0xe0dc9(%rip), %rsi     # 0x3dcd68
movl $0xbb, %edx
callq 0x1045eb
movq 0x18(%rbx), %rdi
callq 0xd2938
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0xd7151
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2fc015
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0xd6e4a
testb %al, %al
je 0x2fc006
shlq $0x4, %r14
addq 0x10(%rbx), %r14
movq %r14, %rbx
jmp 0x2fc00a
addq $0x28, %rbx
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x8ad25
// File: /workspace/github_c_makefile_star2_O3/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 0xe252f
cmpq $0x0, 0x1c2c2b(%rip)    # 0x4befc8
jne 0x2fc3de
leaq -0x3c9(%rip), %rax      # 0x2fbfdd
movq %rax, (%rsp)
leaq -0x3f4(%rip), %rsi      # 0x2fbfbd
leaq -0x39e(%rip), %rdx      # 0x2fc01a
leaq -0x434(%rip), %rcx      # 0x2fbf8b
leaq -0x542(%rip), %r8       # 0x2fbe84
leaq -0x400(%rip), %r9       # 0x2fbfcd
movl $0x38, %edi
callq 0x2fbd3c
movq %rax, 0x1c2bea(%rip)    # 0x4befc8
callq 0xe2545
movq 0x1c2bde(%rip), %rax    # 0x4befc8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2fc38f
movq %rax, %rdi
callq 0x2fbd92
movq %rax, %r14
movq %rbx, 0x28(%rax)
leaq 0xe095a(%rip), %rdx     # 0x3dcd68
movl $0x10, %esi
movq %rbx, %rdi
movl $0x139, %ecx            # imm = 0x139
callq 0x10436a
movq %rax, 0x10(%r14)
movl $0x18, %edi
callq 0xd214c
movq %rax, 0x18(%r14)
movq %rbx, %rdi
callq 0xd6a50
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_O3/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 0x150964
movq %rax, %rbx
movsd 0x5949d(%rip), %xmm0    # 0x355e48
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x150bec
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
movsd 0x5947f(%rip), %xmm0    # 0x355e48
callq 0x150bec
movsd 0x8012a(%rip), %xmm0    # 0x37cb00
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x150bec
movsd 0x54ceb(%rip), %xmm0    # 0x3516d8
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x150bec
movsd 0x517c9(%rip), %xmm0    # 0x34e1d0
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x150b75
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
movsd 0x517a8(%rip), %xmm0    # 0x34e1d0
callq 0x150b75
movq %rbx, %rdi
callq 0x150cee
movq %rbx, %rdi
callq 0x150e36
testb %al, %al
je 0x2fca46
movq %rbx, %rax
popq %rbx
retq
callq 0x8ad97
// File: /workspace/github_c_makefile_star2_O3/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 0x150964
movq %rax, %rbx
movsd 0x593e2(%rip), %xmm0    # 0x355e48
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x150bec
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
movsd 0x593c4(%rip), %xmm0    # 0x355e48
callq 0x150bec
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
movsd 0x593ad(%rip), %xmm0    # 0x355e48
callq 0x150bec
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
movsd 0x59393(%rip), %xmm0    # 0x355e48
callq 0x150bec
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
movsd 0x5937c(%rip), %xmm0    # 0x355e48
callq 0x150b75
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
movsd 0x59365(%rip), %xmm0    # 0x355e48
callq 0x150b75
movq %rbx, %rdi
callq 0x150cee
movq %rbx, %rdi
callq 0x150e36
testb %al, %al
je 0x2fcb01
movq %rbx, %rax
popq %rbx
retq
callq 0x8adce
// File: /workspace/github_c_makefile_star2_O3/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 0xd0d66
movq %rax, %rbx
leaq 0xe0778(%rip), %rsi     # 0x3dd28e
movq %rax, %rdi
callq 0xd0b11
leaq 0x76189(%rip), %rsi     # 0x372cae
movq %rbx, %rdi
callq 0xd0b11
movq %rbx, %rdi
callq 0xd11cf
cmpl $0x2, %eax
jne 0x2fcb3f
movq %rbx, %rax
popq %rbx
retq
callq 0x8ae05
// File: /workspace/github_c_makefile_star2_O3/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 0x2fd3e7
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x2fd41b
testq %r14, %r14
je 0x2fd416
movq (%r14), %rax
testq %rax, %rax
je 0x2fd416
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x2fd40c
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 0x8b4ae
callq 0x8b477
// File: /workspace/github_c_makefile_star2_O3/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 0x2fd43f
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x2fd471
testq %r15, %r15
je 0x2fd46c
movq (%r15), %rax
testq %rax, %rax
je 0x2fd46c
movq (%rax), %rax
testq %rax, %rax
je 0x2fd464
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 0x8b51c
callq 0x8b4e5
// File: /workspace/github_c_makefile_star2_O3/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 0x2fd4aa
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x2fd4ac
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x2fd495
movq %rbx, %rdi
callq *%rax
leaq 0xe02cb(%rip), %rsi     # 0x3dd767
movq %rbx, %rdi
movl $0x36, %edx
popq %rbx
jmp 0x1045eb
popq %rbx
retq
callq 0x8b553
// File: /workspace/github_c_makefile_star2_O3/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 0x2fd4ef
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x20, %edi
callq 0x2f7c10
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 0x8b58a
// File: /workspace/github_c_makefile_star2_O3/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 0x2fd521
movq %rdi, %rbx
movq 0x18(%rdi), %rsi
testq %rsi, %rsi
je 0x2fd521
leaq 0xe025a(%rip), %rdx     # 0x3dd767
movl $0x1, %edi
movl $0x4f, %ecx
callq 0x10436a
movq %rbx, (%rax)
popq %rbx
retq
callq 0x8b5c1
// File: /workspace/github_c_makefile_star2_O3/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 0xd0d66
movq %rax, %rbx
leaq 0x71158(%rip), %rsi     # 0x36e9fa
movq %rax, %rdi
callq 0xd0b11
leaq 0x8f634(%rip), %rsi     # 0x38cee5
movq %rbx, %rdi
callq 0xd0b11
leaq 0x8f793(%rip), %rsi     # 0x38d053
movq %rbx, %rdi
callq 0xd0b11
leaq 0x6a272(%rip), %rsi     # 0x367b41
movq %rbx, %rdi
callq 0xd0b11
leaq 0x8f851(%rip), %rsi     # 0x38d12f
movq %rbx, %rdi
callq 0xd0b11
leaq 0xb15e0(%rip), %rsi     # 0x3aeecd
movq %rbx, %rdi
callq 0xd0b11
movq %rbx, %rdi
callq 0xd11cf
cmpl $0x6, %eax
jne 0x2fd907
movq %rbx, %rax
popq %rbx
retq
callq 0x8b6d4
// File: /workspace/github_c_makefile_star2_O3/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 0xe252f
cmpq $0x0, 0x1c0f96(%rip)    # 0x4befe0
jne 0x2fe072
leaq 0x2d(%rip), %rsi        # 0x2fe080
leaq 0x68(%rip), %rdx        # 0x2fe0c2
leaq 0xcf(%rip), %rcx        # 0x2fe130
movl $0x20, %edi
callq 0x2fd4b1
movq %rax, 0x1c0f6e(%rip)    # 0x4befe0
callq 0xe2545
movq 0x1c0f62(%rip), %rax    # 0x4befe0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2fe03c
movq %rax, %rdi
movq %r14, %rsi
callq 0x2fd526
movq %rax, %r14
testq %rbx, %rbx
je 0x2fe0f0
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x2fe12b
movq 0x10(%r14), %rdi
callq 0x11437f
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x114f10
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x2fe11c
xorl %ebx, %ebx
movq %rax, %rdi
xorl %esi, %esi
callq 0x114318
jmp 0x2fe121
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x8b8c9
// File: /workspace/github_c_makefile_star2_O3/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 0x2fe03c
movq %rax, %rdi
callq 0x2fd4f4
movq %rax, %r15
callq 0x2fe03c
movq %rax, %rdi
movq %r15, %rsi
callq 0x2fd526
movq %rax, %r12
movq %r14, %rdi
callq 0x11be43
movq %rax, 0x18(%r12)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2fe0c2
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_O3/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 %rdi, %rbx
cmpq %rdx, %rcx
jne 0x2ff2a7
xorl %ebp, %ebp
jmp 0x2ff301
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
xorl %ebp, %ebp
movq %rcx, %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2fbc68
shlq $0x4, %r13
movq (%r12,%r13), %r13
incq %rbp
cmpq %r15, %r13
jne 0x2ff2b5
movq %rbp, %r13
cmpq %r15, %r14
je 0x2ff2fc
movq %rbp, %r13
subq $0x1, %r13
jb 0x2ff31d
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x2fbc89
shlq $0x4, %r14
movq (%r12,%r14), %r14
cmpq %r15, %r14
jne 0x2ff2db
testq %r13, %r13
jne 0x2ff327
movq %rbx, %rdi
callq 0x2fbd01
cmpq %rbp, %rax
jne 0x2ff322
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x8bea8
callq 0x8bf1a
callq 0x8bee1
// File: /workspace/github_c_makefile_star2_O3/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 0x2ff405
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2ff40a
movq %rax, %rdi
callq 0x156688
movq %rax, %r14
callq 0x2ff40a
movq %rax, %rdi
movq %r14, %rsi
callq 0x1566fc
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 0xdece7(%rip), %r15     # 0x3de090
movq %r15, %rsi
movl $0x4c, %edx
callq 0x104226
movq %rax, 0x10(%r12)
movq 0x30(%r13), %rax
leaq 0x8(,%rax,8), %rdi
movq %r15, %rsi
movl $0x4f, %edx
callq 0x104226
movq %rax, (%r13)
movq %rbp, (%rax)
cmpq %rbp, 0x30(%r13)
je 0x2ff3f3
movl $0x1, %ecx
movq %rbx, (%rax,%rcx,8)
incq %rcx
cmpq 0x30(%r13), %rcx
jbe 0x2ff3e6
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x8bf53
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/intset_16.c
// Function: gt_intset_16_class
const GtIntsetClass* gt_intset_16_class(void)
{
  static const GtIntsetClass *this_c = NULL;
  if (this_c == NULL) {
    this_c = gt_intset_class_new(sizeof (GtIntset16),
                                 gt_intset_16_add,
                                 gt_intset_16_file_is_type,
                                 gt_intset_16_get,
                                 gt_intset_16_io,
                                 gt_intset_16_get_idx_smallest_geq,
                                 gt_intset_16_is_member,
                                 gt_intset_16_size_of_rep,
                                 gt_intset_16_size,
                                 gt_intset_16_size_of_struct,
                                 gt_intset_16_write,
                                 gt_intset_16_delete);
  }
  return this_c;
}

// Assembly:
movq 0x1bfbd7(%rip), %rax    # 0x4befe8
testq %rax, %rax
je 0x2ff417
retq
pushq %r15
pushq %r14
pushq %rbx
leaq 0x253(%rip), %rax       # 0x2ff676
leaq 0x6b1(%rip), %r10       # 0x2ffadb
leaq 0xa1f(%rip), %r11       # 0x2ffe50
leaq 0x894(%rip), %rbx       # 0x2ffccc
leaq 0xa01(%rip), %r14       # 0x2ffe40
leaq 0x8a4(%rip), %r15       # 0x2ffcea
leaq 0x6e3(%rip), %rsi       # 0x2ffb30
leaq 0xa02(%rip), %rdx       # 0x2ffe56
leaq 0x7b4(%rip), %rcx       # 0x2ffc0f
leaq 0x245(%rip), %r8        # 0x2ff6a7
leaq 0x909(%rip), %r9        # 0x2ffd72
movl $0x18, %edi
pushq %rax
pushq %r10
pushq %r11
pushq %rbx
pushq %r14
pushq %r15
callq 0x15686c
addq $0x30, %rsp
movq %rax, 0x1bfb60(%rip)    # 0x4befe8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2ffb21
movq %rsi, %rbx
testq %rsi, %rsi
je 0x2ffb26
movq %rdx, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x2ffb0f
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x2ffb2b
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
jmp 0x2ffb17
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x2ff6a7
callq 0x8c119
callq 0x8c0e0
callq 0x8c0a7