LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_clone
GtSuffixsortspace *gt_suffixsortspace_clone(GtSuffixsortspace *sssp,
                                            unsigned int clonenumber,
                                            GtLogger *logger)
{
  bool useuint;
  void *tab2clone;
  GtSuffixsortspace *cloned_sssp;

  gt_assert(sssp != NULL);
  useuint = sssp->uinttab != NULL ? true : false;
  tab2clone = useuint ? (void *) sssp->uinttab
                      : (void *) sssp->ulongtab;
  gt_assert(tab2clone != NULL);
  cloned_sssp = gt_suffixsortspace_new_generic(sssp->maxindex + 1,
                                               sssp->maxvalue,
                                               useuint,
                                               tab2clone,
                                               logger);
  gt_assert(clonenumber > 0);
  cloned_sssp->clonenumber = clonenumber;
  cloned_sssp->partoffset = sssp->partoffset;
  return cloned_sssp;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1af47c
movq %rdx, %r8
movl %esi, %ebp
movq %rdi, %rbx
movq 0x58(%rdi), %rax
movq %rax, %rcx
testq %rax, %rax
jne 0x1af44e
movq 0x50(%rbx), %rcx
testq %rcx, %rcx
je 0x1af4d8
xorl %edx, %edx
testq %rax, %rax
setne %dl
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
incq %rdi
callq 0x1af28f
testl %ebp, %ebp
je 0x1af4aa
movl %ebp, 0x4(%rax)
movq 0x38(%rbx), %rcx
movq %rcx, 0x38(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x288ae5(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x135b86(%rip), %rsi    # 0x2e5013
leaq 0x1abf41(%rip), %rdx    # 0x35b3d5
leaq 0x1abf47(%rip), %rcx    # 0x35b3e2
leaq 0x1abf16(%rip), %r8     # 0x35b3b8
movl $0xb1, %r9d
jmp 0x1af504
movq 0x288ab7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x135b58(%rip), %rsi    # 0x2e5013
leaq 0x1abf4b(%rip), %rdx    # 0x35b40d
leaq 0x1abf19(%rip), %rcx    # 0x35b3e2
leaq 0x1abee8(%rip), %r8     # 0x35b3b8
movl $0xbb, %r9d
jmp 0x1af504
movq 0x288a89(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x135b2a(%rip), %rsi    # 0x2e5013
leaq 0x1abf0b(%rip), %rdx    # 0x35b3fb
leaq 0x1abeeb(%rip), %rcx    # 0x35b3e2
leaq 0x1abeba(%rip), %r8     # 0x35b3b8
movl $0xb5, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_delete
void gt_suffixsortspace_delete(GtSuffixsortspace *suffixsortspace,
                               bool checklongestdefined)
{
  if (suffixsortspace != NULL)
  {
    if (checklongestdefined && !suffixsortspace->longestidx.defined)
    {
      fprintf(stderr,"%s, l. %d: longest is not defined\n",__FILE__,__LINE__);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
    if (suffixsortspace->clonenumber == 0)
    {
      gt_free(suffixsortspace->uinttab);
      gt_free(suffixsortspace->ulongtab);
    }
    gt_free(suffixsortspace);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1af571
movq %rdi, %rbx
testb %sil, %sil
je 0x1af527
cmpb $0x0, 0x8(%rbx)
je 0x1af579
cmpl $0x0, 0x4(%rbx)
jne 0x1af556
movq 0x58(%rbx), %rdi
leaq 0x1abe80(%rip), %r14    # 0x35b3b8
movq %r14, %rsi
movl $0xcd, %edx
callq 0x936f9
movq 0x50(%rbx), %rdi
movq %r14, %rsi
movl $0xce, %edx
callq 0x936f9
leaq 0x1abe5b(%rip), %rsi    # 0x35b3b8
movq %rbx, %rdi
movl $0xd0, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2889e8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1abe93(%rip), %rsi    # 0x35b41d
leaq 0x1abe27(%rip), %rdx    # 0x35b3b8
movl $0xc8, %ecx
xorl %eax, %eax
callq 0x17a50
pushq $0x2
popq %rdi
callq 0x178f0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_getdirect
GtUword gt_suffixsortspace_getdirect(const GtSuffixsortspace *sssp,GtUword idx)
{
  gt_assert(sssp != NULL && idx <= sssp->maxindex);
  if (sssp->ulongtab != NULL)
  {
    return sssp->ulongtab[idx];
  }
  gt_assert(sssp->uinttab != NULL);
  return (GtUword) sssp->uinttab[idx];
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1af61b
cmpq %rsi, 0x28(%rdi)
jb 0x1af61b
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x1af60d
movq (%rax,%rsi,8), %rax
jmp 0x1af619
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x1af653
movl (%rax,%rsi,4), %eax
popq %rcx
retq
movq 0x288946(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1359e7(%rip), %rsi    # 0x2e5013
leaq 0x1abe6c(%rip), %rdx    # 0x35b49f
leaq 0x1abe8b(%rip), %rcx    # 0x35b4c5
leaq 0x1abd77(%rip), %r8     # 0x35b3b8
movl $0xdb, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x28890e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1359af(%rip), %rsi    # 0x2e5013
leaq 0x1abe77(%rip), %rdx    # 0x35b4e2
leaq 0x1abe53(%rip), %rcx    # 0x35b4c5
leaq 0x1abd3f(%rip), %r8     # 0x35b3b8
movl $0xe0, %r9d
jmp 0x1af647
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_showrange
void gt_suffixsortspace_showrange(const GtSuffixsortspace *sssp,
                                  GtUword subbucketleft,
                                  GtUword width)
{
  GtUword idx;

  gt_assert(sssp != NULL);
  printf(GT_WU","GT_WU"=",sssp->bucketleftidx+subbucketleft-sssp->partoffset,
                    sssp->bucketleftidx+subbucketleft+width-1-sssp->partoffset);
  for (idx=sssp->bucketleftidx+subbucketleft-sssp->partoffset;
       idx<sssp->bucketleftidx+subbucketleft+width-sssp->partoffset;
       idx++)
  {
    printf(" "GT_WU, gt_suffixsortspace_getdirect(sssp,idx));
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1af763
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x40(%rdi), %rax
addq %rsi, %rax
movq 0x38(%rdi), %rdx
movq %rax, %rsi
subq %rdx, %rsi
addq %rbx, %rax
notq %rdx
addq %rax, %rdx
leaq 0x1abe2f(%rip), %rdi    # 0x35b536
xorl %eax, %eax
callq 0x17070
movq 0x38(%r14), %rax
movq 0x40(%r14), %rcx
leaq (%rcx,%r12), %r15
subq %rax, %r15
addq %r12, %rbx
leaq 0x1a11a4(%rip), %r12    # 0x3508cb
addq %rbx, %rcx
subq %rax, %rcx
cmpq %rcx, %r15
jae 0x1af757
movq %r14, %rdi
movq %r15, %rsi
callq 0x1af5f2
movq %r12, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x17070
incq %r15
movq 0x38(%r14), %rax
movq 0x40(%r14), %rcx
jmp 0x1af727
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x2887fe(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x13589f(%rip), %rsi    # 0x2e5013
leaq 0x1abc5a(%rip), %rdx    # 0x35b3d5
leaq 0x1abd97(%rip), %rcx    # 0x35b519
leaq 0x1abc2f(%rip), %r8     # 0x35b3b8
movl $0x106, %r9d            # imm = 0x106
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_exportptr
GtSuffixsortspace_exportptr *gt_suffixsortspace_exportptr(
                                  GtSuffixsortspace *sssp,
                                  GtUword subbucketleft)
{
  gt_assert(sssp != NULL);
  if (sssp->ulongtab != NULL)
  {
    sssp->exportptr.ulongtabsectionptr = sssp->ulongtab + sssp->bucketleftidx
                                                        + subbucketleft
                                                        - sssp->partoffset;
    sssp->exportptr.uinttabsectionptr = NULL;
  } else
  {
    gt_assert(sssp->uinttab != NULL);
    sssp->exportptr.uinttabsectionptr = sssp->uinttab + sssp->bucketleftidx
                                                      + subbucketleft
                                                      - sssp->partoffset;
    sssp->exportptr.ulongtabsectionptr = NULL;
  }
  sssp->currentexport = true;
  return &sssp->exportptr;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1af803
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x1af7cb
movq 0x38(%rdi), %rcx
movq 0x40(%rdi), %rdx
leaq (%rax,%rdx,8), %rax
leaq (%rax,%rsi,8), %rdx
shlq $0x3, %rcx
subq %rcx, %rdx
leaq 0x18(%rdi), %rax
movq %rdx, 0x20(%rdi)
jmp 0x1af7f3
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x1af831
movq 0x38(%rdi), %rcx
movq 0x40(%rdi), %rdx
leaq (%rax,%rdx,4), %rax
leaq (%rax,%rsi,4), %rax
shlq $0x2, %rcx
subq %rcx, %rax
movq %rax, 0x18(%rdi)
leaq 0x20(%rdi), %rax
andq $0x0, (%rax)
movb $0x1, (%rdi)
addq $0x18, %rdi
movq %rdi, %rax
popq %rcx
retq
movq 0x28875e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1357ff(%rip), %rsi    # 0x2e5013
leaq 0x1abbba(%rip), %rdx    # 0x35b3d5
leaq 0x1abd1d(%rip), %rcx    # 0x35b53f
leaq 0x1abb8f(%rip), %r8     # 0x35b3b8
movl $0x115, %r9d            # imm = 0x115
jmp 0x1af85d
movq 0x288730(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1357d1(%rip), %rsi    # 0x2e5013
leaq 0x1abc99(%rip), %rdx    # 0x35b4e2
leaq 0x1abcef(%rip), %rcx    # 0x35b53f
leaq 0x1abb61(%rip), %r8     # 0x35b3b8
movl $0x11e, %r9d            # imm = 0x11E
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_export_done
void gt_suffixsortspace_export_done (GtSuffixsortspace *sssp)
{
  gt_assert(sssp != NULL);
  sssp->exportptr.ulongtabsectionptr = NULL;
  sssp->exportptr.uinttabsectionptr = NULL;
  sssp->currentexport = false;
}

// Assembly:
testq %rdi, %rdi
je 0x1af879
movb $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
retq
pushq %rax
movq 0x2886e7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x135788(%rip), %rsi    # 0x2e5013
leaq 0x1abb43(%rip), %rdx    # 0x35b3d5
leaq 0x1abcc3(%rip), %rcx    # 0x35b55c
leaq 0x1abb18(%rip), %r8     # 0x35b3b8
movl $0x12a, %r9d            # imm = 0x12A
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_get
GtUword gt_suffixsortspace_get (const GtSuffixsortspace *sssp,
                                GtUword subbucketleft,
                                GtUword idx)
{
  gt_assert(sssp != NULL);
  return gt_suffixsortspace_getdirect(sssp, sssp->bucketleftidx
                                              + subbucketleft
                                              + idx
                                              - sssp->partoffset);
}

// Assembly:
testq %rdi, %rdi
je 0x1af8ca
addq %rsi, %rdx
addq 0x40(%rdi), %rdx
subq 0x38(%rdi), %rdx
movq %rdx, %rsi
jmp 0x1af5f2
pushq %rax
movq 0x288696(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x135737(%rip), %rsi    # 0x2e5013
leaq 0x1abaf2(%rip), %rdx    # 0x35b3d5
leaq 0x1abc91(%rip), %rcx    # 0x35b57b
leaq 0x1abac7(%rip), %r8     # 0x35b3b8
movl $0x134, %r9d            # imm = 0x134
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1af92c
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x1af929
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
movq 0x288634(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1356d5(%rip), %rsi    # 0x2e5013
leaq 0x1aba90(%rip), %rdx    # 0x35b3d5
leaq 0x1abc46(%rip), %rcx    # 0x35b592
leaq 0x1aba65(%rip), %r8     # 0x35b3b8
movl $0x13e, %r9d            # imm = 0x13E
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1af98e
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x1af98b
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
movq 0x2885d2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x135673(%rip), %rsi    # 0x2e5013
leaq 0x1aba2e(%rip), %rdx    # 0x35b3d5
leaq 0x1abc04(%rip), %rcx    # 0x35b5b2
leaq 0x1aba03(%rip), %r8     # 0x35b3b8
movl $0x14c, %r9d            # imm = 0x14C
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1af9fd
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 0x1afa2b
movq %rdx, %rsi
movq %rcx, %rdx
popq %rax
jmp 0x1afa63
movq 0x288564(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x135605(%rip), %rsi    # 0x2e5013
leaq 0x1ab9c0(%rip), %rdx    # 0x35b3d5
leaq 0x1abbb7(%rip), %rcx    # 0x35b5d3
leaq 0x1ab995(%rip), %r8     # 0x35b3b8
movl $0x15e, %r9d            # imm = 0x15E
jmp 0x1afa57
movq 0x288536(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1355d7(%rip), %rsi    # 0x2e5013
leaq 0x1abba7(%rip), %rdx    # 0x35b5ea
leaq 0x1abb89(%rip), %rcx    # 0x35b5d3
leaq 0x1ab967(%rip), %r8     # 0x35b3b8
movl $0x162, %r9d            # imm = 0x162
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1afaaf
cmpq %rsi, 0x28(%rdi)
jb 0x1afaaf
cmpq %rdx, 0x30(%rdi)
jb 0x1afaaf
testq %rdx, %rdx
jne 0x1afa89
movb $0x1, 0x8(%rdi)
movq 0x38(%rdi), %rax
addq %rsi, %rax
movq %rax, 0x10(%rdi)
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x1afa98
movq %rdx, (%rax,%rsi,8)
jmp 0x1afaad
movq %rdx, %rax
shrq $0x20, %rax
jne 0x1afae7
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x1afae7
movl %edx, (%rax,%rsi,4)
popq %rax
retq
movq 0x2884b2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x135553(%rip), %rsi    # 0x2e5013
leaq 0x1ac009(%rip), %rdx    # 0x35bad0
leaq 0x1ac043(%rip), %rcx    # 0x35bb11
leaq 0x1ab8e3(%rip), %r8     # 0x35b3b8
movl $0xf0, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x28847a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x13551b(%rip), %rsi    # 0x2e5013
leaq 0x1ac02f(%rip), %rdx    # 0x35bb2e
leaq 0x1ac00b(%rip), %rcx    # 0x35bb11
leaq 0x1ab8ab(%rip), %r8     # 0x35b3b8
movl $0xfb, %r9d
jmp 0x1afadb
// File: /workspace/github_c_makefile_star2_O2/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 0x1afbe8
cmpq %rsi, 0x40(%rdi)
je 0x1afbdf
cmpb $0x1, (%rdi)
je 0x1afbe8
movq %rsi, 0x40(%rdi)
movq %rdx, 0x48(%rdi)
retq
pushq %rax
movq 0x288378(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x135419(%rip), %rsi    # 0x2e5013
leaq 0x1aba7e(%rip), %rdx    # 0x35b67f
leaq 0x1abac6(%rip), %rcx    # 0x35b6ce
leaq 0x1ab7a9(%rip), %r8     # 0x35b3b8
movl $0x187, %r9d            # imm = 0x187
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1afcbe
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
leaq 0x1ab72a(%rip), %r14    # 0x35b3b8
movq %r14, %rsi
movl $0x19d, %edx            # imm = 0x19D
callq 0x936f9
andq $0x0, 0x50(%rbx)
movq 0x58(%rbx), %rdi
movq %r14, %rsi
movl $0x19f, %edx            # imm = 0x19F
callq 0x936f9
andq $0x0, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2882a3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x135344(%rip), %rsi    # 0x2e5013
leaq 0x1ab6ff(%rip), %rdx    # 0x35b3d5
leaq 0x1aba7f(%rip), %rcx    # 0x35b75c
leaq 0x1ab6d4(%rip), %r8     # 0x35b3b8
movl $0x19c, %r9d            # imm = 0x19C
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1afdfb
cmpl $0x2, %esi
jb 0x1afdfb
movq %rdi, %rbx
movq (%rdi), %rax
cmpl $0x0, 0x4(%rax)
jne 0x1afdfb
movl %esi, %r14d
pushq $0x1
popq %r15
xorl %eax, %eax
cmpq %r15, %r14
je 0x1afd94
movq (%rbx,%r15,8), %rdi
movl 0x4(%rdi), %ecx
cmpq %rcx, %r15
jne 0x1afd9f
movb $0x1, %bpl
testb $0x1, %al
jne 0x1afd81
cmpb $0x1, 0x8(%rdi)
jne 0x1afd72
movq 0x10(%rdi), %rax
movq %rax, %rcx
subq 0x38(%rdi), %rcx
jb 0x1afdcd
movq 0x50(%rdi), %rdx
testq %rdx, %rdx
je 0x1afd63
cmpq $0x0, (%rdx,%rcx,8)
je 0x1afd76
movq 0x58(%rdi), %rdx
testq %rdx, %rdx
je 0x1afd72
cmpl $0x0, (%rdx,%rcx,4)
je 0x1afd76
xorl %ebp, %ebp
jmp 0x1afd81
movq (%rbx), %rcx
movb $0x1, 0x8(%rcx)
movq %rax, 0x10(%rcx)
xorl %esi, %esi
callq 0x1af510
andq $0x0, (%rbx,%r15,8)
incq %r15
movl %ebp, %eax
jmp 0x1afd28
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x2881c2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x135263(%rip), %rsi    # 0x2e5013
leaq 0x1aba2a(%rip), %rdx    # 0x35b7e1
leaq 0x1aba02(%rip), %rcx    # 0x35b7c0
leaq 0x1ab5f3(%rip), %r8     # 0x35b3b8
movl $0x1ae, %r9d            # imm = 0x1AE
jmp 0x1afe27
movq 0x288194(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x135235(%rip), %rsi    # 0x2e5013
leaq 0x1aba13(%rip), %rdx    # 0x35b7f8
leaq 0x1ab9d4(%rip), %rcx    # 0x35b7c0
leaq 0x1ab5c5(%rip), %r8     # 0x35b3b8
movl $0x1b2, %r9d            # imm = 0x1B2
jmp 0x1afe27
movq 0x288166(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x135207(%rip), %rsi    # 0x2e5013
leaq 0x1ab96d(%rip), %rdx    # 0x35b780
leaq 0x1ab9a6(%rip), %rcx    # 0x35b7c0
leaq 0x1ab597(%rip), %r8     # 0x35b3b8
movl $0x1a9, %r9d            # imm = 0x1A9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1afeec
movq %rdi, %rcx
movq 0x50(%rsi), %rdi
testq %rdi, %rdi
je 0x1afeda
pushq $0x8
jmp 0x1afee5
movq 0x58(%rsi), %rdi
testq %rdi, %rdi
je 0x1aff1a
pushq $0x4
popq %rsi
popq %rax
jmp 0xb302c
movq 0x288075(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x135116(%rip), %rsi    # 0x2e5013
leaq 0x1ab4d1(%rip), %rdx    # 0x35b3d5
leaq 0x1ab9ac(%rip), %rcx    # 0x35b8b7
leaq 0x1ab4a6(%rip), %r8     # 0x35b3b8
movl $0x1d2, %r9d            # imm = 0x1D2
jmp 0x1aff46
movq 0x288047(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1350e8(%rip), %rsi    # 0x2e5013
leaq 0x1ab5b0(%rip), %rdx    # 0x35b4e2
leaq 0x1ab97e(%rip), %rcx    # 0x35b8b7
leaq 0x1ab478(%rip), %r8     # 0x35b3b8
movl $0x1d9, %r9d            # imm = 0x1D9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1aff82
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x1aff6d
movq %rsi, %rdi
movq %rax, %rsi
popq %rax
jmp 0x5dc98
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x1affb0
movq %rsi, %rdi
movq %rax, %rsi
popq %rax
jmp 0x5dc2c
movq 0x287fdf(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x135080(%rip), %rsi    # 0x2e5013
leaq 0x1ab43b(%rip), %rdx    # 0x35b3d5
leaq 0x1ab931(%rip), %rcx    # 0x35b8d2
leaq 0x1ab410(%rip), %r8     # 0x35b3b8
movl $0x1e3, %r9d            # imm = 0x1E3
jmp 0x1affdc
movq 0x287fb1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x135052(%rip), %rsi    # 0x2e5013
leaq 0x1ab51a(%rip), %rdx    # 0x35b4e2
leaq 0x1ab903(%rip), %rcx    # 0x35b8d2
leaq 0x1ab3e2(%rip), %r8     # 0x35b3b8
movl $0x1e9, %r9d            # imm = 0x1E9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1ab3c5(%rip), %rsi    # 0x35b3b8
pushq $0x20
popq %rdi
movl $0x223, %edx            # imm = 0x223
callq 0x93160
movq %rbx, 0x10(%rax)
andq $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b03af
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 0x1b0341
cmpq %r12, %r15
jae 0x1b0377
movq %r15, %rdx
notq %rdx
addq %r12, %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0x1afa63
incq %r14
pushq $-0x1
popq %rax
cmpq 0x10(%rsp), %r15
jne 0x1b035a
jmp 0x1b035f
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1afa63
incq %r14
pushq $0x1
popq %rax
cmpq %rbx, %r15
je 0x1b035f
addq %rax, %r15
jmp 0x1b0314
movq 0x8(%rsp), %rax
movq %r14, 0x18(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x287bea(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x134c8b(%rip), %rsi    # 0x2e5013
leaq 0x1ab7fe(%rip), %rdx    # 0x35bb8d
leaq 0x1ab7cd(%rip), %rcx    # 0x35bb63
leaq 0x1ab01b(%rip), %r8     # 0x35b3b8
movl $0x204, %r9d            # imm = 0x204
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x287bb2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x134c53(%rip), %rsi    # 0x2e5013
leaq 0x1a722f(%rip), %rdx    # 0x3575f6
leaq 0x1ab795(%rip), %rcx    # 0x35bb63
leaq 0x1aafe3(%rip), %r8     # 0x35b3b8
movl $0x1f8, %r9d            # imm = 0x1F8
jmp 0x1b03a3
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-suftaborder.c
// Function: showcomparisonfailure
static void showcomparisonfailure(const char *filename,
                                  int line,
                                  const char *where,
                                  const GtEncseq *encseq,
                                  GtReadmode readmode,
                                  const GtSuffixsortspace *suffixsortspace,
                                  GtUword subbucketleft,
                                  GtUword depth,
                                  GtUword idx1,
                                  GtUword idx2,
                                  int cmp,
                                  GtUword maxlcp)
{
  GtUword pos1, pos2;

  pos1 = gt_suffixsortspace_get(suffixsortspace,subbucketleft,idx1);
  pos2 = gt_suffixsortspace_get(suffixsortspace,subbucketleft,idx2);
  fprintf(stderr,"ERROR: file \"%s\", line %d: ",filename,line);
  fprintf(stderr,"%s("GT_WU" vs "GT_WU""
                 " "GT_WU"=\"",
                       where,
                       idx1,
                       idx2,
                       pos1);
  gt_encseq_showatstartposwithdepth(stderr,encseq,readmode,pos1,depth);
  fprintf(stderr,"\",\"");
  gt_encseq_showatstartposwithdepth(stderr,encseq,readmode,pos2,depth);
  fprintf(stderr,"\"="GT_WU")=%d with maxlcp "GT_WU",depth="GT_WU"\n",pos2,cmp,
          maxlcp,depth);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r13
movl %r8d, 0x10(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %esi, 0xc(%rsp)
movq %rdi, 0x18(%rsp)
movl 0x90(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x78(%rsp), %r15
movq 0x88(%rsp), %rbx
movq 0x70(%rsp), %r12
movq 0x80(%rsp), %rbp
movq %r9, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x1af8b2
movq %rax, %r14
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x1af8b2
movq %rax, %r13
movq 0x28795d(%rip), %r12    # 0x437f68
movq (%r12), %rdi
leaq 0x1498b0(%rip), %rsi    # 0x2f9ec6
movq 0x18(%rsp), %rdx
movl 0xc(%rsp), %ecx
xorl %eax, %eax
callq 0x17a50
movq (%r12), %rdi
leaq 0x1498b1(%rip), %rsi    # 0x2f9ee2
movq 0x20(%rsp), %rdx
movq %rbp, %rcx
movq %rbx, %r8
movq %r14, %r9
xorl %eax, %eax
callq 0x17a50
movq (%r12), %rdi
movq 0x28(%rsp), %rbp
movq %rbp, %rsi
movl 0x10(%rsp), %ebx
movl %ebx, %edx
movq %r14, %rcx
movq %r15, %r8
callq 0x77abf
movq (%r12), %rcx
leaq 0x149888(%rip), %rdi    # 0x2f9ef6
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
callq 0x17f00
movq (%r12), %rdi
movq %rbp, %rsi
movl %ebx, %edx
movq %r13, %rcx
movq %r15, %r8
callq 0x77abf
movq (%r12), %rdi
leaq 0x1ab5b6(%rip), %rsi    # 0x35bc4e
movq %r13, %rdx
movl 0x14(%rsp), %ecx
movq 0x30(%rsp), %r8
movq %r15, %r9
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17a50
// File: /workspace/github_c_makefile_star2_O2/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 0x7055e
movq %rax, %r13
xorl %ebx, %ebx
cmpq %r13, %rbx
ja 0x1b073b
movq %r15, %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x1af8b2
movq %rax, %r14
leaq 0x1ab4d5(%rip), %rdi    # 0x35bbda
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x17070
movq 0x287797(%rip), %rax    # 0x437eb0
movq (%rax), %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq 0x10(%rsp), %r8
callq 0x77abf
pushq $0xa
popq %rdi
callq 0x179c0
incq %rbx
jmp 0x1b06e6
addq $0x18, %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/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1aa568(%rip), %r12    # 0x35beec
leaq 0x1aa567(%rip), %r13    # 0x35bef2
xorl %r15d, %r15d
cmpq (%rbx), %r15
jae 0x1b19e9
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0xae386
leaq 0x1aa653(%rip), %rdi    # 0x35bff9
movq %rax, %rsi
xorl %eax, %eax
callq 0x17070
xorl %ebp, %ebp
cmpq (%rbx), %rbp
jae 0x1b19dc
cmpq %rbp, %r15
jne 0x1b19c4
xorps %xmm0, %xmm0
movq %r12, %rdi
jmp 0x1b19d0
movq (%r14,%r15,8), %rax
movsd (%rax,%rbp,8), %xmm0
movq %r13, %rdi
movb $0x1, %al
callq 0x17070
incq %rbp
jmp 0x1b19b2
pushq $0xa
popq %rdi
callq 0x179c0
incq %r15
jmp 0x1b198e
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/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 0x1b21dc
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
leaq 0x1a9e50(%rip), %r14    # 0x35bfff
movq %r14, %rsi
movl $0xca, %edx
callq 0x936f9
movq 0x10(%rbx), %rdi
callq 0xae662
movq %rbx, %rdi
movq %r14, %rsi
movl $0xcc, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1a9e13(%rip), %rsi    # 0x35bfff
pushq $0x30
popq %rdi
movl $0xdf, %edx
callq 0x93160
movq %rax, %rbx
andq $0x0, 0x20(%rax)
andq $0x0, 0x10(%rax)
andq $0x0, (%rax)
movq %r14, %rdi
callq 0x79eb4
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x75d3b
movq %rax, 0x18(%rbx)
movq %r14, 0x28(%rbx)
movq 0x8(%rbx), %rax
movq %rax, (%rbx)
callq 0xae154
movq %rax, 0x10(%rbx)
xorl %r14d, %r14d
cmpq 0x8(%rbx), %r14
jae 0x1b225f
movq 0x10(%rbx), %r15
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xae3f2
movq %r15, %rdi
movq %rax, %rsi
callq 0xae31d
incq %r14
jmp 0x1b2239
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b22c6
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)
movabsq $0x10, %rax
cmpq $0x29, %rax
jae 0x1b2338
movq -0x70(%rsp), %rcx
leal 0x8(%rax), %edx
movl %edx, -0x80(%rsp)
movq (%rcx,%rax), %rcx
movq %rcx, 0x10(%rdi)
cmpl $0x21, %eax
jae 0x1b234d
movq -0x70(%rsp), %rdx
movq %rax, %rcx
addq $0x10, %rcx
movl %ecx, -0x80(%rsp)
movq 0x8(%rdx,%rax), %rdx
movq %rdx, (%rdi)
cmpl $0x18, %eax
ja 0x1b2361
addq -0x70(%rsp), %rcx
addl $0x18, %eax
movl %eax, -0x80(%rsp)
jmp 0x1b236f
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq %rax, 0x10(%rdi)
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq %rax, (%rdi)
movq -0x78(%rsp), %rcx
leaq 0x8(%rcx), %rax
movq %rax, -0x78(%rsp)
movq (%rcx), %rax
movq %rax, 0x8(%rdi)
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b23fa
testq %rdx, %rdx
je 0x1b2428
cmpb $0x0, (%r8)
je 0x1b2456
movq (%rdi), %r8
decq %rdx
movl %edx, %ecx
shlq %cl, %r8
movb $0x1, %cl
testq %r8, %r8
jns 0x1b23f6
movq 0x10(%rdi), %rcx
cmpb %al, (%rcx,%rdx)
sete %cl
movb %cl, (%rsi)
popq %rax
retq
movq 0x285b67(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x132c08(%rip), %rsi    # 0x2e5013
leaq 0x18fbfc(%rip), %rdx    # 0x34200e
leaq 0x1a9d65(%rip), %rcx    # 0x35c17e
leaq 0x1a9d45(%rip), %r8     # 0x35c165
movl $0x91, %r9d
jmp 0x1b2482
movq 0x285b39(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x132bda(%rip), %rsi    # 0x2e5013
leaq 0x1a9d53(%rip), %rdx    # 0x35c193
leaq 0x1a9d37(%rip), %rcx    # 0x35c17e
leaq 0x1a9d17(%rip), %r8     # 0x35c165
movl $0x92, %r9d
jmp 0x1b2482
movq 0x285b0b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x132bac(%rip), %rsi    # 0x2e5013
leaq 0x1a9d36(%rip), %rdx    # 0x35c1a4
leaq 0x1a9d09(%rip), %rcx    # 0x35c17e
leaq 0x1a9ce9(%rip), %r8     # 0x35c165
movl $0x93, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1b24ba
testq %rdx, %rdx
je 0x1b24e8
movq (%rdi), %r8
decq %rdx
movl %edx, %ecx
shlq %cl, %r8
movb $0x1, %cl
testq %r8, %r8
jns 0x1b24b6
movq 0x10(%rdi), %rcx
cmpb %al, (%rcx,%rdx)
sete %cl
movb %cl, (%rsi)
popq %rax
retq
movq 0x285aa7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x132b48(%rip), %rsi    # 0x2e5013
leaq 0x18fb3c(%rip), %rdx    # 0x34200e
leaq 0x1a9cde(%rip), %rcx    # 0x35c1b7
leaq 0x1a9c85(%rip), %r8     # 0x35c165
movl $0xa3, %r9d
jmp 0x1b2514
movq 0x285a79(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x132b1a(%rip), %rsi    # 0x2e5013
leaq 0x1a9c93(%rip), %rdx    # 0x35c193
leaq 0x1a9cb0(%rip), %rcx    # 0x35c1b7
leaq 0x1a9c57(%rip), %r8     # 0x35c165
movl $0xa4, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1a9c95(%rip), %rsi    # 0x35c1d3
pushq $0x28
popq %rdi
pushq $0x20
popq %rdx
callq 0x93160
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x1b25ee
movq %rax, %r13
movq %r15, %rdi
callq 0x9580f
cmpl %ebp, %eax
jae 0x1b2595
movl %eax, %r12d
leaq 0x1a9c77(%rip), %rsi    # 0x35c1e9
movq (%rsp), %rdi
movq %rbx, %rdx
movl %eax, %ecx
movq %r13, %r8
xorl %eax, %eax
callq 0x92e71
movq %rbx, %rdi
movl %r12d, %esi
callq 0x6ba08
movb $0x1, %r12b
jmp 0x1b25c8
leaq 0x1a9c9b(%rip), %rsi    # 0x35c237
xorl %r12d, %r12d
movq (%rsp), %rdi
movq %rbx, %rdx
movl %ebp, %ecx
movq %r13, %r8
xorl %eax, %eax
callq 0x92e71
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6ba08
pushq $-0x1
popq %r15
movl %ebp, %ecx
shlq %cl, %r15
notq %r15
movq %rax, 0x20(%r14)
movb %r12b, 0x18(%r14)
movq %r15, 0x10(%r14)
andq $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_O2/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 0x9580f
cmpl %ebx, %eax
cmovbl %eax, %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x6baf6
addq $0x28, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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)
jae 0x1b30bf
movq (%rbx), %rax
jmp 0x1b30e2
addq $0x20, %rax
movq %rax, 0x10(%rbx)
movq (%rbx), %rdi
imulq $0x18, %rax, %rsi
leaq 0x1a91ba(%rip), %rdx    # 0x35c28f
movl $0xcb, %ecx
callq 0x93472
movq %rax, (%rbx)
testq %rax, %rax
je 0x1b3118
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
imulq $0x18, %rcx, %rcx
movups 0x10(%r14), %xmm0
movups %xmm0, (%rax,%rcx)
movq 0x18(%rbx), %rdx
leaq 0x8(%rdx), %rsi
cmpq %rsi, (%rdx)
setne 0x10(%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x284e49(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x131eea(%rip), %rsi    # 0x2e5013
leaq 0x1a927c(%rip), %rdx    # 0x35c3ac
leaq 0x1a9266(%rip), %rcx    # 0x35c39d
leaq 0x1a9151(%rip), %r8     # 0x35c28f
movl $0xcb, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x18a3f7(%rip), %rdi    # 0x33da46
movq %r14, %rsi
xorl %eax, %eax
callq 0x17070
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x160a31
testb %al, %al
je 0x1b36a5
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x16020b
movq %rax, %rbx
leaq 0x19d245(%rip), %r14    # 0x3508cb
xorl %r15d, %r15d
cmpq 0x10(%rbx), %r15
jae 0x1b36a5
movq (%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x17070
incq %r15
jmp 0x1b3689
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x179c0