LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/seed-extend.c
// Function: gt_seqabstract_reinit_generic
static void gt_seqabstract_reinit_generic(bool rightextension,
                                          GtReadmode query_readmode,
                                          GtSeqabstract *seqabstract,
                                          const GtSeqorEncseq *seqorencseq,
                                          GtUword len,
                                          GtUword offset,
                                          GtUword seqstartpos,
                                          GtUword seqlength)
{
  if (seqorencseq->encseq != NULL)
  {
    /* it is important to set it before the next call */
    if (GT_ISDIRREVERSE(query_readmode))
    {
      gt_seqabstract_seqstartpos_set(seqabstract,seqstartpos);
      gt_seqabstract_totallength_set(seqabstract,seqlength);
    }
    gt_seqabstract_reinit_encseq(rightextension,
                                 query_readmode,
                                 seqabstract,
                                 seqorencseq->encseq,
                                 len,
                                 offset);
  } else
  {
    gt_seqabstract_reinit_gtuchar(rightextension,
                                  query_readmode,
                                  seqabstract,
                                  seqorencseq->seq,
                                  len,
                                  offset,
                                  seqlength);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %r15
movl %esi, %ebp
movl %edi, %r12d
movq 0x58(%rsp), %rbx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x1e1eb9
movl %ebp, %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0x1e1e9a
movq 0x50(%rsp), %rsi
movq %r15, %rdi
movq %r9, 0x10(%rsp)
callq 0x1e27dc
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1e27ec
movq 0x10(%rsp), %r9
movq 0x8(%r13), %rcx
movzbl %r12b, %edi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %r8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1e2956
movq (%r13), %rcx
movq %rbx, (%rsp)
movzbl %r12b, %edi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %r8
callq 0x1e27fc
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/seed-extend.c
// Function: gt_rf_seed_extend_prettyprint
static void gt_rf_seed_extend_prettyprint(bool forxdrop,void *info)
{
  GtProcessinfo_and_querymatchspaceptr *info_querymatch
    = (GtProcessinfo_and_querymatchspaceptr *) info;
  GtUword userdefinedleastlength, errorpercentage;
  double evalue = 0.0, bit_score = 0.0, evalue_threshold = 0.0;

  gt_assert(info_querymatch != NULL);
  if (forxdrop)
  {
    GtXdropmatchinfo *xdropmatchinfo = info_querymatch->processinfo;
    userdefinedleastlength = xdropmatchinfo->userdefinedleastlength;
    errorpercentage = xdropmatchinfo->errorpercentage;
    evalue_threshold = xdropmatchinfo->evalue_threshold;
  } else
  {
    GtGreedyextendmatchinfo *ggemi = info_querymatch->processinfo;
    userdefinedleastlength = ggemi->userdefinedleastlength;
    errorpercentage = ggemi->errorpercentage;
    evalue_threshold = ggemi->evalue_threshold;
  }
  if (gt_querymatch_check_final(&evalue,
                                &bit_score,
                                info_querymatch->karlin_altschul_stat,
                                info_querymatch->querymatchspaceptr,
                                userdefinedleastlength,
                                errorpercentage,
                                evalue_threshold))
  {
    gt_querymatch_prettyprint(evalue,bit_score,
                              info_querymatch->out_display_flag,
                              info_querymatch->querymatchspaceptr);
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, (%rsp)
testq %rsi, %rsi
je 0x1e1f6c
movq %rsi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
leaq 0x38(%rax), %rdx
leaq 0x80(%rax), %rsi
leaq 0x40(%rax), %r8
leaq 0x88(%rax), %r9
leaq 0x48(%rax), %r10
addq $0x90, %rax
testb %dil, %dil
cmovneq %rsi, %rdx
cmoveq %r8, %r9
cmoveq %r10, %rax
movq (%rdx), %r8
movq (%r9), %r9
movsd (%rax), %xmm0
movq 0x10(%rbx), %rdx
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x1bb88d
testb %al, %al
je 0x1e1f66
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %rdi
callq 0x1bae05
addq $0x10, %rsp
popq %rbx
retq
callq 0x75057
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/seed_extend_parts.c
// Function: gt_sequence_parts_info_delete
void gt_sequence_parts_info_delete(GtSequencePartsInfo *spi)
{
  if (spi != NULL)
  {
    gt_free(spi->ssptab);
    gt_free(spi->ranges);
    gt_free(spi);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1e2425
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x1d2cb8(%rip), %r14    # 0x3b50a9
movq %r14, %rsi
movl $0xd9, %edx
callq 0x1045eb
movq (%rbx), %rdi
movq %r14, %rsi
movl $0xda, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0xdb, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/seed_extend_parts.c
// Function: gt_sequence_parts_info_overlap
bool gt_sequence_parts_info_overlap(const GtSequencePartsInfo *spia,
                                    GtUword aidx,
                                    const GtSequencePartsInfo *spib,
                                    GtUword bidx)
{
  GtRange range_a, range_b;

  range_a.start = gt_sequence_parts_info_start_get(spia,aidx);
  range_a.end = gt_sequence_parts_info_end_get(spia,aidx);
  range_b.start = gt_sequence_parts_info_start_get(spib,bidx);
  range_b.end = gt_sequence_parts_info_end_get(spib,bidx);
  return gt_range_overlap(&range_a,&range_b);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x1e2426
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1e2443
movq %rax, 0x8(%r13)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e2426
movq %rsp, %r15
movq %rax, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e2443
movq %rax, 0x8(%r15)
movq %r13, %rdi
movq %r15, %rsi
callq 0x112246
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/seed_extend_parts.c
// Function: gt_sequence_parts_info_equal
bool gt_sequence_parts_info_equal(const GtSequencePartsInfo *spia,
                                  GtUword aidx,
                                  const GtSequencePartsInfo *spib,
                                  GtUword bidx)
{
  return (gt_sequence_parts_info_start_get(spia,aidx) ==
          gt_sequence_parts_info_start_get(spib,bidx)) &&
         (gt_sequence_parts_info_end_get(spia,aidx) ==
          gt_sequence_parts_info_end_get(spib,bidx)) ? true : false;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x1e2426
movq %rax, %r13
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e2426
cmpq %rax, %r13
jne 0x1e257f
movq %r12, %rdi
movq %r15, %rsi
callq 0x1e2443
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e2443
cmpq %rax, %r15
sete %al
jmp 0x1e2581
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/seed_extend_parts.c
// Function: gt_sequence_parts_info_variance_show
void gt_sequence_parts_info_variance_show(const GtSequencePartsInfo *spi)
{
  GtUword variance_sum = 0, idx, avgpartlength;

  avgpartlength = spi->totallength/spi->parts_number;
  for (idx = 0; idx < spi->parts_number; idx++)
  {
    const GtUword partlength
      = gt_sequence_parts_info_partlength(
             spi,
             gt_sequence_parts_info_start_get(spi,idx),
             gt_sequence_parts_info_end_get(spi,idx));
    if (partlength > avgpartlength)
    {
      GtUword diff = partlength - avgpartlength;
      variance_sum += diff * diff;
    } else
    {
      GtUword diff = avgpartlength - partlength;
      variance_sum += diff * diff;
    }
    printf("# Part " GT_WU ": sequence " GT_WU "..." GT_WU ", total length="
           GT_WU ", max_length=" GT_WU "\n",idx+1,
           gt_sequence_parts_info_start_get(spi,idx),
           gt_sequence_parts_info_end_get(spi,idx),
           partlength,
           gt_sequence_parts_info_max_length_get(spi,idx));
  }
  printf("# Variance of parts is %.2e\n",
           (double) variance_sum/spi->parts_number);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
xorl %edx, %edx
divq 0x28(%rdi)
movq %rax, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1e2426
movq %rax, %r13
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1e2443
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1e1fd3
movq %rax, %r13
subq %r14, %rax
ja 0x1e25e9
movq %r14, %rax
subq %r13, %rax
imulq %rax, %rax
addq %rax, %r15
leaq 0x1(%r12), %rbp
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1e2426
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1e2443
movq %rax, %r14
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1e24a4
leaq 0x1d2c4d(%rip), %rdi    # 0x3b5272
movq %rbp, %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rcx
movq %r13, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x17070
movq 0x28(%rbx), %rax
movq %rbp, %r12
cmpq %rax, %rbp
movq 0x8(%rsp), %r14
jb 0x1e25b4
movq %r15, %xmm1
movq 0x165281(%rip), %xmm2   # 0x3478e0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x165285(%rip), %xmm3   # 0x3478f0
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
leaq 0x1d2c15(%rip), %rdi    # 0x3b52b4
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17070
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/seed_extend_parts.c
// Function: gt_sequence_parts_info_seq_extract
GtUchar *gt_sequence_parts_info_seq_extract(const GtEncseq *encseq,
                                            const GtSequencePartsInfo *spi,
                                            GtUword idx)
{
  GtUchar *byte_sequence;
  const GtUword
    firstseqnum = gt_sequence_parts_info_start_get(spi,idx),
    lastseqnum = gt_sequence_parts_info_end_get(spi,idx),
    firstpos = gt_sequence_parts_info_seqstartpos(spi,firstseqnum),
    lastpos = gt_sequence_parts_info_seqendpos(spi,lastseqnum);

  gt_assert(firstpos <= lastpos);
  byte_sequence = gt_malloc(sizeof *byte_sequence * (lastpos - firstpos + 1));
  gt_encseq_extract_encoded(encseq,byte_sequence,firstpos,lastpos);
  return byte_sequence;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1e2426
movq %rax, %r14
movq %r12, %rdi
movq %r15, %rsi
callq 0x1e2443
movq %rax, %r15
movq 0x8(%r12), %rax
testq %rax, %rax
je 0x1e26fa
testq %r14, %r14
je 0x1e2713
movq -0x8(%rax,%r14,8), %r14
incq %r14
jmp 0x1e2716
movq 0x10(%r12), %rax
incq %rax
imulq %rax, %r14
incq %r15
imulq %rax, %r15
addq $-0x2, %r15
jmp 0x1e2733
xorl %r14d, %r14d
movq 0x20(%r12), %rcx
decq %rcx
addq $0x18, %r12
cmpq %r15, %rcx
leaq (%rax,%r15,8), %rax
cmovbeq %r12, %rax
movq (%rax), %r15
decq %r15
movq %r15, %rdi
subq %r14, %rdi
jb 0x1e2772
incq %rdi
leaq 0x1d2964(%rip), %rsi    # 0x3b50a9
movl $0x142, %edx            # imm = 0x142
callq 0x104226
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0xe9127
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x752ff
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/seqabstract.c
// Function: gt_seqabstract_reinit_gtuchar
void gt_seqabstract_reinit_gtuchar(bool rightextension,
                                   GtReadmode readmode,
                                   GtSeqabstract *sa,
                                   const GtUchar *string,
                                   GtUword len,
                                   GtUword startpos,
                                   GtUword totallength)
{
  gt_assert(sa != NULL && totallength != GT_SEQABSTRACT_TOTALLENGTH_UNDEF);

  sa->seqtype = GT_SEQABSTRACT_STRING;
  sa->totallength = totallength;
  sa->seq.string = string;
  gt_seqabstract_init(sa,
                      rightextension,
                      readmode,
                      len,
                      startpos,
                      totallength);
}

// Assembly:
pushq %rax
testq %rdx, %rdx
je 0x1e2833
movq 0x10(%rsp), %r10
cmpq $-0x1, %r10
je 0x1e2833
movl %esi, %eax
movl $0x1, 0x20(%rdx)
movq %r10, 0x10(%rdx)
movq %rcx, 0x28(%rdx)
movzbl %dil, %esi
movq %rdx, %rdi
movl %eax, %edx
movq %r8, %rcx
movq %r9, %r8
movq %r10, %r9
popq %rax
jmp 0x1e2838
callq 0x753a6
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/seqabstract.c
// Function: gt_seqabstract_init
static void gt_seqabstract_init(GtSeqabstract *sa,
                                bool rightextension,
                                GtReadmode readmode,
                                GtUword len,
                                GtUword startpos,
                                GtUword totallength)
{
  sa->len = len;
  gt_assert(startpos >= sa->seqstartpos && (
            !GT_ISDIRREVERSE(readmode) ||
            totallength != GT_SEQABSTRACT_TOTALLENGTH_UNDEF));
  sa->offset = GT_EXTEND_OFFSET(rightextension,
                                readmode,
                                totallength,
                                sa->seqstartpos,
                                startpos,
                                len);
  sa->read_seq_left2right = GT_EXTEND_READ_SEQ_LEFT2RIGHT(rightextension,
                                                          readmode);
  sa->dir_is_complement = GT_ISDIRCOMPLEMENT(readmode) ? true : false;
}

// Assembly:
pushq %rbx
movq %rcx, (%rdi)
movq 0x18(%rdi), %r10
cmpq %r8, %r10
ja 0x1e28c4
movl %edx, %eax
andl $-0x3, %eax
cmpl $0x1, %eax
setne %r11b
cmpq $-0x1, %r9
setne %bl
orb %r11b, %bl
je 0x1e28c4
testb %sil, %sil
je 0x1e2884
movl %edx, %ecx
orl $0x2, %ecx
cmpl $0x3, %ecx
jne 0x1e2876
notq %r8
addq %r9, %r8
leaq (%r8,%r10,2), %r8
movq %r8, 0x8(%rdi)
cmpl $0x3, %ecx
je 0x1e28a7
movb $0x1, %sil
jmp 0x1e28b4
movl %edx, %r11d
orl $0x2, %r11d
cmpl $0x3, %r11d
jne 0x1e289d
addq %rcx, %r8
subq %r8, %r9
leaq (%r9,%r10,2), %rcx
jmp 0x1e28a3
addq %r8, %rcx
decq %rcx
movq %rcx, 0x8(%rdi)
cmpl $0x1, %eax
sete %al
xorb $0x1, %sil
andb %al, %sil
movb %sil, 0x24(%rdi)
andl $-0x2, %edx
cmpl $0x2, %edx
sete 0x25(%rdi)
popq %rbx
retq
callq 0x753dd
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/seqabstract.c
// Function: gt_seqabstract_new_gtuchar
GtSeqabstract *gt_seqabstract_new_gtuchar(bool rightextension,
                                          GtReadmode readmode,
                                          const GtUchar *string,
                                          GtUword len,
                                          GtUword startpos,
                                          GtUword totallength)
{
  GtSeqabstract *sa = gt_seqabstract_new_empty();

  gt_seqabstract_reinit_gtuchar(rightextension, readmode, sa, string, len,
                                startpos, totallength);
  return sa;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, 0x10(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movl %edi, %r13d
leaq 0x1d2a60(%rip), %rsi    # 0x3b5351
movl $0x30, %edi
movl $0x40, %edx
callq 0x104226
movq %rax, %r14
movl $0x0, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movw $0x1, 0x24(%rax)
movq $-0x1, 0x10(%rax)
xorl %eax, %eax
movq %rax, 0x18(%r14)
movq %rax, 0x28(%r14)
movq %rbx, (%rsp)
movl %r13d, %edi
movl %ebp, %esi
movq %r14, %rdx
movq %r12, %rcx
movq %r15, %r8
movq 0x10(%rsp), %r9
callq 0x1e27fc
movq %r14, %rax
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/seqabstract.c
// Function: gt_seqabstract_new_encseq
GtSeqabstract *gt_seqabstract_new_encseq(bool rightextension,
                                         GtReadmode readmode,
                                         const GtEncseq *encseq,
                                         GtUword len,
                                         GtUword startpos)
{
  GtSeqabstract *sa = gt_seqabstract_new_empty();

  gt_seqabstract_reinit_encseq(rightextension, readmode, sa, encseq, len,
                               startpos);
  return sa;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movl %edi, %r12d
leaq 0x1d29a8(%rip), %rsi    # 0x3b5351
movl $0x30, %edi
movl $0x40, %edx
callq 0x104226
movq %rax, %r13
movl $0x0, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movw $0x1, 0x24(%rax)
movq $-0x1, 0x10(%rax)
xorl %eax, %eax
movq %rax, 0x18(%r13)
movq %rax, 0x28(%r13)
movl %r12d, %edi
movl %ebp, %esi
movq %r13, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x1e2956
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/seqabstract.c
// Function: gt_seqabstract_lcp
GtUword gt_seqabstract_lcp(bool rightextension,
                           const GtSeqabstract *useq,
                           const GtSeqabstract *vseq,
                           GtUword u_start,
                           GtUword v_start)
{
  GtUword lcp, maxlen;

  gt_assert(useq != NULL && vseq != NULL &&
            useq->len >= u_start && vseq->len >= v_start);
  maxlen = GT_MIN(useq->len - u_start, vseq->len - v_start);
  for (lcp = 0; lcp < maxlen; lcp++)
  {
    GtUchar u_cc, v_cc;

    u_cc = gt_seqabstract_get_encoded_char(rightextension,useq,u_start + lcp);
    if (GT_ISSPECIAL(u_cc))
    {
      break;
    }
    if (useq->dir_is_complement)
    {
      u_cc = GT_COMPLEMENTBASE(u_cc);
    }
    v_cc = gt_seqabstract_get_encoded_char(rightextension,vseq,v_start + lcp);
    if (GT_ISSPECIAL(v_cc))
    {
      break;
    }
    if (vseq->dir_is_complement)
    {
      v_cc = GT_COMPLEMENTBASE(v_cc);
    }
    if (u_cc != v_cc)
    {
      break;
    }
  }
  return lcp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
testq %rsi, %rsi
je 0x1e2aff
movq %rdx, %r15
testq %rdx, %rdx
je 0x1e2aff
movq %rsi, %r12
movq (%rsi), %rax
subq 0x10(%rsp), %rax
jb 0x1e2aff
movq (%r15), %rbx
subq 0x8(%rsp), %rbx
jb 0x1e2aff
cmpq %rbx, %rax
cmovbq %rax, %rbx
xorl %r13d, %r13d
testq %rbx, %rbx
je 0x1e2aed
movq 0x10(%rsp), %rax
leaq (%rax,%r13), %rsi
movq %r12, %rdi
callq 0x1e2b04
cmpb $-0x3, %al
ja 0x1e2aed
movl %eax, %ebp
movb 0x25(%r12), %r14b
movq 0x8(%rsp), %rax
leaq (%rax,%r13), %rsi
movq %r15, %rdi
callq 0x1e2b04
cmpb $-0x3, %al
ja 0x1e2aed
movb $0x3, %cl
subb %bpl, %cl
movzbl %cl, %ecx
movzbl %bpl, %edx
testb %r14b, %r14b
cmovnel %ecx, %edx
movb $0x3, %cl
subb %al, %cl
movzbl %cl, %ecx
cmpb $0x0, 0x25(%r15)
movzbl %al, %eax
cmovnel %ecx, %eax
cmpb %al, %dl
jne 0x1e2aed
incq %r13
cmpq %r13, %rbx
jne 0x1e2a89
movq %rbx, %r13
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x75486
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/seqabstract.c
// Function: gt_seqabstract_get
char *gt_seqabstract_get(bool rightextension,const GtSeqabstract *seq)
{
  GtUword idx;
  char *buffer = gt_malloc(sizeof *buffer * (seq->len+1));
  char *map = "acgt";

  for (idx = 0; idx < seq->len; idx++)
  {
    GtUchar cc = gt_seqabstract_get_encoded_char(rightextension,seq,idx);

    if (cc == GT_WILDCARD)
    {
      buffer[idx] = '#';
    } else
    {
      if (cc == GT_SEPARATOR)
      {
        buffer[idx] = '$';
      } else
      {
        gt_assert(cc < 4);
        buffer[idx] = map[cc];
      }
    }
  }
  buffer[seq->len] = '\0';
  return buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rdi
incq %rdi
leaq 0x1d2803(%rip), %rsi    # 0x3b5351
movl $0xf9, %edx
callq 0x104226
movq %rax, %r14
cmpq $0x0, (%rbx)
je 0x1e2ba6
xorl %r15d, %r15d
leaq 0x17b715(%rip), %r12    # 0x35e280
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1e2b04
cmpb $-0x2, %al
je 0x1e2b89
movzbl %al, %ecx
cmpl $0xff, %ecx
jne 0x1e2b8d
movb $0x24, %al
jmp 0x1e2b95
movb $0x23, %al
jmp 0x1e2b95
cmpb $0x4, %al
jae 0x1e2bbc
movb (%rcx,%r12), %al
movb %al, (%r14,%r15)
incq %r15
movq (%rbx), %rax
cmpq %rax, %r15
jb 0x1e2b6b
jmp 0x1e2ba8
xorl %eax, %eax
movb $0x0, (%r14,%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x754f8
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/seqnumrelpos.c
// Function: gt_seqnumrelpos_new
GtSeqnumrelpos *gt_seqnumrelpos_new(unsigned int bitsforrelpos,
                                    const GtEncseq *encseq)
{
  GtSeqnumrelpos *snrp;

  snrp = gt_malloc(sizeof (*snrp));
  snrp->bitsforrelpos = bitsforrelpos;
  snrp->relposmask = (1UL << snrp->bitsforrelpos) - 1;
  snrp->encseq = encseq;
  return snrp;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x1d298c(%rip), %rsi    # 0x3b555f
movl $0x18, %edi
movl $0x22, %edx
callq 0x104226
movl %ebp, 0x10(%rax)
movq $-0x1, %rdx
movl %ebp, %ecx
shlq %cl, %rdx
notq %rdx
movq %rdx, 0x8(%rax)
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-apfxlen.c
// Function: gt_recommendedprefixlength
unsigned int gt_recommendedprefixlength(unsigned int numofchars,
                                        GtUword totallength,
                                        double recommendedmultiplier,
                                        bool withspecialsuffixes)
{
  unsigned int prefixlength;

  prefixlength = prefixlengthwithmaxspace(numofchars,totallength,
                                          recommendedmultiplier,
                                          totallength+1,
                                          withspecialsuffixes);
  if (prefixlength == 0)
  {
    return 1U;
  } else
  {
    unsigned int mbp = gt_maxbasepower(numofchars);
    if (mbp >= 1U)
    {
      return GT_MIN(mbp,prefixlength);
    } else
    {
      return prefixlength;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r14
movl %edi, %ebx
movq %rsi, %xmm0
punpckldq 0x164c62(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x164c6a(%rip), %xmm0   # 0x3478f0
incq %r14
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movzbl %dl, %ebp
leal 0x2(%r15), %esi
movl %ebx, %edi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x18b00c
movq %rax, %xmm0
punpckldq 0x164c1f(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x164c27(%rip), %xmm0   # 0x3478f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd 0x8(%rsp), %xmm1
incl %r15d
ucomisd 0x10(%rsp), %xmm1
jbe 0x1e2ca4
testl %r15d, %r15d
je 0x1e2d05
movl %ebx, %edi
callq 0x1b62a4
movl %eax, %ecx
cmpl %r15d, %eax
movl %r15d, %eax
cmovbl %ecx, %eax
testl %ecx, %ecx
cmovel %r15d, %eax
jmp 0x1e2d0a
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-apfxlen.c
// Function: gt_checkprefixlength
int gt_checkprefixlength(unsigned int maxprefixlen,
                      unsigned int prefixlength,
                      GtError *err)
{
  gt_error_check(err);
  if (maxprefixlen < prefixlength)
  {
    gt_error_set(err,"prefix length %u is too large, maximal prefix length "
                      "for this input size and alphabet size is %u",
                      prefixlength,
                      maxprefixlen);
    return -1;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movl %edi, %ebx
testq %rdx, %rdx
je 0x1e2e71
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1e2e96
xorl %eax, %eax
cmpl %ebp, %ebx
jae 0x1e2e91
leaq 0x1d2767(%rip), %rsi    # 0x3b55e5
movq %r14, %rdi
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
callq 0x75568
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: gt_size_of_sort_workspace
size_t gt_size_of_sort_workspace (const Sfxstrategy *sfxstrategy)
{
  size_t sumsize = 0;

  if (!sfxstrategy->cmpcharbychar)
  {
    sumsize += sizeof (GtCountingsortinfo) * sfxstrategy->maxcountingsort;
    if (sfxstrategy->maxwidthrealmedian >= MINMEDIANOF9WIDTH)
    {
      sumsize += sizeof (GtMedianinfo) * sfxstrategy->maxwidthrealmedian;
    }
  }
  sumsize += gt_blindtrie_size(sfxstrategy->maxbltriesort);
  return sumsize;
}

// Assembly:
pushq %rbx
cmpb $0x0, 0x2c(%rdi)
je 0x1e2eeb
xorl %ebx, %ebx
jmp 0x1e2f03
movq (%rdi), %rax
movq 0x18(%rdi), %rbx
shlq $0x4, %rbx
cmpq $0x1f, %rax
jb 0x1e2f03
shlq $0x5, %rax
addq %rax, %rbx
movq 0x10(%rdi), %rdi
callq 0x1e6159
addq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: gt_bentsedgresources_addlcpinfo
static void gt_bentsedgresources_addlcpinfo(GtBentsedgresources *bsr,
                                            GtOutlcpinfo *outlcpinfo,
                                            const GtBcktab *bcktab)
{
  if (outlcpinfo != NULL)
  {
    bsr->tableoflcpvalues = gt_Outlcpinfo_resizereservoir(outlcpinfo,bcktab);
    if (bsr->srsw != NULL)
    {
      gt_shortreadsort_assigntableoflcpvalues(bsr->srsw,bsr->tableoflcpvalues);
    }
  }
}

// Assembly:
testq %rsi, %rsi
je 0x1e3416
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1ecf87
movq %rax, 0x38(%rbx)
movq 0x2e0(%rbx), %rdi
testq %rdi, %rdi
popq %rbx
je 0x1e3416
movq %rax, %rsi
jmp 0x1f54cc
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: bentsedgresources_delete
static void bentsedgresources_delete(GtBentsedgresources *bsr, GtLogger *logger)
{
  gt_free(bsr->countingsortinfo);
  bsr->countingsortinfo = NULL;
  gt_free(bsr->medianinfospace);
  bsr->medianinfospace = NULL;
  gt_shortreadsort_delete(bsr->srsw);
  bsr->srsw = NULL;
  gt_blindtrie_delete(bsr->blindtrie);
  gt_encseq_reader_delete(bsr->esr1);
  gt_encseq_reader_delete(bsr->esr2);
  gt_free(bsr->equalwithprevious);
  GT_FREEARRAY(&bsr->mkvauxstack,GtMKVstack);
  gt_radixsort_str_delete(bsr->rsi);
  gt_logger_log(logger,"countinsertionsort="GT_WU"",bsr->countinsertionsort);
  gt_logger_log(logger,"countbltriesort="GT_WU"",bsr->countbltriesort);
  gt_logger_log(logger,"countcountingsort="GT_WU"",bsr->countcountingsort);
  gt_logger_log(logger,"countshortreadsort="GT_WU"",bsr->countshortreadsort);
  gt_logger_log(logger,"countradixsort="GT_WU"",bsr->countradixsort);
  gt_logger_log(logger,"counttqsort="GT_WU"",bsr->counttqsort);
  gt_free(bsr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x2d8(%rdi), %rdi
leaq 0x1d0c35(%rip), %r15    # 0x3b5720
movq %r15, %rsi
movl $0x5e4, %edx            # imm = 0x5E4
callq 0x1045eb
xorl %r12d, %r12d
movq %r12, 0x2d8(%rbx)
movq 0x2d0(%rbx), %rdi
movq %r15, %rsi
movl $0x5e6, %edx            # imm = 0x5E6
callq 0x1045eb
movq %r12, 0x2d0(%rbx)
movq 0x2e0(%rbx), %rdi
callq 0x1f542d
movq %r12, 0x2e0(%rbx)
movq 0x2c8(%rbx), %rdi
callq 0x1e6192
movq 0x8(%rbx), %rdi
callq 0xe9204
movq 0x10(%rbx), %rdi
callq 0xe9204
movq 0x2c0(%rbx), %rdi
movq %r15, %rsi
movl $0x5ed, %edx            # imm = 0x5ED
callq 0x1045eb
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1e4b8f
leaq 0x20(%rbx), %r15
leaq 0x1d0baa(%rip), %rsi    # 0x3b5720
movl $0x5ee, %edx            # imm = 0x5EE
callq 0x1045eb
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0x2f0(%rbx), %rdi
callq 0x32085a
movq 0x68(%rbx), %rdx
leaq 0x1d0f71(%rip), %rsi    # 0x3b5b17
movq %r14, %rdi
xorl %eax, %eax
callq 0x103fe1
movq 0x90(%rbx), %rdx
leaq 0x1d0f70(%rip), %rsi    # 0x3b5b2e
movq %r14, %rdi
xorl %eax, %eax
callq 0x103fe1
movq 0x88(%rbx), %rdx
leaq 0x1d0f6c(%rip), %rsi    # 0x3b5b42
movq %r14, %rdi
xorl %eax, %eax
callq 0x103fe1
movq 0x78(%rbx), %rdx
leaq 0x1d0f6d(%rip), %rsi    # 0x3b5b58
movq %r14, %rdi
xorl %eax, %eax
callq 0x103fe1
movq 0x80(%rbx), %rdx
leaq 0x1d0f6c(%rip), %rsi    # 0x3b5b6f
movq %r14, %rdi
xorl %eax, %eax
callq 0x103fe1
movq 0x70(%rbx), %rdx
leaq 0x1d0f6a(%rip), %rsi    # 0x3b5b82
movq %r14, %rdi
xorl %eax, %eax
callq 0x103fe1
leaq 0x1d0af7(%rip), %rsi    # 0x3b5720
movq %rbx, %rdi
movl $0x5f6, %edx            # imm = 0x5F6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1045eb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: gt_sortallsuffixesfromstart
void gt_sortallsuffixesfromstart(GtSuffixsortspace *suffixsortspace,
                                 GtUword numberofsuffixes,
                                 const GtEncseq *encseq,
                                 GtReadmode readmode,
                                 GtOutlcpinfo *outlcpinfo,
                                 unsigned int sortmaxdepth,
                                 const Sfxstrategy *sfxstrategy,
                                 GtProcessunsortedsuffixrange
                                   processunsortedsuffixrange,
                                 void *processunsortedsuffixrangeinfo,
                                 GtLogger *logger)
{
  if (numberofsuffixes > 1UL)
  {
    GtBentsedgresources *bsr = bentsedgresources_new(suffixsortspace,
                                                     encseq,
                                                     readmode,
                                                     0,
                                                     NULL,
                                                     sortmaxdepth,
                                                     sfxstrategy,
                                                     outlcpinfo != NULL
                                                       ? true : false);
    gt_bentsedgresources_addlcpinfo(bsr,outlcpinfo,NULL);
    bsr->processunsortedsuffixrange = processunsortedsuffixrange;
    bsr->processunsortedsuffixrangeinfo = processunsortedsuffixrangeinfo;
    gt_sort_bentleysedgewick(bsr,0,numberofsuffixes,0);
    bentsedgresources_delete(bsr, logger);
  }
}

// Assembly:
cmpq $0x2, %rsi
jb 0x1e4ccd
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rsi, %rbx
movq 0x58(%rsp), %r14
movq 0x50(%rsp), %r13
movq 0x48(%rsp), %rbp
xorl %eax, %eax
testq %r8, %r8
setne %al
movq %rdx, %rsi
movl %ecx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
pushq %rax
pushq 0x48(%rsp)
callq 0x1e309e
addq $0x10, %rsp
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1e33e9
movq %rbp, 0x50(%r12)
movq %r13, 0x58(%r12)
movq %r12, %rdi
xorl %esi, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x1e3417
movq %r12, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1e4acf
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: medianof3cmpcharbychar
static GtUword medianof3cmpcharbychar(const GtBentsedgresources *bsr,
                                            GtUword subbucketleft,
                                            GtUword depth,
                                            GtUword a,
                                            GtUword b,
                                            GtUword c)
{
  GtUword vala, valb, valc, cptr;
  GtUchar tmpavar, tmpbvar;

  CMPCHARBYCHARPTR2INT(vala,subbucketleft,tmpavar,a);
  CMPCHARBYCHARPTR2INT(valb,subbucketleft,tmpbvar,b);
  if (vala == valb)
  {
    return a;
  }
  CMPCHARBYCHARPTR2INT(valc,subbucketleft,tmpavar,c);
  if (vala == valc || valb == valc)
  {
    return c;
  }
  return vala < valb ?
        (valb < valc ? b : (vala < valc ? c : a))
      : (valb > valc ? b : (vala < valc ? a : c));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r14
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r13
movq 0x48(%rdi), %rdi
movq %rcx, 0x10(%rsp)
movq %rcx, %rdx
callq 0x1fc965
movq %rax, %r12
addq %rbp, %r12
cmpq 0xb0(%r13), %r12
jae 0x1e5d47
movq (%r13), %rdi
movl 0x18(%r13), %edx
movq %r12, %rsi
callq 0xe7bbc
cmpb $-0x3, %al
ja 0x1e5d47
movzbl %al, %r12d
jmp 0x1e5d4e
addq $0x100, %r12            # imm = 0x100
movq 0x48(%r13), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1fc965
movq %rax, %r15
addq %rbp, %r15
cmpq 0xb0(%r13), %r15
jae 0x1e5d86
movq (%r13), %rdi
movl 0x18(%r13), %edx
movq %r15, %rsi
callq 0xe7bbc
cmpb $-0x3, %al
ja 0x1e5d86
movzbl %al, %r15d
jmp 0x1e5d8d
addq $0x100, %r15            # imm = 0x100
cmpq %r15, %r12
jne 0x1e5d99
movq 0x10(%rsp), %r14
jmp 0x1e5e02
movq 0x48(%r13), %rdi
movq %rbx, %rsi
movq 0x8(%rsp), %rdx
callq 0x1fc965
movq %rax, %rbx
addq %rbp, %rbx
cmpq 0xb0(%r13), %rbx
jae 0x1e5dd2
movq (%r13), %rdi
movl 0x18(%r13), %edx
movq %rbx, %rsi
callq 0xe7bbc
cmpb $-0x3, %al
ja 0x1e5dd2
movzbl %al, %ebx
jmp 0x1e5dd9
addq $0x100, %rbx            # imm = 0x100
cmpq %rbx, %r12
je 0x1e5dfd
cmpq %rbx, %r15
je 0x1e5dfd
cmpq %r15, %r12
jae 0x1e5e14
cmpq %rbx, %r15
jb 0x1e5e02
cmpq %rbx, %r12
movq 0x10(%rsp), %r14
cmovbq 0x8(%rsp), %r14
jmp 0x1e5e02
movq 0x8(%rsp), %r14
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq %rbx, %r15
ja 0x1e5e02
cmpq %rbx, %r12
movq 0x8(%rsp), %r14
cmovbq 0x10(%rsp), %r14
jmp 0x1e5e02
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: medianof3
static GtUword medianof3(const GtBentsedgresources *bsr,
                               GtUword subbucketleft,
                               GtUword depth,
                               GtUword a,
                               GtUword b,
                               GtUword c)
{
  GtSfxcmp vala, valb, valc;
  GtCommonunits commonunits;
  int retvalavalb, retvalavalc, retvalbvalc;

  PTR2INT(vala,subbucketleft,a);
  PTR2INT(valb,subbucketleft,b);
  Sfxdocompare(&commonunits,vala,valb);
  if (GtSfxcmpEQUAL(vala,valb))
  {
    return a;
  }
  PTR2INT(valc,subbucketleft,c);
  Sfxdocompare(&commonunits,vala,valc);
  if (GtSfxcmpEQUAL(vala,valc))
  {
    return c;
  }
  Sfxdocompare(&commonunits,valb,valc);
  if (GtSfxcmpEQUAL(valb,valc))
  {
    return c;
  }
  return GtSfxcmpSMALLER(vala,valb) ?
        (GtSfxcmpSMALLER(valb,valc) ? b : (GtSfxcmpSMALLER(vala,valc) ? c : a))
      : (GtSfxcmpGREATER(valb,valc) ? b : (GtSfxcmpSMALLER(vala,valc) ? a : c));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
movq 0x48(%rdi), %rdi
movq %rcx, %rdx
callq 0x1fc965
movq %rax, 0x50(%rsp)
addq %r13, %rax
cmpq 0xb0(%r12), %rax
jae 0x1e5e86
movq (%r12), %rdx
movq 0x8(%r12), %rsi
movl 0x18(%r12), %ecx
leaq 0x40(%rsp), %rdi
movq %rax, %r8
callq 0xeca81
jmp 0x1e5e97
movq $0x0, 0x40(%rsp)
movl $0x0, 0x48(%rsp)
movq 0x48(%r12), %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x1fc965
movq %rax, 0x38(%rsp)
addq %r13, %rax
cmpq 0xb0(%r12), %rax
jae 0x1e5ed6
movq (%r12), %rdx
movq 0x8(%r12), %rsi
movl 0x18(%r12), %ecx
leaq 0x28(%rsp), %rdi
movq %rax, %r8
callq 0xeca81
jmp 0x1e5ee7
movq $0x0, 0x28(%rsp)
movl $0x0, 0x30(%rsp)
movzbl 0x1c(%r12), %edi
movzbl 0x1d(%r12), %esi
leaq 0x58(%rsp), %rdx
leaq 0x40(%rsp), %rcx
leaq 0x28(%rsp), %r8
callq 0xed110
testl %eax, %eax
je 0x1e5fd5
movl %eax, %ebx
movq 0x48(%r12), %rdi
movq %rbp, %rsi
movq 0x8(%rsp), %rdx
callq 0x1fc965
movq %rax, 0x20(%rsp)
addq %rax, %r13
cmpq 0xb0(%r12), %r13
jae 0x1e5f52
movq (%r12), %rdx
movq 0x8(%r12), %rsi
movl 0x18(%r12), %ecx
leaq 0x10(%rsp), %rdi
movq %r13, %r8
callq 0xeca81
jmp 0x1e5f63
movq $0x0, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movzbl 0x1c(%r12), %edi
movzbl 0x1d(%r12), %esi
leaq 0x58(%rsp), %rdx
leaq 0x40(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0xed110
testl %eax, %eax
je 0x1e5fc2
movl %eax, %ebp
movzbl 0x1c(%r12), %edi
movzbl 0x1d(%r12), %esi
leaq 0x58(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0xed110
testl %eax, %eax
je 0x1e5fc2
testl %ebx, %ebx
js 0x1e5fc9
testl %eax, %eax
jg 0x1e5fd8
testl %ebp, %ebp
movq 0x8(%rsp), %r14
cmovsq %r15, %r14
jmp 0x1e5fd8
movq 0x8(%rsp), %r14
jmp 0x1e5fd8
testl %eax, %eax
js 0x1e5fd8
testl %ebp, %ebp
cmovsq 0x8(%rsp), %r15
movq %r15, %r14
movq %r14, %rax
addq $0x68, %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/sfx-bltrie.c
// Function: gt_blindtrie_resize
void gt_blindtrie_resize(GtBlindtrie *blindtrie,unsigned int maxnumofnodes)
{
  gt_assert(maxnumofnodes > 0);
  if (blindtrie->allocatedBlindtrienode > maxnumofnodes)
  {
    blindtrie->allocatedBlindtrienode = maxnumofnodes;
    blindtrie->spaceBlindtrienode
      = gt_realloc(blindtrie->spaceBlindtrienode,
                   sizeof (*blindtrie->spaceBlindtrienode) *
                   blindtrie->allocatedBlindtrienode);
  }
}

// Assembly:
pushq %rbx
testl %esi, %esi
je 0x1e6154
movq %rdi, %rbx
cmpl %esi, (%rdi)
jbe 0x1e6152
movl %esi, (%rbx)
movq 0x8(%rbx), %rdi
movl %esi, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
leaq 0x1cfbda(%rip), %rdx    # 0x3b5d1e
movl $0x3c2, %ecx            # imm = 0x3C2
callq 0x104461
movq %rax, 0x8(%rbx)
popq %rbx
retq
callq 0x7609f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: gt_blindtrie_delete
void gt_blindtrie_delete(GtBlindtrie *blindtrie)
{
  if (blindtrie == NULL)
  {
    return;
  }
  gt_Viatwobitkeyvalues_delete(blindtrie->vtk1);
  gt_Viatwobitkeyvalues_delete(blindtrie->vtk2);
  gt_free(blindtrie->spaceBlindtrienode);
  GT_FREEARRAY(&blindtrie->overflowsuffixes, GtUword);
  GT_FREEARRAY(&blindtrie->stack, GtBlindtriesnodeptr);
  gt_free(blindtrie);
}

// Assembly:
testq %rdi, %rdi
je 0x1e6244
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x80(%rdi), %rdi
callq 0xed425
movq 0x88(%rbx), %rdi
callq 0xed425
movq 0x8(%rbx), %rdi
leaq 0x1cfb59(%rip), %rsi    # 0x3b5d1e
movl $0x3e6, %edx            # imm = 0x3E6
callq 0x1045eb
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x1e61fc
leaq 0x28(%rbx), %r14
leaq 0x1cfb3b(%rip), %rsi    # 0x3b5d1e
movl $0x3e7, %edx            # imm = 0x3E7
callq 0x1045eb
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1e6229
leaq 0x10(%rbx), %r14
leaq 0x1cfb0e(%rip), %rsi    # 0x3b5d1e
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x1045eb
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x1cfaee(%rip), %rsi    # 0x3b5d1e
movq %rbx, %rdi
movl $0x3e9, %edx            # imm = 0x3E9
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_makeroot
static void blindtrie_makeroot(GtBlindtrie *blindtrie,
                               GtUword currentstartpos,
                               GtUword currenttwobitencodingstoppos)
{
  GtBlindtriesymbol firstchar;

  gt_assert(blindtrie->nextfreeBlindtrienode == GT_BLINDTRIE_ROOTIDX);
  (void) blindtrie_newnode(blindtrie);
  blindtrie_firstchar_set(blindtrie,GT_BLINDTRIE_ROOTIDX,
                          false,0); /* firstchar of root will never be used */
  blindtrie_setdepth(blindtrie,GT_BLINDTRIE_ROOTIDX,0);
  /*blindtrie_rightsibling_set(blindtrie,root,GT_BLINDTRIE_REFNULL); */
  if (blindtrie_isleftofboundary(blindtrie,currentstartpos,0))
  {
    /* Random access */
    firstchar = (GtBlindtriesymbol)
                gt_encseq_get_encoded_char(blindtrie->encseq,
                                           currentstartpos,
                                           blindtrie->readmode);
    if (GT_BLINDTRIECHAR_GT_ISSPECIAL(firstchar))
    {
      firstchar = GT_UNIQUEINT(currentstartpos);
    }
    if (currenttwobitencodingstoppos == ULONG_MAX)
    {
      currenttwobitencodingstoppos
        = blindtrie_currenttwobitencodingstoppos_get(blindtrie,currentstartpos);
    }
  } else
  {
    firstchar = GT_UNIQUEINT(currentstartpos);
    currenttwobitencodingstoppos = GT_BLTRIESTOPPOSUNDEF(blindtrie);
  }
  blindtrie_firstchild_set(blindtrie,GT_BLINDTRIE_ROOTIDX,
                           blindtrie_newleaf(blindtrie,currentstartpos,
                                             currenttwobitencodingstoppos,
                                             firstchar,GT_BLINDTRIE_REFNULL));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x4(%rdi)
jne 0x1e6b28
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1e74ec
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1e767c
movq 0x8(%rbx), %rax
movq $0x0, (%rax)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1e753e
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x1e6ab3
addq %r14, %rax
movq 0x60(%rbx), %rdx
cmpq %rdx, %rax
cmovaeq %rdx, %rax
jmp 0x1e6aba
movq 0x60(%rbx), %rdx
movq %rdx, %rax
cmpq %r14, %rax
jbe 0x1e6ae9
movq 0x40(%rbx), %rdi
movl 0x58(%rbx), %edx
movq %r14, %rsi
callq 0xe7bbc
movzbl %al, %eax
leaq 0x100(%r14), %r12
cmpb $-0x2, %al
cmovbq %rax, %r12
cmpq $-0x1, %r15
je 0x1e6af2
movq %r15, %rdx
jmp 0x1e6b00
leaq 0x100(%r14), %r12
jmp 0x1e6b00
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e6b2d
movq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x1e7598
movq %rbx, %rdi
xorl %esi, %esi
movl %eax, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1e756c
callq 0x763ee
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_currenttwobitencodingstoppos_get
static GtUword blindtrie_currenttwobitencodingstoppos_get(
                                     const GtBlindtrie *blindtrie,
                                     GtUword currentstartpos)
{
  if (!blindtrie->cmpcharbychar &&
      blindtrie->has_twobitencoding_stoppos_support)
  {
    gt_encseq_reader_reinit_with_readmode(blindtrie->esr1,blindtrie->encseq,
                                          blindtrie->readmode,
                                          currentstartpos);
    return gt_getnexttwobitencodingstoppos(GT_ISDIRREVERSE(blindtrie->readmode)
                                           ? false : true,blindtrie->esr1);
  }
  return GT_BLTRIESTOPPOSUNDEF(blindtrie);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x78(%rdi)
jne 0x1e6b69
cmpb $0x1, 0x7a(%rbx)
jne 0x1e6b69
movq %rsi, %rcx
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %rdi
movl 0x58(%rbx), %edx
callq 0xe8eed
movl 0x58(%rbx), %eax
andl $-0x3, %eax
xorl %edi, %edi
cmpl $0x1, %eax
setne %dil
movq 0x48(%rbx), %rsi
popq %rbx
jmp 0xec8db
movq 0x60(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_findsplitnode
static GtBlindtriesnodeptr blindtrie_findsplitnode(const GtBlindtrie *blindtrie,
                                                GtUword lcp)
{
  GtBlindtriesnodeptr currentnode;
  GtUword stackidx;

  currentnode = GT_BLINDTRIE_ROOTIDX;
  for (stackidx=0;stackidx<blindtrie->stack.nextfreeGtBlindtriesnodeptr;
       stackidx++)
  {
    currentnode = blindtrie->stack.spaceGtBlindtriesnodeptr[stackidx];
    if (blindtrie_isleaf(blindtrie,currentnode) ||
        blindtrie_getdepth(blindtrie,currentnode) >= lcp)
    {
      break;
    }
  }
  return currentnode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x20(%rdi)
je 0x1e7187
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x10(%r14), %rax
movl (%rax,%r15,4), %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x1e6d66
testb %al, %al
jne 0x1e7189
movq %r14, %rdi
movl %ebp, %esi
callq 0x1e7455
cmpq %rbx, %rax
jae 0x1e7189
incq %r15
cmpq 0x20(%r14), %r15
jb 0x1e7157
jmp 0x1e7189
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_newnode
static GtBlindtriesnodeptr blindtrie_newnode(GtBlindtrie *blindtrie)
{
  if (blindtrie->nextfreeBlindtrienode >= blindtrie->allocatedBlindtrienode)
  {
    gt_assert(blindtrie->nodenumberincrement >= 1U);
    gt_assert(blindtrie->allocatedBlindtrienode +
              blindtrie->nodenumberincrement <=
              (1U << GT_BLINDTRIE_BITSFORRIGHTSIBLING) - 1);
    blindtrie->allocatedBlindtrienode += blindtrie->nodenumberincrement;
    blindtrie->spaceBlindtrienode
      = gt_realloc(blindtrie->spaceBlindtrienode,
                   sizeof (*blindtrie->spaceBlindtrienode) *
                          blindtrie->allocatedBlindtrienode);
  }
  return blindtrie->nextfreeBlindtrienode++;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %ecx
movl 0x4(%rdi), %eax
cmpl %ecx, %eax
jb 0x1e752c
movl 0x7c(%rbx), %eax
testl %eax, %eax
je 0x1e7534
addl %ecx, %eax
js 0x1e7539
movl %eax, (%rbx)
movq 0x8(%rbx), %rdi
movl %eax, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
leaq 0x1ce803(%rip), %rdx    # 0x3b5d1e
movl $0x148, %ecx            # imm = 0x148
callq 0x104461
movq %rax, 0x8(%rbx)
movl 0x4(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rbx)
popq %rbx
retq
callq 0x768d0
callq 0x76897
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_newleaf
static GtBlindtriesnodeptr blindtrie_newleaf(GtBlindtrie *blindtrie,
                                          GtUword currentstartpos,
                                          GtUword
                                            currenttwobitencodingstoppos,
                                          GtBlindtriesymbol firstchar,
                                          GtBlindtriesnodeptr rightsibling)
{
  GtBlindtriesnodeptr newleaf;

  newleaf = blindtrie_newnode(blindtrie);
  blindtrie_firstchar_set(blindtrie,newleaf,true,firstchar);
  blindtrie_leafinfo_set(blindtrie,
                         newleaf,
                         currentstartpos,
                         currenttwobitencodingstoppos);
  blindtrie_rightsibling_set(blindtrie,newleaf,rightsibling);
  return newleaf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x1e74ec
movl %eax, %ebp
movq %r14, %rdi
movl %eax, %esi
movl $0x1, %edx
callq 0x1e767c
movq 0x8(%r14), %rax
movl %ebp, %ecx
leaq (%rcx,%rcx,2), %rcx
movq %r13, (%rax,%rcx,8)
cmpl %ebp, 0x4(%r14)
jbe 0x1e7663
leaq (%rax,%rcx,8), %rax
movq %r12, 0x8(%rax)
movq 0x60(%r14), %rcx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpq %r15, %rcx
je 0x1e7643
movl 0x58(%r14), %edx
orl $0x2, %edx
cmpl $0x3, %edx
jne 0x1e7625
subq %r12, %rcx
cmpq %r15, %rcx
jb 0x1e7668
testq %r15, %r15
je 0x1e7641
incq %rcx
subq %r15, %rcx
je 0x1e766d
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpq %rdx, %rcx
jae 0x1e766d
movl %ecx, %edx
jmp 0x1e7643
subq %r12, %r15
jb 0x1e7672
movq %r15, %rcx
shrq %rcx
cmpq $0x7fffffff, %rcx       # imm = 0x7FFFFFFF
jae 0x1e7677
incl %r15d
movl %r15d, %edx
jmp 0x1e7643
xorl %edx, %edx
movl %edx, 0x10(%rax)
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x1e76a7
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x7697b
callq 0x769ed
callq 0x769b4
callq 0x76a5f
callq 0x76a26