LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/myersapm.c
// Function: gt_freeMyersonlineresources
void gt_freeMyersonlineresources(Myersonlineresources *ptrmyersonlineresources)
{
  if (ptrmyersonlineresources != NULL)
  {
    gt_free(ptrmyersonlineresources->eqsvectorrev);
    gt_free(ptrmyersonlineresources->eqsvector);
    gt_encseq_reader_delete(ptrmyersonlineresources->esr);
    gt_free(ptrmyersonlineresources);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x3204f8
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0xc402d(%rip), %r14     # 0x3e44e8
movq %r14, %rsi
movl $0x44, %edx
callq 0x1045eb
movq 0x20(%rbx), %rdi
movq %r14, %rsi
movl $0x45, %edx
callq 0x1045eb
movq (%rbx), %rdi
callq 0xe9204
movq %rbx, %rdi
movq %r14, %rsi
movl $0x47, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/radixsort_str.c
// Function: gt_radixsort_str_new
GtRadixsortstringinfo *gt_radixsort_str_new(const GtTwobitencoding
                                             *twobitencoding,
                                            GtUword realtotallength,
                                            GtUword equallengthplus1,
                                            GtUword maxwidth)
{
  GtRadixsortstringinfo *rsi = gt_malloc(sizeof(*rsi));

  rsi->twobitencoding = twobitencoding;
  rsi->equallengthplus1 = equallengthplus1;
  rsi->realtotallength = realtotallength;
  rsi->maxwidth = maxwidth/2;
  rsi->bytesinsizesofbuckets = sizeof (*rsi->sizesofbuckets) *
                               GT_RADIXSORT_STR_NOFBUCKETS;
  rsi->sizesofbuckets = gt_malloc(rsi->bytesinsizesofbuckets);
  rsi->sorted = gt_malloc(sizeof (*rsi->sorted) * rsi->maxwidth);
  rsi->oracle = gt_malloc(sizeof (*rsi->oracle) * rsi->maxwidth);
  rsi->xorvalue2lcp = gt_radixsort_str_init_xorvalue2lcp();
  GT_STACK_INIT(&rsi->stack, 1024UL);
  return rsi;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
leaq 0xc3e44(%rip), %r14     # 0x3e455a
movl $0x8080, %edi           # imm = 0x8080
movq %r14, %rsi
movl $0x88, %edx
callq 0x104226
movq %rax, %rbx
movq %rbp, (%rax)
movq %r12, 0x10(%rax)
movq %r13, 0x18(%rax)
shrq %r15
movq %r15, 0x20(%rax)
movq $0x2008, 0x8(%rax)      # imm = 0x2008
movl $0x2008, %edi           # imm = 0x2008
movq %r14, %rsi
movl $0x90, %edx
callq 0x104226
movq %rax, 0x28(%rbx)
movq 0x20(%rbx), %rdi
shlq $0x3, %rdi
movq %r14, %rsi
movl $0x91, %edx
callq 0x104226
movq %rax, 0x30(%rbx)
movq 0x20(%rbx), %rdi
addq %rdi, %rdi
movq %r14, %rsi
movl $0x92, %edx
callq 0x104226
movq %rax, 0x38(%rbx)
movl $0x100, %edi            # imm = 0x100
movq %r14, %rsi
movl $0x6d, %edx
callq 0x104226
movq %rax, %r14
movb $0x4, %bpl
movl $0x1, %r12d
xorl %r15d, %r15d
xorl %edi, %edi
testq %r15, %r15
je 0x3207cc
testb %bpl, %bpl
je 0x320855
movl $0x1, %r12d
movl %r15d, %ecx
shlq %cl, %r12
decb %bpl
movq %r12, %rdx
subq %rdi, %rdx
jbe 0x3207e3
addq %r14, %rdi
movzbl %bpl, %esi
callq 0x173a0
movq %r12, %rdi
addq $0x2, %r15
cmpq $0x8, %r15
jne 0x3207af
cmpq $0xff, %rdi
ja 0x32080e
movq %r14, %rax
addq %rdi, %rax
movl $0x100, %edx            # imm = 0x100
subq %rdi, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x173a0
movq %r14, 0x40(%rbx)
movl $0x400, %eax            # imm = 0x400
movq %rax, 0x60(%rbx)
movq %rax, 0x68(%rbx)
movq %rax, 0x48(%rbx)
movq %rbx, %rax
addq $0x70, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movq %rax, 0x8070(%rbx)
movq $0x0, 0x8078(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x9411c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/radixsort_str.c
// Function: gt_radixsort_str_delete
void gt_radixsort_str_delete(GtRadixsortstringinfo *rsi)
{
  if (rsi != NULL)
  {
    gt_free(rsi->sizesofbuckets);
    gt_free(rsi->sorted);
    gt_free(rsi->oracle);
    gt_free(rsi->xorvalue2lcp);
    GT_STACK_DELETE(&rsi->stack);
    gt_free(rsi);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x3208fd
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
leaq 0xc3ce5(%rip), %r14     # 0x3e455a
movq %r14, %rsi
movl $0x9c, %edx
callq 0x1045eb
movq 0x30(%rbx), %rdi
movq %r14, %rsi
movl $0x9d, %edx
callq 0x1045eb
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x9e, %edx
callq 0x1045eb
movq 0x40(%rbx), %rdi
movq %r14, %rsi
movl $0x9f, %edx
callq 0x1045eb
movq 0x48(%rbx), %rax
cmpq 0x60(%rbx), %rax
jbe 0x3208e2
movq 0x8070(%rbx), %rdi
leaq 0xc3c8d(%rip), %rsi     # 0x3e455a
movl $0xa0, %edx
callq 0x1045eb
movq $0x0, 0x8070(%rbx)
leaq 0xc3c71(%rip), %rsi     # 0x3e455a
movq %rbx, %rdi
movl $0xa1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/randomcodes-sfx-partssuf.c
// Function: gt_suftabparts_rc_variance
double gt_suftabparts_rc_variance(const GtSuftabparts_rc *suftabparts_rc)
{

  gt_assert(suftabparts_rc->numofparts > 0);
  if (suftabparts_rc->numofparts == 1U)
  {
    return 0.0;
  } else
  {
    double meanwidth, difference, sum = 0.0;
    unsigned int part;

    meanwidth = (double)
      suftabparts_rc->components[suftabparts_rc->numofparts-1].sumofwidth/
      suftabparts_rc->numofparts;
    for (part = 0; part < suftabparts_rc->numofparts; part++)
    {
      difference = (double) suftabparts_rc->components[part].widthofpart
                   - meanwidth;
      sum += difference * difference;
    }
    return sum/(double) (suftabparts_rc->numofparts-1);
  }
}

// Assembly:
pushq %rax
movl 0xc(%rdi), %eax
xorpd %xmm0, %xmm0
cmpq $0x1, %rax
je 0x323971
testl %eax, %eax
je 0x323973
movq (%rdi), %rcx
leal -0x1(%rax), %edx
leaq (%rdx,%rdx,2), %rsi
shlq $0x4, %rsi
movsd 0x18(%rcx,%rsi), %xmm0
unpcklps 0x23fe1(%rip), %xmm0    # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x23fe9(%rip), %xmm0    # 0x3478f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd %xmm0, %xmm1
addq $0x8, %rcx
xorpd %xmm0, %xmm0
movsd 0x23fb1(%rip), %xmm2    # 0x3478e0
movapd 0x23fb9(%rip), %xmm3    # 0x3478f0
movsd (%rcx), %xmm4
unpcklps %xmm2, %xmm4            # xmm4 = xmm4[0],xmm2[0],xmm4[1],xmm2[1]
subpd %xmm3, %xmm4
movapd %xmm4, %xmm5
unpckhpd %xmm4, %xmm5            # xmm5 = xmm5[1],xmm4[1]
addsd %xmm4, %xmm5
subsd %xmm1, %xmm5
mulsd %xmm5, %xmm5
addsd %xmm5, %xmm0
addq $0x30, %rcx
decq %rax
jne 0x323937
movl %edx, %eax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
popq %rax
retq
callq 0x947fe
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/randomcodes-tab.c
// Function: gt_randomcodes_countocc_new
void gt_randomcodes_countocc_new(GtFirstcodesspacelog *fcsl,
                                       GtRandomcodestab *rct,
                                       GtUword numofsequences)
{
  rct->countocc_small = gt_calloc((size_t) (numofsequences+1),
                                  sizeof (*rct->countocc_small));
  GT_FCI_ADDWORKSPACE(fcsl,"countocc_small",
                      sizeof (*rct->countocc_small) *
                      (numofsequences+1));
  rct->countocc_exceptions = ul_u32_gt_hashmap_new();
  gt_assert(rct->countocc_exceptions != NULL);
  rct->outfilenameleftborder = NULL;
  rct->leftborder_samples = NULL;
#if defined (_LP64) || defined (_WIN64)
  rct->modvaluebits = 32U; /* XXX remove the following later */
  if (rct->modvaluebits == 32U)
  {
    rct->modvaluemask = UINT32_MAX;
  } else
  {
    rct->modvaluemask = (uint32_t) ((1UL << rct->modvaluebits) - 1);
  }
  GT_INITARRAY(&rct->bitchangepoints,GtUword);
#endif
  rct->differentcodes = numofsequences;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1(%rdx), %r12
leaq 0xc0a1d(%rip), %r13     # 0x3e4bee
movl $0x1, %esi
movq %r12, %rdi
movq %r13, %rdx
movl $0x27, %ecx
callq 0x10436a
movq %rax, 0x48(%r14)
movq %r12, (%rsp)
leaq 0xbe7d9(%rip), %r8      # 0x3e29ce
movq %r15, %rdi
movl $0x2a, %esi
movq %r13, %rdx
movl $0x1, %ecx
movl $0x1, %r9d
callq 0x316945
movups 0x199619(%rip), %xmm0   # 0x4bd830
movups %xmm0, 0x20(%rsp)
movups 0x1995fd(%rip), %xmm0   # 0x4bd820
movups %xmm0, 0x10(%rsp)
movups 0x1995e1(%rip), %xmm0   # 0x4bd810
movups %xmm0, (%rsp)
callq 0x101194
movq %rax, 0x50(%r14)
testq %rax, %rax
je 0x32427b
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%r14)
movabsq $0x20ffffffff, %rax     # imm = 0x20FFFFFFFF
movq %rax, 0x78(%r14)
movups %xmm0, 0x80(%r14)
movq $0x0, 0x90(%r14)
movq %rbx, (%r14)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x94c70
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/randomcodes-tab.c
// Function: gt_randomcodes_remdups
GtUword gt_randomcodes_remdups(GtUword *allrandomcodes,
    unsigned int codesize, GtUword numofcodes, GtLogger *logger)
{
  GtUword numofdifferentcodes = 0,
                shift = (GtUword)GT_MULT2(GT_UNITSIN2BITENC - codesize);
  if (numofcodes != 0)
  {
    GtUword *storeptr, *readptr;

    for (storeptr = allrandomcodes, readptr = allrandomcodes+1;
         readptr < allrandomcodes + numofcodes;
         readptr++)
    {
      if ((*storeptr ^ *readptr) << shift)
      {
        storeptr++;
        *storeptr = *readptr;
      }
    }
    numofdifferentcodes = (GtUword) (storeptr - allrandomcodes + 1);
    if (numofdifferentcodes < numofcodes)
    {
#ifdef SKDEBUG
      checkcodesorder(allrandomcodes,numofdifferentcodes,false);
#endif
    }
  }
  gt_logger_log(logger,"number of different bucket codes="GT_WU" (%.2f%%) "
                       "of "GT_WU" sampled codes",
                numofdifferentcodes,
                100.00 * (double) numofdifferentcodes/numofcodes,
                numofcodes);
  return numofdifferentcodes;
}

// Assembly:
pushq %rbx
movq %rcx, %r8
movq %rdx, %rax
testq %rdx, %rdx
je 0x32433f
movq %rdi, %rbx
cmpq $0x2, %rax
jl 0x324333
addl %esi, %esi
movl $0x40, %ecx
subl %esi, %ecx
leaq (%rdi,%rax,8), %rdx
leaq 0x8(%rdi), %rsi
movq (%rdi), %r9
movq %rdi, %rbx
movq (%rsi), %r10
movq %r10, %r11
xorq %r9, %r11
shlq %cl, %r11
testq %r11, %r11
je 0x32432a
movq %r10, 0x8(%rbx)
addq $0x8, %rbx
movq %r10, %r9
addq $0x8, %rsi
cmpq %rdx, %rsi
jb 0x32430e
subq %rdi, %rbx
sarq $0x3, %rbx
incq %rbx
jmp 0x324341
xorl %ebx, %ebx
movq %rbx, %xmm1
movq 0x23592(%rip), %xmm2    # 0x3478e0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x23596(%rip), %xmm3    # 0x3478f0
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x2546e(%rip), %xmm0    # 0x3497e0
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
leaq 0xc08b1(%rip), %rsi     # 0x3e4c47
movq %r8, %rdi
movq %rbx, %rdx
movq %rax, %rcx
movb $0x1, %al
callq 0x103fe1
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/randomcodes-tab.c
// Function: gt_randomcodes_countocc_get
static uint32_t gt_randomcodes_countocc_get(const GtRandomcodestab *rct,
                                           GtUword idx)
{
  if (rct->countocc_small[idx] != GT_RANDOMCODES_COUNTOCC_OVERFLOW)
  {
    return (uint32_t) rct->countocc_small[idx];
  } else
  {
    uint32_t *valueptr = ul_u32_gt_hashmap_get(rct->countocc_exceptions,idx);

    gt_assert(valueptr != NULL);
    return *valueptr + (uint32_t) GT_RANDOMCODES_MAXSMALL;
  }
}

// Assembly:
pushq %rax
movq 0x48(%rdi), %rax
movzbl (%rax,%rsi), %eax
cmpl $0xff, %eax
jne 0x32492b
movq 0x50(%rdi), %rdi
movq %rsp, %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x1012ee
testq %rax, %rax
je 0x32492d
movq %rax, %rcx
movl $0xfe, %eax
addl 0x8(%rcx), %eax
popq %rcx
retq
callq 0x94f1a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/randomcodes-tab.c
// Function: gt_randomcodes_get_leftborder
GtUword gt_randomcodes_get_leftborder(const GtRandomcodestab *rct,
                                           GtUword idx)
{
#if defined (_LP64) || defined (_WIN64)
  GT_CHANGEPOINT_GET_RCT(changepoint);

  return (GtUword) rct->leftborder[idx]
                         + (changepoint << rct->modvaluebits);
#else
  return (GtUword) rct->leftborder[idx];
#endif
}

// Assembly:
movq 0x90(%rdi), %rcx
testq %rcx, %rcx
je 0x324976
movq 0x80(%rdi), %rdx
xorl %eax, %eax
cmpq %rsi, (%rdx,%rax,8)
jae 0x324978
incq %rax
cmpq %rax, %rcx
jne 0x324963
movq %rcx, %rax
jmp 0x324978
xorl %eax, %eax
movb 0x7c(%rdi), %cl
shlq %cl, %rax
movq 0x40(%rdi), %rcx
movl (%rcx,%rsi,4), %ecx
addq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/randomcodes-tab.c
// Function: gt_randomcodes_findfirstsamplelarger
GtUword gt_randomcodes_findfirstsamplelarger(const GtRandomcodestab *rct,
                                                  GtUword suftaboffset)
{
  GtUword left = 0, right, mid, midval, found;

  right = found = rct->numofsamples;
  while (left+1 < right)
  {
    mid = GT_DIV2(left+right);
    midval = gt_randomcodes_get_sample(rct,mid);
    if (suftaboffset == midval)
    {
      return mid;
    }
    if (suftaboffset < midval)
    {
      found = mid;
      right = mid - 1;
    } else
    {
      left = mid + 1;
    }
  }
  gt_assert(suftaboffset <= gt_randomcodes_get_sample(rct,found));
  return found;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
cmpq $0x2, %r12
jb 0x3249e7
xorl %r13d, %r13d
movq %r12, %rbp
movq %r13, %r15
addq %rbp, %r15
shrq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x324939
cmpq %rbx, %rax
je 0x3249fa
ja 0x3249d5
incq %r15
movq %r15, %r13
movq %r12, %r15
jmp 0x3249dc
leaq -0x1(%r15), %rbp
movq %r15, %r12
leaq 0x1(%r13), %rax
cmpq %rbp, %rax
jb 0x3249af
jmp 0x3249ea
movq %r12, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x324939
cmpq %rbx, %rax
jb 0x324a0c
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x94f8c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/randomcodes-tab.c
// Function: gt_randomcodes_sample2full
GtUword gt_randomcodes_sample2full(const GtRandomcodestab *rct,
                                        GtUword idx)
{
  gt_assert(idx <= rct->numofsamples);
  if (idx < rct->numofsamples)
  {
    return (GtUword) idx << (GtUword) rct->sampleshift;
  }
  return rct->differentcodes - 1;
}

// Assembly:
cmpq %rsi, 0x8(%rdi)
jb 0x324a2b
jbe 0x324a21
movb 0x38(%rdi), %cl
shlq %cl, %rsi
jmp 0x324a27
movq (%rdi), %rsi
decq %rsi
movq %rsi, %rax
retq
pushq %rax
callq 0x94fc5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/randomcodes-tab.c
// Function: gt_randomcodes_samples_delete
void gt_randomcodes_samples_delete(GtFirstcodesspacelog *fcsl,
                                  GtRandomcodestab *rct)
{
  if (rct->leftborder_samples != NULL)
  {
    gt_free(rct->leftborder_samples);
    GT_FCI_SUBTRACTWORKSPACE(fcsl,"leftborder_samples");
    rct->leftborder_samples = NULL;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x58(%rsi), %rdi
testq %rdi, %rdi
je 0x324a86
movq %rsi, %rbx
leaq 0xc019f(%rip), %r15     # 0x3e4bee
movq %r15, %rsi
movl $0x1b6, %edx            # imm = 0x1B6
callq 0x1045eb
xorl %r12d, %r12d
movq %r12, (%rsp)
leaq 0xbde5e(%rip), %r8      # 0x3e28c8
movq %r14, %rdi
movl $0x1b7, %esi            # imm = 0x1B7
movq %r15, %rdx
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x316945
movq %r12, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/randomcodes-tab.c
// Function: gt_randomcodes_countocc_delete
void gt_randomcodes_countocc_delete(GtFirstcodesspacelog *fcsl,
                                   GtRandomcodestab *rct)
{
  if (rct->countocc_small != NULL)
  {
    GT_FCI_SUBTRACTWORKSPACE(fcsl,"countocc_small");
    gt_free(rct->countocc_small);
    rct->countocc_small = NULL;
  }
  gt_hashtable_delete(rct->countocc_exceptions);
  rct->countocc_exceptions = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
cmpq $0x0, 0x48(%rsi)
je 0x324ae4
xorl %r15d, %r15d
movq %r15, (%rsp)
leaq 0xc013b(%rip), %r14     # 0x3e4bee
leaq 0xbdf14(%rip), %r8      # 0x3e29ce
movl $0x1c1, %esi            # imm = 0x1C1
movq %r14, %rdx
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x316945
movq 0x48(%rbx), %rdi
movq %r14, %rsi
movl $0x1c2, %edx            # imm = 0x1C2
callq 0x1045eb
movq %r15, 0x48(%rbx)
movq 0x50(%rbx), %rdi
callq 0x101d90
movq $0x0, 0x50(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/randomcodes-tab.c
// Function: gt_randomcodes_tab_delete
void gt_randomcodes_tab_delete(GtFirstcodesspacelog *fcsl,GtRandomcodestab *rct)
{
  gt_randomcodes_samples_delete(fcsl,rct);
  gt_str_delete(rct->outfilenameleftborder);
  rct->outfilenameleftborder = NULL;
#if defined (_LP64) || defined (_WIN64)
  GT_FREEARRAY(&rct->bitchangepoints,GtUword);
#endif
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x324a31
movq 0x60(%rbx), %rdi
callq 0x11bdbf
movq $0x0, 0x60(%rbx)
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x324b48
subq $-0x80, %rbx
leaq 0xc00be(%rip), %rsi     # 0x3e4bee
movl $0x1cf, %edx            # imm = 0x1CF
callq 0x1045eb
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-ovlfind-kmp.c
// Function: gt_kmp_preproc
gt_kmp_t* gt_kmp_preproc(const char *seq, GtUword seqlen)
{
  gt_kmp_t* pi;
  gt_kmp_t k;
  GtUword q;

  pi = gt_malloc(sizeof (gt_kmp_t) * seqlen);
  pi[0] = 0;
  k = 0;
  for (q = 1UL; q < seqlen; q++)
  {
    while ((k > 0) && (seq[k] != seq[q])) k = pi[k-1];
    if (seq[k] == seq[q]) k++;
    gt_assert(k < GT_KMP_MAX);
    pi[q] = k;
  }
  return pi;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq (%rsi,%rsi), %rdi
leaq 0xbd587(%rip), %rsi     # 0x3e5314
movl $0x21, %edx
callq 0x104226
movw $0x0, (%rax)
cmpq $0x2, %rbx
jb 0x327de7
movl $0x1, %ecx
xorl %edx, %edx
movb (%r14,%rcx), %sil
testw %dx, %dx
je 0x327dc3
movzwl %dx, %edi
cmpb %sil, (%r14,%rdi)
je 0x327dc7
decl %edi
movzwl (%rax,%rdi,2), %edx
jmp 0x327dad
xorl %edx, %edx
xorl %edi, %edi
xorl %r8d, %r8d
cmpb %sil, (%r14,%rdi)
sete %r8b
addl %r8d, %edx
cmpw $-0x1, %dx
je 0x327def
movw %dx, (%rax,%rcx,2)
incq %rcx
cmpq %rbx, %rcx
jne 0x327da9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x952d5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-ovlfind-kmp.c
// Function: gt_kmp_preproc_unit_test
int gt_kmp_preproc_unit_test(GtError *err)
{
  int had_err = 0;
  int i;
  gt_kmp_t *pi, expected_pi[10] = {(gt_kmp_t)0, (gt_kmp_t)0, (gt_kmp_t)1,
    (gt_kmp_t)2, (gt_kmp_t)3, (gt_kmp_t)4, (gt_kmp_t)5, (gt_kmp_t)6,
    (gt_kmp_t)0, (gt_kmp_t)1};
  pi = gt_kmp_preproc("ababababca", 10UL);
  for (i = 0; i < 10; i++)
    gt_ensure(pi[i] == expected_pi[i]);
  gt_free(pi);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xbd070(%rip), %rdi     # 0x3e538a
movl $0xa, %esi
callq 0x327d78
movq %rax, %r14
leaq 0xbd0c2(%rip), %r12     # 0x3e53f0
leaq 0xbcfdf(%rip), %rbp     # 0x3e5314
xorl %r13d, %r13d
xorl %r15d, %r15d
movl %r15d, %eax
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x328386
movzwl (%r14,%r13), %eax
xorl %r15d, %r15d
cmpw (%r13,%r12), %ax
je 0x328386
movq %rbx, %rdi
leaq 0x360dc(%rip), %rsi     # 0x35e43e
leaq 0xbd02c(%rip), %rdx     # 0x3e5395
leaq 0xbd03d(%rip), %rcx     # 0x3e53ad
movq %rbp, %r8
movl $0xa7, %r9d
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
addq $0x2, %r13
cmpq $0x14, %r13
jne 0x32833b
leaq 0xbcf7d(%rip), %rsi     # 0x3e5314
movq %r14, %rdi
movl $0xa8, %edx
callq 0x1045eb
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-opt.c
// Function: gt_sfxoptions_delete
void gt_sfxoptions_delete(Suffixeratoroptions *so)
{
  /* no checking if error occurs, since errors have been output before */
  gt_index_options_delete(so->idxopts);
  gt_encseq_options_delete(so->encopts);
  gt_encseq_options_delete(so->loadopts);
  gt_str_delete(so->indexname);
  gt_str_delete(so->inputindex);
  gt_str_array_delete(so->db);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x1b5e8c
movq 0x8(%rbx), %rdi
callq 0xfc961
movq 0x10(%rbx), %rdi
callq 0xfc961
movq 0x20(%rbx), %rdi
callq 0x11bdbf
movq 0x28(%rbx), %rdi
callq 0x11bdbf
movq 0x30(%rbx), %rdi
popq %rbx
jmp 0x11c144
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/shu-divergence.c
// Function: gt_get_ln_n_fac
double *gt_get_ln_n_fac(GtUword n)
{
  GtUword i;
  double *ln_n_fac;

  ln_n_fac = gt_calloc((size_t) n + 1, sizeof (double));

  ln_n_fac[0] = log(1.0);
  for (i = 1UL; i <= n; i++) {
    ln_n_fac[i] = log((double) i) + ln_n_fac[i-1];
  }
  return ln_n_fac;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
incq %rdi
leaq 0xba3da(%rip), %rdx     # 0x3e5ac0
movl $0x8, %esi
movl $0xb2, %ecx
callq 0x10436a
movq %rax, %r14
movq $0x0, (%rax)
testq %rbx, %rbx
je 0x32b745
movl $0x1, %r15d
movq %r15, %xmm1
punpckldq 0x1c1c9(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1c1d1(%rip), %xmm1    # 0x3478f0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x17610
addsd -0x8(%r14,%r15,8), %xmm0
movsd %xmm0, (%r14,%r15,8)
incq %r15
cmpq %rbx, %r15
jbe 0x32b70a
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/squarededist.c
// Function: gt_squarededistunit2
static GtUword gt_squarededistunit2 (const GtUchar *u, GtUword m,
                                        const GtUchar *v, GtUword n)
{
  GtUword val, we, nw, *ecol, *ecolptr;
  const GtUchar *uptr, *vptr;

  ecol = gt_malloc(sizeof *ecol * (m+1));
  for (*ecol = 0, ecolptr = ecol+1, uptr = u; uptr < u + m; ecolptr++, uptr++)
  {
    *ecolptr = *(ecolptr-1) + 1;
  }
  for (vptr = v; vptr < v + n; vptr++)
  {
    nw = *ecol;
    *ecol = nw + 1;
    for (ecolptr = ecol+1, uptr = u; uptr < u + m; ecolptr++, uptr++)
    {
      we = *ecolptr;
      *ecolptr = *(ecolptr-1) + 1;
      if (*uptr == *vptr)
      {
        val = nw;
      } else
      {
        val = nw + 1;
      }
      if (val < *ecolptr)
      {
        *ecolptr = val;
      }
      if ((val = we + 1) < *ecolptr)
      {
        *ecolptr = val;
      }
      nw = we;
    }
  }
  val = *(ecolptr-1);
  gt_free(ecol);
  return val;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(,%rsi,8), %rdi
leaq 0xba3d7(%rip), %rsi     # 0x3e5b8b
movl $0x1c, %edx
callq 0x104226
movq $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
leaq (%r12,%r15), %rdx
movq %rcx, %rsi
testq %r15, %r15
jle 0x32b7f6
movq (%rax), %rdi
incq %rdi
movq %r12, %r8
movq %rcx, %rsi
movq %rdi, (%rsi)
addq $0x8, %rsi
incq %r8
incq %rdi
cmpq %rdx, %r8
jb 0x32b7e4
testq %rbx, %rbx
jle 0x32b85f
addq %r14, %rbx
movq (%rax), %rdi
leaq 0x1(%rdi), %rsi
movq %rsi, (%rax)
movq %rcx, %rsi
testq %r15, %r15
jle 0x32b857
movq (%rax), %r9
movq %r12, %r8
movq %rcx, %rsi
movq %rdi, %r11
movq (%rsi), %rdi
incq %r9
movq %r9, (%rsi)
movb (%r8), %bpl
xorl %r10d, %r10d
cmpb (%r14), %bpl
setne %r10b
addq %r11, %r10
cmpq %r9, %r10
cmovaeq %r9, %r10
leaq 0x1(%rdi), %r9
cmpq %r10, %r9
jb 0x32b848
movq %r10, %r9
movq %r9, (%rsi)
addq $0x8, %rsi
incq %r8
cmpq %rdx, %r8
jb 0x32b819
incq %r14
cmpq %rbx, %r14
jb 0x32b7fe
movq -0x8(%rsi), %rbx
leaq 0xba321(%rip), %rsi     # 0x3e5b8b
movq %rax, %rdi
movl $0x3c, %edx
callq 0x1045eb
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/tyr-map.c
// Function: gt_tyrindex_show
void gt_tyrindex_show(const Tyrindex *tyrindex)
{
  printf("# indexfilename = %s\n",tyrindex->indexfilename);
  printf("# alphasize = %u\n",tyrindex->alphasize);
  printf("# mersize = "GT_WU"\n",tyrindex->mersize);
  printf("# numofmers = "GT_WU"\n",(GtUword) tyrindex->numofmers);
  printf("# merbytes = "GT_WU"\n",tyrindex->merbytes);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
leaq 0xba1dd(%rip), %rdi     # 0x3e5c22
xorl %eax, %eax
callq 0x17070
movl 0x10(%rbx), %esi
leaq 0xba1e2(%rip), %rdi     # 0x3e5c38
xorl %eax, %eax
callq 0x17070
movq 0x20(%rbx), %rsi
leaq 0xba1e2(%rip), %rdi     # 0x3e5c4a
xorl %eax, %eax
callq 0x17070
movq 0x18(%rbx), %rsi
leaq 0xba1e1(%rip), %rdi     # 0x3e5c5b
xorl %eax, %eax
callq 0x17070
movq 0x28(%rbx), %rsi
leaq 0xba1e2(%rip), %rdi     # 0x3e5c6e
xorl %eax, %eax
popq %rbx
jmp 0x17070
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/tyr-map.c
// Function: gt_tyrindex_delete
void gt_tyrindex_delete(Tyrindex **tyrindexptr)
{
  Tyrindex *tyrindex = *tyrindexptr;

  gt_fa_xmunmap(tyrindex->mappedfileptr);
  tyrindex->mappedfileptr = NULL;
  gt_free(tyrindex);
  *tyrindexptr = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq (%r14), %rdi
callq 0xfdc54
xorl %r15d, %r15d
movq %r15, (%r14)
leaq 0xba0d1(%rip), %rsi     # 0x3e5bb4
movq %r14, %rdi
movl $0xb6, %edx
callq 0x1045eb
movq %r15, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/tyr-map.c
// Function: gt_tyrcountinfo_get
GtUword gt_tyrcountinfo_get(const Tyrcountinfo *tyrcountinfo,
                               GtUword mernumber)
{
  if (tyrcountinfo->smallcounts[mernumber] == 0)
  {
    const Largecount *lc
      = binsearchLargecount(mernumber,
                            tyrcountinfo->largecounts,
                            tyrcountinfo->largecounts +
                            tyrcountinfo->numoflargecounts-1);
#ifndef NDEBUG
    if (lc == NULL)
    {
      fprintf(stderr,"cannot find count for mer number "GT_WU"",mernumber);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
#endif
    gt_assert (lc != NULL);
    return lc->value;
  }
  return (GtUword) tyrcountinfo->smallcounts[mernumber];
}

// Assembly:
pushq %rax
movq 0x10(%rdi), %rax
movzbl (%rax,%rsi), %eax
testq %rax, %rax
jne 0x32bc69
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
shlq $0x4, %rcx
addq %rax, %rcx
addq $-0x10, %rcx
cmpq %rcx, %rax
ja 0x32bc6b
movq %rcx, %rdi
subq %rax, %rdi
sarq %rdi
andq $-0x10, %rdi
leaq (%rax,%rdi), %rdx
cmpq %rsi, (%rax,%rdi)
jbe 0x32bc5a
addq $-0x10, %rdx
movq %rdx, %rcx
jmp 0x32bc35
jae 0x32bc65
addq $0x10, %rdx
movq %rdx, %rax
jmp 0x32bc35
movq 0x8(%rdx), %rax
popq %rcx
retq
movq %rsi, %rdi
callq 0x959a0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/tyr-map.c
// Function: gt_tyrcountinfo_delete
void gt_tyrcountinfo_delete(Tyrcountinfo **tyrcountinfoptr)
{
  Tyrcountinfo *tyrcountinfo = *tyrcountinfoptr;

  gt_fa_xmunmap(tyrcountinfo->mappedmctfileptr);
  tyrcountinfo->mappedmctfileptr = NULL;
  gt_free(tyrcountinfo);
  *tyrcountinfoptr = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq (%r14), %rdi
callq 0xfdc54
xorl %r15d, %r15d
movq %r15, (%r14)
leaq 0xb9f21(%rip), %rsi     # 0x3e5bb4
movq %r14, %rdi
movl $0x12d, %edx            # imm = 0x12D
callq 0x1045eb
movq %r15, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/tyr-map.c
// Function: gt_tyrindex_binmersearch
const GtUchar *gt_tyrindex_binmersearch(const Tyrindex *tyrindex,
                                              GtUword offset,
                                              const GtUchar *key,
                                              const GtUchar *leftbound,
                                              const GtUchar *rightbound)
{
  const GtUchar *leftptr, *midptr, *rightptr;
  int cmpval;
  GtUword leftlength = offset, rightlength = offset, len;

  leftptr = leftbound;
  rightptr = rightbound;
  while (leftptr <= rightptr)
  {
    len = (GtUword) (rightptr-leftptr)/GT_MULT2(tyrindex->merbytes);
    midptr = leftptr + tyrindex->merbytes * len;
    cmpval = mymemcmp(&offset,midptr,key,tyrindex->merbytes);
    if (cmpval < 0)
    {
      leftptr = midptr + tyrindex->merbytes;
      leftlength = offset;
      if (offset > rightlength)
      {
        offset = rightlength;
      }
    } else
    {
      if (cmpval > 0)
      {
        rightptr = midptr - tyrindex->merbytes;
        rightlength = offset;
        if (offset > leftlength)
        {
          offset = leftlength;
        }
      } else
      {
        return midptr;
      }
    }
  }
  return NULL;
}

// Assembly:
cmpq %r8, %rcx
jbe 0x32bcb1
xorl %eax, %eax
retq
pushq %r14
pushq %rbx
movq %rdx, %r9
movq 0x28(%rdi), %rdi
leaq (%rdi,%rdi), %r10
movq %rdi, %r11
negq %r11
movq %rsi, %r14
movq %rsi, %rbx
movq %r8, %rax
subq %rcx, %rax
xorl %edx, %edx
divq %r10
imulq %rdi, %rax
addq %rcx, %rax
cmpq %rdi, %rbx
jae 0x32bd22
movb (%r9,%rbx), %dl
cmpb %dl, (%rax,%rbx)
jb 0x32bcf7
ja 0x32bd05
incq %rbx
cmpq %rbx, %rdi
jne 0x32bce2
jmp 0x32bd22
addq %rdi, %rax
movq %rax, %rcx
movq %rbx, %r14
movq %rsi, %rax
jmp 0x32bd11
addq %r11, %rax
movq %r14, %rsi
movq %rax, %r8
movq %rbx, %rax
cmpq %rsi, %rbx
cmovaeq %rsi, %rbx
movq %rax, %rsi
cmpq %r8, %rcx
jbe 0x32bccb
xorl %eax, %eax
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/tyr-map.c
// Function: gt_tyrindex_check
void gt_tyrindex_check(GT_UNUSED const Tyrindex *tyrindex)
{
#ifndef NDEBUG
  GtUchar *mercodeptr;
  const GtUchar *result;
  GtUword position;
  GT_UNUSED GtUword previousposition = 0;

  gt_assert(tyrindex->merbytes > 0);
  for (mercodeptr = tyrindex->mertable;
       mercodeptr <= tyrindex->lastmer;
       mercodeptr += tyrindex->merbytes)
  {
    result = gt_tyrindex_binmersearch(tyrindex,0,mercodeptr,
                                   tyrindex->mertable,
                                   tyrindex->lastmer);
    gt_assert(result != NULL);
    if ((result - tyrindex->mertable) % tyrindex->merbytes != 0)
    {
      fprintf(stderr,"result is not multiple of "GT_WU"\n",tyrindex->merbytes);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
    position = (GtUword) (result-tyrindex->mertable)/
                               tyrindex->merbytes;
    if (position > 0 && previousposition + 1 != position)
    {
      fprintf(stderr,"position "GT_WU" is not increasing\n",position);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
    previousposition = position;
  }
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rbx
testq %rbx, %rbx
je 0x32bdc0
movq %rdi, %r14
movq 0x30(%rdi), %r15
movq 0x38(%rdi), %r12
cmpq %r12, %r15
ja 0x32bd9c
xorl %ebp, %ebp
movq %r15, %r13
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x32bca9
testq %rax, %rax
je 0x32bdab
movq %rax, %rcx
subq %r15, %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %rbx
testq %rdx, %rdx
jne 0x32bdb8
cmpq %rcx, %rbx
seta %cl
incq %rbp
cmpq %rax, %rbp
sete %dl
orb %cl, %dl
je 0x32bdb0
addq %rbx, %r13
movq %rax, %rbp
cmpq %r12, %r13
jbe 0x32bd53
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x95a0c
movq %rax, %rdi
callq 0x959e8
movq %rbx, %rdi
callq 0x959c4
callq 0x95a45
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/tyr-map.c
// Function: gt_determinetyrbckpfxlen
int gt_determinetyrbckpfxlen(unsigned int *prefixlength,
                          const Tyrindex *tyrindex,
                          const Definedunsignedint *callprefixlength,
                          GtError *err)
{
  gt_error_check(err);
  if (callprefixlength->defined)
  {
    unsigned int maxprefixlen
      = gt_whatisthemaximalprefixlength(tyrindex->alphasize,
                                     (GtUword) tyrindex->numofmers,
                                     0,true);
    if (maxprefixlen > (unsigned int) tyrindex->mersize)
    {
      maxprefixlen = (unsigned int) tyrindex->mersize;
    }
    if (gt_checkprefixlength(maxprefixlen,callprefixlength->valueunsignedint,
                          err) != 0)
    {
      return -1;
    }
    *prefixlength = callprefixlength->valueunsignedint;
  } else
  {
    unsigned int recommendedprefixlength
      = gt_recommendedprefixlength(tyrindex->alphasize,
                                   (GtUword) tyrindex->numofmers,
                                   GT_RECOMMENDED_MULTIPLIER_DEFAULT,
                                   true);
    if (recommendedprefixlength > (unsigned int) tyrindex->mersize)
    {
      recommendedprefixlength = (unsigned int) tyrindex->mersize;
    }
    *prefixlength = recommendedprefixlength;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rcx, %rcx
je 0x32bdea
movq %r12, %rdi
callq 0xfcc32
testb %al, %al
jne 0x32be55
movl 0x10(%r15), %edi
movq 0x18(%r15), %rsi
cmpb $0x1, (%r14)
jne 0x32be2a
xorl %edx, %edx
movl $0x1, %ecx
callq 0x1e2d15
movl 0x20(%r15), %edi
cmpl %edi, %eax
cmovbl %eax, %edi
movl 0x4(%r14), %esi
movq %r12, %rdx
callq 0x1e2e55
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x32be49
movl 0x4(%r14), %ecx
jmp 0x32be45
movsd 0x258a6(%rip), %xmm0    # 0x3516d8
movl $0x1, %edx
callq 0x1e2c5c
movl 0x20(%r15), %ecx
cmpl %ecx, %eax
cmovbl %eax, %ecx
movl %ecx, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x95a7e
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/ltr/ltr_cluster_prepare_seq_visitor.c
// Function: gt_ltr_cluster_prepare_seq_visitor_free
void gt_ltr_cluster_prepare_seq_visitor_free(GtNodeVisitor *v)
{
  GtLTRClusterPrepareSeqVisitor *lcv;
  lcv = gt_ltr_cluster_prepare_seq_visitor_cast(v);
  gt_encseq_delete(lcv->src_encseq);
  gt_str_array_delete(lcv->feat_to_encseq_keys);
  gt_hashmap_delete(lcv->feat_to_encseq);
  gt_hashmap_delete(lcv->encseq_builders);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x32be98
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1630b1
movq %rax, %rbx
movq 0x10(%rax), %rdi
callq 0xea375
movq 0x28(%rbx), %rdi
callq 0x11c144
movq 0x18(%rbx), %rdi
callq 0x10109b
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x10109b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/ltr/ltr_cluster_prepare_seq_visitor.c
// Function: gt_ltr_cluster_prepare_seq_visitor_class
const GtNodeVisitorClass* gt_ltr_cluster_prepare_seq_visitor_class(void)
{
  static const GtNodeVisitorClass *nvc;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof(GtLTRClusterPrepareSeqVisitor),
                                gt_ltr_cluster_prepare_seq_visitor_free,
                                NULL,
                                gt_ltr_cluster_prepare_seq_visitor_feature_node,
                                NULL,
                                NULL,
                                NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x193162(%rip)    # 0x4bf008
jne 0x32bed7
movq $0x0, (%rsp)
leaq -0x5b(%rip), %rsi       # 0x32be5c
leaq 0x27(%rip), %rcx        # 0x32bee5
movl $0x30, %edi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x163010
movq %rax, 0x193131(%rip)    # 0x4bf008
callq 0xe2545
movq 0x193125(%rip), %rax    # 0x4bf008
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/ltr/ltr_cluster_prepare_seq_visitor.c
// Function: gt_ltr_cluster_prepare_seq_visitor_new
GtNodeVisitor* gt_ltr_cluster_prepare_seq_visitor_new(GtEncseq *encseq,
                                                      GT_UNUSED GtError *err)
{
  GtNodeVisitor *nv;
  GtLTRClusterPrepareSeqVisitor *lcv;
  nv = gt_node_visitor_create(gt_ltr_cluster_prepare_seq_visitor_class());
  lcv = gt_ltr_cluster_prepare_seq_visitor_cast(nv);
  gt_assert(lcv);
  lcv->src_encseq = gt_encseq_ref(encseq);
  lcv->feat_to_encseq = NULL;
  lcv->encseq_builders = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
                                        (GtFree) gt_encseq_builder_delete);
  lcv->feat_to_encseq_keys = gt_str_array_new();
  return nv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
callq 0x32be98
movq %rax, %rdi
callq 0x163080
movq %rax, %rbx
callq 0x32be98
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1630b1
testq %rax, %rax
je 0x32c370
movq %rax, %r14
movq %r15, %rdi
callq 0xea9be
movq %rax, 0x10(%r14)
movq $0x0, 0x18(%r14)
leaq -0x227c9f(%rip), %rsi   # 0x1046aa
leaq -0x235f8b(%rip), %rdx   # 0xf63c5
movl $0x1, %edi
callq 0x1008fc
movq %rax, 0x20(%r14)
callq 0x11be10
movq %rax, 0x28(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x95b5c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/ltr/ltr_cluster_prepare_seq_visitor.c
// Function: gt_ltr_cluster_prepare_seq_finish_encseqs
int gt_ltr_cluster_prepare_seq_finish_encseqs(void *key, void *value,
                                              void *data, GtError *err)
{
  GtLTRClusterPrepareSeqVisitor *v = (GtLTRClusterPrepareSeqVisitor*) data;
  GtEncseqBuilder *eb = (GtEncseqBuilder*) value;
  GtEncseq *encseq;
  int had_err = 0;
  const char *feature = (const char*) key;
  gt_assert(key && value);
  gt_error_check(err);

  encseq = gt_encseq_builder_build(eb, err);
  if (!encseq)
    had_err = -1;
  if (!had_err) {
    if (!v->feat_to_encseq) {
      v->feat_to_encseq = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
                                         (GtFree) gt_encseq_delete);
    }
    gt_assert(!gt_hashmap_get(v->feat_to_encseq, feature));
    gt_hashmap_add(v->feat_to_encseq, gt_cstr_dup(feature), encseq);
    gt_log_log("added encseq %p to hash for feature %s", encseq, feature);
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x32c43a
movq %rsi, %r12
testq %rsi, %rsi
je 0x32c43a
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
testq %rcx, %rcx
je 0x32c3b0
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
jne 0x32c43f
movq %r12, %rdi
movq %r15, %rsi
callq 0xf2e3b
movq %rax, %r15
testq %rax, %rax
je 0x32c426
movq 0x18(%r14), %rdi
testq %rdi, %rdi
jne 0x32c3eb
leaq -0x227d29(%rip), %rsi   # 0x1046aa
leaq -0x242065(%rip), %rdx   # 0xea375
movl $0x1, %edi
callq 0x1008fc
movq %rax, %rdi
movq %rax, 0x18(%r14)
movq %rbx, %rsi
callq 0x100add
testq %rax, %rax
jne 0x32c444
movq 0x18(%r14), %r14
movq %rbx, %rdi
callq 0xe4290
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x100b18
leaq 0xb9a4a(%rip), %rdi     # 0x3e5e63
movq %r15, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x103d72
xorl %eax, %eax
cmpq $0x1, %r15
sbbl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x95b95
callq 0x95bce
callq 0x95c07
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/ltr/ltr_cluster_prepare_seq_visitor.c
// Function: gt_ltr_cluster_prepare_seq_visitor_get_encseqs
GtHashmap* gt_ltr_cluster_prepare_seq_visitor_get_encseqs(
                                              GtLTRClusterPrepareSeqVisitor *v)
{
  gt_assert(v && v->encseq_builders);
  gt_log_log("finishing encseqs");
  if (!v->feat_to_encseq) {
    gt_log_log("starting...");
    (void) gt_hashmap_foreach(v->encseq_builders,
                              gt_ltr_cluster_prepare_seq_finish_encseqs,
                              v,
                              NULL);
  }
  return gt_hashmap_ref(v->feat_to_encseq);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x32c49d
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x32c49d
leaq 0xb9a71(%rip), %rdi     # 0x3e5ed1
xorl %eax, %eax
callq 0x103d72
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
jne 0x32c497
leaq 0xb9a6c(%rip), %rdi     # 0x3e5ee3
xorl %eax, %eax
callq 0x103d72
movq 0x20(%rbx), %rdi
leaq -0x114(%rip), %rsi      # 0x32c375
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x100bc9
movq 0x18(%rbx), %rdi
popq %rbx
jmp 0x100ad8
callq 0x95c40
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/ltr/ltr_cluster_prepare_seq_visitor.c
// Function: extract_feature_seq
static int extract_feature_seq(GtEncseqBuilder *b, const char *header,
                               GtStr *seqid, GtEncseq *encseq, GtRange range,
                               GT_UNUSED const char *fnt, GtError *err)
{
  char *buffer;
  int had_err = 0,
      rval;
  GtUword seqnum,
                startpos;

  rval = sscanf(gt_str_get(seqid), "seq"GT_WU"", &seqnum);
  if (rval != 1) {
    gt_error_set(err, "expected sequence ID of format 'seqX' but "
                      "encountered '%s'",gt_str_get(seqid));
    had_err = -1;
  }
  if (!had_err && (seqnum >= gt_encseq_num_of_sequences(encseq))) {
    gt_error_set(err, "annotation encountered for sequence "GT_WU", but the "
                      "supplied encoded sequence only contains sequences "
                      "0-"GT_WU"", seqnum,
                    gt_encseq_num_of_sequences(encseq)-1);
    had_err = -1;
  }

  if (!had_err) {
    buffer = gt_calloc((size_t) gt_range_length(&range) + 1, sizeof (char));
    startpos = gt_encseq_seqstartpos(encseq, seqnum);
    gt_encseq_extract_decoded(encseq, buffer, startpos + range.start - 1,
                              startpos + range.end - 1);
    gt_encseq_builder_add_cstr(b, buffer, gt_range_length(&range), header);
    gt_free(buffer);
  }

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movq 0x50(%rsp), %r12
movq %r8, 0x8(%rsp)
movq %r9, 0x10(%rsp)
movq %rdx, %rdi
callq 0x11b0a1
leaq 0x63a95(%rip), %rsi     # 0x38ff87
movq %rsp, %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x177f0
cmpl $0x1, %eax
jne 0x32c59d
movq (%rsp), %r13
movq %r15, %rdi
callq 0xe7bac
cmpq %rax, %r13
jae 0x32c5bb
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x112233
leaq 0x1(%rax), %rdi
leaq 0xb98ae(%rip), %r12     # 0x3e5de3
movl $0x1, %esi
movq %r12, %rdx
movl $0x42, %ecx
callq 0x10436a
movq %rax, %rbp
movq (%rsp), %rsi
movq %r15, %rdi
callq 0xeb6ee
leaq -0x1(%rax), %rcx
movq (%r13), %rdx
addq %rcx, %rdx
addq 0x8(%r13), %rcx
movq %r15, %rdi
movq %rbp, %rsi
callq 0xe92be
movq %r13, %rdi
callq 0x112233
movq %r14, %rdi
movq %rbp, %rsi
movq %rax, %rdx
movq %rbx, %rcx
callq 0xf26be
movq %rbp, %rdi
movq %r12, %rsi
movl $0x47, %edx
callq 0x1045eb
xorl %eax, %eax
jmp 0x32c5e4
movq %r13, %rdi
callq 0x11b0a1
leaq 0xb99df(%rip), %rsi     # 0x3e5f8b
movq %r12, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfcb67
jmp 0x32c5df
movq (%rsp), %rbx
movq %r15, %rdi
callq 0xe7bac
leaq -0x1(%rax), %rcx
leaq 0xb99f4(%rip), %rsi     # 0x3e5fc6
movq %r12, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/mgth/mg_codon.c
// Function: mg_codon2amino
char mg_codon2amino(char n0, char n1, char n2)
{
  static char aminos[] = "FFLLSSSSYY**CC*WLLLLPPPPHHQQRRRR"
    "IIIMTTTTNNKKSSRRVVVVAAAADDEEGGGGX";
  unsigned int code = 0;

  switch (n0)
  {
    case 'A':
    case 'a':
      code = A_CODE << 4;
      break;
    case 'C':
    case 'c':
      code = C_CODE << 4;
      break;
    case 'G':
    case 'g':
      code = G_CODE << 4;
      break;
    case 'T':
    case 't':
    case 'U':
    case 'u':
      code = T_CODE << 4;
      break;
    default:
      code = G_CODE << 4;
  }

  switch (n1)
  {
    case 'A':
    case 'a':
      code += A_CODE << 2;
      break;
    case 'C':
    case 'c':
      code += C_CODE << 2;
      break;
    case 'G':
    case 'g':
      code += G_CODE << 2;
      break;
    case 'T':
    case 't':
    case 'U':
    case 'u':
      /* code += T_CODE << 2; */
      break;
    default:
      code = G_CODE << 2;
  }

  switch (n2)
  {
    case 'A':
    case 'a':
    case 'R':
    case 'r':
      code += A_CODE;
      break;
    case 'C':
    case 'c':
      code += C_CODE;
      break;
    case 'G':
    case 'g':
      code += G_CODE;
      break;
    case 'T':
    case 't':
    case 'U':
    case 'u':
    case 'N':
    case 'n':
    case 'Y':
    case 'y':
      code += T_CODE;
      break;
    default:
      code += X_CODE;
  }

  return aminos[code];
}

// Assembly:
movl $0x20, %eax
cmpl $0x60, %edi
jg 0x32c786
cmpl $0x53, %edi
jg 0x32c79a
cmpl $0x41, %edi
je 0x32c7b7
cmpl $0x43, %edi
je 0x32c7b2
cmpl $0x47, %edi
jmp 0x32c7ab
cmpl $0x73, %edi
jg 0x32c79f
cmpl $0x61, %edi
je 0x32c7b7
cmpl $0x63, %edi
je 0x32c7b2
cmpl $0x67, %edi
jmp 0x32c7ab
addl $-0x54, %edi
jmp 0x32c7a2
addl $-0x74, %edi
cmpl $0x2, %edi
jae 0x32c7ab
xorl %eax, %eax
jmp 0x32c7b7
movl $0x30, %eax
jmp 0x32c7b7
movl $0x10, %eax
movsbl %sil, %ecx
cmpl $0x60, %ecx
jg 0x32c7d6
cmpl $0x53, %ecx
jg 0x32c7ef
cmpl $0x41, %ecx
je 0x32c803
cmpl $0x43, %ecx
je 0x32c808
cmpl $0x47, %ecx
je 0x32c7ea
jmp 0x32c7fc
cmpl $0x73, %ecx
jg 0x32c7f4
cmpl $0x61, %ecx
je 0x32c803
cmpl $0x63, %ecx
je 0x32c808
cmpl $0x67, %ecx
jne 0x32c7fc
orl $0xc, %eax
jmp 0x32c80b
addl $-0x54, %ecx
jmp 0x32c7f7
addl $-0x74, %ecx
cmpl $0x2, %ecx
jb 0x32c80b
movl $0xc, %eax
jmp 0x32c80b
orl $0x8, %eax
jmp 0x32c80b
orl $0x4, %eax
movsbl %dl, %ecx
cmpl $0x60, %ecx
jg 0x32c829
cmpl $0x51, %ecx
jg 0x32c850
cmpl $0x46, %ecx
jg 0x32c869
cmpl $0x41, %ecx
je 0x32c864
cmpl $0x43, %ecx
je 0x32c878
jmp 0x32c873
leal -0x67(%rcx), %edx
cmpl $0x12, %edx
ja 0x32c844
movl $0x46080, %esi          # imm = 0x46080
btl %edx, %esi
jb 0x32c87f
testl %edx, %edx
je 0x32c87c
cmpl $0xb, %edx
je 0x32c864
cmpl $0x63, %ecx
je 0x32c878
cmpl $0x61, %ecx
je 0x32c864
jmp 0x32c873
leal -0x54(%rcx), %edx
cmpl $0x2, %edx
jb 0x32c87f
cmpl $0x52, %ecx
je 0x32c864
cmpl $0x59, %ecx
je 0x32c87f
jmp 0x32c873
addl $0x2, %eax
jmp 0x32c87f
cmpl $0x47, %ecx
je 0x32c87c
cmpl $0x4e, %ecx
je 0x32c87f
addl $0x4, %eax
jmp 0x32c87f
incl %eax
jmp 0x32c87f
addl $0x3, %eax
movl %eax, %eax
leaq 0xb9818(%rip), %rcx     # 0x3e60a0
movb (%rax,%rcx), %al
retq