LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_getptr_ulong
const GtUword *gt_suffixsortspace_getptr_ulong (const GtSuffixsortspace *sssp,
                                                GtUword subbucketleft)
{
  gt_assert(sssp != NULL);
  if (sssp->ulongtab != NULL)
  {
    return sssp->ulongtab + sssp->bucketleftidx + subbucketleft
                          - sssp->partoffset;
  } else
  {
    return NULL;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x2060aa
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x2060a7
movq 0x38(%rdi), %rcx
movq 0x40(%rdi), %rdx
leaq (%rax,%rdx,8), %rax
leaq (%rax,%rsi,8), %rax
shlq $0x3, %rcx
subq %rcx, %rax
retq
xorl %eax, %eax
retq
pushq %rax
callq 0x7fddc
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_getptr_uint32
const uint32_t *gt_suffixsortspace_getptr_uint32 (const GtSuffixsortspace *sssp,
                                                  GtUword subbucketleft)
{
  gt_assert(sssp != NULL);
  if (sssp->uinttab != NULL)
  {
    return sssp->uinttab + sssp->bucketleftidx + subbucketleft
                         - sssp->partoffset;
  } else
  {
    return NULL;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x2060d9
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x2060d6
movq 0x38(%rdi), %rcx
movq 0x40(%rdi), %rdx
leaq (%rax,%rdx,4), %rax
leaq (%rax,%rsi,4), %rax
shlq $0x2, %rcx
subq %rcx, %rax
retq
xorl %eax, %eax
retq
pushq %rax
callq 0x7fe15
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_set
void gt_suffixsortspace_set (GtSuffixsortspace *sssp,
                             GtUword subbucketleft,
                             GtUword idx,
                             GtUword value)
{
  GtUword updateindex;

  gt_assert(sssp != NULL);
  updateindex = sssp->bucketleftidx + subbucketleft + idx - sssp->partoffset;
  gt_assert (sssp->widthrelative2bucketleftidx  == 0 ||
             updateindex <
             sssp->bucketleftidx + sssp->widthrelative2bucketleftidx);
  gt_suffixsortspace_setdirect(sssp, updateindex,value);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x206115
addq %rsi, %rdx
movq 0x40(%rdi), %rax
movq 0x48(%rdi), %rsi
addq %rax, %rdx
subq 0x38(%rdi), %rdx
testq %rsi, %rsi
sete %r8b
addq %rax, %rsi
cmpq %rsi, %rdx
setb %al
orb %r8b, %al
je 0x20611a
movq %rdx, %rsi
movq %rcx, %rdx
popq %rax
jmp 0x20611f
callq 0x7fe87
callq 0x7fe4e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_setdirect
static void gt_suffixsortspace_setdirect(GtSuffixsortspace *sssp,
                                         GtUword idx,
                                         GtUword value)
{
  gt_assert(sssp != NULL && idx <= sssp->maxindex && value <= sssp->maxvalue);
  if (value == 0)
  {
    sssp->longestidx.defined = true;
    sssp->longestidx.valueunsignedlong = sssp->partoffset + idx;
  }
  if (sssp->ulongtab != NULL)
  {
    sssp->ulongtab[idx] = value;
  } else
  {
    gt_assert (sssp->uinttab != NULL && value <= (GtUword) UINT_MAX);
    sssp->uinttab[idx] = (uint32_t) value;
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x20616b
cmpq %rsi, 0x28(%rdi)
jb 0x20616b
cmpq %rdx, 0x30(%rdi)
jb 0x20616b
testq %rdx, %rdx
jne 0x206145
movb $0x1, 0x8(%rdi)
movq 0x38(%rdi), %rax
addq %rsi, %rax
movq %rax, 0x10(%rdi)
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x206154
movq %rdx, (%rax,%rsi,8)
jmp 0x206169
movq %rdx, %rax
shrq $0x20, %rax
jne 0x206170
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x206170
movl %edx, (%rax,%rsi,4)
popq %rax
retq
callq 0x7fef9
callq 0x7fec0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_bucketrange_set
void gt_suffixsortspace_bucketrange_set(GtSuffixsortspace *sssp,
                                        GtUword bucketleftidx,
                                        GtUword widthrelative2bucketleftidx)
{
  gt_assert(sssp != NULL && (sssp->bucketleftidx == bucketleftidx ||
                             !sssp->currentexport));
  sssp->bucketleftidx = bucketleftidx;
  sssp->widthrelative2bucketleftidx = widthrelative2bucketleftidx;
}

// Assembly:
testq %rdi, %rdi
je 0x20621b
cmpq %rsi, 0x40(%rdi)
je 0x206212
cmpb $0x1, (%rdi)
je 0x20621b
movq %rsi, 0x40(%rdi)
movq %rdx, 0x48(%rdi)
retq
pushq %rax
callq 0x7ff6b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_sortspace_delete
void gt_suffixsortspace_sortspace_delete (GtSuffixsortspace *sssp)
{
  gt_assert(sssp != NULL);
  gt_free(sssp->ulongtab);
  sssp->ulongtab = NULL;
  gt_free(sssp->uinttab);
  sssp->uinttab = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x20628b
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
leaq 0x1be36c(%rip), %r14    # 0x3c45c8
movq %r14, %rsi
movl $0x19d, %edx            # imm = 0x19D
callq 0x109670
xorl %r15d, %r15d
movq %r15, 0x50(%rbx)
movq 0x58(%rbx), %rdi
movq %r14, %rsi
movl $0x19f, %edx            # imm = 0x19F
callq 0x109670
movq %r15, 0x58(%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x7ffdd
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_delete_cloned
void gt_suffixsortspace_delete_cloned(GtSuffixsortspace **sssp_tab,
                                      unsigned int parts)
{
  bool found = false;
  unsigned int p;

  gt_assert(sssp_tab != NULL && parts > 1U && sssp_tab[0]->clonenumber == 0);
  for (p = 1U; p < parts; p++)
  {
    GtSuffixsortspace *sssp = sssp_tab[p];

    gt_assert(sssp->clonenumber == p);
    if (!found && sssp->longestidx.defined)
    {
      GtUword zerotest;
      gt_assert(sssp->longestidx.valueunsignedlong >= sssp->partoffset);
      zerotest = sssp->longestidx.valueunsignedlong - sssp->partoffset;
      if ((sssp->ulongtab != NULL && sssp->ulongtab[zerotest] == 0) ||
          (sssp->uinttab != NULL && sssp->uinttab[zerotest] == 0))
      {
        sssp_tab[0]->longestidx.defined = true;
        sssp_tab[0]->longestidx.valueunsignedlong
          = sssp->longestidx.valueunsignedlong;
        found = true;
      }
    }
    gt_suffixsortspace_delete(sssp_tab[p],false);
    sssp_tab[p] = NULL;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x206347
cmpl $0x2, %esi
jb 0x206347
movq %rdi, %rbx
movq (%rdi), %rax
cmpl $0x0, 0x4(%rax)
jne 0x206347
cmpl $0x2, %esi
jb 0x206332
movl %esi, %r14d
movl $0x1, %r15d
xorl %ebp, %ebp
movq (%rbx,%r15,8), %rdi
movl 0x4(%rdi), %eax
cmpq %rax, %r15
jne 0x20633d
testb $0x1, %bpl
jne 0x20631b
cmpb $0x1, 0x8(%rdi)
jne 0x20631b
movq 0x10(%rdi), %rax
movq %rax, %rcx
subq 0x38(%rdi), %rcx
jb 0x206342
movq 0x50(%rdi), %rdx
testq %rdx, %rdx
je 0x2062fe
cmpq $0x0, (%rdx,%rcx,8)
je 0x20630d
movq 0x58(%rdi), %rdx
testq %rdx, %rdx
je 0x20631b
cmpl $0x0, (%rdx,%rcx,4)
jne 0x20631b
movq (%rbx), %rcx
movb $0x1, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movb $0x1, %bpl
xorl %esi, %esi
callq 0x205e63
movq $0x0, (%rbx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x2062c9
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x8004f
callq 0x80088
callq 0x80016
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_to_file
void gt_suffixsortspace_to_file (FILE *outfpsuftab,
                                 const GtSuffixsortspace *sssp,
                                 GtUword numberofsuffixes)
{
  gt_assert(sssp != NULL);
  if (sssp->ulongtab != NULL)
  {
    gt_xfwrite((void *) sssp->ulongtab,sizeof (*sssp->ulongtab),
               (size_t) numberofsuffixes, outfpsuftab);
  } else
  {
    gt_assert(sssp->uinttab != NULL);
    gt_xfwrite((void *) sssp->uinttab,sizeof (*sssp->uinttab),
               (size_t) numberofsuffixes, outfpsuftab);
  }
}

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0x2063a4
movq %rdi, %rcx
movq 0x50(%rsi), %rdi
testq %rdi, %rdi
je 0x206390
movl $0x8, %esi
jmp 0x20639e
movq 0x58(%rsi), %rdi
testq %rdi, %rdi
je 0x2063a9
movl $0x4, %esi
popq %rax
jmp 0x125658
callq 0x8016c
callq 0x80133
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_compressed_to_file
void gt_suffixsortspace_compressed_to_file (const GtSuffixsortspace *sssp,
                                            GtBitbuffer *bb,
                                            GtUword numberofsuffixes)
{
  gt_assert(sssp != NULL);
  if (sssp->ulongtab != NULL)
  {
    gt_bitbuffer_write_ulongtab_FILE(bb,sssp->ulongtab,numberofsuffixes);
  } else
  {
    gt_assert (sssp->uinttab != NULL);
    gt_bitbuffer_write_uint32tab_FILE(bb,sssp->uinttab,numberofsuffixes);
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x2063de
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x2063c9
movq %rsi, %rdi
movq %rax, %rsi
popq %rax
jmp 0xd8e35
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x2063e3
movq %rsi, %rdi
movq %rax, %rsi
popq %rax
jmp 0xd8df9
callq 0x801de
callq 0x801a5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_SSSPbuf_new
GtSSSPbuf *gt_SSSPbuf_new(GtUword size)
{
  GtSSSPbuf *sssp_buf = gt_malloc(sizeof *sssp_buf);

  sssp_buf->size = size;
  sssp_buf->nextfree = 0;
  sssp_buf->overhang.start = sssp_buf->overhang.end = 0;
  return sssp_buf;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x1be1d5(%rip), %rsi    # 0x3c45c8
movl $0x20, %edi
movl $0x223, %edx            # imm = 0x223
callq 0x1092b2
movq %rbx, 0x10(%rax)
movq $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_SSSPbuf_insertfullspecialrange
static GtUword gt_suffixsortspace_insertfullspecialrange(
                                                  GtSuffixsortspace *sssp,
                                                  GtReadmode readmode,
                                                  GtUword nextfree,
                                                  GtUword totallength,
                                                  GtUword leftpos,
                                                  GtUword rightpos)
{
  GtUword pos;

  gt_assert(leftpos < rightpos);
  if (GT_ISDIRREVERSE(readmode))
  {
    pos = rightpos - 1;
  } else
  {
    pos = leftpos;
  }
  while (true)
  {
    if (GT_ISDIRREVERSE(readmode))
    {
      gt_assert(pos < totallength);
      gt_suffixsortspace_setdirect(sssp,nextfree,
                                   GT_REVERSEPOS(totallength,pos));
      nextfree++;
      if (pos == leftpos)
      {
        break;
      }
      pos--;
    } else
    {
      gt_suffixsortspace_setdirect(sssp, nextfree, pos);
      nextfree++;
      if (pos == rightpos-1)
      {
        break;
      }
      pos++;
    }
  }
  return nextfree;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq %r9, %r8
jae 0x2066b6
movq %r9, %rbx
movq %rcx, %r12
movl %esi, %ebp
movq %rdi, %r13
movq %rdx, 0x8(%rsp)
movq 0x18(%rdx), %r14
andl $-0x3, %ebp
decq %rbx
cmpl $0x1, %ebp
movq %r8, 0x10(%rsp)
movq %r8, %r15
cmoveq %rbx, %r15
cmpl $0x1, %ebp
jne 0x206679
cmpq %r12, %r15
jae 0x2066b1
movq %r15, %rdx
notq %rdx
addq %r12, %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0x20611f
incq %r14
movq $-0x1, %rax
cmpq 0x10(%rsp), %r15
jne 0x206694
jmp 0x206699
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x20611f
incq %r14
movl $0x1, %eax
cmpq %rbx, %r15
je 0x206699
addq %rax, %r15
jmp 0x206648
movq 0x8(%rsp), %rax
movq %r14, 0x18(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x80334
callq 0x802fb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suftaborder.c
// Function: gt_showentiresuftab
void gt_showentiresuftab(const GtEncseq *encseq,
                         GtReadmode readmode,
                         const GtSuffixsortspace *suffixsortspace,
                         GtUword subbucketleft,
                         GtUword depth)
{
  GtUword idx, pos, totallength = gt_encseq_total_length(encseq);

  for (idx = 0; idx <= totallength; idx++)
  {
    pos = gt_suffixsortspace_get(suffixsortspace,subbucketleft,idx);
    printf("suftab["GT_WU"]="GT_WU" ",idx,pos);
    gt_encseq_showatstartposwithdepth(stdout,encseq,readmode,pos,depth);
    printf("\n");
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
callq 0xec1d8
movq %rax, %r13
xorl %ebx, %ebx
movq %r15, %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x206063
movq %rax, %r14
leaq 0x1be58b(%rip), %rdi    # 0x3c4dea
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x17070
movq 0x2bd675(%rip), %rax    # 0x4c3ee8
movq (%rax), %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq 0x10(%rsp), %r8
callq 0xf1f39
movl $0xa, %edi
callq 0x17a20
incq %rbx
cmpq %r13, %rbx
jbe 0x206845
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/shu-encseq-gc.c
// Function: gt_encseq_get_rel_gc
double *gt_encseq_get_rel_gc(const GtEncseq *encseq,
                             GT_UNUSED GtError *err)
{
  double *gc_content;
  GtUword *gc_count_per_seq,
                max_unit,
                seq_idx = 0;
  bool is_mirrored_encseq;

  is_mirrored_encseq = gt_encseq_is_mirrored(encseq);
  if (is_mirrored_encseq)
  {
    max_unit = GT_DIV2(gt_encseq_num_of_sequences(encseq));
    gc_content = gt_calloc((size_t) GT_MULT2(max_unit), sizeof (double));
  }
  else
  {
    max_unit = gt_encseq_num_of_sequences(encseq);
    gc_content = gt_calloc((size_t) max_unit, sizeof (double));
  }

  gc_count_per_seq = gt_encseq_gc_count(encseq);
  for (seq_idx = 0; seq_idx < max_unit; seq_idx++) {
    calculate_rel_gc(encseq,
                     gc_content,
                     seq_idx,
                     gc_count_per_seq[seq_idx]);
  }
  if (is_mirrored_encseq)
  {
    GtUword double_max_unit = GT_MULT2(max_unit);
    for (seq_idx = 0; seq_idx < max_unit; seq_idx++)
    {
      gc_content[double_max_unit - seq_idx - 1] = gc_content[seq_idx];
    }
  }
  return gc_content;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xfac80
movl %eax, %ebp
movq %rbx, %rdi
callq 0xec1e8
movq %rax, %r15
movb %bpl, 0x7(%rsp)
testb %bpl, %bpl
je 0x206c77
movq %r15, %r13
shrq %r13
andq $-0x2, %r15
leaq 0x1be236(%rip), %rdx    # 0x3c4e96
movl $0x8, %esi
movq %r15, %rdi
movl $0x76, %ecx
callq 0x1093ef
movq %rax, %r14
jmp 0x206c96
leaq 0x1be218(%rip), %rdx    # 0x3c4e96
movl $0x8, %esi
movq %r15, %rdi
movl $0x7b, %ecx
callq 0x1093ef
movq %rax, %r14
movq %r15, %r13
movq %rbx, %rdi
callq 0x206a58
testq %r13, %r13
je 0x206d54
movq %rax, %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rbp
movq %rbx, %rdi
callq 0xec1e8
cmpq %r12, %rax
jbe 0x206dad
movq %rbx, %rdi
movq %r12, %rsi
callq 0xeffd3
cmpq %rbp, %rax
jb 0x206d9e
movq %rbp, %xmm1
movq 0x149bfd(%rip), %xmm2   # 0x3508e0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x149c01(%rip), %xmm3   # 0x3508f0
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
movsd %xmm0, (%r14,%r12,8)
xorpd %xmm1, %xmm1
callq 0x10acd4
cmpl $-0x1, %eax
je 0x206da3
movsd (%r14,%r12,8), %xmm0
movsd 0x1484ea(%rip), %xmm1   # 0x34f228
callq 0x10acd4
cmpl $0x1, %eax
je 0x206da8
incq %r12
cmpq %r12, %r13
jne 0x206cad
cmpb $0x0, 0x7(%rsp)
je 0x206d8c
testq %r13, %r13
je 0x206d8c
movq %r13, %rax
negq %rax
shlq $0x4, %r13
leaq (%r14,%r13), %rcx
addq $-0x8, %rcx
xorl %edx, %edx
movq %r14, %rsi
movsd (%rsi), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
decq %rdx
addq $0x8, %rsi
cmpq %rdx, %rax
jne 0x206d77
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x8073e
callq 0x80707
callq 0x806d0
callq 0x80699
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/shu-genomediff.c
// Function: genomediff_print_table
static void genomediff_print_table(double **tab,
                                   GtShuUnitFileInfo *unit_info)
{
  GtUword i_idx, j_idx;

  for (i_idx = 0; i_idx < unit_info->num_of_genomes; i_idx++) {
    printf("# %s\t", gt_str_array_get(unit_info->genome_names, i_idx));
    for (j_idx = 0; j_idx < unit_info->num_of_genomes; j_idx++) {
      if (i_idx == j_idx)
        printf("%.6f\t",0.0);
      else
        printf("%f\t", tab[i_idx][j_idx]);
    }
    printf("\n");
  }
}

// Assembly:
cmpq $0x0, (%rsi)
je 0x207822
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1bd960(%rip), %r12    # 0x3c510a
leaq 0x1bd95f(%rip), %r13    # 0x3c5110
xorl %ebp, %ebp
movq 0x10(%rbx), %rdi
movq %rbp, %rsi
callq 0x121cfa
leaq 0x1bda51(%rip), %rdi    # 0x3c5217
movq %rax, %rsi
xorl %eax, %eax
callq 0x17070
cmpq $0x0, (%rbx)
je 0x207802
xorl %r15d, %r15d
cmpq %r15, %rbp
jne 0x2077e6
xorps %xmm0, %xmm0
movq %r12, %rdi
jmp 0x2077f3
movq (%r14,%rbp,8), %rax
movsd (%rax,%r15,8), %xmm0
movq %r13, %rdi
movb $0x1, %al
callq 0x17070
incq %r15
cmpq (%rbx), %r15
jb 0x2077d9
movl $0xa, %edi
callq 0x17a20
incq %rbp
cmpq (%rbx), %rbp
jb 0x2077b3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/shu_unitfile.c
// Function: gt_shu_unit_info_delete
void gt_shu_unit_info_delete(GtShuUnitFileInfo *unit_info) {
  if (unit_info != NULL) {
    gt_free(unit_info->map_files);
    gt_str_array_delete(unit_info->genome_names);
    gt_free(unit_info);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x207fe6
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
leaq 0x1bd264(%rip), %r14    # 0x3c521d
movq %r14, %rsi
movl $0xca, %edx
callq 0x109670
movq 0x10(%rbx), %rdi
callq 0x121e8b
movq %rbx, %rdi
movq %r14, %rsi
movl $0xcc, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/shu_unitfile.c
// Function: gt_shu_unit_info_new
GtShuUnitFileInfo *gt_shu_unit_info_new(const GtEncseq *encseq)
{
  GtShuUnitFileInfo *unit_info = gt_malloc(sizeof (*unit_info));

  unit_info->map_files = NULL;
  unit_info->genome_names = NULL;
  unit_info->num_of_genomes = 0;
  unit_info->num_of_files = gt_encseq_num_of_files(encseq);
  unit_info->file_names = gt_encseq_filenames(encseq);
  unit_info->encseq = encseq;
  gt_shu_unit_info_files_as_units(unit_info);
  return unit_info;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x1bd227(%rip), %rsi    # 0x3c521d
movl $0x30, %edi
movl $0xdf, %edx
callq 0x1092b2
movq %rax, %rbx
xorl %r15d, %r15d
movq %r15, 0x20(%rax)
movq %r15, 0x10(%rax)
movq %r15, (%rax)
movq %r14, %rdi
callq 0xf4233
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0xf08d6
movq %rax, 0x18(%rbx)
movq %r14, 0x28(%rbx)
movq 0x8(%rbx), %rax
movq %rax, (%rbx)
callq 0x121b54
movq %rax, 0x10(%rbx)
cmpq %r15, 0x8(%rbx)
je 0x20806f
xorl %r14d, %r14d
movq 0x10(%rbx), %r15
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x121d35
movq %r15, %rdi
movq %rax, %rsi
callq 0x121cc0
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x20804b
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/spaced-seeds.c
// Function: spse_initdfsconstinfo
static void spse_initdfsconstinfo(Limdfsconstinfo *mt,
                                  unsigned int alphasize,
                                  ...)
                                 /* Variable argument list is as follows:
                                    const GtUchar *pattern,
                                    Bitsequence seedbitvector,
                                    GtUword seedweight
                                 */
{
  va_list ap;
  SpseLimdfsconstinfo *mti = (SpseLimdfsconstinfo*) mt;

  va_start(ap,alphasize);
  mti->pattern = va_arg(ap, const GtUchar *);
  mti->seedbitvector = va_arg(ap, GtBitsequence);
  mti->seedweight = va_arg(ap, GtUword);
  va_end(ap);
}

// Assembly:
subq $0x58, %rsp
leaq -0x60(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x2080da
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp)
movaps %xmm6, 0x30(%rsp)
movaps %xmm7, 0x40(%rsp)
movq %rsi, -0x70(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, -0x78(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x80(%rsp)
movl $0x10, %ecx
cmpq $0x28, %rcx
ja 0x208116
movl $0x10, %eax
addq -0x70(%rsp), %rax
addl $0x8, %ecx
movl %ecx, -0x80(%rsp)
jmp 0x208124
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq %rax, 0x10(%rdi)
movl -0x80(%rsp), %ecx
cmpq $0x28, %rcx
ja 0x208146
movq %rcx, %rax
addq -0x70(%rsp), %rax
addl $0x8, %ecx
movl %ecx, -0x80(%rsp)
jmp 0x208154
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq %rax, (%rdi)
movl -0x80(%rsp), %ecx
cmpq $0x28, %rcx
ja 0x208175
movq %rcx, %rax
addq -0x70(%rsp), %rax
addl $0x8, %ecx
movl %ecx, -0x80(%rsp)
jmp 0x208183
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq %rax, 0x8(%rdi)
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/spaced-seeds.c
// Function: spse_nextLimdfsstate
static void spse_nextLimdfsstate(const Limdfsconstinfo *mt,
                                 DECLAREPTRDFSSTATE(aliasoutcol),
                                 GtUword currentdepth,
                                 GtUchar currentchar,
                                 GT_UNUSED const DECLAREPTRDFSSTATE(aliasincol))
{
  SpseLimdfsstate *outcol = (SpseLimdfsstate *) aliasoutcol;
#ifndef NDEBUG
  const SpseLimdfsstate *incol = (const SpseLimdfsstate *) aliasincol;
#endif
  SpseLimdfsconstinfo *mti = (SpseLimdfsconstinfo*) mt;

  gt_assert(GT_ISNOTSPECIAL(currentchar));
  gt_assert(currentdepth > 0);
  gt_assert(incol->pathmatches);

  outcol->pathmatches = setpathmatch(mti->seedbitvector,
                                     mti->pattern,
                                     currentdepth,
                                     currentchar);
}

// Assembly:
pushq %rax
movl %ecx, %eax
cmpb $-0x2, %al
jae 0x20821c
testq %rdx, %rdx
je 0x208221
cmpb $0x0, (%r8)
je 0x208226
movq (%rdi), %r8
decq %rdx
movl %edx, %ecx
shlq %cl, %r8
movb $0x1, %cl
testq %r8, %r8
jns 0x208218
movq 0x10(%rdi), %rcx
cmpb %al, (%rcx,%rdx)
sete %cl
movb %cl, (%rsi)
popq %rax
retq
callq 0x80aee
callq 0x80b60
callq 0x80b27
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/spaced-seeds.c
// Function: spse_inplacenextLimdfsstate
static void spse_inplacenextLimdfsstate(const Limdfsconstinfo *mt,
                                        DECLAREPTRDFSSTATE(aliascol),
                                        GtUword currentdepth,
                                        GtUchar currentchar)
{
  SpseLimdfsstate *col = (SpseLimdfsstate *) aliascol;
  const SpseLimdfsconstinfo *mti = (const SpseLimdfsconstinfo*) mt;

  gt_assert(GT_ISNOTSPECIAL(currentchar));
  gt_assert(currentdepth > 0);
  col->pathmatches = setpathmatch(mti->seedbitvector,
                                  mti->pattern,
                                  currentdepth,
                                  currentchar);
}

// Assembly:
pushq %rax
movl %ecx, %eax
cmpb $-0x2, %al
jae 0x208257
testq %rdx, %rdx
je 0x20825c
movq (%rdi), %r8
decq %rdx
movl %edx, %ecx
shlq %cl, %r8
movb $0x1, %cl
testq %r8, %r8
jns 0x208253
movq 0x10(%rdi), %rcx
cmpb %al, (%rcx,%rdx)
sete %cl
movb %cl, (%rsi)
popq %rax
retq
callq 0x80b99
callq 0x80bd2
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/spmsuftab.c
// Function: gt_spmsuftab_new
GtSpmsuftab *gt_spmsuftab_new(GtUword numofentries,
                              GtUword maxvalue,
                              unsigned int bitsforseqnumrelpos,
                              GtLogger *logger)
{
  GtSpmsuftab *spmsuftab;
  unsigned int bitsforpositions;
  GtUword required;

  spmsuftab = gt_malloc(sizeof (*spmsuftab));
  required = (GtUword) gt_spmsuftab_requiredspace(numofentries,
                                                        maxvalue,
                                                        bitsforseqnumrelpos);
  bitsforpositions = gt_determinebitspervalue(maxvalue);
  if (bitsforpositions < bitsforseqnumrelpos)
  {
    gt_logger_log(logger,"use "GT_WU" bitpackarray-entries for all positions "
                         "(%u bits each,"GT_WU" bytes total)",
                         numofentries,bitsforpositions,required);
    spmsuftab->bitpackarray
      = gt_compact_ulong_store_new(numofentries,bitsforpositions);
    spmsuftab->usebitsforpositions = true;
    spmsuftab->maxvalue = maxvalue;
  } else
  {
    gt_logger_log(logger,"use "GT_WU" bitpackarray-entries for all "
                  "seqnum/relpos-pairs (%u bits each,"GT_WU" bytes total)",
                  numofentries,bitsforseqnumrelpos,required);
    spmsuftab->bitpackarray
      = gt_compact_ulong_store_new(numofentries,bitsforseqnumrelpos);
    spmsuftab->usebitsforpositions = false;
    spmsuftab->maxvalue = (1UL << bitsforseqnumrelpos) - 1;
  }
  spmsuftab->partoffset = 0;
  spmsuftab->numofentries = numofentries;
  return spmsuftab;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1bd16f(%rip), %rsi    # 0x3c53f1
movl $0x28, %edi
movl $0x20, %edx
callq 0x1092b2
movq %rax, %r14
movq %r15, %rdi
callq 0x10af48
cmpl %ebp, %eax
cmovael %ebp, %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0xe8082
movq %rax, %r13
addq $0x28, %r13
movq %r15, %rdi
callq 0x10af48
cmpl %ebp, %eax
jae 0x2082f1
movl %eax, %r12d
leaq 0x1bd13f(%rip), %rsi    # 0x3c5407
movq (%rsp), %rdi
movq %rbx, %rdx
movl %eax, %ecx
movq %r13, %r8
xorl %eax, %eax
callq 0x10906e
movq %rbx, %rdi
movl %r12d, %esi
callq 0xe7fd8
movq %rax, 0x20(%r14)
movb $0x1, 0x18(%r14)
jmp 0x20832d
leaq 0x1bd15d(%rip), %rsi    # 0x3c5455
movq (%rsp), %rdi
movq %rbx, %rdx
movl %ebp, %ecx
movq %r13, %r8
xorl %eax, %eax
callq 0x10906e
movq %rbx, %rdi
movl %ebp, %esi
callq 0xe7fd8
movq %rax, 0x20(%r14)
movb $0x0, 0x18(%r14)
movq $-0x1, %r15
movl %ebp, %ecx
shlq %cl, %r15
notq %r15
movq %r15, 0x10(%r14)
movq $0x0, (%r14)
movq %rbx, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/spmsuftab.c
// Function: gt_spmsuftab_requiredspace
size_t gt_spmsuftab_requiredspace(GtUword numofentries,
                                  GtUword maxvalue,
                                  unsigned int bitsforseqnumrelpos)
{
  unsigned int bitsforpositions = gt_determinebitspervalue(maxvalue);

  return sizeof (GtSpmsuftab) +
         gt_compact_ulong_store_size(numofentries,
                                     GT_MIN(bitsforpositions,
                                            bitsforseqnumrelpos));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x10af48
cmpl %ebx, %eax
cmovbl %eax, %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0xe8082
addq $0x28, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/tagerator.c
// Function: tgr_storematch
static void tgr_storematch(void *processinfo,const GtIdxMatch *match)
{
  ArrayTgrSimplematch *storetab = (ArrayTgrSimplematch *) processinfo;
  TgrSimplematch *simplematch;

  GT_GETNEXTFREEINARRAY(simplematch,storetab,TgrSimplematch,32);
  simplematch->dbstartpos = match->dbstartpos;
  simplematch->matchlength = match->dblen;
  simplematch->rcmatch = ISRCDIR(storetab->twlptr);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
jb 0x208d88
leaq 0x20(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq (%rbx), %rdi
leaq 0x100(,%rax,8), %rax
leaq (%rax,%rax,2), %rsi
leaq 0x1bc732(%rip), %rdx    # 0x3c54ad
movl $0xcb, %ecx
callq 0x1094e6
movq %rax, (%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x208dc1
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
leaq (%rcx,%rcx,2), %rcx
movups 0x10(%r14), %xmm0
movups %xmm0, (%rax,%rcx,8)
movq 0x18(%rbx), %rdx
leaq 0x8(%rdx), %rsi
cmpq %rsi, (%rdx)
setne 0x10(%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x80d64
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/tagerator.c
// Function: showmstats
static void showmstats(void *processinfo,
                       const void *patterninfo,
                       GT_UNUSED GtUword patternstartpos,
                       GtUword mstatlength,
                       GtUword leftbound,
                       GtUword rightbound)
{
  TgrTagwithlength *twl = (TgrTagwithlength *) patterninfo;

  printf(""GT_WU" %c",mstatlength,ISRCDIR(twl) ? '-' : '+');
  if (gt_intervalwidthleq((const Limdfsresources *) processinfo,leftbound,
                       rightbound))
  {
    GtUword idx;
    GtArrayGtUword *mstatspos = gt_fromitv2sortedmatchpositions(
                                  (Limdfsresources *) processinfo,
                                  leftbound,
                                  rightbound,
                                  mstatlength);
    for (idx = 0; idx<mstatspos->nextfreeGtUword; idx++)
    {
      printf(" "GT_WU"",mstatspos->spaceGtUword[idx]);
    }
  }
  printf("\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r14
movq %rdi, %r12
leaq 0x8(%rsi), %rax
xorl %ecx, %ecx
cmpq %rax, (%rsi)
setne %cl
leal 0x2b(,%rcx,2), %edx
leaq 0x19d970(%rip), %rdi    # 0x3a6bc1
movq %r14, %rsi
xorl %eax, %eax
callq 0x17070
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1bb9f7
testb %al, %al
je 0x2092ac
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1bb341
cmpq $0x0, 0x10(%rax)
je 0x2092ac
movq %rax, %rbx
leaq 0x1b07f4(%rip), %r14    # 0x3b9a83
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x17070
incq %r15
cmpq 0x10(%rbx), %r15
jb 0x209292
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x17a20
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/tagerator.c
// Function: cmpdescend
static int cmpdescend(const void *a,const void *b)
{
  TgrSimplematch *valuea = (TgrSimplematch *) a;
  TgrSimplematch *valueb = (TgrSimplematch *) b;

  if (!valuea->rcmatch && valueb->rcmatch)
  {
    return -1;
  }
  if (valuea->rcmatch && !valueb->rcmatch)
  {
    return 1;
  }
  if (valuea->dbstartpos < valueb->dbstartpos)
  {
    return 1;
  }
  if (valuea->dbstartpos > valueb->dbstartpos)
  {
    return -1;
  }
  return 0;
}

// Assembly:
movb 0x10(%rdi), %cl
testb %cl, %cl
je 0x2092d4
movl $0x1, %eax
cmpb $0x1, 0x10(%rsi)
je 0x2092e3
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x0, 0x10(%rsi)
jne 0x2092d3
testb %cl, %cl
jne 0x2092c8
movq (%rdi), %rcx
movq (%rsi), %rdx
movl $0x1, %eax
cmpq %rdx, %rcx
jb 0x2092d3
xorl %eax, %eax
cmpq %rcx, %rdx
sbbl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/test-maxpairs.c
// Function: gt_samplesubstring
static GtUword gt_samplesubstring(bool replacespecialchars,
                                  GtUchar *seqspace,
                                  const GtEncseq *encseq,
                                  GtUword substringlength)
{
  GtUword start, totallength = gt_encseq_total_length(encseq);

  start = (GtUword) (random() % totallength);
  if (start + substringlength > totallength)
  {
    substringlength = totallength - start;
  }
  gt_assert(substringlength > 0);
  gt_encseq_extract_encoded(encseq,seqspace,start,start+substringlength-1);
  if (replacespecialchars)
  {
    GtUword idx;
    const unsigned int numofchars = gt_encseq_alphabetnumofchars(encseq);

    for (idx = 0; idx < substringlength; idx++)
    {
      if (GT_ISSPECIAL(seqspace[idx]))
      {
        seqspace[idx] = (GtUchar) (random() % numofchars);
      }
    }
  }
  return substringlength;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movl %edi, %ebp
movq %rdx, %rdi
callq 0xec1d8
movq %rax, %r13
callq 0x125bcc
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
divq %r13
leaq (%rdx,%r12), %rax
movq %r13, %r14
subq %rdx, %r14
cmpq %r13, %rax
cmovbeq %r12, %r14
testq %r14, %r14
je 0x209cc5
leaq (%rdx,%r14), %rcx
decq %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xed6e0
testb %bpl, %bpl
je 0x209cb3
movq %r15, %rdi
callq 0xf02b7
movl %eax, %ebp
xorl %r15d, %r15d
cmpb $-0x2, (%rbx,%r15)
jb 0x209cab
callq 0x125bcc
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
divl %ebp
movb %dl, (%rbx,%r15)
incq %r15
cmpq %r14, %r15
jb 0x209c92
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x80fcd
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/test-maxpairs.c
// Function: gt_storemaxmatchquery
static void gt_storemaxmatchquery(void *info, const GtQuerymatch *querymatch)
{
  GtArray *tab = (GtArray *) info;
  Substringmatch subm;
  GtUword query_seqlen, query_seqstart;

  subm.len = gt_querymatch_querylen(querymatch);
  subm.dbstart = gt_querymatch_dbstart(querymatch);
  subm.querystart = gt_querymatch_querystart(querymatch);
  gt_querymatch_query_coordinates(&subm.queryseqnum,&query_seqstart,
                                  &query_seqlen, querymatch);
  gt_array_add(tab,subm);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1c3980
leaq 0x28(%rsp), %r15
movq %rax, -0x18(%r15)
movq %r14, %rdi
callq 0x1c3985
movq %rax, -0x10(%r15)
movq %r14, %rdi
callq 0x1c3998
movq %rax, -0x8(%r15)
movq %rsp, %rsi
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rcx
callq 0x1c39b2
leaq 0x10(%rsp), %rsi
movl $0x20, %edx
movq %rbx, %rdi
callq 0xd49ce
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/test-maxpairs.c
// Function: gt_storemaxmatchself
static int gt_storemaxmatchself(void *info,
                                GT_UNUSED const GtGenericEncseq *genericencseq,
                                GtUword len,
                                GtUword pos1,
                                GtUword pos2,
                                GT_UNUSED GtError *err)
{
  GtMaxmatchselfinfo *maxmatchselfinfo = (GtMaxmatchselfinfo *) info;
  GtUword dbstart, querystart;

  if (pos1 < pos2)
  {
    dbstart = pos1;
    querystart = pos2;
  } else
  {
    dbstart = pos2;
    querystart = pos1;
  }
  if (dbstart < maxmatchselfinfo->dblen &&
      maxmatchselfinfo->dblen < querystart)
  {
    Substringmatch subm;
    GtUword pos;

    subm.len = len;
    subm.dbstart = dbstart;
    pos = querystart - (maxmatchselfinfo->dblen + 1);
    if (maxmatchselfinfo->querymarkpos == NULL)
    {
      subm.queryseqnum = 0;
      subm.querystart = pos;
    } else
    {
      GtUword queryseqnum
        = gt_encseq_sep2seqnum(maxmatchselfinfo->querymarkpos,
                               maxmatchselfinfo->numofquerysequences,
                               maxmatchselfinfo->querylen,
                               pos);
      if (queryseqnum == maxmatchselfinfo->numofquerysequences)
      {
        return -1;
      }
      if (queryseqnum == 0)
      {
        subm.querystart = pos;
      } else
      {
        subm.querystart = pos -
                          (maxmatchselfinfo->querymarkpos[queryseqnum-1] + 1);
      }
      subm.queryseqnum = queryseqnum;
    }
    gt_array_add(maxmatchselfinfo->results,subm);
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpq %r8, %rcx
movq %r8, %r14
cmovaq %rcx, %r14
cmovbq %rcx, %r8
movq 0x8(%rdi), %rax
cmpq %rax, %r8
setae %cl
cmpq %r14, %rax
setae %sil
xorl %ebx, %ebx
orb %cl, %sil
jne 0x209de6
movq %rdi, %r15
movq %rdx, (%rsp)
movq %r8, 0x8(%rsp)
notq %rax
addq %rax, %r14
movq 0x10(%rdi), %rdi
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x209d9e
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rsi
movq %r14, %rcx
callq 0xefa70
cmpq 0x20(%r15), %rax
jne 0x209dac
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x209de6
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
xorl %esi, %esi
jmp 0x209dd0
leaq 0x18(%rsp), %rcx
leaq 0x10(%rsp), %rdx
testq %rax, %rax
je 0x209dca
movq 0x10(%r15), %rsi
movq -0x8(%rsi,%rax,8), %rsi
notq %rsi
addq %rsi, %r14
movq %r14, %rsi
movq %rax, %r14
movq %rsi, (%rdx)
movq %r14, (%rcx)
movq (%r15), %rdi
movq %rsp, %rsi
movl $0x20, %edx
callq 0xd49ce
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/test-maxpairs.c
// Function: gt_showSubstringmatch
static int gt_showSubstringmatch(void *a, GT_UNUSED void *info,
                                 GT_UNUSED GtError *err)
{
  Substringmatch *m = (Substringmatch *) a;

  printf(GT_WU " " GT_WU " " GT_WU " " GT_WU "\n",
         m->len,
         m->dbstart,
         m->queryseqnum,
         m->querystart);
  return 0;
}

// Assembly:
pushq %rax
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq 0x18(%rdi), %rcx
movq 0x10(%rdi), %r8
leaq 0x1a38a4(%rip), %rdi    # 0x3ad6f1
xorl %eax, %eax
callq 0x17070
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/test-mergeesa.c
// Function: initNameandFILE
static int initNameandFILE(NameandFILE *nf,
                            const GtStr *outindex,
                            const char *suffix,
                            GtError *err)
{
  gt_error_check(err);
  nf->outfilename = gt_str_clone(outindex);
  gt_str_append_cstr(nf->outfilename,suffix);
  nf->fp = gt_fa_fopen(gt_str_get(nf->outfilename),"wb",err);
  if (nf->fp == NULL)
  {
    return -1;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
testq %rcx, %rcx
je 0x20a1fa
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x20a250
movq %r12, %rdi
callq 0x120e13
movq %rax, (%rbx)
movq %rax, %rdi
movq %r15, %rsi
callq 0x12097f
movq (%rbx), %rdi
callq 0x120d23
leaq 0x1548ee(%rip), %rsi    # 0x35eb0d
leaq 0x1bb953(%rip), %rdx    # 0x3c5b79
movq %rax, %rdi
movl $0x39, %ecx
movq %r14, %r8
callq 0x101c23
movq %rax, 0x8(%rbx)
xorl %ecx, %ecx
cmpq $0x1, %rax
sbbl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x810e6
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/test-mtrieins.c
// Function: gt_test_trieins
int gt_test_trieins(bool onlyins,const char *indexname,GtError *err)
{
  Suffixarray suffixarray;
  bool haserr = false;
  GtUword totallength = 0;

  gt_error_check(err);
  if (streamsuffixarray(&suffixarray,
                        SARR_ESQTAB,
                        indexname,
                        NULL,
                        err) != 0)
  {
    haserr = true;
  } else
  {
    totallength = gt_encseq_total_length(suffixarray.encseq);
  }
  if (!haserr)
  {
    Mergertrierep trierep;
    const GtUchar *characters;

    trierep.encseqreadinfo = gt_malloc(sizeof *trierep.encseqreadinfo);
    trierep.encseqreadinfo->encseqptr = suffixarray.encseq;
    trierep.encseqreadinfo->readmode = suffixarray.readmode;
    characters
      = gt_alphabet_characters(gt_encseq_alphabet(suffixarray.encseq));
    gt_mergertrie_initnodetable(&trierep,totallength,1U);
    maketrie(&trierep,characters,totallength);
    if (onlyins)
    {
#ifdef WITHTRIEIDENT
#ifdef WITHTRIESHOW
      showtrie(&trierep,characters);
#endif
      checktrie(&trierep,totallength+1,totallength,err);
#endif
    } else
    {
#ifdef WITHTRIEIDENT
#ifdef WITHTRIESHOW
      mergertrie_showallnoderelations(trierep.root);
#endif
#endif
      successivelydeletesmallest(&trierep,totallength,characters,err);
    }
    gt_mergertrie_delete(&trierep);
  }
  gt_freesuffixarray(&suffixarray);
  return haserr ? -1 : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
movq %rdx, %rbx
movq %rsi, %r15
movl %edi, %ebp
testq %rdx, %rdx
je 0x20a284
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x20a39f
xorl %r14d, %r14d
leaq 0x40(%rsp), %rdi
movl $0x1, %esi
movq %r15, %rdx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x1a9f52
movl %eax, %ebx
testl %eax, %eax
jne 0x20a2b1
movq 0x40(%rsp), %rdi
callq 0xec1d8
movq %rax, %r14
testl %ebx, %ebx
jne 0x20a37f
leaq 0x1bb957(%rip), %rsi    # 0x3c5c17
movl $0x10, %edi
movl $0x63, %edx
callq 0x1092b2
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
movq 0x40(%rsp), %rdi
movq %rdi, (%rax)
movl 0x88(%rsp), %ecx
movl %ecx, 0x8(%rax)
callq 0xf02da
movq %rax, %rdi
callq 0xd3733
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x32a255
movq %rsp, %r12
movl $0x0, (%r12)
movq $0x0, 0x8(%r12)
movq 0x20(%rsp), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x329cc8
movq 0x8(%rsp), %rax
incq %rax
movq %rax, 0x8(%rsp)
cmpq %r14, %rax
jbe 0x20a31a
movq 0x20(%rsp), %rax
testq %rax, %rax
sete %cl
orb %cl, %bpl
jne 0x20a375
leaq 0x10(%rsp), %r14
cmpq $0x0, 0x10(%rax)
je 0x20a375
movq %r14, %rdi
callq 0x32a190
movq %rax, %rdi
movq %r14, %rsi
callq 0x32a1ad
movq 0x20(%rsp), %rax
testq %rax, %rax
jne 0x20a351
leaq 0x10(%rsp), %rdi
callq 0x32a2b9
leaq 0x40(%rsp), %rdi
callq 0x1a9e1c
xorl %eax, %eax
negl %ebx
sbbl %eax, %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x8111d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/test-pairwise.c
// Function: gt_runcheckfunctionontwofiles
void gt_runcheckfunctionontwofiles(Checkcmppairfuntype checkfunction,
                                   const char *file1,
                                   const char *file2)
{
  const GtUchar *useq = NULL, *vseq = NULL;
  size_t ulen, vlen;
  bool forward = true;
  GtError *err;

  err = gt_error_new();
  useq = (const GtUchar *) gt_fa_mmap_read(file1,&ulen,err);
  if (useq == NULL)
  {
    fprintf(stderr, "error: %s\n", gt_error_get(err));
    exit(GT_EXIT_PROGRAMMING_ERROR);
  }
  vseq = (const GtUchar *) gt_fa_mmap_read(file2,&vlen,err);
  if (vseq == NULL)
  {
    fprintf(stderr, "error: %s\n", gt_error_get(err));
    exit(GT_EXIT_PROGRAMMING_ERROR);
  }
  gt_error_delete(err);
  while (true)
  {
    checkfunction(forward,useq,(GtUword) ulen,
                          vseq,(GtUword) vlen);
    if (!forward)
    {
      break;
    }
    forward = false;
  }
  gt_fa_xmunmap((void *) useq);
  gt_fa_xmunmap((void *) vseq);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1019b4
movq %rax, %r15
leaq 0x1bb86a(%rip), %rdx    # 0x3c5c31
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movl $0x27, %ecx
movq %rax, %r8
callq 0x102572
testq %rax, %rax
je 0x20a457
movq %rax, %r14
leaq 0x1bb846(%rip), %rdx    # 0x3c5c31
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
movl $0x2d, %ecx
movq %r15, %r8
callq 0x102572
testq %rax, %rax
je 0x20a45f
movq %rax, %r12
movq %r15, %rdi
callq 0x101b35
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %r8
movl $0x1, %edi
movq %r14, %rsi
movq %r12, %rcx
callq *%rbx
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %r8
xorl %edi, %edi
movq %r14, %rsi
movq %r12, %rcx
callq *%rbx
movq %r14, %rdi
callq 0x102b12
movq %r12, %rdi
callq 0x102b12
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x81180
movq %r15, %rdi
callq 0x81154
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/test-pairwise.c
// Function: gt_runcheckfunctionontext
GtUword gt_runcheckfunctionontext(Checkcmppairfuntype checkfunction,
                                     const char *text)
{
  GtUword i, len;

  len = (GtUword) strlen(text);
  for (i=1UL; i<=len/2; i++)
  {
    checkfunction(true,
                  (const GtUchar *) text,
                  i,
                  (const GtUchar *) (text+i),
                  len-i);
  }
  return len/2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x172f0
movq %rax, %r15
shrq %r15
cmpq $0x2, %rax
jb 0x20a4ca
movq %rax, %r12
movq %r15, %rbp
negq %rbp
decq %r12
movl $0x1, %r13d
leaq (%rbx,%r13), %rcx
movl $0x1, %edi
movq %rbx, %rsi
movq %r13, %rdx
movq %r12, %r8
callq *%r14
leaq 0x1(,%r13), %rax
addq %rbp, %rax
incq %r13
decq %r12
cmpq $0x1, %rax
jne 0x20a49e
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/test-pairwise.c
// Function: gt_applycheckfunctiontotext
GtUword gt_applycheckfunctiontotext(const GtUchar *text,
                                       GtUword textlen,
                                       void *info)
{
  GtUword i;
  Checkcmppairfuntype checkfunction = (Checkcmppairfuntype) info;

#ifdef SKDEBUG
  printf("%s\n",(char *) text);
#endif
  for (i=0; i<=textlen/2; i++)
  {
    checkfunction(true,text,i,text+i,textlen-i);
  }
  return textlen/2+1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq %rsi, %r15
shrq %r15
incq %r15
xorl %r13d, %r13d
leaq (%r12,%r13), %rcx
movl $0x1, %edi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %r8
callq *%rbx
incq %r13
decq %r14
cmpq %r13, %r15
jne 0x20a4fa
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq