LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-pairwise.c
// Function: find_exact_overlaps
static inline GtContfind find_exact_overlaps(struct Data *d, bool use_kmp,
    GtUword min_length, bool find_nonmaximal)
{
  GtContfind retval;

  if (d->u->seqnum == d->v->seqnum && d->v->direct)
  {
    if (!(d->mode == GT_OVLFIND_SPM || d->mode == GT_OVLFIND_ALL))
      return GT_CONTFIND_EQ;
    if (use_kmp)
      retval = gt_ovlfind_kmp(d->u->seq, d->u->len, d->u->pi, NULL, 0, NULL,
          d->mode, min_length, find_nonmaximal, call_spmproc, d);
    else
      retval = gt_ovlfind_bf(d->u->seq, d->u->len, NULL, 0, d->mode,
          min_length, find_nonmaximal, call_spmproc, d);
  }
  else
  {
    if (use_kmp)
      retval = gt_ovlfind_kmp(d->u->seq, d->u->len, d->u->pi, d->v->seq,
          d->v->len, d->v->pi, d->mode, min_length, find_nonmaximal,
          call_spmproc, d);
    else
      retval = gt_ovlfind_bf(d->u->seq, d->u->len, d->v->seq, d->v->len,
          d->mode, min_length, find_nonmaximal, call_spmproc, d);
  }
  return retval;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rax
movq %rdi, %r10
movq 0x18(%rdi), %rdx
movq 0x20(%rdi), %r9
movq 0x10(%rdx), %rdi
cmpq 0x10(%r9), %rdi
jne 0x1cabe5
cmpb $0x1, 0x18(%r9)
jne 0x1cabe5
movl 0x28(%r10), %r11d
testl $0xfffffffd, %r11d      # imm = 0xFFFFFFFD
jne 0x1cac66
movq (%rdx), %rdi
movq 0x8(%rdx), %r8
testb %sil, %sil
je 0x1cac71
movq 0x20(%rdx), %rdx
subq $0x8, %rsp
leaq 0x12f(%rip), %rbx       # 0x1cacfb
movzbl %cl, %r14d
movq %r8, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rbx
pushq %r14
pushq %rax
pushq %r11
jmp 0x1cac22
movq (%rdx), %rdi
movq 0x8(%rdx), %r11
testb %sil, %sil
je 0x1cac2d
movq 0x20(%rdx), %rdx
movq (%r9), %rbx
movq 0x8(%r9), %r8
movq 0x20(%r9), %r9
movl 0x28(%r10), %r14d
subq $0x8, %rsp
leaq 0xec(%rip), %r15        # 0x1cacfb
movzbl %cl, %r12d
movq %r11, %rsi
movq %rbx, %rcx
pushq %r10
pushq %r15
pushq %r12
pushq %rax
pushq %r14
callq 0x327df4
addq $0x38, %rsp
jmp 0x1cac5e
movq (%r9), %rdx
movq 0x8(%r9), %r9
movl 0x28(%r10), %r8d
subq $0x8, %rsp
leaq 0xb8(%rip), %rbx        # 0x1cacfb
movzbl %cl, %r14d
movq %r11, %rsi
movq %r9, %rcx
movq %rax, %r9
pushq %r10
pushq %rbx
pushq %r14
callq 0x324b8c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x2, %eax
addq $0x8, %rsp
jmp 0x1cac5e
subq $0x8, %rsp
leaq 0x7f(%rip), %rbx        # 0x1cacfb
movzbl %cl, %r14d
movq %r8, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movl %r11d, %r8d
jmp 0x1cac4d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-spmfind.c
// Function: processleafedge_spmvar
static inline int processleafedge_spmvar(bool firstsucc,
    GtUword fatherdepth,
    GtBUinfo_spmeq *father, GtUword seqnum, GtUword relpos,
    GtBUstate_spmeq *state, GT_UNUSED GtError *err)
{
  if (fatherdepth >= state->minmatchlength)
  {
    GtUword seqlen = gt_encseq_seqlength(state->encseq, seqnum);
    if (firstsucc)
    {
      gt_assert(father != NULL);
      father->w_left = state->w_nextfree;
    }
    if (relpos == 0)
    {
      appendtowset_spm(seqnum, state);
      if (fatherdepth == seqlen)
      {
        GtUword readnum = GT_READJOINER_READNUM(seqnum,
            state->first_revcompl, state->nofreads);
        (void)fwrite(&(readnum), sizeof (GtUword), (size_t)1,
            state->cntfile);
        state->nof_contained++;
      }
    }
    if (relpos + fatherdepth == seqlen)
      appendtolset_spm(seqnum, state);
  }
  else
  {
#ifdef GT_READJOINER_STATISTICS
    reset_subtree_stats(state);
#endif
    state->w_nextfree = 0;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
cmpq %rsi, 0x20(%r9)
jbe 0x1cadb4
movq $0x0, 0x80(%rbx)
jmp 0x1cae9b
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %rbp
movq %rsi, %r12
movl %edi, %r13d
movq 0x38(%rbx), %rdi
movq %rcx, %rsi
callq 0xeb9d2
testb %r13b, %r13b
je 0x1cade8
testq %rbp, %rbp
je 0x1caeaa
movq 0x80(%rbx), %rcx
movq %rcx, (%rbp)
testq %r15, %r15
jne 0x1cae42
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %r13
callq 0x1cc252
movq %r13, %rax
cmpq %r12, %r13
jne 0x1cae42
movq 0x58(%rbx), %rcx
decq %rcx
movq %r14, %rax
cmpq %r14, %rcx
jae 0x1cae1c
movq %r14, %rax
notq %rax
addq 0x50(%rbx), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
movq 0xe0(%rbx), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x17fa0
incq 0xe8(%rbx)
movq %r13, %rax
addq %r12, %r15
cmpq %rax, %r15
jne 0x1cae9b
movq 0x68(%rbx), %rcx
cmpq 0x70(%rbx), %rcx
jne 0x1cae8f
leaq 0x400(%rcx), %rax
movq %rax, 0x70(%rbx)
movq 0x60(%rbx), %rdi
leaq 0x2000(,%rcx,8), %rsi
leaq 0x1e36aa(%rip), %rdx    # 0x3ae51c
movl $0xf7, %ecx
callq 0x104461
movq %rax, 0x60(%rbx)
movq 0x68(%rbx), %rcx
cmpq 0x70(%rbx), %rcx
jb 0x1cae93
callq 0x6af90
movq 0x60(%rbx), %rax
movq %r14, (%rax,%rcx,8)
incq 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x6afc9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-spmfind.c
// Function: appendtowset_spm
static inline void appendtowset_spm(GtUword seqnum,
  GtBUstate_spm *state)
{
  WholereadInfo *w;

  state->w_count++;
  if (state->w_count <= state->w_offset)
    return;

  if (state->w_count > state->w_offset + state->w_maxsize)
  {
    state->w_overflow = true;
    return;
  }

  /* realloc if necessary */
  if (state->w_nextfree == state->w_allocated)
    expandwset_spm(state);

  /* add element */
#ifdef GT_READJOINER_DEBUG
  gt_log_log("-- add to wset: "GT_WU"", seqnum);
  gt_log_log("offset: "GT_WU"", state->w_offset);
#endif
  w = state->w_set + state->w_nextfree;
  state->w_nextfree++;

  w->seqnum = seqnum;
  /* get a new blind trie or recycle old one */
  if (w->blindtrie == NULL)
    w->blindtrie = gt_blindtrie_new(NULL, 0,
        GT_SPMFIND_BLTRIE_ALLOC, state->encseq, false, NULL,
        NULL, GT_READMODE_REVERSE);
  else
    gt_blindtrie_reset(w->blindtrie);

#ifdef GT_READJOINER_STATISTICS
  /* statistics */
  if (state->w_nextfree > state->max_w_nextfree)
    state->max_w_nextfree = state->w_nextfree;
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x90(%rsi), %rax
movq 0x98(%rsi), %rcx
incq %rcx
movq %rcx, 0x98(%rsi)
cmpq %rax, %rcx
jbe 0x1cc3fc
movq %rsi, %rbx
addq 0xa0(%rsi), %rax
cmpq %rax, %rcx
jbe 0x1cc296
movb $0x1, 0xa8(%rbx)
jmp 0x1cc3fc
movq %rdi, %r14
movq 0x80(%rbx), %r12
cmpq 0x88(%rbx), %r12
jne 0x1cc3a2
leaq 0x400(%r12), %rsi
movq %rsi, 0x88(%rbx)
movq 0x78(%rbx), %rdi
shlq $0x4, %rsi
leaq 0x1e2251(%rip), %rdx    # 0x3ae51c
movl $0x8d, %ecx
callq 0x104461
movq %rax, %r15
movq %rax, 0x78(%rbx)
movq 0x88(%rbx), %rax
movq %rax, %rdx
subq %r12, %rdx
jbe 0x1cc391
leaq 0x1(%rdx), %rcx
andq $-0x2, %rcx
decq %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shlq $0x4, %r12
leaq (%r12,%r15), %rdx
addq $0x18, %rdx
xorl %esi, %esi
movdqa 0x18c706(%rip), %xmm1   # 0x358a20
movdqa 0x18c70e(%rip), %xmm2   # 0x358a30
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rsi, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6     # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4     # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %edi
notl %edi
testb $0x1, %dil
je 0x1cc36e
movq $0x0, -0x10(%rdx)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %edi
testb $0x1, %dil
je 0x1cc384
movq $0x0, (%rdx)
addq $0x2, %rsi
addq $0x20, %rdx
cmpq %rsi, %rcx
jne 0x1cc32a
movq 0x80(%rbx), %r12
cmpq %rax, %r12
jb 0x1cc3a6
callq 0x6b63e
movq 0x78(%rbx), %r15
movq %r12, %rax
shlq $0x4, %rax
incq %r12
movq %r12, 0x80(%rbx)
movq %r14, (%r15,%rax)
movq 0x8(%r15,%rax), %rdi
testq %rdi, %rdi
je 0x1cc3d5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1e6182
addq %rax, %r15
movq 0x38(%rbx), %rcx
xorl %edi, %edi
xorl %esi, %esi
movl $0x40, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x1
pushq $0x0
callq 0x1e5fec
addq $0x10, %rsp
movq %rax, 0x8(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-spmfind.c
// Function: processlcpinterval_spmvar
static int processlcpinterval_spmvar(GtUword lcp,
    GtBUinfo_spmvar *info, GtBUstate_spmvar *state, GT_UNUSED GtError *err)
{
  if (lcp >= state->minmatchlength)
  {
    GtUword i;
    for (i = 0; i < state->l_nextfree; i++)
    {
      combine_terminal_with_wset(state->l_set[i],
          gt_encseq_seqstartpos(state->encseq, state->l_set[i]),
          gt_encseq_seqlength(state->encseq, state->l_set[i]), info->w_left,
          lcp, state);
    }
    state->l_nextfree = 0;
  }
  return 0;
}

// Assembly:
cmpq %rdi, 0x20(%rdx)
ja 0x1cc6be
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
cmpq $0x0, 0x68(%rdx)
je 0x1cc6a8
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movq 0x38(%rbx), %rdi
movq 0x60(%rbx), %rax
movq (%rax,%rbp,8), %r12
movq %r12, %rsi
callq 0xeb6ee
movq %rax, %r13
movq 0x38(%rbx), %rdi
movq 0x60(%rbx), %rax
movq (%rax,%rbp,8), %rsi
callq 0xeb9d2
movq (%r14), %rcx
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %r15, %r8
movq %rbx, %r9
callq 0x1cc408
incq %rbp
cmpq 0x68(%rbx), %rbp
jb 0x1cc660
movq $0x0, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-spmlist.c
// Function: gt_spmlist_parse_ascii_approx
int gt_spmlist_parse_ascii_approx(const char* filename,
    GtUword min_length, GtSpmprocA processoverlap, void *data,
    GtError *err)
{
  int retval = 0;
  GtFile *infp;

  /*@i1@*/ gt_error_check(err);
  infp = gt_file_new(filename, "r", err);
  if (infp == NULL) return -1;
  retval = gt_spmlist_parse_ascii_generic(infp, min_length, NULL,
      processoverlap, data, err);
  gt_file_delete(infp);
  return retval;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
testq %r8, %r8
je 0x1cc7ba
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1cc807
leaq 0x18e694(%rip), %rsi    # 0x35ae55
movq %r13, %rdi
movq %rbx, %rdx
callq 0xfea8a
testq %rax, %rax
je 0x1cc7f8
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x1cc80c
movl %eax, %ebx
movq %r13, %rdi
callq 0xff22c
movl %ebx, %eax
jmp 0x1cc7fd
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x6b8a5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-spmlist.c
// Function: gt_spmlist_parse_ascii_generic
static int gt_spmlist_parse_ascii_generic(GtFile *infp,
    GtUword min_length, GtSpmproc proc_e, GtSpmprocA proc_a, void *data,
    GtError *err)
{
  int had_err = 0;
  GtStr *line;
  gt_error_check(err);
  line = gt_str_new();
  while (!had_err && gt_str_read_next_line_generic(line, infp) != EOF)
  {
    had_err = parse_line(line, min_length, proc_e, proc_a, data, err);
    gt_str_reset(line);
  }
  gt_str_delete(line);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
testq %r9, %r9
je 0x1cc841
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1cc8a3
callq 0x11ac6c
movq %rax, %r14
movq %r14, %rdi
movq %rbp, %rsi
callq 0x11b32c
cmpl $-0x1, %eax
je 0x1cc886
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
movq %rbx, %r9
callq 0x1cdb1a
movl %eax, %r15d
movq %r14, %rdi
callq 0x11b132
testl %r15d, %r15d
je 0x1cc849
jmp 0x1cc889
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x11bdbf
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x6b8de
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-spmproc.c
// Function: gt_spmproc_skip
void gt_spmproc_skip(GtUword suffix_seqnum, GtUword prefix_seqnum,
  GtUword length, bool suffixseq_direct, bool prefixseq_direct,
  void *data)
{
  GtSpmprocSkipData *d = data;

  if (d->to_skip != NULL)
  {
    if ((bool)GT_ISIBITSET(d->to_skip, suffix_seqnum) ||
        (bool)GT_ISIBITSET(d->to_skip, prefix_seqnum))
    {
      d->skipped_counter++;
      return;
    }
  }
  if (d->out.e.proc != NULL)
  {
    d->out.e.proc(suffix_seqnum, prefix_seqnum, length, suffixseq_direct,
                  prefixseq_direct, d->out.e.data);
  }
}

// Assembly:
movl %ecx, %eax
movq (%r9), %r10
testq %r10, %r10
je 0x1cde73
movq %rdi, %rcx
shrq $0x6, %rcx
movq (%r10,%rcx,8), %r11
movl %edi, %ecx
shlq %cl, %r11
shrq $0x3f, %r11
jne 0x1cde6e
movabsq $-0x8000000000000000, %r11 # imm = 0x8000000000000000
movl %esi, %ecx
shrq %cl, %r11
movq %rsi, %rcx
shrq $0x6, %rcx
testq %r11, (%r10,%rcx,8)
je 0x1cde73
incq 0x18(%r9)
retq
movq 0x8(%r9), %r11
testq %r11, %r11
je 0x1cde8a
movq 0x10(%r9), %r9
movzbl %al, %ecx
movzbl %r8b, %r8d
jmpq *%r11
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-spmproc.c
// Function: gt_spmproc_a_skip
void gt_spmproc_a_skip(GtUword suffix_seqnum,
                       GtUword prefix_seqnum,
                       GtUword suffix_length,
                       GtUword prefix_length,
                       GtUword unit_edist,
                       bool suffixseq_direct,
                       bool prefixseq_direct,
                       void *data)
{
  GtSpmprocSkipData *d = data;

  if (d->to_skip != NULL)
  {
    if ((bool)GT_ISIBITSET(d->to_skip, suffix_seqnum) ||
        (bool)GT_ISIBITSET(d->to_skip, prefix_seqnum))
    {
      d->skipped_counter++;
      return;
    }
  }

  if (d->out.a.proc != NULL)
  {
    d->out.a.proc(suffix_seqnum, prefix_seqnum, suffix_length, prefix_length,
                unit_edist, suffixseq_direct, prefixseq_direct, d->out.a.data);
  }
}

// Assembly:
pushq %rbx
movq %rcx, %rax
movq 0x18(%rsp), %r10
movq (%r10), %r11
testq %r11, %r11
je 0x1cded4
movq %rdi, %rcx
shrq $0x6, %rcx
movq (%r11,%rcx,8), %rbx
movl %edi, %ecx
shlq %cl, %rbx
shrq $0x3f, %rbx
jne 0x1cdece
movabsq $-0x8000000000000000, %rbx # imm = 0x8000000000000000
movl %esi, %ecx
shrq %cl, %rbx
movq %rsi, %rcx
shrq $0x6, %rcx
testq %rbx, (%r11,%rcx,8)
je 0x1cded4
incq 0x18(%r10)
jmp 0x1cdef7
movq 0x8(%r10), %r11
testq %r11, %r11
je 0x1cdef7
movb 0x10(%rsp), %cl
movzbl %cl, %ebx
movzbl %r9b, %r9d
movq %rax, %rcx
pushq 0x10(%r10)
pushq %rbx
callq *%r11
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-spmproc.c
// Function: gt_spmproc_skip_unit_test
int gt_spmproc_skip_unit_test(GtError *err)
{
  int had_err = 0;
  GtSpmprocSkipData d;
  bool skipped;

  gt_error_check(err);
  GT_INITBITTAB(d.to_skip, 4);
  GT_SETIBIT(d.to_skip, 1);
  GT_SETIBIT(d.to_skip, 2);
  GT_SPMPROC_SKIP_TEST(0UL, 1UL, true);
  GT_SPMPROC_SKIP_TEST(1UL, 2UL, true);
  GT_SPMPROC_SKIP_TEST(2UL, 3UL, true);
  GT_SPMPROC_SKIP_TEST(0UL, 3UL, false);

  gt_free(d.to_skip);

  return had_err;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1cdf08
callq 0xfcc32
testb %al, %al
jne 0x1cdf44
leaq 0x1e12a3(%rip), %rbx    # 0x3af1b2
movl $0x8, %esi
xorl %edi, %edi
movq %rbx, %rdx
movl $0x7e, %ecx
callq 0x104461
movabsq $0x6000000000000000, %rcx # imm = 0x6000000000000000
movq %rcx, (%rax)
movq %rax, %rdi
movq %rbx, %rsi
movl $0x86, %edx
callq 0x1045eb
xorl %eax, %eax
popq %rbx
retq
callq 0x6ba34
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_show_limits
void gt_strgraph_show_limits(void)
{
  printf("# max number of reads: "GT_WU"\n", (GtUword) GT_STRGRAPH_N_READS_MAX);
  printf("# max read length: "FormatGtStrgraphLength"\n",
      PRINTGtStrgraphLengthcast(GT_STRGRAPH_LENGTH_MAX));
  printf("# max degree of a vertex: "FormatGtStrgraphVEdgenum"\n",
      PRINTGtStrgraphVEdgenumcast(GT_STRGRAPH_V_EDGENUM_MAX));
  printf("# max number of spm: "FormatGtStrgraphEdgenum"\n",
      PRINTGtStrgraphEdgenumcast(GT_STRGRAPH_NOFSPM_MAX));
  printf("# compile-time chosen representations\n");
  printf("# - counts: %s\n",   GT_STRGRAPH_COUNTS_REPRESENTATION);
  printf("# - vertices: %s\n", GT_STRGRAPH_VERTICES_REPRESENTATION);
  printf("# - edges: %s\n",    GT_STRGRAPH_EDGES_REPRESENTATION);
}

// Assembly:
pushq %rbx
leaq 0x1e127c(%rip), %rdi    # 0x3af245
movabsq $0x7ffffffffffffffe, %rbx # imm = 0x7FFFFFFFFFFFFFFE
movq %rbx, %rsi
xorl %eax, %eax
callq 0x17070
leaq 0x1e127d(%rip), %rdi    # 0x3af261
movq $-0x1, %rsi
xorl %eax, %eax
callq 0x17070
leaq 0x1e1280(%rip), %rdi    # 0x3af279
movq $-0x2, %rsi
xorl %eax, %eax
callq 0x17070
incq %rbx
leaq 0x1e1287(%rip), %rdi    # 0x3af298
movq %rbx, %rsi
xorl %eax, %eax
callq 0x17070
leaq 0x1e3ffa(%rip), %rdi    # 0x3b201c
callq 0x17bd0
leaq 0x1e1284(%rip), %rdi    # 0x3af2b2
leaq 0x1e128d(%rip), %rsi    # 0x3af2c2
xorl %eax, %eax
callq 0x17070
leaq 0x1e1297(%rip), %rdi    # 0x3af2da
leaq 0x1e11f3(%rip), %rsi    # 0x3af23d
xorl %eax, %eax
callq 0x17070
leaq 0x1e1294(%rip), %rdi    # 0x3af2ec
leaq 0x1e11d7(%rip), %rsi    # 0x3af236
xorl %eax, %eax
popq %rbx
jmp 0x17070
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_longest_read
GtStrgraphLength gt_strgraph_longest_read(GtStrgraph *strgraph)
{
  if (strgraph->fixlen > 0)
  {
    return strgraph->fixlen;
  }
  else
  {
    GtStrgraphLength seqlen, maxseqlen;
    GtStrgraphVnum i;

    gt_assert(strgraph->encseq != NULL);
    maxseqlen = 0;
    for (i = 0; i < GT_STRGRAPH_NOFREADS(strgraph); i++)
    {
      seqlen = (GtStrgraphLength)gt_encseq_seqlength(strgraph->encseq,
          (GtUword)i);
      if (seqlen > maxseqlen)
        maxseqlen = seqlen;
    }
    gt_assert(maxseqlen > 0);
    gt_assert(sizeof (GtStrgraphLength) >= sizeof (GtUword) ||
        maxseqlen <= GT_STRGRAPH_LENGTH_MAX);
    return maxseqlen;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
jne 0x1ce0b7
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x1ce0c5
cmpq $0x2, 0x80(%rbx)
jb 0x1ce0c0
xorl %r15d, %r15d
xorl %r14d, %r14d
movq (%rbx), %rdi
movq %r15, %rsi
callq 0xeb9d2
cmpq %r14, %rax
cmovaq %rax, %r14
incq %r15
movq 0x80(%rbx), %rax
shrq %rax
cmpq %rax, %r15
jb 0x1ce08e
testq %r14, %r14
je 0x1ce0c0
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x6ba6b
callq 0x6baa4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_largest_count
GtStrgraphCount gt_strgraph_largest_count(GtStrgraph *strgraph)
{
  GtStrgraphCount count, maxcount;
  GtStrgraphVnum i;
  maxcount = 0;

  gt_assert(strgraph != NULL &&\
            strgraph->__small_counts != NULL &&
            strgraph->__large_counts != NULL);
  for (i = 0; i < (GT_STRGRAPH_NOFVERTICES(strgraph)); i++)
  {
    GT_STRGRAPH_GET_COUNT(strgraph, count, i);
    if (count > maxcount)
      maxcount = count;
  }
  return maxcount;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1ce15b
movq %rdi, %rbx
cmpq $0x0, 0x40(%rdi)
je 0x1ce15b
cmpq $0x0, 0x48(%rbx)
je 0x1ce15b
movq 0x80(%rbx), %rax
testq %rax, %rax
je 0x1ce144
xorl %r12d, %r12d
movq %rsp, %r15
xorl %r14d, %r14d
movq 0x40(%rbx), %rcx
movzbl (%rcx,%r12), %ecx
cmpq $0xff, %rcx
jne 0x1ce133
movq 0x48(%rbx), %rdi
movq %r12, (%rsp)
movq %r15, %rsi
callq 0x1012ee
testq %rax, %rax
je 0x1ce156
movq 0x8(%rax), %rcx
movq 0x80(%rbx), %rax
cmpq %r14, %rcx
cmovaq %rcx, %r14
incq %r12
cmpq %rax, %r12
jb 0x1ce101
jmp 0x1ce147
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x6badd
callq 0x6bb16
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_counts_sum
GtStrgraphEdgenum gt_strgraph_counts_sum(GtStrgraph *strgraph)
{
  GtStrgraphCount count;
  GtStrgraphEdgenum sum;
  GtStrgraphVnum i;
  sum = 0;
  for (i = 0; i < (GT_STRGRAPH_NOFVERTICES(strgraph)); i++)
  {
    gt_assert(sizeof (GtStrgraphEdgenum) >= sizeof (GtStrgraphVEdgenum));
    GT_STRGRAPH_GET_COUNT(strgraph, count, i);
    sum += count;
  }
  return sum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x1ce1bf
movq %rdi, %rbx
xorl %r12d, %r12d
movq %rsp, %r15
xorl %r14d, %r14d
movq 0x40(%rbx), %rcx
movzbl (%rcx,%r12), %ecx
cmpq $0xff, %rcx
jne 0x1ce1b2
movq 0x48(%rbx), %rdi
movq %r12, (%rsp)
movq %r15, %rsi
callq 0x1012ee
testq %rax, %rax
je 0x1ce1d1
movq 0x8(%rax), %rcx
movq 0x80(%rbx), %rax
addq %rcx, %r14
incq %r12
cmpq %rax, %r12
jb 0x1ce180
jmp 0x1ce1c2
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x6bb4f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_new
GtStrgraph* gt_strgraph_new(GtUword nofreads)
{
  GtStrgraph *strgraph;
  strgraph = gt_calloc((size_t)1, sizeof (GtStrgraph));
  strgraph->state = GT_STRGRAPH_PREPARATION;
  strgraph->load_self_spm = false;
  strgraph->minmatchlen = GT_STRGRAPH_LENGTH_MAX;
  strgraph->rlt = NULL;
  gt_strgraph_show_limits_debug_log();
  GT_STRGRAPH_CHECK_NOFREADS(nofreads);
  GT_STRGRAPH_SET_NOFVERTICES(strgraph, (GtStrgraphVnum)nofreads << 1);
  GT_STRGRAPH_ALLOC_COUNTS(strgraph, GT_STRGRAPH_NOFVERTICES(strgraph));
  return strgraph;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
leaq 0x1e1144(%rip), %r15    # 0x3af32d
movl $0x1, %edi
movl $0xa0, %esi
movq %r15, %rdx
movl $0x191, %ecx            # imm = 0x191
callq 0x10436a
movq %rax, %rbx
movl $0x0, 0x10(%rax)
movb $0x0, 0x28(%rax)
movq $-0x1, 0x30(%rax)
movq $0x0, 0x38(%rax)
leaq 0x1e0fdf(%rip), %rdi    # 0x3af204
leaq 0x1e1011(%rip), %rsi    # 0x3af23d
leaq 0x1e1003(%rip), %rdx    # 0x3af236
xorl %eax, %eax
callq 0x103d72
addq %r14, %r14
movq %r14, 0x80(%rbx)
movl $0x1, %esi
movq %r14, %rdi
movq %r15, %rdx
movl $0x199, %ecx            # imm = 0x199
callq 0x10436a
movq %rax, 0x40(%rbx)
movups 0x2ec30c(%rip), %xmm0   # 0x4ba570
movups %xmm0, 0x20(%rsp)
movups 0x2ec2f0(%rip), %xmm0   # 0x4ba560
movups %xmm0, 0x10(%rsp)
movups 0x2ec2d4(%rip), %xmm0   # 0x4ba550
movups %xmm0, (%rsp)
callq 0x101194
movq %rax, 0x48(%rbx)
movq 0x80(%rbx), %rax
movq %rax, 0x50(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_delete
void gt_strgraph_delete(GtStrgraph *strgraph)
{
  if (strgraph != NULL)
  {
    GT_STRGRAPH_FREE_VERTICES(strgraph);
    GT_STRGRAPH_FREE_EDGES(strgraph);
    GT_STRGRAPH_FREE_COUNTS(strgraph);
    gt_reads_libraries_table_delete(strgraph->rlt);
    gt_free(strgraph);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1ce7b7
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %r14
testq %r14, %r14
je 0x1ce6af
movq (%r14), %rdi
leaq 0x192646(%rip), %r15    # 0x360cd8
movq %r15, %rsi
movl $0x5d, %edx
callq 0x1045eb
movq %r14, %rdi
movq %r15, %rsi
movl $0x5e, %edx
callq 0x1045eb
movq 0x70(%rbx), %r14
testq %r14, %r14
je 0x1ce6df
movq (%r14), %rdi
leaq 0x192616(%rip), %r15    # 0x360cd8
movq %r15, %rsi
movl $0x5d, %edx
callq 0x1045eb
movq %r14, %rdi
movq %r15, %rsi
movl $0x5e, %edx
callq 0x1045eb
leaq 0x58(%rbx), %r12
movq 0x60(%rbx), %r14
testq %r14, %r14
je 0x1ce713
movq (%r14), %rdi
leaq 0x1925e2(%rip), %r15    # 0x360cd8
movq %r15, %rsi
movl $0x5d, %edx
callq 0x1045eb
movq %r14, %rdi
movq %r15, %rsi
movl $0x5e, %edx
callq 0x1045eb
movq $0x0, 0x70(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movq 0x88(%rbx), %r14
testq %r14, %r14
je 0x1ce756
movq (%r14), %rdi
leaq 0x19259f(%rip), %r15    # 0x360cd8
movq %r15, %rsi
movl $0x5d, %edx
callq 0x1045eb
movq %r14, %rdi
movq %r15, %rsi
movl $0x5e, %edx
callq 0x1045eb
xorl %r14d, %r14d
movq %r14, 0x88(%rbx)
movq 0x40(%rbx), %rdi
leaq 0x1e0bc2(%rip), %rsi    # 0x3af32d
movl $0x1ce, %edx            # imm = 0x1CE
callq 0x1045eb
movq %r14, 0x40(%rbx)
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x1ce787
callq 0x101d90
movq $0x0, 0x48(%rbx)
movq 0x38(%rbx), %rdi
callq 0x1df427
leaq 0x1e0b8e(%rip), %rsi    # 0x3af32d
movq %rbx, %rdi
movl $0x1d0, %edx            # imm = 0x1D0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_load_reads_library_table
int gt_strgraph_load_reads_library_table(GtStrgraph *strgraph,
    FILE *rlt_fp, GtError *err)
{
  gt_assert(strgraph != NULL);
  gt_assert(strgraph->rlt == NULL);
  strgraph->rlt = gt_reads_libraries_table_load(rlt_fp, err);
  return (strgraph->rlt == NULL) ? -1 : 0;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1ce7e3
movq %rdi, %rbx
cmpq $0x0, 0x38(%rdi)
jne 0x1ce7e8
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1df5a5
movq %rax, 0x38(%rbx)
xorl %ecx, %ecx
cmpq $0x1, %rax
sbbl %ecx, %ecx
movl %ecx, %eax
popq %rbx
retq
callq 0x6bcde
callq 0x6bca5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_get_file
static GtFile* gt_strgraph_get_file(const char *indexname, const char *suffix,
    bool write, bool gzipped)
{
  GtFile *file;
  GtStr *filename;
  GtError *err;

  err = gt_error_new();
  filename = gt_str_new_cstr(indexname);
  gt_str_append_cstr(filename, suffix);
  if (!write && !gt_file_exists(gt_str_get(filename)))
  {
    fprintf(stderr, "file %s does not exist\n", gt_str_get(filename));
    exit(EXIT_FAILURE);
  }
  file = gt_file_open(gzipped ? GT_FILE_MODE_GZIP : GT_FILE_MODE_UNCOMPRESSED,
      gt_str_get(filename), write ? "wb" : "r", err);
  if (file == NULL)
  {
    fprintf(stderr, "%s", gt_error_get(err));
    exit(EXIT_FAILURE);
  }
  gt_str_delete(filename);
  gt_error_delete(err);
  return file;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
callq 0xfcb4c
movq %rax, %rbx
movq %r14, %rdi
callq 0x11acc9
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
callq 0x11acf3
testl %r15d, %r15d
je 0x1cf1fe
leaq 0x1868e5(%rip), %r15    # 0x355ae1
jmp 0x1cf219
movq %r14, %rdi
callq 0x11b0a1
movq %rax, %rdi
callq 0xff28c
testb %al, %al
je 0x1cf261
leaq 0x18bc3c(%rip), %r15    # 0x35ae55
movzbl %bpl, %ebp
movq %r14, %rdi
callq 0x11b0a1
movl %ebp, %edi
movq %rax, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xfead5
testq %rax, %rax
je 0x1cf259
movq %rax, %r15
movq %r14, %rdi
callq 0x11bdbf
movq %rbx, %rdi
callq 0xfcccd
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x6c387
movq %r14, %rdi
callq 0x6c35b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_spmproc_strgraph_count
void gt_spmproc_strgraph_count(GtUword suffix_readnum,
    GtUword prefix_readnum, GtUword length,
    bool suffixseq_direct, bool prefixseq_direct, void *strgraph)
{
  GtStrgraph* g;
  GtStrgraphVnum position;

  gt_assert(strgraph != NULL);
  g = (GtStrgraph*)strgraph;

  gt_assert(g != NULL && g->state == GT_STRGRAPH_PREPARATION);
  position = suffixseq_direct ? GT_STRGRAPH_V_E(suffix_readnum)
                              : GT_STRGRAPH_V_B(suffix_readnum);
  GT_STRGRAPH_INC_COUNT(g, position);

  position = prefixseq_direct ? GT_STRGRAPH_V_B(prefix_readnum)
                              : GT_STRGRAPH_V_E(prefix_readnum);
  GT_STRGRAPH_INC_COUNT(g, position);

  if (g->minmatchlen > (GtStrgraphLength)length)
    g->minmatchlen = (GtStrgraphLength)length;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %r9, %r9
je 0x1cf419
movq %r9, %rbx
cmpl $0x0, 0x10(%r9)
jne 0x1cf41e
movq %rdx, %r14
movq 0x40(%rbx), %rdx
testq %rdx, %rdx
je 0x1cf40f
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x1cf40f
movl %r8d, %ebp
movq %rsi, %r15
movzbl %cl, %ecx
leaq (%rcx,%rdi,2), %r12
movb (%rdx,%r12), %cl
cmpb $-0x3, %cl
ja 0x1cf2ca
incb %cl
movb %cl, (%rdx,%r12)
jmp 0x1cf34b
cmpb $-0x2, %cl
jne 0x1cf31f
movb $-0x1, (%rdx,%r12)
movq 0x48(%rbx), %rdi
leaq 0x10(%rsp), %rsi
movq %r12, (%rsi)
callq 0x1012ee
testq %rax, %rax
jne 0x1cf423
movq 0x48(%rbx), %rdi
leaq 0x10(%rsp), %rsi
movq %r12, (%rsi)
movq $0xff, 0x8(%rsi)
leaq 0x8(%rsp), %rdx
callq 0x1015ee
testl %eax, %eax
jne 0x1cf34b
movq 0x8(%rsp), %rax
movq $0xff, 0x8(%rax)
jmp 0x1cf34b
leaq 0x10(%rsp), %rsi
movq %r12, (%rsi)
movq %rax, %rdi
callq 0x1012ee
movq 0x40(%rbx), %rcx
cmpb $-0x1, (%rcx,%r12)
jne 0x1cf428
testq %rax, %rax
je 0x1cf42d
incq 0x8(%rax)
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x1cf414
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x1cf414
xorb $0x1, %bpl
movzbl %bpl, %ecx
leaq (%rcx,%r15,2), %r15
movb (%rax,%r15), %cl
cmpb $-0x3, %cl
ja 0x1cf382
incb %cl
movb %cl, (%rax,%r15)
jmp 0x1cf3f8
cmpb $-0x2, %cl
jne 0x1cf3d7
movb $-0x1, (%rax,%r15)
movq 0x48(%rbx), %rdi
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
callq 0x1012ee
testq %rax, %rax
jne 0x1cf432
movq 0x48(%rbx), %rdi
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
movq $0xff, 0x8(%rsi)
leaq 0x8(%rsp), %rdx
callq 0x1015ee
testl %eax, %eax
jne 0x1cf3f8
movq 0x8(%rsp), %rax
movq $0xff, 0x8(%rax)
jmp 0x1cf3f8
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
callq 0x1012ee
movq 0x40(%rbx), %rcx
cmpb $-0x1, (%rcx,%r15)
jne 0x1cf437
testq %rax, %rax
je 0x1cf43c
incq 0x8(%rax)
cmpq %r14, 0x30(%rbx)
jbe 0x1cf402
movq %r14, 0x30(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x6c572
callq 0x6c539
callq 0x6c5ab
callq 0x6c3aa
callq 0x6c455
callq 0x6c3e3
callq 0x6c41c
callq 0x6c500
callq 0x6c48e
callq 0x6c4c7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_open_spmlist_file
int gt_strgraph_open_spmlist_file(GtStrgraph *strgraph, const char *indexname,
    const char *suffix, bool binary, GtUword bufsize, GtError *err)
{
  strgraph->binary_spmlist = binary;
  strgraph->spmfile = gt_fa_fopen_with_suffix(indexname, suffix,
      binary ? "wb" : "w", err);
  if (strgraph->spmfile == NULL)
    return -1;
  if (bufsize > 0)
  {
    strgraph->spmfile_buffer = NULL;
    (void)setvbuf(strgraph->spmfile, strgraph->spmfile_buffer, (int)_IOFBF,
        (size_t)bufsize << 20);
  }
  if (binary)
  {
    if (GT_STRGRAPH_NOFREADS(strgraph) > UINT32_MAX)
      gt_spmlist_write_header_bin64(strgraph->spmfile);
    else
      gt_spmlist_write_header_bin32(strgraph->spmfile);
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %r8, %r14
movl %ecx, %ebp
movq %rdi, %rbx
movb %bpl, 0x29(%rdi)
leaq 0x186689(%rip), %rcx    # 0x355ae1
leaq 0x1c4156(%rip), %rax    # 0x3935b5
testl %ebp, %ebp
cmovneq %rcx, %rax
leaq 0x1dfec1(%rip), %rcx    # 0x3af32d
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
movl $0x267, %r8d            # imm = 0x267
callq 0xfcf97
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x1cf4c9
testq %r14, %r14
je 0x1cf4a9
movq $0x0, 0x20(%rbx)
shlq $0x14, %r14
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x17050
xorl %r14d, %r14d
testb %bpl, %bpl
je 0x1cf4d6
movq 0x18(%rbx), %rdi
movq 0x80(%rbx), %rax
shrq $0x21, %rax
je 0x1cf4d1
callq 0x1cc732
jmp 0x1cf4d6
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x1cf4d6
callq 0x1cc6c0
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_spmproc_strgraph_count_and_save
void gt_spmproc_strgraph_count_and_save(GtUword suffix_readnum,
    GtUword prefix_readnum, GtUword length,
    bool suffixseq_direct, bool prefixseq_direct, void *strgraph)
{
  GtStrgraph* g;

  gt_assert(strgraph != NULL);
  g = (GtStrgraph*)strgraph;
  gt_spmproc_strgraph_count(suffix_readnum, prefix_readnum, length,
      suffixseq_direct, prefixseq_direct, strgraph);
  if (g->binary_spmlist)
  {
    if (GT_STRGRAPH_NOFREADS(g) > (GtStrgraphVnum)UINT32_MAX)
    {
      /*@ignore@*/
      gt_spmproc_show_bin64(suffix_readnum, prefix_readnum, length,
          suffixseq_direct, prefixseq_direct, g->spmfile);
      /*@end@*/
    }
    else
    {
      /*@ignore@*/
      gt_spmproc_show_bin32(suffix_readnum, prefix_readnum, length,
          suffixseq_direct, prefixseq_direct, g->spmfile);
      /*@end@*/
    }
  }
  else
  {
    GtFile *gtfile = gt_file_new_from_fileptr(g->spmfile);
    gt_spmproc_show_ascii(suffix_readnum, prefix_readnum, length,
        suffixseq_direct, prefixseq_direct, gtfile);
    gt_file_delete_without_handle(gtfile);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %r9, %r9
je 0x1cf593
movq %r9, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movzbl %cl, %r15d
movzbl %r8b, %ebp
movl %r15d, %ecx
movl %ebp, %r8d
callq 0x1cf269
cmpb $0x1, 0x29(%r13)
jne 0x1cf54b
movq 0x18(%r13), %r9
movq 0x80(%r13), %rax
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %r15d, %ecx
movl %ebp, %r8d
addq $0x8, %rsp
shrq $0x21, %rax
je 0x1cf584
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1cc73f
movq 0x18(%r13), %rdi
callq 0xfed85
movq %rax, %r13
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %r15d, %ecx
movl %ebp, %r8d
movq %rax, %r9
callq 0x1ccb81
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xfec16
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1cc6cd
callq 0x6c5e4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_save_counts
int gt_strgraph_save_counts(GtStrgraph *strgraph, const char *indexname,
    const char *suffix, GT_UNUSED GtError *err)
{
  GtFile *outfp;

  gt_assert(strgraph != NULL);
  gt_assert(strgraph->state == GT_STRGRAPH_PREPARATION);
  outfp = gt_strgraph_get_file(indexname, suffix, true, false);
  gt_assert(outfp != NULL);
  GT_STRGRAPH_SERIALIZE_COUNTS(strgraph, outfp);
  gt_file_delete(outfp);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x1cf60f
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
jne 0x1cf614
movq %rsi, %rdi
movq %rdx, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x1cf1bf
movq %rax, %r14
movq 0x40(%rbx), %rsi
movq 0x50(%rbx), %rdx
movq %rax, %rdi
callq 0xff190
movq 0x48(%rbx), %rdi
movq %rsp, %rdx
movq %r14, (%rdx)
leaq -0x1693(%rip), %rax     # 0x1cdf50
movq %rax, 0x8(%rdx)
movq $0x0, 0x10(%rdx)
leaq 0x9d1d(%rip), %rsi      # 0x1d9313
xorl %ecx, %ecx
callq 0x101b64
movq %r14, %rdi
callq 0xff22c
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x6c656
callq 0x6c61d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_load_counts
int gt_strgraph_load_counts(GtStrgraph *strgraph, const char *indexname,
    const char *suffix, GT_UNUSED GtError *err)
{
  GtFile *infp;

  gt_assert(strgraph != NULL);
  gt_assert(strgraph->state == GT_STRGRAPH_PREPARATION);
  infp = gt_strgraph_get_file(indexname, suffix, false, false);
  gt_assert(infp != NULL);
  GT_STRGRAPH_DESERIALIZE_COUNTS(strgraph, infp);
  gt_file_delete(infp);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x1cf73e
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
jne 0x1cf743
movq %rsi, %rdi
movq %rdx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1cf1bf
movq %rax, %r14
movq 0x40(%rbx), %rsi
movq 0x50(%rbx), %rdx
movq %rax, %rdi
callq 0xff139
cmpl 0x50(%rbx), %eax
jne 0x1cf748
movq $0x0, 0x8(%rsp)
movq %rsp, %rsi
movl $0x8, %edx
movq %r14, %rdi
callq 0xff139
cmpl $0x8, %eax
jne 0x1cf720
leaq 0x8(%rsp), %r15
movq %rsp, %r12
leaq 0x10(%rsp), %rbp
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0xff139
cmpl $0x8, %eax
jne 0x1cf739
movq 0x8(%rsp), %rax
cmpq $0xfe, %rax
ja 0x1cf6ca
movq 0x40(%rbx), %rcx
movq (%rsp), %rdx
movb %al, (%rcx,%rdx)
jmp 0x1cf707
movq 0x40(%rbx), %rax
movq (%rsp), %rcx
movb $-0x1, (%rax,%rcx)
movq 0x48(%rbx), %rdi
movq (%rsp), %rax
movq 0x8(%rsp), %r13
movq %rax, 0x18(%rsp)
movq %r13, 0x20(%rsp)
leaq 0x18(%rsp), %rsi
movq %rbp, %rdx
callq 0x1015ee
testl %eax, %eax
jne 0x1cf707
movq 0x10(%rsp), %rax
movq %r13, 0x8(%rax)
movl $0x8, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0xff139
cmpl $0x8, %eax
je 0x1cf697
movq %r14, %rdi
callq 0xff22c
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x6c701
callq 0x6c73a
callq 0x6c68f
callq 0x6c6c8
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_spmproc_strgraph_add
void gt_spmproc_strgraph_add(GtUword suffix_readnum,
    GtUword prefix_readnum, GtUword length,
    bool suffixseq_direct, bool prefixseq_direct, void *graph)
{
  GtStrgraph *strgraph = graph;
  GtStrgraphLength edgelen = (GtStrgraphLength)length;
  gt_assert(strgraph != NULL);
  gt_assert(suffixseq_direct || prefixseq_direct);

  if (suffix_readnum == prefix_readnum && !strgraph->load_self_spm)
    return;

  if (suffixseq_direct) {
    if (prefixseq_direct) {
      gt_strgraph_add_edge(strgraph, GT_STRGRAPH_V_E(suffix_readnum),
                         GT_STRGRAPH_V_E(prefix_readnum), edgelen);
      gt_strgraph_add_edge(strgraph, GT_STRGRAPH_V_B(prefix_readnum),
                         GT_STRGRAPH_V_B(suffix_readnum), edgelen);
    } else {
      gt_strgraph_add_edge(strgraph, GT_STRGRAPH_V_E(suffix_readnum),
                         GT_STRGRAPH_V_B(prefix_readnum), edgelen);
      gt_strgraph_add_edge(strgraph, GT_STRGRAPH_V_E(prefix_readnum),
                         GT_STRGRAPH_V_B(suffix_readnum), edgelen);
    }
  } else {
    if (prefixseq_direct) {
      gt_strgraph_add_edge(strgraph, GT_STRGRAPH_V_B(suffix_readnum),
                         GT_STRGRAPH_V_E(prefix_readnum), edgelen);
      gt_strgraph_add_edge(strgraph, GT_STRGRAPH_V_B(prefix_readnum),
                         GT_STRGRAPH_V_E(suffix_readnum), edgelen);
    } else {
      gt_strgraph_add_edge(strgraph, GT_STRGRAPH_V_B(suffix_readnum),
                         GT_STRGRAPH_V_B(prefix_readnum), edgelen);
      gt_strgraph_add_edge(strgraph, GT_STRGRAPH_V_E(prefix_readnum),
                         GT_STRGRAPH_V_E(suffix_readnum), edgelen);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %r9, %r9
je 0x1cfd19
movl %ecx, %eax
orb %r8b, %al
je 0x1cfd1e
movq %r9, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
cmpq %rsi, %rdi
jne 0x1cfc76
cmpb $0x1, 0x28(%r15)
jne 0x1cfcc6
addq %r12, %r12
testb %cl, %cl
je 0x1cfca0
movq %r12, %rsi
orq $0x1, %rsi
addq %r14, %r14
testb %r8b, %r8b
je 0x1cfcd0
movq %r14, %rdx
orq $0x1, %rdx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x1cfd32
jmp 0x1cfce2
addq %r14, %r14
movq %r12, %r13
orq $0x1, %r13
testb %r8b, %r8b
je 0x1cfced
movq %r14, %rdx
orq $0x1, %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rcx
callq 0x1cfd32
jmp 0x1cfd02
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1cfd32
orq $0x1, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
jmp 0x1cfd0b
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1cfd32
orq $0x1, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1cfd32
callq 0x6cb03
callq 0x6caca
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_check_outdegs
static void gt_strgraph_check_outdegs(GtStrgraph *strgraph)
{
  GtStrgraphVnum i;
  GtStrgraphVEdgenum j, outdeg;
  for (i = 0UL; i < GT_STRGRAPH_NOFVERTICES(strgraph); i++)
  {
    outdeg = 0;
    for (j = 0; j < GT_STRGRAPH_V_NOFEDGES(strgraph, i); j++)
      if (!GT_STRGRAPH_EDGE_IS_REDUCED(strgraph, i, j))
        outdeg++;
    gt_assert(outdeg == GT_STRGRAPH_V_OUTDEG(strgraph, i));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq 0x80(%rbx), %r14
jae 0x1d1002
movq 0x60(%rbx), %rax
testq %rax, %rax
je 0x1d1011
leaq 0x1(%r14), %r12
xorl %r13d, %r13d
xorl %ebp, %ebp
cmpq %r12, 0x8(%rax)
jbe 0x1d1011
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1d1011
movq (%rax), %rdi
movq %rdx, %rsi
imulq %r12, %rsi
callq 0x2f37dc
movq %rax, %r15
movq 0x60(%rbx), %rax
testq %rax, %rax
je 0x1d1016
cmpq %r14, 0x8(%rax)
jbe 0x1d1016
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1d1016
movq (%rax), %rdi
movq %rdx, %rsi
imulq %r14, %rsi
callq 0x2f37dc
subq %rax, %r15
cmpq %r15, %rbp
jae 0x1d0fca
movq 0x60(%rbx), %rax
testq %rax, %rax
je 0x1d101b
cmpq %r14, 0x8(%rax)
jbe 0x1d101b
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1d101b
movq 0x88(%rbx), %r15
movq (%rax), %rdi
movq %rdx, %rsi
imulq %r14, %rsi
callq 0x2f37dc
testq %r15, %r15
je 0x1d1020
addq %rbp, %rax
cmpq %rax, 0x8(%r15)
jbe 0x1d1020
movl 0x10(%r15), %edx
cmpq $0x41, %rdx
jae 0x1d1020
movq (%r15), %rdi
imulq %rdx, %rax
movq %rax, %rsi
callq 0x2f37dc
movq %rax, %r15
movq 0x90(%rbx), %rdi
callq 0x2f09dd
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %eax, %ecx
shll %cl, %edx
notl %edx
addl %edx, %edx
movslq %edx, %rax
andq %r15, %rax
shrq %rax
xorl %ecx, %ecx
cmpq 0x90(%rbx), %rax
setne %cl
addq %rcx, %r13
incq %rbp
movq 0x60(%rbx), %rax
testq %rax, %rax
jne 0x1d0eaf
jmp 0x1d1011
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x1d1025
cmpq %r14, 0x8(%rax)
jbe 0x1d1025
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1d1025
movq (%rax), %rdi
imulq %rdx, %r14
movq %r14, %rsi
callq 0x2f37dc
movq %r12, %r14
cmpq %rax, %r13
je 0x1d0e8c
callq 0x6d7b4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x6d8d1
callq 0x6d898
callq 0x6d85f
callq 0x6d826
callq 0x6d7ed
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_find_only_edge
static inline GtStrgraphVEdgenum gt_strgraph_find_only_edge(
    GtStrgraph *strgraph, GtStrgraphVnum from)
{
  GtStrgraphVEdgenum j;
  gt_assert(GT_STRGRAPH_V_OUTDEG(strgraph, from) == (GtStrgraphVEdgenum)1);
  for (j = 0; j < GT_STRGRAPH_V_NOFEDGES(strgraph, from); j++)
  {
    if (!GT_STRGRAPH_EDGE_IS_REDUCED(strgraph, from, j))
      return j;
  }
  gt_assert(false); /* outdeg error */
  return 0; /* to avoid warnings */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x70(%rdi), %rax
testq %rax, %rax
je 0x1d39d3
movq %rsi, %rbx
cmpq %rsi, 0x8(%rax)
jbe 0x1d39d3
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1d39d3
movq %rdi, %r14
movq (%rax), %rdi
movq %rdx, %rsi
imulq %rbx, %rsi
callq 0x2f37dc
cmpq $0x1, %rax
jne 0x1d39d8
movq 0x60(%r14), %rax
testq %rax, %rax
je 0x1d39ad
leaq 0x1(%rbx), %r13
xorl %r15d, %r15d
cmpq %r13, 0x8(%rax)
jbe 0x1d39ad
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1d39ad
movq (%rax), %rdi
movq %rdx, %rsi
imulq %r13, %rsi
callq 0x2f37dc
movq %rax, %r12
movq 0x60(%r14), %rax
testq %rax, %rax
je 0x1d39bf
cmpq %rbx, 0x8(%rax)
jbe 0x1d39bf
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1d39bf
movq (%rax), %rdi
movq %rdx, %rsi
imulq %rbx, %rsi
callq 0x2f37dc
subq %rax, %r12
cmpq %r12, %r15
jae 0x1d39ce
movq 0x60(%r14), %rax
testq %rax, %rax
je 0x1d39c4
cmpq %rbx, 0x8(%rax)
jbe 0x1d39c4
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1d39c4
movq 0x88(%r14), %r12
movq (%rax), %rdi
movq %rdx, %rsi
imulq %rbx, %rsi
callq 0x2f37dc
testq %r12, %r12
je 0x1d39c9
addq %r15, %rax
cmpq %rax, 0x8(%r12)
jbe 0x1d39c9
movl 0x10(%r12), %edx
cmpq $0x41, %rdx
jae 0x1d39c9
movq (%r12), %rdi
imulq %rdx, %rax
movq %rax, %rsi
callq 0x2f37dc
movq %rax, %r12
movq 0x90(%r14), %rdi
callq 0x2f09dd
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %eax, %ecx
shll %cl, %edx
notl %edx
addl %edx, %edx
movslq %edx, %rax
andq %r12, %rax
shrq %rax
cmpq 0x90(%r14), %rax
jne 0x1d39b2
incq %r15
movq 0x60(%r14), %rax
testq %rax, %rax
jne 0x1d38a3
callq 0x6f58a
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x6f551
callq 0x6f518
callq 0x6f4df
callq 0x6f4a6
callq 0x6f5c3
callq 0x6f46d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_path_info_compare
static int gt_strgraph_path_info_compare(const void *pi_a, const void *pi_b)
{
  int retv;
  const GtStrgraphPathInfo *a = pi_a, *b = pi_b;
  retv = (int)(a->dest > b->dest) -
    (int)(a->dest < b->dest);
  if (retv == 0)
    retv = (int)(a->width > b->width) - (int)(a->width < b->width);
  return retv;
}

// Assembly:
movq 0x8(%rdi), %rcx
xorl %eax, %eax
cmpq 0x8(%rsi), %rcx
seta %al
sbbl $0x0, %eax
je 0x1d472c
retq
movq 0x18(%rdi), %rcx
xorl %eax, %eax
cmpq 0x18(%rsi), %rcx
seta %al
sbbl $0x0, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_show_edge_lengths_distribution
void gt_strgraph_show_edge_lengths_distribution(const GtStrgraph *strgraph,
    const char *indexname, const char *suffix)
{
  GtDiscDistri *d;
  GtStrgraphVnum i;
  GtStrgraphVEdgenum j;
  GtFile *outfp;

  gt_assert(strgraph != NULL);
  gt_assert(sizeof (GtUword) >= sizeof (GtStrgraphLength));
  d = gt_disc_distri_new();
  for (i = 0; i < GT_STRGRAPH_NOFVERTICES(strgraph); i++)
  {
    for (j = 0; j < GT_STRGRAPH_V_NOFEDGES(strgraph, i); j++)
    {
      gt_disc_distri_add(d,
          (GtUword)GT_STRGRAPH_EDGE_LEN(strgraph, i, j));
    }
  }
  outfp = gt_strgraph_get_file(indexname, suffix, true, false);
  gt_file_xprintf(outfp, "# length nofedges\n");
  gt_disc_distri_foreach(d,
     (GtDiscDistriIterFunc) gt_strgraph_show_disc_distri_datapoint, outfp);
  gt_disc_distri_delete(d);
  gt_file_delete(outfp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
testq %rdi, %rdi
je 0x1d6dcd
movq %rdi, %r12
callq 0xe54e0
movq %rax, %rbx
cmpq $0x0, 0x80(%r12)
je 0x1d6d5f
xorl %ebp, %ebp
movq 0x60(%r12), %rax
testq %rax, %rax
je 0x1d6db9
leaq 0x1(%rbp), %r14
xorl %r15d, %r15d
cmpq %r14, 0x8(%rax)
jbe 0x1d6db9
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1d6db9
movq (%rax), %rdi
movq %rdx, %rsi
imulq %r14, %rsi
callq 0x2f37dc
movq %rax, %r13
movq 0x60(%r12), %rax
testq %rax, %rax
je 0x1d6dbe
cmpq %rbp, 0x8(%rax)
jbe 0x1d6dbe
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1d6dbe
movq (%rax), %rdi
movq %rdx, %rsi
imulq %rbp, %rsi
callq 0x2f37dc
subq %rax, %r13
cmpq %r13, %r15
jae 0x1d6d4e
movq 0x60(%r12), %rax
testq %rax, %rax
je 0x1d6dc8
cmpq %rbp, 0x8(%rax)
jbe 0x1d6dc8
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1d6dc8
movq 0x88(%r12), %r13
movq (%rax), %rdi
movq %rdx, %rsi
imulq %rbp, %rsi
callq 0x2f37dc
testq %r13, %r13
je 0x1d6dc3
addq %r15, %rax
cmpq %rax, 0x8(%r13)
jbe 0x1d6dc3
movl 0x10(%r13), %edx
cmpq $0x41, %rdx
jae 0x1d6dc3
movq (%r13), %rdi
imulq %rdx, %rax
movq %rax, %rsi
callq 0x2f37dc
movq %rax, %r13
movq 0x90(%r12), %rdi
callq 0x2f09dd
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %eax, %ecx
shll %cl, %edx
notl %edx
addl %edx, %edx
movslq %edx, %rsi
andq %r13, %rsi
shrq %rsi
movq %rbx, %rdi
callq 0xe54fb
incq %r15
movq 0x60(%r12), %rax
testq %rax, %rax
jne 0x1d6c34
jmp 0x1d6db9
movq %r14, %rbp
cmpq 0x80(%r12), %r14
jb 0x1d6c1f
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x1cf1bf
movq %rax, %r14
leaq 0x1d8eed(%rip), %rsi    # 0x3afc6c
movq %rax, %rdi
xorl %eax, %eax
callq 0xfee51
leaq 0x42(%rip), %rsi        # 0x1d6dd2
movq %rbx, %rdi
movq %r14, %rdx
callq 0xe56e5
movq %rbx, %rdi
callq 0xe5a93
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xff22c
callq 0x70fdd
callq 0x70fa4
callq 0x70f32
callq 0x70f6b
callq 0x71016