LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/union_find.c
// Function: gt_union_find_find
GtUword gt_union_find_find(GtUnionFind *uf, GtUword elem)
{
  gt_assert(uf && elem < uf->num_of_elems);
  if (elem != uf->elems[elem].parent) /* path compression */
    uf->elems[elem].parent = gt_union_find_find(uf, uf->elems[elem].parent);
  return uf->elems[elem].parent;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1f1686
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x8(%rdi)
jbe 0x1f1686
movq (%r14), %rax
movq (%rax,%rbx,8), %rsi
cmpq %rbx, %rsi
je 0x1f167b
movq %r14, %rdi
callq 0x1f1648
movq (%r14), %rcx
movq %rax, (%rcx,%rbx,8)
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x712d0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/union_find.c
// Function: gt_union_find_union
void gt_union_find_union(GtUnionFind *uf, GtUword elem_a,
                         GtUword elem_b)
{
  GtUword x, y;
  gt_assert(uf && elem_a < uf->num_of_elems && elem_b < uf->num_of_elems);
  x = gt_union_find_find(uf, elem_a);
  y = gt_union_find_find(uf, elem_b);
  uf->elems[y].parent = x;
  /* union-by-rank heuristic
  if (uf->elems[x].rank > uf->elems[y].rank)
    uf->elems[y].parent = x;
  else {
    uf->elems[x].parent = y;
    if (uf->elems[x].rank == uf->elems[y].rank)
      uf->elems[y].rank++;
  }
  */
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1f16cc
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq %rsi, %rax
jbe 0x1f16cc
movq %rdx, %r14
cmpq %rdx, %rax
jbe 0x1f16cc
movq %rbx, %rdi
callq 0x1f1648
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f1648
movq (%rbx), %rcx
movq %r15, (%rcx,%rax,8)
popq %rbx
popq %r14
popq %r15
retq
callq 0x71307
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/esa-splititv-simple.c
// Function: gt_lcpintervalfindcharchildintv_withcheck
bool gt_lcpintervalfindcharchildintv_withcheck(const GtEncseq *encseq,
                                     GtReadmode readmode,
                                     GtUword totallength,
                                     const ESASuffixptr *suftab,
                                     Simplelcpinterval *itv,
                                     GtUchar cc,
                                     GtUword offset,
                                     GtUword left,
                                     GtUword right)
{
  Simplelcpinterval itv2;
  bool occurs = gt_lcpintervalfindcharchildintv(encseq,
                                          readmode,
                                      totallength,
                                      suftab,
                                      itv,
                                      cc,
                                      offset,left,right);
  bool occurs2 = gt_lcpintervalfindcharchildintv_simple(encseq,
                                                  readmode,
                                              totallength,
                                              suftab,
                                              &itv2,
                                              cc,
                                              offset,left,right);
  if ((occurs && !occurs2) || (!occurs && occurs2))
  {
    fprintf(stderr,"occurs = %s, occurs2 = %s\n",occurs ? "true" : "false",
                                                 occurs2 ? "true" : "false");
    exit(EXIT_FAILURE);
  }
  if (occurs && itv->left != itv2.left)
  {
    fprintf(stderr,"left = " GT_WU " != " GT_WU " = left2\n",
            itv->left,itv2.left);
    exit(EXIT_FAILURE);
  }
  if (occurs && itv->right != itv2.right)
  {
    fprintf(stderr,"right = " GT_WU " != " GT_WU " = right2\n",
            itv->right,itv2.right);
    exit(EXIT_FAILURE);
  }
  return occurs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r14d
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %rbx
subq $0x8, %rsp
movq %r8, 0x8(%rsp)
pushq 0x68(%rsp)
pushq 0x68(%rsp)
pushq 0x68(%rsp)
callq 0x2232d8
addq $0x20, %rsp
movl %eax, %ebp
subq $0x8, %rsp
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movl %r13d, %esi
movq %r12, %rdx
movq %r15, %rcx
movl %r14d, %r9d
pushq 0x68(%rsp)
pushq 0x68(%rsp)
pushq 0x68(%rsp)
callq 0x223054
addq $0x20, %rsp
cmpb %al, %bpl
jne 0x2232bf
testb %bpl, %bpl
je 0x2232ae
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
cmpq %rsi, %rdi
jne 0x2232cb
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
cmpq %rsi, %rdi
jne 0x2232d0
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl %bpl, %edi
movzbl %al, %esi
callq 0x7e82d
callq 0x7e7df
callq 0x7e806
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/hlk-version.c
// Function: gt_harlekin_show_version
void gt_harlekin_show_version(const char *progname)
{
  char *clean_progname = NULL;
  size_t pnsize = strlen(progname), hlksize = strlen(" "GT_HARLEKIN_CMD);
  printf("Readjoiner: a string graph-based sequence assembler\n\n");
  printf("version "GT_HARLEKIN_VERSION"\n\n");

  /* rm " harlekin" from progname if possible, to avoid confusing the user */
  clean_progname = gt_malloc(pnsize);
  (void)strcpy(clean_progname, progname);
  if (pnsize > hlksize && strcmp(clean_progname + (pnsize - hlksize),
        " "GT_HARLEKIN_CMD) == 0)
  {
    clean_progname[pnsize - hlksize] = '\0';
  }
  printf("GenomeTools version:\n");
  gt_versionfunc(clean_progname);
  gt_free(clean_progname);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
callq 0x2ee50
movq %rax, %r14
leaq 0x1544d8(%rip), %rdi    # 0x390213
callq 0x2dbb0
leaq 0x154501(%rip), %rdi    # 0x390248
callq 0x2dbb0
leaq 0x15449e(%rip), %rsi    # 0x3901f1
movq %r14, %rdi
movl $0x1f, %edx
callq 0x2d5f0
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x30af0
cmpq $0xa, %r14
jb 0x23bd92
addq %rbx, %r14
addq $-0x9, %r14
leaq 0x154487(%rip), %rsi    # 0x390209
movq %r14, %rdi
callq 0x308e0
testl %eax, %eax
jne 0x23bd92
movb $0x0, (%r14)
leaq 0x1544bc(%rip), %rdi    # 0x390255
callq 0x2dbb0
movq %rbx, %rdi
callq 0x32000
leaq 0x154444(%rip), %rsi    # 0x3901f1
movq %rbx, %rdi
movl $0x28, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x2feb0
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/iter-window.c
// Function: gt_windowiterator_new
Windowiterator *gt_windowiterator_new(const GtEncseq *encseq,
                                   GtUword windowsize,
                                   GtUword startpos,
                                   GtUword endpos)
{
  Windowiterator *wit;

  gt_assert(encseq != NULL);
  gt_assert(endpos <= gt_encseq_total_length(encseq));
  wit = gt_malloc(sizeof (*wit));
  wit->buffer = gt_malloc(sizeof (GtUchar) * windowsize);
  wit->firstpos = wit->bufsize = 0;
  wit->windowsize = windowsize;
  wit->currentpos = startpos;
  wit->endpos = endpos;
  wit->esr = gt_encseq_create_reader_with_readmode(encseq,
                                                   GT_READMODE_FORWARD,
                                                   startpos);
  wit->encseq = encseq;
  return wit;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x240620
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
callq 0x300e0
cmpq %r15, %rax
jb 0x240625
leaq 0x1518b0(%rip), %r13    # 0x391e6d
movl $0x40, %edi
movq %r13, %rsi
movl $0x28, %edx
callq 0x2d5f0
movq %rax, %rbp
movq %r12, %rdi
movq %r13, %rsi
movl $0x29, %edx
callq 0x2d5f0
movq %rax, (%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbp)
movq %r12, 0x18(%rbp)
movq %r14, 0x20(%rbp)
movq %r15, 0x28(%rbp)
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2eae0
movq %rax, 0x38(%rbp)
movq %rbx, 0x30(%rbp)
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x84edf
callq 0x84ea8
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/iter-window.c
// Function: gt_windowiterator_next
const GtUchar *gt_windowiterator_next(GtUword *currentpos,
                                      GtUword *firstpos,
                                      Windowiterator *wit)
{
  GtUchar currentchar;

  while (wit->currentpos < wit->endpos)
  {
    currentchar = gt_encseq_reader_next_encoded_char(wit->esr);
    if (GT_ISSPECIAL(currentchar))
    {
      wit->bufsize = wit->firstpos = 0;
    } else
    {
      if (wit->bufsize < wit->windowsize)
      {
        wit->buffer[wit->bufsize++] = currentchar;
      } else
      {
        wit->buffer[wit->firstpos++] = currentchar;
        if (wit->firstpos == wit->windowsize)
        {
          wit->firstpos = 0;
        }
      }
    }
    if (wit->bufsize == wit->windowsize)
    {
      gt_assert(wit->currentpos >= (GtUword) (wit->windowsize-1));
      gt_assert(wit->firstpos < wit->windowsize);
      *currentpos = wit->currentpos++;
      *firstpos = wit->firstpos;
      return wit->buffer;
    }
    wit->currentpos++;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x20(%rdx), %rax
cmpq 0x28(%rdx), %rax
jae 0x2406f1
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdx), %r13
xorl %r12d, %r12d
movq 0x38(%rbx), %rdi
callq 0x2ddd0
cmpb $-0x2, %al
jb 0x240699
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
jmp 0x2406d4
movq (%rbx), %rcx
movq 0x10(%rbx), %rdx
cmpq 0x18(%rbx), %rdx
jae 0x2406b3
leaq 0x1(%rdx), %rsi
movq %rsi, 0x10(%rbx)
movb %al, (%rcx,%rdx)
jmp 0x2406d4
movq 0x8(%rbx), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x8(%rbx)
movb %al, (%rcx,%rdx)
movq 0x8(%rbx), %rax
cmpq 0x18(%rbx), %rax
jne 0x2406d4
movq $0x0, (%r13)
movq 0x10(%rbx), %rcx
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rcx
je 0x2406f6
incq %rax
movq %rax, 0x20(%rbx)
cmpq 0x28(%rbx), %rax
jb 0x240682
jmp 0x24071a
xorl %r12d, %r12d
jmp 0x24071a
leaq -0x1(%rcx), %rdx
cmpq %rdx, %rax
jb 0x240727
cmpq %rcx, (%r13)
jae 0x24072c
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movq %rax, (%r15)
movq 0x8(%rbx), %rax
movq %rax, (%r14)
movq (%rbx), %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x84f4d
callq 0x84f16
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/lua_tools.c
// Function: gt_lua_stack_dump
void gt_lua_stack_dump(lua_State *L) {
  int i;
  int top = lua_gettop(L);
  for (i = 1; i <= top; i++)
  { /* repeat for each level */
    int t = lua_type(L, i);
    switch (t) {

      case LUA_TSTRING:  /* strings */
        fprintf(stderr, "`%s'", lua_tostring(L, i));
        break;

      case LUA_TBOOLEAN:  /* booleans */
        lua_toboolean(L, i) ? fprintf(stderr,"true") : fprintf(stderr,"false");
        break;

      case LUA_TNUMBER:  /* numbers */
        fprintf(stderr, "%g", lua_tonumber(L, i));
        break;

      default:  /* other values */
        fprintf(stderr, "%s", lua_typename(L, t));
        break;
    }
    fprintf(stderr, "  ");  /* put a separator */
  }
  fprintf(stderr, "\n");  /* end the listing */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x2c6540
testl %eax, %eax
jle 0x241f9a
movl %eax, %r14d
negl %r14d
movl $0x1, %r12d
movq 0x2440ac(%rip), %r13    # 0x485fc0
leaq 0xf72fd(%rip), %r15     # 0x339218
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2c69df
movq %rbx, %rdi
cmpl $0x1, %eax
je 0x241f4c
cmpl $0x3, %eax
je 0x241f42
cmpl $0x4, %eax
jne 0x241f63
movl %r12d, %esi
callq 0x855a5
jmp 0x241f71
movl %r12d, %esi
callq 0x85559
jmp 0x241f71
movl %r12d, %esi
callq 0x2c6e16
movq (%r13), %rdi
testl %eax, %eax
jne 0x241f6c
callq 0x85590
jmp 0x241f71
movl %eax, %esi
callq 0x855cc
jmp 0x241f71
callq 0x8557b
movq (%r13), %rcx
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rdi
callq 0x31720
leal (%r14,%r12), %eax
incl %eax
movl %r12d, %ecx
incl %ecx
movl %ecx, %r12d
cmpl $0x1, %eax
jne 0x241f1b
movq 0x24401f(%rip), %rax    # 0x485fc0
movq (%rax), %rsi
movl $0xa, %edi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2ecc0
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/nullcols.c
// Function: gt_newCharatpos
Charatpos *gt_newCharatpos(GtUword patternlength,unsigned int alphasize)
{
  Charatpos *catpos;

  catpos = gt_malloc(sizeof (*catpos));
  catpos->endindex = gt_malloc(sizeof (GtUword) * alphasize);
  catpos->positions = gt_malloc(sizeof (GtUword) * patternlength);
  return catpos;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x14fb04(%rip), %r15    # 0x392948
movl $0x10, %edi
movq %r15, %rsi
movl $0x20, %edx
callq 0x2d5f0
movq %rax, %r12
movl %ebx, %edi
shlq $0x3, %rdi
movq %r15, %rsi
movl $0x21, %edx
callq 0x2d5f0
movq %rax, (%r12)
shlq $0x3, %r14
movq %r14, %rdi
movq %r15, %rsi
movl $0x22, %edx
callq 0x2d5f0
movq %rax, 0x8(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/nullcols.c
// Function: gt_reinitCharatpos
Charatpos *gt_reinitCharatpos(Charatpos *catpos,
                           const GtUchar *pattern,GtUword patternlength,
                           unsigned int alphasize)
{
  const GtUchar *pptr;
  GtUword partialsum, tmp;
  unsigned int idx;

  for (idx=0; idx<alphasize; idx++)
  {
    catpos->endindex[idx] = 0;
  }
  for (pptr=pattern; pptr<pattern+ patternlength; pptr++)
  {
    catpos->endindex[(int) *pptr]++;
  }
  partialsum = catpos->endindex[0];
  catpos->endindex[0] = 0;
  for (idx=1U; idx<alphasize; idx++)
  {
    tmp = catpos->endindex[idx];
    catpos->endindex[idx] = partialsum;
    partialsum += tmp;
  }
  for (pptr=pattern; pptr<pattern+patternlength; pptr++)
  {
    catpos->positions[catpos->endindex[*pptr]++]
      = (GtUword) (pptr - pattern);
  }
  return catpos;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
movl %ecx, %r13d
testl %ecx, %ecx
je 0x242eca
leaq (,%r13,8), %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x2d4b0
leaq (%r14,%r12), %rax
testq %r12, %r12
jle 0x242ee5
movq %r14, %rcx
movzbl (%rcx), %edx
incq (%r15,%rdx,8)
incq %rcx
cmpq %rax, %rcx
jb 0x242ed6
movq (%r15), %rcx
movq $0x0, (%r15)
cmpl $0x2, %ebp
jb 0x242f0f
movl $0x1, %edx
movq (%r15,%rdx,8), %rsi
addq %rcx, %rsi
movq %rcx, (%r15,%rdx,8)
incq %rdx
movq %rsi, %rcx
cmpq %rdx, %r13
jne 0x242ef9
testq %r12, %r12
jle 0x242f3d
movq 0x8(%rbx), %rcx
xorl %edx, %edx
leaq (%r14,%rdx), %rsi
incq %rsi
movzbl -0x1(%rsi), %edi
movq (%r15,%rdi,8), %r8
leaq 0x1(%r8), %r9
movq %r9, (%r15,%rdi,8)
movq %rdx, (%rcx,%r8,8)
incq %rdx
cmpq %rax, %rsi
jb 0x242f1a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/nullcols.c
// Function: gt_wrapCharatpos
void gt_wrapCharatpos(Charatpos **catposptr)
{
  Charatpos *catpos = *catposptr;
  gt_free(catpos->endindex);
  gt_free(catpos->positions);
  gt_free(catpos);
  *catposptr = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq (%r14), %rdi
leaq 0x14f9e4(%rip), %r15    # 0x392948
movq %r15, %rsi
movl $0x49, %edx
callq 0x2feb0
movq 0x8(%r14), %rdi
movq %r15, %rsi
movl $0x4a, %edx
callq 0x2feb0
movq %r14, %rdi
movq %r15, %rsi
movl $0x4b, %edx
callq 0x2feb0
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/nullcols.c
// Function: gt_maintainnullcols
void gt_maintainnullcols(const Charatpos *catpos,
                      GtUword *front0,GtUchar cc,GtUword depth)
{
  GtUword idx;

  for (idx = (cc == 0) ? 0 : catpos->endindex[cc-1];
       idx < catpos->endindex[cc]; idx++)
  {
    GtUword pos = catpos->positions[idx];
    if (front0[pos] == depth)
    {
      front0[pos]++;
    }
  }
}

// Assembly:
movq (%rdi), %rax
testl %edx, %edx
je 0x242fb5
movzbl %dl, %edx
movl %edx, %r8d
decl %r8d
movq (%rax,%r8,8), %r8
jmp 0x242fba
xorl %edx, %edx
xorl %r8d, %r8d
movq (%rax,%rdx,8), %r9
cmpq %r9, %r8
jae 0x242fe5
movq 0x8(%rdi), %rdi
leaq 0x1(%rcx), %r10
movq (%rdi,%r8,8), %r11
cmpq %rcx, (%rsi,%r11,8)
jne 0x242fdd
movq %r10, (%rsi,%r11,8)
movq (%rax,%rdx,8), %r9
incq %r8
cmpq %r9, %r8
jb 0x242fcb
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/pssm.c
// Function: gt_showProfilematrix
void gt_showProfilematrix(const Profilematrix *prof,
                              const GtUchar *characters)
{
  GtUword d, a;

  printf("# "GT_WU" x "GT_WU" matrix\n",prof->numofcharacters,
                                prof->dimension);
  printf("# mintotalscore=");
  SHOWProfScore(stdout,prof->mintotalscore);
  printf("\n");
  printf("# maxtotalscore=");
  SHOWProfScore(stdout,prof->maxtotalscore);
  printf("\n");
  printf("   ");
  for (a = 0; a < prof->numofcharacters; a++)
  {
    printf("%c",(int) characters[a]);
    printf("%s",(a < prof->numofcharacters - 1) ? "   " : "\n");
  }
  for (d = 0; d < prof->dimension; d++)
  {
    for (a = 0; a < prof->numofcharacters; a++)
    {
      SHOWProfScore(stdout,GETPROFSCORE(prof,a,d));
      printf("%s",(a < prof->numofcharacters - 1) ? " " : " \n");
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdx
movq 0x8(%rdi), %rsi
leaq 0x14e7d2(%rip), %rdi    # 0x392fe9
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x2d300
leaq 0x14e7d6(%rip), %rdi    # 0x392ffd
xorl %eax, %eax
callq 0x2d300
movq 0x2417bb(%rip), %r12    # 0x485ff0
movq (%r12), %rdi
movl 0x1c(%rbx), %edx
leaq 0x173844(%rip), %r15    # 0x3b8087
movq %r15, %rsi
xorl %eax, %eax
callq 0x31920
movl $0xa, %edi
callq 0x2df70
leaq 0x14e7b0(%rip), %rdi    # 0x39300e
xorl %eax, %eax
callq 0x2d300
movq (%r12), %rdi
movl 0x18(%rbx), %edx
movq %r15, %rsi
xorl %eax, %eax
callq 0x31920
movl $0xa, %edi
callq 0x2df70
leaq 0x178677(%rip), %r13    # 0x3bcefe
movq %r13, %rdi
xorl %eax, %eax
callq 0x2d300
cmpq $0x0, 0x8(%rbx)
je 0x2448d7
leaq 0x171152(%rip), %r12    # 0x3b59f1
xorl %r15d, %r15d
movzbl (%r14,%r15), %edi
callq 0x2df70
movq 0x8(%rbx), %rax
decq %rax
cmpq %rax, %r15
leaq 0x1673f6(%rip), %rsi    # 0x3abcb3
cmovbq %r13, %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0x2d300
incq %r15
movq 0x8(%rbx), %rbp
cmpq %rbp, %r15
jb 0x2448a2
movq (%rbx), %rax
testq %rax, %rax
je 0x244963
leaq 0x17379d(%rip), %rcx    # 0x3b8087
leaq 0x169657(%rip), %r15    # 0x3adf48
leaq 0x1697d5(%rip), %r13    # 0x3ae0cd
xorl %r14d, %r14d
testq %rbp, %rbp
je 0x244959
xorl %r12d, %r12d
movq 0x2416e6(%rip), %rax    # 0x485ff0
movq (%rax), %rdi
movq 0x20(%rbx), %rax
movq (%rax,%r12,8), %rax
movl (%rax,%r14,4), %edx
movq %rcx, %rbp
movq %rcx, %rsi
xorl %eax, %eax
callq 0x31920
movq 0x8(%rbx), %rax
decq %rax
cmpq %rax, %r12
movq %r13, %rsi
cmovbq %r15, %rsi
leaq 0x1710b3(%rip), %rdi    # 0x3b59f1
xorl %eax, %eax
callq 0x2d300
movq %rbp, %rcx
incq %r12
movq 0x8(%rbx), %rbp
cmpq %rbp, %r12
jb 0x244903
movq (%rbx), %rax
jmp 0x24495b
xorl %ebp, %ebp
incq %r14
cmpq %rax, %r14
jb 0x2448fb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/pssm.c
// Function: gt_makeitmthresholds
void gt_makeitmthresholds(Profilematrix *prof,
                              ProfScore minscore)
{
  GtUword d, a;
  GtWord ddown;
  ProfScore partsum,
            score,
            *maxscore;

  maxscore = gt_malloc(sizeof *maxscore * prof->dimension);
  for (d=0; d<prof->dimension; d++)
  {
    for (a=0; a<prof->numofcharacters; a++)
    {
      score = GETPROFSCORE(prof,a,d);
      if (a == 0 || maxscore[d] < score)
      {
        maxscore[d] = score;
      }
    }
  }
  partsum = (ProfScore) 0;
  gt_assert(prof->itmthreshold != NULL);
  for (ddown = (GtWord) (prof->dimension-1); ddown>=0; ddown--)
  {
    prof->itmthreshold[ddown] = minscore - partsum;
    partsum += maxscore[ddown];
  }
  gt_free(maxscore);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
shlq $0x2, %rdi
leaq 0x14e696(%rip), %rsi    # 0x39301f
movl $0x51, %edx
callq 0x2d5f0
movq (%r14), %rcx
testq %rcx, %rcx
je 0x2449d4
movq 0x8(%r14), %rdx
xorl %esi, %esi
testq %rdx, %rdx
je 0x2449cc
movq 0x20(%r14), %rdi
xorl %r8d, %r8d
movq (%rdi,%r8,8), %r9
movl (%r9,%rsi,4), %r9d
testq %r8, %r8
je 0x2449c0
cmpl %r9d, (%rax,%rsi,4)
jge 0x2449c4
movl %r9d, (%rax,%rsi,4)
incq %r8
cmpq %r8, %rdx
jne 0x2449ad
incq %rsi
cmpq %rcx, %rsi
jne 0x2449a1
movq 0x10(%r14), %rdx
testq %rdx, %rdx
je 0x244a13
movq %rcx, %rsi
decq %rsi
js 0x2449f8
xorl %esi, %esi
movl %ebx, %edi
subl %esi, %edi
movl %edi, -0x4(%rdx,%rcx,4)
addl -0x4(%rax,%rcx,4), %esi
decq %rcx
jne 0x2449e7
leaq 0x14e620(%rip), %rsi    # 0x39301f
movq %rax, %rdi
movl $0x64, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2feb0
callq 0x86076
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/pssm.c
// Function: gt_lookaheadsearchPSSM
void gt_lookaheadsearchPSSM(const GtEncseq *encseq,
                            const Profilematrix *prof)
{
  GtUword firstpos, bufsize;
  GtUchar currentchar;
  GtUword pos;
  GtEncseqReader *esr;
  GtUword totallength = gt_encseq_total_length(encseq);
  GtUchar *buffer;

  esr = gt_encseq_create_reader_with_readmode(encseq,GT_READMODE_FORWARD,0);
  buffer = gt_malloc(sizeof *buffer * prof->dimension);
  firstpos = bufsize = 0;
  for (pos=0; pos < totallength; pos++)
  {
    currentchar = gt_encseq_reader_next_encoded_char(esr);
    if (GT_ISSPECIAL(currentchar))
    {
      bufsize = firstpos = 0;
    } else
    {
      if (bufsize < prof->dimension)
      {
        buffer[bufsize++] = currentchar;
      } else
      {
        buffer[firstpos++] = currentchar;
        if (firstpos == prof->dimension)
        {
          firstpos = 0;
        }
      }
    }
  }
  gt_encseq_reader_delete(esr);
  gt_free(buffer);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
callq 0x300e0
movq %rax, %r14
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2eae0
movq %rax, %r15
movq (%rbx), %rdi
leaq 0x14e5d5(%rip), %rsi    # 0x39301f
movl $0x72, %edx
callq 0x2d5f0
movq %rax, %r12
testq %r14, %r14
je 0x244a93
xorl %r13d, %r13d
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x2ddd0
cmpb $-0x3, %al
jbe 0x244a74
xorl %ebp, %ebp
xorl %r13d, %r13d
jmp 0x244a8e
cmpq (%rbx), %rbp
jae 0x244a82
movb %al, (%r12,%rbp)
incq %rbp
jmp 0x244a8e
movb %al, (%r12,%r13)
incq %r13
cmpq (%rbx), %r13
je 0x244a6f
decq %r14
jne 0x244a61
movq %r15, %rdi
callq 0x2ebb0
leaq 0x14e57d(%rip), %rsi    # 0x39301f
movq %r12, %rdi
movl $0x8a, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2feb0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/randomcodes-hpcorrect.c
// Function: gt_randomcodes_hpcorrect_process_bucket
int gt_randomcodes_hpcorrect_process_bucket(void *data,
    const GtUword *bucketofsuffixes, const GtSeqnumrelpos *snrp,
    const uint16_t *lcptab_bucket, GtUword numberofsuffixes,
    GT_UNUSED unsigned int sortingdepth, GT_UNUSED GtError *err)
{
  GtUword itvstart, next_itvstart;
  unsigned int lcpvalue;
  GtRandomcodesHpcorrectData *sdata = data;

#ifdef GT_RANDOMCODES_HPCORRECT_DEBUG
  gt_file_xprintf(sdata->outfile, "# bucketsize:\t"GT_WU"\n", numberofsuffixes);
#endif
  for (itvstart = 0, next_itvstart = 1UL; next_itvstart < numberofsuffixes;
      next_itvstart++)
  {
    lcpvalue = (unsigned int) lcptab_bucket[next_itvstart];
#ifdef GT_RANDOMCODES_HPCORRECT_DEBUG
    gt_randomcodes_hpcorrect_show_expanded_kmer(sdata, bucketofsuffixes, snrp,
        next_itvstart - 1UL, lcpvalue);
#endif
    if (lcpvalue < (unsigned int)sdata->k)
    {
#ifdef GT_RANDOMCODES_HPCORRECT_DEBUG
      gt_file_xprintf(sdata->outfile, "# orig-nofsfx:\t"GT_WU"\n",
          next_itvstart - itvstart);
#endif
      gt_randomcodes_hpcorrect_process_kmer_itv(snrp,
          bucketofsuffixes + itvstart, next_itvstart - itvstart, data);
      itvstart = next_itvstart;
    }
  }
#ifdef GT_RANDOMCODES_HPCORRECT_DEBUG
  gt_randomcodes_hpcorrect_show_expanded_kmer(sdata, bucketofsuffixes, snrp,
      next_itvstart - 1UL, lcpvalue);
  gt_file_xprintf(sdata->outfile, "# orig-nofsfx:\t"GT_WU"\n",
      next_itvstart - itvstart);
#endif
  gt_randomcodes_hpcorrect_process_kmer_itv(snrp,
      bucketofsuffixes + itvstart, next_itvstart - itvstart, data);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
cmpq $0x2, %r8
jb 0x249781
movq %r8, %rbx
movq %rcx, %r13
movl $0x1, %ebp
xorl %eax, %eax
movzwl (%r13,%rbp,2), %ecx
cmpl 0x20(%r14), %ecx
jae 0x249777
leaq (%r12,%rax,8), %rsi
movq %rbp, %rdx
subq %rax, %rdx
movq %r15, %rdi
movq %r14, %rcx
callq 0x2497ae
movq %rbp, %rax
incq %rbp
cmpq %rbp, %rbx
jne 0x249753
jmp 0x249788
movl $0x1, %ebx
xorl %eax, %eax
leaq (%r12,%rax,8), %rsi
subq %rax, %rbx
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x2497ae
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/randomcodes-hpcorrect.c
// Function: gt_randomcodes_hpcorrect_data_delete
void gt_randomcodes_hpcorrect_data_delete(GtRandomcodesHpcorrectData *sdata)
{
  gt_assert(sdata != NULL);
  gt_free(sdata->hmers);
  gt_free(sdata->pw_scores);
  gt_free(sdata->pw_scores_copy);
  gt_free(sdata->hmer_cluster);
  gt_free(sdata->cluster_size);
  gt_free(sdata->skip);
  gt_free(sdata->consensus_hmer);
  gt_free(sdata->hdistri);
  gt_union_find_delete(sdata->union_find);
  gt_free(sdata->rextset);
  gt_free(sdata->rextset_size);
  gt_encseq_reader_delete(sdata->esr1);
  gt_encseq_reader_delete(sdata->esr2);
  gt_file_delete(sdata->outfile);
  gt_free(sdata);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x24b63d
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
leaq 0x14a14f(%rip), %r14    # 0x39568d
movq %r14, %rsi
movl $0x495, %edx            # imm = 0x495
callq 0x2feb0
movq 0xa8(%rbx), %rdi
movq %r14, %rsi
movl $0x496, %edx            # imm = 0x496
callq 0x2feb0
movq 0xb0(%rbx), %rdi
movq %r14, %rsi
movl $0x497, %edx            # imm = 0x497
callq 0x2feb0
movq 0x88(%rbx), %rdi
movq %r14, %rsi
movl $0x498, %edx            # imm = 0x498
callq 0x2feb0
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x499, %edx            # imm = 0x499
callq 0x2feb0
movq 0x90(%rbx), %rdi
movq %r14, %rsi
movl $0x49a, %edx            # imm = 0x49A
callq 0x2feb0
movq 0x50(%rbx), %rdi
movq %r14, %rsi
movl $0x49b, %edx            # imm = 0x49B
callq 0x2feb0
movq 0x58(%rbx), %rdi
movq %r14, %rsi
movl $0x49c, %edx            # imm = 0x49C
callq 0x2feb0
movq 0x98(%rbx), %rdi
callq 0x1f160d
movq 0xd0(%rbx), %rdi
movq %r14, %rsi
movl $0x49e, %edx            # imm = 0x49E
callq 0x2feb0
movq 0xd8(%rbx), %rdi
movq %r14, %rsi
movl $0x49f, %edx            # imm = 0x49F
callq 0x2feb0
movq 0x118(%rbx), %rdi
callq 0x2ebb0
movq 0x120(%rbx), %rdi
callq 0x2ebb0
movq 0xa0(%rbx), %rdi
callq 0x2dc80
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4a3, %edx            # imm = 0x4A3
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2feb0
callq 0x87767
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/specialrank.c
// Function: gt_fillrankbounds
Rankedbounds *gt_fillrankbounds(const GtEncseq *encseq,
                             GtReadmode readmode)
{
  if (gt_encseq_has_specialranges(encseq))
  {
    GtSpecialrangeiterator *sri;
    GtRange range;
    GtUword currentrank = 0, realspecialranges;
    Rankedbounds *rankedbounds, *rbptr;

    realspecialranges = gt_encseq_realspecialranges(encseq);
    rankedbounds = gt_malloc(sizeof (Rankedbounds) * realspecialranges);
    sri = gt_specialrangeiterator_new(encseq,
                                      GT_ISDIRREVERSE(readmode)
                                      ? false : true);
    for (rbptr = rankedbounds;
         gt_specialrangeiterator_next(sri,&range);
         rbptr++)
    {
      rbptr->lowerbound = range.start;
      rbptr->upperbound = range.end;
      rbptr->rank = currentrank;
      currentrank += rbptr->upperbound - rbptr->lowerbound;
    }
    gt_assert(rbptr == rankedbounds + realspecialranges);
    gt_specialrangeiterator_delete(sri);
    return rankedbounds;
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %r15
callq 0x14a6fa
testb %al, %al
je 0x29758a
movq %r15, %rdi
callq 0x14c05f
movq %rax, %r14
leaq (,%rax,8), %rax
leaq (%rax,%rax,2), %rdi
leaq 0x10f960(%rip), %rsi    # 0x3a6e62
movl $0x2c, %edx
callq 0x2d5f0
movq %rax, %rbx
andl $-0x3, %ebp
xorl %esi, %esi
cmpl $0x1, %ebp
setne %sil
movq %r15, %rdi
callq 0x14a850
movq %rax, %r15
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x14a8be
movq %rbx, %r13
testb %al, %al
je 0x297573
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
movq %rbx, %r13
movq 0x8(%rsp), %rax
movq %rax, (%r13)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%r13)
movq %rbp, 0x10(%r13)
subq %rax, %rbp
addq %rcx, %rbp
addq $0x18, %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x14a8be
testb %al, %al
jne 0x297544
leaq (%r14,%r14,2), %rax
leaq (%rbx,%rax,8), %rax
cmpq %rax, %r13
jne 0x29759e
movq %r15, %rdi
callq 0x14ae79
jmp 0x29758c
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x9f585
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/specialrank.c
// Function: gt_fromrank2pos
GtUword gt_fromrank2pos(const Rankedbounds *leftptr,
                              const Rankedbounds *rightptr,
                              GtUword rank)
{
  const Rankedbounds *midptr;

  while (leftptr <= rightptr)
  {
    midptr = leftptr + GT_DIV2((GtUword) (rightptr-leftptr));
    if (rank < midptr->rank)
    {
      rightptr = midptr-1;
    } else
    {
      if (rank >= midptr->rank + (midptr->upperbound - midptr->lowerbound))
      {
        leftptr = midptr + 1;
      } else
      {
        return midptr->lowerbound + (rank - midptr->rank);
      }
    }
  }
  fprintf(stderr,"fromrank2rank: cannot find rank "GT_WU""
                 " in ranges",rank);
  exit(GT_EXIT_PROGRAMMING_ERROR);
  /*@ignore@*/
  return 0;
  /*@end@*/
}

// Assembly:
pushq %rax
cmpq %rsi, %rdi
ja 0x297656
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
movq %rsi, %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %rcx, %rax
shrq %rax
leaq (%rax,%rax,2), %rax
leaq (%rdi,%rax,8), %r8
movq 0x10(%r8), %r9
movq %rdx, %rax
subq %r9, %rax
jae 0x29763b
addq $-0x18, %r8
movq %r8, %rsi
jmp 0x297651
movq (%r8), %rdi
addq 0x8(%r8), %r9
subq %rdi, %r9
cmpq %rdx, %r9
ja 0x29765e
addq $0x18, %r8
movq %r8, %rdi
cmpq %rsi, %rdi
jbe 0x29760d
movq %rdx, %rdi
callq 0x9f5e0
addq %rdi, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/specialrank.c
// Function: gt_fillspecialranklist
Specialrank *gt_fillspecialranklist(const GtEncseq *encseq,
                                 GtReadmode readmode,
                                 const GtUword *inversesuftab)
{
  if (gt_encseq_has_specialranges(encseq))
  {
    GtSpecialrangeiterator *sri;
    GtRange range;
    GtUword realspecialranges, specialrank;
    GT_UNUSED GtUword totallength;
    Specialrank *specialranklist, *rbptr;

    totallength = gt_encseq_total_length(encseq);
    realspecialranges = gt_encseq_realspecialranges(encseq);
    specialranklist = gt_malloc(sizeof (Specialrank) * realspecialranges);
    sri = gt_specialrangeiterator_new(encseq,
                                  GT_ISDIRREVERSE(readmode)
                                  ? false : true);
    rbptr = specialranklist;
    specialrank = 0;
    while (gt_specialrangeiterator_next(sri,&range))
    {
      gt_assert(rbptr < specialranklist + realspecialranges);
      gt_assert(range.end<=totallength);
      specialrank += range.end - range.start;
      rbptr->specialrank = specialrank - 1;
      rbptr->key = inversesuftab[range.end];
      rbptr++;
    }
    gt_assert(rbptr == specialranklist + realspecialranges);
    gt_specialrangeiterator_delete(sri);
    qsort(specialranklist,(size_t) realspecialranges,
          sizeof (Specialrank),compareSpecialrank);
    return specialranklist;
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbp
callq 0x14a6fa
testb %al, %al
je 0x297778
movq %rbp, %rdi
callq 0x300e0
movq %rax, %r12
movq %rbp, %rdi
callq 0x14c05f
movq %rax, 0x10(%rsp)
movq %rax, %rdi
shlq $0x4, %rdi
leaq 0x10f7b5(%rip), %rsi    # 0x3a6e62
movq %rdi, (%rsp)
movl $0xa3, %edx
callq 0x2d5f0
movq %rax, %rbx
andl $-0x3, %r15d
xorl %esi, %esi
cmpl $0x1, %r15d
setne %sil
movq %rbp, %rdi
callq 0x14a850
movq %rax, %rbp
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x14a8be
movq %rbx, 0x8(%rsp)
testb %al, %al
je 0x297744
movq 0x8(%rsp), %rbx
movq (%rsp), %rax
leaq (%rbx,%rax), %r13
xorl %ecx, %ecx
cmpq %r13, %rbx
jae 0x297792
movq 0x20(%rsp), %rax
cmpq %r12, %rax
ja 0x29778d
movq %rax, %rdx
subq 0x18(%rsp), %rdx
leaq (%rdx,%rcx), %r15
addq %rdx, %rcx
decq %rcx
movq %rcx, (%rbx)
movq (%r14,%rax,8), %rax
movq %rax, 0x8(%rbx)
addq $0x10, %rbx
movq %rbp, %rdi
leaq 0x18(%rsp), %rsi
callq 0x14a8be
movq %r15, %rcx
testb %al, %al
jne 0x2976fc
movq 0x8(%rsp), %r14
movq %r14, %rax
addq (%rsp), %rax
cmpq %rax, %rbx
jne 0x297797
movq %rbp, %rdi
callq 0x14ae79
leaq 0x38(%rip), %rcx        # 0x29779c
movl $0x10, %edx
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0x305e0
jmp 0x29777b
xorl %r14d, %r14d
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x9f676
callq 0x9f604
callq 0x9f63d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/substriter.c
// Function: gt_substriter_new
Substriter *gt_substriter_new(const GtAlphabet *alphabet,unsigned int qvalue)
{
  Substriter *substriter;

  substriter = gt_malloc(sizeof *substriter);
  substriter->qvalue = qvalue;
  substriter->numofchars = gt_alphabet_num_of_chars(alphabet);
  substriter->multimappower = gt_initmultimappower(substriter->numofchars,
                                                   qvalue);
  return substriter;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x10f65a(%rip), %rsi    # 0x3a707f
movl $0x30, %edi
movl $0x2a, %edx
callq 0x2d5f0
movq %rax, %r15
movl %ebx, 0x20(%rax)
movq %r14, %rdi
callq 0x2ead0
movl %eax, 0x24(%r15)
movl %eax, %edi
movl %ebx, %esi
callq 0x240343
movq %rax, 0x28(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/substriter.c
// Function: gt_substriter_next
int gt_substriter_next(Substriter *substriter)
{
  unsigned int firstspecial;

  while (true)
  {
    if (substriter->remaining >= (GtUword) substriter->qvalue)
    {
      firstspecial = qgram2code(&substriter->currentcode,
                                (const GtCodetype **) substriter->multimappower,
                                substriter->qvalue,
                                substriter->currentptr);
      if (firstspecial == substriter->qvalue)
      {
        substriter->remaining--;
        substriter->currentptr++;
        break;
      }
      substriter->remaining -= firstspecial + 1;
      substriter->currentptr += firstspecial + 1;
    } else
    {
      return 0;
    }
  }
  return 1;
}

// Assembly:
movl 0x20(%rdi), %r8d
movq 0x10(%rdi), %rsi
xorl %eax, %eax
cmpq %r8, %rsi
jb 0x297b15
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %r9
movq 0x28(%rdi), %r10
leal -0x1(%r8), %r11d
movq %r9, %rcx
movq %rsi, %rdx
testl %r11d, %r11d
js 0x297af0
movl $0x1, %ebx
movl %r8d, %r14d
xorl %eax, %eax
leal -0x1(%r14), %r15d
movzbl (%rcx,%r15), %r12d
cmpq $0xfd, %r12
ja 0x297ad3
movq (%r10,%r15,8), %r14
addq (%r14,%r12,8), %rax
incl %ebx
movl %r15d, %r14d
testl %r15d, %r15d
jg 0x297aad
jmp 0x297af8
testl %ebx, %ebx
je 0x297afc
movl %r14d, %eax
subq %rax, %rdx
movq %rdx, 0x10(%rdi)
addq %rax, %rcx
movq %rcx, (%rdi)
xorl %eax, %eax
cmpq %r8, %rdx
jae 0x297a9e
jmp 0x297b0e
xorl %eax, %eax
movq %r9, %rcx
movq %rsi, %rdx
movq %rax, 0x18(%rdi)
decq %rdx
movq %rdx, 0x10(%rdi)
incq %rcx
movq %rcx, (%rdi)
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/ltr/ltr_orf_annotator_stream.c
// Function: gt_ltr_orf_annotator_stream_class
const GtNodeStreamClass* gt_ltr_orf_annotator_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtLTRORFAnnotatorStream),
                                   ltr_orf_annotator_stream_free,
                                   ltr_orf_annotator_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x141717
cmpq $0x0, 0x1eb7c2(%rip)    # 0x48dc78
jne 0x2a24d7
leaq 0x26(%rip), %rsi        # 0x2a24e5
leaq 0x49(%rip), %rdx        # 0x2a250f
movl $0x28, %edi
callq 0x2e6f0
movq %rax, 0x1eb7a1(%rip)    # 0x48dc78
callq 0x14172d
movq 0x1eb795(%rip), %rax    # 0x48dc78
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/ltr/ltr_orf_annotator_stream.c
// Function: ltr_orf_annotator_stream_next
static int ltr_orf_annotator_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                                         GtError *err)
{
  GtLTRORFAnnotatorStream *bs;
  gt_error_check(err);
  bs = ltr_orf_annotator_stream_cast(ns);
  if (bs->progress_loc != NULL)
    (*bs->progress_loc)++;
  return gt_node_stream_next(bs->orf_stream, gn, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x2a252e
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x2a255e
callq 0x2a24a8
movq %rax, %rdi
movq %r15, %rsi
callq 0x2ef70
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x2a254a
incq (%rcx)
movq 0x10(%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2f490
callq 0xa1248
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/ltr/ltr_orf_annotator_stream.c
// Function: gt_ltr_orf_annotator_stream_new
GtNodeStream* gt_ltr_orf_annotator_stream_new(GtNodeStream *in_stream,
                                              GtEncseq *encseq,
                                              unsigned int min,
                                              unsigned int max,
                                              bool all,
                                              GtError *err)
{
  GtLTRORFAnnotatorStream *bs;
  GtNodeStream *ns;
  GtRegionMapping *rmap;
  gt_assert(in_stream);
  ns = gt_node_stream_create(gt_ltr_orf_annotator_stream_class(), false);
  bs = ltr_orf_annotator_stream_cast(ns);
  bs->types = gt_hashmap_new(GT_HASH_STRING, NULL, NULL);
  bs->progress_loc = NULL;
  gt_hashmap_add(bs->types, gt_ft_LTR_retrotransposon, (void*) 1);
  rmap = gt_region_mapping_new_encseq_seqno(encseq);
  gt_assert(rmap);
  bs->orf_stream = gt_orf_finder_stream_new(in_stream, rmap, bs->types, min,
                                            max, all, err);
  return ns;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0x14(%rsp)
movl %edx, 0x10(%rsp)
testq %rdi, %rdi
je 0x2a2624
movq %r9, %r15
movl %r8d, %r14d
movq %rsi, %rbx
movq %rdi, %r12
callq 0x2a24a8
movq %rax, %rdi
xorl %esi, %esi
callq 0x30240
movq %rax, %r13
callq 0x2a24a8
movq %rax, %rdi
movq %r13, %rsi
callq 0x2ef70
movq %rax, %rbp
movl $0x1, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x30500
movq %rax, 0x20(%rbp)
movq $0x0, 0x18(%rbp)
leaq 0xd5afc(%rip), %rsi     # 0x3780d0
movl $0x1, %edx
movq %rax, %rdi
callq 0x30740
movq %rbx, %rdi
callq 0x1d99e8
testq %rax, %rax
je 0x2a2629
movq 0x20(%rbp), %rdx
movq %r15, (%rsp)
movzbl %r14b, %r9d
movq %r12, %rdi
movq %rax, %rsi
movl 0x10(%rsp), %ecx
movl 0x14(%rsp), %r8d
callq 0x1cf615
movq %rax, 0x10(%rbp)
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xa12b6
callq 0xa127f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/custom_track_example.c
// Function: gt_custom_track_example_class
const GtCustomTrackClass* gt_custom_track_example_class(void)
{
  static const GtCustomTrackClass *ctc = NULL;
  gt_class_alloc_lock_enter();
  if (!ctc)
  {
    ctc = gt_custom_track_class_new(sizeof (GtCustomTrackExample),
                                    gt_custom_track_example_sketch,
                                    gt_custom_track_example_get_height,
                                    gt_custom_track_example_get_title,
                                    gt_custom_track_example_delete);
  }
  gt_class_alloc_lock_leave();
  return ctc;
}

// Assembly:
pushq %rax
callq 0x141717
cmpq $0x0, 0x1d59b3(%rip)    # 0x48dce8
jne 0x2b8364
leaq -0x23e(%rip), %rsi      # 0x2b8100
leaq 0x2d(%rip), %rdx        # 0x2b8372
leaq 0x40(%rip), %rcx        # 0x2b838c
leaq 0x57(%rip), %r8         # 0x2b83aa
movl $0x20, %edi
callq 0x2b7f5c
movq %rax, 0x1d5984(%rip)    # 0x48dce8
callq 0x14172d
movq 0x1d5978(%rip), %rax    # 0x48dce8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/custom_track_example.c
// Function: gt_custom_track_example_new
GtCustomTrack* gt_custom_track_example_new()
{
  GtCustomTrackExample *cte;
  GtCustomTrack *ct;
  ct = gt_custom_track_create(gt_custom_track_example_class());
  cte = gt_custom_track_example_cast(ct);
  cte->title = gt_str_new_cstr("Example custom track for AnnotationSketch");
  cte->height = 40;
  return ct;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x2b8327
movq %rax, %rdi
callq 0x2b7f9b
movq %rax, %rbx
callq 0x2b8327
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2b80e6
movq %rax, %r14
leaq 0xf85c1(%rip), %rdi     # 0x3b09bd
callq 0x2f0d0
movq %rax, 0x18(%r14)
movq $0x28, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/custom_track_script_wrapper.c
// Function: gt_custom_track_script_wrapper_class
const GtCustomTrackClass* gt_custom_track_script_wrapper_class(void)
{
  static const GtCustomTrackClass *ctc = NULL;
  gt_class_alloc_lock_enter();
  if (!ctc)
  {
    ctc = gt_custom_track_class_new(sizeof (GtCustomTrackScriptWrapper),
                                    gt_custom_track_script_wrapper_sketch,
                                    gt_custom_track_script_wrapper_get_height,
                                    gt_custom_track_script_wrapper_get_title,
                                    gt_custom_track_script_wrapper_delete);
  }
  gt_class_alloc_lock_leave();
  return ctc;
}

// Assembly:
pushq %rax
callq 0x141717
cmpq $0x0, 0x1d4faf(%rip)    # 0x48dcf8
jne 0x2b8d78
leaq -0x72(%rip), %rsi       # 0x2b8ce0
leaq 0x2d(%rip), %rdx        # 0x2b8d86
leaq 0x40(%rip), %rcx        # 0x2b8da0
leaq 0x6c(%rip), %r8         # 0x2b8dd3
movl $0x38, %edi
callq 0x2b7f5c
movq %rax, 0x1d4f80(%rip)    # 0x48dcf8
callq 0x14172d
movq 0x1d4f74(%rip), %rax    # 0x48dcf8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/custom_track_script_wrapper.c
// Function: gt_custom_track_script_wrapper_get_title
const char* gt_custom_track_script_wrapper_get_title(GtCustomTrack *ct)
{
  GtCustomTrackScriptWrapper *cte;
  cte = gt_custom_track_script_wrapper_cast(ct);
  gt_str_reset(cte->title_buffer);
  cte->get_title_func(NULL, cte->title_buffer);
  return gt_str_get(cte->title_buffer);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2b8d3b
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2b80e6
movq %rax, %rbx
movq 0x30(%rax), %rdi
callq 0x316e0
movq 0x30(%rbx), %rsi
xorl %edi, %edi
callq *0x20(%rbx)
movq 0x30(%rbx), %rdi
popq %rbx
jmp 0x31b20
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/custom_track_script_wrapper.c
// Function: gt_custom_track_script_wrapper_delete
void gt_custom_track_script_wrapper_delete(GtCustomTrack *ct)
{
  GtCustomTrackScriptWrapper *cte;
  if (!ct) return;
  cte = gt_custom_track_script_wrapper_cast(ct);
  cte->free_func(NULL);
  gt_str_delete(cte->title_buffer);
}

// Assembly:
testq %rdi, %rdi
je 0x2b8dfe
pushq %rbx
movq %rdi, %rbx
callq 0x2b8d3b
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2b80e6
movq %rax, %rbx
xorl %edi, %edi
callq *0x28(%rax)
movq 0x30(%rbx), %rdi
popq %rbx
jmp 0x31fe0
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/custom_track_script_wrapper.c
// Function: gt_custom_track_script_wrapper_new
GtCustomTrack* gt_custom_track_script_wrapper_new(GtCtScriptRenderFunc
                                                             render_func,
                                                  GtCtScriptGetHeightFunc
                                                             get_height_func,
                                                  GtCtScriptGetTitleFunc
                                                             get_title_func,
                                                  GtCtScriptFreeFunc
                                                             free_func)
{
  GtCustomTrackScriptWrapper *cte;
  GtCustomTrack *ct;
  ct = gt_custom_track_create(gt_custom_track_script_wrapper_class());
  cte = gt_custom_track_script_wrapper_cast(ct);
  cte->render_func = render_func;
  cte->get_height_func = get_height_func;
  cte->get_title_func = get_title_func;
  cte->free_func = free_func;
  cte->title_buffer = gt_str_new();
  return ct;
}

// 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
callq 0x2b8d3b
movq %rax, %rdi
callq 0x2b7f9b
movq %rax, %r13
callq 0x2b8d3b
movq %rax, %rdi
movq %r13, %rsi
callq 0x2b80e6
movq %rax, %rbp
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
callq 0x30600
movq %rax, 0x30(%rbp)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/samtools-0.1.18/bam_sort.c
// Function: heap_lt
static inline int heap_lt(const heap1_t a, const heap1_t b)
{
	if (g_is_by_qname) {
		int t;
		if (a.b == 0 || b.b == 0) return a.b == 0? 1 : 0;
		t = strnum_cmp(bam1_qname(a.b), bam1_qname(b.b));
		return (t > 0 || (t == 0 && __pos_cmp(a, b)));
	} else return __pos_cmp(a, b);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
cmpl $0x0, 0x196e8f(%rip)    # 0x490364
je 0x2f95a5
movq 0x18(%rsi), %rcx
testq %rcx, %rcx
sete %al
movq 0x18(%rdi), %rdx
testq %rdx, %rdx
sete %sil
orb %al, %sil
jne 0x2f9608
movq 0x30(%rcx), %r12
movq 0x30(%rdx), %r15
movq %r12, 0x10(%rsp)
movq %r15, 0x8(%rsp)
movb (%r12), %r13b
testb %r13b, %r13b
je 0x2f95ce
movq %r12, %rbx
movq 0x8(%rsp), %r14
movsbq (%r14), %rbp
testq %rbp, %rbp
je 0x2f95d7
callq 0x2f1b0
movq (%rax), %rax
movsbq %r13b, %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x2f9547
testb $0x8, 0x1(%rax,%rbp,2)
jne 0x2f9562
cmpb %bpl, %r13b
jne 0x2f95d7
incq %rbx
movq %rbx, 0x10(%rsp)
incq %r14
movq %r14, 0x8(%rsp)
jmp 0x2f9593
movq %rbx, %rdi
leaq 0x10(%rsp), %rsi
movl $0xa, %edx
callq 0x2fbd0
movq %rax, %rbx
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
movl $0xa, %edx
callq 0x2fbd0
cmpq %rax, %rbx
jne 0x2f95e5
movq 0x10(%rsp), %rbx
movb (%rbx), %r13b
testb %r13b, %r13b
jne 0x2f951b
movq 0x8(%rsp), %r14
xorl %r13d, %r13d
jmp 0x2f95d7
movq 0x8(%rsi), %rcx
movq 0x8(%rdi), %rdx
movb $0x1, %al
cmpq %rdx, %rcx
ja 0x2f9608
jne 0x2f9606
movl (%rdi), %ecx
cmpl %ecx, (%rsi)
jg 0x2f9608
sete %cl
movq 0x10(%rdi), %rax
cmpq %rax, 0x10(%rsi)
seta %al
andb %cl, %al
jmp 0x2f9608
xorl %r13d, %r13d
movq %r15, %r14
movq %r12, %rbx
cmpb (%r14), %r13b
jne 0x2f95e5
subq %r12, %rbx
subq %r15, %r14
cmpq %r14, %rbx
setl %cl
setg %dl
leaq 0x50(%rsp), %rsi
leaq 0x70(%rsp), %rdi
movb $0x1, %al
testb %cl, %cl
jne 0x2f95ff
testb %dl, %dl
jne 0x2f9608
orb %dl, %cl
testb $0x1, %cl
je 0x2f961a
xorl %eax, %eax
movzbl %al, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsi), %rcx
movq 0x8(%rdi), %rdx
jmp 0x2f95af