LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x32ecfe
movq 0x50(%rdi), %rdi
movq %rsp, %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x10620e
testq %rax, %rax
je 0x32ed00
movq %rax, %rcx
movl $0xfe, %eax
addl 0x8(%rcx), %eax
popq %rcx
retq
callq 0x96f11
// File: /workspace/github_c_makefile_star2_O1/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 0x32ed49
movq 0x80(%rdi), %rdx
xorl %eax, %eax
cmpq %rsi, (%rdx,%rax,8)
jae 0x32ed4b
incq %rax
cmpq %rax, %rcx
jne 0x32ed36
movq %rcx, %rax
jmp 0x32ed4b
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_O1/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 0x32edba
xorl %r13d, %r13d
movq %r12, %rbp
movq %r13, %r15
addq %rbp, %r15
shrq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x32ed0c
cmpq %rbx, %rax
je 0x32edcd
ja 0x32eda8
incq %r15
movq %r15, %r13
movq %r12, %r15
jmp 0x32edaf
leaq -0x1(%r15), %rbp
movq %r15, %r12
leaq 0x1(%r13), %rax
cmpq %rbp, %rax
jb 0x32ed82
jmp 0x32edbd
movq %r12, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x32ed0c
cmpq %rbx, %rax
jb 0x32eddf
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x96f83
// File: /workspace/github_c_makefile_star2_O1/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 0x32edfe
jbe 0x32edf4
movb 0x38(%rdi), %cl
shlq %cl, %rsi
jmp 0x32edfa
movq (%rdi), %rsi
decq %rsi
movq %rsi, %rax
retq
pushq %rax
callq 0x96fbc
// File: /workspace/github_c_makefile_star2_O1/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 0x32ee59
movq %rsi, %rbx
leaq 0xbf590(%rip), %r15     # 0x3ee3b2
movq %r15, %rsi
movl $0x1b6, %edx            # imm = 0x1B6
callq 0x109670
xorl %r12d, %r12d
movq %r12, (%rsp)
leaq 0xbd1af(%rip), %r8      # 0x3ebfec
movq %r14, %rdi
movl $0x1b7, %esi            # imm = 0x1B7
movq %r15, %rdx
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x320ca8
movq %r12, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x32eeb7
xorl %r15d, %r15d
movq %r15, (%rsp)
leaq 0xbf52c(%rip), %r14     # 0x3ee3b2
leaq 0xbd265(%rip), %r8      # 0x3ec0f2
movl $0x1c1, %esi            # imm = 0x1C1
movq %r14, %rdx
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x320ca8
movq 0x48(%rbx), %rdi
movq %r14, %rsi
movl $0x1c2, %edx            # imm = 0x1C2
callq 0x109670
movq %r15, 0x48(%rbx)
movq 0x50(%rbx), %rdi
callq 0x106d10
movq $0x0, 0x50(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x32ee04
movq 0x60(%rbx), %rdi
callq 0x121b03
movq $0x0, 0x60(%rbx)
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x32ef1b
subq $-0x80, %rbx
leaq 0xbf4af(%rip), %rsi     # 0x3ee3b2
movl $0x1cf, %edx            # imm = 0x1CF
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbc357(%rip), %rsi     # 0x3eead8
movl $0x21, %edx
callq 0x1092b2
movw $0x0, (%rax)
cmpq $0x2, %rbx
jb 0x3327de
movl $0x1, %ecx
xorl %edx, %edx
movzwl %dx, %esi
testw %si, %si
je 0x3327bc
movb (%r14,%rcx), %dil
cmpb %dil, (%r14,%rsi)
je 0x3327bc
decl %esi
movzwl (%rax,%rsi,2), %esi
movl %esi, %edx
testq %rsi, %rsi
jne 0x3327a9
movb (%r14,%rsi), %sil
xorl %edi, %edi
cmpb (%r14,%rcx), %sil
sete %dil
addl %edi, %edx
cmpw $-0x1, %dx
je 0x3327e6
movw %dx, (%rax,%rcx,2)
incq %rcx
cmpq %rbx, %rcx
jne 0x33279d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x972cc
// File: /workspace/github_c_makefile_star2_O1/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 0xbbe08(%rip), %rdi     # 0x3eeb4e
movl $0xa, %esi
callq 0x33276c
movq %rax, %r14
leaq 0xbbe56(%rip), %r12     # 0x3eebb0
leaq 0xbbd77(%rip), %rbp     # 0x3eead8
xorl %r13d, %r13d
xorl %r15d, %r15d
movl %r15d, %eax
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x332db2
movzwl (%r14,%r13), %eax
xorl %r15d, %r15d
cmpw (%r13,%r12), %ax
je 0x332db2
movq %rbx, %rdi
leaq 0x347ac(%rip), %rsi     # 0x36753a
leaq 0xbbdc4(%rip), %rdx     # 0x3eeb59
leaq 0xbbdd5(%rip), %rcx     # 0x3eeb71
movq %rbp, %r8
movl $0xa7, %r9d
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
addq $0x2, %r13
cmpq $0x14, %r13
jne 0x332d67
leaq 0xbbd15(%rip), %rsi     # 0x3eead8
movq %r14, %rdi
movl $0xa8, %edx
callq 0x109670
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_O1/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 0x1be8d8
movq 0x8(%rbx), %rdi
callq 0x1017c9
movq 0x10(%rbx), %rdi
callq 0x1017c9
movq 0x20(%rbx), %rdi
callq 0x121b03
movq 0x28(%rbx), %rdi
callq 0x121b03
movq 0x30(%rbx), %rdi
popq %rbx
jmp 0x121e8b
// File: /workspace/github_c_makefile_star2_O1/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 0xb9000(%rip), %rdx     # 0x3ef2b8
movl $0x8, %esi
movl $0xb2, %ecx
callq 0x1093ef
movq %rax, %r14
movq $0x0, (%rax)
testq %rbx, %rbx
je 0x336317
movl $0x1, %r15d
movq %r15, %xmm1
punpckldq 0x1a5f7(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1a5ff(%rip), %xmm1    # 0x3508f0
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 0x3362dc
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb8fff(%rip), %rsi     # 0x3ef383
movl $0x1c, %edx
callq 0x1092b2
movq $0x0, (%rax)
movq %rax, %rcx
addq $0x8, %rcx
leaq (%r12,%r15), %rdx
movq %rcx, %rsi
testq %r15, %r15
jle 0x3363c6
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 0x3363b4
testq %rbx, %rbx
jle 0x33642f
addq %r14, %rbx
movq (%rax), %rdi
leaq 0x1(%rdi), %rsi
movq %rsi, (%rax)
movq %rcx, %rsi
testq %r15, %r15
jle 0x336427
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 0x336418
movq %r10, %r9
movq %r9, (%rsi)
addq $0x8, %rsi
incq %r8
cmpq %rdx, %r8
jb 0x3363e9
incq %r14
cmpq %rbx, %r14
jb 0x3363ce
movq -0x8(%rsi), %rbx
leaq 0xb8f49(%rip), %rsi     # 0x3ef383
movq %rax, %rdi
movl $0x3c, %edx
callq 0x109670
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/tyr-map.c
// Function: gt_decodesingleinteger
GtUword gt_decodesingleinteger(const GtUchar *start)
{
  GtUword idx, value;

  value = (GtUword) start[0];
  for (idx=1UL; idx < (GtUword) sizeof (GtUword); idx++)
  {
    value |= (((GtUword) start[idx]) << GT_MULT8(idx));
  }
  return value;
}

// Assembly:
movzbl (%rdi), %eax
incq %rdi
movl $0x8, %ecx
movzbl (%rdi), %edx
shlq %cl, %rdx
orq %rdx, %rax
addq $0x8, %rcx
incq %rdi
cmpq $0x40, %rcx
jne 0x33645f
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb8de9(%rip), %rdi     # 0x3ef435
xorl %eax, %eax
callq 0x17070
movl 0x10(%rbx), %esi
leaq 0xb8dee(%rip), %rdi     # 0x3ef44b
xorl %eax, %eax
callq 0x17070
movq 0x20(%rbx), %rsi
leaq 0xb8dee(%rip), %rdi     # 0x3ef45d
xorl %eax, %eax
callq 0x17070
movq 0x18(%rbx), %rsi
leaq 0xb8ded(%rip), %rdi     # 0x3ef46e
xorl %eax, %eax
callq 0x17070
movq 0x28(%rbx), %rsi
leaq 0xb8dee(%rip), %rdi     # 0x3ef481
xorl %eax, %eax
popq %rbx
jmp 0x17070
// File: /workspace/github_c_makefile_star2_O1/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 0x102b12
xorl %r15d, %r15d
movq %r15, (%r14)
leaq 0xb8cc2(%rip), %rsi     # 0x3ef3ac
movq %r14, %rdi
movl $0xb6, %edx
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-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 0x336891
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
shlq $0x4, %rcx
addq %rax, %rcx
addq $-0x10, %rcx
cmpq %rcx, %rax
ja 0x336886
movq %rcx, %rdi
subq %rax, %rdi
sarq %rdi
andq $-0x10, %rdi
leaq (%rax,%rdi), %rdx
cmpq %rsi, (%rax,%rdi)
jbe 0x33687b
addq $-0x10, %rdx
movq %rdx, %rcx
jmp 0x336856
jae 0x336888
addq $0x10, %rdx
movq %rdx, %rax
jmp 0x336856
xorl %edx, %edx
testq %rdx, %rdx
je 0x336893
movq 0x8(%rdx), %rax
popq %rcx
retq
movq %rsi, %rdi
callq 0x97a75
// File: /workspace/github_c_makefile_star2_O1/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 0x102b12
xorl %r15d, %r15d
movq %r15, (%r14)
leaq 0xb8af1(%rip), %rsi     # 0x3ef3ac
movq %r14, %rdi
movl $0x12d, %edx            # imm = 0x12D
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-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 0x3368d9
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
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 %r15d, %r15d
xorl %edx, %edx
divq %r10
imulq %rdi, %rax
addq %rcx, %rax
cmpq %rdi, %rbx
jae 0x33692f
movq %rbx, %r12
movb (%rax,%r12), %bpl
movb (%r9,%r12), %r15b
cmpb %r15b, %bpl
sete %dl
jne 0x336933
incq %r12
cmpq %r12, %rdi
jne 0x336915
jmp 0x336936
movb $0x1, %dl
jmp 0x33693d
movq %r12, %rbx
cmpb %r15b, %bpl
setb %r15b
testb %r15b, %r15b
je 0x336950
addq %rdi, %rax
movq %rax, %rcx
movq %rbx, %r14
movq %rsi, %rax
jmp 0x336960
testb %dl, %dl
jne 0x336971
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 0x3368f8
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x336a14
movq %rdi, %r14
movq 0x30(%rdi), %r15
movq 0x38(%rdi), %r12
cmpq %r12, %r15
ja 0x3369f0
xorl %ebp, %ebp
movq %r15, %r13
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x3368d1
testq %rax, %rax
je 0x3369ff
movq %rax, %rcx
subq %r15, %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %rbx
testq %rdx, %rdx
jne 0x336a0c
cmpq %rcx, %rbx
seta %cl
incq %rbp
cmpq %rax, %rbp
sete %dl
orb %cl, %dl
je 0x336a04
addq %rbx, %r13
movq %rax, %rbp
cmpq %r12, %r13
jbe 0x3369a7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x97ae1
movq %rax, %rdi
callq 0x97abd
movq %rbx, %rdi
callq 0x97a99
callq 0x97b1a
// File: /workspace/github_c_makefile_star2_O1/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 0x336a3e
movq %r12, %rdi
callq 0x101a9a
testb %al, %al
jne 0x336aa9
movl 0x10(%r15), %edi
movq 0x18(%r15), %rsi
cmpb $0x1, (%r14)
jne 0x336a7e
xorl %edx, %edx
movl $0x1, %ecx
callq 0x1ec5a5
movl 0x20(%r15), %edi
cmpl %edi, %eax
cmovbl %eax, %edi
movl 0x4(%r14), %esi
movq %r12, %rdx
callq 0x1ec6e5
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x336a9d
movl 0x4(%r14), %ecx
jmp 0x336a99
movsd 0x23c8a(%rip), %xmm0    # 0x35a710
movl $0x1, %edx
callq 0x1ec4ec
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 0x97b53
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x336aec
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
movq %rax, %rbx
movq 0x10(%rax), %rdi
callq 0xee90c
movq 0x28(%rbx), %rdi
callq 0x121e8b
movq 0x18(%rbx), %rdi
callq 0x105f7d
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x105f7d
// File: /workspace/github_c_makefile_star2_O1/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 0xe6a03
cmpq $0x0, 0x19350e(%rip)    # 0x4ca008
jne 0x336b2b
movq $0x0, (%rsp)
leaq -0x5b(%rip), %rsi       # 0x336ab0
leaq 0x27(%rip), %rcx        # 0x336b39
movl $0x30, %edi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x16ae80
movq %rax, 0x1934dd(%rip)    # 0x4ca008
callq 0xe6a19
movq 0x1934d1(%rip), %rax    # 0x4ca008
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x336aec
movq %rax, %rdi
callq 0x16aef0
movq %rax, %rbx
callq 0x336aec
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
testq %rax, %rax
je 0x336fd3
movq %rax, %r14
movq %r15, %rdi
callq 0xeef4f
movq %rax, 0x10(%r14)
movq $0x0, 0x18(%r14)
leaq -0x22d87d(%rip), %rsi   # 0x10972f
leaq -0x23c4dc(%rip), %rdx   # 0xfaad7
movl $0x1, %edi
callq 0x105830
movq %rax, 0x20(%r14)
callq 0x121b54
movq %rax, 0x28(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x97c31
// File: /workspace/github_c_makefile_star2_O1/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 0x33709c
movq %rsi, %r12
testq %rsi, %rsi
je 0x33709c
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
testq %rcx, %rcx
je 0x337013
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0x3370a1
movq %r12, %rdi
movq %r15, %rsi
callq 0xf748b
movq %rax, %r15
testq %rax, %rax
je 0x337088
cmpq $0x0, 0x18(%r14)
jne 0x337049
leaq -0x22d905(%rip), %rsi   # 0x10972f
leaq -0x24872f(%rip), %rdx   # 0xee90c
movl $0x1, %edi
callq 0x105830
movq %rax, 0x18(%r14)
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x105a11
testq %rax, %rax
jne 0x3370a6
movq 0x18(%r14), %r14
movq %rbx, %rdi
callq 0xe8760
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x105a4c
leaq 0xb85fb(%rip), %rdi     # 0x3ef676
movq %r15, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x108e02
xorl %eax, %eax
cmpq $0x1, %r15
sbbl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x97c6a
callq 0x97ca3
callq 0x97cdc
// File: /workspace/github_c_makefile_star2_O1/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 0x3370fd
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x3370fd
leaq 0xb8622(%rip), %rdi     # 0x3ef6e4
xorl %eax, %eax
callq 0x108e02
cmpq $0x0, 0x18(%rbx)
jne 0x3370f3
leaq 0xb861f(%rip), %rdi     # 0x3ef6f6
xorl %eax, %eax
callq 0x108e02
movq 0x20(%rbx), %rdi
leaq -0x111(%rip), %rsi      # 0x336fd8
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x105afd
movq 0x18(%rbx), %rdi
popq %rbx
jmp 0x105a0c
callq 0x97d15
// File: /workspace/github_c_makefile_star2_O1/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 $0x28, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
movq 0x60(%rsp), %r12
movq %r8, 0x18(%rsp)
movq %r9, 0x20(%rsp)
movq %rdx, %rdi
callq 0x120d23
leaq 0x6225b(%rip), %rsi     # 0x3993af
xorl %ebp, %ebp
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x177f0
cmpl $0x1, %eax
jne 0x3371a9
movq 0x8(%rsp), %rbx
movq %r15, %rdi
callq 0xec1e8
movb $0x1, %r13b
cmpq %rax, %rbx
jb 0x3371cd
movq 0x8(%rsp), %rbx
movq %r15, %rdi
callq 0xec1e8
leaq -0x1(%rax), %rcx
leaq 0xb8642(%rip), %rsi     # 0x3ef7d9
xorl %r13d, %r13d
movq %r12, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1019cf
jmp 0x3371c8
movq %rbx, %rdi
callq 0x120d23
leaq 0xb85e6(%rip), %rsi     # 0x3ef79e
xorl %r13d, %r13d
movq %r12, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb %r13b, %r13b
je 0x337251
leaq 0x18(%rsp), %r13
movq %r13, %rdi
callq 0x117813
leaq 0x1(%rax), %rdi
leaq 0xb840c(%rip), %r12     # 0x3ef5f6
movl $0x1, %esi
movq %r12, %rdx
movl $0x42, %ecx
callq 0x1093ef
movq %rax, %rbx
movq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0xefce0
leaq -0x1(%rax), %rcx
movq (%r13), %rdx
addq %rcx, %rdx
addq 0x8(%r13), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xed87b
movq %r13, %rdi
callq 0x117813
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq 0x10(%rsp), %rcx
callq 0xf6d07
movq %rbx, %rdi
movq %r12, %rsi
movl $0x47, %edx
callq 0x109670
movl %ebp, %eax
addq $0x28, %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/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 0x3373f6
cmpl $0x53, %edi
jg 0x33740a
cmpl $0x41, %edi
je 0x337427
cmpl $0x43, %edi
je 0x337422
cmpl $0x47, %edi
jmp 0x33741b
cmpl $0x73, %edi
jg 0x33740f
cmpl $0x61, %edi
je 0x337427
cmpl $0x63, %edi
je 0x337422
cmpl $0x67, %edi
jmp 0x33741b
addl $-0x54, %edi
jmp 0x337412
addl $-0x74, %edi
cmpl $0x2, %edi
jae 0x33741b
xorl %eax, %eax
jmp 0x337427
movl $0x30, %eax
jmp 0x337427
movl $0x10, %eax
movsbl %sil, %ecx
cmpl $0x60, %ecx
jg 0x337446
cmpl $0x53, %ecx
jg 0x33745f
cmpl $0x41, %ecx
je 0x337473
cmpl $0x43, %ecx
je 0x337478
cmpl $0x47, %ecx
je 0x33745a
jmp 0x33746c
cmpl $0x73, %ecx
jg 0x337464
cmpl $0x61, %ecx
je 0x337473
cmpl $0x63, %ecx
je 0x337478
cmpl $0x67, %ecx
jne 0x33746c
orl $0xc, %eax
jmp 0x33747b
addl $-0x54, %ecx
jmp 0x337467
addl $-0x74, %ecx
cmpl $0x2, %ecx
jb 0x33747b
movl $0xc, %eax
jmp 0x33747b
orl $0x8, %eax
jmp 0x33747b
orl $0x4, %eax
movsbl %dl, %ecx
cmpl $0x60, %ecx
jg 0x337499
cmpl $0x51, %ecx
jg 0x3374c0
cmpl $0x46, %ecx
jg 0x3374d9
cmpl $0x41, %ecx
je 0x3374d4
cmpl $0x43, %ecx
je 0x3374e8
jmp 0x3374e3
leal -0x67(%rcx), %edx
cmpl $0x12, %edx
ja 0x3374b4
movl $0x46080, %esi          # imm = 0x46080
btl %edx, %esi
jb 0x3374ef
testl %edx, %edx
je 0x3374ec
cmpl $0xb, %edx
je 0x3374d4
cmpl $0x63, %ecx
je 0x3374e8
cmpl $0x61, %ecx
je 0x3374d4
jmp 0x3374e3
leal -0x54(%rcx), %edx
cmpl $0x2, %edx
jb 0x3374ef
cmpl $0x52, %ecx
je 0x3374d4
cmpl $0x59, %ecx
je 0x3374ef
jmp 0x3374e3
addl $0x2, %eax
jmp 0x3374ef
cmpl $0x47, %ecx
je 0x3374ec
cmpl $0x4e, %ecx
je 0x3374ef
addl $0x4, %eax
jmp 0x3374ef
incl %eax
jmp 0x3374ef
addl $0x3, %eax
movl %eax, %eax
leaq 0xb83b8(%rip), %rcx     # 0x3ef8b0
movb (%rax,%rcx), %al
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/mgth/mg_combinedscore.c
// Function: add_scores
static void add_scores(ParseStruct *parsestruct_ptr,
                       double *matrix_row,
                       GtUword *count_row_fct,
                       short current_row_fct,
                       GtUword hit_number,
                       GtUword position,
                       unsigned short k, double score)
{
  /* Wenn der Query-Leserahmen negativ ist, muessen die Combined-Scores
     von Rechts nach Links in die Combined-Score Matrix eingetragen werden
     - also ausgehend vom Query-to Wert */
  if (current_row_fct > 3)
  {
    matrix_row[POSITION(MATRIXSTRUCT(query_to), hit_number, -position, -k)]
      += score;
    count_row_fct[POSITION
                  (MATRIXSTRUCT(query_to), hit_number, -position, -k)] +=
      1;
  }
  else
  {
    matrix_row[POSITION(MATRIXSTRUCT(query_from), hit_number, position, k)]
      += score;
    count_row_fct[POSITION
                  (MATRIXSTRUCT(query_from), hit_number, position, k)] +=
      1;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %r9, %r15
movq %r8, %r14
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r12
movzwl 0x40(%rsp), %ebp
cmpw $0x4, %cx
jb 0x3382e6
movq 0x118(%r12), %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %rax
addq %r15, %rbp
notq %rbp
leaq (,%rax,8), %rax
addq %r13, %rax
movsd (%rsp), %xmm0
addsd (%rax,%rbp,8), %xmm0
movsd %xmm0, (%rax,%rbp,8)
movq 0x118(%r12), %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %rax
leaq (%rbx,%rax,8), %rax
leaq (%rax,%rbp,8), %rax
jmp 0x33833e
movq 0x110(%r12), %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %rax
leaq (,%rax,8), %rax
addq %r13, %rax
leaq (%rax,%r15,8), %rax
shll $0x3, %ebp
movsd (%rsp), %xmm0
addsd -0x8(%rbp,%rax), %xmm0
movsd %xmm0, -0x8(%rbp,%rax)
movq 0x110(%r12), %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %rax
leaq (%rbx,%rax,8), %rax
leaq (%rax,%r15,8), %rax
addq %rbp, %rax
addq $-0x8, %rax
incq (%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/mgth/mg_compute_gene_prediction.c
// Function: gt_check_stopcodon
short gt_check_stopcodon(char *contig_seq_ptrfct)
{
  unsigned short codon_status = 0;

  /* jeder if-Zweig ueberprueft entsprechend des
     Metagenomethreader-Arguments zur Verwendung alternativer Start-Codons
     auf Start-Codons */
  if (!strcmp(contig_seq_ptrfct, "tga")
      || !strcmp(contig_seq_ptrfct, "taa")
      || !strcmp(contig_seq_ptrfct, "tag")
      || !strcmp(contig_seq_ptrfct, "tar")
      || !strcmp(contig_seq_ptrfct, "uga")
      || !strcmp(contig_seq_ptrfct, "uaa")
      || !strcmp(contig_seq_ptrfct, "uag")
      || !strcmp(contig_seq_ptrfct, "uar"))
  {
    codon_status = 1;
  }

  return codon_status;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x6425f(%rip), %rsi     # 0x39d9a6
callq 0x17a40
testl %eax, %eax
je 0x3397dd
leaq 0xb5177(%rip), %rsi     # 0x3ee8d2
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x3397dd
leaq 0xba0e4(%rip), %rsi     # 0x3f3852
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x3397dd
leaq 0x89435(%rip), %rsi     # 0x3c2bb6
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x3397dd
leaq 0xb62ba(%rip), %rsi     # 0x3efa4e
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x3397dd
leaq 0xb62ab(%rip), %rsi     # 0x3efa52
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x3397dd
leaq 0xb629c(%rip), %rsi     # 0x3efa56
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x3397dd
leaq 0xb628d(%rip), %rsi     # 0x3efa5a
movq %rbx, %rdi
callq 0x17a40
testl %eax, %eax
je 0x3397dd
xorl %eax, %eax
jmp 0x3397e1
movw $0x1, %ax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/canvas_cairo_context.c
// Function: gt_canvas_cairo_context_class
const GtCanvasClass* gt_canvas_cairo_context_class(void)
{
  static const GtCanvasClass *canvas_class = NULL;
  gt_class_alloc_lock_enter();
  if (!canvas_class) {
    canvas_class = gt_canvas_class_new(sizeof (GtCanvasCairoContext),
                                       gt_canvas_cairo_visit_layout_pre,
                                       gt_canvas_cairo_visit_layout_post,
                                       gt_canvas_cairo_visit_track_pre,
                                       gt_canvas_cairo_visit_track_post,
                                       gt_canvas_cairo_visit_line_pre,
                                       gt_canvas_cairo_visit_line_post,
                                       gt_canvas_cairo_visit_block,
                                       gt_canvas_cairo_visit_element,
                                       gt_canvas_cairo_visit_custom_track,
                                       gt_canvas_cairo_draw_ruler,
                                       NULL);
  }
  gt_class_alloc_lock_leave();
  return canvas_class;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x18febb(%rip)    # 0x4ca010
jne 0x33a1bc
leaq 0x1178d(%rip), %rax     # 0x34b8eb
leaq 0x114d0(%rip), %r10     # 0x34b635
leaq 0x10a58(%rip), %r11     # 0x34abc4
leaq 0x10260(%rip), %rbx     # 0x34a3d3
leaq 0x1018f(%rip), %r14     # 0x34a309
leaq 0xfbb3(%rip), %rsi      # 0x349d34
leaq 0xfc4c(%rip), %rdx      # 0x349dd4
leaq 0xfc48(%rip), %rcx      # 0x349dd7
leaq 0xff4a(%rip), %r8       # 0x34a0e0
leaq 0xffb7(%rip), %r9       # 0x34a154
movl $0x18, %edi
pushq $0x0
pushq %rax
pushq %r10
pushq %r11
pushq %rbx
pushq %r14
callq 0x222148
addq $0x30, %rsp
movq %rax, 0x18fe54(%rip)    # 0x4ca010
callq 0xe6a19
movq 0x18fe48(%rip), %rax    # 0x4ca010
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/custom_track_gc_content.c
// Function: gt_custom_track_gc_content_class
const GtCustomTrackClass* gt_custom_track_gc_content_class(void)
{
  static const GtCustomTrackClass *ctc = NULL;
  gt_class_alloc_lock_enter();
  if (!ctc)
  {
    ctc = gt_custom_track_class_new(sizeof (GtCustomTrackGcContent),
                                    gt_custom_track_gc_content_sketch,
                                    gt_custom_track_gc_content_get_height,
                                    gt_custom_track_gc_content_get_title,
                                    gt_custom_track_gc_content_delete);
  }
  gt_class_alloc_lock_leave();
  return ctc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x18efc7(%rip)    # 0x4ca020
jne 0x33b088
leaq -0x692(%rip), %rsi      # 0x33a9d0
leaq 0xd1(%rip), %rdx        # 0x33b13a
leaq 0xe4(%rip), %rcx        # 0x33b154
leaq 0xfb(%rip), %r8         # 0x33b172
movl $0x48, %edi
callq 0x33a82c
movq %rax, 0x18ef98(%rip)    # 0x4ca020
callq 0xe6a19
movq 0x18ef8c(%rip), %rax    # 0x4ca020
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/custom_track_gc_content.c
// Function: get_val_for_pos
static double get_val_for_pos(GtCustomTrackGcContent *ctgc, GtUword pos)
{
  GtUword i,
                gc_count = 0,
                bases = 0;
  for (i=0;i<ctgc->windowsize;i++)
  {
    if (pos + i > ctgc->seqlen)
      return -1;
    if (ctgc->seq[pos+i] == 'g' || ctgc->seq[pos+i] == 'c'
         || ctgc->seq[pos+i] == 'G' || ctgc->seq[pos+i] == 'C')
    {
      gc_count++;
    }
    bases++;
  }
  return ((double) gc_count)/((double) GT_MIN(ctgc->windowsize, bases));
}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x33b131
movq 0x40(%rdi), %rdx
xorl %ecx, %ecx
movsd 0x39f07(%rip), %xmm0    # 0x374fb8
movl $0x303, %r8d            # imm = 0x303
movq %rax, %r9
cmpq %rdx, %rsi
ja 0x33b130
movq 0x38(%rdi), %r10
movb (%r10,%rsi), %r10b
addb $-0x43, %r10b
rolb $0x6, %r10b
cmpb $0x9, %r10b
ja 0x33b0e2
movzbl %r10b, %r10d
btl %r10d, %r8d
jae 0x33b0e2
incq %rcx
incq %rsi
decq %r9
jne 0x33b0ba
movq %rcx, %xmm1
movq 0x157e9(%rip), %xmm2    # 0x3508e0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x157ed(%rip), %xmm3    # 0x3508f0
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
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
retq
movsd 0xb4cc7(%rip), %xmm0    # 0x3efe00
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/custom_track_gc_content.c
// Function: gt_custom_track_gc_content_new
GtCustomTrack* gt_custom_track_gc_content_new(const char *seq,
                                              GtUword seqlen,
                                              GtUword windowsize,
                                              GtUword height,
                                              double avg,
                                              bool show_scale)
{
  GtCustomTrackGcContent *ctgc;
  GtCustomTrack *ct;
  char buf[BUFSIZ];
  ct = gt_custom_track_create(gt_custom_track_gc_content_class());
  ctgc = gt_custom_track_gc_content_cast(ct);
  ctgc->windowsize = windowsize;
  ctgc->height = height;
  ctgc->seq = seq;
  ctgc->seqlen = seqlen;
  ctgc->avg = avg;
  ctgc->show_scale = show_scale;
  ctgc->title = gt_str_new_cstr("GC content (window size ");
  gt_str_append_uword(ctgc->title, ctgc->windowsize);
  if (gt_double_smaller_double(0, avg))
  {
    (void) snprintf(buf, BUFSIZ, ", average: %.1f%%", avg*100);
    gt_str_append_cstr(ctgc->title, buf);
  }
  gt_str_append_cstr(ctgc->title, ")");
  return ct;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2018, %rsp           # imm = 0x2018
movl %r8d, %ebp
movsd %xmm0, (%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
callq 0x33b04b
movq %rax, %rdi
callq 0x33a86b
movq %rax, %r14
callq 0x33b04b
movq %rax, %rdi
movq %r14, 0x8(%rsp)
movq %r14, %rsi
callq 0x33a9b6
movq %rax, %r14
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %rbx, 0x38(%rax)
movq %r13, 0x40(%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movb %bpl, 0x28(%rax)
leaq 0xb4d4e(%rip), %rdi     # 0x3eff56
callq 0x120955
movq %rax, 0x30(%r14)
movq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x120af4
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
callq 0x10ad54
testb %al, %al
je 0x33b263
movsd (%rsp), %xmm0
mulsd 0x175b4(%rip), %xmm0    # 0x3527f0
leaq 0xb4d2c(%rip), %rdx     # 0x3eff6f
leaq 0x10(%rsp), %rbx
movl $0x2000, %esi           # imm = 0x2000
movq %rbx, %rdi
movb $0x1, %al
callq 0x17c60
movq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0x12097f
movq 0x30(%r14), %rdi
leaq 0xa65c7(%rip), %rsi     # 0x3e1835
callq 0x12097f
movq 0x8(%rsp), %rax
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop