LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/affinealign.c
// Function: gt_affinealign_with_Management
GtWord gt_affinealign_with_Management(GtLinspaceManagement *spacemanager,
                                     const GtScoreHandler *scorehandler,
                                     GtAlignment *align,
                                     const GtUchar *u, GtUword ulen,
                                     const GtUchar *v, GtUword vlen)
{
  GtAffinealignDPentry **dptable;
  GtUword idx;
  gt_assert(u && v && spacemanager && scorehandler);

  gt_assert((ulen+1)*(vlen+1)*sizeof(**dptable) <=
             gt_linspace_management_get_valueTabsize(spacemanager));

  dptable = gt_linspace_management_get_rTabspace(spacemanager);
  *dptable = gt_linspace_management_get_valueTabspace(spacemanager);

  for (idx = 1; idx < ulen + 1; idx++)
    dptable[idx] = dptable[idx-1] + vlen + 1;

  affinealign_fill_table(dptable, u, ulen, v, vlen, GT_WORD_MAX, GT_WORD_MAX,
                         GT_WORD_MAX, GT_WORD_MAX, Affine_X, scorehandler);
  return gt_affinealign_traceback(align, dptable, ulen, vlen);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq %r9, %xmm0
movq %rcx, %xmm1
punpcklqdq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0]
movq %rsi, (%rsp)
movq %rsi, %xmm0
movq %rdi, %xmm2
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
pxor %xmm0, %xmm0
pcmpeqd %xmm0, %xmm2
pcmpeqd %xmm0, %xmm1
movdqa %xmm1, %xmm0
shufps $0xdd, %xmm2, %xmm0     # xmm0 = xmm0[1,3],xmm2[1,3]
shufps $0x88, %xmm2, %xmm1     # xmm1 = xmm1[0,2],xmm2[0,2]
andps %xmm0, %xmm1
movmskps %xmm1, %eax
testl %eax, %eax
jne 0x294f9f
movq %r8, %rbx
movq %rcx, %r13
movq %rdi, %r14
movq 0x50(%rsp), %rbp
leaq 0x1(%r8), %r12
leaq 0x1(%rbp), %rax
imulq %r12, %rax
imulq $0x30, %rax, %r15
callq 0xf999b
cmpq %rax, %r15
ja 0x294fcd
movq %r14, %rdi
callq 0xf9981
movq %rax, %r15
movq %r14, %rdi
callq 0xf9975
movq %rax, (%r15)
pushq $0x1
popq %rax
imulq $0x30, %rbp, %rcx
cmpq %r12, %rax
jae 0x294f4a
movq -0x8(%r15,%rax,8), %rdx
addq %rcx, %rdx
addq $0x30, %rdx
movq %rdx, (%r15,%rax,8)
incq %rax
jmp 0x294f30
subq $0x8, %rsp
movabsq $0x7fffffffffffffff, %r9 # imm = 0x7FFFFFFFFFFFFFFF
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq 0x10(%rsp), %rcx
movq %rbp, %r8
pushq 0x8(%rsp)
pushq $0x3
pushq %r9
pushq %r9
pushq %r9
callq 0x294a84
addq $0x30, %rsp
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %rbp, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2946d4
movq 0x1a2fc2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x50063(%rip), %rsi     # 0x2e5013
leaq 0xe74b0(%rip), %rdx     # 0x37c467
leaq 0xe74d0(%rip), %rcx     # 0x37c48e
leaq 0xe7457(%rip), %r8      # 0x37c41c
movl $0xd6, %r9d
jmp 0x294ff9
movq 0x1a2f94(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x50035(%rip), %rsi     # 0x2e5013
leaq 0xe74c8(%rip), %rdx     # 0x37c4ad
leaq 0xe74a2(%rip), %rcx     # 0x37c48e
leaq 0xe7429(%rip), %r8      # 0x37c41c
movl $0xd9, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/aligned_segment.c
// Function: gt_aligned_segment_enable_edit_tracking
void gt_aligned_segment_enable_edit_tracking(GtAlignedSegment *as)
{
  gt_assert(as != NULL);
  gt_assert(as->s_orig == NULL);
  as->s_orig = gt_malloc(sizeof (*as->s_orig) * (as->alen + 1UL));
  memcpy(as->s_orig, as->s, (size_t)(as->alen + 1UL));
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x296242
movq %rdi, %rbx
cmpq $0x0, 0x40(%rdi)
jne 0x296270
movq 0x20(%rbx), %rdi
incq %rdi
leaq 0xe64b3(%rip), %rsi     # 0x37c6d4
movl $0xda, %edx
callq 0x93160
movq %rax, 0x40(%rbx)
movq (%rbx), %rsi
movq 0x20(%rbx), %rdx
incq %rdx
movq %rax, %rdi
popq %rbx
jmp 0x17630
movq 0x1a1d1f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4edc0(%rip), %rsi     # 0x2e5013
leaq 0x533f2(%rip), %rdx     # 0x2e964c
leaq 0xe64b1(%rip), %rcx     # 0x37c712
leaq 0xe646c(%rip), %r8      # 0x37c6d4
movl $0xd8, %r9d
jmp 0x29629c
movq 0x1a1cf1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4ed92(%rip), %rsi     # 0x2e5013
leaq 0xe64b2(%rip), %rdx     # 0x37c73a
leaq 0xe6483(%rip), %rcx     # 0x37c712
leaq 0xe643e(%rip), %r8      # 0x37c6d4
movl $0xd9, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/aligned_segment.c
// Function: gt_aligned_segment_offset_for_refpos
GtUword gt_aligned_segment_offset_for_refpos(const GtAlignedSegment *as,
    GtUword refpos)
{
  GtUword r_offset, pos, ungapped_pos;
  gt_assert(as != NULL);
  if (refpos < as->r_left || refpos > as->r_right)
    return GT_UNDEF_UWORD;
  r_offset = refpos - as->r_left;
  pos = 0;
  ungapped_pos = 0;
  while (ungapped_pos < r_offset)
  {
    if (as->r[pos] != '-')
      ungapped_pos++;
    pos++;
  }
  gt_assert(pos <= as->alen);
  return pos;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x296541
pushq $-0x1
popq %rax
movq %rsi, %rcx
subq 0x28(%rdi), %rcx
jb 0x29653f
cmpq %rsi, 0x30(%rdi)
jb 0x29653f
xorl %eax, %eax
xorl %edx, %edx
cmpq %rcx, %rdx
jae 0x296539
movq 0x10(%rdi), %rsi
xorl %r8d, %r8d
cmpb $0x2d, (%rsi,%rax)
setne %r8b
addq %r8, %rdx
incq %rax
jmp 0x29651d
cmpq 0x20(%rdi), %rax
ja 0x296579
popq %rcx
retq
movq 0x1a1a20(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4eac1(%rip), %rsi     # 0x2e5013
leaq 0x530f3(%rip), %rdx     # 0x2e964c
leaq 0xe62fa(%rip), %rcx     # 0x37c85a
leaq 0xe616d(%rip), %r8      # 0x37c6d4
movl $0x118, %r9d            # imm = 0x118
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x1a19e8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4ea89(%rip), %rsi     # 0x2e5013
leaq 0xe6351(%rip), %rdx     # 0x37c8e2
leaq 0xe62c2(%rip), %rcx     # 0x37c85a
leaq 0xe6135(%rip), %r8      # 0x37c6d4
movl $0x124, %r9d            # imm = 0x124
jmp 0x29656d
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/aligned_segment.c
// Function: gt_aligned_segment_orig_seqpos_for_refpos
GtUword gt_aligned_segment_orig_seqpos_for_refpos(
    const GtAlignedSegment *as, GtUword refpos)
{
  GtUword r_offset, gapped_pos, ungapped_pos_on_r, ungapped_pos_on_s_orig;
  gt_assert(as != NULL);
  gt_assert(as->s_orig != NULL);
  if (refpos < as->r_left || refpos > as->r_right)
    return GT_UNDEF_UWORD;
  r_offset = refpos - as->r_left;
  gapped_pos = 0;
  ungapped_pos_on_r = 0;
  ungapped_pos_on_s_orig = 0;
  while (ungapped_pos_on_r < r_offset)
  {
    if (as->r[gapped_pos] != '-')
      ungapped_pos_on_r++;
    if (as->s_orig[gapped_pos] != '-')
      ungapped_pos_on_s_orig++;
    gapped_pos++;
  }
  gt_assert(gapped_pos <= as->alen);
  if (as->r_reverse)
    return as->orig_seqlen - 1UL - ungapped_pos_on_s_orig;
  else
    return ungapped_pos_on_s_orig;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x296656
movq 0x40(%rdi), %rcx
testq %rcx, %rcx
je 0x296684
pushq $-0x1
popq %rax
movq %rsi, %rdx
subq 0x28(%rdi), %rdx
jb 0x296654
cmpq %rsi, 0x30(%rdi)
jb 0x296654
xorl %esi, %esi
xorl %r8d, %r8d
xorl %eax, %eax
cmpq %rdx, %r8
jae 0x296641
movq 0x10(%rdi), %r9
xorl %r10d, %r10d
cmpb $0x2d, (%r9,%rsi)
setne %r10b
addq %r10, %r8
xorl %r9d, %r9d
cmpb $0x2d, (%rcx,%rsi)
setne %r9b
addq %r9, %rax
incq %rsi
jmp 0x296616
cmpq 0x20(%rdi), %rsi
ja 0x2966bc
cmpb $0x1, 0x38(%rdi)
jne 0x296654
notq %rax
addq 0x48(%rdi), %rax
popq %rcx
retq
movq 0x1a190b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4e9ac(%rip), %rsi     # 0x2e5013
leaq 0x52fde(%rip), %rdx     # 0x2e964c
leaq 0xe6229(%rip), %rcx     # 0x37c89e
leaq 0xe6058(%rip), %r8      # 0x37c6d4
movl $0x132, %r9d            # imm = 0x132
jmp 0x2966b0
movq 0x1a18dd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4e97e(%rip), %rsi     # 0x2e5013
leaq 0xe622c(%rip), %rdx     # 0x37c8c8
leaq 0xe61fb(%rip), %rcx     # 0x37c89e
leaq 0xe602a(%rip), %r8      # 0x37c6d4
movl $0x133, %r9d            # imm = 0x133
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x1a18a5(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4e946(%rip), %rsi     # 0x2e5013
leaq 0xe6207(%rip), %rdx     # 0x37c8db
leaq 0xe61c3(%rip), %rcx     # 0x37c89e
leaq 0xe5ff2(%rip), %r8      # 0x37c6d4
movl $0x142, %r9d            # imm = 0x142
jmp 0x2966b0
// File: /workspace/github_c_makefile_star2_O2/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 0x296781
cmpq $0x0, 0x10(%rdi)
je 0x2967af
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x20(%rdi), %rdx
cmpq %rdx, %rcx
jae 0x29672d
movq 0x10(%rdi), %rdx
movb (%rdx,%rcx), %sil
cmpb $0x2d, %sil
je 0x296728
cmpq %rax, %rcx
je 0x296725
jbe 0x296749
movb %sil, (%rdx,%rax)
incq %rax
incq %rcx
jmp 0x296703
leaq 0x1(%rdx), %rcx
cmpq %rcx, %rax
ja 0x2967dd
cmpq %rdx, %rax
ja 0x296747
movq 0x10(%rdi), %rcx
movb $0x0, (%rcx,%rax)
popq %rax
retq
movq 0x1a1818(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4e8b9(%rip), %rsi     # 0x2e5013
leaq 0xe61c2(%rip), %rdx     # 0x37c923
leaq 0xe618a(%rip), %rcx     # 0x37c8f2
leaq 0xe5f65(%rip), %r8      # 0x37c6d4
movl $0x154, %r9d            # imm = 0x154
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x1a17e0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4e881(%rip), %rsi     # 0x2e5013
leaq 0x52eb3(%rip), %rdx     # 0x2e964c
leaq 0xe6152(%rip), %rcx     # 0x37c8f2
leaq 0xe5f2d(%rip), %r8      # 0x37c6d4
movl $0x14c, %r9d            # imm = 0x14C
jmp 0x296775
movq 0x1a17b2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4e853(%rip), %rsi     # 0x2e5013
leaq 0xe614e(%rip), %rdx     # 0x37c915
leaq 0xe6124(%rip), %rcx     # 0x37c8f2
leaq 0xe5eff(%rip), %r8      # 0x37c6d4
movl $0x14d, %r9d            # imm = 0x14D
jmp 0x296775
movq 0x1a1784(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4e825(%rip), %rsi     # 0x2e5013
leaq 0xe613b(%rip), %rdx     # 0x37c930
leaq 0xe60f6(%rip), %rcx     # 0x37c8f2
leaq 0xe5ed1(%rip), %r8      # 0x37c6d4
movl $0x15a, %r9d            # imm = 0x15A
jmp 0x296775
// File: /workspace/github_c_makefile_star2_O2/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 0x2968e0
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x20(%rdi), %rdx
cmpq %rdx, %rcx
jae 0x296857
movq (%rdi), %rdx
movb (%rdx,%rcx), %sil
cmpb $0x2d, %sil
je 0x296852
cmpq %rax, %rcx
je 0x29684f
jbe 0x29687a
movb %sil, (%rdx,%rax)
movq 0x8(%rdi), %rdx
movb (%rdx,%rcx), %sil
cmpb $0x7f, %sil
je 0x2968a8
movb %sil, (%rdx,%rax)
incq %rax
incq %rcx
jmp 0x29681c
leaq 0x1(%rdx), %rcx
cmpq %rcx, %rax
ja 0x29690e
cmpq %rdx, %rax
ja 0x296878
movq (%rdi), %rcx
xorl %edx, %edx
movb %dl, (%rcx,%rax)
movq 0x8(%rdi), %rcx
movb %dl, (%rcx,%rax)
popq %rax
retq
movq 0x1a16e7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4e788(%rip), %rsi     # 0x2e5013
leaq 0xe6091(%rip), %rdx     # 0x37c923
leaq 0xe60ad(%rip), %rcx     # 0x37c946
leaq 0xe5e34(%rip), %r8      # 0x37c6d4
movl $0x169, %r9d            # imm = 0x169
jmp 0x2968d4
movq 0x1a16b9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4e75a(%rip), %rsi     # 0x2e5013
leaq 0xe60ac(%rip), %rdx     # 0x37c96c
leaq 0xe607f(%rip), %rcx     # 0x37c946
leaq 0xe5e06(%rip), %r8      # 0x37c6d4
movl $0x16b, %r9d            # imm = 0x16B
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x1a1681(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4e722(%rip), %rsi     # 0x2e5013
leaq 0x52d54(%rip), %rdx     # 0x2e964c
leaq 0xe6047(%rip), %rcx     # 0x37c946
leaq 0xe5dce(%rip), %r8      # 0x37c6d4
movl $0x162, %r9d            # imm = 0x162
jmp 0x2968d4
movq 0x1a1653(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4e6f4(%rip), %rsi     # 0x2e5013
leaq 0xe600a(%rip), %rdx     # 0x37c930
leaq 0xe6019(%rip), %rcx     # 0x37c946
leaq 0xe5da0(%rip), %r8      # 0x37c6d4
movl $0x171, %r9d            # imm = 0x171
jmp 0x2968d4
// File: /workspace/github_c_makefile_star2_O2/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 0x296b49
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xe5bf3(%rip), %r14     # 0x37c6d4
movq %r14, %rsi
movl $0x1a1, %edx            # imm = 0x1A1
callq 0x936f9
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x1a2, %edx            # imm = 0x1A2
callq 0x936f9
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0x1a3, %edx            # imm = 0x1A3
callq 0x936f9
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movl $0x1a4, %edx            # imm = 0x1A4
callq 0x936f9
movq 0x40(%rbx), %rdi
movq %r14, %rsi
movl $0x1a5, %edx            # imm = 0x1A5
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1a6, %edx            # imm = 0x1A6
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x296bb9
movq %rdi, %r14
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x296be7
movq %rsi, %rbx
movq 0x28(%r14), %r15
xorl %r12d, %r12d
cmpq 0x20(%r14), %r12
jae 0x296bad
movb (%rax,%r12), %cl
cmpb $0x3f, %cl
jne 0x296b9d
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x709bc
movq 0x10(%r14), %rcx
movb %al, (%rcx,%r12)
movq 0x10(%r14), %rax
movb (%rax,%r12), %cl
xorl %edx, %edx
cmpb $0x2d, %cl
setne %dl
addq %rdx, %r15
incq %r12
jmp 0x296b71
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x1a13a8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4e449(%rip), %rsi     # 0x2e5013
leaq 0x52a7b(%rip), %rdx     # 0x2e964c
leaq 0xe5e7c(%rip), %rcx     # 0x37ca54
leaq 0xe5af5(%rip), %r8      # 0x37c6d4
movl $0x1ae, %r9d            # imm = 0x1AE
jmp 0x296c13
movq 0x1a137a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4e41b(%rip), %rsi     # 0x2e5013
leaq 0xe5d16(%rip), %rdx     # 0x37c915
leaq 0xe5e4e(%rip), %rcx     # 0x37ca54
leaq 0xe5ac7(%rip), %r8      # 0x37c6d4
movl $0x1af, %r9d            # imm = 0x1AF
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x296cb0
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdx
testq %rdx, %rdx
je 0x296c4c
leaq 0xe5e54(%rip), %rsi     # 0x37ca96
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8d432
movq 0x10(%r14), %rdx
testq %rdx, %rdx
je 0x296c66
leaq 0xe5e41(%rip), %rsi     # 0x37ca9d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8d432
movq 0x40(%r14), %rdx
testq %rdx, %rdx
je 0x296c80
leaq 0xe5e2e(%rip), %rsi     # 0x37caa4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8d432
movq (%r14), %rdx
leaq 0x74392(%rip), %rsi     # 0x30b01c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8d432
movq 0x8(%r14), %rdx
leaq 0xe5e0c(%rip), %rsi     # 0x37caab
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8d432
movq 0x1a12b1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4e352(%rip), %rsi     # 0x2e5013
leaq 0x52984(%rip), %rdx     # 0x2e964c
leaq 0xe5daf(%rip), %rcx     # 0x37ca7e
leaq 0xe59fe(%rip), %r8      # 0x37c6d4
movl $0x1bd, %r9d            # imm = 0x1BD
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x112de7
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 0x112f58
movq 0x20(%r14), %rax
cmpq (%r12), %rax
jne 0x296db9
subq %rbx, %rax
addq (%r14), %rax
cmpq %rax, 0x10(%rsp)
jne 0x296de3
leaq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x11309d
movq 0x20(%r14), %rax
cmpq (%r12), %rax
jne 0x296e0d
subq %rbx, %rax
addq 0x8(%r14), %rax
cmpq %rax, 0x8(%rsp)
jne 0x296e37
callq 0x56967
movq %rax, %r14
movq 0x10(%rsp), %rdx
movq %rax, %rdi
movq %rdx, %rsi
movq %rbx, %rcx
callq 0x570f1
movq %r14, %rdi
callq 0x568b5
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x1a11a8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4e249(%rip), %rsi     # 0x2e5013
leaq 0xe5ce1(%rip), %rdx     # 0x37cab2
leaq 0xe5ceb(%rip), %rcx     # 0x37cac3
leaq 0xe58f5(%rip), %r8      # 0x37c6d4
pushq $0x44
jmp 0x296e5f
movq 0x1a117e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4e21f(%rip), %rsi     # 0x2e5013
leaq 0xe5cf1(%rip), %rdx     # 0x37caec
leaq 0xe5cc1(%rip), %rcx     # 0x37cac3
leaq 0xe58cb(%rip), %r8      # 0x37c6d4
pushq $0x45
jmp 0x296e5f
movq 0x1a1154(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4e1f5(%rip), %rsi     # 0x2e5013
leaq 0xe5c8d(%rip), %rdx     # 0x37cab2
leaq 0xe5c97(%rip), %rcx     # 0x37cac3
leaq 0xe58a1(%rip), %r8      # 0x37c6d4
pushq $0x48
jmp 0x296e5f
movq 0x1a112a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4e1cb(%rip), %rsi     # 0x2e5013
leaq 0xe5cc5(%rip), %rdx     # 0x37cb14
leaq 0xe5c6d(%rip), %rcx     # 0x37cac3
leaq 0xe5877(%rip), %r8      # 0x37c6d4
pushq $0x49
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rdi, %r12
leaq 0xe5d39(%rip), %rsi     # 0x37cbc1
pushq $0x50
popq %rdi
pushq $0x31
popq %rdx
callq 0x93160
movq %rax, %r14
callq 0x6be41
movq %rax, 0x28(%r14)
movb $0x0, 0x4c(%r14)
movq %r12, %rdi
callq 0x8e013
testq %rax, %rax
js 0x296f17
movq %rax, 0x8(%r14)
movq %r12, %rdi
callq 0x6c2be
movq %rax, 0x38(%r14)
movq %r15, 0x20(%r14)
movq 0x8(%r14), %rax
movq 0x28(%r14), %rcx
imulq %rcx, %r15
cmpq %r15, %rax
jae 0x296ee2
xorl %edx, %edx
divq %rcx
incq %rax
movq %rax, 0x20(%r14)
andq $0x0, 0x40(%r14)
andq $0x0, 0x30(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x296f41
movq 0x28(%r14), %rax
imulq 0x20(%r14), %rax
shrq $0x3, %rax
movq %rax, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x1a104a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x51e8f(%rip), %rsi     # 0x2e8db7
leaq 0xe5c92(%rip), %rdx     # 0x37cbc1
pushq $0x35
popq %rcx
xorl %eax, %eax
callq 0x17a50
pushq $0x1
popq %rdi
callq 0x178f0
// File: /workspace/github_c_makefile_star2_O2/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 0x296fd3
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %r15
movq %rsi, %rax
xorl %edx, %edx
divq %r15
testq %rdx, %rdx
jne 0x296ffd
imulq 0x20(%rbx), %r15
movq %r14, (%rbx)
movq 0x40(%rbx), %rdi
callq 0x8b9fa
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
leaq (%rcx,%r15), %rdx
cmpq %rax, %rdx
jbe 0x296fa1
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 0xe5c15(%rip), %rcx     # 0x37cbc1
pushq $0x5d
popq %r8
movq %r15, %rsi
movq %r14, %rdx
callq 0x8b849
movq %rax, 0x40(%rbx)
testq %rax, %rax
je 0x297027
andl $0x0, 0x48(%rbx)
andq $0x0, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x1a0f8e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4e02f(%rip), %rsi     # 0x2e5013
leaq 0xe5bf1(%rip), %rdx     # 0x37cbdc
leaq 0xe5c07(%rip), %rcx     # 0x37cbf9
leaq 0xe5bc8(%rip), %r8      # 0x37cbc1
pushq $0x4d
jmp 0x29704f
movq 0x1a0f64(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4e005(%rip), %rsi     # 0x2e5013
leaq 0xe5bfa(%rip), %rdx     # 0x37cc0f
leaq 0xe5bdd(%rip), %rcx     # 0x37cbf9
leaq 0xe5b9e(%rip), %r8      # 0x37cbc1
pushq $0x4e
jmp 0x29704f
movq 0x1a0f3a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4dfdb(%rip), %rsi     # 0x2e5013
leaq 0xe5bf4(%rip), %rdx     # 0x37cc33
leaq 0xe5bb3(%rip), %rcx     # 0x37cbf9
leaq 0xe5b74(%rip), %r8      # 0x37cbc1
pushq $0x5f
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2970a6
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
decq %rcx
cmpq %rcx, %rax
jae 0x29708a
andl $0x0, 0x48(%rbx)
incq %rax
movq %rax, 0x18(%rbx)
jmp 0x2970a6
xorl %eax, %eax
cmpb $0x0, 0x4c(%rbx)
jne 0x2970d1
movq 0x20(%rbx), %rsi
imulq 0x28(%rbx), %rsi
addq (%rbx), %rsi
movq %rbx, %rdi
callq 0x296f41
movq 0x18(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x2970d9
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)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x1a0e88(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4df29(%rip), %rsi     # 0x2e5013
leaq 0xe5b62(%rip), %rdx     # 0x37cc53
leaq 0xe5b8c(%rip), %rcx     # 0x37cc84
leaq 0xe5ac2(%rip), %r8      # 0x37cbc1
pushq $0x7a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x297165
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rsi
leaq 0xe5b7a(%rip), %rdi     # 0x37cca0
xorl %eax, %eax
callq 0x92a82
movq 0x40(%rbx), %rdi
callq 0x8b9fa
movq 0x38(%rbx), %rdi
leaq 0xe5a80(%rip), %r14     # 0x37cbc1
movq %r14, %rsi
movl $0x86, %edx
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x87, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2971b4
movq %rdi, %rbx
leaq 0xe5b47(%rip), %rdx     # 0x37ccc2
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
pushq $0x27
popq %rcx
callq 0x9334a
movq %rax, %r14
movl $0x40, 0x20(%rax)
movq %rbx, (%rax)
andq $0x0, 0x18(%rax)
andq $0x0, 0x8(%rax)
callq 0x6be41
movq %rax, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x1a0dad(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4de4e(%rip), %rsi     # 0x2e5013
leaq 0x8c2ec(%rip), %rdx     # 0x3234b8
leaq 0xe5adb(%rip), %rcx     # 0x37ccae
leaq 0xe5ae8(%rip), %r8      # 0x37ccc2
pushq $0x25
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x29722d
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
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
callq 0xb302c
pushq $0x40
popq %rcx
subl %ebp, %ecx
addq $0x40, 0x8(%r14)
xorl %eax, %eax
jmp 0x297231
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_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x5e96c
movq %rax, %r15
leaq 0x18(%r14), %r12
xorl %r13d, %r13d
pushq $0x1
popq %rbp
cmpq %r13, %r15
je 0x2972bd
movl 0x20(%r14), %eax
testl %eax, %eax
jne 0x297295
movq (%r14), %rcx
movq %r12, %rdi
pushq $0x8
popq %rsi
movq %rbp, %rdx
callq 0xb302c
andq $0x0, 0x18(%r14)
addq $0x40, 0x8(%r14)
pushq $0x40
popq %rax
decl %eax
movl %eax, 0x20(%r14)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5e839
testb %al, %al
je 0x2972b8
movb 0x20(%r14), %cl
movq %rbp, %rax
shlq %cl, %rax
orq %rax, 0x18(%r14)
incq %r13
jmp 0x29726a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/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 0x297308
movq %rdi, %rbx
addq $0x18, %rdi
movq (%rbx), %rcx
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
callq 0xb302c
movslq 0x20(%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
addq $0x40, %rcx
movq %rcx, 0x8(%rbx)
andq $0x0, 0x18(%rbx)
movl $0x40, 0x20(%rbx)
popq %rbx
retq
movq 0x1a0c59(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4dcfa(%rip), %rsi     # 0x2e5013
leaq 0xe59be(%rip), %rdx     # 0x37ccde
leaq 0xe59c1(%rip), %rcx     # 0x37cce8
leaq 0xe5994(%rip), %r8      # 0x37ccc2
pushq $0x59
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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
movq %rbx, %rdi
callq 0x2972cc
testq %r14, %r14
je 0x29738d
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 0xb2fec
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x29826e
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x586a4
cmpq %r14, %rax
jbe 0x298298
movq (%r15), %rdi
callq 0x584c7
movq %rbx, (%rax,%r14,8)
popq %rbx
popq %r14
popq %r15
retq
movq 0x19fcf3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4cd94(%rip), %rsi     # 0x2e5013
leaq 0x4e459(%rip), %rdx     # 0x2e66df
leaq 0xe4dde(%rip), %rcx     # 0x37d06b
leaq 0xe4d78(%rip), %r8      # 0x37d00c
pushq $0x41
jmp 0x2982c0
movq 0x19fcc9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4cd6a(%rip), %rsi     # 0x2e5013
leaq 0xe4dd0(%rip), %rdx     # 0x37d080
leaq 0xe4db4(%rip), %rcx     # 0x37d06b
leaq 0xe4d4e(%rip), %r8      # 0x37d00c
pushq $0x42
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x38
popq %rdi
callq 0x292a70
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_O2/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 0x298448
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x298448
leaq 0xe4cba(%rip), %rdx     # 0x37d0f2
pushq $0x1
popq %rdi
pushq $0x2f
popq %rcx
callq 0x9334a
movq %rbx, (%rax)
popq %rbx
retq
movq 0x19fb19(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4cbba(%rip), %rsi     # 0x2e5013
leaq 0xe4c69(%rip), %rdx     # 0x37d0c9
leaq 0xe4c73(%rip), %rcx     # 0x37d0da
leaq 0xe4c84(%rip), %r8      # 0x37d0f2
pushq $0x2e
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2984ab
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x298498
movq %rbx, %rdi
callq *%rax
leaq 0xe4c53(%rip), %rsi     # 0x37d0f2
pushq $0x39
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x298626
movq %rsi, %r15
movq %rdi, %r14
leaq 0xe4be5(%rip), %rdx     # 0x37d138
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
movl $0x97, %ecx
callq 0x9334a
movq %rax, %rbx
movq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0x5e839
testb %al, %al
je 0x2985db
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0x581aa
cmpq $0x0, 0x10(%rax)
je 0x298607
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0x581aa
movq %rax, %r15
movq 0x10(%rax), %rdi
movq %rdi, 0x8(%rbx)
andq $0x0, (%rbx)
leaq 0xe4b8d(%rip), %rdx     # 0x37d138
pushq $0x8
popq %rsi
movl $0xa6, %ecx
callq 0x9334a
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 0x2985c3
jmp 0x29861d
movq $0x1, 0x8(%rbx)
andq $0x0, (%rbx)
leaq 0xe4b4a(%rip), %rdx     # 0x37d138
pushq $0x1
popq %rdi
pushq $0x8
popq %rsi
movl $0x9c, %ecx
callq 0x9334a
movq %rax, 0x10(%rbx)
movq %r15, (%rax)
jmp 0x29861d
leaq 0xe4b2a(%rip), %rsi     # 0x37d138
movq %rbx, %rdi
movl $0xaf, %edx
callq 0x936f9
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x19f93b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4c9dc(%rip), %rsi     # 0x2e5013
leaq 0xabcb3(%rip), %rdx     # 0x3442f1
leaq 0xe4aca(%rip), %rcx     # 0x37d10f
leaq 0xe4aec(%rip), %r8      # 0x37d138
movl $0x95, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x29868f
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0xe4ac6(%rip), %rsi     # 0x37d138
movl $0xbb, %edx
callq 0x936f9
movq 0x18(%rbx), %rdi
callq 0x58eb9
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x5ecf6
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x29874e
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x5e839
testb %al, %al
je 0x29873f
shlq $0x4, %r14
addq 0x10(%rbx), %r14
movq %r14, %rbx
jmp 0x298743
addq $0x28, %rbx
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x19f813(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4c8b4(%rip), %rsi     # 0x2e5013
leaq 0xabb8b(%rip), %rdx     # 0x3442f1
leaq 0xe4a43(%rip), %rcx     # 0x37d1b0
leaq 0xe49c4(%rip), %r8      # 0x37d138
movl $0xd5, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/clustered_set_uf.c
// Function: gt_clustered_set_union_find_append_elem
static void
gt_clustered_set_union_find_append_elem(GtClusteredSetUF *cs_uf,
                                        GtUword c,
                                        GtUword elem,
                                        GT_UNUSED GtError *err)
{
  GtClusteredSetUFClusterInfo *cluster_info;
  cs_uf->cluster_elems[elem].cluster_num = c;
  cs_uf->cluster_elems[elem].next_elem = cs_uf->num_of_elems;
  cluster_info = CINFO(c);
  cs_uf->cluster_elems[cluster_info->last_elem].next_elem = elem;
  cluster_info->last_elem = elem;
  cluster_info->cluster_size++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq %rdx, %rcx
shlq $0x4, %rcx
movq %rsi, (%rax,%rcx)
movq 0x28(%rdi), %rdx
movq %rdx, 0x8(%rax,%rcx)
movq 0x18(%rdi), %rdi
callq 0x581aa
movq 0x10(%r14), %rcx
movq 0x8(%rax), %rdx
shlq $0x4, %rdx
movq %rbx, 0x8(%rcx,%rdx)
movq %rbx, 0x8(%rax)
incq 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x69e97
cmpq $0x0, 0x1a5482(%rip)    # 0x43df78
jne 0x298b35
leaq -0x3e9(%rip), %rax      # 0x298716
movq %rax, (%rsp)
leaq -0x47a(%rip), %rsi      # 0x298690
leaq -0x38b(%rip), %rdx      # 0x298786
leaq -0x4ba(%rip), %rcx      # 0x29865e
leaq -0x5e7(%rip), %r8       # 0x298538
leaq -0x453(%rip), %r9       # 0x2986d3
pushq $0x38
popq %rdi
callq 0x2983cc
movq %rax, 0x1a5443(%rip)    # 0x43df78
callq 0x69ede
movq 0x1a5437(%rip), %rax    # 0x43df78
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x298ae8
movq %rax, %rdi
callq 0x298420
movq %rax, %r14
movq %rbx, 0x28(%rax)
leaq 0xe45d3(%rip), %rdx     # 0x37d138
pushq $0x10
popq %rsi
movq %rbx, %rdi
movl $0x139, %ecx            # imm = 0x139
callq 0x9334a
movq %rax, 0x10(%r14)
pushq $0x18
popq %rdi
callq 0x5809c
movq %rax, 0x18(%r14)
movq %rbx, %rdi
callq 0x5e0b0
movq %rax, 0x20(%r14)
andq $0x0, 0x30(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
pushq $0x2
popq %rdi
movl %edi, %esi
callq 0xec1d4
movq %rax, %rbx
movsd 0x5cd78(%rip), %xmm0    # 0x2f5e58
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xec5aa
pushq $0x1
popq %rbp
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
movsd 0x5cd5a(%rip), %xmm0    # 0x2f5e58
callq 0xec5aa
movsd 0x83dfd(%rip), %xmm0    # 0x31cf08
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0xec5aa
movsd 0x585c9(%rip), %xmm0    # 0x2f16e8
movq %rbx, %rdi
movl %ebp, %esi
movl %ebp, %edx
callq 0xec5aa
movsd 0x5509d(%rip), %xmm0    # 0x2ee1d0
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0xec487
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
movsd 0x55082(%rip), %xmm0    # 0x2ee1d0
callq 0xec487
movq %rbx, %rdi
callq 0xec842
movq %rbx, %rdi
callq 0xeca3c
testb %al, %al
je 0x299171
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x19edf0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x4be91(%rip), %rsi     # 0x2e5013
leaq 0x8a1f1(%rip), %rdx     # 0x32337a
leaq 0xe4492(%rip), %rcx     # 0x37d622
leaq 0xe449e(%rip), %r8      # 0x37d635
pushq $0x26
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390