LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x190c74
movl %ebp, %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0x190c55
movq 0x50(%rsp), %rsi
movq %r15, %rdi
movq %r9, 0x10(%rsp)
callq 0x191708
movq %r15, %rdi
movq %rbx, %rsi
callq 0x191749
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 0x191910
movq (%r13), %rcx
movq %rbx, (%rsp)
movzbl %r12b, %edi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %r8
callq 0x19178a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/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
andq $0x0, 0x8(%rsp)
andq $0x0, (%rsp)
testq %rsi, %rsi
je 0x190d27
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 0x16af45
testb %al, %al
je 0x190d21
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %rdi
callq 0x16a2d0
addq $0x10, %rsp
popq %rbx
retq
movq 0x2a723a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1542db(%rip), %rsi    # 0x2e5013
leaq 0x1c4717(%rip), %rdx    # 0x355456
leaq 0x1c4728(%rip), %rcx    # 0x35546e
leaq 0x1c3f97(%rip), %r8     # 0x354ce4
movl $0x52f, %r9d            # imm = 0x52F
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x19128c
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x1c42b1(%rip), %r14    # 0x355509
movq %r14, %rsi
movl $0xd9, %edx
callq 0x936f9
movq (%rbx), %rdi
movq %r14, %rsi
movl $0xda, %edx
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0xdb, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x19128d
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1912dd
movq %rax, 0x8(%r13)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19128d
movq %rsp, %r15
movq %rax, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1912dd
movq %rax, 0x8(%r15)
movq %r13, %rdi
movq %r15, %rsi
callq 0xa3234
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x19128d
movq %rax, %r13
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19128d
cmpq %rax, %r13
jne 0x1914b2
movq %r12, %rdi
movq %r15, %rsi
callq 0x1912dd
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1912dd
cmpq %rax, %r15
sete %al
jmp 0x1914b4
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq 0x28(%rdi), %rcx
xorl %edx, %edx
divq %rcx
movq %rax, %r14
xorl %r12d, %r12d
movq $0x0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
cmpq %rcx, %r12
jae 0x191591
movq %rbx, %rdi
movq %r12, %rsi
callq 0x19128d
movq %rax, %r13
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1912dd
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x190dbf
movq %rax, %r13
subq %r14, %rax
ja 0x19152e
movq %r14, %rax
subq %r13, %rax
imulq %rax, %rax
addq %rax, 0x8(%rsp)
leaq 0x1(%r12), %rbp
movq %rbx, %rdi
movq %r12, %rsi
callq 0x19128d
movq %rax, %r15
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1912dd
movq %rax, %r14
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1913a4
leaq 0x1c4168(%rip), %rdi    # 0x3556d2
movq %rbp, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %r13, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x17070
movq 0x28(%rbx), %rcx
movq %rbp, %r12
movq 0x10(%rsp), %r14
jmp 0x1914f0
movsd 0x8(%rsp), %xmm1
movsd 0x156341(%rip), %xmm2   # 0x2e78e0
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x156346(%rip), %xmm3   # 0x2e78f0
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rcx, %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 0x1c4136(%rip), %rdi    # 0x355714
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_O2/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 %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x19128d
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x1912dd
movq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x190d60
movq %rax, %r14
movq %r15, %rdi
movq %r13, %rsi
callq 0x190d86
movq %rax, %rdi
subq %r14, %rdi
jb 0x19167a
movq %rax, %r15
incq %rdi
leaq 0x1c3eba(%rip), %rsi    # 0x355509
movl $0x142, %edx            # imm = 0x142
callq 0x93160
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x721ca
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x2a68e7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x153988(%rip), %rsi    # 0x2e5013
leaq 0x1c409f(%rip), %rdx    # 0x355731
leaq 0x1c40ac(%rip), %rcx    # 0x355745
leaq 0x1c3e69(%rip), %r8     # 0x355509
movl $0x141, %r9d            # imm = 0x141
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x1917c1
movq 0x10(%rsp), %r10
cmpq $-0x1, %r10
je 0x1917c1
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 0x1917f7
movq 0x2a67a0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x153841(%rip), %rsi    # 0x2e5013
leaq 0x1c4039(%rip), %rdx    # 0x355812
leaq 0x1c4070(%rip), %rcx    # 0x355850
leaq 0x1c3fca(%rip), %r8     # 0x3557b1
pushq $0x70
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x191883
movl %edx, %eax
andl $-0x3, %eax
cmpl $0x1, %eax
setne %r11b
cmpq $-0x1, %r9
setne %bl
orb %r11b, %bl
je 0x191883
testb %sil, %sil
je 0x191843
movl %edx, %ecx
orl $0x2, %ecx
cmpl $0x3, %ecx
jne 0x191835
notq %r8
addq %r9, %r8
leaq (%r8,%r10,2), %r8
movq %r8, 0x8(%rdi)
cmpl $0x3, %ecx
je 0x191866
movb $0x1, %sil
jmp 0x191873
movl %edx, %r11d
orl $0x2, %r11d
cmpl $0x3, %r11d
jne 0x19185c
addq %rcx, %r8
subq %r8, %r9
leaq (%r9,%r10,2), %rcx
jmp 0x191862
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
movq 0x2a66de(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15377f(%rip), %rsi    # 0x2e5013
leaq 0x1c4080(%rip), %rdx    # 0x35591b
leaq 0x1c40e9(%rip), %rcx    # 0x35598b
leaq 0x1c3f08(%rip), %r8     # 0x3557b1
pushq $0x50
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x1916d4
movq %rax, %r14
movq %rbx, (%rsp)
movl %r13d, %edi
movl %ebp, %esi
movq %rax, %rdx
movq %r12, %rcx
movq %r15, %r8
movq 0x10(%rsp), %r9
callq 0x19178a
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_O2/genometools[P]genometools/src/match/seqabstract.c
// Function: gt_seqabstract_reinit_encseq
void gt_seqabstract_reinit_encseq(bool rightextension,
                                  GtReadmode readmode,
                                  GtSeqabstract *sa,
                                  const GtEncseq *encseq,
                                  GtUword len,
                                  GtUword startpos)
{
  gt_assert(sa != NULL);
  sa->seqtype = GT_SEQABSTRACT_ENCSEQ;
  sa->seq.encseq = encseq;
  gt_seqabstract_init(sa,
                      rightextension,
                      readmode,
                      len,
                      startpos,
                      sa->totallength);
}

// Assembly:
testq %rdx, %rdx
je 0x19193d
movl %esi, %eax
movl $0x2, 0x20(%rdx)
movq %rcx, 0x28(%rdx)
movq 0x10(%rdx), %r10
movzbl %dil, %esi
movq %rdx, %rdi
movl %eax, %edx
movq %r8, %rcx
movq %r9, %r8
movq %r10, %r9
jmp 0x1917f7
pushq %rax
movq 0x2a6623(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1536c4(%rip), %rsi    # 0x2e5013
leaq 0x1c3e73(%rip), %rdx    # 0x3557c9
leaq 0x1c3f11(%rip), %rcx    # 0x35586e
leaq 0x1c3e4d(%rip), %r8     # 0x3557b1
movl $0x92, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x191ae6
movq %rdx, %r15
testq %rdx, %rdx
je 0x191ae6
movq %rsi, %r12
movq (%rsi), %rax
subq 0x10(%rsp), %rax
jb 0x191ae6
movq (%r15), %rbx
subq 0x8(%rsp), %rbx
jb 0x191ae6
cmpq %rbx, %rax
cmovbq %rax, %rbx
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x191ad4
movq 0x10(%rsp), %rax
leaq (%rax,%r13), %rsi
movq %r12, %rdi
callq 0x191b1e
cmpb $-0x3, %al
ja 0x191ad1
movl %eax, %ebp
movb 0x25(%r12), %r14b
movq 0x8(%rsp), %rax
leaq (%rax,%r13), %rsi
movq %r15, %rdi
callq 0x191b1e
cmpb $-0x3, %al
ja 0x191ad1
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 0x191ad1
incq %r13
jmp 0x191a6e
movq %r13, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2a647b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15351c(%rip), %rsi    # 0x2e5013
leaq 0x1c3da3(%rip), %rdx    # 0x3558a1
leaq 0x1c3de9(%rip), %rcx    # 0x3558ee
leaq 0x1c3ca5(%rip), %r8     # 0x3557b1
movl $0xd6, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/seqabstract.c
// Function: gt_seqabstract_get_encoded_char
static GtUchar gt_seqabstract_get_encoded_char(GT_UNUSED bool rightextension,
                                               const GtSeqabstract *seq,
                                               GtUword idx)
{
  GtUword accesspos;

  if (seq->read_seq_left2right)
  {
    accesspos = seq->offset + idx;
  } else
  {
    gt_assert(seq->offset >= idx);
    accesspos = seq->offset - idx;
  }
  if (seq->seqtype == GT_SEQABSTRACT_STRING)
  {
    return seq->seq.string[accesspos];
  }
  return gt_encseq_get_encoded_char(seq->seq.encseq,accesspos,
                                    GT_READMODE_FORWARD);
}

// Assembly:
movq %rsi, %rax
movq 0x8(%rdi), %rsi
cmpb $0x1, 0x24(%rdi)
jne 0x191b30
addq %rax, %rsi
jmp 0x191b35
subq %rax, %rsi
jb 0x191b4a
cmpl $0x1, 0x20(%rdi)
movq 0x28(%rdi), %rdi
jne 0x191b43
movb (%rdi,%rsi), %al
retq
xorl %edx, %edx
jmp 0x705e4
pushq %rax
movq 0x2a6416(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1534b7(%rip), %rsi    # 0x2e5013
leaq 0x1f2648(%rip), %rdx    # 0x3841ab
leaq 0x1c3e35(%rip), %rcx    # 0x35599f
leaq 0x1c3c40(%rip), %r8     # 0x3557b1
movl $0xc2, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1c3c16(%rip), %rsi    # 0x3557b1
movl $0xf9, %edx
callq 0x93160
movq %rax, %r14
xorl %r15d, %r15d
leaq 0x16c682(%rip), %r12    # 0x2fe234
movq (%rbx), %rax
cmpq %rax, %r15
jae 0x191bed
movq %rbx, %rdi
movq %r15, %rsi
callq 0x191b1e
cmpb $-0x2, %al
je 0x191bd8
movzbl %al, %ecx
cmpl $0xff, %ecx
jne 0x191bdc
movb $0x24, %al
jmp 0x191be4
movb $0x23, %al
jmp 0x191be4
cmpb $0x4, %al
jae 0x191c01
movb (%rcx,%r12), %al
movb %al, (%r14,%r15)
incq %r15
jmp 0x191bb2
movb $0x0, (%r14,%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x2a6360(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x153401(%rip), %rsi    # 0x2e5013
leaq 0x1c3ce8(%rip), %rdx    # 0x355901
leaq 0x1c3ce8(%rip), %rcx    # 0x355908
leaq 0x1c3b8a(%rip), %r8     # 0x3557b1
movl $0x10a, %r9d            # imm = 0x10A
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x1c3d74(%rip), %rsi    # 0x3559bf
pushq $0x18
popq %rdi
pushq $0x22
popq %rdx
callq 0x93160
movl %ebp, 0x10(%rax)
pushq $-0x1
popq %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_O2/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 %rbx
pushq %rax
movl %edx, %ecx
movl %edi, %ebx
leaq 0x1(%rsi), %rdx
callq 0x191d2f
testl %eax, %eax
je 0x191d25
movl %eax, %ebp
movl %ebx, %edi
callq 0x1649b0
movl %eax, %ecx
cmpl %ebp, %eax
movl %ebp, %eax
cmovbl %ecx, %eax
testl %ecx, %ecx
cmovel %ebp, %eax
jmp 0x191d28
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-apfxlen.c
// Function: gt_whatisthemaximalprefixlength
unsigned int gt_whatisthemaximalprefixlength(unsigned int numofchars,
                                             GtUword totallength,
                                             unsigned int prefixlenbits,
                                             bool withspecialsuffixes)
{
  unsigned int maxprefixlen, mbp;

  maxprefixlen = prefixlengthwithmaxspace(numofchars,totallength,
                                          GT_MAXMULTIPLIEROFTOTALLENGTH,
                                          totallength+1,
                                          withspecialsuffixes);
  mbp = gt_maxbasepower(numofchars);
  maxprefixlen = GT_MIN(mbp,maxprefixlen);
  if (prefixlenbits > 0)
  {
    unsigned int tmplength;
    tmplength
      = prefixlengthwithmaxspace(numofchars,
                                 (GtUword)
                                 MAXREMAININGAFTERPREFIXLEN(prefixlenbits),
                                 GT_RECOMMENDED_MULTIPLIER_DEFAULT,
                                 totallength+1,
                                 withspecialsuffixes);
    if (tmplength > 0 && maxprefixlen > tmplength)
    {
      maxprefixlen = tmplength;
    }
    tmplength = GT_MAXVALUEWITHBITS(prefixlenbits);
    if (tmplength > 0 && maxprefixlen > tmplength)
    {
      maxprefixlen = tmplength;
    }
  }
  if (maxprefixlen == 0)
  {
    return 1U;
  }
  return maxprefixlen;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r14d
movl %edi, %r12d
leaq 0x1(%rsi), %r15
movsd 0x1c3c30(%rip), %xmm0   # 0x355a10
movq %r15, %rdx
callq 0x191d2f
movl %eax, %ebx
movl %r12d, %edi
callq 0x1649b0
cmpl %ebx, %eax
cmovbl %eax, %ebx
testl %r14d, %r14d
je 0x191e3d
leal 0x20(%r14), %ecx
negl %ecx
pushq $-0x1
popq %rsi
shlq %cl, %rsi
notq %rsi
movzbl %bpl, %ecx
movsd 0x15f8d1(%rip), %xmm0   # 0x2f16e8
movl %r12d, %edi
movq %r15, %rdx
callq 0x191d2f
cmpl %eax, %ebx
movl %eax, %edx
cmovbl %ebx, %edx
testl %eax, %eax
cmovel %ebx, %edx
pushq $-0x1
popq %rbx
movl %r14d, %ecx
shll %cl, %ebx
notl %ebx
cmpl %ebx, %edx
cmovbl %edx, %ebx
cmpl $0x1, %ebx
adcl $0x0, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x191e6a
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x191e8d
xorl %eax, %eax
cmpl %ebp, %ebx
jae 0x191e88
leaq 0x1c3bce(%rip), %rsi    # 0x355a45
movq %r14, %rdi
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x2a60d4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x153175(%rip), %rsi    # 0x2e5013
leaq 0x15331a(%rip), %rdx    # 0x2e51bf
leaq 0x1c3b6c(%rip), %rcx    # 0x355a18
leaq 0x1c3b7a(%rip), %r8     # 0x355a2d
movl $0x99, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x191f13
xorl %ebx, %ebx
jmp 0x191f2b
movq (%rdi), %rax
movq 0x18(%rdi), %rbx
shlq $0x4, %rbx
cmpq $0x1f, %rax
jb 0x191f2b
shlq $0x5, %rax
addq %rax, %rbx
movq 0x10(%rdi), %rdi
callq 0x1952d7
addq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x192410
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x19d6e1
movq %rax, 0x38(%rbx)
movq 0x2e0(%rbx), %rdi
testq %rdi, %rdi
popq %rbx
je 0x192410
movq %rax, %rsi
jmp 0x1a7b09
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x2d8(%rdi), %rdi
leaq 0x1c2223(%rip), %r15    # 0x355b80
movq %r15, %rsi
movl $0x5e4, %edx            # imm = 0x5E4
callq 0x936f9
andq $0x0, 0x2d8(%rbx)
movq 0x2d0(%rbx), %rdi
movq %r15, %rsi
movl $0x5e6, %edx            # imm = 0x5E6
callq 0x936f9
andq $0x0, 0x2d0(%rbx)
movq 0x2e0(%rbx), %rdi
callq 0x1a7a6c
andq $0x0, 0x2e0(%rbx)
movq 0x2c8(%rbx), %rdi
callq 0x195304
movq 0x8(%rbx), %rdi
callq 0x722ae
movq 0x10(%rbx), %rdi
callq 0x722ae
movq 0x2c0(%rbx), %rdi
movq %r15, %rsi
movl $0x5ed, %edx            # imm = 0x5ED
callq 0x936f9
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1939fe
leaq 0x20(%rbx), %r15
leaq 0x1c2198(%rip), %rsi    # 0x355b80
movl $0x5ee, %edx            # imm = 0x5EE
callq 0x936f9
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
andq $0x0, 0x10(%r15)
movq 0x2f0(%rbx), %rdi
callq 0x2c1a84
movq 0x68(%rbx), %rdx
leaq 0x1c2562(%rip), %rsi    # 0x355f77
movq %r14, %rdi
xorl %eax, %eax
callq 0x92e71
movq 0x90(%rbx), %rdx
leaq 0x1c2561(%rip), %rsi    # 0x355f8e
movq %r14, %rdi
xorl %eax, %eax
callq 0x92e71
movq 0x88(%rbx), %rdx
leaq 0x1c255d(%rip), %rsi    # 0x355fa2
movq %r14, %rdi
xorl %eax, %eax
callq 0x92e71
movq 0x78(%rbx), %rdx
leaq 0x1c255e(%rip), %rsi    # 0x355fb8
movq %r14, %rdi
xorl %eax, %eax
callq 0x92e71
movq 0x80(%rbx), %rdx
leaq 0x1c255d(%rip), %rsi    # 0x355fcf
movq %r14, %rdi
xorl %eax, %eax
callq 0x92e71
movq 0x70(%rbx), %rdx
leaq 0x1c255b(%rip), %rsi    # 0x355fe2
movq %r14, %rdi
xorl %eax, %eax
callq 0x92e71
leaq 0x1c20e8(%rip), %rsi    # 0x355b80
movq %rbx, %rdi
movl $0x5f6, %edx            # imm = 0x5F6
popq %rbx
popq %r14
popq %r15
jmp 0x936f9
// File: /workspace/github_c_makefile_star2_O2/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 0x193b34
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 0x1920b1
popq %rcx
popq %rdx
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1923e3
movq %rbp, 0x50(%r12)
movq %r13, 0x58(%r12)
movq %r12, %rdi
xorl %esi, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x192411
movq %r12, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x193944
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: vectorswap
static inline void vectorswap(GtSuffixsortspace *sssp,
                              GtUword subbucketleft1,
                              GtUword subbucketleft2,
                              GtUword width)
{
  GtUword idx, tmp;

  for (idx = 0; idx < width; idx++)
  {
    tmp = gt_suffixsortspace_get(sssp,subbucketleft1,idx);
    gt_suffixsortspace_set(sssp,subbucketleft1,idx,
                           gt_suffixsortspace_get(sssp,subbucketleft2,idx));
    gt_suffixsortspace_set(sssp,subbucketleft2,idx,tmp);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x194c8b
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x1af8b2
movq %rax, %rbp
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1af8b2
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0x1af9c7
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x1af9c7
incq %r13
jmp 0x194c40
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-lcpvalues.h
// Function: gt_lcptab_update
static inline void gt_lcptab_update(GtLcpvalues *tableoflcpvalues,
                                                 GtUword subbucketleft,
                                                 GtUword idx,
                                                 GtUword value)
{
  gt_assert (tableoflcpvalues != NULL &&
             tableoflcpvalues->bucketoflcpvalues != NULL &&
             tableoflcpvalues->lcptaboffset+subbucketleft+idx <
             tableoflcpvalues->numofentries);
#ifndef NDEBUG
  if (tableoflcpvalues->isset != NULL)
  {
    GT_SETIBIT(tableoflcpvalues->isset,
               tableoflcpvalues->lcptaboffset+subbucketleft+idx);
  }
#endif
  gt_assert(value <= GT_LCPVALUE_MAX);
  tableoflcpvalues->bucketoflcpvalues[tableoflcpvalues->lcptaboffset +
                                      subbucketleft + idx]
                                      = (GtLcpvaluetype) value;
  if (value >= (GtUword) LCPOVERFLOW)
  {
    tableoflcpvalues->numoflargelcpvalues++; /* this may overcount as there may
                                                be some value at index <idx>
                                                which was already overflowing */
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x194cfd
movq 0x8(%rdi), %r8
testq %r8, %r8
je 0x194cfd
movq %rcx, %rax
leaq (%rdx,%rsi), %rcx
addq 0x20(%rdi), %rcx
cmpq 0x10(%rdi), %rcx
jae 0x194cfd
movq (%rdi), %r9
testq %r9, %r9
je 0x194cd7
movabsq $-0x8000000000000000, %r10 # imm = 0x8000000000000000
shrq %cl, %r10
shrq $0x6, %rcx
orq %r10, (%r9,%rcx,8)
movq %rax, %rcx
shrq $0x20, %rcx
jne 0x194d27
movq 0x20(%rdi), %rcx
leaq (%r8,%rcx,4), %rcx
leaq (%rcx,%rsi,4), %rcx
movl %eax, (%rcx,%rdx,4)
cmpq $0xff, %rax
jb 0x194cfb
incq 0x18(%rdi)
popq %rax
retq
movq 0x2a3264(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x150305(%rip), %rsi    # 0x2e5013
leaq 0x1c0fd9(%rip), %rdx    # 0x355cee
leaq 0x1c1231(%rip), %rcx    # 0x355f4d
leaq 0x1c107b(%rip), %r8     # 0x355d9e
pushq $0x3f
jmp 0x194d4f
movq 0x2a323a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1502db(%rip), %rsi    # 0x2e5013
leaq 0x1c121f(%rip), %rdx    # 0x355f5e
leaq 0x1c1207(%rip), %rcx    # 0x355f4d
leaq 0x1c1051(%rip), %r8     # 0x355d9e
pushq $0x47
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-lcpvalues.h
// Function: gt_lcptab_getvalue
static inline GtUword gt_lcptab_getvalue(
                                        const GtLcpvalues *tableoflcpvalues,
                                        GtUword subbucketleft,
                                        GtUword idx)
{
  gt_assert (tableoflcpvalues != NULL &&
             tableoflcpvalues->bucketoflcpvalues != NULL &&
             tableoflcpvalues->lcptaboffset+subbucketleft+idx <
             tableoflcpvalues->numofentries);
  gt_assert(tableoflcpvalues->isset == NULL ||
            GT_ISIBITSET(tableoflcpvalues->isset,
                         tableoflcpvalues->lcptaboffset+subbucketleft+idx));
  return (GtUword) tableoflcpvalues->bucketoflcpvalues
                           [tableoflcpvalues->lcptaboffset+subbucketleft+idx];
}

// Assembly:
pushq %rax
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x194da1
movq 0x20(%rdi), %r8
leaq (%rdx,%rsi), %rcx
addq %r8, %rcx
cmpq 0x10(%rdi), %rcx
jae 0x194da1
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x194d94
movq %rcx, %r9
shrq $0x6, %r9
movq (%rdi,%r9,8), %rdi
shlq %cl, %rdi
shrq $0x3f, %rdi
je 0x194dcb
leaq (%rax,%r8,4), %rax
leaq (%rax,%rsi,4), %rax
movl (%rax,%rdx,4), %eax
popq %rcx
retq
movq 0x2a31c0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x150261(%rip), %rsi    # 0x2e5013
leaq 0x1c0f35(%rip), %rdx    # 0x355cee
leaq 0x1c0fcb(%rip), %rcx    # 0x355d8b
leaq 0x1c0fd7(%rip), %r8     # 0x355d9e
pushq $0x5b
jmp 0x194df3
movq 0x2a3196(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x150237(%rip), %rsi    # 0x2e5013
leaq 0x1c0fd5(%rip), %rdx    # 0x355db8
leaq 0x1c0fa1(%rip), %rcx    # 0x355d8b
leaq 0x1c0fad(%rip), %r8     # 0x355d9e
pushq $0x5e
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1af8b2
movq %rax, %r12
addq %rbp, %r12
cmpq 0xb0(%r13), %r12
jae 0x194e5a
movq (%r13), %rdi
movl 0x18(%r13), %edx
movq %r12, %rsi
callq 0x705e4
cmpb $-0x3, %al
ja 0x194e5a
movzbl %al, %r12d
jmp 0x194e61
addq $0x100, %r12            # imm = 0x100
movq 0x48(%r13), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1af8b2
movq %rax, %r15
addq %rbp, %r15
cmpq 0xb0(%r13), %r15
jae 0x194e99
movq (%r13), %rdi
movl 0x18(%r13), %edx
movq %r15, %rsi
callq 0x705e4
cmpb $-0x3, %al
ja 0x194e99
movzbl %al, %r15d
jmp 0x194ea0
addq $0x100, %r15            # imm = 0x100
cmpq %r15, %r12
jne 0x194eac
movq 0x10(%rsp), %r14
jmp 0x194f15
movq 0x48(%r13), %rdi
movq %rbx, %rsi
movq 0x8(%rsp), %rdx
callq 0x1af8b2
movq %rax, %rbx
addq %rbp, %rbx
cmpq 0xb0(%r13), %rbx
jae 0x194ee5
movq (%r13), %rdi
movl 0x18(%r13), %edx
movq %rbx, %rsi
callq 0x705e4
cmpb $-0x3, %al
ja 0x194ee5
movzbl %al, %ebx
jmp 0x194eec
addq $0x100, %rbx            # imm = 0x100
cmpq %rbx, %r12
je 0x194f10
cmpq %rbx, %r15
je 0x194f10
cmpq %r15, %r12
jae 0x194f27
cmpq %rbx, %r15
jb 0x194f15
cmpq %rbx, %r12
movq 0x10(%rsp), %r14
cmovbq 0x8(%rsp), %r14
jmp 0x194f15
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 0x194f15
cmpq %rbx, %r12
movq 0x8(%rsp), %r14
cmovbq 0x10(%rsp), %r14
jmp 0x194f15
// File: /workspace/github_c_makefile_star2_O2/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 0x1af8b2
movq %rax, 0x50(%rsp)
addq %r13, %rax
cmpq 0xb0(%r12), %rax
jae 0x194f99
movq (%r12), %rdx
movq 0x8(%r12), %rsi
movl 0x18(%r12), %ecx
leaq 0x40(%rsp), %rdi
movq %rax, %r8
callq 0x76841
jmp 0x194fa4
andq $0x0, 0x40(%rsp)
andl $0x0, 0x48(%rsp)
movq 0x48(%r12), %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x1af8b2
movq %rax, 0x38(%rsp)
addq %r13, %rax
cmpq 0xb0(%r12), %rax
jae 0x194fe3
movq (%r12), %rdx
movq 0x8(%r12), %rsi
movl 0x18(%r12), %ecx
leaq 0x28(%rsp), %rdi
movq %rax, %r8
callq 0x76841
jmp 0x194fee
andq $0x0, 0x28(%rsp)
andl $0x0, 0x30(%rsp)
movzbl 0x1c(%r12), %edi
movzbl 0x1d(%r12), %esi
leaq 0x58(%rsp), %rdx
leaq 0x40(%rsp), %rcx
leaq 0x28(%rsp), %r8
callq 0x77074
testl %eax, %eax
je 0x1950d6
movl %eax, %ebx
movq 0x48(%r12), %rdi
movq %rbp, %rsi
movq 0x8(%rsp), %rdx
callq 0x1af8b2
movq %rax, 0x20(%rsp)
addq %rax, %r13
cmpq 0xb0(%r12), %r13
jae 0x195059
movq (%r12), %rdx
movq 0x8(%r12), %rsi
movl 0x18(%r12), %ecx
leaq 0x10(%rsp), %rdi
movq %r13, %r8
callq 0x76841
jmp 0x195064
andq $0x0, 0x10(%rsp)
andl $0x0, 0x18(%rsp)
movzbl 0x1c(%r12), %edi
movzbl 0x1d(%r12), %esi
leaq 0x58(%rsp), %rdx
leaq 0x40(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0x77074
testl %eax, %eax
je 0x1950c3
movl %eax, %ebp
movzbl 0x1c(%r12), %edi
movzbl 0x1d(%r12), %esi
leaq 0x58(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0x77074
testl %eax, %eax
je 0x1950c3
testl %ebx, %ebx
js 0x1950ca
testl %eax, %eax
jg 0x1950d9
testl %ebp, %ebp
movq 0x8(%rsp), %r14
cmovsq %r15, %r14
jmp 0x1950d9
movq 0x8(%rsp), %r14
jmp 0x1950d9
testl %eax, %eax
js 0x1950d9
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_O2/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 0x19529f
movq %rdi, %rbx
cmpl %esi, (%rdi)
jbe 0x19529d
movl %esi, (%rbx)
movq 0x8(%rbx), %rdi
movl %esi, %eax
imulq $0x18, %rax, %rsi
leaq 0x1c0eef(%rip), %rdx    # 0x35617e
movl $0x3c2, %ecx            # imm = 0x3C2
callq 0x93472
movq %rax, 0x8(%rbx)
popq %rbx
retq
movq 0x2a2cc2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x14fd63(%rip), %rsi    # 0x2e5013
leaq 0x1c0f1d(%rip), %rdx    # 0x3561d4
leaq 0x1c0f28(%rip), %rcx    # 0x3561e6
leaq 0x1c0eb9(%rip), %r8     # 0x35617e
movl $0x3bb, %r9d            # imm = 0x3BB
xorl %eax, %eax
callq 0x17a50
callq 0x17390