LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_decode_seedpair
static void gt_diagbandseed_decode_seedpair(GtDiagbandseedSeedPair *seedpair,
                                            const GtSeedpairlist *seedpairlist,
                                            GtUword offset)
{
  GtUword transfer, value_seqnums, value_positions;
  GtDiagbandseedPosition apos, bpos;
  const uint8_t *bytestring = seedpairlist->mlist_bytestring->spaceuint8_t +
                              offset;

  value_seqnums
    = gt_diagbandseed_bytestring2GtUword(bytestring,sizeof (GtUword));
  seedpair->aseqnum = (GtDiagbandseedSeqnum)
                      ((value_seqnums >>
                        seedpairlist->bits_left_adjust[idx_aseqnum]) &
                       seedpairlist->mask_tab[idx_aseqnum]);
  seedpair->bseqnum = (GtDiagbandseedSeqnum)
                      ((value_seqnums >>
                        seedpairlist->bits_left_adjust[idx_bseqnum]) &
                       seedpairlist->mask_tab[idx_bseqnum]);
  transfer = value_seqnums & seedpairlist->transfer_mask;
  value_positions
    = gt_diagbandseed_bytestring2GtUword(bytestring + sizeof (GtUword),
                                         seedpairlist->bytes_seedpair -
                                         sizeof (GtUword));
  value_positions >>= seedpairlist->bits_unused_in2GtUwords;
  value_positions |= (transfer << seedpairlist->transfer_shift);
  apos = (GtDiagbandseedPosition) (value_positions &
                                   seedpairlist->mask_tab[idx_apos]);
  bpos = (GtDiagbandseedPosition) (value_positions >>
                                   seedpairlist->bits_values[idx_apos]);
  GT_DIAGBANDSEED_SETPOS(seedpair,apos,bpos); /* for splt bytestring */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq (%rax), %r13
leaq (%r13,%rdx), %rdi
pushq $0x8
popq %rsi
callq 0x141a36
movq %rax, %r15
movb 0x86(%r14), %cl
shrq %cl, %rax
andl 0x20(%r14), %eax
movl %eax, 0x4(%rbx)
movb 0x88(%r14), %cl
movq %r15, %rax
shrq %cl, %rax
andl 0x28(%r14), %eax
movl %eax, (%rbx)
andq 0x40(%r14), %r15
leaq (%r12,%r13), %rdi
addq $0x8, %rdi
movq 0x90(%r14), %rsi
addq $-0x8, %rsi
callq 0x141a36
movb 0xac(%r14), %cl
shrq %cl, %rax
movb 0xa8(%r14), %cl
shlq %cl, %r15
movb 0x80(%r14), %cl
orq %rax, %r15
movl 0x38(%r14), %eax
andl %r15d, %eax
shrq %cl, %r15
movl %r15d, 0xc(%rbx)
movl %eax, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_bytestring2GtUword
static GtUword gt_diagbandseed_bytestring2GtUword(const uint8_t *bytestring,
                                                  GtUword bytestring_length)
{
  int idx, shift;
  GtUword value = 0;

  for (idx = 0, shift = (sizeof (GtUword) - 1) * CHAR_BIT;
       idx < bytestring_length; idx++, shift -= CHAR_BIT)
  {
    value |= (((GtUword) bytestring[idx]) << shift);
  }
  return value;
}

// Assembly:
pushq $0x38
popq %rcx
xorl %edx, %edx
xorl %eax, %eax
cmpq %rdx, %rsi
je 0x141a55
movzbl (%rdi,%rdx), %r8d
shlq %cl, %r8
orq %r8, %rax
incq %rdx
addl $-0x8, %ecx
jmp 0x141a3d
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_segment_reject_register_match
static void gt_segment_reject_register_match(GtSegmentRejectInfo
                                                *segment_reject_info,
                                             GtUword bseqnum)
{
  GtUword idx;

  gt_assert(segment_reject_info !=NULL);
  idx = bseqnum - segment_reject_info->b_firstseq;
  gt_assert(bseqnum >= segment_reject_info->b_firstseq &&
            idx < segment_reject_info->b_numsequences &&
            !GT_ISIBITSET(segment_reject_info->b_bitsequence,idx));
  GT_SETIBIT(segment_reject_info->b_bitsequence,idx);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1427cf
subq (%rdi), %rsi
jb 0x1427a1
cmpq 0x8(%rdi), %rsi
jae 0x1427a1
movq 0x10(%rdi), %rax
movq %rsi, %rdx
shrq $0x6, %rdx
movq (%rax,%rdx,8), %rdi
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
movl %esi, %ecx
shrq %cl, %r8
testq %r8, %rdi
jne 0x1427a1
orq %r8, %rdi
movq %rdi, (%rax,%rdx,8)
popq %rax
retq
movq 0x2f57c0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a2861(%rip), %rsi    # 0x2e5013
leaq 0x1fef18(%rip), %rdx    # 0x3416d1
leaq 0x1feef0(%rip), %rcx    # 0x3416b0
leaq 0x1fd6f5(%rip), %r8     # 0x33febc
movl $0xe2, %r9d
jmp 0x1427fb
movq 0x2f5792(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a2833(%rip), %rsi    # 0x2e5013
leaq 0x1feeae(%rip), %rdx    # 0x341695
leaq 0x1feec2(%rip), %rcx    # 0x3416b0
leaq 0x1fd6c7(%rip), %r8     # 0x33febc
movl $0xde, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_set_sequence
static void gt_diagbandseed_set_sequence(GtSeqorEncseq *seqorencseq,
                                         const GtSequencePartsInfo *seqranges,
                                         const GtUchar *bytesequence,
                                         GtUword first_seqstartpos,
                                         GtUword seqnum,
                                         const GtUchar *characters,
                                         GtUchar wildcardshow,
                                         bool haswildcards,
                                         const GtEncseq *encseq_for_seq_desc)
{
  const GtUword
    seqstartpos = gt_sequence_parts_info_seqstartpos(seqranges,seqnum),
    seqendpos = gt_sequence_parts_info_seqendpos(seqranges,seqnum),
    b_off = seqstartpos - first_seqstartpos;
  const char *seqdescptr;
  if (encseq_for_seq_desc != NULL)
  {
    GtUword desclen;
    seqdescptr = gt_encseq_description(encseq_for_seq_desc,
                                       &desclen,
                                       seqnum);
  } else
  {
    seqdescptr = "Unknown";
  }
  GT_SEQORENCSEQ_INIT_SEQ(seqorencseq,bytesequence + b_off,seqdescptr,
                          seqendpos - seqstartpos + 1,characters,
                          wildcardshow,
                          haswildcards);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %r14
movq %rsi, %rdi
movq %r8, %rsi
callq 0x190d60
movq %rax, %r13
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x190d86
movq 0x60(%rsp), %rdi
movq %rax, %rbp
testq %rdi, %rdi
je 0x14285e
leaq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0x75b24
jmp 0x142865
leaq 0x1ff02b(%rip), %rax    # 0x341890
subq %r13, %rbp
subq %r12, %r13
andq $0x0, 0x8(%r14)
addq %r13, %r15
movq %r15, (%r14)
movq %rax, 0x10(%r14)
incq %rbp
movq %rbp, 0x20(%r14)
andq $0x0, 0x18(%r14)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%r14)
movb 0x50(%rsp), %al
movb %al, 0x30(%r14)
movb 0x58(%rsp), %al
movb %al, 0x31(%r14)
addq $0x18, %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/match/diagbandseed.c
// Function: gt_diagbandseed_bstart_ldesc_compare_mems
static int gt_diagbandseed_bstart_ldesc_compare_mems(const void *vl,
                                                     const void *vr)
{
  GtDiagbandseedMaximalmatch *l = (GtDiagbandseedMaximalmatch *) vl,
                             *r = (GtDiagbandseedMaximalmatch *) vr;
  GtDiagbandseedPosition lapos = l->apos + 1 - l->len,
                         lbpos = l->bpos + 1 - l->len,
                         rapos = r->apos + 1 - r->len,
                         rbpos = r->bpos + 1 - r->len;
  if (lbpos < rbpos)
  {
    return -1;
  }
  if (lbpos > rbpos)
  {
    return 1;
  }
  if (l->len < r->len)
  {
    return 1;
  }
  if (l->len > r->len)
  {
    return -1;
  }
  if (lapos < rapos)
  {
    return -1;
  }
  if (lapos > rapos)
  {
    return 1;
  }
  gt_assert(false);
  return 0;
}

// Assembly:
movl 0x8(%rdi), %ecx
movl 0x4(%rdi), %r9d
subl %ecx, %r9d
incl %r9d
movl 0x8(%rsi), %r8d
movl 0x4(%rsi), %r10d
subl %r8d, %r10d
incl %r10d
pushq $-0x1
popq %rax
cmpl %r10d, %r9d
jae 0x142a4a
retq
pushq $0x1
popq %rdx
cmpl %r8d, %ecx
jb 0x142ab4
cmpl %r10d, %r9d
ja 0x142ab4
movl (%rdi), %edi
subl %ecx, %edi
incl %edi
movl (%rsi), %esi
subl %r8d, %esi
incl %esi
cmpl %r8d, %ecx
seta %cl
cmpl %esi, %edi
setb %r8b
orb %cl, %r8b
jne 0x142a49
movl %edx, %eax
cmpl %esi, %edi
ja 0x142a49
pushq %rax
movq 0x2f54e5(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a2586(%rip), %rsi    # 0x2e5013
leaq 0x1e3f58(%rip), %rdx    # 0x3269ec
leaq 0x1feff6(%rip), %rcx    # 0x341a91
leaq 0x1fd41a(%rip), %r8     # 0x33febc
movl $0xb58, %r9d            # imm = 0xB58
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/echoseq.c
// Function: gt_symbolstring2fasta
void gt_symbolstring2fasta(FILE *fpout,
                        const char *desc,
                        const GtAlphabet *alpha,
                        const GtUchar *w,
                        GtUword wlen,
                        GtUword width)
{
  GtUword i, j;
  GtUchar currentchar;

  gt_assert(width > 0);
  if (desc == NULL)
  {
    fprintf(fpout,">\n");
  } else
  {
    fprintf(fpout,">%s\n",desc);
  }
  for (i = 0, j = 0; ; i++)
  {
    currentchar = w[i];
    if (currentchar == (GtUchar) GT_SEPARATOR)
    {
      fprintf(fpout,"\n>\n");
      j = 0;
    } else
    {
      gt_alphabet_echo_pretty_symbol(alpha,fpout,currentchar);
    }
    if (i == wlen - 1)
    {
      fprintf(fpout,"\n");
      break;
    }
    if (currentchar != (GtUchar) GT_SEPARATOR)
    {
      j++;
      if (j >= width)
      {
        fprintf(fpout,"\n");
        j = 0;
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
testq %r9, %r9
je 0x142ce6
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rdx
movq %rdi, %r15
testq %rsi, %rsi
je 0x142c5f
leaq 0x1a7580(%rip), %rsi    # 0x2ea1d3
movq %r15, %rdi
xorl %eax, %eax
callq 0x17a50
jmp 0x142c74
leaq 0x1ff38e(%rip), %rdi    # 0x341ff4
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rcx
callq 0x17f00
decq %r14
xorl %ebx, %ebx
xorl %ebp, %ebp
movb (%r12,%rbp), %al
cmpb $-0x1, %al
je 0x142cac
movzbl %al, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x57274
cmpq %rbp, %r14
je 0x142ccd
incq %rbx
cmpq (%rsp), %rbx
jb 0x142cc8
pushq $0xa
popq %rdi
movq %r15, %rsi
callq 0x17930
jmp 0x142cc6
leaq 0x1ff340(%rip), %rdi    # 0x341ff3
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rcx
callq 0x17f00
cmpq %rbp, %r14
je 0x142ccd
xorl %ebx, %ebx
incq %rbp
jmp 0x142c7b
pushq $0xa
popq %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17930
movq 0x2f527b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a231c(%rip), %rsi    # 0x2e5013
leaq 0x24091c(%rip), %rdx    # 0x38361a
leaq 0x1ff2c4(%rip), %rcx    # 0x341fc9
leaq 0x1ff2d3(%rip), %r8     # 0x341fdf
pushq $0x23
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/echoseq.c
// Function: gt_encseq2symbolstring
void gt_encseq2symbolstring(FILE *fpout,
                            const GtEncseq *encseq,
                            GtReadmode readmode,
                            GtUword start,
                            GtUword wlen,
                            GtUword width)
{
  GtUword j, idx, lastpos;
  GtUchar currentchar;
  GtEncseqReader *esr;
  const GtAlphabet *alpha;

  esr = gt_encseq_create_reader_with_readmode(encseq, readmode, start);
  gt_assert(width > 0);
  lastpos = start + wlen - 1;
  alpha = gt_encseq_alphabet(encseq);
  for (idx = start, j = 0; /* Nothing */ ; idx++)
  {
    currentchar = gt_encseq_reader_next_encoded_char(esr);
    if (currentchar == (GtUchar) GT_SEPARATOR)
    {
      fprintf(fpout,"\n>\n");
      j = 0;
    } else
    {
      gt_alphabet_echo_pretty_symbol(alpha,fpout,currentchar);
    }
    if (idx == lastpos)
    {
      fprintf(fpout,"\n");
      break;
    }
    if (currentchar != (GtUchar) GT_SEPARATOR)
    {
      j++;
      if (j >= width)
      {
        fprintf(fpout,"\n");
        j = 0;
      }
    }
  }
  gt_encseq_reader_delete(esr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, %rdi
movl %edx, %esi
movq %rcx, %rdx
callq 0x72260
testq %rbx, %rbx
je 0x142dd2
movq %rax, %r12
movq %r13, %rdi
callq 0x754dd
movq %rax, %r13
decq %r15
xorl %ebp, %ebp
movq %r12, %rdi
callq 0x70f55
cmpb $-0x1, %al
je 0x142d90
movzbl %al, %edx
movq %r13, %rdi
movq %r14, %rsi
callq 0x57274
testq %r15, %r15
je 0x142db1
incq %rbp
cmpq %rbx, %rbp
jb 0x142dac
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x17930
jmp 0x142daa
leaq 0x1ff25c(%rip), %rdi    # 0x341ff3
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x17f00
testq %r15, %r15
je 0x142db1
xorl %ebp, %ebp
decq %r15
jmp 0x142d5c
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x17930
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x722ae
movq 0x2f518f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a2230(%rip), %rsi    # 0x2e5013
leaq 0x240830(%rip), %rdx    # 0x38361a
leaq 0x1ff206(%rip), %rcx    # 0x341ff7
leaq 0x1ff1e7(%rip), %r8     # 0x341fdf
pushq $0x54
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/echoseq.c
// Function: gt_fprintfencseq
void gt_fprintfencseq(FILE *fpout,
                      const GtEncseq *encseq,
                      GtUword start,
                      GtUword wlen)
{
  GtUword idx;
  GtUchar currentchar;
  const GtAlphabet *alpha;

  alpha = gt_encseq_alphabet(encseq);
  for (idx = start; idx < start + wlen; idx++)
  {
    currentchar = gt_encseq_get_encoded_char(encseq,
                                                    idx,
                                                    GT_READMODE_FORWARD);
    gt_assert(GT_ISNOTSPECIAL(currentchar));
    gt_alphabet_echo_pretty_symbol(alpha,fpout,currentchar);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
callq 0x754dd
movq %rax, %r13
addq %r14, %rbx
cmpq %rbx, %r14
jae 0x142e54
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x705e4
cmpb $-0x2, %al
jae 0x142e5e
movzbl %al, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x57274
incq %r14
jmp 0x142e2b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x2f5103(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a21a4(%rip), %rsi    # 0x2e5013
leaq 0x1ff198(%rip), %rdx    # 0x34200e
leaq 0x1ff1ae(%rip), %rcx    # 0x34202b
leaq 0x1ff15b(%rip), %r8     # 0x341fdf
movl $0x83, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/echoseq.c
// Function: gt_encseq2fastaoutput
void gt_encseq2fastaoutput(FILE *fpout,
                           const char *desc,
                           const GtEncseq *encseq,
                           GtReadmode readmode,
                           GtUword start,
                           GtUword wlen,
                           GtUword width)
{
  gt_assert(width > 0);
  if (desc == NULL)
  {
    fprintf(fpout,">\n");
  } else
  {
    fprintf(fpout,">%s\n",desc);
  }
  gt_encseq2symbolstring(fpout,
                         encseq,
                         readmode,
                         start,
                         wlen,
                         width);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x40(%rsp), %r15
testq %r15, %r15
je 0x142f0d
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %rdx
movq %rdi, %r13
testq %rsi, %rsi
je 0x142ed4
leaq 0x1a730b(%rip), %rsi    # 0x2ea1d3
movq %r13, %rdi
xorl %eax, %eax
callq 0x17a50
jmp 0x142ee9
leaq 0x1ff119(%rip), %rdi    # 0x341ff4
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %r13, %rcx
callq 0x17f00
movq %r13, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
movq %r15, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x142d1c
movq 0x2f5054(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a20f5(%rip), %rsi    # 0x2e5013
leaq 0x2406f5(%rip), %rdx    # 0x38361a
leaq 0x1ff110(%rip), %rcx    # 0x34203c
leaq 0x1ff0ac(%rip), %r8     # 0x341fdf
movl $0x90, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/echoseq.c
// Function: gt_echodescriptionandsequence
int gt_echodescriptionandsequence(const GtStrArray *filenametab,GtError *err)
{
  GtSeqIterator *seqit;
  char *desc = NULL;
  const GtUchar *sequence;
  GtUword seqlen;
  bool haserr = false;
  int retval;

  seqit = gt_seq_iterator_sequence_buffer_new(filenametab, err);
  if (!seqit)
    return -1;
  while (true)
  {
    retval = gt_seq_iterator_next(seqit,
                                 &sequence,
                                 &seqlen,
                                 &desc,
                                 err);
    if (retval < 0)
    {
      haserr = true;
      break;
    }
    if (retval == 0)
    {
      break;
    }
    gt_symbolstring2fasta(stdout,desc,NULL,sequence,seqlen,70UL);
  }
  gt_seq_iterator_delete(seqit);
  return haserr ? -1 : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
andq $0x0, (%rsp)
callq 0xa70d0
testq %rax, %rax
je 0x142fc2
movq %rax, %r14
leaq 0x8(%rsp), %r12
movq %rsp, %r13
pushq $0x46
popq %rbp
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rbx, %r8
callq 0xa62e5
testl %eax, %eax
jle 0x142fb1
movq 0x2f4f1c(%rip), %rax    # 0x437eb0
movq (%rax), %rdi
movq (%rsp), %rsi
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
xorl %edx, %edx
movq %rbp, %r9
callq 0x142c20
jmp 0x142f73
movl %eax, %r15d
movq %r14, %rdi
callq 0xa6389
sarl $0x1f, %r15d
jmp 0x142fc6
pushq $-0x1
popq %r15
movl %r15d, %eax
addq $0x18, %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/match/eis-bwtseq-construct.c
// Function: gt_availBWTSeq
BWTSeq *
gt_availBWTSeq(const struct bwtParam *params, GtLogger *verbosity,
            GtError *err)
{
  struct BWTSeq *bwtSeq = NULL;
  Suffixarray suffixArray;
  GtUword len;
  gt_assert(params && err);
  gt_error_check(err);
  if (streamsuffixarray(&suffixArray, SARR_SUFTAB | SARR_BWTTAB
                        | SARR_ESQTAB, gt_str_get(params->projectName),
                        verbosity, err))
  {
    gt_error_unset(err);
    if (streamsuffixarray(&suffixArray, SARR_SUFTAB | SARR_ESQTAB,
                          gt_str_get(params->projectName), verbosity, err))
    {
      GtEncseqMetadata *emd = NULL;
      gt_error_unset(err);
      emd = gt_encseq_metadata_new(gt_str_get(params->projectName), err);
      if (emd == NULL)
        return NULL;
      len = gt_encseq_metadata_total_length(emd);
      gt_encseq_metadata_delete(emd);
    } else {
      len = gt_encseq_total_length(suffixArray.encseq) + 1;
    }
  } else {
    len = gt_encseq_total_length(suffixArray.encseq) + 1;
  }
  bwtSeq = gt_availBWTSeqFromSA(params, &suffixArray, len, err);
  gt_freesuffixarray(&suffixArray);
  return bwtSeq;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
testq %rdi, %rdi
je 0x1430df
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1430df
movq %rsi, %r15
movq %rdi, %r14
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x143109
movq 0x20(%r14), %rdi
callq 0xad1fa
leaq 0x8(%rsp), %rdi
pushq $0xb
popq %rsi
movq %rax, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x14d283
testl %eax, %eax
je 0x143098
movq %rbx, %rdi
callq 0x89efa
movq 0x20(%r14), %rdi
callq 0xad1fa
leaq 0x8(%rsp), %rdi
pushq $0x3
popq %rsi
movq %rax, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x14d283
testl %eax, %eax
je 0x143098
movq %rbx, %rdi
callq 0x89efa
movq 0x20(%r14), %rdi
callq 0xad1fa
movq %rax, %rdi
movq %rbx, %rsi
callq 0x87eb0
testq %rax, %rax
je 0x1430db
movq %rax, %r12
movq %rax, %rdi
callq 0x88588
movq %rax, %r15
movq %r12, %rdi
callq 0x888b5
jmp 0x1430a8
movq 0x8(%rsp), %rdi
callq 0x7055e
movq %rax, %r15
incq %r15
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x14313f
movq %rax, %rbx
movq %r12, %rdi
callq 0x14d148
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %ebx, %ebx
jmp 0x1430c9
movq 0x2f4e82(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a1f23(%rip), %rsi    # 0x2e5013
leaq 0x1ff010(%rip), %rdx    # 0x342107
leaq 0x1fef54(%rip), %rcx    # 0x342052
leaq 0x1fef5c(%rip), %r8     # 0x342061
pushq $0x25
jmp 0x143131
movq 0x2f4e58(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a1ef9(%rip), %rsi    # 0x2e5013
leaq 0x1a209e(%rip), %rdx    # 0x2e51bf
leaq 0x1fef2a(%rip), %rcx    # 0x342052
leaq 0x1fef32(%rip), %r8     # 0x342061
pushq $0x26
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-bwtseq-construct.c
// Function: gt_availBWTSeqFromSA
BWTSeq *
gt_availBWTSeqFromSA(const struct bwtParam *params, Suffixarray *sa,
                  GtUword totalLen, GtError *err)
{
  BWTSeq *bwtSeq;
  gt_assert(sa && params && err);
  gt_error_check(err);
  /* try loading index */
  bwtSeq = gt_loadBWTSeqForSA(gt_str_get(params->projectName),
                              params->seqParams.encType,
                              params->seqParams.EISFeatureSet,
                              gt_encseq_alphabet(sa->encseq), err);
  /* if loading didn't work try on-demand creation */
  if (!bwtSeq)
  {
    gt_error_unset(err);
    bwtSeq = gt_createBWTSeqFromSA(params, sa, totalLen, err);
  }
  else
  {
    fputs("Using pre-computed sequence index.\n", stderr);
  }
  return bwtSeq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x14320b
movq %rsi, %r15
testq %rsi, %rsi
je 0x14320b
movq %rcx, %rbx
testq %rcx, %rcx
je 0x14320b
movq %rdi, %r12
movq %rdx, (%rsp)
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x143235
movq 0x20(%r12), %rdi
callq 0xad1fa
movq %rax, %r13
movl (%r12), %ebp
movl 0x4(%r12), %r14d
movq (%r15), %rdi
callq 0x754dd
movq %r13, %rdi
movl %ebp, %esi
movl %r14d, %edx
movq %rax, %rcx
movq %rbx, %r8
callq 0x143419
testq %rax, %rax
jne 0x1431e0
movq %rbx, %rdi
callq 0x89efa
movq %r12, %rdi
movq %r15, %rsi
movq (%rsp), %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1433a6
movq %rax, %r13
movq 0x2f4d7e(%rip), %rax    # 0x437f68
movq (%rax), %rsi
leaq 0x1fef36(%rip), %rdi    # 0x34212a
callq 0x17870
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2f4d56(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a1df7(%rip), %rsi    # 0x2e5013
leaq 0x1feede(%rip), %rdx    # 0x342101
leaq 0x1feeeb(%rip), %rcx    # 0x342115
leaq 0x1fee30(%rip), %r8     # 0x342061
pushq $0x66
jmp 0x14325d
movq 0x2f4d2c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a1dcd(%rip), %rsi    # 0x2e5013
leaq 0x1a1f72(%rip), %rdx    # 0x2e51bf
leaq 0x1feec1(%rip), %rcx    # 0x342115
leaq 0x1fee06(%rip), %r8     # 0x342061
pushq $0x67
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-bwtseq-construct.c
// Function: gt_trSuftab2BWTSeq
BWTSeq *
gt_trSuftab2BWTSeq(const struct bwtParam *params, GtLogger *verbosity,
                GtError *err)
{
  struct BWTSeq *bwtSeq = NULL;
  Suffixarray suffixArray;
  GtUword len;
  gt_assert(params && err);
  gt_error_check(err);
  do
  {
    if (streamsuffixarray(&suffixArray,
                          SARR_SUFTAB | SARR_BWTTAB | SARR_ESQTAB,
                          gt_str_get(params->projectName), verbosity, err))
    {
      gt_error_unset(err);
      if (streamsuffixarray(&suffixArray, SARR_SUFTAB | SARR_ESQTAB,
                            gt_str_get(params->projectName), verbosity, err))
      {
        gt_error_set(err, "suffix array project %s does not hold required "
                     "suffix array (.suf) and encoded sequence (.esq) "
                     "information!", gt_str_get(params->projectName));
        break;
      }
    }
    len = gt_encseq_total_length(suffixArray.encseq) + 1;
    bwtSeq = gt_createBWTSeqFromSA(params, &suffixArray, len, err);
    gt_freesuffixarray(&suffixArray);
  } while (0);
  return bwtSeq;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
testq %rdi, %rdi
je 0x143346
movq %rdx, %rbx
testq %rdx, %rdx
je 0x143346
movq %rsi, %r15
movq %rdi, %r14
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x143370
movq 0x20(%r14), %rdi
callq 0xad1fa
movq %rsp, %rdi
pushq $0xb
popq %rsi
movq %rax, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x14d283
testl %eax, %eax
je 0x14330e
movq %rbx, %rdi
callq 0x89efa
movq 0x20(%r14), %rdi
callq 0xad1fa
movq %rsp, %rdi
pushq $0x3
popq %rsi
movq %rax, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x14d283
testl %eax, %eax
je 0x14330e
movq 0x20(%r14), %rdi
callq 0xad1fa
leaq 0x1fed99(%rip), %rsi    # 0x342095
xorl %r14d, %r14d
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x89dbb
jmp 0x143336
movq %rsp, %r15
movq (%r15), %rdi
callq 0x7055e
leaq 0x1(%rax), %rdx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x1433a6
movq %rax, %r14
movq %r15, %rdi
callq 0x14d148
movq %r14, %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
movq 0x2f4c1b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a1cbc(%rip), %rsi    # 0x2e5013
leaq 0x1feda9(%rip), %rdx    # 0x342107
leaq 0x1fed1d(%rip), %rcx    # 0x342082
leaq 0x1fecf5(%rip), %r8     # 0x342061
pushq $0x48
jmp 0x143398
movq 0x2f4bf1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a1c92(%rip), %rsi    # 0x2e5013
leaq 0x1a1e37(%rip), %rdx    # 0x2e51bf
leaq 0x1fecf3(%rip), %rcx    # 0x342082
leaq 0x1feccb(%rip), %r8     # 0x342061
pushq $0x49
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-bwtseq-construct.c
// Function: gt_createBWTSeqFromSA
BWTSeq *
gt_createBWTSeqFromSA(const struct bwtParam *params, Suffixarray *sa,
                   GtUword totalLen, GtError *err)
{
  BWTSeq *bwtSeq = NULL;
  if (!sa->longest.defined)
  {
    gt_log_log("error: position of null-rotation/longest suffix not available"
               " for project %s\n", gt_str_get(params->projectName));
  }
  else
  {
    SuffixarrayFileInterface sai;
    gt_initSuffixarrayFileInterface(&sai, totalLen, sa);
    bwtSeq = gt_createBWTSeqFromSAI(params, &sai, err);
    gt_destructSuffixarrayFileInterface(&sai);
  }
  return bwtSeq;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdi, %r14
cmpb $0x0, 0x38(%rsi)
je 0x1433ed
movq %rcx, %rbx
movq %rsi, %rax
movq %rsp, %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x14a055
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1435f8
movq %rax, %rbx
movq %r15, %rdi
callq 0x14a3cb
jmp 0x143409
movq 0x20(%r14), %rdi
callq 0xad1fa
leaq 0x1fed93(%rip), %rdi    # 0x342190
xorl %ebx, %ebx
movq %rax, %rsi
xorl %eax, %eax
callq 0x92a82
movq %rbx, %rax
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-bwtseq-construct.c
// Function: gt_loadBWTSeqForSA
BWTSeq *
gt_loadBWTSeqForSA(const char *projectName, enum seqBaseEncoding encType,
                   int BWTOptFlags, const GtAlphabet *gtalphabet,
                   GtError *err)
{
  struct BWTSeq *bwtSeq = NULL;
  EISeq *seqIdx = NULL;
  MRAEnc *alphabet = NULL;
  gt_assert(projectName && gtalphabet && err);
  alphabet = gt_SANewMRAEnc(gtalphabet);
  seqIdx = gt_loadEncIdxSeqForSA(gtalphabet, projectName, encType,
                                 gt_convertBWTOptFlags2EISFeatures(BWTOptFlags),
                                 err);
  if (seqIdx != NULL)
  {
    bwtSeq = gt_newBWTSeq(seqIdx, alphabet,
                          GTAlphabetRangeSort[GT_ALPHABETHANDLING_DEFAULT]);
  }
  if (!bwtSeq)
  {
    gt_MRAEncDelete(alphabet);
    if (seqIdx)
    {
      gt_deleteEncIdxSeq(seqIdx);
    }
  }
  return bwtSeq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1434b4
movq %rcx, %r15
testq %rcx, %rcx
je 0x1434b4
movq %r8, %r14
testq %r8, %r8
je 0x1434b4
movl %edx, %r13d
movl %esi, %ebp
movq %rdi, %r12
movq %r15, %rdi
callq 0x14a618
movq %rax, %rbx
movl %r13d, %edi
callq 0x1462ff
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
movl %eax, %ecx
movq %r14, %r8
callq 0x148292
testq %rax, %rax
je 0x14349b
movq %rax, %r14
leaq 0x1fedc7(%rip), %rdx    # 0x342240
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1468fc
testq %rax, %rax
jne 0x1434a5
movq %rbx, %rdi
callq 0x149458
movq %r14, %rdi
callq 0x1483fc
jmp 0x1434a3
movq %rbx, %rdi
callq 0x149458
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2f4aad(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a1b4e(%rip), %rsi    # 0x2e5013
leaq 0x1fec90(%rip), %rdx    # 0x34215c
leaq 0x1fecaa(%rip), %rcx    # 0x34217d
leaq 0x1feb87(%rip), %r8     # 0x342061
movl $0xa6, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-bwtseq-construct.c
// Function: gt_loadBWTSeq
BWTSeq *
gt_loadBWTSeq(const char *projectName, int BWTOptFlags,
              GT_UNUSED GtLogger *verbosity, GtError *err)
{
  struct BWTSeq *bwtSeq = NULL;
  GtEncseq *encseq;
  GtEncseqLoader *el;
  gt_assert(projectName && err);
  gt_error_check(err);

  el = gt_encseq_loader_new();
  gt_encseq_loader_do_not_require_sds_tab(el);
  gt_encseq_loader_do_not_require_des_tab(el);
  gt_encseq_loader_do_not_require_ssp_tab(el);
  encseq = gt_encseq_loader_load(el, projectName, err);
  gt_encseq_loader_delete(el);

  if (encseq == NULL)
    return NULL;
  bwtSeq = gt_loadBWTSeqForSA(projectName, BWT_ON_BLOCK_ENC, BWTOptFlags,
                           gt_encseq_alphabet(encseq), err);
  gt_encseq_delete(encseq);
  return bwtSeq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x143592
movq %rcx, %rbx
testq %rcx, %rcx
je 0x143592
movl %esi, %ebp
movq %rdi, %r14
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x1435c0
callq 0x791cd
movq %rax, %r12
movq %rax, %rdi
callq 0x7d25b
movq %r12, %rdi
callq 0x7d0cd
movq %r12, %rdi
callq 0x7d193
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7921d
movq %rax, %r15
movq %r12, %rdi
callq 0x79f01
testq %r15, %r15
je 0x143587
movq %r15, %rdi
callq 0x754dd
pushq $0x2
popq %rsi
movq %r14, %rdi
movl %ebp, %edx
movq %rax, %rcx
movq %rbx, %r8
callq 0x143419
movq %rax, %rbx
movq %r15, %rdi
callq 0x735fd
movq %rbx, %rax
jmp 0x143589
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x2f49cf(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a1a70(%rip), %rsi    # 0x2e5013
leaq 0x20017f(%rip), %rdx    # 0x343729
leaq 0x1feb9d(%rip), %rcx    # 0x34214e
leaq 0x1feaa9(%rip), %r8     # 0x342061
movl $0x8c, %r9d
jmp 0x1435ec
movq 0x2f49a1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a1a42(%rip), %rsi    # 0x2e5013
leaq 0x1a1be7(%rip), %rdx    # 0x2e51bf
leaq 0x1feb6f(%rip), %rcx    # 0x34214e
leaq 0x1fea7b(%rip), %r8     # 0x342061
movl $0x8d, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-bwtseq-construct.c
// Function: gt_createBWTSeqFromSAI
BWTSeq *
gt_createBWTSeqFromSAI(const struct bwtParam *params,
                    SuffixarrayFileInterface *sai,
                    GtError *err)
{
  BWTSeq *bwtSeq;
  SpecialsRankLookup *sprTable = NULL;
  const enum rangeSortMode *rangeSort;
  gt_assert(sai && err && params);
  buildSpRTable(params, SAIGetLength(sai), SAIGetEncSeq(sai),
                SAIGetGtReadmode(sai), &sprTable, &rangeSort);
  bwtSeq = gt_createBWTSeqFromSASS(params, SAI2SASS(sai), sprTable, rangeSort,
                                err);
  if (sprTable)
    gt_deleteSpecialsRankLookup(sprTable);
  return bwtSeq;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
andq $0x0, (%rsp)
testq %rdi, %rdi
je 0x14367d
movq %rsi, %r14
testq %rsi, %rsi
je 0x14367d
movq %rdx, %rbx
testq %rdx, %rdx
je 0x14367d
movq %rdi, %r15
movq (%r14), %rsi
movq 0xd0(%r14), %rax
movq (%rax), %rdx
movl 0x48(%rax), %ecx
movq %rsp, %r12
leaq 0x8(%rsp), %r13
movq %r12, %r8
movq %r13, %r9
callq 0x1436b5
movq (%r12), %rdx
movq (%r13), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %r8
callq 0x143714
movq %rax, %rbx
movq (%r12), %rdi
testq %rdi, %rdi
je 0x14366c
callq 0x149ea8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x2f48e4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a1985(%rip), %rsi    # 0x2e5013
leaq 0x1feb49(%rip), %rdx    # 0x3421de
leaq 0x1feb57(%rip), %rcx    # 0x3421f3
leaq 0x1fe9be(%rip), %r8     # 0x342061
movl $0xf4, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-bwtseq-construct.c
// Function: buildSpRTable
static inline void
buildSpRTable(const struct bwtParam *params,
              GtUword totalLen,
              const GtEncseq *encseq,
              GtReadmode readmode,
              SpecialsRankLookup **sprTable,
              const enum rangeSortMode **rangeSort)
{
  if (params->featureToggles & BWTReversiblySorted)
  {
    int sampleIntervalLog2 = params->sourceRankInterval;
    if (sampleIntervalLog2 == -1)
    {
      sampleIntervalLog2
        = gt_requiredUIntBits(requiredUlongBits(totalLen));
    }
    *sprTable = gt_newSpecialsRankLookup(encseq, readmode, sampleIntervalLog2);
  }
  *rangeSort = GTAlphabetRangeSort[sprTable?
                                   GT_ALPHABETHANDLING_W_RANK:
                                   GT_ALPHABETHANDLING_DEFAULT];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
testb $0x4, 0x10(%rdi)
je 0x1436f3
movl %ecx, %ebp
movq %rdx, %r15
movl 0x18(%rdi), %edx
cmpl $-0x1, %edx
jne 0x1436e6
movq %rsi, %rdi
callq 0x28a939
movl %eax, %edi
callq 0x28a8fc
movl %eax, %edx
movq %r15, %rdi
movl %ebp, %esi
callq 0x149c40
movq %rax, (%r14)
xorl %eax, %eax
testq %r14, %r14
setne %al
leaq 0x1feb3e(%rip), %rcx    # 0x342240
leaq (%rcx,%rax,8), %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-bwtseq-construct.c
// Function: gt_createBWTSeqFromSASS
static BWTSeq *
gt_createBWTSeqFromSASS(const struct bwtParam *params, SASeqSrc *src,
                     SpecialsRankLookup *sprTable,
                     const enum rangeSortMode *rangeSort,
                     GtError *err)
{
  EISeq *seqIdx = NULL;
  BWTSeq *bwtSeq = NULL;
  seqIdx = gt_createBWTSeqGeneric(params, gt_createEncIdxSeqGen, src,
                               rangeSort, sprTable, err);
  if (seqIdx)
  {
    MRAEnc *alphabet = SASSNewMRAEnc(src);
    bwtSeq = gt_newBWTSeq(seqIdx, alphabet, rangeSort);
    if (!bwtSeq)
    {
      gt_deleteEncIdxSeq(seqIdx);
      gt_MRAEncDelete(alphabet);
    }
  }
  return bwtSeq;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r9
movq %rcx, %rbx
movq %rdx, %r8
movq %rsi, %r15
leaq 0x4b3e(%rip), %rsi      # 0x14826a
movq %r15, %rdx
callq 0x14478c
testq %rax, %rax
je 0x143769
movq %rax, %r14
movq %r15, %rdi
callq *0x40(%r15)
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x1468fc
testq %rax, %rax
jne 0x14376b
movq %r14, %rdi
callq 0x1483fc
movq %r15, %rdi
callq 0x149458
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-bwtseq-construct.c
// Function: gt_createBWTSeqFromSfxI
BWTSeq *
gt_createBWTSeqFromSfxI(const struct bwtParam *params, sfxInterface *sfxi,
                     GtError *err)
{
  BWTSeq *bwtSeq;
  SpecialsRankLookup *sprTable = NULL;
  const enum rangeSortMode *rangeSort;
  gt_assert(sfxi && params && err);
  buildSpRTable(params, gt_SfxIGetLength(sfxi), gt_SfxIGetEncSeq(sfxi),
                gt_SfxIGetReadmode(sfxi), &sprTable, &rangeSort);
  bwtSeq = gt_createBWTSeqFromSASS(params, gt_SfxI2SASS(sfxi), sprTable,
                                   rangeSort,
                                   err);
  if (sprTable)
    gt_deleteSpecialsRankLookup(sprTable);
  return bwtSeq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
andq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x143828
movq %rsi, %r15
testq %rsi, %rsi
je 0x143828
movq %rdx, %rbx
testq %rdx, %rdx
je 0x143828
movq %rdi, %r14
movq %r15, %rdi
callq 0x14ae54
movq %rax, %r12
movq %r15, %rdi
callq 0x14aeac
movq %rax, %r13
movq %r15, %rdi
callq 0x14aeb4
leaq 0x8(%rsp), %rbp
leaq 0x10(%rsp), %r9
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %eax, %ecx
movq %rbp, %r8
movq %r9, %r12
callq 0x1436b5
movq %r15, %rdi
callq 0x14a674
movq (%rbp), %rdx
movq (%r12), %rcx
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %r8
callq 0x143714
movq %rax, %rbx
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x143816
callq 0x149ea8
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2f4739(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a17da(%rip), %rsi    # 0x2e5013
leaq 0x1fe9ca(%rip), %rdx    # 0x34220a
leaq 0x1fe9d9(%rip), %rcx    # 0x342220
leaq 0x1fe813(%rip), %r8     # 0x342061
movl $0x105, %r9d            # imm = 0x105
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-bwtseq-context.c
// Function: gt_newBWTSeqContextRetrieverFactory
BWTSeqContextRetrieverFactory *
gt_newBWTSeqContextRetrieverFactory(GtUword seqLen, short mapIntervalLog2)
{
  BWTSeqContextRetrieverFactory *newFactory;
  newFactory = gt_malloc(sizeof (*newFactory));
  initBWTSeqContextRetrieverFactory(newFactory, seqLen, mapIntervalLog2);
  return newFactory;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
movl %esi, %ebp
movq %rdi, %r14
leaq 0x1fea71(%rip), %rsi    # 0x342322
pushq $0x30
popq %rdi
pushq $0x64
popq %rdx
callq 0x93160
movq %rax, %rbx
cmpw $-0x3, %bp
jbe 0x1438e2
cmpw $-0x1, %bp
movw $0xfffe, %bp            # imm = 0xFFFE
jne 0x143914
movq %r14, %rdi
callq 0x28a939
movl %eax, %edi
callq 0x28a8fc
movl %eax, %ebp
jmp 0x143914
testw %bp, %bp
js 0x1439dc
movzwl %bp, %r15d
movq %r14, %rdi
callq 0x28a939
cmpl $0x3f, %eax
ja 0x143908
movq %r14, %rdi
callq 0x28a939
cltq
jmp 0x14390b
pushq $0x40
popq %rax
cmpq %r15, %rax
jbe 0x1439dc
movq %r14, (%rbx)
andq $0x0, 0x8(%rbx)
pushq $-0x1
popq %rax
movl %ebp, %ecx
shll %cl, %eax
notl %eax
movq %rax, 0x10(%rbx)
movw %bp, 0x1a(%rbx)
movb $0x0, 0x18(%rbx)
callq 0xacb84
movq %rax, 0x28(%rbx)
leaq 0x1fe9e1(%rip), %rdx    # 0x342322
pushq $0x5
popq %rsi
pushq $0x4e
popq %rcx
movq %rax, %rdi
callq 0x8abea
pushq $0x1
popq %rdx
movl %ebp, %ecx
shll %cl, %edx
movq %rax, %r15
movq %rax, 0x20(%rbx)
movslq %edx, %rax
addq %rax, %r14
decq %r14
shrq %cl, %r14
movq %rsp, %r12
movl $0x2000, %edx           # imm = 0x2000
movq %r12, %rdi
xorl %esi, %esi
callq 0x17380
movl $0x400, %ebp            # imm = 0x400
pushq $0x8
popq %r13
cmpq %r14, %rbp
jge 0x1439a5
movl $0x400, %edx            # imm = 0x400
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rcx
callq 0xb302c
addq $0x400, %rbp            # imm = 0x400
jmp 0x143984
movl $0x400, %ecx            # imm = 0x400
movq %r14, %rax
cqto
idivq %rcx
testq %rdx, %rdx
je 0x1439c7
movl %edx, %edx
movq %rsp, %rdi
pushq $0x8
popq %rsi
movq %r15, %rcx
callq 0xb302c
movq %rbx, %rax
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2f4585(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a1626(%rip), %rsi    # 0x2e5013
leaq 0x1fea73(%rip), %rdx    # 0x342467
leaq 0x1fea97(%rip), %rcx    # 0x342492
leaq 0x1fe920(%rip), %r8     # 0x342322
pushq $0x41
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-bwtseq-context.c
// Function: gt_BWTSCRFReadAdvance
GtUword
gt_BWTSCRFReadAdvance(BWTSeqContextRetrieverFactory *factory,
                   GtUword chunkSize,
                   SeqDataReader readSfxIdx)
{
  GtUword buf[BLOCK_IO_SIZE], sfxIdxLeft = chunkSize;
  gt_assert(factory);
  while (sfxIdxLeft)
  {
    GtUword len = GT_MIN(BLOCK_IO_SIZE, sfxIdxLeft);
    if (SDRRead(readSfxIdx, buf, len)
        != len)
    {
      fputs("error: short read when building context retriever!\n", stderr);
      abort();
    }
    gt_BWTSCRFMapAdvance(factory, buf, len);
    sfxIdxLeft -= len;
  }
  return chunkSize - sfxIdxLeft;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2018, %rsp           # imm = 0x2018
testq %rdi, %rdi
je 0x143ad6
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r12
leaq 0x10(%rsp), %r13
movq %rsi, 0x8(%rsp)
movq %rsi, %r14
testq %r14, %r14
je 0x143aa4
movl $0x400, %eax            # imm = 0x400
cmpq %rax, %r14
movl $0x400, %ebp            # imm = 0x400
cmovbq %r14, %rbp
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq *%rbx
cmpq %rbp, %rax
jne 0x143abb
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x143b0e
subq %rbp, %r14
jmp 0x143a6b
movq 0x8(%rsp), %rax
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2f44a6(%rip), %rax    # 0x437f68
movq (%rax), %rsi
leaq 0x1fe893(%rip), %rdi    # 0x34235f
callq 0x17870
callq 0x17390
movq 0x2f448b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a152c(%rip), %rsi    # 0x2e5013
leaq 0x1fe853(%rip), %rdx    # 0x342341
leaq 0x1fe854(%rip), %rcx    # 0x342349
leaq 0x1fe826(%rip), %r8     # 0x342322
movl $0x8d, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-bwtseq-context.c
// Function: gt_BWTSCRFMapAdvance
size_t
gt_BWTSCRFMapAdvance(BWTSeqContextRetrieverFactory *factory,
                  const GtUword *src,
                  size_t len)
{
  GtUword currentSfxPos;
  gt_assert(factory);
  currentSfxPos = factory->currentSfxPos;
  {
    size_t i;
    GtUword mask = factory->moduloMask,
      seqLen = factory->seqLen;
    for (i = 0; i < len; ++i)
    {
      if (!(((src[i] + seqLen - 1)%seqLen) & mask))
        addMapVal(factory, currentSfxPos + i, ((src[i] + seqLen - 1)%seqLen));
    }
  }
  factory->currentSfxPos = currentSfxPos + len;
  return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x143be7
movq %rdx, %r13
movq %rsi, %rbp
movq (%rdi), %r14
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rdi), %r9
leaq -0x1(%r14), %r10
xorl %r15d, %r15d
movq %r9, 0x18(%rsp)
movq %r10, 0x10(%rsp)
cmpq %r15, %r13
je 0x143bb8
movq (%rbp,%r15,8), %rax
addq %r10, %rax
xorl %edx, %edx
divq %r14
testq %r9, %rdx
jne 0x143bb3
movb 0x1a(%rdi), %cl
sarq %cl, %rdx
movq 0x8(%rsp), %rax
addq %r15, %rax
shlq $0x3, %rdx
movq %rax, 0x20(%rsp)
movq %rdi, %rbx
movq 0x20(%rdi), %r12
movq %r12, %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x17c70
cmpl $-0x1, %eax
je 0x143bd6
leaq 0x20(%rsp), %rdi
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %r12, %rcx
callq 0xb302c
movq %rbx, %rdi
movq 0x18(%rsp), %r9
movq 0x10(%rsp), %r10
incq %r15
jmp 0x143b4c
movq 0x8(%rsp), %rax
addq %r13, %rax
movq %rax, 0x8(%rdi)
movq %r13, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1fe8d7(%rip), %rdi    # 0x3424b4
movl $0x80, %esi
callq 0x144645
movq 0x2f437a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a141b(%rip), %rsi    # 0x2e5013
leaq 0x1fe742(%rip), %rdx    # 0x342341
leaq 0x1fe78d(%rip), %rcx    # 0x342393
leaq 0x1fe715(%rip), %r8     # 0x342322
movl $0xa3, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-bwtseq-context.c
// Function: gt_BWTSeqCRLoad
BWTSeqContextRetriever *
gt_BWTSeqCRLoad(const BWTSeq *bwtSeq,
             const char *projectName,
             short mapIntervalLog2)
{
  GtUword seqLen;
  unsigned short bitsPerUlong;
  BWTSeqContextRetriever *gt_newBWTSeqCR;
  gt_assert(bwtSeq && projectName);
  seqLen = BWTSeqLength(bwtSeq);
  bitsPerUlong = requiredUlongBits(seqLen - 1);
  gt_newBWTSeqCR = gt_malloc(sizeof (*gt_newBWTSeqCR));
  gt_newBWTSeqCR->bitsPerUlong = bitsPerUlong;
  gt_newBWTSeqCR->bwtSeq = bwtSeq;
  if (mapIntervalLog2 != CTX_MAP_ILOG_AUTOSIZE)
  {
    if (!BWTSeqCRMapOpen(mapIntervalLog2, bitsPerUlong, seqLen,
                         projectName, false, gt_newBWTSeqCR))
    {
      gt_free(gt_newBWTSeqCR);
      return NULL;
    }
  }
  else
  {
    short mapIntervalLog2Max = bitsPerUlong;
    mapIntervalLog2 = 0;
    while (!BWTSeqCRMapOpen(mapIntervalLog2, bitsPerUlong, seqLen,
                            projectName, false, gt_newBWTSeqCR)
           && mapIntervalLog2 < mapIntervalLog2Max)
      ++mapIntervalLog2;
    if (!gt_newBWTSeqCR->revMap)
    {
      gt_free(gt_newBWTSeqCR);
      return NULL;
    }
  }
  gt_newBWTSeqCR->mapIntervalLog2 = mapIntervalLog2;
  gt_newBWTSeqCR->mapInterval = 1 << mapIntervalLog2;
  gt_newBWTSeqCR->mapMask = gt_newBWTSeqCR->mapInterval - 1;
  return gt_newBWTSeqCR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x144143
movq %rsi, %r14
testq %rsi, %rsi
je 0x144143
movl %edx, %ebp
movq %rdi, %r12
movq (%rdi), %rax
movq 0x10(%rax), %r15
leaq -0x1(%r15), %rdi
callq 0x28a939
movl %eax, %r13d
leaq 0x1fe2a7(%rip), %rsi    # 0x342322
pushq $0x30
popq %rdi
movl $0x15d, %edx            # imm = 0x15D
callq 0x93160
movq %rax, %rbx
movw %r13w, 0x2a(%rax)
movq %r12, 0x10(%rax)
cmpw $-0x1, %bp
je 0x1440c7
movzwl %bp, %edi
movzwl %r13w, %esi
movq %r15, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x143ddc
testb %al, %al
jne 0x144102
leaq 0x1fe265(%rip), %rsi    # 0x342322
movq %rbx, %rdi
movl $0x165, %edx            # imm = 0x165
jmp 0x14412a
movl %r13d, %eax
movswl %ax, %r13d
movw $0xffff, %bp            # imm = 0xFFFF
movzwl %ax, %r12d
incl %ebp
movzwl %bp, %edi
movl %r12d, %esi
movq %r15, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x143ddc
testb %al, %al
jne 0x1440fb
movswl %bp, %eax
cmpl %eax, %r13d
jg 0x1440d6
cmpq $0x0, 0x20(%rbx)
je 0x14411b
movw %bp, 0x28(%rbx)
pushq $0x1
popq %rax
movl %ebp, %ecx
shll %cl, %eax
cltq
movq %rax, (%rbx)
decq %rax
movq %rax, 0x8(%rbx)
jmp 0x144131
leaq 0x1fe200(%rip), %rsi    # 0x342322
movq %rbx, %rdi
movl $0x173, %edx            # imm = 0x173
callq 0x936f9
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2f3e1e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1a0ebf(%rip), %rsi    # 0x2e5013
leaq 0x1fe272(%rip), %rdx    # 0x3423cd
leaq 0x1fe281(%rip), %rcx    # 0x3423e3
leaq 0x1fe1b9(%rip), %r8     # 0x342322
movl $0x15a, %r9d            # imm = 0x15A
xorl %eax, %eax
callq 0x17a50
callq 0x17390