LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %dil, %al
movq 0x30(%rsp), %rdi
andb $0x1, %al
movb %al, 0x27(%rsp)
movl %esi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %r9, (%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x2b08b9
cmpq $-0x1, 0x30(%rsp)
jne 0x2b08f1
movq 0x38b6e0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x265749(%rip), %rsi    # 0x516013
leaq 0x2d7931(%rip), %rdx    # 0x588202
leaq 0x2d7968(%rip), %rcx    # 0x588240
leaq 0x2d78c2(%rip), %r8     # 0x5881a1
movl $0x70, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2b08f3
movq 0x18(%rsp), %rax
movl $0x1, 0x20(%rax)
movq 0x30(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x18(%rsp), %rdi
movb 0x27(%rsp), %al
movl 0x20(%rsp), %edx
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
movq 0x30(%rsp), %r9
andb $0x1, %al
movzbl %al, %esi
callq 0x2b0950
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movl %esi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
callq 0x2b0770
movq %rax, 0x8(%rsp)
movb 0x37(%rsp), %dil
movl 0x30(%rsp), %esi
movq 0x8(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r9
movq 0x10(%rsp), %rax
andb $0x1, %dil
movzbl %dil, %edi
movq %rax, (%rsp)
callq 0x2b0880
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movl %esi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %r9, (%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x2b0c24
movq 0x38b3ad(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x265416(%rip), %rsi    # 0x516013
leaq 0x2d75b5(%rip), %rdx    # 0x5881b9
leaq 0x2d7653(%rip), %rcx    # 0x58825e
leaq 0x2d758f(%rip), %r8     # 0x5881a1
movl $0x92, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2b0c26
movq 0x18(%rsp), %rax
movl $0x2, 0x20(%rax)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x18(%rsp), %rdi
movb 0x27(%rsp), %al
movl 0x20(%rsp), %edx
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
movq 0x18(%rsp), %rsi
movq 0x10(%rsi), %r9
andb $0x1, %al
movzbl %al, %esi
callq 0x2b0950
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movl %esi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
callq 0x2b0770
movq %rax, (%rsp)
movb 0x27(%rsp), %al
movl 0x20(%rsp), %esi
movq (%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
andb $0x1, %al
movzbl %al, %edi
callq 0x2b0bc0
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x47(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x2b0d9f
cmpq $0x0, 0x30(%rsp)
je 0x2b0d9f
movq 0x38(%rsp), %rax
movq (%rax), %rax
cmpq 0x28(%rsp), %rax
jb 0x2b0d9f
movq 0x30(%rsp), %rax
movq (%rax), %rax
cmpq 0x20(%rsp), %rax
jae 0x2b0dd7
movq 0x38b1fa(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x265263(%rip), %rsi    # 0x516013
leaq 0x2d74da(%rip), %rdx    # 0x588291
leaq 0x2d7520(%rip), %rcx    # 0x5882de
leaq 0x2d73dc(%rip), %r8     # 0x5881a1
movl $0xd6, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2b0dd9
movq 0x38(%rsp), %rax
movq (%rax), %rax
subq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
movq (%rcx), %rcx
subq 0x20(%rsp), %rcx
cmpq %rcx, %rax
jae 0x2b0e0b
movq 0x38(%rsp), %rax
movq (%rax), %rax
subq 0x28(%rsp), %rax
movq %rax, (%rsp)
jmp 0x2b0e1c
movq 0x30(%rsp), %rax
movq (%rax), %rax
subq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x2b0efa
movb 0x47(%rsp), %al
movq 0x38(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq 0x18(%rsp), %rdx
andb $0x1, %al
movzbl %al, %edi
callq 0x2b0f10
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0xfe, %eax
jl 0x2b0e70
jmp 0x2b0efa
movq 0x38(%rsp), %rax
testb $0x1, 0x25(%rax)
je 0x2b0e8b
movzbl 0xf(%rsp), %ecx
movl $0x3, %eax
subl %ecx, %eax
movb %al, 0xf(%rsp)
movb 0x47(%rsp), %al
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq 0x18(%rsp), %rdx
andb $0x1, %al
movzbl %al, %edi
callq 0x2b0f10
movb %al, 0xe(%rsp)
movzbl 0xe(%rsp), %eax
cmpl $0xfe, %eax
jl 0x2b0eba
jmp 0x2b0efa
movq 0x30(%rsp), %rax
testb $0x1, 0x25(%rax)
je 0x2b0ed5
movzbl 0xe(%rsp), %ecx
movl $0x3, %eax
subl %ecx, %eax
movb %al, 0xe(%rsp)
movzbl 0xf(%rsp), %eax
movzbl 0xe(%rsp), %ecx
cmpl %ecx, %eax
je 0x2b0ee5
jmp 0x2b0efa
jmp 0x2b0ee7
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2b0e2e
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x26(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
testb $0x1, 0x24(%rax)
je 0x2b0f47
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x2b0fa6
jmp 0x2b0f49
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x10(%rsp), %rax
jae 0x2b0f91
movq 0x38b040(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2650a9(%rip), %rsi    # 0x516013
leaq 0x30867a(%rip), %rdx    # 0x5b95eb
leaq 0x2d7417(%rip), %rcx    # 0x58838f
leaq 0x2d7222(%rip), %r8     # 0x5881a1
movl $0xc2, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2b0f93
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
subq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x1, 0x20(%rax)
jne 0x2b0fc8
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x27(%rsp)
jmp 0x2b0fe1
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0xa9da0
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
leaq 0x2d7188(%rip), %rsi    # 0x5881a1
movl $0xf9, %edx
callq 0xe80f0
movq %rax, 0x18(%rsp)
leaq 0x27e40d(%rip), %rax    # 0x52f43c
movq %rax, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x2b111b
movb 0x37(%rsp), %al
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
andb $0x1, %al
movzbl %al, %edi
callq 0x2b0f10
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0xfe, %eax
jne 0x2b1088
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movb $0x23, (%rax,%rcx)
jmp 0x2b1106
movzbl 0xf(%rsp), %eax
cmpl $0xff, %eax
jne 0x2b10a4
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movb $0x24, (%rax,%rcx)
jmp 0x2b1104
jmp 0x2b10a6
movzbl 0xf(%rsp), %eax
cmpl $0x4, %eax
jl 0x2b10e8
movq 0x38aee9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x264f52(%rip), %rsi    # 0x516013
leaq 0x2d7229(%rip), %rdx    # 0x5882f1
leaq 0x2d7229(%rip), %rcx    # 0x5882f8
leaq 0x2d70cb(%rip), %r8     # 0x5881a1
movl $0x10a, %r9d            # imm = 0x10A
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2b10ea
movq 0x10(%rsp), %rax
movzbl 0xf(%rsp), %ecx
movb (%rax,%rcx), %dl
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x2b1106
jmp 0x2b1108
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x2b103d
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x18, %edi
leaq 0x2d7256(%rip), %rsi    # 0x5883af
movl $0x22, %edx
callq 0xe80f0
movq %rax, (%rsp)
movl 0x14(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x10(%rax)
movq (%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
subq $0x1, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %dl, %al
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rsi
movsd 0x10(%rsp), %xmm0
movq 0x18(%rsp), %rdx
addq $0x1, %rdx
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x2b1390
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jne 0x2b1346
movl $0x1, 0x24(%rsp)
jmp 0x2b1385
movl 0x20(%rsp), %edi
callq 0x25d660
movl %eax, 0x4(%rsp)
cmpl $0x1, 0x4(%rsp)
jb 0x2b137d
movl 0x4(%rsp), %eax
cmpl 0x8(%rsp), %eax
jae 0x2b136d
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
jmp 0x2b1374
movl 0x8(%rsp), %eax
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x2b1385
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-apfxlen.c
// Function: prefixlengthwithmaxspace
static unsigned int prefixlengthwithmaxspace(unsigned int numofchars,
                                             GtUword maxbytes,
                                             double factor,
                                             GtUword maxvalue,
                                             bool withspecialsuffixes)
{
  unsigned int prefixlength;
  uint64_t sizeofrep;

#ifdef WITHINFO
  printf("maxbytes = "GT_WU"\n",(GtUword) (maxbytes * factor));
#endif
  for (prefixlength = 1U; /* Nothing */; prefixlength++)
  {
    sizeofrep = gt_bcktab_sizeoftable(numofchars,prefixlength,
                                      maxvalue,withspecialsuffixes);
#ifdef WITHINFO
    printf("sizeofrep = "GT_WU", after divide "GT_WU"\n",(GtUword) sizeofrep,
                                        (GtUword) (sizeofrep/factor));
#endif
    if (sizeofrep/factor > (uint64_t) maxbytes)
    {
#ifdef WITHINFO
      printf("prefixlengthwithmaxspace = %u\n",prefixlength-1);
#endif
      return prefixlength-1;
    }
  }
  /*@ignore@*/
  return 1U;
  /*@end@*/
}

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movl $0x1, 0x10(%rsp)
movl 0x34(%rsp), %edi
movl 0x10(%rsp), %esi
movq 0x18(%rsp), %rdx
movzbl 0x17(%rsp), %ecx
andl $0x1, %ecx
callq 0x203b80
movq %rax, 0x8(%rsp)
movaps 0x267552(%rip), %xmm3   # 0x518930
movq 0x8(%rsp), %xmm0
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x267550(%rip), %xmm2   # 0x518940
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x20(%rsp), %xmm1
divsd %xmm1, %xmm0
movq 0x28(%rsp), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x2b1434
movl 0x10(%rsp), %eax
subl $0x1, %eax
addq $0x38, %rsp
retq
jmp 0x2b1436
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x2b13b8
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %cl, %al
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
andb $0x1, %al
movb %al, 0x13(%rsp)
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq $0x1, %rdx
movb 0x13(%rsp), %al
movsd 0x2d6f79(%rip), %xmm0   # 0x588400
andb $0x1, %al
movzbl %al, %ecx
callq 0x2b1390
movl %eax, 0xc(%rsp)
movl 0x20(%rsp), %edi
callq 0x25d660
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jae 0x2b14b5
movl 0x8(%rsp), %eax
movl %eax, (%rsp)
jmp 0x2b14bc
movl 0xc(%rsp), %eax
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0x14(%rsp)
jbe 0x2b1554
movl 0x20(%rsp), %edi
movl $0x20, %eax
subl 0x14(%rsp), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %esi
shlq %cl, %rsi
subq $0x1, %rsi
movq 0x18(%rsp), %rdx
addq $0x1, %rdx
movb 0x13(%rsp), %al
movsd 0x271258(%rip), %xmm0   # 0x522758
andb $0x1, %al
movzbl %al, %ecx
callq 0x2b1390
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jbe 0x2b1527
movl 0xc(%rsp), %eax
cmpl 0x4(%rsp), %eax
jbe 0x2b1527
movl 0x4(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jbe 0x2b1552
movl 0xc(%rsp), %eax
cmpl 0x4(%rsp), %eax
jbe 0x2b1552
movl 0x4(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x2b1554
cmpl $0x0, 0xc(%rsp)
jne 0x2b1565
movl $0x1, 0x24(%rsp)
jmp 0x2b156d
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, (%rsp)
je 0x2b15de
movq (%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x2b15a6
jmp 0x2b15de
movq 0x38a9f3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x264a5c(%rip), %rsi    # 0x516013
leaq 0x264c01(%rip), %rdx    # 0x5161bf
leaq 0x2d6e43(%rip), %rcx    # 0x588408
leaq 0x2d6e51(%rip), %r8     # 0x58841d
movl $0x99, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2b15e0
movl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
jae 0x2b160e
movq (%rsp), %rdi
movl 0xc(%rsp), %edx
movl 0x10(%rsp), %ecx
leaq 0x2d6e38(%rip), %rsi    # 0x588435
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x2b1616
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x2c(%rax)
jne 0x2b16d7
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
shlq $0x4, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x1f, (%rax)
jb 0x2b16d5
movq 0x10(%rsp), %rax
movq (%rax), %rax
shlq $0x5, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x2b16d7
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x2b81e0
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2b214f
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x2c7940
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x2e0(%rax)
je 0x2b214d
movq 0x10(%rsp), %rax
movq 0x2e0(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rsi
callq 0x2dab40
jmp 0x2b214f
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
cmpq $0x1, 0x38(%rsp)
jbe 0x2b3cd8
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl 0x2c(%rsp), %edx
movl 0x1c(%rsp), %r9d
movq 0x50(%rsp), %r8
movq 0x20(%rsp), %r10
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %r10
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %cl
xorl %eax, %eax
xorl %eax, %eax
movq %rsp, %rax
movq %r8, (%rax)
movzbl %cl, %ecx
andl $0x1, %ecx
movl %ecx, 0x8(%rax)
xorl %ecx, %ecx
movl %ecx, %r8d
callq 0x2b19a0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2b20f0
movq 0x58(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x60(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
callq 0x2b2160
movq 0x10(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x2b39f0
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: gt_BentsedgIterator_new
static GtBentsedgIterator *gt_BentsedgIterator_new(GtCodetype mincode,
                                                   GtCodetype maxcode,
                                                   GtUword totalwidth,
                                                   unsigned int numofchars,
                                                   const GtBcktab *bcktab)
{
  GtBentsedgIterator *bentsedg_iterator = gt_malloc(sizeof *bentsedg_iterator);

  bentsedg_iterator->code = mincode;
  bentsedg_iterator->mincode = mincode;
  bentsedg_iterator->maxcode = maxcode;
  bentsedg_iterator->totalwidth = totalwidth;
  bentsedg_iterator->rightchar = (unsigned int) (mincode % numofchars);
  bentsedg_iterator->bcktab = bcktab;
  bentsedg_iterator->bucketnumber = 0;
  bentsedg_iterator->mutex = gt_mutex_new();
  return bentsedg_iterator;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movl $0x40, %edi
leaq 0x2d4348(%rip), %rsi    # 0x588570
movl $0x6f4, %edx            # imm = 0x6F4
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movl 0x1c(%rsp), %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x30(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
callq 0x1210d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: gt_bendsedgSynchronizer_new
static GtBentsedgSynchronizer *gt_bendsedgSynchronizer_new(void)
{
  GtBentsedgSynchronizer *bs_sync = gt_malloc(sizeof *bs_sync);

  bs_sync->queue = gt_bs_priority_queue_new(gt_jobs);
  bs_sync->nextrequest = 0;
  bs_sync->mutex = gt_mutex_new();
  return bs_sync;
}

// Assembly:
pushq %rax
movl $0x18, %edi
leaq 0x2d42a3(%rip), %rsi    # 0x588570
movl $0x770, %edx            # imm = 0x770
callq 0xe80f0
movq %rax, (%rsp)
leaq 0x389096(%rip), %rax    # 0x63d378
movl (%rax), %eax
movl %eax, %edi
callq 0x2b7a00
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
callq 0x1210d0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: gt_bentsedg_stream_thread_caller
static void *gt_bentsedg_stream_thread_caller(void *data)
{
  GtBentsedg_stream_thread_info *thinfo
    = (GtBentsedg_stream_thread_info *) data;

  while (true)
  {
    GtBucketspecification bucketspec;
    GtUword bucketnumber;

    gt_mutex_lock(thinfo->bs_it->mutex);
    if (!gt_BentsedgIterator_next(&bucketspec,thinfo->bs_it))
    {
      gt_mutex_unlock(thinfo->bs_it->mutex);
      break;
    }
    bucketnumber = thinfo->bs_it->bucketnumber++;
    gt_mutex_unlock(thinfo->bs_it->mutex);
    if (bucketspec.nonspecialsinbucket > 1UL)
    {
      gt_sort_bentleysedgewick(thinfo->bsr,bucketspec.left,
                               bucketspec.nonspecialsinbucket,
                               (GtUword) thinfo->prefixlength);
    }
    gt_mutex_lock(thinfo->bs_sync->mutex);
    gt_bendsedgSynchronizer_process(thinfo->bs_sync,bucketnumber);
    gt_mutex_unlock(thinfo->bs_sync->mutex);
  }
  return NULL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rax), %rdi
callq 0x1211d0
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
leaq 0x10(%rsp), %rdi
callq 0x2b7a70
testb $0x1, %al
jne 0x2b4373
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rax), %rdi
callq 0x121270
jmp 0x2b4407
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rax), %rdi
callq 0x121270
cmpq $0x1, 0x18(%rsp)
jbe 0x2b43cb
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
callq 0x2b2160
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x1211d0
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x2b7af0
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x121270
jmp 0x2b4333
xorl %eax, %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: gt_BentsedgIterator_delete
static void gt_BentsedgIterator_delete(GtBentsedgIterator *bs_it)
{
  if (bs_it != NULL)
  {
    gt_assert(bs_it->bucketnumber == bs_it->maxcode - bs_it->mincode + 1);
    gt_mutex_delete(bs_it->mutex);
    gt_free(bs_it);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x2b449b
jmp 0x2b441e
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq (%rsp), %rcx
movq 0x28(%rcx), %rcx
movq (%rsp), %rdx
subq 0x20(%rdx), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
je 0x2b4477
movq 0x387b5a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x261bc3(%rip), %rsi    # 0x516013
leaq 0x2d4679(%rip), %rdx    # 0x588ad0
leaq 0x2d46ad(%rip), %rcx    # 0x588b0b
leaq 0x2d410b(%rip), %r8     # 0x588570
movl $0x717, %r9d            # imm = 0x717
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2b4479
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x121150
movq (%rsp), %rdi
leaq 0x2d40df(%rip), %rsi    # 0x588570
movl $0x719, %edx            # imm = 0x719
callq 0xe88c0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: gt_bendsedgSynchronizer_delete
static void gt_bendsedgSynchronizer_delete(GtBentsedgSynchronizer *bs_sync)
{
  if (bs_sync != NULL)
  {
    gt_assert(gt_bs_priority_queue_is_empty(bs_sync->queue));
    gt_mutex_delete(bs_sync->mutex);
    gt_bs_priority_queue_delete(bs_sync->queue);
    gt_free(bs_sync);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x2b4526
jmp 0x2b44ae
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x2b3d50
testb $0x1, %al
jne 0x2b44f6
movq 0x387adb(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x261b44(%rip), %rsi    # 0x516013
leaq 0x2d4650(%rip), %rdx    # 0x588b26
leaq 0x2d4677(%rip), %rcx    # 0x588b54
leaq 0x2d408c(%rip), %r8     # 0x588570
movl $0x793, %r9d            # imm = 0x793
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2b44f8
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x121150
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x2b7e60
movq (%rsp), %rdi
leaq 0x2d4054(%rip), %rsi    # 0x588570
movl $0x796, %edx            # imm = 0x796
callq 0xe88c0
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: cmpcharbychardelivermedian
static GtUword cmpcharbychardelivermedian(const GtBentsedgresources *bsr,
                                                GtUword subbucketleft,
                                                GtUword width,
                                                GtUword depth)
{
  GtUword pl = 0,
                pm = GT_DIV2(width),
                pr = width - 1;

  if (width >= MINMEDIANOF9WIDTH)
  { /* On big arrays, pseudomedian of 9 */
    GtUword offset, doubleoffset;
    offset = GT_DIV8(width);
    doubleoffset = GT_MULT2(offset);
    pl = medianof3cmpcharbychar(bsr,subbucketleft,depth,pl,pl+offset,
                                pl+doubleoffset);
    pm = medianof3cmpcharbychar(bsr,subbucketleft,depth,pm-offset,
                                pm,pm+offset);
    pr = medianof3cmpcharbychar(bsr,subbucketleft,depth,
                                pr-doubleoffset,pr-offset,
                                pr);
  }
  return medianof3cmpcharbychar(bsr,subbucketleft,depth,pl,pm,pr);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x30(%rsp), %rax
shrq %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x10(%rsp)
cmpq $0x1f, 0x30(%rsp)
jb 0x2b4a76
movq 0x30(%rsp), %rax
shrq $0x3, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
shlq %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x20(%rsp), %r8
addq 0x8(%rsp), %r8
movq 0x20(%rsp), %r9
addq (%rsp), %r9
callq 0x2b6980
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x18(%rsp), %rcx
subq 0x8(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x18(%rsp), %r9
addq 0x8(%rsp), %r9
callq 0x2b6980
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x10(%rsp), %rcx
subq (%rsp), %rcx
movq 0x10(%rsp), %r8
subq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
callq 0x2b6980
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %r9
callq 0x2b6980
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: blockcmpdelivermedian
static GtUword blockcmpdelivermedian(const GtBentsedgresources *bsr,
                                           GtUword subbucketleft,
                                           GtUword width,
                                           GtUword depth,
                                           GtUword maxwidthrealmedian)
{
  GtUword pl = 0,
                pm = GT_DIV2(width),
                pr = width - 1;

  if (width >= MINMEDIANOF9WIDTH)
  {
    if (width > maxwidthrealmedian)
    { /* On big arrays, pseudomedian of 9 */
      GtUword offset, doubleoffset;
      offset = GT_DIV8(width);
      doubleoffset = GT_MULT2(offset);
      pl = medianof3(bsr,subbucketleft,depth,pl,pl+offset,
                     pl+doubleoffset);
      pm = medianof3(bsr,subbucketleft,depth,pm-offset,pm,pm+offset);
      pr = medianof3(bsr,subbucketleft,depth,pr-doubleoffset,
                     pr-offset,pr);
      pm = medianof3(bsr,subbucketleft,depth,pl,pm,pr);
    } else /* width <= maxwidthrealmedian */
    {
      pm = realmedian(bsr, subbucketleft,width, depth);
    }
  } else
  {
    pm = medianof3(bsr,subbucketleft,depth,pl,pm,pr);
  }
  return pm;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x40(%rsp), %rax
shrq %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x18(%rsp)
cmpq $0x1f, 0x40(%rsp)
jb 0x2b4bf8
movq 0x40(%rsp), %rax
cmpq 0x30(%rsp), %rax
jbe 0x2b4bd8
movq 0x40(%rsp), %rax
shrq $0x3, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
shlq %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x28(%rsp), %r8
addq 0x10(%rsp), %r8
movq 0x28(%rsp), %r9
addq 0x8(%rsp), %r9
callq 0x2b6c80
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x20(%rsp), %rcx
subq 0x10(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x20(%rsp), %r9
addq 0x10(%rsp), %r9
callq 0x2b6c80
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x18(%rsp), %rcx
subq 0x8(%rsp), %rcx
movq 0x18(%rsp), %r8
subq 0x10(%rsp), %r8
movq 0x18(%rsp), %r9
callq 0x2b6c80
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r9
callq 0x2b6c80
movq %rax, 0x20(%rsp)
jmp 0x2b4bf6
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x2b7090
movq %rax, 0x20(%rsp)
jmp 0x2b4c20
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r9
callq 0x2b6c80
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x2b56ed
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x2e9ec0
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x2e9ec0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
callq 0x2ea0a0
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x2ea0a0
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x2b5651
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x2b574a
movq 0x20(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2b574a
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
addq 0x18(%rsp), %rax
addq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x2b5782
movq 0x38684f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2608b8(%rip), %rsi    # 0x516013
leaq 0x2d2f8e(%rip), %rdx    # 0x5886f0
leaq 0x2d31f2(%rip), %rcx    # 0x58895b
leaq 0x2d3030(%rip), %r8     # 0x5887a0
movl $0x3f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2b5784
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
je 0x2b57da
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rcx
addq 0x18(%rsp), %rcx
addq 0x10(%rsp), %rcx
andq $0x3f, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movq 0x20(%rcx), %rcx
addq 0x18(%rsp), %rcx
addq 0x10(%rsp), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x2b57dc
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, 0x8(%rsp)
jbe 0x2b5820
movq 0x3867b1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x26081a(%rip), %rsi    # 0x516013
leaq 0x2d532a(%rip), %rdx    # 0x58ab2a
leaq 0x2d3154(%rip), %rcx    # 0x58895b
leaq 0x2d2f92(%rip), %r8     # 0x5887a0
movl $0x47, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2b5822
movq 0x8(%rsp), %rax
movl %eax, %edx
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
movq 0x20(%rcx), %rcx
addq 0x18(%rsp), %rcx
addq 0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
cmpq $0xff, 0x8(%rsp)
jb 0x2b5864
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: multistrategysort
static bool multistrategysort(GtBentsedgresources *bsr,
                              GtUword subbucketleft,
                              GtUword width,
                              GtUword depth,
                              GtUword sortmaxdepth)
{
  gt_assert(width > 1UL);
  if (width <= bsr->sfxstrategy->maxinsertionsort)
  {
    if (sortmaxdepth == 0)
    {
      bs_insertionsort(bsr,subbucketleft,width,depth);
    } else
    {
      bs_insertionsortmaxdepth(bsr,subbucketleft,width,depth,sortmaxdepth);
    }
    return true;
  }
  if (width <= bsr->sfxstrategy->maxbltriesort)
  {
    gt_blindtrie_suffixsort(bsr->blindtrie,
                            subbucketleft,
                            bsr->tableoflcpvalues,
                            width,
                            depth,
                            sortmaxdepth,
                            bsr->processunsortedsuffixrange,
                            bsr->processunsortedsuffixrangeinfo);
    bsr->countbltriesort++;
    return true;
  }
  return false;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
cmpq $0x1, 0x28(%rsp)
ja 0x2b58cd
movq 0x386704(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x26076d(%rip), %rsi    # 0x516013
leaq 0x2d2dc2(%rip), %rdx    # 0x58866f
leaq 0x2d2e0d(%rip), %rcx    # 0x5886c1
leaq 0x2d2cb5(%rip), %r8     # 0x588570
movl $0x323, %r9d            # imm = 0x323
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2b58cf
movq 0x28(%rsp), %rax
movq 0x38(%rsp), %rcx
movq 0x40(%rcx), %rcx
cmpq 0x8(%rcx), %rax
ja 0x2b592e
cmpq $0x0, 0x18(%rsp)
jne 0x2b5906
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x2b59c0
jmp 0x2b5924
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
callq 0x2b5ed0
movb $0x1, 0x47(%rsp)
jmp 0x2b59ae
movq 0x28(%rsp), %rax
movq 0x38(%rsp), %rcx
movq 0x40(%rcx), %rcx
cmpq 0x10(%rcx), %rax
ja 0x2b59a9
movq 0x38(%rsp), %rax
movq 0x2c8(%rax), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rax
movq 0x38(%rax), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r9
movq 0x38(%rsp), %rax
movq 0x50(%rax), %r10
movq 0x38(%rsp), %rax
movq 0x58(%rax), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2b8360
movq 0x38(%rsp), %rax
movq 0x90(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x90(%rax)
movb $0x1, 0x47(%rsp)
jmp 0x2b59ae
movb $0x0, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax)