LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/script_wrapper_visitor.c
// Function: script_wrapper_visitor_meta_node
static int script_wrapper_visitor_meta_node(GtNodeVisitor *nv,
                                            GtMetaNode *rn,
                                            GtError *err)
{
  GtScriptWrapperVisitor *swv;
  int had_err = 0;
  gt_error_check(err);
  swv = gt_script_wrapper_visitor_cast(nv);
  if (swv->meta_node_func)
    had_err = swv->meta_node_func(rn, err);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x1e6583
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x1e65b1
callq 0x1e6330
movq %rax, %rdi
movq %r15, %rsi
callq 0x2e4d0
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x1e65a9
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x6b8b1
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/script_wrapper_visitor.c
// Function: gt_script_wrapper_visitor_new
GtNodeVisitor*
gt_script_wrapper_visitor_new(GtScriptWrapperVisitorCommentNodeFunc cn,
                              GtScriptWrapperVisitorFeatureNodeFunc fn,
                              GtScriptWrapperVisitorRegionNodeFunc rn,
                              GtScriptWrapperVisitorSequenceNodeFunc sn,
                              GtScriptWrapperVisitorMetaNodeFunc mn,
                              GtScriptWrapperVisitorEOFNodeFunc en,
                              GtScriptWrapperVisitorFreeFunc free_func)
{
  GtNodeVisitor *nv;
  GtScriptWrapperVisitor *swv;
  nv = gt_node_visitor_create(gt_script_wrapper_visitor_class());

  swv = gt_script_wrapper_visitor_cast(nv);
  swv->comment_node_func = cn;
  swv->feature_node_func = fn;
  swv->region_node_func = rn;
  swv->sequence_node_func = sn;
  swv->meta_node_func = mn;
  swv->eof_node_func = en;
  swv->free_func = free_func;
  return nv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
callq 0x1e6330
movq %rax, %rdi
callq 0x307b0
movq %rax, %rbx
callq 0x1e6330
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2e4d0
movq %rbp, 0x10(%rax)
movq %r13, 0x18(%rax)
movq %r12, 0x20(%rax)
movq %r15, 0x28(%rax)
movq %r14, 0x30(%rax)
movq (%rsp), %rcx
movq %rcx, 0x38(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x40(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/union_find.c
// Function: gt_union_find_new
GtUnionFind* gt_union_find_new(GtUword num_of_elems)
{
  GtUnionFind *uf;
  GtUword i;
  gt_assert(num_of_elems);
  uf = gt_malloc(sizeof *uf);
  uf->elems = gt_calloc(sizeof (GtUnionFindElement), num_of_elems);
  uf->allocated = num_of_elems;
  for (i = 0; i < num_of_elems; i++)
    uf->elems[i].parent = i;
  uf->num_of_elems = num_of_elems;
  return uf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1f99f1
movq %rdi, %rbx
leaq 0x18fbe2(%rip), %r15    # 0x389502
movl $0x18, %edi
movq %r15, %rsi
movl $0x28, %edx
callq 0x2d5f0
movq %rax, %r14
movl $0x8, %edi
movq %rbx, %rsi
movq %r15, %rdx
movl $0x29, %ecx
callq 0x2fef0
movq %rax, (%r14)
movq %rbx, 0x10(%r14)
leaq 0x1(%rbx), %rcx
andq $-0x2, %rcx
leaq -0x1(%rbx), %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x14bfc1(%rip), %xmm1   # 0x345930
xorl %edx, %edx
movdqa 0x14bfc7(%rip), %xmm2   # 0x345940
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x14c017(%rip), %xmm4   # 0x3459a0
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x1f99bf
movq %rdx, (%rax,%rdx,8)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x1f99d7
leaq 0x1(%rdx), %rsi
movq %rsi, 0x8(%rax,%rdx,8)
addq $0x2, %rdx
paddq %xmm4, %xmm1
cmpq %rdx, %rcx
jne 0x1f9989
movq %rbx, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x7208f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/union_find.c
// Function: gt_union_find_reset
void gt_union_find_reset(GtUnionFind *uf, GtUword num_of_elems)
{
  GtUword i;
  gt_assert(num_of_elems);
  if (num_of_elems > uf->allocated)
  {
    uf->elems = gt_realloc(uf->elems, sizeof (GtUnionFindElement) *
        num_of_elems);
    uf->allocated = num_of_elems;
  }
  for (i = 0; i < num_of_elems; i++)
    uf->elems[i].parent = i;
  uf->num_of_elems = num_of_elems;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1f9ade
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x10(%rdi)
jae 0x1f9a32
movq (%r14), %rdi
leaq (,%rbx,8), %rsi
leaq 0x18fae1(%rip), %rdx    # 0x389502
movl $0x38, %ecx
callq 0x2d900
movq %rax, (%r14)
movq %rbx, 0x10(%r14)
cmpq $0x1, %rbx
movq %rbx, %rdx
adcq $0x0, %rdx
movq (%r14), %rax
leaq 0x1(%rdx), %rcx
andq $-0x2, %rcx
decq %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x14bed3(%rip), %xmm1   # 0x345930
xorl %edx, %edx
movdqa 0x14bed9(%rip), %xmm2   # 0x345940
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x14bf29(%rip), %xmm4   # 0x3459a0
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x1f9aad
movq %rdx, (%rax,%rdx,8)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x1f9ac5
leaq 0x1(%rdx), %rsi
movq %rsi, 0x8(%rax,%rdx,8)
addq $0x2, %rdx
paddq %xmm4, %xmm1
cmpq %rdx, %rcx
jne 0x1f9a77
movq %rbx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x720c6
// File: /workspace/github_c_makefile_star2_O1/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 0x1f9b5d
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x8(%rdi)
jbe 0x1f9b5d
movq (%r14), %rax
movq (%rax,%rbx,8), %rsi
cmpq %rbx, %rsi
je 0x1f9b4e
movq %r14, %rdi
callq 0x1f9b1e
movq (%r14), %rcx
movq %rax, (%rcx,%rbx,8)
movq (%r14), %rax
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x720fd
// File: /workspace/github_c_makefile_star2_O1/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 0x1f9ba3
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq %rsi, %rax
jbe 0x1f9ba3
movq %rdx, %r14
cmpq %rdx, %rax
jbe 0x1f9ba3
movq %rbx, %rdi
callq 0x1f9b1e
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f9b1e
movq (%rbx), %rcx
movq %r15, (%rcx,%rax,8)
popq %rbx
popq %r14
popq %r15
retq
callq 0x72134
// File: /workspace/github_c_makefile_star2_O1/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 0x22c1b8
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 0x22bf40
addq $0x20, %rsp
cmpb %al, %bpl
jne 0x22c1a2
testb %bpl, %bpl
je 0x22c191
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
cmpq %rsi, %rdi
jne 0x22c1ae
testb %bpl, %bpl
je 0x22c191
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
cmpq %rsi, %rdi
jne 0x22c1b3
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 0x7fcbb
callq 0x7fc6d
callq 0x7fc94
// File: /workspace/github_c_makefile_star2_O1/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 0x154c54(%rip), %rdi    # 0x399787
callq 0x2dbb0
leaq 0x154c7d(%rip), %rdi    # 0x3997bc
callq 0x2dbb0
leaq 0x154c1a(%rip), %rsi    # 0x399765
movq %r14, %rdi
movl $0x1f, %edx
callq 0x2d5f0
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x30af0
cmpq $0xa, %r14
jb 0x244b8a
addq %rbx, %r14
addq $-0x9, %r14
leaq 0x154c03(%rip), %rsi    # 0x39977d
movq %r14, %rdi
callq 0x308e0
testl %eax, %eax
jne 0x244b8a
movb $0x0, (%r14)
leaq 0x154c38(%rip), %rdi    # 0x3997c9
callq 0x2dbb0
movq %rbx, %rdi
callq 0x32000
leaq 0x154bc0(%rip), %rsi    # 0x399765
movq %rbx, %rdi
movl $0x28, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x2feb0
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x2492c0
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
callq 0x300e0
cmpq %r15, %rax
jb 0x2492c5
leaq 0x152184(%rip), %r13    # 0x39b3e1
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 0x864f8
callq 0x864c1
// File: /workspace/github_c_makefile_star2_O1/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 0x249391
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 0x249339
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
jmp 0x249374
movq (%rbx), %rcx
movq 0x10(%rbx), %rdx
cmpq 0x18(%rbx), %rdx
jae 0x249353
leaq 0x1(%rdx), %rsi
movq %rsi, 0x10(%rbx)
movb %al, (%rcx,%rdx)
jmp 0x249374
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 0x249374
movq $0x0, 0x8(%rbx)
movq 0x18(%rbx), %rcx
movq 0x20(%rbx), %rax
cmpq %rcx, 0x10(%rbx)
je 0x249396
incq %rax
movq %rax, 0x20(%rbx)
cmpq 0x28(%rbx), %rax
jb 0x249322
jmp 0x2493ba
xorl %r12d, %r12d
jmp 0x2493ba
leaq -0x1(%rcx), %rdx
cmpq %rdx, %rax
jb 0x2493c7
cmpq %rcx, 0x8(%rbx)
jae 0x2493cc
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 0x86566
callq 0x8652f
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x2d0da9
testl %eax, %eax
jle 0x24ac9e
movl %eax, %r14d
negl %r14d
movl $0x1, %r12d
movq 0x2453a8(%rip), %r13    # 0x48ffc0
leaq 0xf7586(%rip), %r15     # 0x3421a5
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2d1140
movq %rbx, %rdi
cmpl $0x1, %eax
je 0x24ac50
cmpl $0x3, %eax
je 0x24ac46
cmpl $0x4, %eax
jne 0x24ac67
movl %r12d, %esi
callq 0x86bf7
jmp 0x24ac75
movl %r12d, %esi
callq 0x86bab
jmp 0x24ac75
movl %r12d, %esi
callq 0x2d1500
movq (%r13), %rdi
testl %eax, %eax
jne 0x24ac70
callq 0x86be2
jmp 0x24ac75
movl %eax, %esi
callq 0x86c1e
jmp 0x24ac75
callq 0x86bcd
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 0x24ac1f
movq 0x24531b(%rip), %rax    # 0x48ffc0
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_O1/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 0x150308(%rip), %r15    # 0x39befc
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_O1/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 %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl %ecx, %r12d
testl %ecx, %ecx
je 0x24bc74
movq (%rbx), %rdi
leaq (,%r12,8), %rdx
xorl %esi, %esi
callq 0x2d4b0
leaq (%r14,%r15), %rax
testq %r15, %r15
jle 0x24bc92
movq (%rbx), %rcx
movq %r14, %rdx
movzbl (%rdx), %esi
incq (%rcx,%rsi,8)
incq %rdx
cmpq %rax, %rdx
jb 0x24bc83
movq (%rbx), %rcx
movq (%rcx), %rdx
movq $0x0, (%rcx)
cmpl $0x2, %ebp
jb 0x24bcbf
movl $0x1, %esi
movq (%rcx,%rsi,8), %rdi
addq %rdx, %rdi
movq %rdx, (%rcx,%rsi,8)
incq %rsi
movq %rdi, %rdx
cmpq %rsi, %r12
jne 0x24bca9
testq %r15, %r15
jle 0x24bcee
movq 0x8(%rbx), %rdx
xorl %esi, %esi
leaq (%r14,%rsi), %rdi
incq %rdi
movzbl -0x1(%rdi), %r8d
movq (%rcx,%r8,8), %r9
leaq 0x1(%r9), %r10
movq %r10, (%rcx,%r8,8)
movq %rsi, (%rdx,%r9,8)
incq %rsi
cmpq %rax, %rdi
jb 0x24bcca
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1501ed(%rip), %r15    # 0x39befc
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_O1/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:
movzbl %dl, %eax
testl %edx, %edx
je 0x24bd5e
movq (%rdi), %rdx
leal -0x1(%rax), %r8d
movq (%rdx,%r8,8), %rdx
jmp 0x24bd60
xorl %edx, %edx
movq (%rdi), %r8
cmpq (%r8,%rax,8), %rdx
jae 0x24bd8a
movq 0x8(%rdi), %rdi
movq (%rdi,%rdx,8), %r9
movq (%rsi,%r9,8), %r10
cmpq %rcx, %r10
jne 0x24bd81
incq %r10
movq %r10, (%rsi,%r9,8)
incq %rdx
cmpq (%r8,%rax,8), %rdx
jb 0x24bd6d
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x14ee72(%rip), %rdi    # 0x39c5cd
xorl %eax, %eax
callq 0x2d300
leaq 0x14ee78(%rip), %rdi    # 0x39c5e1
xorl %eax, %eax
callq 0x2d300
movq 0x242879(%rip), %r12    # 0x48fff0
movq (%r12), %rdi
movl 0x1c(%rbx), %edx
leaq 0x173fea(%rip), %r15    # 0x3c176f
movq %r15, %rsi
xorl %eax, %eax
callq 0x31920
movl $0xa, %edi
callq 0x2df70
leaq 0x14ee52(%rip), %rdi    # 0x39c5f2
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 0x178e45(%rip), %r15    # 0x3c660e
movq %r15, %rdi
xorl %eax, %eax
callq 0x2d300
cmpq $0x0, 0x8(%rbx)
je 0x24d818
leaq 0x167b72(%rip), %r13    # 0x3b5353
leaq 0x171971(%rip), %r12    # 0x3bf159
xorl %ebp, %ebp
movzbl (%r14,%rbp), %edi
callq 0x2df70
movq 0x8(%rbx), %rax
decq %rax
cmpq %rax, %rbp
movq %r13, %rsi
cmovbq %r15, %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0x2d300
incq %rbp
cmpq 0x8(%rbx), %rbp
jb 0x24d7ea
cmpq $0x0, (%rbx)
je 0x24d891
leaq 0x173f4a(%rip), %rbp    # 0x3c176f
xorl %r13d, %r13d
cmpq $0x0, 0x8(%rbx)
movq 0x2427bc(%rip), %r12    # 0x48fff0
leaq 0x17191e(%rip), %r15    # 0x3bf159
je 0x24d889
xorl %r14d, %r14d
movq (%r12), %rdi
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rax
movl (%rax,%r13,4), %edx
movq %rbp, %rsi
xorl %eax, %eax
callq 0x31920
movq 0x8(%rbx), %rax
decq %rax
cmpq %rax, %r14
leaq 0x169fa2(%rip), %rsi    # 0x3b780d
leaq 0x169e16(%rip), %rax    # 0x3b7688
cmovbq %rax, %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2d300
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x24d840
incq %r13
cmpq (%rbx), %r13
jb 0x24d828
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14ed4c(%rip), %rsi    # 0x39c603
movl $0x51, %edx
callq 0x2d5f0
movq (%r14), %rcx
testq %rcx, %rcx
je 0x24d902
movq 0x8(%r14), %rdx
xorl %esi, %esi
testq %rdx, %rdx
je 0x24d8fa
movq 0x20(%r14), %rdi
xorl %r8d, %r8d
movq (%rdi,%r8,8), %r9
movl (%r9,%rsi,4), %r9d
testq %r8, %r8
je 0x24d8ee
cmpl %r9d, (%rax,%rsi,4)
jge 0x24d8f2
movl %r9d, (%rax,%rsi,4)
incq %r8
cmpq %r8, %rdx
jne 0x24d8db
incq %rsi
cmpq %rcx, %rsi
jne 0x24d8cf
movq 0x10(%r14), %rdx
testq %rdx, %rdx
je 0x24d944
movq %rcx, %rsi
decq %rsi
js 0x24d929
xorl %esi, %esi
movl %ebx, %edi
subl %esi, %edi
movl %edi, -0x4(%rdx,%rcx,4)
addl -0x4(%rax,%rcx,4), %esi
decq %rcx
testq %rcx, %rcx
jg 0x24d915
leaq 0x14ecd3(%rip), %rsi    # 0x39c603
movq %rax, %rdi
movl $0x64, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2feb0
callq 0x87771
// File: /workspace/github_c_makefile_star2_O1/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 0x14ec88(%rip), %rsi    # 0x39c603
movl $0x72, %edx
callq 0x2d5f0
movq %rax, %r12
testq %r14, %r14
je 0x24d9c4
xorl %r13d, %r13d
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x2ddd0
cmpb $-0x3, %al
jbe 0x24d9a5
xorl %ebp, %ebp
xorl %r13d, %r13d
jmp 0x24d9bf
cmpq (%rbx), %rbp
jae 0x24d9b3
movb %al, (%r12,%rbp)
incq %rbp
jmp 0x24d9bf
movb %al, (%r12,%r13)
incq %r13
cmpq (%rbx), %r13
je 0x24d9a0
decq %r14
jne 0x24d992
movq %r15, %rdi
callq 0x2ebb0
leaq 0x14ec30(%rip), %rsi    # 0x39c603
movq %r12, %rdi
movl $0x8a, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2feb0
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x2527a5
movq %r8, %rbx
movq %rcx, %r13
movl $0x1, %ebp
xorl %eax, %eax
movzwl (%r13,%rbp,2), %ecx
cmpl 0x20(%r14), %ecx
jae 0x25279b
leaq (%r12,%rax,8), %rsi
movq %rbp, %rdx
subq %rax, %rdx
movq %r15, %rdi
movq %r14, %rcx
callq 0x2527d2
movq %rbp, %rax
incq %rbp
cmpq %rbp, %rbx
jne 0x252777
jmp 0x2527ac
movl $0x1, %ebx
xorl %eax, %eax
leaq (%r12,%rax,8), %rsi
subq %rax, %rbx
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x2527d2
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_O1/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 0x2543bd
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
leaq 0x14a9af(%rip), %r14    # 0x39ec6d
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 0x1f9ae3
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 0x88e62
// File: /workspace/github_c_makefile_star2_O1/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 0x14e7a7
testb %al, %al
je 0x2a159a
movq %r15, %rdi
callq 0x15015f
movq %rax, %r14
leaq (,%rax,8), %rax
leaq (%rax,%rax,2), %rdi
leaq 0x10efc0(%rip), %rsi    # 0x3b04d2
movl $0x2c, %edx
callq 0x2d5f0
movq %rax, %rbx
andl $-0x3, %ebp
xorl %esi, %esi
cmpl $0x1, %ebp
setne %sil
movq %r15, %rdi
callq 0x14e901
movq %rax, %r15
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x14e979
movq %rbx, %r13
testb %al, %al
je 0x2a1583
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 0x14e979
testb %al, %al
jne 0x2a1554
leaq (%r14,%r14,2), %rax
leaq (%rbx,%rax,8), %rax
cmpq %rax, %r13
jne 0x2a15ae
movq %r15, %rdi
callq 0x14ef70
jmp 0x2a159c
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xa12cb
// File: /workspace/github_c_makefile_star2_O1/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 0x2a1666
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 0x2a164b
addq $-0x18, %r8
movq %r8, %rsi
jmp 0x2a1661
movq (%r8), %rdi
addq 0x8(%r8), %r9
subq %rdi, %r9
cmpq %rdx, %r9
ja 0x2a166e
addq $0x18, %r8
movq %r8, %rdi
cmpq %rsi, %rdi
jbe 0x2a161d
movq %rdx, %rdi
callq 0xa1326
addq %rdi, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14e7a7
testb %al, %al
je 0x2a1788
movq %rbp, %rdi
callq 0x300e0
movq %rax, %r12
movq %rbp, %rdi
callq 0x15015f
movq %rax, 0x10(%rsp)
movq %rax, %rdi
shlq $0x4, %rdi
leaq 0x10ee15(%rip), %rsi    # 0x3b04d2
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 0x14e901
movq %rax, %rbp
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x14e979
movq %rbx, 0x8(%rsp)
testb %al, %al
je 0x2a1754
movq 0x8(%rsp), %rbx
movq (%rsp), %rax
leaq (%rbx,%rax), %r13
xorl %ecx, %ecx
cmpq %r13, %rbx
jae 0x2a17a2
movq 0x20(%rsp), %rax
cmpq %r12, %rax
ja 0x2a179d
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 0x14e979
movq %r15, %rcx
testb %al, %al
jne 0x2a170c
movq 0x8(%rsp), %r14
movq %r14, %rax
addq (%rsp), %rax
cmpq %rax, %rbx
jne 0x2a17a7
movq %rbp, %rdi
callq 0x14ef70
leaq 0x38(%rip), %rcx        # 0x2a17ac
movl $0x10, %edx
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0x305e0
jmp 0x2a178b
xorl %r14d, %r14d
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xa13bc
callq 0xa134a
callq 0xa1383
// File: /workspace/github_c_makefile_star2_O1/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 0x10ecb6(%rip), %rsi    # 0x3b06ef
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 0x248fe3
movq %rax, 0x28(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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), %edx
movq 0x10(%rdi), %rax
cmpq %rdx, %rax
jae 0x2a1a96
xorl %eax, %eax
retq
pushq %rbx
movq (%rdi), %rcx
movq 0x28(%rdi), %rsi
leal -0x1(%rdx), %r8d
testl %r8d, %r8d
js 0x2a1ad1
movl %edx, %r9d
xorl %r10d, %r10d
leal -0x1(%r9), %r11d
movzbl (%rcx,%r11), %ebx
cmpq $0xfd, %rbx
ja 0x2a1add
movq (%rsi,%r11,8), %r9
addq (%r9,%rbx,8), %r10
movl %r11d, %r9d
testl %r11d, %r11d
jg 0x2a1aad
jmp 0x2a1ad4
xorl %r10d, %r10d
movq %r10, 0x18(%rdi)
movl %edx, %r9d
jmp 0x2a1ae0
decl %r9d
cmpl %edx, %r9d
je 0x2a1afe
incl %r9d
subq %r9, %rax
movq %rax, 0x10(%rdi)
addq %r9, %rcx
movq %rcx, (%rdi)
cmpq %rdx, %rax
jae 0x2a1aa2
xorl %eax, %eax
jmp 0x2a1b10
decq %rax
movq %rax, 0x10(%rdi)
incq %rcx
movq %rcx, (%rdi)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1456d7
cmpq $0x0, 0x1eb5fe(%rip)    # 0x497c78
jne 0x2ac69b
leaq 0x26(%rip), %rsi        # 0x2ac6a9
leaq 0x49(%rip), %rdx        # 0x2ac6d3
movl $0x28, %edi
callq 0x2e6f0
movq %rax, 0x1eb5dd(%rip)    # 0x497c78
callq 0x1456ed
movq 0x1eb5d1(%rip), %rax    # 0x497c78
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2ac6f2
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x2ac722
callq 0x2ac66c
movq %rax, %rdi
movq %r15, %rsi
callq 0x2ef70
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x2ac70e
incq (%rcx)
movq 0x10(%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2f490
callq 0xa30a7
// File: /workspace/github_c_makefile_star2_O1/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 0x2ac7e8
movq %r9, %r15
movl %r8d, %r14d
movq %rsi, %rbx
movq %rdi, %r12
callq 0x2ac66c
movq %rax, %rdi
xorl %esi, %esi
callq 0x30240
movq %rax, %r13
callq 0x2ac66c
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 0xd4c66(%rip), %rsi     # 0x3813fe
movl $0x1, %edx
movq %rax, %rdi
callq 0x30740
movq %rbx, %rdi
callq 0x1e1a04
testq %rax, %rax
je 0x2ac7ed
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 0x1d721b
movq %rax, 0x10(%rbp)
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xa3115
callq 0xa30de
// File: /workspace/github_c_makefile_star2_O1/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 0x1456d7
cmpq $0x0, 0x1d524f(%rip)    # 0x497ce8
jne 0x2c2ac8
leaq -0x23e(%rip), %rsi      # 0x2c2864
leaq 0x2d(%rip), %rdx        # 0x2c2ad6
leaq 0x40(%rip), %rcx        # 0x2c2af0
leaq 0x57(%rip), %r8         # 0x2c2b0e
movl $0x20, %edi
callq 0x2c26c0
movq %rax, 0x1d5220(%rip)    # 0x497ce8
callq 0x1456ed
movq 0x1d5214(%rip), %rax    # 0x497ce8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2c2a8b
movq %rax, %rdi
callq 0x2c26ff
movq %rax, %rbx
callq 0x2c2a8b
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2c284a
movq %rax, %r14
leaq 0xf75ad(%rip), %rdi     # 0x3ba10d
callq 0x2f0d0
movq %rax, 0x18(%r14)
movq $0x28, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq