LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/radixsort_str.c
// Function: gt_radixsort_str_codeslcp
static inline gt_radixsort_str_bucketnum_t
        gt_radixsort_str_codeslcp(GtRadixsortstringinfo *rsi,
            gt_radixsort_str_bucketnum_t a, gt_radixsort_str_bucketnum_t b)
{
  if (a != GT_RADIXSORT_STR_SPECIAL_BUCKET &&
      b != GT_RADIXSORT_STR_SPECIAL_BUCKET)
  {
    gt_radixsort_str_bucketnum_t codeslcp, maxcodeslcp, ova, ovb;

    codeslcp = rsi->xorvalue2lcp[GT_DIV4(a ^ b)];
    /* now take the overflow into account */
    ova = GT_RADIXSORT_STR_OVERFLOW_NONSPECIAL(a);
    ovb = GT_RADIXSORT_STR_OVERFLOW_NONSPECIAL(b);
    maxcodeslcp = GT_RADIXSORT_STR_KMERSIZE - GT_MAX(ova, ovb);
    return GT_MIN(codeslcp, maxcodeslcp);
  }
  return 0;
}

// Assembly:
movw %dx, %ax
movw %si, %cx
movq %rdi, -0x10(%rsp)
movw %cx, -0x12(%rsp)
movw %ax, -0x14(%rsp)
movzwl -0x12(%rsp), %eax
cmpl $0x400, %eax            # imm = 0x400
je 0x4d56f6
movzwl -0x14(%rsp), %eax
cmpl $0x400, %eax            # imm = 0x400
je 0x4d56f6
movq -0x10(%rsp), %rax
movq 0x40(%rax), %rax
movzwl -0x12(%rsp), %ecx
movzwl -0x14(%rsp), %edx
xorl %edx, %ecx
sarl $0x2, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movw %ax, -0x16(%rsp)
movzwl -0x12(%rsp), %eax
andl $0x3, %eax
movw %ax, -0x1a(%rsp)
movzwl -0x14(%rsp), %eax
andl $0x3, %eax
movw %ax, -0x1c(%rsp)
movzwl -0x1a(%rsp), %eax
movzwl -0x1c(%rsp), %ecx
cmpl %ecx, %eax
jle 0x4d56ac
movzwl -0x1a(%rsp), %eax
movl %eax, -0x20(%rsp)
jmp 0x4d56b5
movzwl -0x1c(%rsp), %eax
movl %eax, -0x20(%rsp)
movl -0x20(%rsp), %eax
movslq %eax, %rcx
movl $0x4, %eax
subq %rcx, %rax
movw %ax, -0x18(%rsp)
movzwl -0x16(%rsp), %eax
movzwl -0x18(%rsp), %ecx
cmpl %ecx, %eax
jge 0x4d56e2
movzwl -0x16(%rsp), %eax
movl %eax, -0x24(%rsp)
jmp 0x4d56eb
movzwl -0x18(%rsp), %eax
movl %eax, -0x24(%rsp)
movl -0x24(%rsp), %eax
movw %ax, -0x2(%rsp)
jmp 0x4d56fd
movw $0x0, -0x2(%rsp)
movw -0x2(%rsp), %ax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/radixsort_str.c
// Function: gt_radixsort_str_code_at_position
static inline gt_radixsort_str_kmercode_t gt_radixsort_str_code_at_position(
    const GtTwobitencoding *twobitencoding, GtUword pos)
{
  unsigned int unitoffset = (unsigned int) GT_MODBYUNITSIN2BITENC(pos);
  GtUword unitindex = GT_DIVBYUNITSIN2BITENC(pos);

  if (unitoffset <=
      (unsigned int) (GT_UNITSIN2BITENC - GT_RADIXSORT_STR_KMERSIZE))
  {
    return (gt_radixsort_str_kmercode_t)
      (twobitencoding[unitindex] >>
       GT_MULT2(GT_UNITSIN2BITENC - GT_RADIXSORT_STR_KMERSIZE - unitoffset))
       & GT_RADIXSORT_STR_KMERCODE_MAX;
  } else
  {
    unsigned int shiftleft =
      GT_MULT2(unitoffset + (unsigned int) GT_RADIXSORT_STR_KMERSIZE -
               GT_UNITSIN2BITENC);
    return (gt_radixsort_str_kmercode_t)
                  ((twobitencoding[unitindex] << shiftleft) |
                   (twobitencoding[unitindex + 1] >>
                       (GT_MULT2(GT_UNITSIN2BITENC) - shiftleft)))
                  & GT_RADIXSORT_STR_KMERCODE_MAX;
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
andq $0x1f, %rax
movl %eax, -0x1c(%rsp)
movq -0x18(%rsp), %rax
shrq $0x5, %rax
movq %rax, -0x28(%rsp)
cmpl $0x1c, -0x1c(%rsp)
ja 0x4d5cfc
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x1c(%rsp), %ecx
movl %ecx, %edx
movl $0x1c, %ecx
subq %rdx, %rcx
shlq %rcx
shrq %cl, %rax
movzbl %al, %eax
andl $0xff, %eax
movb %al, -0x1(%rsp)
jmp 0x4d5d50
movl -0x1c(%rsp), %eax
addl $0x4, %eax
subl $0x20, %eax
shll %eax
movl %eax, -0x2c(%rsp)
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x2c(%rsp), %ecx
shlq %cl, %rax
movq -0x10(%rsp), %rcx
movq -0x28(%rsp), %rdx
movq 0x8(%rcx,%rdx,8), %rdx
movl $0x40, %ecx
subl -0x2c(%rsp), %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
movzbl %al, %eax
andl $0xff, %eax
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x0, 0xc(%rax)
ja 0x4d962c
movq 0x1629a5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3ca0e(%rip), %rsi     # 0x516013
leaq 0xe0d13(%rip), %rdx     # 0x5ba31f
leaq 0xe0d2b(%rip), %rcx     # 0x5ba33e
leaq 0xe0bea(%rip), %r8      # 0x5ba204
movl $0x135, %r9d            # imm = 0x135
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d962e
movq 0x28(%rsp), %rax
cmpl $0x1, 0xc(%rax)
jne 0x4d9647
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x4d974b
movq $0x0, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rcx
movl 0xc(%rax), %eax
movl %eax, %edx
decl %edx
leaq (%rdx,%rdx,2), %rdx
shlq $0x4, %rdx
movq 0x18(%rcx,%rdx), %xmm0
movaps 0x3f2bc(%rip), %xmm1    # 0x518930
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x3f2c0(%rip), %xmm1    # 0x518940
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x4d972c
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl 0xc(%rsp), %ecx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %xmm0
movaps 0x3f25b(%rip), %xmm1    # 0x518930
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x3f25f(%rip), %xmm1    # 0x518940
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
subsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4d96a6
movsd 0x10(%rsp), %xmm0
movq 0x28(%rsp), %rax
movl 0xc(%rax), %eax
decl %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-sfx-partssuf.c
// Function: gt_suftabparts_rc_minindex_raw
static GtCodetype gt_suftabparts_rc_minindex_raw(
    unsigned int part, const GtSuftabparts_rc *suftabparts_rc)
{
  GtCodetype minindex;
  gt_assert(suftabparts_rc != NULL && part < suftabparts_rc->numofparts);

  minindex = (part == 0) ? 0 : suftabparts_rc->components[part-1].nextidx + 1;
  if (suftabparts_rc->fct != NULL)
  {
    return gt_randomcodes_sample2full(suftabparts_rc->fct,minindex);
  }
  return minindex;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x4da203
movl 0x1c(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x4da23b
movq 0x161d96(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3bdff(%rip), %rsi     # 0x516013
leaq 0xe015e(%rip), %rdx     # 0x5ba379
leaq 0xe02ed(%rip), %rcx     # 0x5ba50f
leaq 0xdffdb(%rip), %r8      # 0x5ba204
movl $0x5c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4da23d
cmpl $0x0, 0x1c(%rsp)
jne 0x4da24c
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x4da26f
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
addq $0x1, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x4da29e
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x4dbda0
movq %rax, 0x20(%rsp)
jmp 0x4da2a8
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-sfx-partssuf.c
// Function: gt_suftabparts_rc_maxindex_raw
static GtCodetype gt_suftabparts_rc_maxindex_raw(
    unsigned int part, const GtSuftabparts_rc *suftabparts_rc)
{
  GtCodetype maxindex;

  gt_assert(suftabparts_rc != NULL && part < suftabparts_rc->numofparts);
  if (suftabparts_rc->fct != NULL)
  {
    maxindex = suftabparts_rc->components[part].nextidx;
    return gt_randomcodes_sample2full(suftabparts_rc->fct,maxindex);
  }
  maxindex = (part == suftabparts_rc->numofparts - 1)
               ? suftabparts_rc->components[part].nextidx - 1
               : suftabparts_rc->components[part].nextidx;
  return maxindex;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x4da2e3
movl 0x1c(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x4da31b
movq 0x161cb6(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3bd1f(%rip), %rsi     # 0x516013
leaq 0xe007e(%rip), %rdx     # 0x5ba379
leaq 0xe022c(%rip), %rcx     # 0x5ba52e
leaq 0xdfefb(%rip), %r8      # 0x5ba204
movl $0x6b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4da31d
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x4da35e
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x1c(%rsp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x4dbda0
movq %rax, 0x20(%rsp)
jmp 0x4da3be
movl 0x1c(%rsp), %eax
movq 0x10(%rsp), %rcx
movl 0xc(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x4da391
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x1c(%rsp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
subq $0x1, %rax
movq %rax, (%rsp)
jmp 0x4da3ab
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x1c(%rsp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $0x1, %rdi
movl $0x1, %esi
leaq 0xdfa95(%rip), %rdx     # 0x5ba54d
movl $0x27, %ecx
callq 0xe83c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
addq $0x1, %rax
shlq $0x0, %rax
movl $0x2a, %esi
leaq 0xdfa61(%rip), %rdx     # 0x5ba54d
movl $0x1, %r9d
leaq 0xdd599(%rip), %r8      # 0x5b8092
movl %r9d, %ecx
movq %rax, (%rsp)
callq 0x4bea60
callq 0x4dac00
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x4dab5a
movq 0x161477(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3b4e0(%rip), %rsi     # 0x516013
leaq 0xdfa2f(%rip), %rdx     # 0x5ba569
leaq 0xdfa49(%rip), %rcx     # 0x5ba58a
leaq 0xdfa05(%rip), %r8      # 0x5ba54d
movl $0x2c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4dab5c
movq 0x18(%rsp), %rax
movq $0x0, 0x60(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x58(%rax)
movq 0x18(%rsp), %rax
movl $0x20, 0x7c(%rax)
movq 0x18(%rsp), %rax
cmpl $0x20, 0x7c(%rax)
jne 0x4dab9b
movq 0x18(%rsp), %rax
movl $0xffffffff, 0x78(%rax) # imm = 0xFFFFFFFF
jmp 0x4dabbb
movq 0x18(%rsp), %rax
movl 0x7c(%rax), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x78(%rax)
jmp 0x4dabbd
movq 0x18(%rsp), %rax
movq $0x0, 0x80(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x90(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x88(%rax)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x20, %eax
subl 0x3c(%rsp), %eax
shll %eax
movl %eax, %eax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x4dadb9
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x40(%rsp), %rcx
movq 0x30(%rsp), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x4dad8f
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
xorq (%rcx), %rax
movq 0x18(%rsp), %rcx
shlq %cl, %rax
cmpq $0x0, %rax
je 0x4dad7d
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
jmp 0x4dad7f
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
jmp 0x4dad26
movq 0x10(%rsp), %rax
movq 0x40(%rsp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x4dadb7
jmp 0x4dadb7
jmp 0x4dadb9
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
movq %rdx, %xmm0
movaps 0x3db61(%rip), %xmm3    # 0x518930
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x3db65(%rip), %xmm2    # 0x518940
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x3fa46(%rip), %xmm1    # 0x51a838
mulsd %xmm1, %xmm0
movq 0x30(%rsp), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq 0x30(%rsp), %rcx
leaq 0xdf787(%rip), %rsi     # 0x5ba5a6
movb $0x1, %al
callq 0xe7cd0
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xff, %eax
je 0x4dbabf
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, 0x24(%rsp)
jmp 0x4dbb29
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x4dc120
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x4dbb17
movq 0x1604ba(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3a523(%rip), %rsi     # 0x516013
leaq 0xdc74c(%rip), %rdx     # 0x5b8243
leaq 0xded41(%rip), %rcx     # 0x5ba83f
leaq 0xdea48(%rip), %r8      # 0x5ba54d
movl $0xc4, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4dbb19
movq 0x8(%rsp), %rax
movl (%rax), %eax
addl $0xfe, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rdx
xorl %eax, %eax
cmpq 0x90(%rdx), %rcx
movb %al, -0x19(%rsp)
jae 0x4dbc1d
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movq 0x80(%rcx), %rcx
movq -0x18(%rsp), %rdx
cmpq (%rcx,%rdx,8), %rax
seta %al
movb %al, -0x19(%rsp)
movb -0x19(%rsp), %al
testb $0x1, %al
jne 0x4dbc27
jmp 0x4dbc37
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x4dbbe3
movq -0x8(%rsp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rsp), %rdx
movq -0x8(%rsp), %rcx
movl 0x7c(%rcx), %ecx
shlq %cl, %rdx
movq %rdx, %rcx
addq %rcx, %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
addq $0x1, %rax
cmpq 0x20(%rsp), %rax
jae 0x4dbd24
movq 0x28(%rsp), %rax
addq 0x20(%rsp), %rax
shrq %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4dbb60
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x4dbceb
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x4dbd8e
movq 0x30(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x4dbd11
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x4dbd1f
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x4dbc9a
jmp 0x4dbd26
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4dbb60
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jbe 0x4dbd82
movq 0x16024f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3a2b8(%rip), %rsi     # 0x516013
leaq 0xdea68(%rip), %rdx     # 0x5ba7ca
leaq 0xdea96(%rip), %rcx     # 0x5ba7ff
leaq 0xde7dd(%rip), %r8      # 0x5ba54d
movl $0x1a2, %r9d            # imm = 0x1A2
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4dbd84
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x4dbdf4
movq 0x1601dd(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3a246(%rip), %rsi     # 0x516013
leaq 0xde9c3(%rip), %rdx     # 0x5ba797
leaq 0xdea49(%rip), %rcx     # 0x5ba824
leaq 0xde76b(%rip), %r8      # 0x5ba54d
movl $0x1a9, %r9d            # imm = 0x1A9
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4dbdf6
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x4dbe1b
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movl 0x38(%rcx), %ecx
shlq %cl, %rax
movq %rax, 0x10(%rsp)
jmp 0x4dbe2c
movq 0x8(%rsp), %rax
movq (%rax), %rax
subq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x58(%rax)
je 0x4dbeb0
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rdi
leaq 0xde6e3(%rip), %rsi     # 0x5ba54d
movl $0x1b6, %edx            # imm = 0x1B6
callq 0xe88c0
movq 0x10(%rsp), %rdi
movl $0x1b7, %esi            # imm = 0x1B7
leaq 0xde6c8(%rip), %rdx     # 0x5ba54d
xorl %ecx, %ecx
leaq 0xdc0de(%rip), %r8      # 0x5b7f6c
movl $0x1, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x4bea60
movq 0x8(%rsp), %rax
movq $0x0, 0x58(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x4dbf30
movq 0x10(%rsp), %rdi
movl $0x1c1, %esi            # imm = 0x1C1
leaq 0xde662(%rip), %rdx     # 0x5ba54d
xorl %ecx, %ecx
leaq 0xdc19e(%rip), %r8      # 0x5b8092
movl $0x1, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x4bea60
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
leaq 0xde634(%rip), %rsi     # 0x5ba54d
movl $0x1c2, %edx            # imm = 0x1C2
callq 0xe88c0
movq 0x8(%rsp), %rax
movq $0x0, 0x48(%rax)
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0xe3360
movq 0x8(%rsp), %rax
movq $0x0, 0x50(%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4dbe40
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq $0x0, 0x60(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x80(%rax)
je 0x4dbfe4
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rdi
leaq 0xde5a3(%rip), %rsi     # 0x5ba54d
movl $0x1cf, %edx            # imm = 0x1CF
callq 0xe88c0
movq 0x8(%rsp), %rax
movq $0x0, 0x88(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x90(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x80(%rax)
jmp 0x4dbfe6
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-tab.c
// Function: gt_randomcodes_countocc_setnull
void gt_randomcodes_countocc_setnull(GtRandomcodestab *rct)
{
  rct->leftborder = NULL;
  rct->countocc_small = NULL;
  rct->leftborder_samples = NULL;
  rct->countocc_exceptions = NULL;
  rct->differentcodes = 0;
  rct->lastincremented_idx = 0;
  rct->lastincremented_valueptr = NULL;
  rct->hashmap_addcount = 0;
  rct->hashmap_incrementcount = 0;
  rct->all_incrementcount = 0;
  rct->hashmap_getcount = 0;
  rct->outfilenameleftborder = NULL;
#if defined (_LP64) || defined (_WIN64)
  GT_INITARRAY(&rct->bitchangepoints,GtUword);
#endif
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x48(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x58(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x50(%rax)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x68(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x70(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x60(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x80(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x90(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x88(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-ovlfind-bf.c
// Function: contfind_bf
static inline bool contfind_bf(const char *a, GtUword alen,
    const char *b, GtUword blen)
{
  GtUword offset;
  gt_assert(alen < blen);
  for (offset = 0; offset <= blen-alen; offset++)
    if (memcmp(a, b+offset, (size_t)alen) == 0) return true;
  return false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x10(%rsp), %rax
jb 0x4dc57c
movq 0x15fa55(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x39abe(%rip), %rsi     # 0x516013
leaq 0xde587(%rip), %rdx     # 0x5baae3
leaq 0xde58c(%rip), %rcx     # 0x5baaef
leaq 0xde309(%rip), %r8      # 0x5ba873
movl $0x1f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4dc57e
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
subq 0x20(%rsp), %rcx
cmpq %rcx, %rax
ja 0x4dc5d2
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x192c0
cmpl $0x0, %eax
jne 0x4dc5c0
movb $0x1, 0x37(%rsp)
jmp 0x4dc5d7
jmp 0x4dc5c2
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x4dc587
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-ovlfind-bf.c
// Function: spmfind_bf
static inline void spmfind_bf(const char *a, GtUword alen,
    const char *b, GtUword blen, GtUword minlen,
    bool find_nonmaximal, bool self_comparison,
    void(*proc)(GtUword, bool, void*), bool direction,
    void* procdata)
{
  GtUword len, from;
  from = GT_MIN(alen, blen);
  if (self_comparison)
    from -= 1;
  for (len = from; len >= minlen; len--)
    if (memcmp(a+alen-len, b, (size_t)len) == 0)
    {
      proc(len, direction, procdata);
      if (!find_nonmaximal) break;
    }
}

// Assembly:
subq $0x58, %rsp
movl %r9d, %eax
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r9
movq 0x8(%rsp), %rsi
movq %rdi, %r10
movq 0x10(%rsp), %rdi
movb %al, %dl
movq 0x78(%rsp), %rax
movb 0x70(%rsp), %al
movq 0x68(%rsp), %rcx
movb 0x60(%rsp), %cl
movq %r10, 0x50(%rsp)
movq %r9, 0x48(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %r8, 0x30(%rsp)
andb $0x1, %dl
movb %dl, 0x2f(%rsp)
andb $0x1, %cl
movb %cl, 0x2e(%rsp)
andb $0x1, %al
movb %al, 0x2d(%rsp)
movq 0x48(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x4dc669
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
jmp 0x4dc672
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x2e(%rsp)
je 0x4dc690
movq 0x18(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x30(%rsp), %rax
jb 0x4dc706
movq 0x50(%rsp), %rdi
addq 0x48(%rsp), %rdi
xorl %eax, %eax
subq 0x20(%rsp), %rax
addq %rax, %rdi
movq 0x40(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x192c0
cmpl $0x0, %eax
jne 0x4dc6f4
movq 0x68(%rsp), %rax
movq 0x20(%rsp), %rdi
movb 0x2d(%rsp), %cl
movq 0x78(%rsp), %rdx
andb $0x1, %cl
movzbl %cl, %esi
callq *%rax
testb $0x1, 0x2f(%rsp)
jne 0x4dc6f2
jmp 0x4dc706
jmp 0x4dc6f4
jmp 0x4dc6f6
movq 0x20(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x4dc69a
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-ovlfind-dp.c
// Function: v_contfind_dp
static inline
bool v_contfind_dp(GtUword max_edist, GtUword m,
                  GtOvlfindDpCell **lastcol)
{
  GtUword i;
  for (i = 0; i <= m; i++)
    if ((*lastcol)[i].edist <= max_edist &&
        (*lastcol)[i].start_j == 0)
      return true;
  return false;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x18(%rsp), %rax
ja 0x4deaf0
movq -0x20(%rsp), %rax
movq (%rax), %rax
imulq $0x18, -0x28(%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x10(%rsp), %rax
ja 0x4deade
movq -0x20(%rsp), %rax
movq (%rax), %rax
imulq $0x18, -0x28(%rsp), %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
jne 0x4deade
movb $0x1, -0x1(%rsp)
jmp 0x4deaf5
jmp 0x4deae0
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x4dea98
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-ovlfind-dp.c
// Function: u_contfind_dp
static inline
bool u_contfind_dp(GtUword max_edist, GtUword n,
                  GtOvlfindDpCell **lastrow)
{
  GtUword j;
  for (j = 0; j <= n; j++)
    if ((*lastrow)[j].edist <= max_edist &&
        (*lastrow)[j].start_i == 0)
      return true;
  return false;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x18(%rsp), %rax
ja 0x4deb70
movq -0x20(%rsp), %rax
movq (%rax), %rax
imulq $0x18, -0x28(%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x10(%rsp), %rax
ja 0x4deb5e
movq -0x20(%rsp), %rax
movq (%rax), %rax
imulq $0x18, -0x28(%rsp), %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
jne 0x4deb5e
movb $0x1, -0x1(%rsp)
jmp 0x4deb75
jmp 0x4deb60
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x4deb18
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-ovlfind-dp.c
// Function: u_smpfind_dp
static inline void u_smpfind_dp(GtUword min_length,
    GtUword max_edist, bool find_submaximal,
    GtUword m, GtUword n, GtOvlfindDpCell **lastrow,
    void (*proc)(GtUword, GtUword, GtUword, bool,
    void*), void* procdata)
{
  GtUword j, suffix_length;

  gt_assert(m > 0);
  gt_assert(n > 0);
  gt_assert(lastrow != NULL);
  for (j = n; j >= min_length; j--)
  {
    if ((*lastrow)[j].edist <= max_edist &&
        (*lastrow)[j].start_j == 0)
    {
      suffix_length = m - (*lastrow)[j].start_i;
      if (suffix_length >= min_length)
        proc(suffix_length, j /* prefix length */,
             (*lastrow)[j].edist, true, procdata);
      if (!find_submaximal) break;
    }
  }
}

// Assembly:
subq $0x48, %rsp
movb %dl, %al
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rdx
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
cmpq $0x0, 0x28(%rsp)
ja 0x4debef
movq 0x15d3e2(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3744b(%rip), %rsi     # 0x516013
leaq 0xaacde(%rip), %rdx     # 0x5898ad
leaq 0xdc090(%rip), %rcx     # 0x5bac66
leaq 0xdbf2c(%rip), %r8      # 0x5bab09
movl $0x4d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4debf1
jmp 0x4debf3
cmpq $0x0, 0x20(%rsp)
ja 0x4dec33
movq 0x15d39e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x37407(%rip), %rsi     # 0x516013
leaq 0x6a8d7(%rip), %rdx     # 0x5494ea
leaq 0xdc04c(%rip), %rcx     # 0x5bac66
leaq 0xdbee8(%rip), %r8      # 0x5bab09
movl $0x4e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4dec35
jmp 0x4dec37
cmpq $0x0, 0x18(%rsp)
jne 0x4dec77
movq 0x15d35a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x373c3(%rip), %rsi     # 0x516013
leaq 0xdc01c(%rip), %rdx     # 0x5bac73
leaq 0xdc008(%rip), %rcx     # 0x5bac66
leaq 0xdbea4(%rip), %r8      # 0x5bab09
movl $0x4f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4dec79
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x40(%rsp), %rax
jb 0x4ded40
movq 0x18(%rsp), %rax
movq (%rax), %rax
imulq $0x18, 0x10(%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq 0x38(%rsp), %rax
ja 0x4ded2b
movq 0x18(%rsp), %rax
movq (%rax), %rax
imulq $0x18, 0x10(%rsp), %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
jne 0x4ded2b
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x18, 0x10(%rsp), %rdx
addq %rdx, %rcx
subq 0x8(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x40(%rsp), %rax
jb 0x4ded20
movq 0x50(%rsp), %rax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x18, 0x10(%rsp), %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq 0x58(%rsp), %r8
movl $0x1, %ecx
callq *%rax
testb $0x1, 0x37(%rsp)
jne 0x4ded29
jmp 0x4ded40
jmp 0x4ded2b
jmp 0x4ded2d
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x4dec83
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-ovlfind-dp.c
// Function: v_smpfind_dp
static inline
void v_smpfind_dp(GtUword min_length, GtUword max_edist,
                  bool find_submaximal, GtUword m,
                  GtUword n, GtOvlfindDpCell **lastcol,
                  void (*proc)(GtUword, GtUword,
                               GtUword, bool, void*),
                  void* procdata)
{
  GtUword i, prefix_length;

  gt_assert(m > 0);
  gt_assert(n > 0);
  gt_assert(lastcol != NULL);
  for (i = m; i >= min_length; i--)
  {
    if ((*lastcol)[i].edist <= max_edist &&
        (*lastcol)[i].start_i == 0)
    {
      prefix_length = n - (*lastcol)[i].start_j;
      if (prefix_length >= min_length)
        proc(i /* suffix length */, prefix_length,
             (*lastcol)[i].edist, false, procdata);
      if (!find_submaximal) break;
    }
  }
}

// Assembly:
subq $0x48, %rsp
movb %dl, %al
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rdx
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
cmpq $0x0, 0x28(%rsp)
ja 0x4dedbf
movq 0x15d212(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3727b(%rip), %rsi     # 0x516013
leaq 0xaab0e(%rip), %rdx     # 0x5898ad
leaq 0xdbedd(%rip), %rcx     # 0x5bac83
leaq 0xdbd5c(%rip), %r8      # 0x5bab09
movl $0x69, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4dedc1
jmp 0x4dedc3
cmpq $0x0, 0x20(%rsp)
ja 0x4dee03
movq 0x15d1ce(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x37237(%rip), %rsi     # 0x516013
leaq 0x6a707(%rip), %rdx     # 0x5494ea
leaq 0xdbe99(%rip), %rcx     # 0x5bac83
leaq 0xdbd18(%rip), %r8      # 0x5bab09
movl $0x6a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4dee05
jmp 0x4dee07
cmpq $0x0, 0x18(%rsp)
jne 0x4dee47
movq 0x15d18a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x371f3(%rip), %rsi     # 0x516013
leaq 0xdbe69(%rip), %rdx     # 0x5bac90
leaq 0xdbe55(%rip), %rcx     # 0x5bac83
leaq 0xdbcd4(%rip), %r8      # 0x5bab09
movl $0x6b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4dee49
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x40(%rsp), %rax
jb 0x4def0d
movq 0x18(%rsp), %rax
movq (%rax), %rax
imulq $0x18, 0x10(%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq 0x38(%rsp), %rax
ja 0x4deef8
movq 0x18(%rsp), %rax
movq (%rax), %rax
imulq $0x18, 0x10(%rsp), %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
jne 0x4deef8
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x18, 0x10(%rsp), %rdx
addq %rdx, %rcx
subq 0x10(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x40(%rsp), %rax
jb 0x4deeed
movq 0x50(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x18, 0x10(%rsp), %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq 0x58(%rsp), %r8
xorl %ecx, %ecx
callq *%rax
testb $0x1, 0x37(%rsp)
jne 0x4deef6
jmp 0x4def0d
jmp 0x4deef8
jmp 0x4deefa
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x4dee53
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
shlq %rdi
leaq 0xd9943(%rip), %rsi     # 0x5baca0
movl $0x21, %edx
callq 0xe80f0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movw $0x0, (%rax)
movw $0x0, 0x1e(%rsp)
movq $0x1, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x4e148e
jmp 0x4e1398
movzwl 0x1e(%rsp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
jle 0x4e13cd
movq 0x30(%rsp), %rax
movzwl 0x1e(%rsp), %ecx
movsbl (%rax,%rcx), %eax
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x4e13d7
jmp 0x4e13f2
movq 0x20(%rsp), %rax
movzwl 0x1e(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, 0x1e(%rsp)
jmp 0x4e1398
movq 0x30(%rsp), %rax
movzwl 0x1e(%rsp), %ecx
movsbl (%rax,%rcx), %eax
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x4e1420
movw 0x1e(%rsp), %ax
addw $0x1, %ax
movw %ax, 0x1e(%rsp)
jmp 0x4e1422
movzwl 0x1e(%rsp), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jl 0x4e1466
movq 0x15ab6b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x34bd4(%rip), %rsi     # 0x516013
leaq 0xd9876(%rip), %rdx     # 0x5bacbc
leaq 0xd987e(%rip), %rcx     # 0x5baccb
leaq 0xd984c(%rip), %r8      # 0x5baca0
movl $0x28, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4e1468
movw 0x1e(%rsp), %dx
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movw %dx, (%rax,%rcx,2)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x4e1386
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-ovlfind-kmp.c
// Function: contfind_kmp
static inline bool contfind_kmp(const char *a, GtUword alen,
    const gt_kmp_t *pi, const char *b, GtUword blen)
{
  gt_kmp_t q;
  GtUword i;
  q = 0;
  gt_assert(alen < blen);
  for (i = 0; i < blen; i++)
  {
    while ((q > 0) && (a[q] != b[i]))
      q = pi[q - 1];
    if (a[q] == b[i])
      q++;
    if ((GtUword)q == alen)
      return true;
  }
  return false;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movw $0x0, 0x16(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x18(%rsp), %rax
jb 0x4e1998
movq 0x15a639(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x346a2(%rip), %rsi     # 0x516013
leaq 0xd916b(%rip), %rdx     # 0x5baae3
leaq 0xd93ec(%rip), %rcx     # 0x5bad6b
leaq 0xd931a(%rip), %r8      # 0x5baca0
movl $0x5b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4e199a
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x4e1a65
jmp 0x4e19b5
movzwl 0x16(%rsp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
jle 0x4e19ea
movq 0x38(%rsp), %rax
movzwl 0x16(%rsp), %ecx
movsbl (%rax,%rcx), %eax
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x4e19f4
jmp 0x4e1a0f
movq 0x28(%rsp), %rax
movzwl 0x16(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, 0x16(%rsp)
jmp 0x4e19b5
movq 0x38(%rsp), %rax
movzwl 0x16(%rsp), %ecx
movsbl (%rax,%rcx), %eax
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x4e1a3d
movw 0x16(%rsp), %ax
addw $0x1, %ax
movw %ax, 0x16(%rsp)
movzwl 0x16(%rsp), %eax
cmpq 0x30(%rsp), %rax
jne 0x4e1a50
movb $0x1, 0x47(%rsp)
jmp 0x4e1a6a
jmp 0x4e1a52
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x4e19a3
movb $0x0, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-ovlfind-kmp.c
// Function: spmfind_kmp
static inline void spmfind_kmp(const char *a, GtUword alen,
    const char *b, GtUword blen, const gt_kmp_t *pi,
    GtUword min_length, bool find_submaximal, bool self_comparison,
    void(*proc)(GtUword, bool, void*), bool direction,
    void* procdata)
{
  gt_kmp_t q;
  GtUword max_matchlen;
  max_matchlen = GT_MIN(alen, blen);
  if (self_comparison)
    max_matchlen -= 1;
  q = findnextmatch(a, b, alen - max_matchlen, alen - 1, pi);
  if ((GtUword)q >= min_length)
    proc((GtUword)q, direction, procdata);
  if (find_submaximal)
    while (q > 0)
    {
      q = findnextmatch(a, b, alen - q + 1, alen - 1, pi);
      if ((GtUword)q >= min_length)
        proc((GtUword)q, direction, procdata);
    }
}

// Assembly:
subq $0x58, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r10
movq 0x8(%rsp), %rsi
movq %rdi, %r11
movq 0x10(%rsp), %rdi
movq 0x80(%rsp), %rax
movb 0x78(%rsp), %al
movq 0x70(%rsp), %rcx
movb 0x68(%rsp), %cl
movb 0x60(%rsp), %dl
movq %r11, 0x50(%rsp)
movq %r10, 0x48(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
andb $0x1, %dl
movb %dl, 0x27(%rsp)
andb $0x1, %cl
movb %cl, 0x26(%rsp)
andb $0x1, %al
movb %al, 0x25(%rsp)
movq 0x48(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x4e1b00
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
jmp 0x4e1b09
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x26(%rsp)
je 0x4e1b27
movq 0x18(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
subq 0x18(%rsp), %rdx
movq 0x48(%rsp), %rcx
subq $0x1, %rcx
movq 0x30(%rsp), %r8
callq 0x4e3cd0
movw %ax, 0x22(%rsp)
movzwl 0x22(%rsp), %eax
cmpq 0x28(%rsp), %rax
jb 0x4e1b7f
movq 0x70(%rsp), %rax
movzwl 0x22(%rsp), %ecx
movl %ecx, %edi
movb 0x25(%rsp), %cl
movq 0x80(%rsp), %rdx
andb $0x1, %cl
movzbl %cl, %esi
callq *%rax
testb $0x1, 0x27(%rsp)
je 0x4e1bf5
jmp 0x4e1b88
movzwl 0x22(%rsp), %eax
cmpl $0x0, %eax
jle 0x4e1bf3
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movzwl 0x22(%rsp), %eax
subq %rax, %rdx
addq $0x1, %rdx
movq 0x48(%rsp), %rcx
subq $0x1, %rcx
movq 0x30(%rsp), %r8
callq 0x4e3cd0
movw %ax, 0x22(%rsp)
movzwl 0x22(%rsp), %eax
cmpq 0x28(%rsp), %rax
jb 0x4e1bf1
movq 0x70(%rsp), %rax
movzwl 0x22(%rsp), %ecx
movl %ecx, %edi
movb 0x25(%rsp), %cl
movq 0x80(%rsp), %rdx
andb $0x1, %cl
movzbl %cl, %esi
callq *%rax
jmp 0x4e1b88
jmp 0x4e1bf5
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0xd9168(%rip), %rax     # 0x5bad80
movq %rax, (%rsp)
movq 0xd9165(%rip), %rax     # 0x5bad88
movq %rax, 0x8(%rsp)
movl 0xd9162(%rip), %eax     # 0x5bad90
movl %eax, 0x10(%rsp)
leaq 0xd90dd(%rip), %rdi     # 0x5bad16
movl $0xa, %esi
callq 0x4e1340
movq %rax, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
cmpl $0xa, 0x28(%rsp)
jge 0x4e1cc4
jmp 0x4e1c59
cmpl $0x0, 0x2c(%rsp)
jne 0x4e1cb3
movq 0x20(%rsp), %rax
movslq 0x28(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
movslq 0x28(%rsp), %rcx
movzwl (%rsp,%rcx,2), %ecx
cmpl %ecx, %eax
je 0x4e1cb1
movq 0x30(%rsp), %rdi
leaq 0x4d973(%rip), %rsi     # 0x52f5fa
leaq 0xd9093(%rip), %rdx     # 0x5bad21
leaq 0xd90a4(%rip), %rcx     # 0x5bad39
leaq 0xd9004(%rip), %r8      # 0x5baca0
movl $0xa7, %r9d
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x2c(%rsp) # imm = 0xFFFFFFFF
jmp 0x4e1cb3
jmp 0x4e1cb5
jmp 0x4e1cb7
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x4e1c50
movq 0x20(%rsp), %rdi
leaq 0xd8fd0(%rip), %rsi     # 0x5baca0
movl $0xa8, %edx
callq 0xe88c0
movl 0x2c(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-ovlfind-kmp.c
// Function: findnextmatch
static inline gt_kmp_t findnextmatch(const char *a, const char *b,
    GtUword from, GtUword to, const gt_kmp_t *pi)
{
  gt_kmp_t q;
  GtUword i;
  q = 0;
  for (i = from; i <= to; i++)
  {
    while ((q > 0) && (a[i] != b[q]))
      q = pi[q - 1];
    if (a[i] == b[q])
      q++;
  }
  return q;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movw $0x0, -0x2a(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
cmpq -0x20(%rsp), %rax
ja 0x4e3da9
jmp 0x4e3d0c
movzwl -0x2a(%rsp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rsp)
jle 0x4e3d41
movq -0x8(%rsp), %rax
movq -0x38(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x10(%rsp), %rcx
movzwl -0x2a(%rsp), %edx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x39(%rsp)
movb -0x39(%rsp), %al
testb $0x1, %al
jne 0x4e3d4b
jmp 0x4e3d66
movq -0x28(%rsp), %rax
movzwl -0x2a(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x2a(%rsp)
jmp 0x4e3d0c
movq -0x8(%rsp), %rax
movq -0x38(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x10(%rsp), %rcx
movzwl -0x2a(%rsp), %edx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x4e3d94
movw -0x2a(%rsp), %ax
addw $0x1, %ax
movw %ax, -0x2a(%rsp)
jmp 0x4e3d96
movq -0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rsp)
jmp 0x4e3cfa
movw -0x2a(%rsp), %ax
retq
nop