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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x176a53
movq %rbx, %rdi
callq 0x32150
testb %al, %al
jne 0x176a81
callq 0x1768e8
movq %rax, %rdi
movq %r15, %rsi
callq 0x2f4e0
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x176a79
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x294528(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x167d5e(%rip), %rsi    # 0x2de7f0
leaq 0x167f2a(%rip), %rdx    # 0x2de9c3
leaq 0x1a20fd(%rip), %rcx    # 0x318b9d
leaq 0x1a20ac(%rip), %r8     # 0x318b53
pushq $0x36
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/script_wrapper_visitor.c
// Function: script_wrapper_visitor_region_node
static int script_wrapper_visitor_region_node(GtNodeVisitor *nv,
                                              GtRegionNode *rn,
                                              GtError *err)
{
  GtScriptWrapperVisitor *swv;
  int had_err = 0;
  gt_error_check(err);
  swv = gt_script_wrapper_visitor_cast(nv);
  if (swv->region_node_func)
    had_err = swv->region_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 0x176ad6
movq %rbx, %rdi
callq 0x32150
testb %al, %al
jne 0x176b04
callq 0x1768e8
movq %rax, %rdi
movq %r15, %rsi
callq 0x2f4e0
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x176afc
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x2944a5(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x167cdb(%rip), %rsi    # 0x2de7f0
leaq 0x167ea7(%rip), %rdx    # 0x2de9c3
leaq 0x1a209e(%rip), %rcx    # 0x318bc1
leaq 0x1a2029(%rip), %r8     # 0x318b53
pushq $0x43
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/script_wrapper_visitor.c
// Function: script_wrapper_visitor_sequence_node
static int script_wrapper_visitor_sequence_node(GtNodeVisitor *nv,
                                                GtSequenceNode *sn,
                                                GtError *err)
{
  GtScriptWrapperVisitor *swv;
  int had_err = 0;
  gt_error_check(err);
  swv = gt_script_wrapper_visitor_cast(nv);
  if (swv->sequence_node_func)
    had_err = swv->sequence_node_func(sn, err);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x176b59
movq %rbx, %rdi
callq 0x32150
testb %al, %al
jne 0x176b87
callq 0x1768e8
movq %rax, %rdi
movq %r15, %rsi
callq 0x2f4e0
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x176b7f
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x294422(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x167c58(%rip), %rsi    # 0x2de7f0
leaq 0x167e24(%rip), %rdx    # 0x2de9c3
leaq 0x1a203e(%rip), %rcx    # 0x318be4
leaq 0x1a1fa6(%rip), %r8     # 0x318b53
pushq $0x5d
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/script_wrapper_visitor.c
// Function: script_wrapper_visitor_eof_node
static int script_wrapper_visitor_eof_node(GtNodeVisitor *nv,
                                           GtEOFNode *rn,
                                           GtError *err)
{
  GtScriptWrapperVisitor *swv;
  int had_err = 0;
  gt_error_check(err);
  swv = gt_script_wrapper_visitor_cast(nv);
  if (swv->eof_node_func)
    had_err = swv->eof_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 0x176bdc
movq %rbx, %rdi
callq 0x32150
testb %al, %al
jne 0x176c0a
callq 0x1768e8
movq %rax, %rdi
movq %r15, %rsi
callq 0x2f4e0
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x176c02
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x29439f(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x167bd5(%rip), %rsi    # 0x2de7f0
leaq 0x167da1(%rip), %rdx    # 0x2de9c3
leaq 0x1a1fe0(%rip), %rcx    # 0x318c09
leaq 0x1a1f23(%rip), %r8     # 0x318b53
pushq $0x77
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/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 0x176c5f
movq %rbx, %rdi
callq 0x32150
testb %al, %al
jne 0x176c8d
callq 0x1768e8
movq %rax, %rdi
movq %r15, %rsi
callq 0x2f4e0
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x176c85
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x29431c(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x167b52(%rip), %rsi    # 0x2de7f0
leaq 0x167d1e(%rip), %rdx    # 0x2de9c3
leaq 0x1a1f7d(%rip), %rcx    # 0x318c29
leaq 0x1a1ea0(%rip), %r8     # 0x318b53
pushq $0x6a
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/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 0x1768e8
movq %rax, %rdi
callq 0x31800
movq %rax, %rbx
callq 0x1768e8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2f4e0
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
// File: /workspace/github_c_makefile_star2_O2/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 0x18e61e
movq %rdi, %rbx
leaq 0x194eda(%rip), %r15    # 0x3234b2
pushq $0x18
popq %rdi
pushq $0x28
popq %rdx
movq %r15, %rsi
callq 0x2e5f0
movq %rax, %r14
pushq $0x8
popq %rdi
pushq $0x29
popq %rcx
movq %rbx, %rsi
movq %r15, %rdx
callq 0x30f40
movq %rax, (%r14)
movq %rbx, 0x10(%r14)
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0x18e611
movq %rcx, (%rax,%rcx,8)
incq %rcx
jmp 0x18e603
movq %rbx, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x27c98b(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x1501c1(%rip), %rsi    # 0x2de7f0
leaq 0x17c3cc(%rip), %rdx    # 0x30aa02
leaq 0x194e63(%rip), %rcx    # 0x3234a0
leaq 0x194e6e(%rip), %r8     # 0x3234b2
pushq $0x27
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/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 0x18e6a9
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
cmpq %rsi, 0x10(%rdi)
jae 0x18e68d
leaq (,%rbx,8), %rsi
leaq 0x194e37(%rip), %rdx    # 0x3234b2
pushq $0x38
popq %rcx
movq %rax, %rdi
callq 0x2e900
movq %rax, (%r14)
movq %rbx, 0x10(%r14)
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0x18e69d
movq %rcx, (%rax,%rcx,8)
incq %rcx
jmp 0x18e68f
movq %rbx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x27c900(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x150136(%rip), %rsi    # 0x2de7f0
leaq 0x17c341(%rip), %rdx    # 0x30aa02
leaq 0x194e04(%rip), %rcx    # 0x3234cc
leaq 0x194de3(%rip), %r8     # 0x3234b2
pushq $0x34
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/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 0x18e754
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x8(%rdi)
jbe 0x18e754
movq (%r14), %rax
movq (%rax,%rbx,8), %rsi
cmpq %rbx, %rsi
je 0x18e749
movq %r14, %rdi
callq 0x18e716
movq (%r14), %rcx
movq %rax, (%rcx,%rbx,8)
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x27c855(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x15008b(%rip), %rsi    # 0x2de7f0
leaq 0x194d74(%rip), %rdx    # 0x3234e0
leaq 0x194d8b(%rip), %rcx    # 0x3234fe
leaq 0x194d38(%rip), %r8     # 0x3234b2
pushq $0x49
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/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 0x18e7cb
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq %rsi, %rax
jbe 0x18e7cb
movq %rdx, %r14
cmpq %rdx, %rax
jbe 0x18e7cb
movq %rbx, %rdi
callq 0x18e716
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18e716
movq (%rbx), %rcx
movq %r15, (%rcx,%rax,8)
popq %rbx
popq %r14
popq %r15
retq
movq 0x27c7de(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x150014(%rip), %rsi    # 0x2de7f0
leaq 0x194d2e(%rip), %rdx    # 0x323511
leaq 0x194d64(%rip), %rcx    # 0x32354e
leaq 0x194cc1(%rip), %r8     # 0x3234b2
pushq $0x53
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/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 0x2fe60
movq %rax, %r14
leaq 0x151240(%rip), %rdi    # 0x33356b
callq 0x2ebc0
leaq 0x151269(%rip), %rdi    # 0x3335a0
callq 0x2ebc0
leaq 0x151206(%rip), %rsi    # 0x333549
pushq $0x1f
popq %rdx
movq %r14, %rdi
callq 0x2e5f0
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x31b50
cmpq $0xa, %r14
jb 0x1e2380
addq %rbx, %r14
addq $-0x9, %r14
leaq 0x1511f1(%rip), %rsi    # 0x333561
movq %r14, %rdi
callq 0x31930
testl %eax, %eax
jne 0x1e2380
movb $0x0, (%r14)
leaq 0x151226(%rip), %rdi    # 0x3335ad
callq 0x2ebc0
movq %rbx, %rdi
callq 0x33040
leaq 0x1511ae(%rip), %rsi    # 0x333549
pushq $0x28
popq %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x30f00
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x1e7d72
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
callq 0x31140
cmpq %r15, %rax
jb 0x1e7d9c
leaq 0x14d4c0(%rip), %r13    # 0x3351d5
pushq $0x40
popq %rdi
pushq $0x28
popq %rdx
movq %r13, %rsi
callq 0x2e5f0
movq %rax, %rbp
pushq $0x29
popq %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x2e5f0
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 0x2faf0
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
movq 0x223237(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0xf6a6d(%rip), %rsi     # 0x2de7f0
leaq 0x1404d3(%rip), %rdx    # 0x32825d
leaq 0x14d42e(%rip), %rcx    # 0x3351bf
leaq 0x14d43d(%rip), %r8     # 0x3351d5
pushq $0x26
jmp 0x1e7dc4
movq 0x22320d(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0xf6a43(%rip), %rsi     # 0x2de7f0
leaq 0x14d439(%rip), %rdx    # 0x3351ed
leaq 0x14d404(%rip), %rcx    # 0x3351bf
leaq 0x14d413(%rip), %r8     # 0x3351d5
pushq $0x27
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdx), %r13
movq 0x20(%rdx), %rax
xorl %r12d, %r12d
cmpq 0x28(%rbx), %rax
jae 0x1e7eb4
movq 0x38(%rbx), %rdi
callq 0x2edf0
cmpb $-0x2, %al
jb 0x1e7e41
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
jmp 0x1e7e79
movq (%rbx), %rcx
movq 0x10(%rbx), %rdx
cmpq 0x18(%rbx), %rdx
jae 0x1e7e5b
leaq 0x1(%rdx), %rsi
movq %rsi, 0x10(%rbx)
movb %al, (%rcx,%rdx)
jmp 0x1e7e79
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 0x1e7e79
andq $0x0, (%r13)
movq 0x10(%rbx), %rcx
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rcx
je 0x1e7e90
incq %rax
movq %rax, 0x20(%rbx)
jmp 0x1e7e20
leaq -0x1(%rcx), %rdx
cmpq %rdx, %rax
jb 0x1e7ec1
cmpq %rcx, (%r13)
jae 0x1e7eeb
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
movq 0x2230e8(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0xf691e(%rip), %rsi     # 0x2de7f0
leaq 0x14d33d(%rip), %rdx    # 0x335216
leaq 0x14d367(%rip), %rcx    # 0x335247
leaq 0x14d2ee(%rip), %r8     # 0x3351d5
pushq $0x57
jmp 0x1e7f13
movq 0x2230be(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0xf68f4(%rip), %rsi     # 0x2de7f0
leaq 0x14d35b(%rip), %rdx    # 0x33525e
leaq 0x14d33d(%rip), %rcx    # 0x335247
leaq 0x14d2c4(%rip), %r8     # 0x3351d5
pushq $0x58
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x278a59
movl %eax, %r14d
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
negl %r14d
pushq $0x1
popq %r15
movq 0x2215bb(%rip), %r13    # 0x40afb0
pushq $0x1
popq %rbp
leaq 0xf27a9(%rip), %r12     # 0x2dc1a8
leal (%r14,%r15), %eax
cmpl $0x1, %eax
je 0x1e9ae7
movq %rbx, %rdi
movl %r15d, %esi
callq 0x278dc5
cmpl $0x1, %eax
je 0x1e9a7d
cmpl $0x3, %eax
je 0x1e9a52
cmpl $0x4, %eax
jne 0x1e9a9b
movq (%r13), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x279207
movq (%rsp), %rdi
leaq 0x16feba(%rip), %rsi    # 0x359900
movq %rax, %rdx
xorl %eax, %eax
callq 0x32960
jmp 0x1e9acd
movq %r12, %rbp
movq (%r13), %r12
movq %rbx, %rdi
movl %r15d, %esi
callq 0x279185
movq %r12, %rdi
movq %rbp, %r12
pushq $0x1
popq %rbp
leaq 0x17108f(%rip), %rsi    # 0x35ab03
movb $0x1, %al
callq 0x32960
jmp 0x1e9acd
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2791e3
movq (%r13), %rcx
testl %eax, %eax
jne 0x1e9abb
leaq 0x122e51(%rip), %rdi    # 0x30c8e8
pushq $0x5
jmp 0x1e9ac4
movq (%r13), %rcx
movq %rcx, (%rsp)
movq %rbx, %rdi
movl %eax, %esi
callq 0x278dde
movq %rax, %rdi
movq (%rsp), %rsi
callq 0x30bf0
jmp 0x1e9acd
leaq 0x1404cf(%rip), %rdi    # 0x329f91
pushq $0x4
popq %rsi
movq %rbp, %rdx
callq 0x32760
movq (%r13), %rcx
movq %r12, %rdi
pushq $0x2
popq %rsi
movq %rbp, %rdx
callq 0x32760
incl %r15d
jmp 0x1e99ff
movq (%r13), %rsi
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2fcd0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x14b0ac(%rip), %r15    # 0x335ca8
pushq $0x10
popq %rdi
pushq $0x20
popq %rdx
movq %r15, %rsi
callq 0x2e5f0
movq %rax, %r12
movl %ebx, %edi
shlq $0x3, %rdi
pushq $0x21
popq %rdx
movq %r15, %rsi
callq 0x2e5f0
movq %rax, (%r12)
shlq $0x3, %r14
pushq $0x22
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2e5f0
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_O2/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:
movq %rdi, %rax
movl %ecx, %edi
xorl %ecx, %ecx
cmpq %rcx, %rdi
je 0x1eac61
movq (%rax), %r8
andq $0x0, (%r8,%rcx,8)
incq %rcx
jmp 0x1eac4f
addq %rsi, %rdx
movq (%rax), %rcx
movq %rsi, %r8
cmpq %rdx, %r8
jae 0x1eac7c
movzbl (%r8), %r9d
incq (%rcx,%r9,8)
incq %r8
jmp 0x1eac6a
movq (%rcx), %r9
andq $0x0, (%rcx)
pushq $0x1
popq %r8
cmpq %rdi, %r8
jae 0x1eac9f
movq (%rcx,%r8,8), %r10
addq %r9, %r10
movq %r9, (%rcx,%r8,8)
incq %r8
movq %r10, %r9
jmp 0x1eac87
xorl %edi, %edi
leaq (%rsi,%rdi), %r8
cmpq %rdx, %r8
jae 0x1eacc7
movq 0x8(%rax), %r9
movzbl (%r8), %r8d
movq (%rcx,%r8,8), %r10
leaq 0x1(%r10), %r11
movq %r11, (%rcx,%r8,8)
movq %rdi, (%r9,%r10,8)
incq %rdi
jmp 0x1eaca1
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x14afcb(%rip), %r15    # 0x335ca8
pushq $0x49
popq %rdx
movq %r15, %rsi
callq 0x30f00
movq 0x8(%r14), %rdi
pushq $0x4a
popq %rdx
movq %r15, %rsi
callq 0x30f00
pushq $0x4b
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x30f00
andq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1ead25
movzbl %dl, %edx
movl %edx, %r8d
decl %r8d
movq (%rax,%r8,8), %r8
jmp 0x1ead2a
xorl %edx, %edx
xorl %r8d, %r8d
leaq 0x1(%rcx), %r9
cmpq (%rax,%rdx,8), %r8
jae 0x1ead4b
movq 0x8(%rdi), %r10
movq (%r10,%r8,8), %r10
cmpq %rcx, (%rsi,%r10,8)
jne 0x1ead46
movq %r9, (%rsi,%r10,8)
incq %r8
jmp 0x1ead2e
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x14995f(%rip), %rdi    # 0x336366
xorl %eax, %eax
callq 0x2e300
leaq 0x149965(%rip), %rdi    # 0x33637a
xorl %eax, %eax
callq 0x2e300
movq 0x21e5c5(%rip), %r12    # 0x40afe8
movq (%r12), %rdi
movl 0x1c(%rbx), %edx
leaq 0x16e90e(%rip), %r15    # 0x35b33f
movq %r15, %rsi
xorl %eax, %eax
callq 0x32960
pushq $0xa
popq %rbp
movl %ebp, %edi
callq 0x2ef90
leaq 0x14993f(%rip), %rdi    # 0x33638b
xorl %eax, %eax
callq 0x2e300
movq (%r12), %rdi
movl 0x18(%rbx), %edx
movq %r15, %rsi
xorl %eax, %eax
callq 0x32960
movl %ebp, %edi
callq 0x2ef90
leaq 0x173704(%rip), %r15    # 0x360176
movq %r15, %rdi
xorl %eax, %eax
callq 0x2e300
leaq 0x1626c0(%rip), %r13    # 0x34f143
leaq 0x16c3b7(%rip), %r12    # 0x358e41
xorl %ebp, %ebp
movq 0x8(%rbx), %rax
cmpq %rax, %rbp
jae 0x1ecabf
movzbl (%r14,%rbp), %edi
callq 0x2ef90
movq 0x8(%rbx), %rax
decq %rax
cmpq %rax, %rbp
movq %r13, %rsi
cmovbq %r15, %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0x2e300
incq %rbp
jmp 0x1eca8c
leaq 0x1648d2(%rip), %r12    # 0x351398
leaq 0x164a50(%rip), %rbp    # 0x35151d
leaq 0x16c36d(%rip), %r15    # 0x358e41
xorl %r13d, %r13d
cmpq (%rbx), %r13
jae 0x1ecb31
xorl %r14d, %r14d
cmpq %rax, %r14
jae 0x1ecb2c
movq 0x21e4fd(%rip), %rax    # 0x40afe8
movq (%rax), %rdi
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rax
movl (%rax,%r13,4), %edx
leaq 0x16e83e(%rip), %rsi    # 0x35b33f
xorl %eax, %eax
callq 0x32960
movq 0x8(%rbx), %rax
decq %rax
cmpq %rax, %r14
movq %rbp, %rsi
cmovbq %r12, %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2e300
incq %r14
movq 0x8(%rbx), %rax
jmp 0x1ecadf
incq %r13
jmp 0x1ecad7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/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 0x149845(%rip), %rsi    # 0x33639c
pushq $0x51
popq %rdx
callq 0x2e5f0
movq (%r14), %rcx
xorl %edx, %edx
cmpq %rcx, %rdx
je 0x1ecb99
movq 0x8(%r14), %rsi
xorl %edi, %edi
cmpq %rdi, %rsi
je 0x1ecb94
movq 0x20(%r14), %r8
movq (%r8,%rdi,8), %r8
movl (%r8,%rdx,4), %r8d
testq %rdi, %rdi
je 0x1ecb8b
cmpl %r8d, (%rax,%rdx,4)
jge 0x1ecb8f
movl %r8d, (%rax,%rdx,4)
incq %rdi
jmp 0x1ecb6f
incq %rdx
jmp 0x1ecb64
movq 0x10(%r14), %rdx
testq %rdx, %rdx
je 0x1ecbd4
decq %rcx
xorl %esi, %esi
testq %rcx, %rcx
js 0x1ecbbb
movl %ebx, %edi
subl %esi, %edi
movl %edi, (%rdx,%rcx,4)
addl (%rax,%rcx,4), %esi
decq %rcx
jmp 0x1ecba7
leaq 0x1497da(%rip), %rsi    # 0x33639c
pushq $0x64
popq %rdx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x30f00
movq 0x21e3d5(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0xf1c0b(%rip), %rsi     # 0x2de7f0
leaq 0x1497c1(%rip), %rdx    # 0x3363ad
leaq 0x1497d5(%rip), %rcx    # 0x3363c8
leaq 0x1497a2(%rip), %r8     # 0x33639c
pushq $0x5e
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/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 0x31140
movq %rax, %r14
xorl %r13d, %r13d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2faf0
movq %rax, %r15
movq (%rbx), %rdi
leaq 0x14975d(%rip), %rsi    # 0x33639c
pushq $0x72
popq %rdx
callq 0x2e5f0
movq %rax, %r12
xorl %ebp, %ebp
subq $0x1, %r14
jb 0x1ecc7f
movq %r15, %rdi
callq 0x2edf0
cmpb $-0x3, %al
ja 0x1ecc7a
cmpq (%rbx), %r13
jae 0x1ecc6c
movb %al, (%r12,%r13)
incq %r13
jmp 0x1ecc4c
movb %al, (%r12,%rbp)
incq %rbp
cmpq (%rbx), %rbp
je 0x1ecc4a
jmp 0x1ecc4c
xorl %r13d, %r13d
jmp 0x1ecc4a
movq %r15, %rdi
callq 0x2fbc0
leaq 0x14970e(%rip), %rsi    # 0x33639c
movq %r12, %rdi
movl $0x8a, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30f00
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %rbx
pushq $0x1
popq %r15
xorl %eax, %eax
cmpq %r12, %r15
jae 0x1f2268
movzwl (%r13,%r15,2), %ecx
cmpl 0x20(%rbx), %ecx
jae 0x1f2263
leaq (,%rax,8), %rsi
addq %rbp, %rsi
movq %r15, %rdx
subq %rax, %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1f2295
movq %r15, %rax
incq %r15
jmp 0x1f2234
leaq (,%rax,8), %rsi
addq %rbp, %rsi
subq %rax, %r15
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1f2295
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_O2/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 0x1f3cfe
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
leaq 0x144dce(%rip), %r14    # 0x3389cd
movq %r14, %rsi
movl $0x495, %edx            # imm = 0x495
callq 0x30f00
movq 0xa8(%rbx), %rdi
movq %r14, %rsi
movl $0x496, %edx            # imm = 0x496
callq 0x30f00
movq 0xb0(%rbx), %rdi
movq %r14, %rsi
movl $0x497, %edx            # imm = 0x497
callq 0x30f00
movq 0x88(%rbx), %rdi
movq %r14, %rsi
movl $0x498, %edx            # imm = 0x498
callq 0x30f00
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x499, %edx            # imm = 0x499
callq 0x30f00
movq 0x90(%rbx), %rdi
movq %r14, %rsi
movl $0x49a, %edx            # imm = 0x49A
callq 0x30f00
movq 0x50(%rbx), %rdi
movq %r14, %rsi
movl $0x49b, %edx            # imm = 0x49B
callq 0x30f00
movq 0x58(%rbx), %rdi
movq %r14, %rsi
movl $0x49c, %edx            # imm = 0x49C
callq 0x30f00
movq 0x98(%rbx), %rdi
callq 0x18e6df
movq 0xd0(%rbx), %rdi
movq %r14, %rsi
movl $0x49e, %edx            # imm = 0x49E
callq 0x30f00
movq 0xd8(%rbx), %rdi
movq %r14, %rsi
movl $0x49f, %edx            # imm = 0x49F
callq 0x30f00
movq 0x118(%rbx), %rdi
callq 0x2fbc0
movq 0x120(%rbx), %rdi
callq 0x2fbc0
movq 0xa0(%rbx), %rdi
callq 0x2ec90
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4a3, %edx            # imm = 0x4A3
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x30f00
movq 0x2172ab(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0xeaae1(%rip), %rsi     # 0x2de7f0
leaq 0x144d46(%rip), %rdx    # 0x338a5c
leaq 0x144d4d(%rip), %rcx    # 0x338a6a
leaq 0x144ca9(%rip), %r8     # 0x3389cd
movl $0x494, %r9d            # imm = 0x494
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/randomcodes-hpcorrect.c
// Function: gt_randomcodes_hpcorrect_compute_hscore
static inline gt_rchc_score_t
    gt_randomcodes_hpcorrect_compute_hscore(
    bool *identical, const uint8_t *hmer1, const uint8_t *hmer2,
    GtUword k)
{
  GtUword i;
  gt_rchc_score_t total_score = 0;
  gt_assert(identical != NULL);
  *identical = true;
  for (i = 0; i < k; i++)
  {
    uint8_t h1 = hmer1[i], h2 = hmer2[i];
    if (h1!=h2)
      *identical = false;
    if (h1 > GT_RCHC_HSCORE_MAXH)
      h1 = GT_RCHC_HSCORE_MAXH;
    if (h2 > GT_RCHC_HSCORE_MAXH)
      h2 = GT_RCHC_HSCORE_MAXH;
    total_score += gt_rchc_hscore[(GT_RCHC_HSCORE_MAXH+1)*h1+h2];
  }
  return total_score;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1f3daa
movb $0x1, (%rdi)
xorl %r8d, %r8d
pushq $0x9
popq %r9
leaq 0x14502e(%rip), %r10    # 0x338d90
xorl %eax, %eax
cmpq %r8, %rcx
je 0x1f3da3
movb (%rsi,%r8), %bl
movb (%rdx,%r8), %r11b
cmpb %r11b, %bl
je 0x1f3d79
movb $0x0, (%rdi)
movzbl %bl, %ebp
cmpb $0x9, %bl
cmovael %r9d, %ebp
movzbl %r11b, %ebx
cmpb $0x9, %r11b
cmovael %r9d, %ebx
imull $0xa, %ebp, %r11d
addb %bl, %r11b
movzbl %r11b, %r11d
addq (%r10,%r11,8), %rax
incq %r8
jmp 0x1f3d64
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x2171ff(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0xeaa35(%rip), %rsi     # 0x2de7f0
leaq 0x144da9(%rip), %rdx    # 0x338b6b
leaq 0x144db4(%rip), %rcx    # 0x338b7d
leaq 0x144bfd(%rip), %r8     # 0x3389cd
movl $0xe7, %r9d
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/randomcodes-hpcorrect.c
// Function: gt_randomcodes_hpcorrect_similar_rext
static inline bool gt_randomcodes_hpcorrect_similar_rext(
    GtRandomcodesHpcorrectData *sdata,
    GtUword u_sfx, GtUword u_kmerpos, int u_offset,
    GtUword t_sfx, GtUword t_kmerpos, int t_offset,
    gt_rchc_score_t minscore)
{
  return (gt_randomcodes_hpcorrect_same_rext_letters(sdata, u_kmerpos, u_offset,
        t_kmerpos, t_offset)) &&
    (gt_randomcodes_hpcorrect_compute_hscore_manhattan(NULL,
          GT_RANDOMCODES_HPCORRECT_HMER(sdata, u_sfx) + sdata->k + u_offset,
          GT_RANDOMCODES_HPCORRECT_HMER(sdata, t_sfx) + sdata->k + t_offset,
          (GtUword)sdata->r) >= minscore);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %r12d
movq %rsi, %r15
movq %rdi, %r14
movl 0x40(%rsp), %ebp
movq %rdx, %rsi
movl %ecx, %edx
movq %r9, %rcx
movl %ebp, %r8d
callq 0x1f3e60
testb %al, %al
je 0x1f3e4f
movq 0x48(%rsp), %r13
movq 0x20(%r14), %rax
movq 0x48(%r14), %rcx
imulq %rcx, %r15
addq 0x30(%r14), %rax
movl %r12d, %edi
addq %rax, %rdi
addq %r15, %rdi
imulq %rcx, %rbx
movl %ebp, %esi
addq %rax, %rsi
addq %rbx, %rsi
movl 0xcc(%r14), %edx
callq 0x1f3ec5
cmpq %r13, %rax
setge %al
jmp 0x1f3e51
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_O2/genometools[P]genometools/src/match/randomcodes-hpcorrect.c
// Function: gt_randomcodes_hpcorrect_same_rext_letters
static inline bool gt_randomcodes_hpcorrect_same_rext_letters(
    GtRandomcodesHpcorrectData *sdata, GtUword u_kmerpos, int u_offset,
    GtUword t_kmerpos, int t_offset)
{
  GtCommonunits commonunits;
  return (u_kmerpos + u_offset == t_kmerpos + t_offset) ||
      (gt_encseq_compare_viatwobitencoding(&commonunits,
        sdata->encseq, sdata->encseq, GT_READMODE_FORWARD, sdata->esr1,
        sdata->esr2, u_kmerpos + u_offset + sdata->k,
        t_kmerpos + t_offset + sdata->k, 0, (GtUword)sdata->r) == 0);
}

// Assembly:
movslq %edx, %r10
addq %rsi, %r10
movl %r8d, %esi
addq %rcx, %rsi
movb $0x1, %al
cmpq %rsi, %r10
je 0x1f3ec4
subq $0x38, %rsp
movq 0x118(%rdi), %r8
movq 0x120(%rdi), %r9
movq (%rdi), %rdx
movq 0x20(%rdi), %rax
addq %rax, %r10
addq %rax, %rsi
movl 0xcc(%rdi), %eax
movq %rax, 0x18(%rsp)
movq %rsi, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movq %r10, (%rsp)
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
xorl %ecx, %ecx
callq 0xc943e
testl %eax, %eax
sete %al
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/randomcodes-hpcorrect.c
// Function: gt_randomcodes_hpcorrect_compute_hscore_manhattan
static inline gt_rchc_score_t gt_randomcodes_hpcorrect_compute_hscore_manhattan(
    bool *identical, const uint8_t *hmer1, const uint8_t *hmer2,
    GtUword k)
{
  GtUword i;
  gt_rchc_score_t total_score = 0;
  if (identical != NULL)
    *identical = true;
  for (i = 0; i < k; i++)
  {
    uint8_t h1 = hmer1[i], h2 = hmer2[i];
    if (h1!=h2)
    {
      if (identical != NULL)
        *identical = false;
      total_score -= (h1 > h2 ? h1 - h2 : h2 - h1);
    }
  }
  return total_score;
}

// Assembly:
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rcx, %rdx
je 0x1f3efb
movzbl (%rdi,%rcx), %r8d
movzbl (%rsi,%rcx), %r9d
cmpb %r9b, %r8b
je 0x1f3ef6
movl %r8d, %r10d
subl %r9d, %r10d
movl %r9d, %r11d
subl %r8d, %r11d
cmpb %r9b, %r8b
cmoval %r10d, %r11d
movslq %r11d, %r8
subq %r8, %rax
incq %rcx
jmp 0x1f3ec9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc5cfe
testb %al, %al
je 0x244708
movq %r15, %rdi
callq 0xc7e90
imulq $0x18, %rax, %r14
leaq 0x105c5d(%rip), %rsi    # 0x34a2f4
pushq $0x2c
popq %rdx
movq %r14, %rdi
callq 0x2e5f0
movq %rax, %rbx
andl $-0x3, %ebp
xorl %esi, %esi
cmpl $0x1, %ebp
setne %sil
movq %r15, %rdi
callq 0xc5e48
movq %rax, %r15
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
xorl %ebp, %ebp
movq %r15, %rdi
movq %r12, %rsi
callq 0xc5ee3
testb %al, %al
je 0x2446f9
movq 0x8(%rsp), %rax
movq %rax, (%rbx,%r13)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rbx,%r13)
movq %rbp, 0x10(%rbx,%r13)
subq %rax, %rbp
addq %rcx, %rbp
addq $0x18, %r13
jmp 0x2446c6
cmpq %r13, %r14
jne 0x24471c
movq %r15, %rdi
callq 0xc6661
jmp 0x24470a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1c688d(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x9a0c3(%rip), %rsi     # 0x2de7f0
leaq 0x105bd8(%rip), %rdx    # 0x34a30c
leaq 0x105bfb(%rip), %rcx    # 0x34a336
leaq 0x105bb2(%rip), %r8     # 0x34a2f4
pushq $0x39
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/specialrank.c
// Function: gt_frompos2rank
GtUword gt_frompos2rank(const Rankedbounds *leftptr,
                              const Rankedbounds *rightptr,
                              GtUword specialpos)
{
  const Rankedbounds *midptr;

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

// Assembly:
pushq %rax
movq %rdx, %rcx
pushq $0x18
popq %r8
cmpq %rsi, %rdi
ja 0x24479c
movq %rsi, %rax
subq %rdi, %rax
cqto
idivq %r8
shrq %rax
imulq $0x18, %rax, %r9
leaq (%rdi,%r9), %rdx
movq %rcx, %rax
subq (%rdi,%r9), %rax
jb 0x24478d
cmpq %rcx, 0x8(%rdx)
ja 0x244796
addq $0x18, %rdx
movq %rdx, %rdi
jmp 0x24475a
addq $-0x18, %rdx
movq %rdx, %rsi
jmp 0x24475a
addq 0x10(%rdx), %rax
popq %rcx
retq
movq 0x1c680d(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x105b9b(%rip), %rsi    # 0x34a348
movq %rcx, %rdx
xorl %eax, %eax
callq 0x32960
pushq $0x2
popq %rdi
callq 0x2ed60
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdx, %rcx
pushq $0x18
popq %r8
cmpq %rsi, %rdi
ja 0x244815
movq %rsi, %rax
subq %rdi, %rax
cqto
idivq %r8
shrq %rax
imulq $0x18, %rax, %rax
leaq (%rdi,%rax), %rdx
movq 0x10(%rdi,%rax), %r9
movq %rcx, %rax
subq %r9, %rax
jb 0x244807
movq (%rdx), %rdi
addq 0x8(%rdx), %r9
subq %rdi, %r9
cmpq %rcx, %r9
ja 0x244810
addq $0x18, %rdx
movq %rdx, %rdi
jmp 0x2447c7
addq $-0x18, %rdx
movq %rdx, %rsi
jmp 0x2447c7
addq %rdi, %rax
popq %rcx
retq
movq 0x1c6794(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x105b4e(%rip), %rsi    # 0x34a374
movq %rcx, %rdx
xorl %eax, %eax
callq 0x32960
pushq $0x2
popq %rdi
callq 0x2ed60
// File: /workspace/github_c_makefile_star2_O2/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 0x1058a8(%rip), %rsi    # 0x34a511
pushq $0x30
popq %rdi
pushq $0x2a
popq %rdx
callq 0x2e5f0
movq %rax, %r15
movl %ebx, 0x20(%rax)
movq %r14, %rdi
callq 0x2fae0
movl %eax, 0x24(%r15)
movl %eax, %edi
movl %ebx, %esi
callq 0x1e7a1d
movq %rax, 0x28(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq