LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/esa-spmsk.c
// Function: gt_spmsk_inl_delete
GtUword gt_spmsk_inl_delete(GtBUstate_spmsk *state)
{
  if (state != NULL)
  {
    GtUword tmpcount;

    GT_FREEARRAY(&state->Wset,GtUword);
    GT_FREEARRAY(&state->Lset,GtUword);
    gt_GtArrayGtBUItvinfo_delete_spmsk(
                 (GtArrayGtBUItvinfo_spmsk *) state->stack,state);
    tmpcount = state->spmcounter;
    gt_free(state);
    return tmpcount;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1b0516
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x1b04a4
leaq 0x38(%rbx), %r14
leaq 0x1fe589(%rip), %rsi    # 0x3aea14
movl $0x9c, %edx
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x1b04d1
leaq 0x50(%rbx), %r14
leaq 0x1fe55c(%rip), %rsi    # 0x3aea14
movl $0x9d, %edx
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x68(%rbx), %r14
movq (%r14), %rdi
leaq 0x1fe514(%rip), %r15    # 0x3ae9f3
movq %r15, %rsi
movl $0x6b, %edx
callq 0x109670
movq %r14, %rdi
movq %r15, %rsi
movl $0x6c, %edx
callq 0x109670
movq 0x20(%rbx), %r14
leaq 0x1fe50d(%rip), %rsi    # 0x3aea14
movq %rbx, %rdi
movl $0xa1, %edx
callq 0x109670
jmp 0x1b0519
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/esa-spmsk.c
// Function: processleafedge_spmsk
static int processleafedge_spmsk(bool firstedge,
                                 GtUword fd,
                                 GtBUinfo_spmsk *finfo,
                                 GtUword seqnum,
                                 GtUword relpos,
                                 GtBUstate_spmsk *state,
                                 GT_UNUSED GtError *err)

{
  if (fd >= state->minmatchlength)
  {
    if (firstedge)
    {
      gt_assert(finfo != NULL);
      ((GtBUinfo_spmsk *) finfo)->firstinW = state->Wset.nextfreeGtUword;
    }
    if (relpos == 0)
    {
      GT_STOREINARRAY(&state->Wset,GtUword,128,seqnum);
    }
    if (relpos + fd == gt_encseq_seqlength(state->encseq,seqnum))
    {
      GT_STOREINARRAY(&state->Lset,GtUword,128,seqnum);
    }
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq %rsi, 0x18(%r9)
ja 0x1b0ad9
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r14
movq %rsi, %r12
testb %dil, %dil
je 0x1b0a1f
testq %rdx, %rdx
je 0x1b0ae5
movq 0x48(%rbx), %rax
movq %rax, (%rdx)
testq %r15, %r15
jne 0x1b0a77
movq 0x40(%rbx), %rax
cmpq %rax, 0x48(%rbx)
jb 0x1b0a5a
leaq 0x80(%rax), %rcx
movq %rcx, 0x40(%rbx)
movq 0x38(%rbx), %rdi
leaq 0x400(,%rax,8), %rsi
leaq 0x1fdfc8(%rip), %rdx    # 0x3aea14
movl $0x4d, %ecx
callq 0x1094e6
movq %rax, 0x38(%rbx)
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x1b0aef
movq 0x48(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x48(%rbx)
movq %r14, (%rax,%rcx,8)
addq %r12, %r15
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xeffd3
cmpq %rax, %r15
jne 0x1b0ad9
movq 0x58(%rbx), %rax
cmpq %rax, 0x60(%rbx)
jb 0x1b0ac0
leaq 0x80(%rax), %rcx
movq %rcx, 0x58(%rbx)
movq 0x50(%rbx), %rdi
leaq 0x400(,%rax,8), %rsi
leaq 0x1fdf62(%rip), %rdx    # 0x3aea14
movl $0x51, %ecx
callq 0x1094e6
movq %rax, 0x50(%rbx)
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0x1b0aea
movq 0x60(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x60(%rbx)
movq %r14, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x64ca6
callq 0x64c38
callq 0x64c6f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/esa-spmsk.c
// Function: processlcpinterval_spmsk
static int processlcpinterval_spmsk(GtUword lcp,
                                    GtBUinfo_spmsk *info,
                                    GtBUstate_spmsk *state,
                                    GT_UNUSED GtError *err)
{
  if (lcp >= state->minmatchlength)
  {
    GtUword lidx, widx, firstpos;

    gt_assert(info != NULL);
    firstpos = ((GtBUinfo_spmsk *) info)->firstinW;
    for (lidx = 0; lidx < state->Lset.nextfreeGtUword; lidx++)
    {
      if (state->outputspms)
      {
        GtUword lpos = state->Lset.spaceGtUword[lidx];

        for (widx = firstpos; widx < state->Wset.nextfreeGtUword; widx++)
        {
          printf(GT_WU " " GT_WU " " GT_WU "\n",lpos,
                 state->Wset.spaceGtUword[widx],lcp);
        }
      } else
      {
        gt_assert(state->countspms);
        if (firstpos < state->Wset.nextfreeGtUword)
        {
          state->spmcounter += state->Wset.nextfreeGtUword - firstpos;
        }
      }
    }
    state->Lset.nextfreeGtUword = 0;
  } else
  {
    state->Wset.nextfreeGtUword = 0;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl $0x48, %eax
cmpq %rdi, 0x18(%rdx)
ja 0x1b0b9b
testq %rsi, %rsi
je 0x1b0bb7
movl $0x60, %eax
cmpq $0x0, 0x60(%rbx)
je 0x1b0b9b
movq %rdi, %r14
movq (%rsi), %rax
movq %rax, (%rsp)
leaq 0x1fd061(%rip), %r15    # 0x3adb98
xorl %r13d, %r13d
cmpb $0x1, 0x31(%rbx)
jne 0x1b0b79
movq (%rsp), %rax
cmpq 0x48(%rbx), %rax
jae 0x1b0b8d
movq 0x50(%rbx), %rax
movq (%rax,%r13,8), %r12
movq (%rsp), %rbp
movq 0x38(%rbx), %rax
movq (%rax,%rbp,8), %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x17070
incq %rbp
cmpq 0x48(%rbx), %rbp
jb 0x1b0b56
jmp 0x1b0b8d
cmpb $0x0, 0x30(%rbx)
je 0x1b0bb2
movq 0x48(%rbx), %rax
subq (%rsp), %rax
jbe 0x1b0b8d
addq %rax, 0x20(%rbx)
incq %r13
cmpq 0x60(%rbx), %r13
jb 0x1b0b3a
movl $0x60, %eax
movq $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x64cdd
callq 0x64d14
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/esa_spmitvs_visitor.c
// Function: gt_esa_spmitvs_visitor_delete
void gt_esa_spmitvs_visitor_delete(GtESAVisitor *ev)
{
  GtESASpmitvsVisitor *esv;
  gt_assert(ev);
  esv = gt_esa_spmitvs_visitor_cast(ev);
  gt_free(esv->wholeleafcount);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1b0c73
movq %rdi, %rbx
callq 0x1b0c78
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1b1141
movq 0x40(%rax), %rdi
leaq 0x1fdee0(%rip), %rsi    # 0x3aeb48
movl $0x9f, %edx
popq %rbx
jmp 0x109670
callq 0x64d4b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/esa_spmitvs_visitor.c
// Function: gt_esa_spmitvs_visitor_class
const GtESAVisitorClass* gt_esa_spmitvs_visitor_class()
{
  static const GtESAVisitorClass *esc = NULL;
  gt_class_alloc_lock_enter();
  if (!esc) {
    esc = gt_esa_visitor_class_new(sizeof (GtESASpmitvsVisitor),
                                   gt_esa_spmitvs_visitor_delete,
                                   gt_esa_spmitvs_visitor_processleafedge,
                                   gt_esa_spmitvs_visitor_processbranchingedge,
                                   gt_esa_spmitvs_visitor_processlcpinterval,
                                   NULL,
                                   NULL);
  }
  gt_class_alloc_lock_leave();
  return esc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x318c92(%rip)    # 0x4c9918
jne 0x1b0cc0
movq $0x0, (%rsp)
leaq -0x53(%rip), %rsi       # 0x1b0c44
leaq 0x30(%rip), %rdx        # 0x1b0cce
leaq 0xae(%rip), %rcx        # 0x1b0d53
leaq 0x15a(%rip), %r8        # 0x1b0e06
movl $0x58, %edi
xorl %r9d, %r9d
callq 0x1b10b0
movq %rax, 0x318c58(%rip)    # 0x4c9918
callq 0xe6a19
movq 0x318c4c(%rip), %rax    # 0x4c9918
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/esa_spmitvs_visitor.c
// Function: gt_esa_spmitvs_visitor_processleafedge
static int gt_esa_spmitvs_visitor_processleafedge(GtESAVisitor *ev,
                                                  GT_UNUSED bool firstsucc,
                                                  GtUword fd,
                                                  GT_UNUSED GtUword flb,
                                                  GT_UNUSED
                                                         GtESAVisitorInfo *info,
                                                  GtUword leafnumber,
                                                  GT_UNUSED GtError *err)

{
  GtESASpmitvsVisitor *esv;
  gt_assert(ev);
  esv = gt_esa_spmitvs_visitor_cast(ev);

  if (gt_esa_spmitvs_visitor_iswholeleaf(esv->encseq,esv->readmode,leafnumber))
  {
    gt_assert(esv->currentleafindex != esv->totallength);
    esv->lastwholeleaf = esv->currentleafindex;
  } else
  {
    if (leafnumber + fd < esv->totallength &&
        !gt_encseq_position_is_separator(esv->encseq,
                                         leafnumber + fd,
                                         esv->readmode))
    {
      esv->unnecessaryleaves++;
    }
  }
  esv->currentleafindex++;
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1b0d49
movq %r9, %r14
movq %rdx, %r15
movq %rdi, %rbx
callq 0x1b0c78
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1b1141
movq %rax, %rbx
testq %r14, %r14
je 0x1b0d0d
movl 0x50(%rbx), %edx
movq 0x48(%rbx), %rdi
leaq -0x1(%r14), %rsi
callq 0xec754
testb %al, %al
je 0x1b0d27
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
je 0x1b0d4e
movq %rax, 0x28(%rbx)
incq 0x20(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
addq %r15, %r14
cmpq 0x18(%rbx), %r14
jae 0x1b0d1b
movq 0x48(%rbx), %rdi
movl 0x50(%rbx), %edx
movq %r14, %rsi
callq 0xec754
testb %al, %al
jne 0x1b0d1b
incq 0x10(%rbx)
jmp 0x1b0d1b
callq 0x64dbb
callq 0x64d84
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/esa_spmitvs_visitor.c
// Function: gt_esa_spmitvs_visitor_processbranchingedge
static int gt_esa_spmitvs_visitor_processbranchingedge(GtESAVisitor *ev,
                                                    GT_UNUSED bool firstsucc,
                                                    GtUword fd,
                                                    GT_UNUSED GtUword flb,
                                                    GT_UNUSED
                                                        GtESAVisitorInfo *finfo,
                                                    GtUword sd,
                                                    GtUword slb,
                                                    GtUword srb,
                                                    GT_UNUSED
                                                        GtESAVisitorInfo *sinfo,
                                                    GT_UNUSED GtError *err)
{
  GtESASpmitvsVisitor *esv;
  GtUword idx;
  gt_assert(ev);
  esv = gt_esa_spmitvs_visitor_cast(ev);

  for (idx=fd+1; idx<sd; idx++)
  {
    gt_assert(idx <= esv->maxlen);
    if (esv->lastwholeleaf != esv->totallength &&
        esv->lastwholeleaf >= slb)
    {
      gt_assert(esv->lastwholeleaf <= srb);
      esv->wholeleafcount[idx].wholeleaf++;
      esv->wholeleafcount[idx].wholeleafwidth += (srb - slb + 1);
    } else
    {
      esv->wholeleafcount[idx].nowholeleaf++;
      esv->wholeleafcount[idx].nowholeleafwidth += (srb - slb + 1);
    }
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1b0e01
movq %r9, %rbx
movq %rdx, %r14
movq %rdi, %r15
callq 0x1b0c78
movq %rax, %rdi
movq %r15, %rsi
callq 0x1b1141
leaq 0x1(%r14), %rcx
cmpq %rbx, %rcx
jae 0x1b0def
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rsi
movq 0x30(%rax), %rdi
movq %rdx, %r8
subq %rsi, %r8
incq %r8
shlq $0x5, %r14
addq $0x38, %r14
cmpq %rdi, %rcx
ja 0x1b0df7
movq 0x28(%rax), %r9
cmpq %rsi, %r9
jb 0x1b0dd4
cmpq 0x18(%rax), %r9
je 0x1b0dd4
cmpq %rdx, %r9
ja 0x1b0dfc
movq 0x40(%rax), %r9
incq -0x18(%r9,%r14)
movq %rcx, %r10
shlq $0x5, %r10
addq %r10, %r9
addq $0x8, %r9
jmp 0x1b0de0
movq 0x40(%rax), %r9
incq -0x8(%r9,%r14)
addq %r14, %r9
addq %r8, (%r9)
incq %rcx
addq $0x20, %r14
cmpq %rcx, %rbx
jne 0x1b0da2
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x64e29
callq 0x64df2
callq 0x64e60
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/esa_spmitvs_visitor.c
// Function: gt_esa_spmitvs_visitor_processlcpinterval
static int gt_esa_spmitvs_visitor_processlcpinterval(GtESAVisitor *ev,
                                                     GtUword lcp,
                                                     GtUword lb,
                                                     GtUword rb,
                                                     GT_UNUSED
                                                         GtESAVisitorInfo *info,
                                                     GT_UNUSED GtError *err)
{
  GtESASpmitvsVisitor *esv;
  gt_assert(ev);
  esv = gt_esa_spmitvs_visitor_cast(ev);

  if (esv->lastwholeleaf != esv->totallength &&
      esv->lastwholeleaf >= lb)
  {
    gt_assert(lcp <= (GtUword) esv->maxlen);
    gt_assert(esv->lastwholeleaf <= rb);
    esv->wholeleafcount[lcp].wholeleaf++;
    esv->wholeleafcount[lcp].wholeleafwidth += (rb - lb + 1);
  } else
  {
    esv->wholeleafcount[lcp].nowholeleaf++;
    esv->wholeleafcount[lcp].nowholeleafwidth += (rb - lb + 1);
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1b0e8a
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x1b0c78
movq %rax, %rdi
movq %r12, %rsi
callq 0x1b1141
movq 0x28(%rax), %rcx
cmpq %r14, %rcx
jb 0x1b0e5a
cmpq 0x18(%rax), %rcx
je 0x1b0e5a
cmpq %r15, 0x30(%rax)
jb 0x1b0e8f
cmpq %rbx, %rcx
ja 0x1b0e94
movq 0x40(%rax), %rax
shlq $0x5, %r15
addq %r15, %rax
addq $0x8, %rax
jmp 0x1b0e69
movq 0x40(%rax), %rax
shlq $0x5, %r15
addq %r15, %rax
addq $0x18, %rax
incq -0x8(%rax)
movq (%rax), %rcx
subq %r14, %rbx
addq %rbx, %rcx
incq %rcx
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x64f09
callq 0x64ed0
callq 0x64e97
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/esa_spmitvs_visitor.c
// Function: gt_esa_spmitvs_visitor_new
GtESAVisitor* gt_esa_spmitvs_visitor_new(const GtEncseq *encseq,
                                         GtReadmode readmode,
                                         unsigned int prefixlength,
                                         GT_UNUSED GtError *err)
{
  GtESAVisitor *ev = gt_esa_visitor_create(gt_esa_spmitvs_visitor_class());
  GtESASpmitvsVisitor *esv = gt_esa_spmitvs_visitor_cast(ev);

  esv->encseq = encseq;
  esv->readmode = readmode;
  esv->maxlen = gt_encseq_max_seq_length(encseq);
  esv->unnecessaryleaves = 0;
  esv->totallength = gt_encseq_total_length(encseq);
  esv->currentleafindex = 0;
  esv->lastwholeleaf = esv->totallength; /* undefined */
  esv->prefixlength = prefixlength;
  esv->wholeleafcount = gt_malloc(sizeof (*esv->wholeleafcount) *
                                 (esv->maxlen+1));
  memset(esv->wholeleafcount, 0,
         sizeof (*esv->wholeleafcount) * (esv->maxlen+1));

  return ev;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r15
callq 0x1b0c78
movq %rax, %rdi
callq 0x1b1110
movq %rax, %rbx
callq 0x1b0c78
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1b1141
movq %rax, %r14
movq %r15, 0x48(%rax)
movl %r12d, 0x50(%rax)
movq %r15, %rdi
callq 0xf035e
movq %rax, 0x30(%r14)
xorl %r12d, %r12d
movq %r12, 0x10(%r14)
movq %r15, %rdi
callq 0xec1d8
movq %rax, 0x18(%r14)
movq %r12, 0x20(%r14)
movq %rax, 0x28(%r14)
movl %ebp, 0x38(%r14)
movq 0x30(%r14), %rdi
shlq $0x5, %rdi
addq $0x20, %rdi
leaq 0x1fdc36(%rip), %rsi    # 0x3aeb48
movl $0xc4, %edx
callq 0x1092b2
movq %rax, 0x40(%r14)
movq 0x30(%r14), %rdx
shlq $0x5, %rdx
addq $0x20, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x173a0
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/esa_visitor.c
// Function: gt_esa_visitor_class_new
const GtESAVisitorClass*
gt_esa_visitor_class_new(size_t size,
                         GtESAVisitorFreeFunc free,
                         GtESAVisitorLeafEdgeFunc leafedge_func,
                         GtESAVisitorBranchingEdgeFunc branchingedge_func,
                         GtESAVisitorLCPIntervalFunc lcpinterval_func,
                         GtESAVisitorInfoCreatorFunc create_info_func,
                         GtESAVisitorInfoDestructorFunc delete_info_func)
{
  GtESAVisitorClass *c_class;
  gt_assert(size);
  c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->free = free;
  c_class->leafedge_func = leafedge_func;
  c_class->branchingedge_func = branchingedge_func;
  c_class->lcpinterval_func = lcpinterval_func;
  c_class->create_info_func = create_info_func;
  c_class->delete_info_func = delete_info_func;
  return c_class;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1b110b
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movl $0x38, %edi
callq 0x301854
movq %rbp, (%rax)
movq %r13, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x64f42
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/esa_visitor.c
// Function: gt_esa_visitor_create
GtESAVisitor* gt_esa_visitor_create(const GtESAVisitorClass *evc)
{
  GtESAVisitor *ev;
  gt_assert(evc && evc->size);
  ev = gt_calloc((size_t) 1, evc->size);
  ev->c_class = evc;
  return ev;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1b113c
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x1b113c
leaq 0x1fdbb3(%rip), %rdx    # 0x3aecdb
movl $0x1, %edi
movl $0x3f, %ecx
callq 0x1093ef
movq %rbx, (%rax)
popq %rbx
retq
callq 0x64f79
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/esa_visitor.c
// Function: gt_esa_visitor_info_new
GtESAVisitorInfo* gt_esa_visitor_info_new(GtESAVisitor *ev)
{
  gt_assert(ev && ev->c_class);
  if (ev->c_class->create_info_func != NULL)
    return ev->c_class->create_info_func(ev);
  return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x1b1175
movq (%rdi), %rax
testq %rax, %rax
je 0x1b1175
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x1b1172
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x64fe7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/esa_visitor.c
// Function: gt_esa_visitor_visit_leaf_edge
int gt_esa_visitor_visit_leaf_edge(GtESAVisitor *ev,
                                   bool firstsucc,
                                   GtUword fd,
                                   GtUword flb,
                                   GtESAVisitorInfo *info,
                                   GtUword leafnumber,
                                   GtError *err)
{
  gt_error_check(err);
  gt_assert(ev && ev->c_class);
  if (ev->c_class->leafedge_func != NULL)
    return ev->c_class->leafedge_func(ev, firstsucc, fd, flb, info, leafnumber,
                                      err);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r13
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1b11c9
callq 0x101a9a
testb %al, %al
jne 0x1b1219
testq %r13, %r13
je 0x1b1214
movq (%r13), %rax
testq %rax, %rax
je 0x1b1214
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x1b1203
movzbl %bpl, %esi
movq %r13, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x6508c
callq 0x65055
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/esa_visitor.c
// Function: gt_esa_visitor_visit_branching_edge
int gt_esa_visitor_visit_branching_edge(GtESAVisitor *ev,
                                        bool firstsucc,
                                        GtUword fd,
                                        GtUword flb,
                                        GtESAVisitorInfo *finfo,
                                        GtUword sd,
                                        GtUword slb,
                                        GtUword srb,
                                        GtESAVisitorInfo *sinfo,
                                        GtError *err)
{
  gt_error_check(err);
  gt_assert(ev && ev->c_class);
  if (ev->c_class->branchingedge_func != NULL)
    return ev->c_class->branchingedge_func(ev, firstsucc, fd, flb, finfo, sd,
                                           slb, srb, sinfo, err);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r13
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x1b124d
callq 0x101a9a
testb %al, %al
jne 0x1b129d
testq %r13, %r13
je 0x1b1298
movq (%r13), %rax
testq %rax, %rax
je 0x1b1298
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x1b1287
movzbl %bpl, %esi
movq %r13, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x650fa
callq 0x650c3
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/esa_visitor.c
// Function: gt_esa_visitor_visit_lcp_interval
int gt_esa_visitor_visit_lcp_interval(GtESAVisitor *ev,
                                      GtUword lcp,
                                      GtUword lb,
                                      GtUword rb,
                                      GtESAVisitorInfo *info,
                                      GtError *err)
{
  gt_error_check(err);
  gt_assert(ev && ev->c_class);
  if (ev->c_class->lcpinterval_func != NULL)
    return ev->c_class->lcpinterval_func(ev, lcp, lb, rb, info, err);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
testq %r9, %r9
je 0x1b12d0
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x1b131f
testq %rbp, %rbp
je 0x1b131a
movq (%rbp), %rax
testq %rax, %rax
je 0x1b131a
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x1b1309
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x6516a
callq 0x65131
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/esa_visitor.c
// Function: gt_esa_visitor_delete
void gt_esa_visitor_delete(GtESAVisitor *ev)
{
  if (!ev) return;
  gt_assert(ev->c_class);
  if (ev->c_class->free != NULL)
    ev->c_class->free(ev);
  gt_free(ev);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1b1358
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x1b135a
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x1b1343
movq %rbx, %rdi
callq *%rax
leaq 0x1fd991(%rip), %rsi    # 0x3aecdb
movq %rbx, %rdi
movl $0x91, %edx
popq %rbx
jmp 0x109670
popq %rbx
retq
callq 0x651a3
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/firstcodes-scan.c
// Function: gt_firstcodes_kmerscan_eqlen
GtUword gt_firstcodes_kmerscan_eqlen(const GtBitsequence *twobitencoding,
                                           bool withcheck,
                                           GtUword equallength,
                                           GtUword totallength,
                                           GtUword numofsequences,
                                           GtUword maxunitindex,
                                           unsigned int kmersize,
                                           unsigned int minmatchlength,
                                           GtProcesskmercode processcode,
                                           void *data)
{
  GtUword startpos, encodingsum = 0, fseqnum;

  if (equallength >= (GtUword) minmatchlength)
  {
    for (startpos = 0, fseqnum = 0; startpos < totallength;
         startpos += equallength+1, fseqnum++)
    {
      encodingsum += (GtUword) gt_firstcodes_kmerscan_range(
                                                  twobitencoding,
                                                  withcheck,
                                                  kmersize,
                                                  minmatchlength,
                                                  startpos,
                                                  startpos + equallength,
                                                  fseqnum,
                                                  numofsequences - 1 - fseqnum,
                                                  maxunitindex,
                                                  processcode,
                                                  data);
    }
  }
  return encodingsum;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movl 0x58(%rsp), %r9d
movq %rdx, (%rsp)
cmpq %rdx, %r9
seta %al
testq %rcx, %rcx
sete %dl
orb %al, %dl
jne 0x1b13f8
movq %r8, %r14
movq %rdi, %rbp
movq (%rsp), %rax
incq %rax
movq %rax, 0x8(%rsp)
decq %r14
xorl %ebx, %ebx
xorl %r15d, %r15d
xorl %r13d, %r13d
movq %rcx, 0x10(%rsp)
movq (%rsp), %rax
leaq (%rax,%rbx), %r8
movq %rbp, %rdi
movl 0x50(%rsp), %esi
movl %r9d, %edx
movq %rbx, %rcx
movq %r15, %r9
pushq 0x68(%rsp)
pushq 0x68(%rsp)
pushq %r12
pushq %r14
callq 0x1b140d
movl 0x78(%rsp), %r9d
movq 0x30(%rsp), %rcx
addq $0x20, %rsp
addq %rax, %r13
incq %r15
decq %r14
addq 0x8(%rsp), %rbx
cmpq %rcx, %rbx
jb 0x1b13ac
jmp 0x1b13fb
xorl %r13d, %r13d
movq %r13, %rax
addq $0x18, %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/firstcodes.c
// Function: gt_firstcodes_find_insert
const GtUword *gt_firstcodes_find_insert(const GtFirstcodesinfo *fci,
                                               GtUword code)
{
  const GtUword *found = NULL, *leftptr = NULL, *midptr, *rightptr = NULL;

  leftptr = fci->allfirstcodes + fci->currentminindex;
  rightptr = fci->allfirstcodes + fci->currentmaxindex;
  while (leftptr <= rightptr)
  {
    midptr = leftptr + GT_DIV2((GtUword) (rightptr-leftptr));
    if (code < *midptr)
    {
      rightptr = midptr - 1;
      found = midptr;
    } else
    {
      if (code > *midptr)
      {
        leftptr = midptr + 1;
      } else
      {
        return midptr;
      }
    }
  }
  return found;
}

// Assembly:
movq 0x28(%rdi), %rax
movq 0x30(%rdi), %rcx
cmpq %rcx, %rax
jle 0x1b360c
xorl %eax, %eax
retq
movq 0x98(%rdi), %rdx
leaq (%rdx,%rcx,8), %rcx
leaq (%rdx,%rax,8), %rdx
xorl %edi, %edi
movq %rcx, %r8
subq %rdx, %r8
sarq %r8
andq $-0x8, %r8
leaq (%rdx,%r8), %rax
cmpq %rsi, (%rdx,%r8)
jbe 0x1b363d
leaq -0x8(%rax), %rcx
movq %rax, %rdi
jmp 0x1b3649
jae 0x1b364e
movq %rax, %rdx
addq $0x8, %rdx
movq %rdi, %rax
cmpq %rcx, %rdx
jbe 0x1b361d
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/firstcodes.c
// Function: gt_firstcodes_idx2code
static GtUword gt_firstcodes_idx2code(const GtFirstcodesinfo *fci,
                                            GtUword idx)
{
  gt_assert(idx <= fci->differentcodes);
  if (idx == fci->differentcodes)
  {
    return fci->allfirstcodes[idx-1];
  }
  return fci->allfirstcodes[idx];
}

// Assembly:
cmpq %rsi, 0x38(%rdi)
jb 0x1b5784
setne %al
shlq $0x3, %rsi
addq 0x98(%rdi), %rsi
movzbl %al, %eax
movq -0x8(%rsi,%rax,8), %rax
retq
pushq %rax
callq 0x65835
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/firstcodes.c
// Function: gt_firstcode_delete_before_end
static void gt_firstcode_delete_before_end(GtFirstcodesinfo *fci)
{
  gt_firstcodes_binsearchcache_delete(fci->binsearchcache,fci->fcsl);
  if (fci->radixsort_codepos != NULL)
  {
    gt_radixsort_delete(fci->radixsort_codepos);
    GT_FCI_SUBTRACTWORKSPACE(fci->fcsl,"radixsort_codepos");
    fci->radixsort_codepos = NULL;
  }
  if (fci->mappedmarkprefix != NULL)
  {
    gt_Sfxmappedrange_delete(fci->mappedmarkprefix);
    gt_marksubstring_delete(fci->buf.markprefix,true);
  } else
  {
    gt_marksubstring_delete(fci->buf.markprefix,true);
    if (fci->buf.markprefix != NULL)
    {
      GT_FCI_SUBTRACTSPLITSPACE(fci->fcsl,"markprefix");
    }
  }
  fci->buf.markprefix = NULL;
  gt_marksubstring_delete(fci->buf.marksuffix,true);
  if (fci->buf.marksuffix != NULL)
  {
    GT_FCI_SUBTRACTWORKSPACE(fci->fcsl,"marksuffix");
  }
  fci->buf.marksuffix = NULL;
  if (fci->mappedallfirstcodes == NULL && fci->allfirstcodes != NULL)
  {
    gt_free(fci->allfirstcodes);
    fci->allfirstcodes = NULL;
    GT_FCI_SUBTRACTSPLITSPACE(fci->fcsl,"allfirstcodes");
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
movq 0xa8(%rbx), %rsi
callq 0x31e4af
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x1b5a2c
callq 0x114bc7
movq 0xa8(%rbx), %rdi
xorl %r14d, %r14d
movq %r14, (%rsp)
leaq 0x1f95c9(%rip), %rdx    # 0x3aefd8
leaq 0x1f96f0(%rip), %r8     # 0x3af106
movl $0x261, %esi            # imm = 0x261
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x320ca8
movq %r14, 0x70(%rbx)
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x1b5a50
callq 0x1f8bb6
movq 0xd0(%rbx), %rdi
movl $0x1, %esi
callq 0x1c0876
jmp 0x1b5a97
movq 0xd0(%rbx), %rdi
movl $0x1, %esi
callq 0x1c0876
cmpq $0x0, 0xd0(%rbx)
je 0x1b5a97
movq 0xa8(%rbx), %rdi
movq $0x0, (%rsp)
leaq 0x1f9557(%rip), %rdx    # 0x3aefd8
leaq 0x1f985d(%rip), %r8     # 0x3af2e5
movl $0x26d, %esi            # imm = 0x26D
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x320ca8
movq $0x0, 0xd0(%rbx)
movq 0xd8(%rbx), %rdi
movl $0x1, %esi
callq 0x1c0876
cmpq $0x0, 0xd8(%rbx)
je 0x1b5aec
movq 0xa8(%rbx), %rdi
movq $0x0, (%rsp)
leaq 0x1f9505(%rip), %rdx    # 0x3aefd8
leaq 0x1f9816(%rip), %r8     # 0x3af2f0
movl $0x274, %esi            # imm = 0x274
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x320ca8
movq $0x0, 0xd8(%rbx)
cmpq $0x0, 0x88(%rbx)
jne 0x1b5b4e
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x1b5b4e
leaq 0x1f94c4(%rip), %r14    # 0x3aefd8
movq %r14, %rsi
movl $0x279, %edx            # imm = 0x279
callq 0x109670
xorl %eax, %eax
movq %rax, 0x98(%rbx)
movq 0xa8(%rbx), %rdi
movq %rax, (%rsp)
leaq 0x19dd32(%rip), %r8     # 0x35386e
movl $0x27b, %esi            # imm = 0x27B
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x320ca8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/firstcodes.c
// Function: gt_firstcodes_accumulatecounts_flush
static void gt_firstcodes_accumulatecounts_flush(void *data)
{
  GtFirstcodesinfo *fci = (GtFirstcodesinfo *) data;

  if (fci->buf.nextfree > 0)
  {
    GtUword foundindex, foundcode;

    gt_assert(fci->allfirstcodes != NULL);
    fci->codebuffer_total += fci->buf.nextfree;
    gt_radixsort_inplace_sort(fci->radixsort_code,fci->buf.nextfree);
    foundindex = gt_firstcodes_find_accu(&foundcode,
                                         fci->allfirstcodes,
                                         fci->allfirstcodes0_save,
                                         fci->differentcodes,
                                         fci->tab.differencemask,
                                         fci->binsearchcache,
                                         fci->buf.spaceGtUword[0]);
    if (foundindex != ULONG_MAX)
    {
      fci->firstcodehits
        += gt_firstcodes_accumulatecounts_merge(&fci->tab,
                                                fci->allfirstcodes,
                                                fci->differentcodes,
                                                fci->buf.spaceGtUword,
                                                fci->buf.spaceGtUword
                                                + fci->buf.nextfree - 1,
                                                foundindex,
                                                foundcode);
    }
    fci->flushcount++;
    fci->buf.nextfree = 0;
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0xc0(%rdi), %rsi
testq %rsi, %rsi
je 0x1b5c3e
movq %rdi, %rbx
cmpq $0x0, 0x98(%rdi)
je 0x1b5c44
addq %rsi, 0x20(%rbx)
movq 0x68(%rbx), %rdi
callq 0x115413
movq 0x98(%rbx), %rsi
movq 0xa0(%rbx), %rdx
movq 0x168(%rbx), %r8
movq 0x38(%rbx), %rcx
movq 0x48(%rbx), %r9
movq 0xf0(%rbx), %rax
movq (%rax), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x31e52e
cmpq $-0x1, %rax
je 0x1b5c30
leaq 0x110(%rbx), %rdi
movq 0x38(%rbx), %rdx
movq 0x98(%rbx), %rsi
movq 0xf0(%rbx), %rcx
movq 0xc0(%rbx), %r8
leaq -0x8(%rcx,%r8,8), %r8
movq 0x8(%rsp), %r9
movq %r9, (%rsp)
movq %rax, %r9
callq 0x32157b
addq %rax, (%rbx)
incl 0x50(%rbx)
movq $0x0, 0xc0(%rbx)
addq $0x10, %rsp
popq %rbx
retq
callq 0x65a2a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/firstcodes.c
// Function: gt_kmercode2prefix_index
static GtUword gt_kmercode2prefix_index(GtUword idx,
                                              const void *data)
{
  const GtFirstcodesinfo *fci = (const GtFirstcodesinfo *) data;

  gt_assert(fci != NULL && idx < fci->differentcodes);
  return (GtUword) fci->allfirstcodes[idx]
            >> (GtUword) fci->shiftright2index;
}

// Assembly:
testq %rsi, %rsi
je 0x1b5c96
cmpq %rdi, 0x38(%rsi)
jbe 0x1b5c96
movq 0x98(%rsi), %rax
movq (%rax,%rdi,8), %rax
movb 0x54(%rsi), %cl
shrq %cl, %rax
retq
pushq %rax
callq 0x65a63
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/firstcodes.c
// Function: gt_firstcodes_thread_caller_sortremaining
static void *gt_firstcodes_thread_caller_sortremaining(void *data)
{
  GtSortRemainingThreadinfo *threadinfo = (GtSortRemainingThreadinfo *) data;

  if (gt_firstcodes_sortremaining(threadinfo->srsw,
                                  threadinfo->encseq,
                                  threadinfo->readmode,
                                  threadinfo->spmsuftab,
                                  threadinfo->snrp,
                                  threadinfo->fct,
                                  threadinfo->minindex,
                                  threadinfo->maxindex,
                                  threadinfo->sumofwidth,
                                  threadinfo->spaceforbucketprocessing,
                                  threadinfo->depth,
                                  threadinfo->itvprocess,
                                  threadinfo->itvprocess_end,
                                  threadinfo->itvprocessdata,
                                  threadinfo->withsuftabcheck,
                                  threadinfo->err) != 0)
  {
    gt_assert(false);
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
movl 0x10(%rdi), %edx
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %r8
movq 0x28(%rdi), %r9
movups 0x38(%rdi), %xmm0
movups 0x48(%rdi), %xmm1
movq 0x30(%rdi), %r10
movq 0x60(%rdi), %r11
movq 0x68(%rdi), %rbx
movq 0x70(%rdi), %r14
movzbl 0x58(%rdi), %ebp
movq 0x78(%rdi), %rdi
movq %rdi, 0x48(%rsp)
movl %ebp, 0x40(%rsp)
movq %r14, 0x38(%rsp)
movq %rbx, 0x30(%rsp)
movq %r11, 0x28(%rsp)
movq %r10, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rax, %rdi
callq 0x1b5c9c
testl %eax, %eax
jne 0x1b6015
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x65c9b
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/fmi-fwduni.c
// Function: gt_skfmuniqueforward
GtUword gt_skfmuniqueforward (const void *genericindex,
                                 GT_UNUSED GtUword offset,
                                 GT_UNUSED GtUword left,
                                 GT_UNUSED GtUword right,
                                 GT_UNUSED GtUword *witnessposition,
                                 const GtUchar *qstart,
                                 const GtUchar *qend)
{
  GtUchar cc;
  const GtUchar *qptr;
  GtUwordBound bwtbound;
  const Fmindex *fmindex = (Fmindex *) genericindex;

  gt_assert(qstart < qend);
  qptr = qstart;
  cc = *qptr++;
  if (GT_ISSPECIAL(cc))
  {
    return 0;
  }
  bwtbound.lbound = fmindex->tfreq[cc];
  bwtbound.ubound = fmindex->tfreq[cc+1];
  while (qptr < qend && bwtbound.lbound + 1 < bwtbound.ubound)
  {
    cc = *qptr;
    if (GT_ISSPECIAL (cc))
    {
      return 0;
    }
    bwtbound.lbound = fmindex->tfreq[cc] +
                      fmoccurrence (fmindex, cc, bwtbound.lbound);
    bwtbound.ubound = fmindex->tfreq[cc] +
                      fmoccurrence (fmindex, cc, bwtbound.ubound);
    qptr++;
  }
  if (bwtbound.lbound + 1 == bwtbound.ubound)
  {
    return (GtUword) (qptr - qstart);
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, (%rsp)
cmpq 0x50(%rsp), %r9
jae 0x1b6103
movzbl (%r9), %eax
cmpq $0xfd, %rax
ja 0x1b60f2
movq (%rsp), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx,%rax,8), %r13
movq 0x8(%rcx,%rax,8), %r14
movq %r9, 0x8(%rsp)
leaq 0x1(%r9), %rcx
leaq 0x1(%r13), %rax
cmpq 0x50(%rsp), %rcx
jae 0x1b60e3
cmpq %r14, %rax
jae 0x1b60e3
movq (%rsp), %r12
movzbl (%rcx), %ebp
cmpq $0xfd, %rbp
ja 0x1b60f2
movq 0x18(%r12), %rax
leal (,%rbp,8), %r15d
movq (%rax,%r15), %rbx
movq %r12, %rdi
movl %ebp, %esi
movq %r13, %rdx
movq %rcx, 0x10(%rsp)
callq 0x1b6108
movq %rax, %r13
movq 0x18(%r12), %rax
movq (%rax,%r15), %r15
movq %r12, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x1b6108
movq 0x10(%rsp), %rcx
movq %rax, %r14
addq %r15, %r14
incq %rcx
leaq (%rbx,%r13), %rax
incq %rax
cmpq 0x50(%rsp), %rcx
jae 0x1b60e3
addq %rbx, %r13
cmpq %r14, %rax
jb 0x1b6077
cmpq %r14, %rax
jne 0x1b60f2
subq 0x8(%rsp), %rcx
movq %rcx, %rax
jmp 0x1b60f4
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x65cd4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/fmi-map.c
// Function: gt_freefmindex
void gt_freefmindex(Fmindex *fmindex)
{
  if (fmindex->mappedptr != NULL)
  {
    gt_fa_xmunmap(fmindex->mappedptr);
  }
  if (fmindex->bwtformatching != NULL)
  {
    gt_encseq_delete(fmindex->bwtformatching);
    fmindex->bwtformatching = NULL;
  }
  gt_alphabet_delete((GtAlphabet *) fmindex->alphabet);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x1b688a
callq 0x102b12
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1b689e
callq 0xee90c
movq $0x0, (%rbx)
movq 0x68(%rbx), %rdi
popq %rbx
jmp 0xd335d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/fmi-mapspec.c
// Function: gt_flushfmindex2file
int gt_flushfmindex2file(FILE *fp,
                         Fmindex *fmindex,
                         bool storeindexpos,
                         GtError *err)
{
  Fmindexwithoptions fmwithoptions;

  gt_error_check(err);
  fmwithoptions.fmptr = fmindex;
  fmwithoptions.storeindexpos = storeindexpos;
  return gt_mapspec_write(assignfmmapspecification,fp,
                          (void *) &fmwithoptions,fmindex->sizeofindex,err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
testq %rcx, %rcx
je 0x1b6e2a
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x1b6e5a
leaq 0x8(%rsp), %rdx
movq %r15, (%rdx)
movb %bpl, 0x8(%rdx)
movq 0xa0(%r15), %rcx
leaq 0x1b(%rip), %rdi        # 0x1b6e5f
movq %r14, %rsi
movq %rbx, %r8
callq 0x10a125
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x65e90
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/fmi-mapspec.c
// Function: assignfmmapspecification
static void assignfmmapspecification(GtMapspec *mapspec,
                                     void *data,
                                     GT_UNUSED bool writemode)
{
  Fmindexwithoptions *fmwithoptions = (Fmindexwithoptions *) data;
  Fmindex *fmindex;

  fmindex = fmwithoptions->fmptr;
  gt_mapspec_add_ulong(mapspec, fmindex->tfreq,
                       (GtUword) TFREQSIZE(fmindex->mapsize));
  gt_mapspec_add_ulong(mapspec, fmindex->superbfreq,
                       (GtUword) SUPERBFREQSIZE(fmindex->mapsize,
                                                      fmindex->nofsuperblocks));
  gt_mapspec_add_ulong(mapspec, fmindex->markpostable,
                       fmwithoptions->storeindexpos
                       ? (GtUword) MARKPOSTABLELENGTH(fmindex->bwtlength,
                                                            fmindex->markdist)
                       : 0);
  gt_mapspec_add_ulongbound(mapspec, fmindex->boundarray,
                            (GtUword) fmindex->numofcodes);
  gt_mapspec_add_pairbwtindex(mapspec, fmindex->specpos.spaceGtPairBwtidx,
                              fmwithoptions->storeindexpos
                              ? fmindex->specpos.nextfreeGtPairBwtidx
                              : 0);
  gt_mapspec_add_uchar(mapspec, fmindex->bfreq,
                (GtUword) BFREQSIZE(fmindex->mapsize,fmindex->nofblocks));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
leaq 0x18(%r15), %rsi
movl 0x78(%r15), %edx
incl %edx
callq 0x10a4c9
leaq 0x20(%r15), %rsi
movl 0x78(%r15), %edx
imulq 0xb0(%r15), %rdx
movq %rbx, %rdi
callq 0x10a4c9
leaq 0x28(%r15), %rsi
cmpb $0x1, 0x8(%r14)
jne 0x1b6eb7
movq 0x10(%r15), %rax
decq %rax
xorl %edx, %edx
divq 0xb8(%r15)
movq %rax, %rdx
incq %rdx
jmp 0x1b6eb9
xorl %edx, %edx
movq %rbx, %rdi
callq 0x10a4c9
leaq 0xc8(%r15), %rsi
movq 0xc0(%r15), %rdx
movq %rbx, %rdi
callq 0x10a568
cmpb $0x1, 0x8(%r14)
jne 0x1b6ee4
movq 0x60(%r15), %rdx
jmp 0x1b6ee6
xorl %edx, %edx
leaq 0x50(%r15), %rsi
movq %rbx, %rdi
callq 0x10aa60
movl 0x78(%r15), %edx
imulq 0xa8(%r15), %rdx
leaq 0x8(%r15), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10a38b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/fmi-mapspec.c
// Function: gt_fillfmmapspecstartptr
int gt_fillfmmapspecstartptr(Fmindex *fmindex,
                             bool storeindexpos,
                             const GtStr *tmpfilename,
                             GtError *err)
{
  Fmindexwithoptions fmwithoptions;

  gt_error_check(err);
  fmwithoptions.fmptr = fmindex;
  fmwithoptions.storeindexpos = storeindexpos;
  return gt_mapspec_read(assignfmmapspecification,
                         (void *) &fmwithoptions,
                         gt_str_get(tmpfilename),
                         fmindex->sizeofindex,
                         &fmindex->mappedptr,
                         err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
testq %rcx, %rcx
je 0x1b6f37
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x1b6f7b
movq %rsp, %r12
movq %r14, (%r12)
movb %bpl, 0x8(%r12)
movq %r15, %rdi
callq 0x120d23
movq 0xa0(%r14), %rcx
addq $0x70, %r14
leaq -0xfe(%rip), %rdi       # 0x1b6e5f
movq %r12, %rsi
movq %rax, %rdx
movq %r14, %r8
movq %rbx, %r9
callq 0x109e7f
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x65ec7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/ft-polish.c
// Function: polishing_info_new_with_bias
GtFtPolishing_info *polishing_info_new_with_bias(double errorpercentage,
                                                 double matchscore_bias,
                                                 GtUword history_size)
{
  GtFtPolishing_info *pol_info = gt_malloc(sizeof *pol_info);

  gt_assert(pol_info != NULL);
  if (history_size == 0)
  {
    pol_info->cut_depth = (GtUword) 15;
  } else
  {
    pol_info->cut_depth = GT_MIN(history_size/2,(GtUword) 15);
  }
  pol_info->pol_size = 2 * pol_info->cut_depth;
  pol_info->entries = 1UL << pol_info->cut_depth;
  pol_info->mask = pol_info->entries - 1;
  pol_info->values = gt_malloc(sizeof *pol_info->values * pol_info->entries);
  gt_assert(pol_info->values != NULL);
  pol_info->match_score = 20.0 * errorpercentage * matchscore_bias;
  gt_assert(pol_info->match_score <= 1000.0);
  pol_info->difference_score = 1000.0 - pol_info->match_score;
  fill_polishing_info(pol_info,0,0,0,0);
  return pol_info;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
leaq 0x1f7eab(%rip), %rsi    # 0x3b01c8
movl $0x38, %edi
movl $0x29, %edx
callq 0x1092b2
testq %rax, %rax
je 0x1b83ee
movq %rax, %rbx
movq %r14, %rcx
shrq %rcx
movl $0xf, %eax
cmpq %rax, %rcx
cmovaeq %rax, %rcx
testq %r14, %r14
cmoveq %rax, %rcx
movq %rcx, 0x8(%rbx)
leal (%rcx,%rcx), %eax
movq %rax, 0x10(%rbx)
movl $0x1, %eax
shlq %cl, %rax
movq %rax, (%rbx)
decq %rax
movq %rax, 0x18(%rbx)
movl $0x4, %edi
shlq %cl, %rdi
leaq 0x1f7e4b(%rip), %rsi    # 0x3b01c8
movl $0x36, %edx
callq 0x1092b2
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x1b83f3
movsd 0x10(%rsp), %xmm0
mulsd 0x1f7e22(%rip), %xmm0   # 0x3b01c0
mulsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, 0x28(%rbx)
cmpq $0x3e9, %rax            # imm = 0x3E9
jge 0x1b83f8
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd 0x1d52ab(%rip), %xmm1   # 0x38d670
subsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, 0x20(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1b83fd
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x661ec
callq 0x661b5
callq 0x6617e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/ft-polish.c
// Function: fill_polishing_info
static void fill_polishing_info(GtFtPolishing_info *pol_info,
                                GtUword currentdepth,
                                GtUword prefix, GtWord score, GtWord maxscore)
{
  gt_assert(currentdepth <= pol_info->cut_depth);
  if (currentdepth == pol_info->cut_depth)
  {
    gt_assert(prefix < pol_info->entries && score >= INT16_MIN + maxscore);
    pol_info->values[prefix].diff_from_max = (int16_t) (score - maxscore);
    pol_info->values[prefix].score_sum = (int16_t) score;
  } else
  {
    if (score > maxscore)
    {
      maxscore = score;
    }
    gt_assert(score >= INT16_MIN - pol_info->difference_score);
    fill_polishing_info(pol_info,currentdepth+1, prefix << 1,
                        score - pol_info->difference_score,maxscore);
    gt_assert(score <= INT16_MAX - pol_info->match_score);
    fill_polishing_info(pol_info,currentdepth+1,(prefix << 1) | 1UL,
                        score + pol_info->match_score,maxscore);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
movq 0x8(%r12), %rax
cmpq %r13, %rax
jb 0x1b84a9
je 0x1b8478
cmpq %r15, %rbx
cmovgq %rbx, %r15
movq 0x20(%r12), %rax
movq $-0x8000, %rcx          # imm = 0x8000
subq %rax, %rcx
cmpq %rbx, %rcx
jg 0x1b84ae
incq %r13
addq %r14, %r14
movq %rbx, %rcx
subq %rax, %rcx
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %r8
callq 0x1b83fd
movq 0x28(%r12), %rax
movl $0x7fff, %ecx           # imm = 0x7FFF
subq %rax, %rcx
cmpq %rbx, %rcx
jl 0x1b84b3
orq $0x1, %r14
addq %rax, %rbx
jmp 0x1b8415
cmpq %r14, (%r12)
jbe 0x1b84b8
leaq -0x8000(%r15), %rax
cmpq %rbx, %rax
jg 0x1b84b8
movl %ebx, %eax
subl %r15d, %eax
movq 0x30(%r12), %rcx
movw %ax, 0x2(%rcx,%r14,4)
movw %bx, (%rcx,%r14,4)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x662c8
callq 0x6625a
callq 0x66223
callq 0x66291