LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/test-pairwise.c
// Function: gt_runcheckfunctiononalphalen
GtUword gt_runcheckfunctiononalphalen(Checkcmppairfuntype checkfunction,
                                         const char *charlist,
                                         GtUword len)
{
  return applyall(charlist,
                  len,
                  (void *) checkfunction,
                  gt_applycheckfunctiontotext);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, 0x38(%rsp)
movq %rsi, %rdi
callq 0x172f0
movq %rax, 0x30(%rsp)
leaq 0x1(%r15), %rbx
leaq 0x8(,%r15,8), %rdi
leaq 0x1bb6d2(%rip), %r14    # 0x3c5c31
movq %r14, %rsi
movl $0x70, %edx
callq 0x1092b2
movq %rax, %r13
movq %rbx, %rdi
movq %r14, %rsi
movl $0x71, %edx
callq 0x1092b2
movq %rax, %rbp
cmpq $0x1, %rbx
movq %r15, %rdx
adcq $0x1, %rdx
shlq $0x3, %rdx
movq $0x0, 0x20(%rsp)
movq %r13, %rdi
xorl %esi, %esi
callq 0x173a0
movq %r15, %rbx
decq %r15
movb $0x0, (%rbp,%rbx)
movq %rbx, %rsi
shrq %rsi
incq %rsi
movq %r15, 0x18(%rsp)
xorl %r14d, %r14d
movq %rbx, 0x10(%rsp)
movq %r12, 0x8(%rsp)
movq %r13, 0x28(%rsp)
movq %r14, 0x40(%rsp)
testq %rbx, %rbx
je 0x20a5f0
xorl %eax, %eax
movq (%r13,%rax,8), %rcx
movb (%r12,%rcx), %cl
movb %cl, (%rbp,%rax)
incq %rax
cmpq %rax, %rbx
jne 0x20a5db
xorl %r14d, %r14d
movq 0x38(%rsp), %r12
leaq (%r14,%rbp), %rcx
movl $0x1, %edi
movq %rsi, %r13
movq %rbp, %rsi
movq %r14, %rdx
movq %rbx, %r8
callq *%r12
movq %r13, %rsi
incq %r14
decq %rbx
cmpq %r14, %r13
jne 0x20a5f8
movq 0x28(%rsp), %r13
movq (%r13,%r15,8), %rax
incq %rax
movq %rax, (%r13,%r15,8)
movq 0x30(%rsp), %rcx
cmpq %rcx, %rax
movq 0x40(%rsp), %r14
jne 0x20a660
movq $0x0, (%r13,%r15,8)
subq $0x1, %r15
jb 0x20a667
movq (%r13,%r15,8), %rax
incq %rax
movq %rax, (%r13,%r15,8)
cmpq %rcx, %rax
je 0x20a63f
movq 0x18(%rsp), %r15
jmp 0x20a671
movb $0x1, %al
movq %rax, 0x20(%rsp)
xorl %r15d, %r15d
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %r12
addq %rsi, %r14
testb $0x1, 0x20(%rsp)
je 0x20a5cf
leaq 0x1bb5a1(%rip), %rbx    # 0x3c5c31
movq %r13, %rdi
movq %rbx, %rsi
movl $0x91, %edx
callq 0x109670
movq %rbp, %rdi
movq %rbx, %rsi
movl $0x92, %edx
callq 0x109670
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/test-pairwise.c
// Function: gt_computegreedyunitedist
GtUword gt_computegreedyunitedist(const GtUchar *useq,
                                        GtUword ulen,
                                        const GtUchar *vseq,
                                        GtUword vlen)
{
  GtUword edist;
  bool rightextension = true;
  GtFrontResource *frontresource = gt_frontresource_new(10UL);
  GtSeqabstract *greedyedistuseq, *greedyedistvseq;

  greedyedistuseq
    = gt_seqabstract_new_gtuchar(rightextension,GT_READMODE_FORWARD,
                                 useq,ulen,0,ulen);
  greedyedistvseq
    = gt_seqabstract_new_gtuchar(rightextension,GT_READMODE_FORWARD,
                                 vseq,vlen,0,vlen);
  edist = greedyunitedist(frontresource,greedyedistuseq,greedyedistvseq);
  gt_seqabstract_delete(greedyedistuseq);
  gt_seqabstract_delete(greedyedistvseq);
  gt_frontresource_delete(frontresource);
  return edist;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl $0xa, %edi
callq 0x1ba644
movq %rax, %rbx
movl $0x1, %edi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x1ec161
movq %rax, %r12
movl $0x1, %edi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x1ec161
movq %rax, %r14
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1ba6cc
movq %rax, %r15
movq %r12, %rdi
callq 0x1ec2af
movq %r14, %rdi
callq 0x1ec2af
movq %rbx, %rdi
callq 0x1ba690
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/test-pairwise.c
// Function: gt_checkgreedyunitedist
void gt_checkgreedyunitedist(GT_UNUSED bool forward,
                             const GtUchar *useq,
                             GtUword ulen,
                             const GtUchar *vseq,
                             GtUword vlen)
{
  GtUword edist1, edist2;
  GtFrontResource *frontresource = gt_frontresource_new(10UL);
  bool rightextension = true;
  GtSeqabstract *greedyedistuseq, *greedyedistvseq;

  greedyedistuseq
    = gt_seqabstract_new_gtuchar(rightextension,GT_READMODE_FORWARD,
                                 useq,ulen,0,ulen);
  greedyedistvseq
    = gt_seqabstract_new_gtuchar(rightextension,GT_READMODE_FORWARD,
                                 vseq,vlen,0,vlen);
  edist1 = greedyunitedist(frontresource,greedyedistuseq,greedyedistvseq);
  edist2 = gt_squarededistunit (useq,ulen,vseq,vlen);
#ifdef SKDEBUG
  printf("edist = " GT_WU "\n",edist1);
#endif
  if (edist1 != edist2)
  {
    fprintf(stderr,"greedyunitedist = "GT_WU" != "GT_WU
            " = gt_squarededistunit\n", edist1,edist2);
    exit(GT_EXIT_PROGRAMMING_ERROR);
  }
  gt_seqabstract_delete(greedyedistuseq);
  gt_seqabstract_delete(greedyedistvseq);
  gt_frontresource_delete(frontresource);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %rbx
movq %rcx, 0x10(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movl $0xa, %edi
callq 0x1ba644
movq %rax, %r15
movl $0x1, %edi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x1ec161
movq %rax, %rbp
movl $0x1, %edi
xorl %esi, %esi
movq %rbx, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x1ec161
movq %rax, %rbx
movq %r15, 0x8(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x1ba6cc
movq %rax, %r15
movq %r13, %rdi
movq %r12, %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rcx
callq 0x336340
cmpq %rax, %r15
jne 0x20a808
movq %rbp, %rdi
callq 0x1ec2af
movq %rbx, %rdi
callq 0x1ec2af
movq 0x8(%rsp), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1ba690
movq %r15, %rdi
movq %rax, %rsi
callq 0x811ac
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/turnwheels.c
// Function: gt_turningwheel_new
Turningwheel *gt_turningwheel_new(unsigned int numofwheels,
                                  unsigned int asize)
{
  unsigned int i;
  Turningwheel *tw;

  tw = gt_malloc(sizeof (*tw));
  gt_assert(numofwheels < (unsigned int) MAXNUMOFWHEELS);
  gt_assert(numofwheels > 0);
  gt_assert(asize > 0);
  for (i=0; i<numofwheels; i++)
  {
    tw->wheelspace[i] = 0;
  }
  tw->numofwheels = numofwheels;
  tw->asize = asize;
  tw->idx = numofwheels - 1;
  tw->minchanged = 0;
  return tw;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movl %edi, %ebx
leaq 0x1bb45c(%rip), %rsi    # 0x3c5c7f
movl $0x58, %edi
movl $0x26, %edx
callq 0x1092b2
cmpl $0x12, %ebx
jae 0x20a871
testl %ebx, %ebx
je 0x20a876
testl %ebp, %ebp
je 0x20a87b
movq %rax, %r14
leal (,%rbx,4), %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x173a0
movl %ebx, 0x48(%r14)
movl %ebp, 0x4c(%r14)
decl %ebx
movl %ebx, 0x50(%r14)
movl $0x0, 0x54(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x811d3
callq 0x81241
callq 0x8120a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/twobits2kmers.c
// Function: gt_checkkmercode
static void gt_checkkmercode(GT_UNUSED void *processinfo,
                             GT_UNUSED bool firstinrange,
                             GT_UNUSED GtUword pos,
                             GT_UNUSED GtCodetype code)
{
#ifndef NDEBUG
  GtKmercodeiterator *kmercodeiterator = (GtKmercodeiterator *) processinfo;
  const GtKmercode *kmercodeptr;

  gt_assert(kmercodeiterator != NULL);
  kmercodeptr = gt_kmercodeiterator_encseq_nonspecial_next(kmercodeiterator);
  gt_assert(kmercodeptr != NULL && !kmercodeptr->definedspecialposition);
  gt_assert(code == kmercodeptr->code);
#endif
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x20ad31
movq %rcx, %rbx
callq 0x1f80be
testq %rax, %rax
je 0x20ad2c
cmpb $0x1, (%rax)
je 0x20ad2c
cmpq %rbx, 0x8(%rax)
jne 0x20ad36
popq %rbx
retq
callq 0x81505
callq 0x8153e
callq 0x814cc
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/tyr-mersplit.c
// Function: gt_tyrbckinfo_new
Tyrbckinfo *gt_tyrbckinfo_new(const char *tyrindexname,unsigned int alphasize,
                              GtError *err)
{
  size_t numofbytes;
  Tyrbckinfo *tyrbckinfo;
  bool haserr = false;

  tyrbckinfo = gt_malloc(sizeof *tyrbckinfo);
  tyrbckinfo->mappedmbdfileptr = gt_fa_mmap_read_with_suffix(tyrindexname,
                                                          BUCKETSUFFIX,
                                                          &numofbytes,err);
  if (tyrbckinfo->mappedmbdfileptr == NULL)
  {
    haserr = true;
  }
  if (!haserr)
  {
    GtUword pl_long;

    gt_assert(tyrbckinfo->mappedmbdfileptr != NULL);
    pl_long = *((GtUword *) tyrbckinfo->mappedmbdfileptr);
    tyrbckinfo->prefixlength = (unsigned int) pl_long;
    tyrbckinfo->numofcodes
      = gt_power_for_small_exponents(alphasize,tyrbckinfo->prefixlength);
    /*check if numofbytes == expected size*/
    gt_assert(numofbytes == sizeof (GtUword) *
                            (1UL +
                             (tyrbckinfo->numofcodes+1) +
                             GT_NUMOFINTSFORBITS(tyrbckinfo->numofcodes + 1)));
    tyrbckinfo->bounds = ((GtUword *) tyrbckinfo->mappedmbdfileptr) + 1;
    tyrbckinfo->boundisdefined
      = tyrbckinfo->bounds + tyrbckinfo->numofcodes + 1;
    if (tyrbckinfo->prefixlength > 0 && GT_MOD4(tyrbckinfo->prefixlength) > 0)
    {
      tyrbckinfo->remainmask
        = (GtUchar) MAXUCHARVALUEWITHBITS(GT_MULT2(
                                       4U - GT_MOD4(tyrbckinfo->prefixlength)));
    }
  }
  if (haserr)
  {
    gt_free(tyrbckinfo);
    return NULL;
  }
  return tyrbckinfo;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
leaq 0x1baa42(%rip), %r12    # 0x3c5ef4
movl $0x30, %edi
movq %r12, %rsi
movl $0x197, %edx            # imm = 0x197
callq 0x1092b2
movq %rax, %rbx
leaq 0x1baab3(%rip), %rsi    # 0x3c5f81
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rcx
movl $0x19a, %r8d            # imm = 0x19A
movq %r14, %r9
callq 0x102bc0
movq %rax, (%rbx)
testq %rax, %rax
je 0x20b563
movl (%rax), %esi
movl %esi, 0x8(%rbx)
movl %ebp, %edi
callq 0x10af8d
movq %rax, 0x10(%rbx)
leaq 0x1(%rax), %rcx
movq %rax, %rdx
shrq $0x6, %rdx
incq %rdx
cmpq $0x40, %rcx
movl $0x1, %ecx
cmovaeq %rdx, %rcx
addq %rax, %rcx
leaq 0x10(,%rcx,8), %rcx
cmpq %rcx, 0x8(%rsp)
jne 0x20b589
movq (%rbx), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x20(%rbx)
leaq (%rcx,%rax,8), %rax
addq $0x10, %rax
movq %rax, 0x18(%rbx)
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0x20b579
andl $0x3, %eax
je 0x20b579
addl %eax, %eax
movb $0x8, %cl
subb %al, %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
notb %al
movb %al, 0x28(%rbx)
jmp 0x20b579
leaq 0x1ba98a(%rip), %rsi    # 0x3c5ef4
movq %rbx, %rdi
movl $0x1b9, %edx            # imm = 0x1B9
callq 0x109670
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x8173b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/tyr-mersplit.c
// Function: gt_tyrbckinfo_delete
void gt_tyrbckinfo_delete(Tyrbckinfo **tyrbckinfoptr)
{
  Tyrbckinfo *tyrbckinfo = *tyrbckinfoptr;

  gt_fa_xmunmap(tyrbckinfo->mappedmbdfileptr);
  tyrbckinfo->mappedmbdfileptr = NULL;
  gt_free(tyrbckinfo);
  *tyrbckinfoptr = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq (%r14), %rdi
callq 0x102b12
xorl %r15d, %r15d
movq %r15, (%r14)
leaq 0x1ba946(%rip), %rsi    # 0x3c5ef4
movq %r14, %rdi
movl $0x1c5, %edx            # imm = 0x1C5
callq 0x109670
movq %r15, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: adddistpos2distribution
static int adddistpos2distribution(GtUword countocc,
                                   GtUword position,
                                   void *adddistposinfo,
                                   GT_UNUSED GtError *err)
{
  TyrDfsstate *state = (TyrDfsstate *) adddistposinfo;

  incrementdistribcounts(&state->occdistribution,countocc,1UL);
  if (decideifocc(state,countocc))
  {
    state->occdistribution.spaceCountwithpositions[countocc].positionlist
      = insertListUlong(state->occdistribution.
                               spaceCountwithpositions[countocc].positionlist,
                         position);
  }
  if (state->performtest)
  {
    checknumberofoccurrences(state,countocc,position);
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rdi, 0x40(%rdx)
ja 0x20bd9c
movq 0x38(%r14), %rdi
leaq 0x80(%rbx), %r12
movq %r12, %rsi
shlq $0x4, %rsi
leaq 0x1ba2fe(%rip), %rdx    # 0x3c6067
movl $0x133, %ecx            # imm = 0x133
callq 0x1094e6
movq %rax, 0x38(%r14)
movq 0x40(%r14), %rcx
movq %r12, %rdx
subq %rcx, %rdx
jbe 0x20bd98
shlq $0x4, %rcx
addq %rcx, %rax
shlq $0x4, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x173a0
movq %r12, 0x40(%r14)
leaq 0x1(%rbx), %rax
cmpq 0x48(%r14), %rax
jbe 0x20bdaa
movq %rax, 0x48(%r14)
movq 0x38(%r14), %rax
movq %rbx, %r12
shlq $0x4, %r12
incq (%rax,%r12)
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
testq %rdx, %rdx
je 0x20bdd7
testq %rcx, %rcx
je 0x20be98
cmpq %rbx, %rdx
seta %dl
jmp 0x20bddd
testq %rcx, %rcx
sete %dl
cmpq %rbx, %rcx
setb %cl
orb %dl, %cl
jne 0x20be12
movq 0x8(%rax,%r12), %r13
leaq 0x1ba274(%rip), %rsi    # 0x3c6067
movl $0x10, %edi
movl $0x9d, %edx
callq 0x1092b2
movq %r15, (%rax)
movq %r13, 0x8(%rax)
movq 0x38(%r14), %rcx
movq %rax, 0x8(%rcx,%r12)
cmpb $0x1, 0x68(%r14)
jne 0x20be8c
movq (%r14), %rax
testq %rax, %rax
je 0x20be4b
xorl %r12d, %r12d
movq 0x20(%r14), %rdi
leaq (%r15,%r12), %rsi
movl 0x28(%r14), %edx
callq 0xec1f8
movq 0xa8(%r14), %rcx
movb %al, (%rcx,%r12)
incq %r12
movq (%r14), %rax
cmpq %rax, %r12
jb 0x20be24
movq 0x8(%r14), %rcx
movq 0x20(%r14), %rdi
movq 0xa0(%r14), %rsi
movl 0x28(%r14), %r9d
xorl %edx, %edx
xorl %r8d, %r8d
pushq %rax
pushq 0xa8(%r14)
callq 0x1ac81c
addq $0x10, %rsp
movq %rax, %r14
movq %rax, %rdi
callq 0x1ac8db
cmpq %rbx, %rax
jne 0x20bea6
movq %r14, %rdi
callq 0x1ac968
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
cmpq %rbx, %rdx
jbe 0x20bde7
jmp 0x20be12
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8180d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: outputsortedstring2index
static int outputsortedstring2index(GtUword countocc,
                                    GtUword position,
                                    void *adddistposinfo,
                                    GtError *err)
{
  TyrDfsstate *state = (TyrDfsstate *) adddistposinfo;

  if (decideifocc(state,countocc))
  {
    if (outputsortedstring2indexviafileptr(state->encseq,
                                           state->mersize,
                                           state->bytebuffer,
                                           state->sizeofbuffer,
                                           state->merindexfpout,
                                           state->countsfilefpout,
                                           position,
                                           countocc,
                                           &state->largecounts,
                                           state->countoutputmers,
                                           err) != 0)
    {
      return -1;
    }
    state->countoutputmers++;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
testq %rcx, %rcx
je 0x20bee2
testq %rax, %rax
je 0x20bef7
cmpq %r14, %rcx
seta %cl
jmp 0x20bee8
testq %rax, %rax
sete %cl
cmpq %r14, %rax
setb %al
orb %cl, %al
je 0x20bf00
jmp 0x20bfe2
cmpq %r14, %rcx
ja 0x20bfe2
movq (%rbx), %rcx
movq 0x20(%rbx), %rsi
movq 0x70(%rbx), %r12
movq 0x78(%rbx), %r13
movq 0x50(%rbx), %rbp
movq 0x58(%rbx), %r15
movq 0x98(%rbx), %rax
movq %rax, 0x10(%rsp)
movq %r12, %rdi
callq 0xebc4c
movl $0x1, %esi
movq %r12, %rdi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x125658
testq %r15, %r15
je 0x20bfdb
cmpq $0xff, %r14
jbe 0x20bfc1
movq 0x88(%rbx), %rsi
cmpq %rsi, 0x90(%rbx)
jb 0x20bf8e
addq $0x20, %rsi
movq %rsi, 0x88(%rbx)
movq 0x80(%rbx), %rdi
shlq $0x4, %rsi
leaq 0x1ba0ea(%rip), %rdx    # 0x3c6067
movl $0x175, %ecx            # imm = 0x175
callq 0x1094e6
movq %rax, 0x80(%rbx)
movq 0x80(%rbx), %rax
testq %rax, %rax
je 0x20bff3
movq 0x90(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x90(%rbx)
shlq $0x4, %rcx
movq 0x10(%rsp), %rdx
movq %rdx, (%rax,%rcx)
movq %r14, 0x8(%rax,%rcx)
xorl %r14d, %r14d
leaq 0xf(%rsp), %rdi
movb %r14b, (%rdi)
movl $0x1, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x125658
incq 0x98(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x81834
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: tyr_processleafedge
static int tyr_processleafedge(GT_UNUSED bool firstsucc,
                           GtUword fatherdepth,
                           GT_UNUSED Dfsinfo *father,
                           GtUword leafnumber,
                           Dfsstate *astate,
                           GtError *err)
{
  TyrDfsstate *state = (TyrDfsstate*) astate;
  gt_error_check(err);
  if (fatherdepth < state->mersize &&
      leafnumber + state->mersize <= state->totallength &&
      !gt_encseq_contains_special(state->encseq,
                                  state->readmode,
                                  state->esrspace,
                                  leafnumber + fatherdepth,
                                  state->mersize - fatherdepth))
  {
    if (state->processoccurrencecount(1UL,leafnumber,state,err) != 0)
    {
      return -1;
    }
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %rbx
movq %rcx, %r15
movq %rsi, %r12
testq %r9, %r9
je 0x20c044
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x20c09c
movq (%rbx), %rax
movq %rax, %r8
subq %r12, %r8
jbe 0x20c08e
addq %r15, %rax
cmpq 0x8(%rbx), %rax
ja 0x20c08e
movq 0x20(%rbx), %rdi
movl 0x28(%rbx), %esi
movq 0x60(%rbx), %rdx
addq %r15, %r12
movq %r12, %rcx
callq 0xed3e1
testb %al, %al
jne 0x20c08e
movl $0x1, %edi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq *0x30(%rbx)
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x20c090
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x8186d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: tyr_processcompletenode
static int tyr_processcompletenode(GtUword nodeptrdepth,
                               Dfsinfo *anodeptr,
                               GtUword nodeptrminusonedepth,
                               Dfsstate *astate,
                               GtError *err)
{
  TyrDfsinfo *nodeptr = (TyrDfsinfo*) anodeptr;
  TyrDfsstate *state = (TyrDfsstate*) astate;
  gt_error_check(err);
  if (state->mersize <= nodeptrdepth)
  {
    GtUword fatherdepth;

    fatherdepth = nodeptr->lcptabrightmostleafplus1;
    if (fatherdepth < nodeptrminusonedepth)
    {
      fatherdepth = nodeptrminusonedepth;
    }
    if (fatherdepth < state->mersize)
    {
      if (state->processoccurrencecount((GtUword)
                                        (nodeptr->rightmostleaf -
                                         nodeptr->leftmostleaf + 1),
                                        nodeptr->suftabrightmostleaf,
                                        state,
                                        err) != 0)
      {
        return -1;
      }
    }
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r13
testq %r8, %r8
je 0x20c0ca
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x20c112
movq (%rbx), %rcx
xorl %eax, %eax
cmpq %r13, %rcx
ja 0x20c108
movq 0x18(%r15), %rax
cmpq %r12, %rax
cmovaq %rax, %r12
cmpq %rcx, %r12
jae 0x20c106
movq 0x8(%r15), %rdi
movq 0x10(%r15), %rsi
subq (%r15), %rdi
incq %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq *0x30(%rbx)
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x20c108
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x818a6
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq 0x10(%r8), %r13
movq 0x20(%r8), %rcx
leaq 0x1(%rsi), %rax
movq %rcx, 0x10(%rsp)
cmpq %rcx, %rax
setbe %al
addq %rsi, %rbx
cmpq %r13, %rbx
setb %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x20c368
movq %rsi, %r14
movq 0x28(%r8), %rax
movq %rax, 0x8(%rsp)
movq (%r8), %r12
movl 0x8(%r8), %ebp
movq 0x18(%r8), %r15
addq $0x2, %r14
movq %r12, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0xec1f8
cmpb $-0x3, %al
ja 0x20c368
leaq -0x1(%r14), %rsi
cmpq %r15, %rsi
jb 0x20c352
movl $0x1, %edx
movq 0x8(%rsp), %rdi
callq 0x20c400
incq %rbx
cmpq %r13, %rbx
jae 0x20c368
leaq 0x1(%r14), %rax
cmpq 0x10(%rsp), %r14
movq %rax, %r14
jbe 0x20c329
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq %rsi, 0x8(%rdi)
ja 0x20c463
movq (%r15), %rdi
leaq 0x80(%r14), %r12
leaq 0x400(,%r14,8), %rsi
leaq 0x1b9f22(%rip), %rdx    # 0x3c6352
movl $0x48, %ecx
callq 0x1094e6
movq %rax, (%r15)
movq 0x8(%r15), %rcx
cmpq %r12, %rcx
jae 0x20c45f
leaq (%rax,%rcx,8), %rdi
movq %r14, %rax
subq %rcx, %rax
leaq 0x400(,%rax,8), %rdx
xorl %esi, %esi
callq 0x173a0
movq %r12, 0x8(%r15)
leaq 0x1(%r14), %rax
cmpq 0x10(%r15), %rax
jbe 0x20c471
movq %rax, 0x10(%r15)
movq (%r15), %rax
addq %rbx, (%rax,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %rsi
movq (%rdx), %rdi
movq 0x20(%rdx), %rdx
callq 0xebbcc
movq (%r15), %rdx
testq %r14, %r14
je 0x20c4b9
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x20ad3c
movq 0x10(%r15), %rcx
movq 0x18(%r15), %r8
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x3368d1
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/tyr-search.c
// Function: mermatchoutput
static void mermatchoutput(const Tyrindex *tyrindex,
                           const Tyrcountinfo *tyrcountinfo,
                           const Tyrsearchinfo *tyrsearchinfo,
                           const GtUchar *result,
                           const GtUchar *query,
                           const GtUchar *qptr,
                           uint64_t unitnum,
                           bool forward)
{
  bool firstitem = true;
  GtUword queryposition;

  queryposition = (GtUword) (qptr-query);
  if (tyrsearchinfo->showmode & SHOWQSEQNUM)
  {
    printf(Formatuint64_t,PRINTuint64_tcast(unitnum));
    firstitem = false;
  }
  if (tyrsearchinfo->showmode & SHOWQPOS)
  {
    ADDTABULATOR;
    printf("%c"GT_WU"",forward ? '+' : '-',queryposition);
  }
  if (tyrsearchinfo->showmode & SHOWCOUNTS)
  {
    GtUword mernumber = gt_tyrindex_ptr2number(tyrindex,result);
    ADDTABULATOR;
    printf(""GT_WU"",gt_tyrcountinfo_get(tyrcountinfo,mernumber));
  }
  if (tyrsearchinfo->showmode & SHOWSEQUENCE)
  {
    ADDTABULATOR;
    gt_alphabet_decode_seq_to_fp(tyrsearchinfo->dnaalpha,
                                 stdout,
                                 qptr,
                                 tyrsearchinfo->mersize);
  }
  if (tyrsearchinfo->showmode & (SHOWSEQUENCE | SHOWQPOS | SHOWCOUNTS))
  {
    (void) putchar('\n');
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, (%rsp)
movq %r8, %rbp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, 0x10(%rsp)
movq %rdi, %r13
movb 0x58(%rsp), %r12b
movb $0x1, %r15b
testb $0x1, 0x28(%rdx)
je 0x20ca06
movq 0x50(%rsp), %rsi
leaq 0x1b8c30(%rip), %rdi    # 0x3c562c
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x17070
testb $0x2, 0x28(%rbx)
je 0x20ca57
movq %r13, 0x8(%rsp)
movq %r14, %r13
movq (%rsp), %r14
subq %rbp, %r14
testb %r15b, %r15b
je 0x20ca25
xorl %r15d, %r15d
jmp 0x20ca2f
movl $0x9, %edi
callq 0x17a20
xorb $0x1, %r12b
movzbl %r12b, %eax
leal 0x2b(,%rax,2), %esi
leaq 0x1b99a2(%rip), %rdi    # 0x3c63e7
movq %r14, %rdx
xorl %eax, %eax
callq 0x17070
movq %r13, %r14
movq 0x8(%rsp), %r13
testb $0x4, 0x28(%rbx)
je 0x20ca9d
movq %r13, %rdi
movq %r14, %rsi
callq 0x3366bc
movq %rax, %r14
testb %r15b, %r15b
je 0x20ca75
xorl %r15d, %r15d
jmp 0x20ca7f
movl $0x9, %edi
callq 0x17a20
movq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x336835
leaq 0x1b8b99(%rip), %rdi    # 0x3c562c
movq %rax, %rsi
xorl %eax, %eax
callq 0x17070
testb $0x8, 0x28(%rbx)
je 0x20cacd
testb %r15b, %r15b
jne 0x20cab2
movl $0x9, %edi
callq 0x17a20
movq 0x20(%rbx), %rcx
movq 0x30(%rbx), %rdi
movq 0x2b7427(%rip), %rax    # 0x4c3ee8
movq (%rax), %rsi
movq (%rsp), %rdx
callq 0xd394b
testb $0xe, 0x28(%rbx)
je 0x20caeb
movl $0xa, %edi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17a20
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x1b9691(%rip), %rsi    # 0x3c641f
movl $0x48, %edi
movl $0xae, %edx
callq 0x1092b2
movq %r14, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movl (%r14), %ebp
testl %ebp, %ebp
jle 0x20ce41
movq %rax, %rbx
testb $0x1, %bpl
jne 0x20cdd1
movl 0x4(%r14), %edx
movl 0x8(%r14), %eax
movl 0xc(%r14), %ecx
jmp 0x20cde5
addl %ebp, %ebp
movl 0x4(%r14), %edx
movl 0x8(%r14), %eax
addl %edx, %edx
addl %eax, %eax
movl 0xc(%r14), %ecx
addl %ecx, %ecx
movl %ebp, %r14d
subl %edx, %r14d
jl 0x20ce3c
shrl %ebp
movl %ebp, %r15d
subl %eax, %r15d
jl 0x20ce3c
subl %ecx, %ebp
jl 0x20ce3c
movl %r14d, %edi
movl %r15d, %esi
callq 0x10b0ea
movl %eax, %edi
movl %ebp, %esi
callq 0x10b0ea
movl %eax, %ecx
movl %eax, 0x14(%rbx)
movl %r14d, %eax
cltd
idivl %ecx
movl %eax, 0x8(%rbx)
movl %r15d, %eax
cltd
idivl %ecx
movl %eax, 0xc(%rbx)
movl %ebp, %eax
cltd
idivl %ecx
movl %eax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x81ade
callq 0x81aa5
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x20cec7
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x20ce7f
leaq 0x18(%rbx), %r14
leaq 0x1b95b9(%rip), %rsi    # 0x3c641f
movl $0xbb, %edx
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x20ceac
leaq 0x30(%rbx), %r14
leaq 0x1b958c(%rip), %rsi    # 0x3c641f
movl $0xbc, %edx
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x1b956c(%rip), %rsi    # 0x3c641f
movq %rbx, %rdi
movl $0xbd, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r15
movq %rdi, %r14
leaq 0x1(%rsi), %r12
imulq %rsi, %r12
addq %rdx, %r12
cmpq 0x20(%rdi), %r12
jb 0x20d803
leaq 0x20(%r12), %rsi
movq %rsi, 0x20(%r14)
movq 0x18(%r14), %rdi
shlq $0x4, %rsi
leaq 0x1b8c2a(%rip), %rdx    # 0x3c641f
movl $0xda, %ecx
callq 0x1094e6
movq %rax, 0x18(%r14)
movq 0x18(%r14), %rax
movq %r12, %rcx
shlq $0x4, %rcx
movq %r15, (%rax,%rcx)
movb %bl, 0x8(%rax,%rcx)
incq %r12
movq %r12, 0x28(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
leaq 0x1b9ad5(%rip), %rdx    # 0x3c7870
movl $0x1, %edi
movl $0x40, %esi
movl $0x2b, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x10ff7c
movq %rax, 0x8(%rbx)
callq 0x1208f8
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x20de01
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x121b03
movq (%rbx), %rdi
callq 0x1040fc
movq 0x8(%rbx), %rdi
callq 0x110231
leaq 0x1b9a7d(%rip), %rsi    # 0x3c7870
movq %rbx, %rdi
movl $0x38, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x20dec6
movq %rdi, %rbx
leaq 0x1b9a94(%rip), %rdi    # 0x3c78ae
leaq 0x1b9ab4(%rip), %rsi    # 0x3c78d5
callq 0x10cc4e
movq %rax, %r14
leaq 0x18(%rbx), %rdx
leaq 0x1b9abb(%rip), %rdi    # 0x3c78ef
leaq 0x1b9abb(%rip), %rsi    # 0x3c78f6
movl $0x64, %r9d
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10f81b
movq %rax, %r15
movq %rax, %rdi
callq 0x10fa96
movq %r14, %rdi
movq %r15, %rsi
callq 0x10cd10
leaq 0x20(%rbx), %rdx
leaq 0x1b9b06(%rip), %rdi    # 0x3c7972
leaq 0x1b9b06(%rip), %rsi    # 0x3c7979
movl $0x64, %r9d
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10f81b
movq %rax, %r15
movq %rax, %rdi
callq 0x10fa96
movq %r14, %rdi
movq %r15, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10fa96
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10ffa3
movq %r14, %rdi
movl $0x1, %esi
callq 0x10d766
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x81d51
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq 0x50(%rsi), %rsi
testq %rsi, %rsi
je 0x20e05d
leaq 0x1b99d2(%rip), %rdi    # 0x3c7a28
xorl %eax, %eax
callq 0x125448
movq (%r14), %rdi
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x20e0a6
callq 0x120d4c
testq %rax, %rax
je 0x20e0a6
movq (%r14), %rdi
callq 0x120d23
movq %rax, %rdi
callq 0x10415c
testb %al, %al
jne 0x20e0a6
movq (%r14), %rdi
callq 0x120d23
leaq 0x1b9a0d(%rip), %rsi    # 0x3c7aa1
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
leaq 0x1b99de(%rip), %rdx    # 0x3c7abb
movl $0x1, %edi
movl $0x110, %esi            # imm = 0x110
movl $0x59, %ecx
callq 0x1093ef
movq %rax, %rbx
movl $0x110, %edx            # imm = 0x110
movq %rax, %rdi
xorl %esi, %esi
callq 0x173a0
callq 0x1208f8
movq %rax, (%rbx)
callq 0x1208f8
movq %rax, 0x8(%rbx)
callq 0x1208f8
movq %rax, 0x10(%rbx)
callq 0x10ff7c
movq %rax, 0x20(%rbx)
callq 0x121b54
movq %rax, 0x30(%rbx)
callq 0x17b020
movq %rax, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x20e199
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x121b03
movq 0x8(%rbx), %rdi
callq 0x121b03
movq 0x10(%rbx), %rdi
callq 0x121b03
movq 0x30(%rbx), %rdi
callq 0x121e8b
movq 0x28(%rbx), %rdi
callq 0x1040fc
movq 0x20(%rbx), %rdi
callq 0x110231
movq 0x38(%rbx), %rdi
callq 0x17b067
leaq 0x1b9930(%rip), %rsi    # 0x3c7abb
movq %rbx, %rdi
movl $0x6f, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
leaq 0x1b923c(%rip), %rbx    # 0x3c8283
movl $0x1, %edi
movl $0xf8, %esi
movq %rbx, %rdx
movl $0x93, %ecx
callq 0x1093ef
movq %rax, %r14
callq 0x10ff7c
movq %rax, (%r14)
callq 0x1208f8
movq %rax, 0x18(%r14)
callq 0x1208f8
movq %rax, 0x20(%r14)
callq 0x1208f8
movq %rax, 0x10(%r14)
callq 0x1208f8
movq %rax, 0x28(%r14)
callq 0x1208f8
movq %rax, 0x30(%r14)
callq 0x1208f8
movq %rax, 0x38(%r14)
movl $0x1, %edi
movl $0x10, %esi
movq %rbx, %rdx
movl $0x9b, %ecx
callq 0x1093ef
movq %rax, 0xf0(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x20f199
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1040fc
movq (%rbx), %rdi
callq 0x110231
movq 0x18(%rbx), %rdi
callq 0x121b03
movq 0x20(%rbx), %rdi
callq 0x121b03
movq 0x10(%rbx), %rdi
callq 0x121b03
movq 0x28(%rbx), %rdi
callq 0x121b03
movq 0x30(%rbx), %rdi
callq 0x121b03
movq 0x38(%rbx), %rdi
callq 0x121b03
movq 0xe8(%rbx), %rdi
callq 0x10f386
movq 0xe0(%rbx), %rdi
callq 0x10f386
movq 0xd8(%rbx), %rdi
callq 0x10f386
movq 0xc0(%rbx), %rdi
callq 0x10f386
movq 0xc8(%rbx), %rdi
callq 0x10f386
movq 0xd0(%rbx), %rdi
callq 0x10f386
movq 0xf0(%rbx), %rdi
leaq 0x1b910e(%rip), %r14    # 0x3c8283
movq %r14, %rsi
movl $0xb1, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0xb2, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe6a03
cmpq $0x0, 0x2b96fe(%rip)    # 0x4c9968
jne 0x21028b
leaq 0x26(%rip), %rsi        # 0x210299
leaq 0x88(%rip), %rdx        # 0x210302
movl $0x50, %edi
callq 0x16abb4
movq %rax, 0x2b96dd(%rip)    # 0x4c9968
callq 0xe6a19
movq 0x2b96d1(%rip), %rax    # 0x4c9968
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x21025c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x2102e9
xorl %r14d, %r14d
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %rdi
callq 0x14c43a
incq %r14
movq 0x18(%rbx), %rdi
callq 0xd4a9a
cmpq %rax, %r14
jb 0x2102c4
movq 0x18(%rbx), %rdi
callq 0xd4ef4
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x16ac6e
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, (%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
callq 0x21025c
movq %rax, %rdi
xorl %esi, %esi
callq 0x16abec
movq %rax, %rbp
callq 0x21025c
movq %rax, %rdi
movq %rbp, %rsi
callq 0x16ae64
movq %rax, %rbx
movq %r13, %rdi
callq 0x16ac58
movq %rax, 0x10(%rbx)
movl $0x8, %edi
callq 0xd46fc
movq %rax, 0x18(%rbx)
movq %r12, 0x20(%rbx)
movb $0x1, 0x38(%rbx)
movq $0x0, 0x40(%rbx)
movq %r15, 0x28(%rbx)
movq %r14, 0x48(%rbx)
movq (%rsp), %rax
movq %rax, 0x30(%rbx)
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/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 0xe6a03
cmpq $0x0, 0x2b8aaa(%rip)    # 0x4c9970
jne 0x210ee7
leaq 0x26(%rip), %rsi        # 0x210ef5
leaq 0xa3(%rip), %rdx        # 0x210f79
movl $0x88, %edi
callq 0x16abb4
movq %rax, 0x2b8a89(%rip)    # 0x4c9970
callq 0xe6a19
movq 0x2b8a7d(%rip), %rax    # 0x4c9970
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/ltr/ltr_cluster_stream.c
// Function: gt_ltr_cluster_stream_free
static void gt_ltr_cluster_stream_free(GtNodeStream *ns)
{
  GtUword i;
  GtLTRClusterStream *lcs = gt_ltr_cluster_stream_cast(ns);
  gt_node_visitor_delete((GtNodeVisitor*) lcs->lcv);
  gt_hashmap_delete(lcs->feat_to_encseq);
  gt_str_array_delete(lcs->feat_to_encseq_keys);
  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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x210eb8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0x16b162
movq 0x28(%rbx), %rdi
callq 0x105f7d
movq 0x30(%rbx), %rdi
callq 0x121e8b
movq 0x20(%rbx), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x210f60
xorl %r14d, %r14d
movq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %rdi
callq 0x14c43a
incq %r14
movq 0x20(%rbx), %rdi
callq 0xd4a9a
cmpq %rax, %r14
jb 0x210f3b
movq 0x20(%rbx), %rdi
callq 0xd4ef4
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x16ac6e