LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2e9f8d
movq 0x352044(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x22c0ad(%rip), %rsi    # 0x516013
leaq 0x2a06c6(%rip), %rdx    # 0x58a633
leaq 0x2a421c(%rip), %rcx    # 0x58e190
leaq 0x2a4048(%rip), %r8     # 0x58dfc3
movl $0x13e, %r9d            # imm = 0x13E
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2e9f8f
movq 0x8(%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x2e9fd8
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x40(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq (%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
subq 0x38(%rdx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0x2e9fe1
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2ea03d
movq 0x351f94(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x22bffd(%rip), %rsi    # 0x516013
leaq 0x2a0616(%rip), %rdx    # 0x58a633
leaq 0x2a418c(%rip), %rcx    # 0x58e1b0
leaq 0x2a3f98(%rip), %r8     # 0x58dfc3
movl $0x14c, %r9d            # imm = 0x14C
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ea03f
movq 0x8(%rsp), %rax
cmpq $0x0, 0x58(%rax)
je 0x2ea088
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x40(%rcx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq (%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
subq 0x38(%rdx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0x2ea091
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x2ea0f8
movq 0x351ed9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x22bf42(%rip), %rsi    # 0x516013
leaq 0x2a055b(%rip), %rdx    # 0x58a633
leaq 0x2a40f2(%rip), %rcx    # 0x58e1d1
leaq 0x2a3edd(%rip), %r8     # 0x58dfc3
movl $0x15e, %r9d            # imm = 0x15E
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ea0fa
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
addq 0x18(%rsp), %rax
addq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
subq 0x38(%rcx), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x2ea179
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x40(%rcx), %rcx
movq 0x20(%rsp), %rdx
addq 0x48(%rdx), %rcx
cmpq %rcx, %rax
jb 0x2ea179
movq 0x351e58(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x22bec1(%rip), %rsi    # 0x516013
leaq 0x2a408f(%rip), %rdx    # 0x58e1e8
leaq 0x2a4071(%rip), %rcx    # 0x58e1d1
leaq 0x2a3e5c(%rip), %r8     # 0x58dfc3
movl $0x162, %r9d            # imm = 0x162
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ea17b
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2ea1a0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2ea1d9
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x28(%rcx), %rax
ja 0x2ea1d9
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jbe 0x2ea211
movq 0x351dc0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x22be29(%rip), %rsi    # 0x516013
leaq 0x2a44e6(%rip), %rdx    # 0x58e6d7
leaq 0x2a4520(%rip), %rcx    # 0x58e718
leaq 0x2a3dc4(%rip), %r8     # 0x58dfc3
movl $0xf0, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ea213
cmpq $0x0, (%rsp)
jne 0x2ea23a
movq 0x10(%rsp), %rax
movb $0x1, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rcx
addq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x2ea25e
movq (%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x2ea2c8
jmp 0x2ea260
movq 0x10(%rsp), %rax
cmpq $0x0, 0x58(%rax)
je 0x2ea277
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, (%rsp)
jbe 0x2ea2af
movq 0x351d22(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x22bd8b(%rip), %rsi    # 0x516013
leaq 0x2a44a6(%rip), %rdx    # 0x58e735
leaq 0x2a4482(%rip), %rcx    # 0x58e718
leaq 0x2a3d26(%rip), %r8     # 0x58dfc3
movl $0xfb, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ea2b1
movq (%rsp), %rax
movl %eax, %edx
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x8(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x2ea564
movq 0x351a6d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x22bad6(%rip), %rsi    # 0x516013
leaq 0x2a00ef(%rip), %rdx    # 0x58a633
leaq 0x2a3e0f(%rip), %rcx    # 0x58e35a
leaq 0x2a3a71(%rip), %r8     # 0x58dfc3
movl $0x19c, %r9d            # imm = 0x19C
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ea566
movq (%rsp), %rax
movq 0x50(%rax), %rdi
leaq 0x2a3a4e(%rip), %rsi    # 0x58dfc3
movl $0x19d, %edx            # imm = 0x19D
callq 0xe88c0
movq (%rsp), %rax
movq $0x0, 0x50(%rax)
movq (%rsp), %rax
movq 0x58(%rax), %rdi
leaq 0x2a3a29(%rip), %rsi    # 0x58dfc3
movl $0x19f, %edx            # imm = 0x19F
callq 0xe88c0
movq (%rsp), %rax
movq $0x0, 0x58(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2ea8d2
movq 0x3516ff(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x22b768(%rip), %rsi    # 0x516013
leaq 0x29fd81(%rip), %rdx    # 0x58a633
leaq 0x2a3bfc(%rip), %rcx    # 0x58e4b5
leaq 0x2a3703(%rip), %r8     # 0x58dfc3
movl $0x1d2, %r9d            # imm = 0x1D2
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ea8d4
movq 0x8(%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x2ea8fe
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rdi
movq (%rsp), %rdx
movq 0x10(%rsp), %rcx
movl $0x8, %esi
callq 0x126d30
jmp 0x2ea962
jmp 0x2ea900
movq 0x8(%rsp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x2ea944
movq 0x35168d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x22b6f6(%rip), %rsi    # 0x516013
leaq 0x2a37bc(%rip), %rdx    # 0x58e0e0
leaq 0x2a3b8a(%rip), %rcx    # 0x58e4b5
leaq 0x2a3691(%rip), %r8     # 0x58dfc3
movl $0x1d9, %r9d            # imm = 0x1D9
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ea946
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rdi
movq (%rsp), %rdx
movq 0x10(%rsp), %rcx
movl $0x4, %esi
callq 0x126d30
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2ea9c2
movq 0x35160f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x22b678(%rip), %rsi    # 0x516013
leaq 0x29fc91(%rip), %rdx    # 0x58a633
leaq 0x2a3b27(%rip), %rcx    # 0x58e4d0
leaq 0x2a3613(%rip), %r8     # 0x58dfc3
movl $0x1e3, %r9d            # imm = 0x1E3
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ea9c4
movq 0x10(%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x2ea9e9
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rsi
movq (%rsp), %rdx
callq 0x892f0
jmp 0x2eaa48
jmp 0x2ea9eb
movq 0x10(%rsp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x2eaa2f
movq 0x3515a2(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x22b60b(%rip), %rsi    # 0x516013
leaq 0x2a36d1(%rip), %rdx    # 0x58e0e0
leaq 0x2a3aba(%rip), %rcx    # 0x58e4d0
leaq 0x2a35a6(%rip), %r8     # 0x58dfc3
movl $0x1e9, %r9d            # imm = 0x1E9
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2eaa31
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rsi
movq (%rsp), %rdx
callq 0x89240
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x20, %edi
leaq 0x2a355e(%rip), %rsi    # 0x58dfc3
movl $0x223, %edx            # imm = 0x223
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_SSSPbuf_insertfullspecialrange
static void gt_SSSPbuf_insertfullspecialrange(GtSuffixsortspace *sssp,
                                              GtReadmode readmode,
                                              GtSSSPbuf *sssp_buf,
                                              GtUword totallength,
                                              GtUword leftpos,
                                              GtUword rightpos)
{
  gt_assert(sssp_buf != NULL);
  sssp_buf->nextfree
    = gt_suffixsortspace_insertfullspecialrange(sssp,
                                                readmode,
                                                sssp_buf->nextfree,
                                                totallength,
                                                leftpos,
                                                rightpos);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x2eb091
movq 0x350f40(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x22afa9(%rip), %rsi    # 0x516013
leaq 0x2a3485(%rip), %rdx    # 0x58e4f6
leaq 0x2a36f2(%rip), %rcx    # 0x58e76a
leaq 0x2a2f44(%rip), %r8     # 0x58dfc3
movl $0x240, %r9d            # imm = 0x240
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2eb093
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
callq 0x2eb110
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_overflow_abort
static void gt_suffixsortspace_overflow_abort(GT_UNUSED const char *f,
                                              GT_UNUSED int l,
                                              void *data)
{
  fprintf(stderr, "error: overflow detected while calculating size of "
                  "suffix sorting space: "GT_WU" * "GT_WU" bytes is too large "
                  "for " "the current platform, please recompile GenomeTools "
                  "with support for a larger address space to prevent this "
                  "(e.g. 64 bit instead of 32 bit) or use the `-parts' "
                  "option.\n",
                  (GtUword) sizeof (GtUword),
                  *(GtUword*) data);
  exit(GT_EXIT_PROGRAMMING_ERROR);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq %rdx, (%rsp)
movq 0x350eb8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq (%rsp), %rax
movq (%rax), %rcx
leaq 0x2a34cc(%rip), %rsi    # 0x58e5c5
movl $0x8, %edx
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jb 0x2eb175
movq 0x350e5c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x22aec5(%rip), %rsi    # 0x516013
leaq 0x29eee0(%rip), %rdx    # 0x58a035
leaq 0x2a3630(%rip), %rcx    # 0x58e78c
leaq 0x2a2e60(%rip), %r8     # 0x58dfc3
movl $0x1f8, %r9d            # imm = 0x1F8
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2eb177
cmpl $0x1, 0x2c(%rsp)
je 0x2eb185
cmpl $0x3, 0x2c(%rsp)
jne 0x2eb194
movq 0x8(%rsp), %rax
subq $0x1, %rax
movq %rax, (%rsp)
jmp 0x2eb19d
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
jmp 0x2eb19f
cmpl $0x1, 0x2c(%rsp)
je 0x2eb1b1
cmpl $0x3, 0x2c(%rsp)
jne 0x2eb23d
jmp 0x2eb1b3
movq (%rsp), %rax
cmpq 0x18(%rsp), %rax
jb 0x2eb1f6
movq 0x350ddb(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x22ae44(%rip), %rsi    # 0x516013
leaq 0x2a35e0(%rip), %rdx    # 0x58e7b6
leaq 0x2a35af(%rip), %rcx    # 0x58e78c
leaq 0x2a2ddf(%rip), %r8     # 0x58dfc3
movl $0x204, %r9d            # imm = 0x204
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2eb1f8
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
subq $0x1, %rdx
subq (%rsp), %rdx
callq 0x2ea1a0
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x2eb22f
jmp 0x2eb283
movq (%rsp), %rax
addq $-0x1, %rax
movq %rax, (%rsp)
jmp 0x2eb27e
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rsp), %rdx
callq 0x2ea1a0
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x2eb272
jmp 0x2eb283
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x2eb19f
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq 0x78(%rsp), %rax
movl 0x70(%rsp), %eax
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rax
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movq %r9, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x2e9ec0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0x2e9ec0
movq %rax, 0x8(%rsp)
movq 0x350a09(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x40(%rsp), %rdx
movl 0x3c(%rsp), %ecx
leaq 0x23fab2(%rip), %rsi    # 0x52b05c
movb $0x0, %al
callq 0x199f0
movq 0x3509e8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x30(%rsp), %rdx
movq 0x60(%rsp), %rcx
movq 0x68(%rsp), %r8
movq 0x10(%rsp), %r9
leaq 0x23faa2(%rip), %rsi    # 0x52b078
movb $0x0, %al
callq 0x199f0
movq 0x3509bc(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
movq 0x10(%rsp), %rcx
movq 0x58(%rsp), %r8
callq 0xb5850
movq 0x35099a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x23fa7c(%rip), %rsi    # 0x52b08c
movb $0x0, %al
callq 0x199f0
movq 0x350982(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
movq 0x8(%rsp), %rcx
movq 0x58(%rsp), %r8
callq 0xb5850
movq 0x350960(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
movl 0x70(%rsp), %ecx
movq 0x78(%rsp), %r8
movq 0x58(%rsp), %r9
leaq 0x2a31ec(%rip), %rsi    # 0x58e849
movb $0x0, %al
callq 0x199f0
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x40(%rsp), %rdi
callq 0xa9d00
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x8(%rsp), %rax
ja 0x2eb721
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x2e9ec0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x2a3129(%rip), %rdi    # 0x58e803
movb $0x0, %al
callq 0x19070
movq 0x350850(%rip), %rax    # 0x63bf38
movq (%rax), %rdi
movq 0x40(%rsp), %rsi
movl 0x3c(%rsp), %edx
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0xb5850
leaq 0x2a7b69(%rip), %rdi    # 0x593273
movb $0x0, %al
callq 0x19070
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2eb6a4
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0xc2ec0
andb $0x1, %al
movb %al, 0x17(%rsp)
testb $0x1, 0x17(%rsp)
je 0x2ebe85
movq 0x40(%rsp), %rdi
callq 0xa9d50
shrq %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
shlq %rdi
movl $0x8, %esi
leaq 0x2a2a0d(%rip), %rdx    # 0x58e881
movl $0x76, %ecx
callq 0xe83c0
movq %rax, 0x30(%rsp)
jmp 0x2ebeb4
movq 0x40(%rsp), %rdi
callq 0xa9d50
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x8, %esi
leaq 0x2a29dc(%rip), %rdx    # 0x58e881
movl $0x7b, %ecx
callq 0xe83c0
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2ebaf0
movq %rax, 0x28(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x2ebf0a
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
callq 0x2ebf80
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2ebecc
testb $0x1, 0x17(%rsp)
je 0x2ebf6c
movq 0x20(%rsp), %rax
shlq %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x2ebf6a
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x30(%rsp), %rax
movq 0x8(%rsp), %rcx
subq 0x18(%rsp), %rcx
subq $0x1, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2ebf27
jmp 0x2ebf6c
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/shu-encseq-gc.c
// Function: calculate_rel_gc
static inline void calculate_rel_gc(const GtEncseq *encseq,
                                    double *gc_content,
                                    GtUword seq_idx,
                                    GtUword gc_count)
{
  GtUword length;
  gt_assert(seq_idx < gt_encseq_num_of_sequences(encseq));
  length = gt_encseq_seqlength(encseq, seq_idx);
  gt_assert(gc_count <= length);
  gc_content[seq_idx] = (double) gc_count / (double) length;
  gt_assert(gt_double_compare(gc_content[seq_idx], 0.0) != -1);
  gt_assert(gt_double_compare(gc_content[seq_idx], 1.0) != 1);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0xa9d50
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x2ebff1
movq 0x34ffe0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x22a049(%rip), %rsi    # 0x516013
leaq 0x2a2930(%rip), %rdx    # 0x58e901
leaq 0x2a2956(%rip), %rcx    # 0x58e92e
leaq 0x2a28a2(%rip), %r8     # 0x58e881
movl $0x25, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ebff3
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xb09f0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jbe 0x2ec04b
movq 0x34ff86(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x229fef(%rip), %rsi    # 0x516013
leaq 0x2a2914(%rip), %rdx    # 0x58e93f
leaq 0x2a28fc(%rip), %rcx    # 0x58e92e
leaq 0x2a2848(%rip), %r8     # 0x58e881
movl $0x27, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ec04d
movq 0x18(%rsp), %xmm0
movaps 0x22c8d6(%rip), %xmm3   # 0x518930
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x22c8da(%rip), %xmm2   # 0x518940
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x10(%rsp), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
callq 0xec290
cmpl $-0x1, %eax
jne 0x2ec0f5
movq 0x34fedc(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x229f45(%rip), %rsi    # 0x516013
leaq 0x2a287d(%rip), %rdx    # 0x58e952
leaq 0x2a2852(%rip), %rcx    # 0x58e92e
leaq 0x2a279e(%rip), %r8     # 0x58e881
movl $0x29, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ec0f7
jmp 0x2ec0f9
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x22b130(%rip), %xmm1   # 0x517240
callq 0xec290
cmpl $0x1, %eax
jne 0x2ec152
movq 0x34fe7f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x229ee8(%rip), %rsi    # 0x516013
leaq 0x2a2852(%rip), %rdx    # 0x58e984
leaq 0x2a27f5(%rip), %rcx    # 0x58e92e
leaq 0x2a2741(%rip), %r8     # 0x58e881
movl $0x2a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ec154
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x2ed74e
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x11f8c0
movq %rax, %rsi
leaq 0x2a153d(%rip), %rdi    # 0x58ebf4
movb $0x0, %al
callq 0x19070
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x2ed72d
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0x2ed6f5
leaq 0x2a13fe(%rip), %rdi    # 0x58eae7
xorps %xmm0, %xmm0
movb $0x1, %al
callq 0x19070
jmp 0x2ed71b
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x2a13d9(%rip), %rdi    # 0x58eaed
movb $0x1, %al
callq 0x19070
jmp 0x2ed71d
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2ed6c7
leaq 0x2a5b3f(%rip), %rdi    # 0x593273
movb $0x0, %al
callq 0x19070
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2ed687
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/shu_unitfile.c
// Function: gt_shu_unit_file_info_read
int gt_shu_unit_file_info_read(const GtStr *unitfile,
                               GtShuUnitFileInfo *unit_info,
                               GT_UNUSED GtLogger *logger,
                               GtError *err)
{
  int had_err = 0;
  /* open Lua */
  lua_State *L = luaL_newstate();
  /* library needed?
  lua_openlibs(L); */

  had_err = shu_unitfile_load(L, gt_str_get(unitfile), err);
  if (!had_err)
    had_err = traverse_units(L, unit_info, err);

  lua_close(L);
  return had_err;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
callq 0x33bb50
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x11dee0
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x18(%rsp), %rdx
callq 0x2edde0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x2eddc1
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x2edec0
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rdi
callq 0x339e40
movl 0x14(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/shu_unitfile.c
// Function: shu_unitfile_load
static int shu_unitfile_load(lua_State *L,
                             const char *unitfile,
                             GtError *err)
{
  int had_err = 0;
  if (luaL_loadfile(L, unitfile) ||
      lua_pcall(L, 0, 0, 0)) {
    had_err = -1;
    gt_error_set(err, "Lua could not load file '%s'!", lua_tostring(L, -1));
  }
  if (!had_err) {
    lua_getglobal(L, "units");
    if (!lua_istable(L, -1)) {
      had_err = -1;
      gt_error_set(err, "Somethings wrong with the unitfile.");
    }
  }
  return had_err;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x33b630
cmpl $0x0, %eax
jne 0x2ede24
movq 0x20(%rsp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x3375c0
cmpl $0x0, %eax
je 0x2ede5d
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x334f50
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x2a0dbd(%rip), %rsi    # 0x58ec13
movb $0x0, %al
callq 0xd88c0
cmpl $0x0, 0xc(%rsp)
jne 0x2edeab
movq 0x20(%rsp), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
leaq 0x28e271(%rip), %rdx    # 0x57c0e6
callq 0x336410
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3345d0
cmpl $0x5, %eax
je 0x2edea9
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rdi
leaq 0x2a0d8f(%rip), %rsi    # 0x58ec31
movb $0x0, %al
callq 0xd88c0
jmp 0x2edeab
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x2ee1d7
movq (%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0x2a0a4f(%rip), %rsi    # 0x58ebfa
movl $0xca, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11fd20
movq (%rsp), %rdi
leaq 0x2a0a2d(%rip), %rsi    # 0x58ebfa
movl $0xcc, %edx
callq 0xe88c0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x30, %edi
leaq 0x2a0a05(%rip), %rsi    # 0x58ebfa
movl $0xdf, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rdi
callq 0xb7df0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rdi
callq 0xb1f80
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rdi
callq 0x2ee280
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/shu_unitfile.c
// Function: gt_shu_unit_info_files_as_units
static void gt_shu_unit_info_files_as_units(GtShuUnitFileInfo *unit_info)
{
  GtUword i_idx;

  unit_info->num_of_genomes = unit_info->num_of_files;
  unit_info->genome_names = gt_str_array_new();
  for (i_idx = 0; i_idx < unit_info->num_of_files; i_idx++)
  {
    gt_str_array_add(unit_info->genome_names,
                     gt_str_array_get_str(unit_info->file_names, i_idx));
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
callq 0x11f5c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x2ee300
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x11f960
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x11f840
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2ee2b4
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/shu_unitfile.c
// Function: shu_unitfile_traverse_inner_keys
static int shu_unitfile_traverse_inner_keys(lua_State *L,
                                            GtShuUnitFileInfo *unit_info,
                                            bool *file_set,
                                            GtStr *mapping_filename,
                                            GtUword genome_idx,
                                            GtUword *files_added,
                                            GtError *err)
{
  int had_err = 0;

  gt_str_array_add_cstr(unit_info->genome_names, lua_tostring(L, -2));

  lua_pushnil(L); /* the first inner key */
  while (lua_next(L, -2) != 0 && !had_err) {
    had_err = shu_unitfile_compare_inner_key_filenames(L, unit_info, file_set,
                                                       mapping_filename,
                                                       genome_idx,
                                                       err);
    if (!had_err)
      (*files_added)++;
    lua_pop(L, 1);
  }
  return had_err;
}

// Assembly:
subq $0x48, %rsp
movq 0x50(%rsp), %rax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
xorl %eax, %eax
movl %eax, %edx
callq 0x334f50
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x11f720
movq 0x40(%rsp), %rdi
callq 0x335470
movq 0x40(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x338000
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
je 0x2ee3a1
cmpl $0x0, 0x14(%rsp)
setne %al
xorb $-0x1, %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x2ee3ab
jmp 0x2ee3fc
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x50(%rsp), %r9
callq 0x2ee410
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x2ee3e8
movq 0x18(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x40(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x333ed0
jmp 0x2ee377
movl 0x14(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 $0xb8, %rsp
testb %al, %al
je 0x2ee652
movaps %xmm0, (%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm2, 0x20(%rsp)
movaps %xmm3, 0x30(%rsp)
movaps %xmm4, 0x40(%rsp)
movaps %xmm5, 0x50(%rsp)
movaps %xmm6, 0x60(%rsp)
movaps %xmm7, 0x70(%rsp)
movq %r9, -0x8(%rsp)
movq %r8, -0x10(%rsp)
movq %rcx, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rdi, 0xb0(%rsp)
movl %esi, 0xac(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x88(%rsp)
leaq 0x90(%rsp), %rax
leaq -0x30(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0xc0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq 0x90(%rsp), %rax
movq %rax, -0x40(%rsp)
movl 0x90(%rsp), %eax
movl %eax, -0x34(%rsp)
cmpl $0x28, %eax
ja 0x2ee6e8
movq -0x40(%rsp), %rcx
movl -0x34(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x48(%rsp)
jmp 0x2ee701
movq -0x40(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x48(%rsp)
movq -0x48(%rsp), %rax
movq (%rax), %rcx
movq 0x88(%rsp), %rax
movq %rcx, 0x10(%rax)
leaq 0x90(%rsp), %rax
movq %rax, -0x58(%rsp)
movl 0x90(%rsp), %eax
movl %eax, -0x4c(%rsp)
cmpl $0x28, %eax
ja 0x2ee74e
movq -0x58(%rsp), %rcx
movl -0x4c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x60(%rsp)
jmp 0x2ee767
movq -0x58(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x60(%rsp)
movq -0x60(%rsp), %rax
movq (%rax), %rcx
movq 0x88(%rsp), %rax
movq %rcx, (%rax)
leaq 0x90(%rsp), %rax
movq %rax, -0x70(%rsp)
movl 0x90(%rsp), %eax
movl %eax, -0x64(%rsp)
cmpl $0x28, %eax
ja 0x2ee7b3
movq -0x70(%rsp), %rcx
movl -0x64(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x78(%rsp)
jmp 0x2ee7cc
movq -0x70(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x78(%rsp)
movq -0x78(%rsp), %rax
movq (%rax), %rcx
movq 0x88(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0xb8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/spaced-seeds.c
// Function: spse_fullmatchLimdfsstate
static void spse_fullmatchLimdfsstate(Limdfsresult *limdfsresult,
                                      DECLAREPTRDFSSTATE(aliascolumn),
                                      GT_UNUSED GtUword leftbound,
                                      GT_UNUSED GtUword rightbound,
                                      GT_UNUSED GtUword width,
                                      GtUword currentdepth,
                                      Limdfsconstinfo *mt)
{
  SpseLimdfsstate *limdfsstate = (SpseLimdfsstate *) aliascolumn;
  SpseLimdfsconstinfo *mti = (SpseLimdfsconstinfo*) mt;

  if (limdfsstate->pathmatches)
  {
    if (currentdepth == mti->seedweight)
    {
      limdfsresult->status = Limdfssuccess;
      limdfsresult->pprefixlen = mti->seedweight;
      limdfsresult->distance = 0;
      return;
    }
    if (currentdepth < mti->seedweight)
    {
      limdfsresult->status = Limdfscontinue;
      return;
    }
  }
  limdfsresult->status = Limdfsstop;
}

// Assembly:
movq 0x8(%rsp), %rax
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x38(%rsp)
movq 0x8(%rsp), %rax
movq %rax, -0x40(%rsp)
movq -0x38(%rsp), %rax
testb $0x1, (%rax)
je 0x2ee8dc
movq -0x30(%rsp), %rax
movq -0x40(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x2ee8bd
movq -0x8(%rsp), %rax
movl $0x0, (%rax)
movq -0x40(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
jmp 0x2ee8e7
movq -0x30(%rsp), %rax
movq -0x40(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x2ee8da
movq -0x8(%rsp), %rax
movl $0x1, (%rax)
jmp 0x2ee8e7
jmp 0x2ee8dc
movq -0x8(%rsp), %rax
movl $0x2, (%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movb %cl, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movq %r8, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl 0x2f(%rsp), %eax
cmpl $0xfe, %eax
jl 0x2ee970
movq 0x34d661(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2276ca(%rip), %rsi    # 0x516013
leaq 0x285988(%rip), %rdx    # 0x5742d8
leaq 0x2a0422(%rip), %rcx    # 0x58ed79
leaq 0x2a0402(%rip), %r8     # 0x58ed60
movl $0x91, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ee972
jmp 0x2ee974
cmpq $0x0, 0x30(%rsp)
ja 0x2ee9b4
movq 0x34d61d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x227686(%rip), %rsi    # 0x516013
leaq 0x2a03fa(%rip), %rdx    # 0x58ed8e
leaq 0x2a03de(%rip), %rcx    # 0x58ed79
leaq 0x2a03be(%rip), %r8     # 0x58ed60
movl $0x92, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ee9b6
jmp 0x2ee9b8
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
jne 0x2ee9fa
movq 0x34d5d7(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x227640(%rip), %rsi    # 0x516013
leaq 0x2a03c5(%rip), %rdx    # 0x58ed9f
leaq 0x2a0398(%rip), %rcx    # 0x58ed79
leaq 0x2a0378(%rip), %r8     # 0x58ed60
movl $0x93, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ee9fc
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x30(%rsp), %rdx
movzbl 0x2f(%rsp), %ecx
callq 0x2eeb20
movb %al, %cl
movq 0x18(%rsp), %rax
andb $0x1, %cl
movb %cl, (%rax)
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl 0x1f(%rsp), %eax
cmpl $0xfe, %eax
jl 0x2eeaa1
movq 0x34d530(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x227599(%rip), %rsi    # 0x516013
leaq 0x285857(%rip), %rdx    # 0x5742d8
leaq 0x2a032a(%rip), %rcx    # 0x58edb2
leaq 0x2a02d1(%rip), %r8     # 0x58ed60
movl $0xa3, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2eeaa3
jmp 0x2eeaa5
cmpq $0x0, 0x20(%rsp)
ja 0x2eeae5
movq 0x34d4ec(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x227555(%rip), %rsi    # 0x516013
leaq 0x2a02c9(%rip), %rdx    # 0x58ed8e
leaq 0x2a02e6(%rip), %rcx    # 0x58edb2
leaq 0x2a028d(%rip), %r8     # 0x58ed60
movl $0xa4, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2eeae7
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x20(%rsp), %rdx
movzbl 0x1f(%rsp), %ecx
callq 0x2eeb20
movb %al, %cl
movq 0x10(%rsp), %rax
andb $0x1, %cl
movb %cl, (%rax)
addq $0x38, %rsp
retq
nopl (%rax,%rax)