LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: showmerdistribution
static void showmerdistribution(const TyrDfsstate *state)
{
  GtUword countocc;

  for (countocc = 0;
      countocc < state->occdistribution.nextfreeCountwithpositions;
      countocc++)
  {
    if (state->occdistribution.spaceCountwithpositions[countocc].occcount > 0)
    {
      printf(""GT_WU" "GT_WU"\n",countocc,
                         state->occdistribution.
                                spaceCountwithpositions[countocc].occcount);
      if (decideifocc(state,countocc))
      {
        showListUlong(state->encseq,
                      state->mersize,
                      state->occdistribution.spaceCountwithpositions[countocc].
                                             positionlist);
        wrapListUlong(state->occdistribution.spaceCountwithpositions[countocc].
                                             positionlist);
      }
    }
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x2f6b49
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jbe 0x2f6b34
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x25d9b4(%rip), %rdi    # 0x55447d
movb $0x0, %al
callq 0x19070
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2f6580
testb $0x1, %al
jne 0x2f6ae5
jmp 0x2f6b32
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
callq 0x2f6be0
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x2f6c50
jmp 0x2f6b34
jmp 0x2f6b36
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2f6a72
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: bruteforcecountnumofmers
static uint64_t bruteforcecountnumofmers(const TyrDfsstate *state)
{
  GtUword idx;
  uint64_t numofmers = 0;

  for (idx=0; idx <= state->totallength - state->mersize; idx++)
  {
    if (!gt_encseq_contains_special(state->encseq,
                                    state->readmode,
                                    state->esrspace,
                                    idx,
                                    state->mersize))
    {
      numofmers++;
    }
  }
  return numofmers;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rsp), %rdx
subq (%rdx), %rcx
cmpq %rcx, %rax
ja 0x2f6bd3
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x28(%rax), %esi
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rdx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq (%rax), %r8
callq 0xabb90
testb $0x1, %al
jne 0x2f6bc1
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x2f6bc3
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2f6b6a
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: showListUlong
static void showListUlong(const GtEncseq *encseq,
                          GtUword mersize,
                          const ListUlong *node)
{
  const ListUlong *tmp;

  for (tmp = node; tmp != NULL; tmp = tmp->nextptr)
  {
    gt_fprintfencseq(stdout,encseq,tmp->position,mersize);
    (void) putchar((int) '\n');
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2f6c40
movq 0x34532c(%rip), %rax    # 0x63bf38
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
movq 0x18(%rsp), %rcx
callq 0x21e540
movl $0xa, %edi
callq 0x19960
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2f6bfd
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: wrapListUlong
static void wrapListUlong(ListUlong *node)
{
  ListUlong *tmpnext;

  if (node != NULL)
  {
    while (true)
    {
      if (node->nextptr == NULL)
      {
        gt_free(node);
        break;
      }
      tmpnext = node->nextptr;
      gt_free(node);
      node = tmpnext;
    }
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2f6cb9
jmp 0x2f6c63
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2f6c87
movq 0x10(%rsp), %rdi
leaq 0x298ec1(%rip), %rsi    # 0x58fb3c
movl $0xad, %edx
callq 0xe88c0
jmp 0x2f6cb7
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x298e9b(%rip), %rsi    # 0x58fb3c
movl $0xb1, %edx
callq 0xe88c0
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x2f6c63
jmp 0x2f6cb9
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-occratio.c
// Function: gt_tyr_occratio_func
int gt_tyr_occratio_func(const char *inputindex,
                         bool scanfile,
                         GtUword minmersize,
                         GtUword maxmersize,
                         GtArrayuint64_t *uniquedistribution,
                         GtArrayuint64_t *nonuniquedistribution,
                         GtArrayuint64_t *nonuniquemultidistribution,
                         GtLogger *logger,
                         GtError *err)
{
  bool haserr = false;
  Sequentialsuffixarrayreader *ssar;

  gt_error_check(err);
  ssar = gt_newSequentialsuffixarrayreaderfromfile(inputindex,
                                                SARR_LCPTAB |
                                                SARR_SUFTAB |
                                                SARR_ESQTAB,
                                                scanfile,
                                                logger,
                                                err);
  if (ssar == NULL)
  {
    haserr = true;
  }
  if (!haserr)
  {
    if (computeoccurrenceratio(ssar,
                               minmersize,
                               maxmersize,
                               uniquedistribution,
                               nonuniquedistribution,
                               nonuniquemultidistribution,
                               logger,
                               err) != 0)
    {
      haserr = true;
    }
  }
  if (ssar != NULL)
  {
    gt_freeSequentialsuffixarrayreader(&ssar);
  }
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x58, %rsp
movb %sil, %al
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rsi
movq %rdi, 0x50(%rsp)
andb $0x1, %al
movb %al, 0x4f(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movb $0x0, 0x27(%rsp)
cmpq $0x0, 0x70(%rsp)
je 0x2f6d4a
movq 0x70(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x2f6d12
jmp 0x2f6d4a
movq 0x345287(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x21f2f0(%rip), %rsi    # 0x516013
leaq 0x21f495(%rip), %rdx    # 0x5161bf
leaq 0x2990e1(%rip), %rcx    # 0x58fe12
leaq 0x2990ef(%rip), %r8     # 0x58fe27
movl $0xfa, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2f6d4c
movq 0x50(%rsp), %rdi
movb 0x4f(%rsp), %al
movq 0x68(%rsp), %rcx
movq 0x70(%rsp), %r8
movl $0x7, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0x23b3e0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x2f6d80
movb $0x1, 0x27(%rsp)
testb $0x1, 0x27(%rsp)
jne 0x2f6dc9
movq 0x18(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x60(%rsp), %r9
movq 0x68(%rsp), %r10
movq 0x70(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2f6e00
cmpl $0x0, %eax
je 0x2f6dc7
movb $0x1, 0x27(%rsp)
jmp 0x2f6dc9
cmpq $0x0, 0x18(%rsp)
je 0x2f6ddb
leaq 0x18(%rsp), %rdi
callq 0x23b5e0
movb 0x27(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-occratio.c
// Function: occ_processleafedge
static int occ_processleafedge(GT_UNUSED bool firstsucc,
                           GtUword fatherdepth,
                           GT_UNUSED Dfsinfo *father,
                           GtUword leafnumber,
                           Dfsstate *astate,
                           GT_UNUSED GtError *err)
{
  OccDfsstate *state = (OccDfsstate*) astate;
  iteritvdistribution(state->uniquedistribution,
                      state->encseq,
                      state->readmode,
                      state->totallength,
                      state->minmersize,
                      state->maxmersize,
                      fatherdepth+1,
                      leafnumber);
  return 0;
}

// Assembly:
subq $0x48, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x47(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rsp), %rax
movl 0x8(%rax), %edx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %r8
movq 0x10(%rsp), %rax
movq 0x20(%rax), %r9
movq 0x38(%rsp), %r10
addq $0x1, %r10
movq 0x28(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2f7280
xorl %eax, %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-occratio.c
// Function: occ_processcompletenode
static int occ_processcompletenode(GtUword nodeptrdepth,
                               Dfsinfo *anodeptr,
                               GtUword nodeptrminusonedepth,
                               Dfsstate *astate,
                               GT_UNUSED GtError *err)
{
  GtUword fatherdepth;
  GtUword startlength, endlength;
  OccDfsinfo *nodeptr = (OccDfsinfo*) anodeptr;
  OccDfsstate *state = (OccDfsstate*) astate;

  fatherdepth = nodeptr->lcptabrightmostleafplus1;
  if (fatherdepth < nodeptrminusonedepth)
  {
    fatherdepth = nodeptrminusonedepth;
  }
  startlength = (GtUword) (fatherdepth + 1);
  if (startlength < state->minmersize)
  {
    startlength = state->minmersize;
  }
  endlength = (GtUword) nodeptrdepth;
  if (endlength > state->maxmersize)
  {
    endlength = state->maxmersize;
  }
  if (startlength <= endlength)
  {
    GtUword lenval;
    GtUword occcount = nodeptr->rightmostleaf - nodeptr->leftmostleaf + 1;

    for (lenval = startlength; lenval <= endlength; lenval++)
    {
      adddistributionuint64_t(state->nonuniquemultidistribution,
                              lenval,
                              (GtUword) occcount);
      adddistributionuint64_t(state->nonuniquedistribution,
                              lenval,
                              1UL);
    }
  }
  return 0;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x50(%rsp), %rax
jae 0x2f7135
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x2f7161
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jbe 0x2f7189
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
ja 0x2f7207
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
subq (%rcx), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x28(%rsp), %rax
ja 0x2f7205
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2f7380
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x2f7380
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2f71b9
jmp 0x2f7207
xorl %eax, %eax
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-occratio.c
// Function: iteritvdistribution
static void iteritvdistribution(GtArrayuint64_t *distribution,
                                const GtEncseq *encseq,
                                GtReadmode readmode,
                                GtUword totallength,
                                GtUword minmersize,
                                GtUword maxmersize,
                                GtUword length,
                                GtUword startpos)
{

  if (length <= (GtUword) maxmersize)
  {
    GtUword ulen, pos;

    for (ulen = length,
         pos = startpos + length - 1;
         ulen <= (GtUword) maxmersize &&
         pos < totallength &&
         GT_ISNOTSPECIAL(gt_encseq_get_encoded_char(encseq,pos,readmode));
         pos++, ulen++)
    {
      if (ulen >= (GtUword) minmersize)
      {
        adddistributionuint64_t(distribution,(GtUword) ulen,1UL);
      }
    }
  }
}

// Assembly:
subq $0x48, %rsp
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x18(%rsp), %rax
ja 0x2f736d
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rax
addq 0x50(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x18(%rsp), %rcx
movb %al, 0x7(%rsp)
ja 0x2f731e
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpq 0x28(%rsp), %rcx
movb %al, 0x7(%rsp)
jae 0x2f731e
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x34(%rsp), %edx
callq 0xa9da0
movzbl %al, %eax
cmpl $0xfe, %eax
setl %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x2f7328
jmp 0x2f736b
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jb 0x2f7348
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x2f7380
jmp 0x2f734a
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2f72d8
jmp 0x2f736d
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-occratio.c
// Function: adddistributionuint64_t
static void adddistributionuint64_t(GtArrayuint64_t *occdistribution,
                                    GtUword countocc,
                                    GtUword value)
{
  if (countocc >= occdistribution->allocateduint64_t)
  {
    const GtUword addamount = 128UL;
    GtUword idx;

    occdistribution->spaceuint64_t
      = gt_realloc(occdistribution->spaceuint64_t,
                   sizeof *occdistribution->spaceuint64_t *
                   (countocc+addamount));
    for (idx=occdistribution->allocateduint64_t;
         idx<countocc+addamount; idx++)
    {
      occdistribution->spaceuint64_t[idx] = 0;
    }
    occdistribution->allocateduint64_t = countocc+addamount;
  }
  if (countocc + 1 > occdistribution->nextfreeuint64_t)
  {
    occdistribution->nextfreeuint64_t = countocc+1;
  }
  occdistribution->spaceuint64_t[countocc] += value;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x2f743d
movq $0x80, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
addq $0x80, %rsi
shlq $0x3, %rsi
leaq 0x298a58(%rip), %rdx    # 0x58fe27
movl $0x48, %ecx
callq 0xe8540
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
addq $0x80, %rcx
cmpq %rcx, %rax
jae 0x2f7428
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x2f73f1
movq 0x18(%rsp), %rcx
addq $0x80, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq 0x20(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x2f7463
movq 0x18(%rsp), %rcx
addq $0x1, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
addq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-search.c
// Function: gt_searchsinglemer
const GtUchar *gt_searchsinglemer(const GtUchar *qptr,
                                        const Tyrindex *tyrindex,
                                        const Tyrsearchinfo *tyrsearchinfo,
                                        const Tyrbckinfo *tyrbckinfo)
{
  const GtUchar *result;

  gt_encseq_plainseq2bytecode(tyrsearchinfo->bytecode,qptr,
                                       tyrsearchinfo->mersize);
  if (tyrbckinfo == NULL)
  {
    result = gt_tyrindex_binmersearch(tyrindex,0,tyrsearchinfo->bytecode,
                                   tyrsearchinfo->mertable,
                                   tyrsearchinfo->lastmer);
  } else
  {
    result = gt_searchinbuckets(tyrindex,tyrbckinfo,tyrsearchinfo->bytecode);
  }
  return result;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdx
callq 0xa9400
cmpq $0x0, 0x8(%rsp)
jne 0x2f74f9
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %r8
xorl %eax, %eax
movl %eax, %esi
callq 0x4e8680
movq %rax, (%rsp)
jmp 0x2f7514
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
callq 0x2f43d0
movq %rax, (%rsp)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-search.c
// Function: gt_tyrsearchinfo_init
static void gt_tyrsearchinfo_init(Tyrsearchinfo *tyrsearchinfo,
                               const Tyrindex *tyrindex,
                               unsigned int showmode,
                               unsigned int searchstrand)
{
  GtUword merbytes;

  merbytes = gt_tyrindex_merbytes(tyrindex);
  tyrsearchinfo->mersize = gt_tyrindex_mersize(tyrindex);
  tyrsearchinfo->mertable = gt_tyrindex_mertable(tyrindex);
  tyrsearchinfo->lastmer = gt_tyrindex_lastmer(tyrindex);
  tyrsearchinfo->showmode = showmode;
  tyrsearchinfo->searchstrand = searchstrand;
  tyrsearchinfo->dnaalpha = gt_alphabet_new_dna();
  tyrsearchinfo->bytecode = gt_malloc(sizeof *tyrsearchinfo->bytecode
                                      * merbytes);
  tyrsearchinfo->rcbuf = gt_malloc(sizeof *tyrsearchinfo->rcbuf
                                   * tyrsearchinfo->mersize);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4e8150
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4e8160
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rdi
callq 0x4e8130
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rdi
callq 0x4e8140
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0x14(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x28(%rax)
movl 0x10(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x2c(%rax)
callq 0x7e4b0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rdi
shlq $0x0, %rdi
leaq 0x2983e4(%rip), %rsi    # 0x58fe64
movl $0x3a, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
shlq $0x0, %rdi
leaq 0x2983bb(%rip), %rsi    # 0x58fe64
movl $0x3c, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-search.c
// Function: gt_tyrsearchinfo_delete
static void gt_tyrsearchinfo_delete(Tyrsearchinfo *tyrsearchinfo)
{
  if (tyrsearchinfo != NULL)
  {
    gt_alphabet_delete(tyrsearchinfo->dnaalpha);
    gt_free(tyrsearchinfo->bytecode);
    gt_free(tyrsearchinfo->rcbuf);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x2f7d5a
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x7e3d0
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x29812d(%rip), %rsi    # 0x58fe64
movl $0x44, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x298114(%rip), %rsi    # 0x58fe64
movl $0x45, %edx
callq 0xe88c0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/xdrop.c
// Function: gt_xdrop_resources_new
GtXdropresources *gt_xdrop_resources_new(const GtXdropArbitraryscores *scores)
{
  GtXdropresources *res = gt_malloc(sizeof *res);

  res->arbitscores = scores;
  GT_INITARRAY (&res->fronts, GtXdropfrontvalue);
  GT_INITARRAY (&res->big_t, GtXdropscore);
  gt_calculatedistancesfromscores(scores,&res->arbitdistances);
  return res;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x48, %edi
leaq 0x297b9d(%rip), %rsi    # 0x58ff02
movl $0xae, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
jmp 0x2f83aa
movq 0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x40(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0x2f83f0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/xdrop.c
// Function: gt_xdrop_resources_delete
void gt_xdrop_resources_delete(GtXdropresources *res)
{
  if (res != NULL)
  {
    GT_FREEARRAY (&res->fronts, GtXdropfrontvalue);
    GT_FREEARRAY (&res->big_t, GtXdropscore);
    gt_free(res);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x2f868d
jmp 0x2f85e2
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2f862a
movq (%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x297906(%rip), %rsi    # 0x58ff02
movl $0xbb, %edx
callq 0xe88c0
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
jmp 0x2f862c
jmp 0x2f862e
movq (%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x2f8676
movq (%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0x2978ba(%rip), %rsi    # 0x58ff02
movl $0xbc, %edx
callq 0xe88c0
movq (%rsp), %rax
movq $0x0, 0x38(%rax)
movq (%rsp), %rax
movq $0x0, 0x40(%rax)
movq (%rsp), %rax
movq $0x0, 0x30(%rax)
jmp 0x2f8678
movq (%rsp), %rdi
leaq 0x29787f(%rip), %rsi    # 0x58ff02
movl $0xbd, %edx
callq 0xe88c0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/xdrop.c
// Function: gt_xdrop_frontvalue_set
static void gt_xdrop_frontvalue_set(GtXdropresources *res, GtWord d, GtWord k,
                                    GtXdropfrontvalue value)
{
  const GtUword frontidx = GT_XDROP_FRONTIDX(d, k);

  if (frontidx >= res->fronts.allocatedGtXdropfrontvalue)
  {
    res->fronts.allocatedGtXdropfrontvalue = frontidx + 32UL;
    res->fronts.spaceGtXdropfrontvalue
      = gt_realloc_mem(res->fronts.spaceGtXdropfrontvalue,
                       sizeof (*res->fronts.spaceGtXdropfrontvalue) *
                       res->fronts.allocatedGtXdropfrontvalue,
                       __FILE__, __LINE__);
  }
  res->fronts.spaceGtXdropfrontvalue[frontidx] = value;
  res->fronts.nextfreeGtXdropfrontvalue = frontidx + 1;
}

// Assembly:
subq $0x38, %rsp
movb %r8b, %al
movq %rcx, 0x28(%rsp)
movb %al, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
imulq 0x18(%rsp), %rax
addq 0x18(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jb 0x2f984e
movq 0x8(%rsp), %rcx
addq $0x20, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rsi
shlq $0x4, %rsi
leaq 0x2966ca(%rip), %rdx    # 0x58ff02
movl $0xda, %ecx
callq 0xe8540
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
addq $0x1, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x28(%rax)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/ltr/gt_ltrclustering.c
// Function: gt_ltrclustering_arguments_new
static void* gt_ltrclustering_arguments_new(void)
{
  GtLTRClusteringArguments *arguments = gt_calloc((size_t) 1,
                                                  sizeof (*arguments));
  arguments->ofi = gt_output_file_info_new();
  arguments->file_prefix = gt_str_new();
  return arguments;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x40, %esi
leaq 0x29711e(%rip), %rdx    # 0x591380
movl $0x2b, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0xf7d20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/ltr/gt_ltrclustering.c
// Function: gt_ltrclustering_arguments_delete
static void gt_ltrclustering_arguments_delete(void *tool_arguments)
{
  GtLTRClusteringArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->file_prefix);
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2fa2bd
jmp 0x2fa2fc
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rdi
leaq 0x29708e(%rip), %rsi    # 0x591380
movl $0x38, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/ltr/gt_ltrclustering.c
// Function: gt_ltrclustering_option_parser_new
static GtOptionParser* gt_ltrclustering_option_parser_new(void *tool_arguments)
{
  GtLTRClusteringArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] indexname [GFF3_file ...]",
                            "Cluster features of LTRs.");

  /* -psmall */
  option = gt_option_new_uword_min_max("psmall", "specify how many percent of"
                                       " the smaller sequence a match needs to"
                                       " cover in order to cluster the two"
                                       " sequences of the match.",
                                       &arguments->psmall, 0, 0, 100UL);

  gt_option_is_mandatory(option);
  gt_option_parser_add_option(op, option);

  /* -plarge */
  option = gt_option_new_uword_min_max("plarge", "specify how many percent of"
                                       " the larger sequence a match needs to"
                                       " cover in order to cluster the two"
                                       " sequences of the match.",
                                       &arguments->plarge, 0, 0, 100UL);
  gt_option_is_mandatory(option);
  gt_option_parser_add_option(op, option);

  gt_option_is_mandatory(option);

  gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);

  gt_option_parser_set_min_args(op, 1U);

  return op;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x2fa363
movq 0x341c6e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x21bcd7(%rip), %rsi    # 0x516013
leaq 0x28081c(%rip), %rdx    # 0x57ab5f
leaq 0x297051(%rip), %rcx    # 0x59139b
leaq 0x29702f(%rip), %r8     # 0x591380
movl $0x40, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2fa365
leaq 0x297052(%rip), %rdi    # 0x5913be
leaq 0x297072(%rip), %rsi    # 0x5913e5
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdx
addq $0x18, %rdx
leaq 0x297072(%rip), %rdi    # 0x5913ff
leaq 0x297072(%rip), %rsi    # 0x591406
xorl %eax, %eax
movl %eax, %r8d
movl $0x64, %r9d
movq %r8, %rcx
callq 0xf6710
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xf6ca0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdx
addq $0x20, %rdx
leaq 0x2970ad(%rip), %rdi    # 0x591482
leaq 0x2970ad(%rip), %rsi    # 0x591489
xorl %eax, %eax
movl %eax, %r8d
movl $0x64, %r9d
movq %r8, %rcx
callq 0xf6710
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xf6ca0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x8(%rsp), %rdi
callq 0xf6ca0
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xf7d50
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0xf2980
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/ltr/gt_ltrdigest.c
// Function: gt_ltrdigest_arguments_check
int gt_ltrdigest_arguments_check(GT_UNUSED int rest_argc, void *tool_arguments,
                                 GtError* err)
{
  GtLTRdigestOptions *arguments = tool_arguments;
  int had_err  = 0;

  if (arguments->nthreads > 0) {
    gt_warning("The '-threads' option is deprecated. Please use the '-j'"
               "option of the 'gt' call instead, e.g.:\n"
               "  gt -j "GT_WU" ltrdigest ...", arguments->nthreads);
  }

  /* -trnas */
  if (!had_err && arguments->trna_lib && gt_str_length(arguments->trna_lib) > 0)
  {
    if (!gt_file_exists(gt_str_get(arguments->trna_lib)))
    {
      gt_error_set(err, "File '%s' does not exist!",
                        gt_str_get(arguments->trna_lib));
      had_err = -1;
    }
  }
  return had_err;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x50(%rax)
jbe 0x2fa7c7
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rsi
leaq 0x296d78(%rip), %rdi    # 0x591538
movb $0x0, %al
callq 0x1267d0
cmpl $0x0, 0x14(%rsp)
jne 0x2fa83c
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x2fa83c
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x11dfa0
cmpq $0x0, %rax
jbe 0x2fa83c
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x11dee0
movq %rax, %rdi
callq 0xde820
testb $0x1, %al
jne 0x2fa83a
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x11dee0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x296d86(%rip), %rsi    # 0x5915b1
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x2fa83c
movl 0x14(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/ltr/gt_ltrdigest.c
// Function: gt_ltrdigest_arguments_new
static void* gt_ltrdigest_arguments_new(void)
{
  GtLTRdigestOptions *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  memset(arguments, 0, sizeof *arguments);
  arguments->trna_lib = gt_str_new();
  arguments->prefix = gt_str_new();
  arguments->cutoffs = gt_str_new();
  arguments->ofi = gt_output_file_info_new();
  arguments->hmm_files = gt_str_array_new();
  arguments->s2fi = gt_seqid2file_info_new();
  return arguments;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x110, %esi            # imm = 0x110
leaq 0x296d39(%rip), %rdx    # 0x5915cb
movl $0x59, %ecx
callq 0xe83c0
movq %rax, (%rsp)
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x110, %edx            # imm = 0x110
callq 0x19360
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
callq 0xf7d20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rax)
callq 0x1d43b0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/ltr/gt_ltrdigest.c
// Function: gt_ltrdigest_arguments_delete
static void gt_ltrdigest_arguments_delete(void *tool_arguments)
{
  GtLTRdigestOptions *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->trna_lib);
  gt_str_delete(arguments->prefix);
  gt_str_delete(arguments->cutoffs);
  gt_str_array_delete(arguments->hmm_files);
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_seqid2file_info_delete(arguments->s2fi);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2fa93d
jmp 0x2fa9b4
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x1d4420
movq 0x8(%rsp), %rdi
leaq 0x296c21(%rip), %rsi    # 0x5915cb
movl $0x6f, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/ltr/gt_ltrharvest.c
// Function: gt_ltrharvest_arguments_new
static void* gt_ltrharvest_arguments_new(void)
{
  LTRharvestArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->ofi = gt_output_file_info_new();
  arguments->str_motif = gt_str_new();
  arguments->str_overlaps = gt_str_new();
  arguments->str_indexname = gt_str_new();
  arguments->str_fastaoutputfilename = gt_str_new();
  arguments->str_fastaoutputfilenameinnerregion = gt_str_new();
  arguments->str_gff3filename = gt_str_new();
  arguments->motif = gt_calloc((size_t) 1, sizeof (GtLTRFourCharMotif));
  return arguments;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0xf8, %esi
leaq 0x295c31(%rip), %rdx    # 0x591d93
movl $0x93, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0xf7d20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rax)
movl $0x1, %edi
movl $0x10, %esi
leaq 0x295ba3(%rip), %rdx    # 0x591d93
movl $0x9b, %ecx
callq 0xe83c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xf0(%rax)
movq (%rsp), %rax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/ltr/gt_ltrharvest.c
// Function: gt_ltrharvest_arguments_delete
static void gt_ltrharvest_arguments_delete(void *tool_arguments)
{
  LTRharvestArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_str_delete(arguments->str_motif);
  gt_str_delete(arguments->str_overlaps);
  gt_str_delete(arguments->str_indexname);
  gt_str_delete(arguments->str_fastaoutputfilename);
  gt_str_delete(arguments->str_fastaoutputfilenameinnerregion);
  gt_str_delete(arguments->str_gff3filename);
  gt_option_delete(arguments->optiongff3);
  gt_option_delete(arguments->optionoutinner);
  gt_option_delete(arguments->optionout);
  gt_option_delete(arguments->optionmotif);
  gt_option_delete(arguments->optionmotifmis);
  gt_option_delete(arguments->optionoverlaps);
  gt_free(arguments->motif);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2fc230
jmp 0x2fc338
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0xe8(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0xe0(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0xd8(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0xc0(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0xc8(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0xd0(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0xf0(%rax), %rdi
leaq 0x295a7b(%rip), %rsi    # 0x591d93
movl $0xb1, %edx
callq 0xe88c0
movq 0x8(%rsp), %rdi
leaq 0x295a65(%rip), %rsi    # 0x591d93
movl $0xb2, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/ltr/gt_ltrharvest.c
// Function: gt_ltrharvest_showargsline
static void gt_ltrharvest_showargsline(int argc, const char **argv)
{
  int i;
  gt_assert(argv && argc >= 1);
  printf("# args=");
  for (i=1; i<argc; i++) {
    printf("%s", argv[i]);
    if (i != argc-1) printf(" ");
  }
  printf("\n");
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2fd8ac
cmpl $0x1, 0x14(%rsp)
jge 0x2fd8e4
movq 0x33e6ed(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x218756(%rip), %rsi    # 0x516013
leaq 0x294966(%rip), %rdx    # 0x59222a
leaq 0x294971(%rip), %rcx    # 0x59223c
leaq 0x2944c1(%rip), %r8     # 0x591d93
movl $0x243, %r9d            # imm = 0x243
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2fd8e6
leaq 0x29496a(%rip), %rdi    # 0x592257
movb $0x0, %al
callq 0x19070
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x2fd94e
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x29e706(%rip), %rdi    # 0x59c021
movb $0x0, %al
callq 0x19070
movl 0x4(%rsp), %eax
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x2fd93f
leaq 0x297b47(%rip), %rdi    # 0x59547f
movb $0x0, %al
callq 0x19070
jmp 0x2fd941
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2fd8fc
leaq 0x29591e(%rip), %rdi    # 0x593273
movb $0x0, %al
callq 0x19070
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/ltr/ltr_classify_stream.c
// Function: gt_ltr_classify_stream_class
const GtNodeStreamClass* gt_ltr_classify_stream_class(void)
{
  static const GtNodeStreamClass *nsc;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof(GtLTRClassifyStream),
                                   gt_ltr_classify_stream_free,
                                   gt_ltr_classify_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x9f220
cmpq $0x0, 0x34536a(%rip)    # 0x642fc8
jne 0x2fdc7f
movl $0x50, %edi
leaq 0x24(%rip), %rsi        # 0x2fdc90
leaq 0xbd(%rip), %rdx        # 0x2fdd30
callq 0x1b1ae0
movq %rax, 0x345349(%rip)    # 0x642fc8
callq 0x9f280
movq 0x34533d(%rip), %rax    # 0x642fc8
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/ltr/ltr_classify_stream.c
// Function: gt_ltr_classify_stream_free
static void gt_ltr_classify_stream_free(GtNodeStream *ns)
{
  GtUword i;
  GtLTRClassifyStream *lcs = gt_ltr_classify_stream_cast(ns);
  for (i = 0; i < gt_array_size(lcs->nodes); i++)
    gt_genome_node_delete(*(GtGenomeNode**) gt_array_get(lcs->nodes, i));
  gt_array_delete(lcs->nodes);
  gt_node_stream_delete(lcs->in_stream);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
callq 0x2fdc50
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x1b20f0
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x81370
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x2fdd09
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x80b60
movq (%rax), %rdi
callq 0x173180
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2fdcb9
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x81f80
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1b1cb0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/ltr/ltr_classify_stream.c
// Function: gt_ltr_classify_stream_new
GtNodeStream* gt_ltr_classify_stream_new(GtNodeStream *in_stream,
                                         GtHashmap *features,
                                         const char *famprefix,
                                         char **current_state,
                                         GtUword *progress,
                                         GT_UNUSED GtError *err)
{
  GtNodeStream *ns;
  GtLTRClassifyStream *lcs;
  ns = gt_node_stream_create(gt_ltr_classify_stream_class(), false);
  lcs = gt_ltr_classify_stream_cast(ns);
  lcs->in_stream = gt_node_stream_ref(in_stream);
  lcs->nodes = gt_array_new(sizeof(GtGenomeNode*));
  lcs->features = features;
  lcs->first_next = true;
  lcs->next_index = 0;
  lcs->famprefix = famprefix;
  lcs->progress = progress;
  lcs->current_state = current_state;
  return ns;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
callq 0x2fdc50
movq %rax, %rdi
xorl %esi, %esi
callq 0x1b1b80
movq %rax, 0x10(%rsp)
callq 0x2fdc50
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x1b20f0
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x1b1c50
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movl $0x8, %edi
callq 0x80990
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x38(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movb $0x1, 0x38(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x40(%rax)
movq 0x30(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/ltr/ltr_classify_stream.c
// Function: ltr_group_compatible
static bool ltr_group_compatible(GtArray *candidates, GtGenomeNode *candidate1,
                                 GtBittab *group, GtHashmap *features,
                                 GtError *err)
{
  GtArray *group_member;
  GtGenomeNode *candidate2;
  bool compatible = true;
  GtUword i, index;

  gt_assert(candidates && candidate1 && group);
  gt_error_check(err);

  group_member = gt_array_new(sizeof(GtUword));
  gt_bittab_get_all_bitnums(group, group_member);

  for (i = 0; i < gt_array_size(group_member); i++) {
    index = *(GtUword*) gt_array_get(group_member, i);
    candidate2 = *(GtGenomeNode**) gt_array_get(candidates, index);
    if (!(compatible = ltr_candidates_compatible(candidate1, candidate2,
                                                 features, err)))
      break;
  }
  gt_array_delete(group_member);

  return compatible;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movb $0x1, 0x1f(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0x2fe61a
cmpq $0x0, 0x48(%rsp)
je 0x2fe61a
cmpq $0x0, 0x40(%rsp)
jne 0x2fe652
movq 0x33d97f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2179e8(%rip), %rsi    # 0x516013
leaq 0x293f52(%rip), %rdx    # 0x592584
leaq 0x293f6d(%rip), %rcx    # 0x5925a6
leaq 0x293ed0(%rip), %r8     # 0x592510
movl $0x91, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2fe654
jmp 0x2fe656
cmpq $0x0, 0x30(%rsp)
je 0x2fe6a6
movq 0x30(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x2fe66e
jmp 0x2fe6a6
movq 0x33d92b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x217994(%rip), %rsi    # 0x516013
leaq 0x217b39(%rip), %rdx    # 0x5161bf
leaq 0x293f19(%rip), %rcx    # 0x5925a6
leaq 0x293e7c(%rip), %r8     # 0x592510
movl $0x92, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2fe6a8
movl $0x8, %edi
callq 0x80990
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x8a6d0
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x81370
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x2fe759
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x80b60
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x80b60
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
callq 0x2fee30
movb %al, %cl
andb $0x1, %cl
movb %cl, 0x1f(%rsp)
testb $0x1, %al
jne 0x2fe744
jmp 0x2fe759
jmp 0x2fe746
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2fe6cf
movq 0x28(%rsp), %rdi
callq 0x81f80
movb 0x1f(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/ltr/ltr_classify_stream.c
// Function: remove_fnmap_from_candidates
static void remove_fnmap_from_candidates(GtArray *candidates)
{
  GtGenomeNode *gn;
  GtUword i;

  for (i = 0; i < gt_array_size(candidates); i++) {
    gn = *(GtGenomeNode**) gt_array_get(candidates, i);
    if (gt_feature_node_try_cast(gn) == NULL)
      continue;
    gt_genome_node_release_user_data(gn, "fnmap");
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x81370
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x2fee0d
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x80b60
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x170450
cmpq $0x0, %rax
jne 0x2fedec
jmp 0x2fedfd
movq 0x18(%rsp), %rdi
leaq 0x293786(%rip), %rsi    # 0x59257e
callq 0x172980
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2feda2
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/ltr/ltr_cluster_stream.c
// Function: gt_ltr_cluster_stream_class
const GtNodeStreamClass* gt_ltr_cluster_stream_class(void)
{
  static const GtNodeStreamClass *nsc;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof(GtLTRClusterStream),
                                   gt_ltr_cluster_stream_free,
                                   gt_ltr_cluster_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x9f220
cmpq $0x0, 0x343de2(%rip)    # 0x642fd0
jne 0x2ff20f
movl $0x88, %edi
leaq 0x24(%rip), %rsi        # 0x2ff220
leaq 0xed(%rip), %rdx        # 0x2ff2f0
callq 0x1b1ae0
movq %rax, 0x343dc1(%rip)    # 0x642fd0
callq 0x9f280
movq 0x343db5(%rip), %rax    # 0x642fd0
popq %rcx
retq
nopl (%rax)