LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x1a8275
movq %r9, %rbx
movq %rdx, %r14
movq %rdi, %r15
callq 0x1a80ec
movq %rax, %rdi
movq %r15, %rsi
callq 0x1a85ad
leaq 0x1(%r14), %rcx
cmpq %rbx, %rcx
jae 0x1a8263
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 0x1a826b
movq 0x28(%rax), %r9
cmpq %rsi, %r9
jb 0x1a8248
cmpq 0x18(%rax), %r9
je 0x1a8248
cmpq %rdx, %r9
ja 0x1a8270
movq 0x40(%rax), %r9
incq -0x18(%r9,%r14)
movq %rcx, %r10
shlq $0x5, %r10
addq %r10, %r9
addq $0x8, %r9
jmp 0x1a8254
movq 0x40(%rax), %r9
incq -0x8(%r9,%r14)
addq %r14, %r9
addq %r8, (%r9)
incq %rcx
addq $0x20, %r14
cmpq %rcx, %rbx
jne 0x1a8216
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x636a1
callq 0x6366a
callq 0x636d8
// File: /workspace/github_c_makefile_star2_O3/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 0x1a82fe
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x1a80ec
movq %rax, %rdi
movq %r12, %rsi
callq 0x1a85ad
movq 0x28(%rax), %rcx
cmpq %r14, %rcx
jb 0x1a82ce
cmpq 0x18(%rax), %rcx
je 0x1a82ce
cmpq %r15, 0x30(%rax)
jb 0x1a8303
cmpq %rbx, %rcx
ja 0x1a8308
movq 0x40(%rax), %rax
shlq $0x5, %r15
addq %r15, %rax
addq $0x8, %rax
jmp 0x1a82dd
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 0x63781
callq 0x63748
callq 0x6370f
// File: /workspace/github_c_makefile_star2_O3/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 0x1a80ec
movq %rax, %rdi
callq 0x1a857c
movq %rax, %rbx
callq 0x1a80ec
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1a85ad
movq %rax, %r14
movq %r15, 0x48(%rax)
movl %r12d, 0x50(%rax)
movq %r15, %rdi
callq 0xebd5d
movq %rax, 0x30(%r14)
xorl %r12d, %r12d
movq %r12, 0x10(%r14)
movq %r15, %rdi
callq 0xe7b9c
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 0x1fd220(%rip), %rsi    # 0x3a55a6
movl $0xc4, %edx
callq 0x104226
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_O3/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 0x1a8577
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movl $0x38, %edi
callq 0x2f7c10
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 0x637ba
// File: /workspace/github_c_makefile_star2_O3/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 0x1a85a8
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x1a85a8
leaq 0x1fd1a5(%rip), %rdx    # 0x3a5739
movl $0x1, %edi
movl $0x3f, %ecx
callq 0x10436a
movq %rbx, (%rax)
popq %rbx
retq
callq 0x637f1
// File: /workspace/github_c_makefile_star2_O3/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 0x1a85e1
movq (%rdi), %rax
testq %rax, %rax
je 0x1a85e1
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x1a85de
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x6385f
// File: /workspace/github_c_makefile_star2_O3/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 0x1a8635
callq 0xfcc32
testb %al, %al
jne 0x1a8685
testq %r13, %r13
je 0x1a8680
movq (%r13), %rax
testq %rax, %rax
je 0x1a8680
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x1a866f
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 0x63904
callq 0x638cd
// File: /workspace/github_c_makefile_star2_O3/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 0x1a86b9
callq 0xfcc32
testb %al, %al
jne 0x1a8709
testq %r13, %r13
je 0x1a8704
movq (%r13), %rax
testq %rax, %rax
je 0x1a8704
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x1a86f3
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 0x63972
callq 0x6393b
// File: /workspace/github_c_makefile_star2_O3/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 0x1a873c
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1a878b
testq %rbp, %rbp
je 0x1a8786
movq (%rbp), %rax
testq %rax, %rax
je 0x1a8786
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x1a8775
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 0x639e2
callq 0x639a9
// File: /workspace/github_c_makefile_star2_O3/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 0x1a87c4
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x1a87c6
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x1a87af
movq %rbx, %rdi
callq *%rax
leaq 0x1fcf83(%rip), %rsi    # 0x3a5739
movq %rbx, %rdi
movl $0x91, %edx
popq %rbx
jmp 0x1045eb
popq %rbx
retq
callq 0x63a1b
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x1a8864
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 0x1a8879
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 0x1a8818
jmp 0x1a8867
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_O3/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 0x1aaa78
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 0x1aaaa9
leaq -0x8(%rax), %rcx
movq %rax, %rdi
jmp 0x1aaab5
jae 0x1aaaba
movq %rax, %rdx
addq $0x8, %rdx
movq %rdi, %rax
cmpq %rcx, %rdx
jbe 0x1aaa89
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1accd6
setne %al
shlq $0x3, %rsi
addq 0x98(%rdi), %rsi
movzbl %al, %eax
movq -0x8(%rsi,%rax,8), %rax
retq
pushq %rax
callq 0x640ad
// File: /workspace/github_c_makefile_star2_O3/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 0x314157
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x1acf6f
callq 0x10f61d
movq 0xa8(%rbx), %rdi
xorl %r14d, %r14d
movq %r14, (%rsp)
leaq 0x1f8ae2(%rip), %rdx    # 0x3a5a34
leaq 0x1f8c09(%rip), %r8     # 0x3a5b62
movl $0x261, %esi            # imm = 0x261
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x316945
movq %r14, 0x70(%rbx)
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x1acf93
callq 0x1ef400
movq 0xd0(%rbx), %rdi
movl $0x1, %esi
callq 0x1b7d90
jmp 0x1acfda
movq 0xd0(%rbx), %rdi
movl $0x1, %esi
callq 0x1b7d90
cmpq $0x0, 0xd0(%rbx)
je 0x1acfda
movq 0xa8(%rbx), %rdi
movq $0x0, (%rsp)
leaq 0x1f8a70(%rip), %rdx    # 0x3a5a34
leaq 0x1f8d76(%rip), %r8     # 0x3a5d41
movl $0x26d, %esi            # imm = 0x26D
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x316945
movq $0x0, 0xd0(%rbx)
movq 0xd8(%rbx), %rdi
movl $0x1, %esi
callq 0x1b7d90
cmpq $0x0, 0xd8(%rbx)
je 0x1ad02f
movq 0xa8(%rbx), %rdi
movq $0x0, (%rsp)
leaq 0x1f8a1e(%rip), %rdx    # 0x3a5a34
leaq 0x1f8d2f(%rip), %r8     # 0x3a5d4c
movl $0x274, %esi            # imm = 0x274
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x316945
movq $0x0, 0xd8(%rbx)
cmpq $0x0, 0x88(%rbx)
jne 0x1ad091
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x1ad091
leaq 0x1f89dd(%rip), %r14    # 0x3a5a34
movq %r14, %rsi
movl $0x279, %edx            # imm = 0x279
callq 0x1045eb
xorl %eax, %eax
movq %rax, 0x98(%rbx)
movq 0xa8(%rbx), %rdi
movq %rax, (%rsp)
leaq 0x19d7ce(%rip), %r8     # 0x34a84d
movl $0x27b, %esi            # imm = 0x27B
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x316945
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1ad181
movq %rdi, %rbx
cmpq $0x0, 0x98(%rdi)
je 0x1ad187
addq %rsi, 0x20(%rbx)
movq 0x68(%rbx), %rdi
callq 0x10fe4f
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 0x3141d6
cmpq $-0x1, %rax
je 0x1ad173
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 0x3171df
addq %rax, (%rbx)
incl 0x50(%rbx)
movq $0x0, 0xc0(%rbx)
addq $0x10, %rsp
popq %rbx
retq
callq 0x642a2
// File: /workspace/github_c_makefile_star2_O3/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 0x1ad1d9
cmpq %rdi, 0x38(%rsi)
jbe 0x1ad1d9
movq 0x98(%rsi), %rax
movq (%rax,%rdi,8), %rax
movb 0x54(%rsi), %cl
shrq %cl, %rax
retq
pushq %rax
callq 0x642db
// File: /workspace/github_c_makefile_star2_O3/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 0x1ad1df
testl %eax, %eax
jne 0x1ad54f
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x64513
// File: /workspace/github_c_makefile_star2_O3/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 0x1ad63b
movzbl (%r9), %eax
cmpq $0xfd, %rax
ja 0x1ad62a
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 0x1ad61b
cmpq %r14, %rax
jae 0x1ad61b
movq (%rsp), %r12
movzbl (%rcx), %ebp
cmpq $0xfd, %rbp
ja 0x1ad62a
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 0x1ad640
movq %rax, %r13
movq 0x18(%r12), %rax
movq (%rax,%r15), %r15
movq %r12, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x1ad640
movq 0x10(%rsp), %rcx
movq %rax, %r14
addq %r15, %r14
incq %rcx
leaq (%rbx,%r13), %rax
incq %rax
cmpq 0x50(%rsp), %rcx
jae 0x1ad61b
addq %rbx, %r13
cmpq %r14, %rax
jb 0x1ad5af
cmpq %r14, %rax
jne 0x1ad62a
subq 0x8(%rsp), %rcx
movq %rcx, %rax
jmp 0x1ad62c
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x6454c
// File: /workspace/github_c_makefile_star2_O3/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 0x1addbe
callq 0xfdc54
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1addd2
callq 0xea375
movq $0x0, (%rbx)
movq 0x68(%rbx), %rdi
popq %rbx
jmp 0xd0e1c
// File: /workspace/github_c_makefile_star2_O3/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 0x1ae32e
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1ae35e
leaq 0x8(%rsp), %rdx
movq %r15, (%rdx)
movb %bpl, 0x8(%rdx)
movq 0xa0(%r15), %rcx
leaq 0x1b(%rip), %rdi        # 0x1ae363
movq %r14, %rsi
movq %rbx, %r8
callq 0x105023
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x64708
// File: /workspace/github_c_makefile_star2_O3/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 0x1053cc
leaq 0x20(%r15), %rsi
movl 0x78(%r15), %edx
imulq 0xb0(%r15), %rdx
movq %rbx, %rdi
callq 0x1053cc
leaq 0x28(%r15), %rsi
cmpb $0x1, 0x8(%r14)
jne 0x1ae3bb
movq 0x10(%r15), %rax
decq %rax
xorl %edx, %edx
divq 0xb8(%r15)
movq %rax, %rdx
incq %rdx
jmp 0x1ae3bd
xorl %edx, %edx
movq %rbx, %rdi
callq 0x1053cc
leaq 0xc8(%r15), %rsi
movq 0xc0(%r15), %rdx
movq %rbx, %rdi
callq 0x105471
cmpb $0x1, 0x8(%r14)
jne 0x1ae3e8
movq 0x60(%r15), %rdx
jmp 0x1ae3ea
xorl %edx, %edx
leaq 0x50(%r15), %rsi
movq %rbx, %rdi
callq 0x105999
movl 0x78(%r15), %edx
imulq 0xa8(%r15), %rdx
leaq 0x8(%r15), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x105282
// File: /workspace/github_c_makefile_star2_O3/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 0x1ae43b
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1ae47f
movq %rsp, %r12
movq %r14, (%r12)
movb %bpl, 0x8(%r12)
movq %r15, %rdi
callq 0x11b0a1
movq 0xa0(%r14), %rcx
addq $0x70, %r14
leaq -0xfe(%rip), %rdi       # 0x1ae363
movq %r12, %rsi
movq %rax, %rdx
movq %r14, %r8
movq %rbx, %r9
callq 0x104dc0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x6473f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/fmi-save.c
// Function: gt_saveFmindex
int gt_saveFmindex(const char *indexname,Fmindex *fm,
                   const GtSpecialcharinfo *specialcharinfo,
                   bool storeindexpos,GtError *err)
{
  gt_error_check(err);
  if (writefmascii(indexname, fm, specialcharinfo,storeindexpos,err) != 0)
  {
    return -1;
  }
  if (writefmdata (indexname, fm, storeindexpos,err) != 0)
  {
    return -2;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
testq %r8, %r8
je 0x1ae977
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1ae9f7
movzbl %bpl, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
callq 0x1ae9fc
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x1ae9eb
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
je 0x1ae996
callq 0x64858
movzbl %bpl, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
xorl %r8d, %r8d
callq 0x1ae9fc
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x1ae9eb
leaq 0x1f7c3e(%rip), %rsi    # 0x3a65db
leaq 0x1a713d(%rip), %rdx    # 0x355ae1
leaq 0x1f7f2f(%rip), %rcx    # 0x3a68da
movq %r15, %rdi
movl $0x4c, %r8d
movq %rbx, %r9
callq 0xfcf97
movl $0xfffffffe, %r12d      # imm = 0xFFFFFFFE
testq %rax, %rax
je 0x1ae9eb
movq %rax, %r15
movzbl %bpl, %edx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x1ae308
testl %eax, %eax
jne 0x1ae9eb
movq %r15, %rdi
callq 0xfd09a
xorl %r12d, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x6488f
// File: /workspace/github_c_makefile_star2_O3/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 0x1f743b(%rip), %rsi    # 0x3a6c28
movl $0x38, %edi
movl $0x29, %edx
callq 0x104226
testq %rax, %rax
je 0x1af8be
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 0x1f73db(%rip), %rsi    # 0x3a6c28
movl $0x36, %edx
callq 0x104226
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x1af8c3
movsd 0x10(%rsp), %xmm0
mulsd 0x1f73b2(%rip), %xmm0   # 0x3a6c20
mulsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, 0x28(%rbx)
cmpq $0x3e9, %rax            # imm = 0x3E9
jge 0x1af8c8
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd 0x1d4a1b(%rip), %xmm1   # 0x3842b0
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 0x1af8cd
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x64a64
callq 0x64a2d
callq 0x649f6
// File: /workspace/github_c_makefile_star2_O3/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 0x8(%rdi), %rax
cmpq %rsi, %rax
jb 0x1af94e
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
cmpq %rax, %r13
je 0x1af953
cmpq %r15, %rbx
cmovgq %rbx, %r15
movq 0x20(%r12), %rax
movq $-0x8000, %rcx          # imm = 0x8000
subq %rax, %rcx
cmpq %rbx, %rcx
jg 0x1af984
incq %r13
addq %r14, %r14
movq %rbx, %rcx
subq %rax, %rcx
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %r8
callq 0x1af8cd
movq 0x28(%r12), %rax
movl $0x7fff, %ecx           # imm = 0x7FFF
subq %rax, %rcx
cmpq %rbx, %rcx
jl 0x1af989
orq $0x1, %r14
addq %rax, %rbx
movq 0x8(%r12), %rax
cmpq %r13, %rax
jae 0x1af8ee
callq 0x64b40
cmpq %r14, (%r12)
jbe 0x1af98e
leaq -0x8000(%r15), %rax
cmpq %rbx, %rax
jg 0x1af98e
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 0x64ad2
callq 0x64a9b
callq 0x64b09
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-polish.c
// Function: polishing_info_show
void polishing_info_show(const GtFtPolishing_info *pol_info)
{
  GtUword idx;

  printf("pi->cut_depth=" GT_WU "\n",pol_info->cut_depth);
  printf("pi->entries=" GT_WU "\n",pol_info->entries);
  printf("pi->match_score=" GT_WD "\n",pol_info->match_score);
  printf("pi->difference_score=" GT_WD "\n",pol_info->difference_score);
  printf("pi->mask=%s\n",
         polish_intbits2string(pol_info->cut_depth,pol_info->mask));
  for (idx = 0; idx < pol_info->entries; idx++)
  {
    printf("[%s]=%+hd/%+hd\n",polish_intbits2string(pol_info->cut_depth,idx),
                              pol_info->values[idx].score_sum,
                              pol_info->values[idx].diff_from_max);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
leaq 0x1f72cb(%rip), %rdi    # 0x3a6c94
xorl %eax, %eax
callq 0x17070
movq (%rbx), %rsi
leaq 0x1f72cd(%rip), %rdi    # 0x3a6ca7
xorl %eax, %eax
callq 0x17070
movq 0x28(%rbx), %rsi
leaq 0x1f72cc(%rip), %rdi    # 0x3a6cb8
xorl %eax, %eax
callq 0x17070
movq 0x20(%rbx), %rsi
leaq 0x1f72cf(%rip), %rdi    # 0x3a6ccd
xorl %eax, %eax
callq 0x17070
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rsi
callq 0x1afa7a
leaq 0x1f72ce(%rip), %rdi    # 0x3a6ce7
leaq 0x30ef00(%rip), %rsi    # 0x4be920
xorl %eax, %eax
callq 0x17070
cmpq $0x0, (%rbx)
je 0x1afa6e
leaq 0x1f72c0(%rip), %r14    # 0x3a6cf4
leaq 0x30eee5(%rip), %r15    # 0x4be920
xorl %r12d, %r12d
movq 0x8(%rbx), %rdi
movq %r12, %rsi
callq 0x1afa7a
movq 0x30(%rbx), %rax
movswl (%rax,%r12,4), %edx
movswl 0x2(%rax,%r12,4), %ecx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x17070
incq %r12
cmpq (%rbx), %r12
jb 0x1afa3e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-polish.c
// Function: polish_intbits2string
static char *polish_intbits2string(GtUword bits,GtUword bs)
{
  char *csptr;
  GtUword mask;
  static char cs[64+1];

  gt_assert(bits > 0 && bits <= sizeof (GtUword) * CHAR_BIT);
  for (csptr = cs, mask = ((GtUword) 1) << (bits-1); mask > 0;
       mask >>= 1, csptr++)
  {
     *csptr = (bs & mask) ? '1' : '0';
  }
  *csptr = '\0';
  return cs;
}

// Assembly:
pushq %rax
decq %rdi
cmpq $0x40, %rdi
jae 0x1afaba
movl $0x1, %eax
movl %edi, %ecx
shlq %cl, %rax
leaq 0x30ee8b(%rip), %rcx    # 0x4be920
movq %rax, %rdx
testq %rsi, %rax
sete %dil
xorb $0x31, %dil
movb %dil, (%rcx)
shrq %rdx
incq %rcx
cmpq $0x1, %rax
movq %rdx, %rax
ja 0x1afa98
movb $0x0, (%rcx)
popq %rax
retq
callq 0x64b77
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-polish.c
// Function: history_is_polished_brute_force
bool history_is_polished_brute_force(const GtFtPolishing_info *pol_info,
                                     uint64_t matchhistory,
                                     bool withoutput)
{
  GtUword idx;
  uint64_t mask;
  GtWord sum_score = 0;

  for (mask = (uint64_t) 1, idx = 0; idx < 2 * pol_info->cut_depth;
       idx++, mask <<= 1)
  {
    if (matchhistory & mask)
    {
      sum_score += pol_info->match_score;
    } else
    {
      sum_score -= pol_info->difference_score;
    }
    if (withoutput)
    {
      printf(GT_WU ": sum_score=" GT_WD "\n",idx,sum_score);
    }
    if (sum_score < 0)
    {
      return false;
    }
  }
  return true;
}

// Assembly:
movq 0x8(%rdi), %rax
shlq %rax
testq %rax, %rax
je 0x1afb75
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %r12d
xorl %r13d, %r13d
xorl %ebp, %ebp
testq %r14, %r12
je 0x1afb30
addq 0x28(%r15), %r13
jmp 0x1afb34
subq 0x20(%r15), %r13
testb %bl, %bl
je 0x1afb4c
leaq 0x1f71c5(%rip), %rdi    # 0x3a6d04
movq %rbp, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x17070
testq %r13, %r13
setns %al
js 0x1afb66
incq %rbp
addq %r12, %r12
movq 0x8(%r15), %rcx
addq %rcx, %rcx
cmpq %rcx, %rbp
jb 0x1afb25
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-trimstat.c
// Function: gt_ft_trimstat_new
GtFtTrimstat *gt_ft_trimstat_new(void)
{
  GtFtTrimstat *trimstat = gt_malloc(sizeof *trimstat);

  gt_assert(trimstat != 0);
  trimstat->trim_dist = gt_calloc(101,sizeof *trimstat->trim_dist);
  gt_assert(trimstat->trim_dist != NULL);
  trimstat->matchlength_dist = gt_calloc(101,
                                         sizeof *trimstat->matchlength_dist);
  gt_assert(trimstat->matchlength_dist != NULL);
  trimstat->diedout = 0;
  GT_INITARRAY(&trimstat->distance_dist,GtUword);
  GT_INITARRAY(&trimstat->maxvalid_dist,GtUword);
  trimstat->spaceforfront_total = 0;
  trimstat->sum_meanvalid = 0.0;
  return trimstat;
}

// Assembly:
pushq %rbx
leaq 0x1f72b8(%rip), %rsi    # 0x3a6e38
movl $0x58, %edi
movl $0x11, %edx
callq 0x104226
testq %rax, %rax
je 0x1afbfe
movq %rax, %rbx
leaq 0x1f729a(%rip), %rdx    # 0x3a6e38
movl $0x65, %edi
movl $0x8, %esi
movl $0x14, %ecx
callq 0x10436a
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x1afc03
leaq 0x1f7276(%rip), %rdx    # 0x3a6e38
movl $0x65, %edi
movl $0x8, %esi
movl $0x17, %ecx
callq 0x10436a
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x1afc08
movq $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movq %rbx, %rax
popq %rbx
retq
callq 0x64c1c
callq 0x64be5
callq 0x64bae
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/ft-trimstat.c
// Function: gt_ft_trimstat_delete
void gt_ft_trimstat_delete(GtFtTrimstat *trimstat)
{
  if (trimstat != NULL)
  {
    gt_free(trimstat->trim_dist);
    GT_FREEARRAY(&trimstat->distance_dist,GtUword);
    GT_FREEARRAY(&trimstat->maxvalid_dist,GtUword);
    gt_free(trimstat->matchlength_dist);
    gt_free(trimstat);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1aff0b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x1f6fc0(%rip), %rsi    # 0x3a6e38
movl $0x81, %edx
callq 0x1045eb
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1afeaf
leaq 0x18(%rbx), %r14
leaq 0x1f6fa2(%rip), %rsi    # 0x3a6e38
movl $0x82, %edx
callq 0x1045eb
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x1afedc
leaq 0x30(%rbx), %r14
leaq 0x1f6f75(%rip), %rsi    # 0x3a6e38
movl $0x83, %edx
callq 0x1045eb
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x10(%rbx), %rdi
leaq 0x1f6f51(%rip), %r14    # 0x3a6e38
movq %r14, %rsi
movl $0x84, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x85, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/gfa_writer.c
// Function: gt_gfa_writer_new
GtGfaWriter* gt_gfa_writer_new(GtFile *file,
                               const GtEncseq *encseq,
                               GtGfaVersion version)
{
  GtGfaWriter *gw;
  gw = gt_malloc(sizeof (*gw));
  gw->file = gt_file_ref(file);
  gw->encseq = gt_encseq_ref((GtEncseq*)encseq);
  gw->version = version;
  return gw;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1f6e19(%rip), %rsi    # 0x3a701c
movl $0x18, %edi
movl $0x22, %edx
callq 0x104226
movq %rax, %r12
movq %r15, %rdi
callq 0xfec09
movq %rax, (%r12)
movq %r14, %rdi
callq 0xea9be
movq %rax, 0x8(%r12)
movl %ebx, 0x10(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq