LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq 0x10(%rsi), %rax
addq (%rax), %rdx
movl $0x38, %ecx
xorl %eax, %eax
movq %rdx, %r8
movzbl (%r8), %r9d
shlq %cl, %r9
orq %r9, %rax
addq $-0x8, %rcx
incq %r8
cmpq $-0x8, %rcx
jne 0x197ab6
movb 0x86(%rsi), %cl
movq %rax, %r8
shrq %cl, %r8
andl 0x20(%rsi), %r8d
movl %r8d, 0x4(%rdi)
movb 0x88(%rsi), %cl
movq %rax, %r8
shrq %cl, %r8
andl 0x28(%rsi), %r8d
movl %r8d, (%rdi)
movq 0x40(%rsi), %r8
movq 0x90(%rsi), %r10
cmpq $0x8, %r10
je 0x197b2b
movl $0x38, %ecx
movl $0x8, %r11d
xorl %r9d, %r9d
movzbl (%rdx,%r11), %ebx
shlq %cl, %rbx
orq %rbx, %r9
addl $-0x8, %ecx
incq %r11
cmpq %r11, %r10
jne 0x197b13
jmp 0x197b2e
xorl %r9d, %r9d
andq %rax, %r8
movb 0xac(%rsi), %cl
shrq %cl, %r9
movb 0xa8(%rsi), %cl
shlq %cl, %r8
movb 0x80(%rsi), %cl
orq %r9, %r8
movl 0x38(%rsi), %eax
andl %r8d, %eax
shrq %cl, %r8
movl %r8d, 0xc(%rdi)
movl %eax, 0x8(%rdi)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x198701
subq (%rdi), %rsi
jb 0x1986fc
cmpq 0x8(%rdi), %rsi
jae 0x1986fc
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 0x1986fc
orq %r8, %rdi
movq %rdi, (%rax,%rdx,8)
popq %rax
retq
callq 0x5e0d8
callq 0x5e111
// File: /workspace/github_c_makefile_star2_O3/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 0x1e1f74
movq %rax, %r13
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x1e1f9a
movq 0x60(%rsp), %rdi
movq %rax, %rbp
testq %rdi, %rdi
je 0x19875d
leaq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0xec19e
jmp 0x198764
leaq 0x208e3d(%rip), %rax    # 0x3a15a1
subq %r13, %rbp
subq %r12, %r13
xorl %ecx, %ecx
movq %rcx, 0x8(%r14)
addq %r13, %r15
movq %r15, (%r14)
movq %rax, 0x10(%r14)
incq %rbp
movq %rbp, 0x20(%r14)
movq %rcx, 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_O3/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), %r8d
subl %ecx, %r8d
incl %r8d
movl 0x8(%rsi), %edx
movl 0x4(%rsi), %r9d
subl %edx, %r9d
incl %r9d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %r9d, %r8d
jae 0x198921
retq
cmpl %edx, %ecx
jb 0x198953
cmpl %r9d, %r8d
ja 0x198953
movl (%rdi), %edi
subl %ecx, %edi
incl %edi
movl (%rsi), %esi
subl %edx, %esi
incl %esi
cmpl %edx, %ecx
seta %cl
cmpl %esi, %edi
setb %dl
orb %cl, %dl
jne 0x198920
movl $0x1, %eax
cmpl %esi, %edi
ja 0x198920
pushq %rax
callq 0x5e183
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_chain_out
static void gt_diagbandseed_chain_out(void *data,
                                      const GtChain2Dimmatchtable *matchtable,
                                      const GtChain2Dim *chain)
{
  GtUword idx, chainlength;
  const GtDiagbandseedSequencePair *sequencepair
    = (const GtDiagbandseedSequencePair *) data;

  gt_assert(chain != NULL);
  chainlength = gt_chain_chainlength(chain);
  printf("# chain of length " GT_WU " with score " GT_WD "\n",
         chainlength,gt_chain_chainscore(chain));

  gt_assert(!gt_chain_storedinreverseorder(chain));
  for (idx = 0; idx < chainlength; idx++)
  {
    GtChain2Dimmatchvalues value;

    gt_chain_extractchainelem(&value, matchtable, chain, idx);
    gt_assert(value.startpos[0] <= value.endpos[0] &&
              value.weight >= 0 &&
              value.endpos[0] - value.startpos[0] + 1
                        == (GtUword) value.weight &&
              value.startpos[1] <= value.endpos[1] &&
              value.endpos[1] - value.startpos[1] + 1
                        == (GtUword) value.weight);

    gt_diagbandseed_printchainelem(stdout,
                                   sequencepair->aseqnum,
                                   value.startpos[0],
                                   sequencepair->bseqnum,
                                   value.startpos[1],
                                   (GtUword) value.weight);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdx, %rdx
je 0x198a4d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x18e30e
movq %rax, %r12
movq %rbx, %rdi
callq 0x18e309
leaq 0x208e61(%rip), %rdi    # 0x3a17f4
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x17070
movq %rbx, %rdi
callq 0x18e313
testb %al, %al
jne 0x198a52
testq %r12, %r12
je 0x198a39
leaq 0x20737b(%rip), %rbp    # 0x39fd3b
xorl %r13d, %r13d
movq %rsp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x18e317
movq (%rsp), %r8
movq 0x10(%rsp), %rax
subq %r8, %rax
jb 0x198a48
movq 0x20(%rsp), %rdx
testq %rdx, %rdx
js 0x198a48
incq %rax
cmpq %rdx, %rax
jne 0x198a48
movq 0x8(%rsp), %r10
movq 0x18(%rsp), %rax
subq %r10, %rax
jb 0x198a48
incq %rax
cmpq %rdx, %rax
jne 0x198a48
movq 0x3204c6(%rip), %rax    # 0x4b8ed8
movq (%rax), %rdi
movl (%r15), %ecx
movl 0x4(%r15), %r11d
movq %rbp, %rsi
movq %rdx, %r9
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x17ab0
addq $0x10, %rsp
incq %r13
cmpq %r13, %r12
jne 0x1989c3
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5e1bc
callq 0x5e22e
callq 0x5e1f5
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x198b2a
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rdx
movq %rdi, %r12
testq %rsi, %rsi
je 0x198a97
leaq 0x1b1748(%rip), %rsi    # 0x34a1d3
movq %r12, %rdi
xorl %eax, %eax
callq 0x17ab0
jmp 0x198ab0
leaq 0x209267(%rip), %rdi    # 0x3a1d05
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rcx
callq 0x17fa0
decq %r14
xorl %ebx, %ebx
xorl %ebp, %ebp
movb (%r15,%rbp), %al
cmpb $-0x1, %al
je 0x198aea
movzbl %al, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0xd156a
cmpq %rbp, %r14
je 0x198b0f
incq %rbx
cmpq (%rsp), %rbx
jb 0x198b0a
movl $0xa, %edi
movq %r12, %rsi
callq 0x17980
jmp 0x198b08
movl $0x3, %esi
movl $0x1, %edx
leaq 0x209209(%rip), %rdi    # 0x3a1d04
movq %r12, %rcx
callq 0x17fa0
cmpq %rbp, %r14
je 0x198b0f
xorl %ebx, %ebx
incq %rbp
jmp 0x198ab7
movl $0xa, %edi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17980
callq 0x5e267
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movq %rsi, %r13
movq %rdi, %r15
movq %rsi, %rdi
movl %edx, %esi
movq %rcx, %rdx
callq 0xe91b2
testq %rbx, %rbx
je 0x198bed
movq %rax, %r12
movq %r13, %rdi
callq 0xebcd9
movq %rax, %r13
decq %r14
xorl %ebp, %ebp
movq %r12, %rdi
callq 0xe8186
cmpb $-0x1, %al
je 0x198ba5
movzbl %al, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0xd156a
testq %r14, %r14
je 0x198bca
incq %rbp
cmpq %rbx, %rbp
jb 0x198bc5
movl $0xa, %edi
movq %r15, %rsi
callq 0x17980
jmp 0x198bc3
movl $0x3, %esi
movl $0x1, %edx
leaq 0x20914e(%rip), %rdi    # 0x3a1d04
movq %r15, %rcx
callq 0x17fa0
testq %r14, %r14
je 0x198bca
xorl %ebp, %ebp
decq %r14
jmp 0x198b6f
movl $0xa, %edi
movq %r15, %rsi
callq 0x17980
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe9204
callq 0x5e29e
// File: /workspace/github_c_makefile_star2_O3/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 0xebcd9
movq %rax, %r13
leaq (%rbx,%r14), %rax
cmpq %r14, %rax
jbe 0x198c42
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xe7bbc
cmpb $-0x2, %al
jae 0x198c4c
movzbl %al, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0xd156a
incq %r14
decq %rbx
jne 0x198c1b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x5e2d5
// File: /workspace/github_c_makefile_star2_O3/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 0x198ccc
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %rdx
movq %rdi, %r13
testq %rsi, %rsi
je 0x198c8f
leaq 0x1b1550(%rip), %rsi    # 0x34a1d3
movq %r13, %rdi
xorl %eax, %eax
callq 0x17ab0
jmp 0x198ca8
leaq 0x20906f(%rip), %rdi    # 0x3a1d05
movl $0x2, %esi
movl $0x1, %edx
movq %r13, %rcx
callq 0x17fa0
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 0x198b2f
callq 0x5e30e
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movq $0x0, (%rsp)
callq 0x114f10
testq %rax, %rax
je 0x198d6c
movq %rax, %rbx
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rsp, %rcx
movq %rax, %rdi
movq %r14, %r8
callq 0x11433d
testl %eax, %eax
jle 0x198d5d
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %rsp, %r13
movq 0x3201b1(%rip), %rax    # 0x4b8ed8
movq (%rax), %rdi
movq (%rsp), %rsi
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
movl $0x46, %r9d
xorl %edx, %edx
callq 0x198a58
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x11433d
testl %eax, %eax
jg 0x198d20
movl %eax, %ebp
movq %rbx, %rdi
callq 0x11437f
sarl $0x1f, %ebp
jmp 0x198d71
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x198e8f
movq %rdx, %rbx
testq %rdx, %rdx
je 0x198e8f
movq %rsi, %r15
movq %rdi, %r14
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x198e94
movq 0x20(%r14), %rdi
callq 0x11b0a1
leaq 0x8(%rsp), %rdi
movl $0xb, %esi
movq %rax, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x1a1676
testl %eax, %eax
je 0x198e48
movq %rbx, %rdi
callq 0xfcc44
movq 0x20(%r14), %rdi
callq 0x11b0a1
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movq %rax, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x1a1676
testl %eax, %eax
je 0x198e48
movq %rbx, %rdi
callq 0xfcc44
movq 0x20(%r14), %rdi
callq 0x11b0a1
movq %rax, %rdi
movq %rbx, %rsi
callq 0xfb8bc
testq %rax, %rax
je 0x198e8b
movq %rax, %r12
movq %rax, %rdi
callq 0xfbed4
movq %rax, %r15
movq %r12, %rdi
callq 0xfbf9f
jmp 0x198e58
movq 0x8(%rsp), %rdi
callq 0xe7b9c
movq %rax, %r15
incq %r15
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x198e99
movq %rax, %rbx
movq %r12, %rdi
callq 0x1a1540
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %ebx, %ebx
jmp 0x198e79
callq 0x5e347
callq 0x5e37e
// File: /workspace/github_c_makefile_star2_O3/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 0x198f50
movq %rsi, %r15
testq %rsi, %rsi
je 0x198f50
movq %rcx, %rbx
testq %rcx, %rcx
je 0x198f50
movq %rdi, %r12
movq %rdx, (%rsp)
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x198f55
movq 0x20(%r12), %rdi
callq 0x11b0a1
movq %rax, %r13
movl (%r12), %ebp
movl 0x4(%r12), %r14d
movq (%r15), %rdi
callq 0xebcd9
movq %r13, %rdi
movl %ebp, %esi
movl %r14d, %edx
movq %rax, %rcx
movq %rbx, %r8
callq 0x1990b6
testq %rax, %rax
jne 0x198f36
movq %rbx, %rdi
callq 0xfcc44
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 0x199043
movq %rax, %r13
callq 0x5e3ec
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5e3b5
callq 0x5e402
// File: /workspace/github_c_makefile_star2_O3/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 0x199039
movq %rdx, %rbx
testq %rdx, %rdx
je 0x199039
movq %rsi, %r15
movq %rdi, %r14
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x19903e
movq 0x20(%r14), %rdi
callq 0x11b0a1
movq %rsp, %rdi
movl $0xb, %esi
movq %rax, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x1a1676
testl %eax, %eax
je 0x199001
movq %rbx, %rdi
callq 0xfcc44
movq 0x20(%r14), %rdi
callq 0x11b0a1
movq %rsp, %rdi
movl $0x3, %esi
movq %rax, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x1a1676
testl %eax, %eax
je 0x199001
movq 0x20(%r14), %rdi
callq 0x11b0a1
leaq 0x208db7(%rip), %rsi    # 0x3a1da6
xorl %r14d, %r14d
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfcb67
jmp 0x199029
movq %rsp, %r15
movq (%r15), %rdi
callq 0xe7b9c
leaq 0x1(%rax), %rdx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x199043
movq %rax, %r14
movq %r15, %rdi
callq 0x1a1540
movq %r14, %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
callq 0x5e439
callq 0x5e470
// File: /workspace/github_c_makefile_star2_O3/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 0x19908a
movq %rcx, %rbx
movq %rsi, %rax
movq %rsp, %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x19ecc9
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x199204
movq %rax, %rbx
movq %r15, %rdi
callq 0x19ef84
jmp 0x1990a6
movq 0x20(%r14), %rdi
callq 0x11b0a1
leaq 0x208e07(%rip), %rdi    # 0x3a1ea1
xorl %ebx, %ebx
movq %rax, %rsi
xorl %eax, %eax
callq 0x103d72
movq %rbx, %rax
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x199151
movq %rcx, %r15
testq %rcx, %rcx
je 0x199151
movq %r8, %r14
testq %r8, %r8
je 0x199151
movl %edx, %r13d
movl %esi, %ebp
movq %rdi, %r12
movq %r15, %rdi
callq 0x19f128
movq %rax, %rbx
movl %r13d, %edi
callq 0x19b727
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
movl %eax, %ecx
movq %r14, %r8
callq 0x19d00e
testq %rax, %rax
je 0x199138
movq %rax, %r14
leaq 0x208e3a(%rip), %rdx    # 0x3a1f50
movq %rax, %rdi
movq %rbx, %rsi
callq 0x19bafc
testq %rax, %rax
jne 0x199142
movq %rbx, %rdi
callq 0x19e389
movq %r14, %rdi
callq 0x19d11c
jmp 0x199140
movq %rbx, %rdi
callq 0x19e389
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5e4a7
// File: /workspace/github_c_makefile_star2_O3/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 0x1991fa
movq %rcx, %rbx
testq %rcx, %rcx
je 0x1991fa
movl %esi, %ebp
movq %rdi, %r14
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1991ff
callq 0xef0cd
movq %rax, %r12
movq %rax, %rdi
callq 0xf2408
movq %r12, %rdi
callq 0xf23ac
movq %r12, %rdi
callq 0xf23d9
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xef129
movq %rax, %r15
movq %r12, %rdi
callq 0xefbe3
testq %r15, %r15
je 0x1991ef
movq %r15, %rdi
callq 0xebcd9
movq %r14, %rdi
movl $0x2, %esi
movl %ebp, %edx
movq %rax, %rcx
movq %rbx, %r8
callq 0x1990b6
movq %rax, %rbx
movq %r15, %rdi
callq 0xea375
movq %rbx, %rax
jmp 0x1991f1
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x5e4e0
callq 0x5e519
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x1992ba
movq %rsi, %r14
testq %rsi, %rsi
je 0x1992ba
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1992ba
movq %rdi, %r15
testb $0x4, 0x10(%rdi)
jne 0x199252
leaq 0x208d1b(%rip), %rcx    # 0x3a1f58
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1992bf
movq 0xd0(%r14), %rax
movq (%rax), %r12
movl 0x48(%rax), %ebp
movl 0x18(%r15), %edx
cmpl $-0x1, %edx
jne 0x199279
movq (%r14), %rdi
callq 0x2f09dd
movl %eax, %edi
callq 0x2f09a0
movl %eax, %edx
movq %r12, %rdi
movl %ebp, %esi
callq 0x19e938
movq %rax, %r12
leaq 0x208ccb(%rip), %rcx    # 0x3a1f58
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq %rbx, %r8
callq 0x1992bf
movq %rax, %rbx
testq %r12, %r12
je 0x1992ae
movq %r12, %rdi
callq 0x19ebbf
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x5e552
// File: /workspace/github_c_makefile_star2_O3/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 0x3d0f(%rip), %rsi      # 0x19cfe6
movq %r15, %rdx
callq 0x19a00c
testq %rax, %rax
je 0x199314
movq %rax, %r14
movq %r15, %rdi
callq *0x40(%r15)
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x19bafc
testq %rax, %rax
jne 0x199316
movq %r14, %rdi
callq 0x19d11c
movq %r15, %rdi
callq 0x19e389
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rax
testq %rdi, %rdi
je 0x1993e0
movq %rsi, %r15
testq %rsi, %rsi
je 0x1993e0
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1993e0
movq %rdi, %r14
movq %r15, %rdi
callq 0x19f84f
movq %rax, %r13
movq %r15, %rdi
callq 0x19f874
movq %rax, %r12
movq %r15, %rdi
callq 0x19f87c
testb $0x4, 0x10(%r14)
jne 0x199375
xorl %r12d, %r12d
jmp 0x19939e
movl %eax, %ebp
movl 0x18(%r14), %edx
cmpl $-0x1, %edx
jne 0x199391
movq %r13, %rdi
callq 0x2f09dd
movl %eax, %edi
callq 0x2f09a0
movl %eax, %edx
movq %r12, %rdi
movl %ebp, %esi
callq 0x19e938
movq %rax, %r12
movq %r15, %rdi
callq 0x19f154
leaq 0x208bab(%rip), %rcx    # 0x3a1f58
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %rbx, %r8
callq 0x1992bf
movq %rax, %rbx
testq %r12, %r12
je 0x1993ce
movq %r12, %rdi
callq 0x19ebbf
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5e58b
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x208bf5(%rip), %rsi    # 0x3a2032
movl $0x30, %edi
movl $0x64, %edx
callq 0x104226
movq %rax, %rbx
cmpw $-0x3, %bp
jbe 0x199472
cmpw $-0x1, %bp
movw $0xfffe, %bp            # imm = 0xFFFE
jne 0x1994a5
movq %r14, %rdi
callq 0x2f09dd
movl %eax, %edi
callq 0x2f09a0
movl %eax, %ebp
jmp 0x1994a5
testw %bp, %bp
js 0x19958a
movzwl %bp, %r15d
movq %r14, %rdi
callq 0x2f09dd
movl $0x40, %ecx
cmpl $0x3f, %eax
ja 0x19949c
movq %r14, %rdi
callq 0x2f09dd
movslq %eax, %rcx
cmpq %r15, %rcx
jbe 0x19958a
movq %r14, (%rbx)
movq $0x0, 0x8(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %ebp, %ecx
shll %cl, %eax
notl %eax
movq %rax, 0x10(%rbx)
movw %bp, 0x1a(%rbx)
movb $0x0, 0x18(%rbx)
callq 0x11ac6c
movq %rax, 0x28(%rbx)
leaq 0x208b5b(%rip), %rdx    # 0x3a2032
movq %rax, %rdi
movl $0x5, %esi
movl $0x4e, %ecx
callq 0xfd35a
movl $0x1, %edx
movl %ebp, %ecx
shll %cl, %edx
movq %rax, %r15
movq %rax, 0x20(%rbx)
movslq %edx, %rax
leaq (%r14,%rax), %r12
decq %r12
shrq %cl, %r12
movq %rsp, %rdi
movl $0x2000, %edx           # imm = 0x2000
xorl %esi, %esi
callq 0x173a0
cmpq $0x401, %r12            # imm = 0x401
jl 0x199548
movl $0x400, %r13d           # imm = 0x400
movq %rsp, %r14
movl $0x8, %esi
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
movq %r15, %rcx
callq 0x11f89c
addq $0x400, %r13            # imm = 0x400
cmpq %r12, %r13
jl 0x199527
leaq 0x3ff(%r12), %rax
testq %r12, %r12
cmovnsq %r12, %rax
andq $-0x400, %rax           # imm = 0xFC00
subq %rax, %r12
je 0x199575
movl %r12d, %edx
movq %rsp, %rdi
movl $0x8, %esi
movq %r15, %rcx
callq 0x11f89c
movq %rbx, %rax
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5e5c4
// File: /workspace/github_c_makefile_star2_O3/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 0x19963d
movq %rsi, 0x8(%rsp)
testq %rsi, %rsi
je 0x199621
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r12
leaq 0x10(%rsp), %r13
movq 0x8(%rsp), %r14
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 0x199638
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x199642
subq %rbp, %r14
jne 0x1995ed
movq 0x8(%rsp), %rax
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5e5fb
callq 0x5e617
// File: /workspace/github_c_makefile_star2_O3/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 0x199719
movq %rdx, %rbp
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rdx, %rdx
je 0x1996f6
movq %rsi, %r14
movq (%rdi), %r8
movq 0x10(%rdi), %r12
leaq -0x1(%r8), %r9
xorl %r15d, %r15d
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movq (%r14,%r15,8), %rax
addq %r9, %rax
xorl %edx, %edx
divq %r8
testq %r12, %rdx
jne 0x1996ee
movb 0x1a(%rdi), %cl
sarq %cl, %rdx
movq 0x8(%rsp), %rax
addq %r15, %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r13
shlq $0x3, %rdx
movq %rax, 0x20(%rsp)
movq %r13, %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x17cf0
cmpl $-0x1, %eax
je 0x199714
movl $0x8, %esi
movl $0x1, %edx
leaq 0x20(%rsp), %rdi
movq %r13, %rcx
callq 0x11f89c
movq %rbx, %rdi
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %r9
incq %r15
cmpq %r15, %rbp
jne 0x199689
movq 0x8(%rsp), %rax
addq %rbp, %rax
movq %rax, 0x8(%rdi)
movq %rbp, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5e650
callq 0x5e697
// File: /workspace/github_c_makefile_star2_O3/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 0x199c6e
movq %rsi, %r14
testq %rsi, %rsi
je 0x199c6e
movl %edx, %ebp
movq %rdi, %r12
movq (%rdi), %rax
movq 0x10(%rax), %r15
leaq -0x1(%r15), %rdi
callq 0x2f09dd
movl %eax, %r13d
leaq 0x208490(%rip), %rsi    # 0x3a2032
movl $0x30, %edi
movl $0x15d, %edx            # imm = 0x15D
callq 0x104226
movq %rax, %rbx
movw %r13w, 0x2a(%rax)
movq %r12, 0x10(%rax)
cmpw $-0x1, %bp
je 0x199bf0
movzwl %bp, %edi
movzwl %r13w, %esi
movq %r15, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x19990d
testb %al, %al
jne 0x199c2b
leaq 0x20844c(%rip), %rsi    # 0x3a2032
movq %rbx, %rdi
movl $0x165, %edx            # imm = 0x165
jmp 0x199c55
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 0x19990d
testb %al, %al
jne 0x199c24
movswl %bp, %eax
cmpl %eax, %r13d
jg 0x199bff
cmpq $0x0, 0x20(%rbx)
je 0x199c46
movw %bp, 0x28(%rbx)
movl $0x1, %eax
movl %ebp, %ecx
shll %cl, %eax
cltq
movq %rax, (%rbx)
decq %rax
movq %rax, 0x8(%rbx)
jmp 0x199c5c
leaq 0x2083e5(%rip), %rsi    # 0x3a2032
movq %rbx, %rdi
movl $0x173, %edx            # imm = 0x173
callq 0x1045eb
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5e804
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-bwtseq-context.c
// Function: gt_BWTSeqCRAccessSubseq
void
gt_BWTSeqCRAccessSubseq(const BWTSeqContextRetriever *bwtSeqCR,
                     GtUword start, size_t len, Symbol subseq[])
{
  struct SeqMark currentPos;
  struct extBitsRetrieval extBits;
  const BWTSeq *bwtSeq;
  initExtBitsRetrieval(&extBits);
  gt_assert(bwtSeqCR);
  gt_assert(start < BWTSeqLength(bwtSeqCR->bwtSeq));
  bwtSeq = bwtSeqCR->bwtSeq;
  {
    GtUword end = start + len - 1;
    currentPos = BWTSeqCRNextMark(bwtSeqCR, end);
    gt_assert(currentPos.textPos >= end);
    while (currentPos.textPos > end)
    {
      currentPos.bwtPos = BWTSeqLFMap(bwtSeq, currentPos.bwtPos, &extBits);
      --currentPos.textPos;
    }
  }
  {
    GtUword i = len;
    while (i)
    {
      --i;
      subseq[i] = BWTSeqGetSym(bwtSeq, currentPos.bwtPos);
      currentPos.bwtPos = BWTSeqLFMap(bwtSeq, currentPos.bwtPos, &extBits);
#ifndef NDEBUG
      --currentPos.textPos;
#endif
    }
  }
  gt_assert(currentPos.textPos + 1 == start);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x40(%rsp)
testq %rdi, %rdi
je 0x199df4
movq 0x10(%rdi), %r12
movq (%r12), %rax
movq 0x10(%rax), %rax
cmpq %rsi, %rax
jbe 0x199df9
movq %rdx, %r15
leaq (%rsi,%rdx), %r14
decq %r14
cmpq %r14, %rax
jbe 0x199dfe
movq %rsi, (%rsp)
movq 0x8(%rdi), %rbx
leaq (%rbx,%r14), %rcx
notq %rbx
andq %rcx, %rbx
cmpq %rax, %rbx
jae 0x199d3a
movb 0x28(%rdi), %cl
movq %rbx, %r8
shrq %cl, %r8
movq 0x20(%rdi), %rax
movzwl 0x2a(%rdi), %edx
movq %rdx, %rsi
imulq %r8, %rsi
movq %rax, %rdi
callq 0x2f37dc
movq %rax, %r13
jmp 0x199d45
decq %rax
movq 0x30(%r12), %r13
movq %rax, %rbx
cmpq %r14, %rbx
jb 0x199e03
jbe 0x199d71
leaq 0x10(%rsp), %rbp
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x199e0d
movq %rax, %r13
decq %rbx
cmpq %r14, %rbx
ja 0x199d55
movq %r14, %rbx
testq %r15, %r15
je 0x199dd2
subq %r15, %rbx
leaq 0x10(%rsp), %rbp
movq (%r12), %rdi
testq %rdi, %rdi
je 0x199def
movq 0x18(%r12), %rdx
testq %rdx, %rdx
je 0x199def
movq (%rdi), %rax
movq 0x8(%rdi), %r14
movq %r13, %rsi
callq *0x30(%rax)
cmpl $0x1, (%r14)
jne 0x199dea
movzbl %al, %eax
movb 0x118(%r14,%rax), %al
movq 0x8(%rsp), %rcx
movb %al, -0x1(%rcx,%r15)
decq %r15
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x199e0d
movq %rax, %r13
testq %r15, %r15
jne 0x199d7e
incq %rbx
cmpq (%rsp), %rbx
jne 0x199e08
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x173b0
callq 0x5e8e6
callq 0x5e98f
callq 0x5e876
callq 0x5e8af
callq 0x5e956
callq 0x5e91d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-bwtseq-extinfo.c
// Function: writeLocateInfoHeader
static int
writeLocateInfoHeader(FILE *fp, void *cbData)
{
  struct locateHeader headerData;
  Definedunsignedlong rot0Pos;
  const struct locateHeaderWriteInfo *headerSrc = cbData;
  gt_assert(cbData);
  headerData.locateInterval = headerSrc->locateInterval;
  rot0Pos = SASSGetRot0Pos(headerSrc->src);
  if (!rot0Pos.defined)
  {
    fputs("Invalid index construction: position of suffix 0 unknown!\n",
          stderr);
    abort();
  }
  headerData.rot0Pos = rot0Pos.valueunsignedlong;
  headerData.featureToggles = headerSrc->featureToggles;
  gt_xfwrite(&headerData, sizeof (headerData), 1, fp);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x19a649
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %eax
movl %eax, 0x10(%rsp)
movq (%rsi), %rdi
callq *0x18(%rdi)
testb $0x1, %al
je 0x19a64e
leaq 0x8(%rsp), %rdi
movq %rdx, (%rdi)
movl 0xc(%r14), %eax
movl %eax, 0xc(%rdi)
movl $0x10, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11f89c
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x5ed26
callq 0x5ed0a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-bwtseq-extinfo.c
// Function: writeRankSortHeader
static int
writeRankSortHeader(FILE *fp, void *cbData)
{
  struct sortModeHeader *headerData = cbData;
  gt_assert(cbData);
  gt_xfwrite(&headerData->bitsPerOrigRank, sizeof (headerData->bitsPerOrigRank),
             1, fp);
  {
    size_t i, numRanges = MRAEncGetNumRanges(headerData->alphabet);
    for (i = 0; i < numRanges; ++i)
    {
      int16_t mode = headerData->rangeSort[i];
      gt_xfwrite(&mode, sizeof (mode), 1, fp);
    }
  }
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rsi, %rsi
je 0x19a6d3
movq %rsi, %rbx
movq %rdi, %r14
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x11f89c
movq 0x8(%rbx), %rax
movl 0x4(%rax), %r12d
testq %r12, %r12
je 0x19a6c0
xorl %r13d, %r13d
leaq 0xe(%rsp), %r15
movq 0x10(%rbx), %rax
movzwl (%rax,%r13,4), %eax
movw %ax, 0xe(%rsp)
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x11f89c
incq %r13
cmpq %r13, %r12
jne 0x19a695
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x5ed5d