LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/union_find.c
// Function: gt_union_find_new
GtUnionFind* gt_union_find_new(GtUword num_of_elems)
{
  GtUnionFind *uf;
  GtUword i;
  gt_assert(num_of_elems);
  uf = gt_malloc(sizeof *uf);
  uf->elems = gt_calloc(sizeof (GtUnionFindElement), num_of_elems);
  uf->allocated = num_of_elems;
  for (i = 0; i < num_of_elems; i++)
    uf->elems[i].parent = i;
  uf->num_of_elems = num_of_elems;
  return uf;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x28e379
movq 0x36dc80(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x26d24b(%rip), %rsi    # 0x4fb59d
leaq 0x29a6f1(%rip), %rdx    # 0x528a4a
leaq 0x2b35d0(%rip), %rcx    # 0x541930
leaq 0x2b35db(%rip), %r8     # 0x541942
movl $0x27, %r9d
movb $0x0, %al
callq 0x33960
callq 0x2f830
jmp 0x28e37b
movl $0x18, %edi
leaq 0x2b35bb(%rip), %rsi    # 0x541942
movl $0x28, %edx
callq 0x2f600
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rsi
movl $0x8, %edi
leaq 0x2b359b(%rip), %rdx    # 0x541942
movl $0x29, %ecx
callq 0x31f50
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x28e3ff
movq (%rsp), %rdx
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x28e3d2
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/union_find.c
// Function: gt_union_find_reset
void gt_union_find_reset(GtUnionFind *uf, GtUword num_of_elems)
{
  GtUword i;
  gt_assert(num_of_elems);
  if (num_of_elems > uf->allocated)
  {
    uf->elems = gt_realloc(uf->elems, sizeof (GtUnionFindElement) *
        num_of_elems);
    uf->allocated = num_of_elems;
  }
  for (i = 0; i < num_of_elems; i++)
    uf->elems[i].parent = i;
  uf->num_of_elems = num_of_elems;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x28e46e
movq 0x36db8b(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x26d156(%rip), %rsi    # 0x4fb59d
leaq 0x29a5fc(%rip), %rdx    # 0x528a4a
leaq 0x2b3507(%rip), %rcx    # 0x54195c
leaq 0x2b34e6(%rip), %r8     # 0x541942
movl $0x34, %r9d
movb $0x0, %al
callq 0x33960
callq 0x2f830
jmp 0x28e470
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x28e4bb
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
shlq $0x3, %rsi
leaq 0x2b34aa(%rip), %rdx    # 0x541942
movl $0x38, %ecx
callq 0x2f910
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x28e4f0
movq (%rsp), %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x28e4c3
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/union_find.c
// Function: gt_union_find_find
GtUword gt_union_find_find(GtUnionFind *uf, GtUword elem)
{
  gt_assert(uf && elem < uf->num_of_elems);
  if (elem != uf->elems[elem].parent) /* path compression */
    uf->elems[elem].parent = gt_union_find_find(uf, uf->elems[elem].parent);
  return uf->elems[elem].parent;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x28e576
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x28e5ae
movq 0x36da4b(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x26d016(%rip), %rsi    # 0x4fb59d
leaq 0x2b33e2(%rip), %rdx    # 0x541970
leaq 0x2b33f9(%rip), %rcx    # 0x54198e
leaq 0x2b33a6(%rip), %r8     # 0x541942
movl $0x49, %r9d
movb $0x0, %al
callq 0x33960
callq 0x2f830
jmp 0x28e5b0
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movq 0x8(%rsp), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0x28e5f7
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x28e550
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/union_find.c
// Function: gt_union_find_union
void gt_union_find_union(GtUnionFind *uf, GtUword elem_a,
                         GtUword elem_b)
{
  GtUword x, y;
  gt_assert(uf && elem_a < uf->num_of_elems && elem_b < uf->num_of_elems);
  x = gt_union_find_find(uf, elem_a);
  y = gt_union_find_find(uf, elem_b);
  uf->elems[y].parent = x;
  /* union-by-rank heuristic
  if (uf->elems[x].rank > uf->elems[y].rank)
    uf->elems[y].parent = x;
  else {
    uf->elems[x].parent = y;
    if (uf->elems[x].rank == uf->elems[y].rank)
      uf->elems[y].rank++;
  }
  */
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x28e64b
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x28e64b
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x28e683
movq 0x36d976(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x26cf41(%rip), %rsi    # 0x4fb59d
leaq 0x2b333e(%rip), %rdx    # 0x5419a1
leaq 0x2b3374(%rip), %rcx    # 0x5419de
leaq 0x2b32d1(%rip), %r8     # 0x541942
movl $0x53, %r9d
movb $0x0, %al
callq 0x33960
callq 0x2f830
jmp 0x28e685
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x28e550
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x28e550
movq %rax, (%rsp)
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-splititv-simple.c
// Function: lcpintervalfindfirst
static GtUword lcpintervalfindfirst(const GtEncseq *encseq,
                                          GtReadmode readmode,
                                          GtUword totallength,
                                          const ESASuffixptr *suftab,
                                          GtUchar cc,
                                          GtUword offset,
                                          GtUword left,
                                          GtUword right)
{
  GtUword found = ULONG_MAX;

  while (left <= right)
  {
    GtUword mid = left + GT_DIV2(right - left + 1);
    GtUword pos = ESASUFFIXPTRGET(suftab,mid) + offset;
    GtUchar midcc = SEQUENCE(encseq,pos);
    if (midcc < cc)
    {
      left = mid + 1;
    } else
    {
      if (cc == midcc)
      {
        found = mid;
      }
      if (mid == 0)
      {
        break;
      }
      right = mid - 1;
    }
  }
  return found;
}

// Assembly:
subq $0x58, %rsp
movb %r8b, %al
movq 0x68(%rsp), %r8
movq 0x60(%rsp), %r8
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movb %al, 0x37(%rsp)
movq %r9, 0x28(%rsp)
movq $-0x1, 0x20(%rsp)
movq 0x60(%rsp), %rax
cmpq 0x68(%rsp), %rax
ja 0x2f46a8
movq 0x60(%rsp), %rax
movq 0x68(%rsp), %rcx
subq 0x60(%rsp), %rcx
addq $0x1, %rcx
shrq %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x40(%rsp), %rax
jne 0x2f4633
movl $0xff, %eax
movl %eax, 0x8(%rsp)
jmp 0x2f464d
movq 0x50(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x4c(%rsp), %edx
callq 0x31b50
movzbl %al, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %eax
movzbl 0x37(%rsp), %ecx
cmpl %ecx, %eax
jge 0x2f4673
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
jmp 0x2f46a3
movzbl 0x37(%rsp), %eax
movzbl 0xf(%rsp), %ecx
cmpl %ecx, %eax
jne 0x2f468b
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x2f4695
jmp 0x2f46a8
movq 0x18(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x68(%rsp)
jmp 0x2f45d6
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/hlk-version.c
// Function: gt_harlekin_show_version
void gt_harlekin_show_version(const char *progname)
{
  char *clean_progname = NULL;
  size_t pnsize = strlen(progname), hlksize = strlen(" "GT_HARLEKIN_CMD);
  printf("Readjoiner: a string graph-based sequence assembler\n\n");
  printf("version "GT_HARLEKIN_VERSION"\n\n");

  /* rm " harlekin" from progname if possible, to avoid confusing the user */
  clean_progname = gt_malloc(pnsize);
  (void)strcpy(clean_progname, progname);
  if (pnsize > hlksize && strcmp(clean_progname + (pnsize - hlksize),
        " "GT_HARLEKIN_CMD) == 0)
  {
    clean_progname[pnsize - hlksize] = '\0';
  }
  printf("GenomeTools version:\n");
  gt_versionfunc(clean_progname);
  gt_free(clean_progname);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x30e70
movq %rax, 0x10(%rsp)
movq $0x9, 0x8(%rsp)
leaq 0x22de1a(%rip), %rdi    # 0x551c4b
movb $0x0, %al
callq 0x2f300
leaq 0x22de42(%rip), %rdi    # 0x551c81
movb $0x0, %al
callq 0x2f300
movq 0x10(%rsp), %rdi
leaq 0x22de3d(%rip), %rsi    # 0x551c8f
movl $0x1f, %edx
callq 0x2f600
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x32b70
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jbe 0x323eb2
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
subq 0x8(%rsp), %rax
addq %rax, %rdi
leaq 0x22de12(%rip), %rsi    # 0x551ca7
callq 0x32950
cmpl $0x0, %eax
jne 0x323eb2
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
subq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
leaq 0x22ddf8(%rip), %rdi    # 0x551cb1
movb $0x0, %al
callq 0x2f300
movq 0x18(%rsp), %rdi
callq 0x34060
movq 0x18(%rsp), %rdi
leaq 0x22ddb9(%rip), %rsi    # 0x551c8f
movl $0x28, %edx
callq 0x31f10
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/iter-window.c
// Function: gt_windowiterator_new
Windowiterator *gt_windowiterator_new(const GtEncseq *encseq,
                                   GtUword windowsize,
                                   GtUword startpos,
                                   GtUword endpos)
{
  Windowiterator *wit;

  gt_assert(encseq != NULL);
  gt_assert(endpos <= gt_encseq_total_length(encseq));
  wit = gt_malloc(sizeof (*wit));
  wit->buffer = gt_malloc(sizeof (GtUchar) * windowsize);
  wit->firstpos = wit->bufsize = 0;
  wit->windowsize = windowsize;
  wit->currentpos = startpos;
  wit->endpos = endpos;
  wit->esr = gt_encseq_create_reader_with_readmode(encseq,
                                                   GT_READMODE_FORWARD,
                                                   startpos);
  wit->encseq = encseq;
  return wit;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x32dfe8
movq 0x2ce011(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x1cd5dc(%rip), %rsi    # 0x4fb59d
leaq 0x218215(%rip), %rdx    # 0x5461dd
leaq 0x22599f(%rip), %rcx    # 0x55396e
leaq 0x2259ae(%rip), %r8     # 0x553984
movl $0x26, %r9d
movb $0x0, %al
callq 0x33960
callq 0x2f830
jmp 0x32dfea
jmp 0x32dfec
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x32150
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jbe 0x32e045
movq 0x2cdfb4(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x1cd57f(%rip), %rsi    # 0x4fb59d
leaq 0x225977(%rip), %rdx    # 0x55399c
leaq 0x225942(%rip), %rcx    # 0x55396e
leaq 0x225951(%rip), %r8     # 0x553984
movl $0x27, %r9d
movb $0x0, %al
callq 0x33960
callq 0x2f830
jmp 0x32e047
movl $0x40, %edi
leaq 0x225931(%rip), %rsi    # 0x553984
movl $0x28, %edx
callq 0x2f600
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
shlq $0x0, %rdi
leaq 0x225912(%rip), %rsi    # 0x553984
movl $0x29, %edx
callq 0x2f600
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rdx
xorl %esi, %esi
callq 0x30b20
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/lua_tools.c
// Function: gt_lua_stack_dump
void gt_lua_stack_dump(lua_State *L) {
  int i;
  int top = lua_gettop(L);
  for (i = 1; i <= top; i++)
  { /* repeat for each level */
    int t = lua_type(L, i);
    switch (t) {

      case LUA_TSTRING:  /* strings */
        fprintf(stderr, "`%s'", lua_tostring(L, i));
        break;

      case LUA_TBOOLEAN:  /* booleans */
        lua_toboolean(L, i) ? fprintf(stderr,"true") : fprintf(stderr,"false");
        break;

      case LUA_TNUMBER:  /* numbers */
        fprintf(stderr, "%g", lua_tonumber(L, i));
        break;

      default:  /* other values */
        fprintf(stderr, "%s", lua_typename(L, t));
        break;
    }
    fprintf(stderr, "  ");  /* put a separator */
  }
  fprintf(stderr, "\n");  /* end the listing */
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x431b20
movl %eax, 0x28(%rsp)
movl $0x1, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x28(%rsp), %eax
jg 0x33180c
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x432240
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x20(%rsp)
subl $0x1, %eax
je 0x331738
jmp 0x3316de
movl 0x20(%rsp), %eax
subl $0x3, %eax
je 0x33177f
jmp 0x3316ed
movl 0x20(%rsp), %eax
subl $0x4, %eax
jne 0x3317b1
jmp 0x3316fc
movq 0x2ca8c5(%rip), %rax    # 0x5fbfc8
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x432bc0
movq 0x18(%rsp), %rdi
movq %rax, %rdx
leaq 0x2473a7(%rip), %rsi    # 0x578ad3
movb $0x0, %al
callq 0x33960
jmp 0x3317e4
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x432b50
cmpl $0x0, %eax
je 0x331765
movq 0x2ca876(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x20af61(%rip), %rsi    # 0x53c6bd
movb $0x0, %al
callq 0x33960
jmp 0x33177d
movq 0x2ca85c(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x1f9239(%rip), %rsi    # 0x52a9af
movb $0x0, %al
callq 0x33960
jmp 0x3317e4
movq 0x2ca842(%rip), %rax    # 0x5fbfc8
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x432a60
movq 0x10(%rsp), %rdi
leaq 0x24845f(%rip), %rsi    # 0x579c07
movb $0x1, %al
callq 0x33960
jmp 0x3317e4
movq 0x2ca810(%rip), %rax    # 0x5fbfc8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x432290
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x246ae4(%rip), %rsi    # 0x5782c1
movb $0x0, %al
callq 0x33960
movq 0x2ca7dd(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x1c77f5(%rip), %rsi    # 0x4f8fea
movb $0x0, %al
callq 0x33960
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x3316af
movq 0x2ca7b5(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x23c82a(%rip), %rsi    # 0x56e047
movb $0x0, %al
callq 0x33960
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/nullcols.c
// Function: gt_newCharatpos
Charatpos *gt_newCharatpos(GtUword patternlength,unsigned int alphasize)
{
  Charatpos *catpos;

  catpos = gt_malloc(sizeof (*catpos));
  catpos->endindex = gt_malloc(sizeof (GtUword) * alphasize);
  catpos->positions = gt_malloc(sizeof (GtUword) * patternlength);
  return catpos;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x10, %edi
leaq 0x220979(%rip), %rsi    # 0x5545c2
movl $0x20, %edx
callq 0x2f600
movq %rax, (%rsp)
movl 0xc(%rsp), %eax
movl %eax, %edi
shlq $0x3, %rdi
leaq 0x22095a(%rip), %rsi    # 0x5545c2
movl $0x21, %edx
callq 0x2f600
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
shlq $0x3, %rdi
leaq 0x220936(%rip), %rsi    # 0x5545c2
movl $0x22, %edx
callq 0x2f600
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/nullcols.c
// Function: gt_reinitCharatpos
Charatpos *gt_reinitCharatpos(Charatpos *catpos,
                           const GtUchar *pattern,GtUword patternlength,
                           unsigned int alphasize)
{
  const GtUchar *pptr;
  GtUword partialsum, tmp;
  unsigned int idx;

  for (idx=0; idx<alphasize; idx++)
  {
    catpos->endindex[idx] = 0;
  }
  for (pptr=pattern; pptr<pattern+ patternlength; pptr++)
  {
    catpos->endindex[(int) *pptr]++;
  }
  partialsum = catpos->endindex[0];
  catpos->endindex[0] = 0;
  for (idx=1U; idx<alphasize; idx++)
  {
    tmp = catpos->endindex[idx];
    catpos->endindex[idx] = partialsum;
    partialsum += tmp;
  }
  for (pptr=pattern; pptr<pattern+patternlength; pptr++)
  {
    catpos->positions[catpos->endindex[*pptr]++]
      = (GtUword) (pptr - pattern);
  }
  return catpos;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movl $0x0, -0x3c(%rsp)
movl -0x3c(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jae 0x333cf6
movq -0x8(%rsp), %rax
movq (%rax), %rax
movl -0x3c(%rsp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rsp)
jmp 0x333ccb
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq -0x10(%rsp), %rcx
addq -0x18(%rsp), %rcx
cmpq %rcx, %rax
jae 0x333d43
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq -0x28(%rsp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x333d00
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq $0x0, (%rax)
movl $0x1, -0x3c(%rsp)
movl -0x3c(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jae 0x333dba
movq -0x8(%rsp), %rax
movq (%rax), %rax
movl -0x3c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rsp)
movq -0x30(%rsp), %rdx
movq -0x8(%rsp), %rax
movq (%rax), %rax
movl -0x3c(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x38(%rsp), %rax
addq -0x30(%rsp), %rax
movq %rax, -0x30(%rsp)
movl -0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rsp)
jmp 0x333d6a
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq -0x10(%rsp), %rcx
addq -0x18(%rsp), %rcx
cmpq %rcx, %rax
jae 0x333e23
movq -0x28(%rsp), %rdx
movq -0x10(%rsp), %rax
subq %rax, %rdx
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rsi
movq -0x28(%rsp), %rcx
movzbl (%rcx), %ecx
movl %ecx, %edi
movq (%rsi,%rdi,8), %rcx
movq %rcx, %r8
addq $0x1, %r8
movq %r8, (%rsi,%rdi,8)
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x333dc4
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/nullcols.c
// Function: gt_wrapCharatpos
void gt_wrapCharatpos(Charatpos **catposptr)
{
  Charatpos *catpos = *catposptr;
  gt_free(catpos->endindex);
  gt_free(catpos->positions);
  gt_free(catpos);
  *catposptr = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
leaq 0x22076d(%rip), %rsi    # 0x5545c2
movl $0x49, %edx
callq 0x31f10
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x220753(%rip), %rsi    # 0x5545c2
movl $0x4a, %edx
callq 0x31f10
movq 0x8(%rsp), %rdi
leaq 0x22073d(%rip), %rsi    # 0x5545c2
movl $0x4b, %edx
callq 0x31f10
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/nullcols.c
// Function: gt_maintainnullcols
void gt_maintainnullcols(const Charatpos *catpos,
                      GtUword *front0,GtUchar cc,GtUword depth)
{
  GtUword idx;

  for (idx = (cc == 0) ? 0 : catpos->endindex[cc-1];
       idx < catpos->endindex[cc]; idx++)
  {
    GtUword pos = catpos->positions[idx];
    if (front0[pos] == depth)
    {
      front0[pos]++;
    }
  }
}

// Assembly:
movb %dl, %al
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movb %al, -0x11(%rsp)
movq %rcx, -0x20(%rsp)
movzbl -0x11(%rsp), %eax
cmpl $0x0, %eax
jne 0x333ec8
xorl %eax, %eax
movq %rax, -0x38(%rsp)
jmp 0x333ee4
movq -0x8(%rsp), %rax
movq (%rax), %rax
movzbl -0x11(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
movzbl -0x11(%rsp), %edx
cmpq (%rcx,%rdx,8), %rax
jae 0x333f5a
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rsp)
movq -0x10(%rsp), %rax
movq -0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rsp), %rax
jne 0x333f48
movq -0x10(%rsp), %rax
movq -0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x333f4a
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x333eee
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/pssm.c
// Function: gt_makeitmthresholds
void gt_makeitmthresholds(Profilematrix *prof,
                              ProfScore minscore)
{
  GtUword d, a;
  GtWord ddown;
  ProfScore partsum,
            score,
            *maxscore;

  maxscore = gt_malloc(sizeof *maxscore * prof->dimension);
  for (d=0; d<prof->dimension; d++)
  {
    for (a=0; a<prof->numofcharacters; a++)
    {
      score = GETPROFSCORE(prof,a,d);
      if (a == 0 || maxscore[d] < score)
      {
        maxscore[d] = score;
      }
    }
  }
  partsum = (ProfScore) 0;
  gt_assert(prof->itmthreshold != NULL);
  for (ddown = (GtWord) (prof->dimension-1); ddown>=0; ddown--)
  {
    prof->itmthreshold[ddown] = minscore - partsum;
    partsum += maxscore[ddown];
  }
  gt_free(maxscore);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
shlq $0x2, %rdi
leaq 0x21d9d7(%rip), %rsi    # 0x554ce7
movl $0x51, %edx
callq 0x2f600
movq %rax, (%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x3373c2
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x3373ad
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x33738b
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x8(%rsp), %eax
jge 0x33739b
movl 0x8(%rsp), %edx
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x33739d
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x337343
jmp 0x3373af
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x337327
movl $0x0, 0xc(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x33740e
movq 0x2c4beb(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x1c41b6(%rip), %rsi    # 0x4fb59d
leaq 0x21d90a(%rip), %rdx    # 0x554cf8
leaq 0x21d91e(%rip), %rcx    # 0x554d13
leaq 0x21d8eb(%rip), %r8     # 0x554ce7
movl $0x5e, %r9d
movb $0x0, %al
callq 0x33960
callq 0x2f830
jmp 0x337410
movq 0x30(%rsp), %rax
movq (%rax), %rax
subq $0x1, %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jl 0x337466
movl 0x2c(%rsp), %edx
subl 0xc(%rsp), %edx
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x337421
movq (%rsp), %rdi
leaq 0x21d876(%rip), %rsi    # 0x554ce7
movl $0x64, %edx
callq 0x31f10
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/pssm.c
// Function: gt_lookaheadsearchPSSM
void gt_lookaheadsearchPSSM(const GtEncseq *encseq,
                            const Profilematrix *prof)
{
  GtUword firstpos, bufsize;
  GtUchar currentchar;
  GtUword pos;
  GtEncseqReader *esr;
  GtUword totallength = gt_encseq_total_length(encseq);
  GtUchar *buffer;

  esr = gt_encseq_create_reader_with_readmode(encseq,GT_READMODE_FORWARD,0);
  buffer = gt_malloc(sizeof *buffer * prof->dimension);
  firstpos = bufsize = 0;
  for (pos=0; pos < totallength; pos++)
  {
    currentchar = gt_encseq_reader_next_encoded_char(esr);
    if (GT_ISSPECIAL(currentchar))
    {
      bufsize = firstpos = 0;
    } else
    {
      if (bufsize < prof->dimension)
      {
        buffer[bufsize++] = currentchar;
      } else
      {
        buffer[firstpos++] = currentchar;
        if (firstpos == prof->dimension)
        {
          firstpos = 0;
        }
      }
    }
  }
  gt_encseq_reader_delete(esr);
  gt_free(buffer);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x32150
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x30b20
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rdi
shlq $0x0, %rdi
leaq 0x21d822(%rip), %rsi    # 0x554ce7
movl $0x72, %edx
callq 0x2f600
movq %rax, (%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x3375a6
movq 0x10(%rsp), %rdi
callq 0x2fdf0
movb %al, 0x27(%rsp)
movzbl 0x27(%rsp), %eax
cmpl $0xfe, %eax
jl 0x33752c
movq $0x0, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
jmp 0x337591
movq 0x28(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x337559
movb 0x27(%rsp), %dl
movq (%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x28(%rsp)
movb %dl, (%rax,%rcx)
jmp 0x33758f
movb 0x27(%rsp), %dl
movq (%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x30(%rsp)
movb %dl, (%rax,%rcx)
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq (%rcx), %rax
jne 0x33758d
movq $0x0, 0x30(%rsp)
jmp 0x33758f
jmp 0x337591
jmp 0x337593
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x3374ee
movq 0x10(%rsp), %rdi
callq 0x30bf0
movq (%rsp), %rdi
leaq 0x21d72c(%rip), %rsi    # 0x554ce7
movl $0x8a, %edx
callq 0x31f10
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-hpcorrect.c
// Function: gt_randomcodes_hpcorrect_process_bucket
int gt_randomcodes_hpcorrect_process_bucket(void *data,
    const GtUword *bucketofsuffixes, const GtSeqnumrelpos *snrp,
    const uint16_t *lcptab_bucket, GtUword numberofsuffixes,
    GT_UNUSED unsigned int sortingdepth, GT_UNUSED GtError *err)
{
  GtUword itvstart, next_itvstart;
  unsigned int lcpvalue;
  GtRandomcodesHpcorrectData *sdata = data;

#ifdef GT_RANDOMCODES_HPCORRECT_DEBUG
  gt_file_xprintf(sdata->outfile, "# bucketsize:\t"GT_WU"\n", numberofsuffixes);
#endif
  for (itvstart = 0, next_itvstart = 1UL; next_itvstart < numberofsuffixes;
      next_itvstart++)
  {
    lcpvalue = (unsigned int) lcptab_bucket[next_itvstart];
#ifdef GT_RANDOMCODES_HPCORRECT_DEBUG
    gt_randomcodes_hpcorrect_show_expanded_kmer(sdata, bucketofsuffixes, snrp,
        next_itvstart - 1UL, lcpvalue);
#endif
    if (lcpvalue < (unsigned int)sdata->k)
    {
#ifdef GT_RANDOMCODES_HPCORRECT_DEBUG
      gt_file_xprintf(sdata->outfile, "# orig-nofsfx:\t"GT_WU"\n",
          next_itvstart - itvstart);
#endif
      gt_randomcodes_hpcorrect_process_kmer_itv(snrp,
          bucketofsuffixes + itvstart, next_itvstart - itvstart, data);
      itvstart = next_itvstart;
    }
  }
#ifdef GT_RANDOMCODES_HPCORRECT_DEBUG
  gt_randomcodes_hpcorrect_show_expanded_kmer(sdata, bucketofsuffixes, snrp,
      next_itvstart - 1UL, lcpvalue);
  gt_file_xprintf(sdata->outfile, "# orig-nofsfx:\t"GT_WU"\n",
      next_itvstart - itvstart);
#endif
  gt_randomcodes_hpcorrect_process_kmer_itv(snrp,
      bucketofsuffixes + itvstart, next_itvstart - itvstart, data);
  return 0;
}

// Assembly:
subq $0x58, %rsp
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movl %r9d, 0x2c(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x1, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x341e48
movq 0x38(%rsp), %rax
movq 0x18(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x8(%rsp), %rcx
movq 0x20(%rcx), %rcx
cmpl %ecx, %eax
jae 0x341e36
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x20(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq 0x18(%rsp), %rdx
subq 0x20(%rsp), %rdx
movq 0x50(%rsp), %rcx
callq 0x341e80
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x341e38
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x341dd3
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x20(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq 0x18(%rsp), %rdx
subq 0x20(%rsp), %rdx
movq 0x50(%rsp), %rcx
callq 0x341e80
xorl %eax, %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-hpcorrect.c
// Function: gt_randomcodes_hpcorrect_process_kmer_itv
static inline void gt_randomcodes_hpcorrect_process_kmer_itv(
    const GtSeqnumrelpos *snrp, const GtUword *suffixes,
    GtUword nofsuffixes, GtRandomcodesHpcorrectData *sdata)
{
  GtUword clusternum, nofclusters;
  bool allidentical;
  if (nofsuffixes > sdata->maxwidth)
  {
    gt_randomcodes_hpcorrect_partition_kmer_itv(snrp, suffixes,
        nofsuffixes, sdata);
    return;
  }
#ifdef GT_RANDOMCODES_HPCORRECT_VERBOSE
  gt_file_xprintf(sdata->outfile, "# nofsfx:\t"GT_WU"\n", nofsuffixes);
#endif
  if (nofsuffixes < 3UL)
    return;
  if (sdata->hmers_alloc < nofsuffixes)
    gt_randomcode_realloc_hmers_data(nofsuffixes, sdata);
  gt_randomcodes_hpcorrect_fill_hmers(snrp, suffixes, nofsuffixes, sdata);
  nofclusters = gt_randomcodes_hpcorrect_cluster(&allidentical, nofsuffixes,
      sdata);
  if (allidentical)
    return;
  if (nofclusters > nofsuffixes - 2UL)
    return;
  for (clusternum = 0; clusternum < nofsuffixes; clusternum++)
  {
    if (sdata->cluster_size[clusternum] >= 3UL)
    {
      if (!sdata->firstpass)
        gt_randomcodes_hpcorrect_process_cluster(snrp, suffixes, nofsuffixes,
            sdata, clusternum);
      else
        gt_randomcodes_hpcorrect_firstpass_process_cluster(snrp, suffixes,
            nofsuffixes, sdata, clusternum);
    }
  }
}

// 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 0x18(%rsp), %rcx
cmpq 0xc0(%rcx), %rax
jbe 0x341ec9
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x342940
jmp 0x341fd8
cmpq $0x3, 0x20(%rsp)
jae 0x341ed6
jmp 0x341fd8
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
cmpq 0x20(%rsp), %rax
jae 0x341ef5
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x342a80
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x342d30
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x7(%rsp), %rdi
callq 0x342e10
movq %rax, 0x8(%rsp)
testb $0x1, 0x7(%rsp)
je 0x341f33
jmp 0x341fd8
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
subq $0x2, %rcx
cmpq %rcx, %rax
jbe 0x341f4b
jmp 0x341fd8
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x341fd8
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq $0x3, (%rax,%rcx,8)
jb 0x341fc3
movq 0x18(%rsp), %rax
testb $0x1, 0xc9(%rax)
jne 0x341fa3
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x343000
jmp 0x341fc1
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x343060
jmp 0x341fc3
jmp 0x341fc5
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x341f54
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-hpcorrect.c
// Function: gt_randomcodes_hpcorrect_data_delete
void gt_randomcodes_hpcorrect_data_delete(GtRandomcodesHpcorrectData *sdata)
{
  gt_assert(sdata != NULL);
  gt_free(sdata->hmers);
  gt_free(sdata->pw_scores);
  gt_free(sdata->pw_scores_copy);
  gt_free(sdata->hmer_cluster);
  gt_free(sdata->cluster_size);
  gt_free(sdata->skip);
  gt_free(sdata->consensus_hmer);
  gt_free(sdata->hdistri);
  gt_union_find_delete(sdata->union_find);
  gt_free(sdata->rextset);
  gt_free(sdata->rextset_size);
  gt_encseq_reader_delete(sdata->esr1);
  gt_encseq_reader_delete(sdata->esr2);
  gt_file_delete(sdata->outfile);
  gt_free(sdata);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x3427d4
movq 0x2b9825(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x1b8df0(%rip), %rsi    # 0x4fb59d
leaq 0x214cb7(%rip), %rdx    # 0x55746b
leaq 0x214cbe(%rip), %rcx    # 0x557479
leaq 0x214c1a(%rip), %r8     # 0x5573dc
movl $0x494, %r9d            # imm = 0x494
movb $0x0, %al
callq 0x33960
callq 0x2f830
jmp 0x3427d6
movq (%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0x214bf7(%rip), %rsi    # 0x5573dc
movl $0x495, %edx            # imm = 0x495
callq 0x31f10
movq (%rsp), %rax
movq 0xa8(%rax), %rdi
leaq 0x214bdb(%rip), %rsi    # 0x5573dc
movl $0x496, %edx            # imm = 0x496
callq 0x31f10
movq (%rsp), %rax
movq 0xb0(%rax), %rdi
leaq 0x214bbf(%rip), %rsi    # 0x5573dc
movl $0x497, %edx            # imm = 0x497
callq 0x31f10
movq (%rsp), %rax
movq 0x88(%rax), %rdi
leaq 0x214ba3(%rip), %rsi    # 0x5573dc
movl $0x498, %edx            # imm = 0x498
callq 0x31f10
movq (%rsp), %rax
movq 0x38(%rax), %rdi
leaq 0x214b8a(%rip), %rsi    # 0x5573dc
movl $0x499, %edx            # imm = 0x499
callq 0x31f10
movq (%rsp), %rax
movq 0x90(%rax), %rdi
leaq 0x214b6e(%rip), %rsi    # 0x5573dc
movl $0x49a, %edx            # imm = 0x49A
callq 0x31f10
movq (%rsp), %rax
movq 0x50(%rax), %rdi
leaq 0x214b55(%rip), %rsi    # 0x5573dc
movl $0x49b, %edx            # imm = 0x49B
callq 0x31f10
movq (%rsp), %rax
movq 0x58(%rax), %rdi
leaq 0x214b3c(%rip), %rsi    # 0x5573dc
movl $0x49c, %edx            # imm = 0x49C
callq 0x31f10
movq (%rsp), %rax
movq 0x98(%rax), %rdi
callq 0x28e510
movq (%rsp), %rax
movq 0xd0(%rax), %rdi
leaq 0x214b10(%rip), %rsi    # 0x5573dc
movl $0x49e, %edx            # imm = 0x49E
callq 0x31f10
movq (%rsp), %rax
movq 0xd8(%rax), %rdi
leaq 0x214af4(%rip), %rsi    # 0x5573dc
movl $0x49f, %edx            # imm = 0x49F
callq 0x31f10
movq (%rsp), %rax
movq 0x118(%rax), %rdi
callq 0x30bf0
movq (%rsp), %rax
movq 0x120(%rax), %rdi
callq 0x30bf0
movq (%rsp), %rax
movq 0xa0(%rax), %rdi
callq 0x2fc90
movq (%rsp), %rdi
leaq 0x214aaf(%rip), %rsi    # 0x5573dc
movl $0x4a3, %edx            # imm = 0x4A3
callq 0x31f10
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-hpcorrect.c
// Function: gt_randomcodes_hpcorrect_partition_kmer_itv
static void gt_randomcodes_hpcorrect_partition_kmer_itv(
    const GtSeqnumrelpos *snrp, const GtUword *suffixes,
    GtUword nofsuffixes, GtRandomcodesHpcorrectData *sdata)
{
    GtUword partnum, partsize, offset, nof_parts;
    gt_assert(sdata->maxwidth > 0);
    nof_parts = 1 + nofsuffixes / sdata->maxwidth;
    partsize = nofsuffixes / nof_parts;
    for (partnum = 0, offset = 0; partnum < nof_parts - 1;
         partnum++, offset+=partsize)
    {
      gt_randomcodes_hpcorrect_process_kmer_itv(snrp, suffixes + offset,
          partsize, sdata);
    }
    if (nofsuffixes - offset > 0)
      gt_randomcodes_hpcorrect_process_kmer_itv(snrp, suffixes + offset,
          nofsuffixes - offset, sdata);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, 0xc0(%rax)
ja 0x34299f
movq 0x2b965a(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x1b8c25(%rip), %rsi    # 0x4fb59d
leaq 0x214b1f(%rip), %rdx    # 0x55749e
leaq 0x214b2c(%rip), %rcx    # 0x5574b2
leaq 0x214a4f(%rip), %r8     # 0x5573dc
movl $0x36d, %r9d            # imm = 0x36D
movb $0x0, %al
callq 0x33960
callq 0x2f830
jmp 0x3429a1
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
xorl %edx, %edx
divq 0xc0(%rcx)
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x8(%rsp)
movq %rax, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x342a39
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x10(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq 0x18(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x341e80
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x3429e2
movq 0x30(%rsp), %rax
subq 0x10(%rsp), %rax
cmpq $0x0, %rax
jbe 0x342a73
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x10(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq 0x30(%rsp), %rdx
subq 0x10(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x341e80
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-hpcorrect.c
// Function: gt_randomcodes_hpcorrect_fill_hmers
static void gt_randomcodes_hpcorrect_fill_hmers(
    const GtSeqnumrelpos *snrp, const GtUword *suffixes,
    GtUword nofsuffixes, GtRandomcodesHpcorrectData *sdata)
{
  GtUword i;
  for (i = 0; i < nofsuffixes; i++)
  {
    GtUword relpos, seqnum, startpos, kmerpos;
    relpos = gt_seqnumrelpos_decode_relpos(snrp, suffixes[i]);
    seqnum = gt_seqnumrelpos_decode_seqnum(snrp, suffixes[i]);
    startpos = gt_encseq_seqstartpos(sdata->encseq, seqnum);
    kmerpos = startpos + relpos;
    gt_hplstore_get_range(sdata->hplstore,
        GT_RANDOMCODES_HPCORRECT_HMER(sdata,i), kmerpos, sdata->hmers_width);
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x342e09
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x398350
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x398330
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x31a00
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rsi
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
imulq 0x48(%rcx), %rax
addq %rax, %rsi
movq (%rsp), %rdx
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rcx
callq 0x3243a0
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x342d51
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-hpcorrect.c
// Function: gt_randomcodes_hpcorrect_process_cluster
static inline void gt_randomcodes_hpcorrect_process_cluster(
    const GtSeqnumrelpos *snrp, const GtUword *suffixes,
    GtUword nofsuffixes, GtRandomcodesHpcorrectData *sdata,
    GtUword clusternum)
{
  gt_randomcodes_hpcorrect_compute_consensus_hmer(nofsuffixes, sdata,
      clusternum);
  gt_randomcodes_hpcorrect_correct_hmers(snrp, suffixes, nofsuffixes,
      sdata, clusternum);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x343c50
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
callq 0x343cc0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-hpcorrect.c
// Function: gt_randomcodes_hpcorrect_fill_pw_scores_matrix
static inline void gt_randomcodes_hpcorrect_fill_pw_scores_matrix(
    GtUword nofsuffixes, GtRandomcodesHpcorrectData *sdata)
{
  GtUword i, j;
  bool identical;
  for (i = 0; i < nofsuffixes; i++)
  {
    for (j = i + 1; j < nofsuffixes; j++)
    {
      GT_RANDOMCODES_HPCORRECT_PW_SCORE(sdata,i,j) =
        gt_randomcodes_hpcorrect_compute_hscore(
            &identical, GT_RANDOMCODES_HPCORRECT_HMER(sdata,i),
            GT_RANDOMCODES_HPCORRECT_HMER(sdata,j), sdata->k
            /*, sdata->manhattan, LONG_MAX*/);
    }
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0x34335b
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0x343346
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rsi
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
imulq 0x48(%rcx), %rax
addq %rax, %rsi
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rdx
movq 0x28(%rsp), %rax
movq 0x38(%rsp), %rcx
imulq 0x48(%rcx), %rax
addq %rax, %rdx
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rcx
leaq 0x27(%rsp), %rdi
callq 0x343b30
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq 0xa8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x30(%rsp), %rax
jb 0x3432f1
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
movq 0x40(%rcx), %rcx
shlq %rcx
subq $0x3, %rcx
subq 0x30(%rsp), %rcx
imulq %rcx, %rax
shrq %rax
addq 0x28(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x343320
movq 0x28(%rsp), %rax
movq 0x38(%rsp), %rcx
movq 0x40(%rcx), %rcx
shlq %rcx
subq $0x3, %rcx
subq 0x28(%rsp), %rcx
imulq %rcx, %rax
shrq %rax
addq 0x30(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x343245
jmp 0x343348
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x343227
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-hpcorrect.c
// Function: gt_randomcodes_hpcorrect_compute_hscore
static inline gt_rchc_score_t
    gt_randomcodes_hpcorrect_compute_hscore(
    bool *identical, const uint8_t *hmer1, const uint8_t *hmer2,
    GtUword k)
{
  GtUword i;
  gt_rchc_score_t total_score = 0;
  gt_assert(identical != NULL);
  *identical = true;
  for (i = 0; i < k; i++)
  {
    uint8_t h1 = hmer1[i], h2 = hmer2[i];
    if (h1!=h2)
      *identical = false;
    if (h1 > GT_RCHC_HSCORE_MAXH)
      h1 = GT_RCHC_HSCORE_MAXH;
    if (h2 > GT_RCHC_HSCORE_MAXH)
      h2 = GT_RCHC_HSCORE_MAXH;
    total_score += gt_rchc_hscore[(GT_RCHC_HSCORE_MAXH+1)*h1+h2];
  }
  return total_score;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x343b91
movq 0x2b8468(%rip), %rax    # 0x5fbfc8
movq (%rax), %rdi
leaq 0x1b7a33(%rip), %rsi    # 0x4fb59d
leaq 0x2139d3(%rip), %rdx    # 0x557544
leaq 0x213a17(%rip), %rcx    # 0x55758f
leaq 0x21385d(%rip), %r8     # 0x5573dc
movl $0xe7, %r9d
movb $0x0, %al
callq 0x33960
callq 0x2f830
jmp 0x343b93
movq 0x30(%rsp), %rax
movb $0x1, (%rax)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x343c44
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x7(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x6(%rsp)
movzbl 0x7(%rsp), %eax
movzbl 0x6(%rsp), %ecx
cmpl %ecx, %eax
je 0x343bec
movq 0x30(%rsp), %rax
movb $0x0, (%rax)
movzbl 0x7(%rsp), %eax
cmpl $0x9, %eax
jle 0x343bfb
movb $0x9, 0x7(%rsp)
movzbl 0x6(%rsp), %eax
cmpl $0x9, %eax
jle 0x343c0a
movb $0x9, 0x6(%rsp)
movzbl 0x7(%rsp), %eax
imull $0xa, %eax, %eax
movzbl 0x6(%rsp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x2beacd(%rip), %rax    # 0x6026f0
movq (%rax,%rcx,8), %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x343ba4
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-hpcorrect.c
// Function: gt_randomcodes_hpcorrect_compute_consensus_hmer
static inline void gt_randomcodes_hpcorrect_compute_consensus_hmer(
    GtUword nofsuffixes, GtRandomcodesHpcorrectData *sdata,
    GtUword clusternum)
{
  GtUword pos;
  for (pos = 0; pos < sdata->k; pos++)
  {
    sdata->consensus_hmer[pos] =
      gt_randomcodes_hpcorrect_compute_consensus_for_pos(pos, nofsuffixes,
          sdata, clusternum);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x343cb8
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x344030
movb %al, %dl
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x343c6c
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/randomcodes-hpcorrect.c
// Function: gt_randomcodes_hpcorrect_similar_rext
static inline bool gt_randomcodes_hpcorrect_similar_rext(
    GtRandomcodesHpcorrectData *sdata,
    GtUword u_sfx, GtUword u_kmerpos, int u_offset,
    GtUword t_sfx, GtUword t_kmerpos, int t_offset,
    gt_rchc_score_t minscore)
{
  return (gt_randomcodes_hpcorrect_same_rext_letters(sdata, u_kmerpos, u_offset,
        t_kmerpos, t_offset)) &&
    (gt_randomcodes_hpcorrect_compute_hscore_manhattan(NULL,
          GT_RANDOMCODES_HPCORRECT_HMER(sdata, u_sfx) + sdata->k + u_offset,
          GT_RANDOMCODES_HPCORRECT_HMER(sdata, t_sfx) + sdata->k + t_offset,
          (GtUword)sdata->r) >= minscore);
}

// Assembly:
subq $0x38, %rsp
movq 0x48(%rsp), %rax
movl 0x40(%rsp), %eax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq 0x8(%rsp), %rcx
movl 0x40(%rsp), %r8d
callq 0x3450d0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x345046
jmp 0x3450c0
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rsi
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
imulq 0x48(%rcx), %rax
addq %rax, %rsi
movq 0x30(%rsp), %rax
addq 0x20(%rax), %rsi
movslq 0x1c(%rsp), %rax
addq %rax, %rsi
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rdx
movq 0x10(%rsp), %rax
movq 0x30(%rsp), %rcx
imulq 0x48(%rcx), %rax
addq %rax, %rdx
movq 0x30(%rsp), %rax
addq 0x20(%rax), %rdx
movslq 0x40(%rsp), %rax
addq %rax, %rdx
movq 0x30(%rsp), %rax
movl 0xcc(%rax), %eax
movl %eax, %ecx
xorl %eax, %eax
movl %eax, %edi
callq 0x3451b0
cmpq 0x48(%rsp), %rax
setge %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)