LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: gt_blindtrie_delete
void gt_blindtrie_delete(GtBlindtrie *blindtrie)
{
  if (blindtrie == NULL)
  {
    return;
  }
  gt_Viatwobitkeyvalues_delete(blindtrie->vtk1);
  gt_Viatwobitkeyvalues_delete(blindtrie->vtk2);
  gt_free(blindtrie->spaceBlindtrienode);
  GT_FREEARRAY(&blindtrie->overflowsuffixes, GtUword);
  GT_FREEARRAY(&blindtrie->stack, GtBlindtriesnodeptr);
  gt_free(blindtrie);
}

// Assembly:
testq %rdi, %rdi
je 0x1953b0
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x80(%rdi), %rdi
callq 0x77477
movq 0x88(%rbx), %rdi
callq 0x77477
movq 0x8(%rbx), %rdi
leaq 0x1c0e47(%rip), %rsi    # 0x35617e
movl $0x3e6, %edx            # imm = 0x3E6
callq 0x936f9
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x19536b
leaq 0x28(%rbx), %r14
leaq 0x1c0e29(%rip), %rsi    # 0x35617e
movl $0x3e7, %edx            # imm = 0x3E7
callq 0x936f9
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x195395
leaq 0x10(%rbx), %r14
leaq 0x1c0dff(%rip), %rsi    # 0x35617e
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x936f9
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq 0x1c0de2(%rip), %rsi    # 0x35617e
movq %rbx, %rdi
movl $0x3e9, %edx            # imm = 0x3E9
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_makeroot
static void blindtrie_makeroot(GtBlindtrie *blindtrie,
                               GtUword currentstartpos,
                               GtUword currenttwobitencodingstoppos)
{
  GtBlindtriesymbol firstchar;

  gt_assert(blindtrie->nextfreeBlindtrienode == GT_BLINDTRIE_ROOTIDX);
  (void) blindtrie_newnode(blindtrie);
  blindtrie_firstchar_set(blindtrie,GT_BLINDTRIE_ROOTIDX,
                          false,0); /* firstchar of root will never be used */
  blindtrie_setdepth(blindtrie,GT_BLINDTRIE_ROOTIDX,0);
  /*blindtrie_rightsibling_set(blindtrie,root,GT_BLINDTRIE_REFNULL); */
  if (blindtrie_isleftofboundary(blindtrie,currentstartpos,0))
  {
    /* Random access */
    firstchar = (GtBlindtriesymbol)
                gt_encseq_get_encoded_char(blindtrie->encseq,
                                           currentstartpos,
                                           blindtrie->readmode);
    if (GT_BLINDTRIECHAR_GT_ISSPECIAL(firstchar))
    {
      firstchar = GT_UNIQUEINT(currentstartpos);
    }
    if (currenttwobitencodingstoppos == ULONG_MAX)
    {
      currenttwobitencodingstoppos
        = blindtrie_currenttwobitencodingstoppos_get(blindtrie,currentstartpos);
    }
  } else
  {
    firstchar = GT_UNIQUEINT(currentstartpos);
    currenttwobitencodingstoppos = GT_BLTRIESTOPPOSUNDEF(blindtrie);
  }
  blindtrie_firstchild_set(blindtrie,GT_BLINDTRIE_ROOTIDX,
                           blindtrie_newleaf(blindtrie,currentstartpos,
                                             currenttwobitencodingstoppos,
                                             firstchar,GT_BLINDTRIE_REFNULL));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x4(%rdi)
jne 0x195cde
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x196ab4
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x196b5e
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x196bd5
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x195c69
addq %r14, %rax
movq 0x60(%rbx), %rdx
cmpq %rdx, %rax
cmovaeq %rdx, %rax
jmp 0x195c70
movq 0x60(%rbx), %rdx
movq %rdx, %rax
cmpq %r14, %rax
jbe 0x195c9f
movq 0x40(%rbx), %rdi
movl 0x58(%rbx), %edx
movq %r14, %rsi
callq 0x705e4
movzbl %al, %eax
leaq 0x100(%r14), %r12
cmpb $-0x2, %al
cmovbq %rax, %r12
cmpq $-0x1, %r15
je 0x195ca8
movq %r15, %rdx
jmp 0x195cb6
leaq 0x100(%r14), %r12
jmp 0x195cb6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x195d16
movq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x196c95
movq %rbx, %rdi
xorl %esi, %esi
movl %eax, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x196c36
movq 0x2a2283(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x14f324(%rip), %rsi    # 0x2e5013
leaq 0x1c0730(%rip), %rdx    # 0x356426
leaq 0x1c0762(%rip), %rcx    # 0x35645f
leaq 0x1c047a(%rip), %r8     # 0x35617e
movl $0x176, %r9d            # imm = 0x176
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_currenttwobitencodingstoppos_get
static GtUword blindtrie_currenttwobitencodingstoppos_get(
                                     const GtBlindtrie *blindtrie,
                                     GtUword currentstartpos)
{
  if (!blindtrie->cmpcharbychar &&
      blindtrie->has_twobitencoding_stoppos_support)
  {
    gt_encseq_reader_reinit_with_readmode(blindtrie->esr1,blindtrie->encseq,
                                          blindtrie->readmode,
                                          currentstartpos);
    return gt_getnexttwobitencodingstoppos(GT_ISDIRREVERSE(blindtrie->readmode)
                                           ? false : true,blindtrie->esr1);
  }
  return GT_BLTRIESTOPPOSUNDEF(blindtrie);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x78(%rdi)
jne 0x195d52
cmpb $0x1, 0x7a(%rbx)
jne 0x195d52
movq %rsi, %rcx
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %rdi
movl 0x58(%rbx), %edx
callq 0x71f38
movl 0x58(%rbx), %eax
andl $-0x3, %eax
xorl %edi, %edi
cmpl $0x1, %eax
setne %dil
movq 0x48(%rbx), %rsi
popq %rbx
jmp 0x7669f
movq 0x60(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_findsplitnode
static GtBlindtriesnodeptr blindtrie_findsplitnode(const GtBlindtrie *blindtrie,
                                                GtUword lcp)
{
  GtBlindtriesnodeptr currentnode;
  GtUword stackidx;

  currentnode = GT_BLINDTRIE_ROOTIDX;
  for (stackidx=0;stackidx<blindtrie->stack.nextfreeGtBlindtriesnodeptr;
       stackidx++)
  {
    currentnode = blindtrie->stack.spaceGtBlindtriesnodeptr[stackidx];
    if (blindtrie_isleaf(blindtrie,currentnode) ||
        blindtrie_getdepth(blindtrie,currentnode) >= lcp)
    {
      break;
    }
  }
  return currentnode;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
xorl %r12d, %r12d
cmpq 0x20(%r15), %r12
jae 0x1964cc
movq 0x10(%r15), %rax
movl (%rax,%r12,4), %ebx
movq %r15, %rdi
movl %ebx, %esi
callq 0x195fa6
testb %al, %al
jne 0x1964cc
movq %r15, %rdi
movl %ebx, %esi
callq 0x196880
incq %r12
cmpq %r14, %rax
jb 0x19649e
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_newnode
static GtBlindtriesnodeptr blindtrie_newnode(GtBlindtrie *blindtrie)
{
  if (blindtrie->nextfreeBlindtrienode >= blindtrie->allocatedBlindtrienode)
  {
    gt_assert(blindtrie->nodenumberincrement >= 1U);
    gt_assert(blindtrie->allocatedBlindtrienode +
              blindtrie->nodenumberincrement <=
              (1U << GT_BLINDTRIE_BITSFORRIGHTSIBLING) - 1);
    blindtrie->allocatedBlindtrienode += blindtrie->nodenumberincrement;
    blindtrie->spaceBlindtrienode
      = gt_realloc(blindtrie->spaceBlindtrienode,
                   sizeof (*blindtrie->spaceBlindtrienode) *
                          blindtrie->allocatedBlindtrienode);
  }
  return blindtrie->nextfreeBlindtrienode++;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %ecx
movl 0x4(%rdi), %eax
cmpl %ecx, %eax
jb 0x196af0
movl 0x7c(%rbx), %eax
testl %eax, %eax
je 0x196af8
addl %ecx, %eax
js 0x196b26
movl %eax, (%rbx)
movq 0x8(%rbx), %rdi
movl %eax, %eax
imulq $0x18, %rax, %rsi
leaq 0x1bf69f(%rip), %rdx    # 0x35617e
movl $0x148, %ecx            # imm = 0x148
callq 0x93472
movq %rax, 0x8(%rbx)
movl 0x4(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rbx)
popq %rbx
retq
movq 0x2a1469(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x14e50a(%rip), %rsi    # 0x2e5013
leaq 0x1bf962(%rip), %rdx    # 0x356472
leaq 0x1bf980(%rip), %rcx    # 0x356497
leaq 0x1bf660(%rip), %r8     # 0x35617e
movl $0x140, %r9d            # imm = 0x140
jmp 0x196b52
movq 0x2a143b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x14e4dc(%rip), %rsi    # 0x2e5013
leaq 0x1bf96b(%rip), %rdx    # 0x3564a9
leaq 0x1bf952(%rip), %rcx    # 0x356497
leaq 0x1bf632(%rip), %r8     # 0x35617e
movl $0x143, %r9d            # imm = 0x143
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_extractleafnode
static GtBlindtriesnodeptr blindtrie_extractleafnode(GtBlindtrie *blindtrie,
                                                     GtBlindtriesnodeptr head)
{
  gt_assert(!blindtrie_isleaf(blindtrie,head));
  do
  {
    head = blindtrie_firstchild_get(blindtrie,head);
  } while (!blindtrie_isleaf(blindtrie,head));
  return head;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x195fa6
testb %al, %al
jne 0x196f48
movq %rbx, %rdi
movl %ebp, %esi
callq 0x196820
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x195fa6
testb %al, %al
je 0x196f25
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x2a1019(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x14e0ba(%rip), %rsi    # 0x2e5013
leaq 0x1bf74c(%rip), %rdx    # 0x3566ac
leaq 0x1bf767(%rip), %rcx    # 0x3566ce
leaq 0x1bf210(%rip), %r8     # 0x35617e
movl $0x19a, %r9d            # imm = 0x19A
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-copysort.c
// Function: resetsorted
static void resetsorted(GtBucketspec2 *bucketspec2)
{
  unsigned int idx, idx2;

  for (idx = 0; idx<bucketspec2->numofchars; idx++)
  {
    bucketspec2->superbuckettab[idx].sorted = false;
    for (idx2 = 0; idx2<bucketspec2->numofchars; idx2++)
    {
      GtUword startidx = getstartidx(bucketspec2,idx,idx2),
             endidx = getendidx(bucketspec2,idx,idx2);
      bucketspec2->subbuckettab[idx][idx2].sorted =
        (startidx < endidx) ? false : true;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x14(%rdi), %eax
xorl %r14d, %r14d
pushq $0x1
popq %r13
movl %eax, %ecx
cmpq %rcx, %r14
jae 0x197720
movq 0x38(%rbx), %rcx
movq %r14, %rdx
shlq $0x4, %rdx
movb $0x0, 0x1(%rcx,%rdx)
movq %r13, %rbp
xorl %r15d, %r15d
movl %eax, %ecx
cmpq %rcx, %r15
jae 0x19771b
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x197d9a
movq %rax, %r12
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x197cff
cmpq %rax, %r12
movq 0x40(%rbx), %rax
movq (%rax,%r14,8), %rax
setae (%rax,%rbp)
incq %r15
movl 0x14(%rbx), %eax
addq $0x10, %rbp
jmp 0x1976da
incq %r14
jmp 0x1976bd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-copysort.c
// Function: getendidx
static GtUword getendidx(const GtBucketspec2 *bucketspec2,
                        unsigned int first,
                        unsigned int second)
{
  gt_assert(first < bucketspec2->numofchars);
  gt_assert(second <= bucketspec2->numofchars);
  if (second < bucketspec2->numofchars)
  {
    return bucketspec2->subbuckettab[first][second].bucketend;
  }
  return bucketspec2->superbuckettab[first].bucketend;
}

// Assembly:
pushq %rax
movl 0x14(%rdi), %eax
cmpl %esi, %eax
jbe 0x197d3a
cmpl %edx, %eax
jb 0x197d64
movl %esi, %eax
jbe 0x197d26
movq 0x40(%rdi), %rcx
movq (%rcx,%rax,8), %rax
movl %edx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
addq $0x8, %rax
jmp 0x197d35
movq 0x38(%rdi), %rcx
shlq $0x4, %rax
addq %rcx, %rax
addq $0x8, %rax
movq (%rax), %rax
popq %rcx
retq
movq 0x2a0227(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x14d2c8(%rip), %rsi    # 0x2e5013
leaq 0x1bef31(%rip), %rdx    # 0x356c83
leaq 0x1bef4a(%rip), %rcx    # 0x356ca3
leaq 0x1becb1(%rip), %r8     # 0x356a11
pushq $0x5d
jmp 0x197d8c
movq 0x2a01fd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x14d29e(%rip), %rsi    # 0x2e5013
leaq 0x1bef31(%rip), %rdx    # 0x356cad
leaq 0x1bef20(%rip), %rcx    # 0x356ca3
leaq 0x1bec87(%rip), %r8     # 0x356a11
pushq $0x5e
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-copysort.c
// Function: getstartidx
static GtUword getstartidx(const GtBucketspec2 *bucketspec2,
                                 unsigned int first,
                                 unsigned int second)
{
  gt_assert(first < bucketspec2->numofchars);
  gt_assert(second <= bucketspec2->numofchars);
  if (second > 0)
  {
    return bucketspec2->subbuckettab[first][second-1].bucketend;
  }
  if (first > 0)
  {
    return bucketspec2->superbuckettab[first-1].bucketend;
  }
  return 0;
}

// Assembly:
pushq %rax
movl 0x14(%rdi), %eax
cmpl %esi, %eax
jbe 0x197dd7
cmpl %edx, %eax
jb 0x197e01
testl %edx, %edx
je 0x197db6
movl %esi, %eax
shlq $0x3, %rax
addq 0x40(%rdi), %rax
jmp 0x197dc3
testl %esi, %esi
je 0x197dd3
addq $0x38, %rdi
movq %rdi, %rax
movl %esi, %edx
movq (%rax), %rax
decl %edx
shlq $0x4, %rdx
movq 0x8(%rax,%rdx), %rax
popq %rcx
retq
xorl %eax, %eax
jmp 0x197dd1
movq 0x2a018a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x14d22b(%rip), %rsi    # 0x2e5013
leaq 0x1bee94(%rip), %rdx    # 0x356c83
leaq 0x1beed9(%rip), %rcx    # 0x356ccf
leaq 0x1bec14(%rip), %r8     # 0x356a11
pushq $0x4c
jmp 0x197e29
movq 0x2a0160(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x14d201(%rip), %rsi    # 0x2e5013
leaq 0x1bee94(%rip), %rdx    # 0x356cad
leaq 0x1beeaf(%rip), %rcx    # 0x356ccf
leaq 0x1bebea(%rip), %r8     # 0x356a11
pushq $0x4d
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-copysort.c
// Function: gt_copysort_delete
void gt_copysort_delete(GtBucketspec2 *bucketspec2)
{
  gt_assert(bucketspec2 != NULL);
  gt_array2dim_delete(bucketspec2->subbuckettab);
  gt_free(bucketspec2->superbuckettab);
  gt_free(bucketspec2->order);
  gt_free(bucketspec2);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x197ea8
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq (%rax), %rdi
leaq 0x1bebc0(%rip), %r14    # 0x356a11
movq %r14, %rsi
movl $0x217, %edx            # imm = 0x217
callq 0x936f9
movq 0x40(%rbx), %rdi
movq %r14, %rsi
movl $0x217, %edx            # imm = 0x217
callq 0x936f9
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x218, %edx            # imm = 0x218
callq 0x936f9
movq 0x20(%rbx), %rdi
movq %r14, %rsi
movl $0x219, %edx            # imm = 0x219
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x21a, %edx            # imm = 0x21A
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
movq 0x2a00b9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x14d15a(%rip), %rsi    # 0x2e5013
leaq 0x1bec20(%rip), %rdx    # 0x356ae0
leaq 0x1bec2d(%rip), %rcx    # 0x356af4
leaq 0x1beb43(%rip), %r8     # 0x356a11
movl $0x216, %r9d            # imm = 0x216
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-copysort.c
// Function: superbucketsize
static GtUword superbucketsize(const GtBucketspec2 *bucketspec2,
                                     unsigned int bucketnum)
{
  if (bucketnum == 0)
  {
    return bucketspec2->superbuckettab[0].bucketend;
  }
  return bucketspec2->superbuckettab[bucketnum].bucketend -
         bucketspec2->superbuckettab[bucketnum-1].bucketend;
}

// Assembly:
movq 0x38(%rdi), %rcx
testl %esi, %esi
je 0x197eff
movl %esi, %eax
shlq $0x4, %rax
movq 0x8(%rcx,%rax), %rax
decl %esi
shlq $0x4, %rsi
subq 0x8(%rcx,%rsi), %rax
retq
movq 0x8(%rcx), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: gt_differencecover_delete
void gt_differencecover_delete(GtDifferencecover *dcov)
{
  if (dcov != NULL)
  {
    gt_assert(dcov->bcktab == NULL);
    gt_assert(dcov->sortedsample == NULL);
    gt_assert(dcov->filltable == NULL);
    gt_assert(dcov->multimappower == NULL);
    gt_free(dcov->coverrank_evaluated);
    dcov->coverrank_evaluated = NULL;
    gt_free(dcov->coverrank_bits);
    dcov->coverrank_bits = NULL;
    gt_free(dcov->diff2pos);
    dcov->diff2pos = NULL;
    gt_free(dcov->inversesuftab);
    dcov->inversesuftab = NULL;
    gt_rmq_delete(dcov->rmq);
    dcov->rmq = NULL;
    gt_free(dcov);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x198328
movq %rdi, %rbx
cmpq $0x0, 0x58(%rdi)
jne 0x198330
cmpq $0x0, 0x148(%rbx)
jne 0x198361
cmpq $0x0, 0x90(%rbx)
jne 0x19838f
cmpq $0x0, 0x88(%rbx)
jne 0x1983bd
movq 0x20(%rbx), %rdi
leaq 0x1beaed(%rip), %r14    # 0x356d90
movq %r14, %rsi
movl $0x213, %edx            # imm = 0x213
callq 0x936f9
andq $0x0, 0x20(%rbx)
movq 0x28(%rbx), %rdi
movq %r14, %rsi
movl $0x215, %edx            # imm = 0x215
callq 0x936f9
andq $0x0, 0x28(%rbx)
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x217, %edx            # imm = 0x217
callq 0x936f9
andq $0x0, 0x38(%rbx)
movq 0x98(%rbx), %rdi
movq %r14, %rsi
movl $0x219, %edx            # imm = 0x219
callq 0x936f9
andq $0x0, 0x98(%rbx)
movq 0x150(%rbx), %rdi
callq 0x112589
andq $0x0, 0x150(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x21d, %edx            # imm = 0x21D
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x29fc31(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x14ccd2(%rip), %rsi    # 0x2e5013
leaq 0x1beab7(%rip), %rdx    # 0x356dff
leaq 0x1beac5(%rip), %rcx    # 0x356e14
leaq 0x1bea3a(%rip), %r8     # 0x356d90
movl $0x20f, %r9d            # imm = 0x20F
jmp 0x1983e9
movq 0x29fc00(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x14cca1(%rip), %rsi    # 0x2e5013
leaq 0x1beab5(%rip), %rdx    # 0x356e2e
leaq 0x1bea94(%rip), %rcx    # 0x356e14
leaq 0x1bea09(%rip), %r8     # 0x356d90
movl $0x210, %r9d            # imm = 0x210
jmp 0x1983e9
movq 0x29fbd2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x14cc73(%rip), %rsi    # 0x2e5013
leaq 0x1beaa2(%rip), %rdx    # 0x356e49
leaq 0x1bea66(%rip), %rcx    # 0x356e14
leaq 0x1be9db(%rip), %r8     # 0x356d90
movl $0x211, %r9d            # imm = 0x211
jmp 0x1983e9
movq 0x29fba4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x14cc45(%rip), %rsi    # 0x2e5013
leaq 0x1bea8c(%rip), %rdx    # 0x356e61
leaq 0x1bea38(%rip), %rcx    # 0x356e14
leaq 0x1be9ad(%rip), %r8     # 0x356d90
movl $0x212, %r9d            # imm = 0x212
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: gt_inl_dc_queue_new
static GtInlDCQueue *gt_inl_dc_queue_new(GtUword queuesize)
{
  GtInlDCQueue *q;

  q = gt_malloc(sizeof (*q));
  gt_assert(queuesize > 0);
  q->queuespace = gt_malloc(sizeof (*q->queuespace) * queuesize);
  q->noofelements = 0;
  q->queuesize = queuesize;
  q->dequeueindex = q->enqueueindex = queuesize - 1;
  return q;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1bbe13(%rip), %r14    # 0x356d90
pushq $0x28
popq %rdi
movq %r14, %rsi
movl $0x83, %edx
callq 0x93160
movq %rax, %r15
movq %rbx, %rdi
shlq $0x4, %rdi
movq %r14, %rsi
movl $0x85, %edx
callq 0x93160
movq %rax, (%r15)
andq $0x0, 0x20(%r15)
movq %rbx, 0x18(%r15)
decq %rbx
movq %rbx, 0x8(%r15)
movq %rbx, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_compareCodeatposition
static int dc_compareCodeatposition(const void *vala,const void *valb)
{
  const Codeatposition *a = (const Codeatposition *) vala;
  const Codeatposition *b = (const Codeatposition *) valb;

  if (a->maxprefixindex < b->maxprefixindex)
  {
    return -1;
  }
  if (a->maxprefixindex > b->maxprefixindex)
  {
    return 1;
  }
  if (a->position < b->position)
  {
    return 1;
  }
  if (a->position > b->position)
  {
    return -1;
  }
  gt_assert(false);
  return 0;
}

// Assembly:
movl (%rdi), %eax
andl $0xf, %eax
movl (%rsi), %edx
andl $0xf, %edx
pushq $-0x1
popq %rcx
cmpl %edx, %eax
jae 0x19afd8
movl %ecx, %eax
retq
pushq $0x1
popq %rax
ja 0x19afeb
movq 0x8(%rsi), %rdx
cmpq %rdx, 0x8(%rdi)
jb 0x19afeb
movl %ecx, %eax
jbe 0x19afec
retq
pushq %rax
movq 0x29cf74(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x14a015(%rip), %rsi    # 0x2e5013
leaq 0x18b9e7(%rip), %rdx    # 0x3269ec
leaq 0x1bc3ee(%rip), %rcx    # 0x3573fa
leaq 0x1bbd7d(%rip), %r8     # 0x356d90
movl $0x28b, %r9d            # imm = 0x28B
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/bcktab.h
// Function: gt_bcktab_leftborder_insertionindex
static inline GtUword gt_bcktab_leftborder_insertionindex(
                                                  GtLeftborder *lb,
                                                  GtCodetype code)
{
  gt_assert(lb != NULL);
  if (lb->ulongbounds != NULL)
  {
    return --lb->ulongbounds[code];
  }
  gt_assert(lb->uintbounds != NULL);
  return (GtUword) --lb->uintbounds[code];
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x19b053
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x19b041
movq (%rcx,%rsi,8), %rax
decq %rax
movq %rax, (%rcx,%rsi,8)
jmp 0x19b051
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x19b07d
movl (%rcx,%rsi,4), %eax
decl %eax
movl %eax, (%rcx,%rsi,4)
popq %rcx
retq
movq 0x29cf0e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x149faf(%rip), %rsi    # 0x2e5013
leaq 0x1a35f4(%rip), %rdx    # 0x33e65f
leaq 0x1bc51e(%rip), %rcx    # 0x357590
leaq 0x1bc343(%rip), %r8     # 0x3573bc
pushq $0x45
jmp 0x19b0a5
movq 0x29cee4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x149f85(%rip), %rsi    # 0x2e5013
leaq 0x1a3604(%rip), %rdx    # 0x33e699
leaq 0x1bc4f4(%rip), %rcx    # 0x357590
leaq 0x1bc319(%rip), %r8     # 0x3573bc
pushq $0x4a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_addunsortedrange
static void dc_addunsortedrange(void *voiddcov,
                                GT_UNUSED GtSuffixsortspace *sssp,
                                GtUword blisbl,
                                GtUword width,
                                GT_UNUSED GtUword depth)
{
  GtDifferencecover *dcov = (GtDifferencecover *) voiddcov;
  GtDcPairsuffixptr *ptr;

  gt_assert(depth >= (GtUword) dcov->vparam);
  dc_updatewidth (dcov,width,dcov->vparam);
  GT_GETNEXTFREEINARRAY(ptr,&dcov->firstgeneration,GtDcPairsuffixptr,1024);
  ptr->blisbl = blisbl;
  ptr->width = width;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movl (%rdi), %edx
cmpq %r8, %rdx
ja 0x19b5e3
movq %rcx, %rbx
movq %rdi, %r15
movq %rcx, %rsi
callq 0x19ba78
movq 0x118(%r15), %rsi
cmpq %rsi, 0x120(%r15)
jae 0x19b588
movq 0x110(%r15), %rax
jmp 0x19b5b9
addq $0x400, %rsi            # imm = 0x400
movq %rsi, 0x118(%r15)
movq 0x110(%r15), %rdi
shlq $0x4, %rsi
leaq 0x1bb7e8(%rip), %rdx    # 0x356d90
movl $0x45e, %ecx            # imm = 0x45E
callq 0x93472
movq %rax, 0x110(%r15)
testq %rax, %rax
je 0x19b611
movq 0x120(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x120(%r15)
shlq $0x4, %rcx
movq %r14, (%rax,%rcx)
movq %rbx, 0x8(%rax,%rcx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x29c97e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x149a1f(%rip), %rsi    # 0x2e5013
leaq 0x1bc2ef(%rip), %rdx    # 0x3578ea
leaq 0x1bc308(%rip), %rcx    # 0x35790a
leaq 0x1bb787(%rip), %r8     # 0x356d90
movl $0x45c, %r9d            # imm = 0x45C
jmp 0x19b63d
movq 0x29c950(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1499f1(%rip), %rsi    # 0x2e5013
leaq 0x1bc2f5(%rip), %rdx    # 0x35791e
leaq 0x1bc2da(%rip), %rcx    # 0x35790a
leaq 0x1bb759(%rip), %r8     # 0x356d90
movl $0x45e, %r9d            # imm = 0x45E
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_filldiff2pos
static void dc_filldiff2pos(GtDifferencecover *dcov)
{
  Diffvalue *iptr, *jptr;

  gt_assert(dcov->diff2pos == NULL);
  dcov->diff2pos = gt_malloc(sizeof (*dcov->diff2pos) * dcov->vparam);
  dcov->requiredspace += sizeof (*dcov->diff2pos) * dcov->vparam;
  for (iptr=dcov->diffvalues + dcov->size - 1; iptr>=dcov->diffvalues; iptr--)
  {
    for (jptr=dcov->diffvalues; jptr<dcov->diffvalues + dcov->size; jptr++)
    {
      dcov->diff2pos[GT_MODV(*jptr - *iptr)] = *iptr;
    }
  }
}

// Assembly:
pushq %rbx
cmpq $0x0, 0x38(%rdi)
jne 0x19b94d
movq %rdi, %rbx
movl (%rdi), %edi
addq %rdi, %rdi
leaq 0x1bb495(%rip), %rsi    # 0x356d90
movl $0x169, %edx            # imm = 0x169
callq 0x93160
movq %rax, 0x38(%rbx)
movl (%rbx), %ecx
movl 0x8(%rbx), %edx
addq %rcx, %rcx
addq %rcx, 0x40(%rbx)
movq 0x30(%rbx), %rcx
leaq (%rcx,%rdx,2), %rdx
movq %rdx, %rsi
addq $-0x2, %rsi
cmpq %rcx, %rsi
jb 0x19b94b
movq %rcx, %rdi
cmpq %rdx, %rdi
jae 0x19b920
movzwl (%rsi), %r8d
movzwl (%rdi), %r9d
subl %r8d, %r9d
andl 0xc(%rbx), %r9d
movw %r8w, (%rax,%r9,2)
addq $0x2, %rdi
jmp 0x19b92c
popq %rbx
retq
movq 0x29c614(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1496b5(%rip), %rsi    # 0x2e5013
leaq 0x1bc0c0(%rip), %rdx    # 0x357a25
leaq 0x1bc0d0(%rip), %rcx    # 0x357a3c
leaq 0x1bb41d(%rip), %r8     # 0x356d90
movl $0x168, %r9d            # imm = 0x168
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_updatewidth
static void dc_updatewidth (GtDifferencecover *dcov,GtUword width,
                            unsigned int depth)
{
  if (width > 1UL)
  {
    gt_assert(dcov != NULL);
    dcov->firstgenerationtotalwidth += width;
    dcov->firstgenerationcount++;
    if (dcov->allocateditvinfo < width)
    {
      dcov->allocateditvinfo = width;
    }
    if (dcov->currentdepth == 0)
    {
      dcov->currentdepth = (GtUword) depth;
    } else
    {
      gt_assert(dcov->currentdepth == (GtUword) depth);
    }
  }
}

// Assembly:
pushq %rax
cmpq $0x2, %rsi
jb 0x19bafe
testq %rdi, %rdi
je 0x19bb00
movdqu 0x130(%rdi), %xmm0
movq %rsi, %xmm1
shufpd $0x2, 0x1b6b86(%rip), %xmm1 # xmm1 = xmm1[0],mem[1]
paddq %xmm0, %xmm1
movdqu %xmm1, 0x130(%rdi)
cmpq %rsi, 0xa0(%rdi)
jae 0x19bab6
movq %rsi, 0xa0(%rdi)
movq 0xb8(%rdi), %rax
movl %edx, %ecx
testq %rax, %rax
je 0x19baf7
cmpq %rcx, %rax
je 0x19bafe
movq 0x29c498(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x149539(%rip), %rsi    # 0x2e5013
leaq 0x1bbc0a(%rip), %rdx    # 0x3576eb
leaq 0x1bbbf4(%rip), %rcx    # 0x3576dc
leaq 0x1bb2a1(%rip), %r8     # 0x356d90
movl $0x343, %r9d            # imm = 0x343
jmp 0x19bb2c
movq %rcx, 0xb8(%rdi)
popq %rax
retq
movq 0x29c461(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x149502(%rip), %rsi    # 0x2e5013
leaq 0x1bb2be(%rip), %rdx    # 0x356dd6
leaq 0x1bbbbd(%rip), %rcx    # 0x3576dc
leaq 0x1bb26a(%rip), %r8     # 0x356d90
movl $0x337, %r9d            # imm = 0x337
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_qsortcmparr
static int QSORTNAME(qsortcmparr) (GtUword a,
                                   GtUword b,
                                   const GtDifferencecover *dcov,
                                   GtLcptrace *lcptrace,
                                   GtUword subbucketleft,
                                   const QSORTNAME(Datatype) sssp)
{
  GtUword suffixpos1, suffixpos2;

  gt_assert(sssp != NULL);
  suffixpos1 = dc_ARRAY_GET(sssp,a);
  suffixpos2 = dc_ARRAY_GET(sssp,b);
  return gt_differencecover_compare (dcov, lcptrace, suffixpos1, suffixpos2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %rdx
movq %r9, %rdi
movq %r8, %rsi
callq 0x1af8b2
movq %rax, %r12
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1af8b2
movq %rax, %r15
movq 0x48(%r14), %rax
cmpq %r12, %rax
jbe 0x19c2d7
cmpq %r15, %rax
jbe 0x19c2d7
movq 0x38(%r14), %rax
movl %r15d, %ecx
subl %r12d, %ecx
movl 0xc(%r14), %edx
andl %edx, %ecx
movzwl (%rax,%rcx,2), %esi
subl %r12d, %esi
andl %edx, %esi
movl %esi, (%rbx)
addq %r12, %rsi
movq %r14, %rdi
callq 0x19a078
movq %rax, 0x8(%rbx)
movl (%rbx), %esi
addq %r15, %rsi
movq %r14, %rdi
callq 0x19a078
movq %rax, 0x10(%rbx)
movq 0x8(%rbx), %rdx
cmpq %rax, %rdx
je 0x19c305
xorl %ecx, %ecx
cmpq %rax, %rdx
sbbl %ecx, %ecx
orl $0x1, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x29bc8a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x148d2b(%rip), %rsi    # 0x2e5013
leaq 0x1bb89a(%rip), %rdx    # 0x357b89
leaq 0x1bb8d4(%rip), %rcx    # 0x357bca
leaq 0x1baa93(%rip), %r8     # 0x356d90
movl $0x778, %r9d            # imm = 0x778
jmp 0x19c331
movq 0x29bc5c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x148cfd(%rip), %rsi    # 0x2e5013
leaq 0x1bb8c8(%rip), %rdx    # 0x357be5
leaq 0x1bb8a6(%rip), %rcx    # 0x357bca
leaq 0x1baa65(%rip), %r8     # 0x356d90
movl $0x77c, %r9d            # imm = 0x77C
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: gt_differencecover_eval_lcp
static GtUword gt_differencecover_eval_lcp(const GtLcptrace *lcptrace,
                                           const GtDifferencecover *dcov)
{
  if (lcptrace->idx1 < dcov->effectivesamplesize &&
      lcptrace->idx2 < dcov->effectivesamplesize)
  {
    gt_assert(dcov->rmq != NULL);
    return (GtUword)
            gt_rmq_find_min_value(dcov->rmq,
                                  GT_MIN(lcptrace->idx1,lcptrace->idx2)+1,
                                  GT_MAX(lcptrace->idx1,lcptrace->idx2))
             + lcptrace->offset;
  }
  return (GtUword) lcptrace->offset;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x78(%rsi), %rcx
cmpq %rcx, %rax
jae 0x19c382
movq 0x10(%rbx), %rdx
cmpq %rcx, %rdx
jae 0x19c382
movq 0x150(%rsi), %rdi
testq %rdi, %rdi
je 0x19c386
cmpq %rdx, %rax
movq %rdx, %rsi
cmovbq %rax, %rsi
cmovaq %rax, %rdx
incq %rsi
callq 0x111f7d
movl %eax, %ecx
movl (%rbx), %eax
addq %rcx, %rax
jmp 0x19c384
movl (%rbx), %eax
popq %rbx
retq
movq 0x29bbdb(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x148c7c(%rip), %rsi    # 0x2e5013
leaq 0x1bac7a(%rip), %rdx    # 0x357018
leaq 0x1bb861(%rip), %rcx    # 0x357c06
leaq 0x1ba9e4(%rip), %r8     # 0x356d90
movl $0x768, %r9d            # imm = 0x768
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_gt_inlined_qsort_arr_r_med3
static inline GtUword QSORTNAME(gt_inlined_qsort_arr_r_med3)
                     (GtUword a, GtUword b, GtUword c,
                      const GtDifferencecover *dcov,
                      GtLcptrace *lcptrace,
                      GtUword subbucketleft,
                      const QSORTNAME(Datatype) data)
{
  return
    QSORTNAME(qsortcmparr) (a, b, dcov, lcptrace, subbucketleft, data) < 0
      ? (QSORTNAME(qsortcmparr) (b, c, dcov, lcptrace,
                                 subbucketleft, data) < 0
        ? b
        : (QSORTNAME(qsortcmparr) (a, c, dcov, lcptrace,
                                   subbucketleft, data) < 0
          ? c : a))
          : (QSORTNAME(qsortcmparr) (b, c, dcov, lcptrace,
                                     subbucketleft, data) > 0
            ? b
            : (QSORTNAME(qsortcmparr) (a, c, dcov, lcptrace,
                                       subbucketleft, data) < 0
              ? a
              : c));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %r14
movq 0x50(%rsp), %r9
movq %rdi, 0x8(%rsp)
movq %rcx, %rdx
movq %r8, %rcx
movq %r15, %r8
callq 0x19c22e
movl %eax, %ebx
movq %r14, %rdi
movq %r13, 0x10(%rsp)
movq %r13, %rsi
movq 0x50(%rsp), %r13
movq %rbp, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r13, %r9
callq 0x19c22e
testl %ebx, %ebx
js 0x19c430
testl %eax, %eax
jg 0x19c45b
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq 0x10(%rsp), %r14
movq %r14, %rsi
jmp 0x19c444
testl %eax, %eax
js 0x19c45b
movq 0x8(%rsp), %r14
movq %r14, %rdi
movq 0x10(%rsp), %rbx
movq %rbx, %rsi
movq %rbp, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r13, %r9
callq 0x19c22e
testl %eax, %eax
cmovsq %rbx, %r14
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-enumcodes.c
// Function: gt_Enumcodeatposition_new
Enumcodeatposition *gt_Enumcodeatposition_new(const GtEncseq *encseq,
                                              GtReadmode readmode,
                                              unsigned int prefixlength,
                                              unsigned int numofchars)
{
  Enumcodeatposition *ecp;

  ecp = gt_malloc(sizeof *ecp);
  ecp->encseq = encseq;
  ecp->readmode = readmode;
  ecp->multimappower = gt_initmultimappower(numofchars,prefixlength);
  ecp->filltable = gt_initfilltable(numofchars,prefixlength);
  ecp->prefixlength = prefixlength;
  ecp->moveforward = GT_ISDIRREVERSE(readmode) ? true : false;
  ecp->totallength = gt_encseq_total_length(encseq);
  if (ecp->moveforward)
  {
    ecp->previousrange.start = ecp->previousrange.end = 0;
  } else
  {
    ecp->previousrange.start = ecp->previousrange.end = ecp->totallength;
  }
  ecp->exhausted = false;
  if (gt_encseq_has_specialranges(encseq))
  {
    ecp->sri = gt_specialrangeiterator_new(encseq,ecp->moveforward);
  } else
  {
    ecp->sri = NULL;
  }
  return ecp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r15d
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r14
leaq 0x1bb798(%rip), %rsi    # 0x357c22
pushq $0x50
popq %rdi
pushq $0x2e
popq %rdx
callq 0x93160
movq %rax, %rbx
movq %r14, 0x30(%rax)
movl %ebp, 0x38(%rax)
movl %r15d, %edi
movl %r12d, %esi
callq 0x164b59
movq %rax, 0x40(%rbx)
movl %r15d, %edi
movl %r12d, %esi
callq 0x164aec
movq %rax, 0x48(%rbx)
movl %r12d, 0x3c(%rbx)
andl $-0x3, %ebp
cmpl $0x1, %ebp
sete 0x18(%rbx)
movq %r14, %rdi
callq 0x7055e
movq %rax, 0x20(%rbx)
xorl %r15d, %r15d
cmpb $0x0, 0x18(%rbx)
cmovneq %r15, %rax
movq %rax, 0x8(%rbx)
movq %rax, (%rbx)
movb $0x0, 0x28(%rbx)
movq %r14, %rdi
callq 0x740a6
testb %al, %al
je 0x19c508
movzbl 0x18(%rbx), %esi
movq %r14, %rdi
callq 0x741f0
movq %rax, %r15
movq %r15, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-enumcodes.c
// Function: gt_Enumcodeatposition_next
bool gt_Enumcodeatposition_next(Specialcontext *specialcontext,
                                Enumcodeatposition *ecp)
{
  GtRange currentrange;
  bool done;

  if (ecp->exhausted)
  {
    return false;
  }
  while (ecp->sri != NULL)
  {
    if (!gt_specialrangeiterator_next(ecp->sri,&currentrange))
    {
      gt_specialrangeiterator_delete(ecp->sri);
      ecp->sri = NULL;
      break;
    }
    if (ecp->moveforward)
    {
      if (newcodelistelem(specialcontext,
                          ecp->previousrange.end,
                          currentrange.start,
                          ecp))
      {
        ecp->previousrange = currentrange;
        return true;
      }
    } else
    {
      if (newcodelistelem(specialcontext,
                          currentrange.end,
                          ecp->previousrange.start,
                          ecp))
      {
        ecp->previousrange = currentrange;
        return true;
      }
    }
    ecp->previousrange = currentrange;
  }
  ecp->exhausted = true;
  if (ecp->moveforward)
  {
    done = newcodelistelem(specialcontext,
                           ecp->previousrange.end,
                           ecp->totallength,
                           ecp);
  } else
  {
    done = newcodelistelem(specialcontext,
                           0,
                           ecp->previousrange.start,
                           ecp);
  }
  return done;
}

// Assembly:
cmpb $0x0, 0x28(%rsi)
je 0x19c521
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x19c586
movq %r15, %rsi
callq 0x7428b
testb %al, %al
je 0x19c578
cmpb $0x1, 0x18(%rbx)
jne 0x19c558
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
jmp 0x19c560
movq 0x8(%rsp), %rsi
movq (%rbx), %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x19c5c2
testb %al, %al
jne 0x19c5af
movups (%rsp), %xmm0
movups %xmm0, (%rbx)
jmp 0x19c533
movq 0x10(%rbx), %rdi
callq 0x74a09
andq $0x0, 0x10(%rbx)
movb $0x1, 0x28(%rbx)
cmpb $0x1, 0x18(%rbx)
jne 0x19c59d
movq 0x8(%rbx), %rsi
movq 0x20(%rbx), %rdx
movq %r14, %rdi
jmp 0x19c5a5
movq (%rbx), %rdx
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x19c5c2
jmp 0x19c5b8
movups (%rsp), %xmm0
movups %xmm0, (%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-enumcodes.c
// Function: newcodelistelem
static bool newcodelistelem(Specialcontext *specialcontext,
                            GtUword smallerval,
                            GtUword largerval,
                            const Enumcodeatposition *ecp)
{
  if (smallerval < largerval)
  {
    GtUword distance = largerval - smallerval;

    if (distance > (GtUword) (ecp->prefixlength-1))
    {
      distance = (GtUword) (ecp->prefixlength-1);
    }
    specialcontext->maxprefixindex = (unsigned int) distance;
    if (ecp->moveforward)
    {
      specialcontext->position = ecp->totallength - smallerval;
    } else
    {
      specialcontext->position = largerval;
    }
    gt_assert(specialcontext->position >=
              (GtUword) specialcontext->maxprefixindex);
    return true;
  }
  return false;
}

// Assembly:
movq %rdx, %r8
subq %rsi, %r8
jbe 0x19c5f1
movl 0x3c(%rcx), %eax
decl %eax
cmpq %rax, %r8
cmovbq %r8, %rax
movl %eax, (%rdi)
cmpb $0x1, 0x18(%rcx)
movq %rdx, %r8
jne 0x19c5e8
movq 0x20(%rcx), %r8
subq %rsi, %r8
movq %r8, 0x8(%rdi)
cmpq %rax, %r8
jb 0x19c5f8
cmpq %rsi, %rdx
seta %al
retq
pushq %rax
movq 0x29b968(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x148a09(%rip), %rsi    # 0x2e5013
leaq 0x1bb6dc(%rip), %rdx    # 0x357ced
leaq 0x1bb71a(%rip), %rcx    # 0x357d32
leaq 0x1bb603(%rip), %r8     # 0x357c22
pushq $0x5e
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-enumcodes.c
// Function: gt_Enumcodeatposition_delete
void gt_Enumcodeatposition_delete(Enumcodeatposition *ecp)
{
  if (ecp != NULL)
  {
    gt_free(ecp->filltable);
    gt_multimappower_delete(ecp->multimappower);
    gt_free(ecp);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x19c673
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
leaq 0x1bb5dc(%rip), %r14    # 0x357c22
movq %r14, %rsi
movl $0xa2, %edx
callq 0x936f9
movq 0x40(%rbx), %rdi
callq 0x164c86
movq %rbx, %rdi
movq %r14, %rsi
movl $0xa4, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-enumcodes.c
// Function: gt_Enumcodeatposition_filledqgramcode
GtCodetype gt_Enumcodeatposition_filledqgramcode(const Enumcodeatposition *ecp,
                                                 unsigned int prefixindex,
                                                 GtUword pos)
{
  GtCodetype code;
  unsigned int idx;
  GtUchar cc;

  gt_assert(prefixindex > 0 && prefixindex < ecp->prefixlength);
  code = ecp->filltable[prefixindex];
  for (idx=0; idx<prefixindex; idx++)
  {
    gt_assert((GtUword) (pos + idx) < ecp->totallength);
    cc = gt_encseq_get_encoded_char_nospecial(ecp->encseq,
                                              pos + idx,
                                              ecp->readmode);
    gt_assert(GT_ISNOTSPECIAL(cc));
    code += ecp->multimappower[idx][cc];
  }
  return code;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testl %esi, %esi
je 0x19c749
movq %rdi, %r14
cmpl %esi, 0x3c(%rdi)
jbe 0x19c749
movq %rdx, %rbx
movq 0x48(%r14), %rax
movl %esi, %r12d
movq (%rax,%r12,8), %r15
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x19c6d6
leaq (%rbx,%r13), %rsi
cmpq 0x20(%r14), %rsi
jae 0x19c711
movq 0x30(%r14), %rdi
movl 0x38(%r14), %edx
callq 0x70bf6
cmpb $-0x2, %al
jae 0x19c6e3
movq 0x40(%r14), %rcx
movq (%rcx,%r13,8), %rcx
movzbl %al, %eax
addq (%rcx,%rax,8), %r15
incq %r13
jmp 0x19c6a2
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x29b87e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x14891f(%rip), %rsi    # 0x2e5013
leaq 0x16751c(%rip), %rdx    # 0x303c17
leaq 0x1bb56d(%rip), %rcx    # 0x357c6f
leaq 0x1bb519(%rip), %r8     # 0x357c22
movl $0xb8, %r9d
jmp 0x19c73d
movq 0x29b850(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1488f1(%rip), %rsi    # 0x2e5013
leaq 0x1bb56c(%rip), %rdx    # 0x357c95
leaq 0x1bb53f(%rip), %rcx    # 0x357c6f
leaq 0x1bb4eb(%rip), %r8     # 0x357c22
movl $0xb4, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x29b818(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1488b9(%rip), %rsi    # 0x2e5013
leaq 0x1bb4db(%rip), %rdx    # 0x357c3c
leaq 0x1bb507(%rip), %rcx    # 0x357c6f
leaq 0x1bb4b3(%rip), %r8     # 0x357c22
movl $0xb0, %r9d
jmp 0x19c73d
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-enumcodes.c
// Function: gt_Enumcodeatposition_filledqgramcodestopatmax
bool gt_Enumcodeatposition_filledqgramcodestopatmax(
                                        GtCodetype *code,
                                        const Enumcodeatposition *ecp,
                                        unsigned int prefixindex,
                                        GtUword pos,
                                        GtCodetype stopcode)
{
  GtCodetype tmpcode;
  unsigned int idx;
  GtUchar cc;

  gt_assert(prefixindex > 0 && prefixindex < ecp->prefixlength);
  tmpcode = ecp->filltable[prefixindex];
  if (tmpcode > stopcode)
  {
    return false;
  }
  for (idx=0; idx<prefixindex; idx++)
  {
    gt_assert((GtUword) (pos + idx) < ecp->totallength);
    cc = gt_encseq_get_encoded_char_nospecial(ecp->encseq,
                                              pos + idx,
                                              ecp->readmode);
    gt_assert(GT_ISNOTSPECIAL(cc));
    tmpcode += ecp->multimappower[idx][cc];
    if (tmpcode > stopcode)
    {
      return false;
    }
  }
  *code = tmpcode;
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
je 0x19c867
movq %rsi, %r12
cmpl %edx, 0x3c(%rsi)
jbe 0x19c867
movq %r8, %rbx
movq 0x48(%r12), %rax
movl %edx, %r13d
movq (%rax,%r13,8), %rbp
cmpq %r8, %rbp
ja 0x19c7ef
movq %rcx, %r14
movq %rdi, (%rsp)
xorl %r15d, %r15d
cmpq %r15, %r13
je 0x19c7f3
leaq (%r14,%r15), %rsi
cmpq 0x20(%r12), %rsi
jae 0x19c80b
movq 0x30(%r12), %rdi
movl 0x38(%r12), %edx
callq 0x70bf6
cmpb $-0x2, %al
jae 0x19c839
movq 0x40(%r12), %rcx
movq (%rcx,%r15,8), %rcx
movzbl %al, %eax
addq (%rcx,%rax,8), %rbp
incq %r15
cmpq %rbx, %rbp
jbe 0x19c7b4
xorl %eax, %eax
jmp 0x19c7fc
movq (%rsp), %rax
movq %rbp, (%rax)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x29b756(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1487f7(%rip), %rsi    # 0x2e5013
leaq 0x1bb472(%rip), %rdx    # 0x357c95
leaq 0x1bb494(%rip), %rcx    # 0x357cbe
leaq 0x1bb3f1(%rip), %r8     # 0x357c22
movl $0xd1, %r9d
jmp 0x19c893
movq 0x29b728(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1487c9(%rip), %rsi    # 0x2e5013
leaq 0x1673c6(%rip), %rdx    # 0x303c17
leaq 0x1bb466(%rip), %rcx    # 0x357cbe
leaq 0x1bb3c3(%rip), %r8     # 0x357c22
movl $0xd5, %r9d
jmp 0x19c893
movq 0x29b6fa(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x14879b(%rip), %rsi    # 0x2e5013
leaq 0x1bb3bd(%rip), %rdx    # 0x357c3c
leaq 0x1bb438(%rip), %rcx    # 0x357cbe
leaq 0x1bb395(%rip), %r8     # 0x357c22
movl $0xc9, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-lcpvalues.c
// Function: gt_Outlcpinfo_reinit
void gt_Outlcpinfo_reinit(GtOutlcpinfo *outlcpinfo,
                          unsigned int numofchars,
                          unsigned int prefixlength,
                          GtUword numoflcpvalues)
{
  if (outlcpinfo != NULL)
  {
    if (prefixlength > 0)
    {
      outlcpinfo->turnwheel = gt_turningwheel_new(prefixlength,numofchars);
      outlcpinfo->sizeofinfo += gt_turningwheel_size();
    } else
    {
      outlcpinfo->turnwheel = NULL;
    }
    outlcpinfo->sizeofinfo
      += gt_tableoflcpvalues_realloc(&outlcpinfo->lcpsubtab.tableoflcpvalues,
                                     numoflcpvalues);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x19cb02
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0x19cae7
movl %edx, %edi
callq 0x1b4cf4
movq %rax, (%rbx)
callq 0x1b4dcc
addq %rax, 0x18(%rbx)
jmp 0x19caeb
andq $0x0, (%rbx)
leaq 0x40(%rbx), %rdi
movq %r14, %rsi
callq 0x19cb03
addq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-lcpvalues.c
// Function: gt_tableoflcpvalues_realloc
static size_t gt_tableoflcpvalues_realloc(GtLcpvalues *tableoflcpvalues,
                                          GtUword numoflcpvalues)
{
  if (numoflcpvalues > tableoflcpvalues->numofentries)
  {
    size_t sizeofinfo;

    tableoflcpvalues->bucketoflcpvalues
      = gt_realloc(tableoflcpvalues->bucketoflcpvalues,
                   sizeof (*tableoflcpvalues->bucketoflcpvalues) *
                   numoflcpvalues);
    sizeofinfo = sizeof (*tableoflcpvalues->bucketoflcpvalues) *
                         (numoflcpvalues - tableoflcpvalues->numofentries);
#ifndef NDEBUG
    GT_INITBITTABGENERIC(tableoflcpvalues->isset,
                         tableoflcpvalues->isset,
                         numoflcpvalues);
#endif
    sizeofinfo += GT_NUMOFINTSFORBITS(numoflcpvalues -
                                      tableoflcpvalues->numofentries)
                  * sizeof (GtBitsequence);
    tableoflcpvalues->numoflargelcpvalues = 0;
    tableoflcpvalues->numofentries = numoflcpvalues;
    tableoflcpvalues->lcptaboffset = 0;
    return sizeofinfo;
  }
  return 0;
}

// Assembly:
cmpq %rsi, 0x10(%rdi)
jae 0x19cbc4
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
leaq (,%rsi,4), %rsi
leaq 0x1bb211(%rip), %r15    # 0x357d42
movq %r15, %rdx
movl $0x14b, %ecx            # imm = 0x14B
callq 0x93472
movq %rax, 0x8(%r14)
movq %rbx, %r13
subq 0x10(%r14), %r13
leaq -0x1(%rbx), %r12
shrq $0x3, %r12
andq $-0x8, %r12
pushq $0x8
popq %rbp
addq %rbp, %r12
cmpq $0x40, %rbx
movq (%r14), %rdi
cmovbq %rbp, %r12
movq %r12, %rsi
movq %r15, %rdx
movl $0x151, %ecx            # imm = 0x151
callq 0x93472
movq %rax, (%r14)
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x17380
movq %rbx, %rax
subq 0x10(%r14), %rax
leaq -0x1(%rax), %rcx
shrq $0x6, %rcx
cmpq $0x40, %rax
leaq 0x8(,%rcx,8), %rax
cmovbq %rbp, %rax
leaq (%rax,%r13,4), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq