LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-spmfind.c
// Function: resetwsetbt_spm
static inline void resetwsetbt_spm(GtBUstate_spm *state)
{
  GtUword i, bsize_sum = 0, nofbltries = 0;
  GtBlindtrie *b;
  printcurrentspace_spm("before resizing");
  for (i = 0; i < state->w_allocated; i++)
  {
    b = (state->w_set + i)->blindtrie;
    if (b != NULL)
    {
      bsize_sum += gt_blindtrie_current_size(b);
      gt_blindtrie_resize(b, 1U);
      nofbltries++;
    }
    else
      break;
  }
  gt_log_log("current number of blindtries: "GT_WU"", nofbltries);
  gt_log_log("total size of the blindtries: %.2f MB", GT_MEGABYTES(bsize_sum));
  printcurrentspace_spm("after resizing");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
leaq 0x2f7833(%rip), %rdi    # 0x5813b5
callq 0x28b590
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x88(%rcx), %rax
jae 0x289c0c
movq 0x20(%rsp), %rax
movq 0x78(%rax), %rax
movq 0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x289bf8
movq (%rsp), %rdi
callq 0x2b8220
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x2b8140
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x289bfa
jmp 0x289c0c
jmp 0x289bfc
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x289b90
movq 0x8(%rsp), %rsi
leaq 0x2f77ad(%rip), %rdi    # 0x5813c5
xorl %eax, %eax
callq 0xe7740
movaps 0x28ed0a(%rip), %xmm1   # 0x518930
movq 0x10(%rsp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x28ed08(%rip), %xmm1   # 0x518940
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x28ecd1(%rip), %xmm1   # 0x518920
divsd %xmm1, %xmm0
leaq 0x2f778d(%rip), %rdi    # 0x5813e7
movb $0x1, %al
callq 0xe7740
leaq 0x2f77a5(%rip), %rdi    # 0x58140d
callq 0x28b590
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x98(%rax)
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x90(%rcx), %rax
ja 0x28ace4
jmp 0x28ade0
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x90(%rcx), %rcx
movq 0x18(%rsp), %rdx
addq 0xa0(%rdx), %rcx
cmpq %rcx, %rax
jbe 0x28ad1e
movq 0x18(%rsp), %rax
movb $0x1, 0xa8(%rax)
jmp 0x28ade0
movq 0x18(%rsp), %rax
movq 0x80(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x88(%rcx), %rax
jne 0x28ad42
movq 0x18(%rsp), %rdi
callq 0x28b0e0
movq 0x18(%rsp), %rax
movq 0x78(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x80(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x80(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x80(%rax)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x28add2
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rcx
xorl %eax, %eax
movl %eax, %r9d
movl $0x40, %edx
xorl %r8d, %r8d
movq %r9, %rdi
movq %r9, %rsi
movq $0x0, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0x2b7ea0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x28ade0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2b8240
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-spmfind.c
// Function: expandwset_spm
static inline void expandwset_spm(GtBUstate_spm *state)
{
  GtUword prevsize, i;
  prevsize = state->w_allocated;
  state->w_allocated += GT_SPMFIND_WSET_ALLOC_INC;
  state->w_set = gt_realloc(state->w_set, sizeof (WholereadInfo) *
      state->w_allocated);
  for (i = prevsize; i < state->w_allocated; i++)
    (state->w_set + i)->blindtrie = NULL;
  gt_assert(state->w_nextfree < state->w_allocated);
#ifdef GT_READJOINER_STATISTICS
  (state->nof_w_set_realloc)++;
#endif
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rcx
addq $0x400, %rcx            # imm = 0x400
movq %rcx, 0x88(%rax)
movq 0x10(%rsp), %rax
movq 0x78(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rsi
shlq $0x4, %rsi
leaq 0x2f5fcf(%rip), %rdx    # 0x581103
movl $0x8d, %ecx
callq 0xe8540
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x78(%rax)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x88(%rcx), %rax
jae 0x28b18f
movq 0x10(%rsp), %rax
movq 0x78(%rax), %rax
movq (%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x28b153
jmp 0x28b191
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x88(%rcx), %rax
jb 0x28b1e3
movq 0x3b0dee(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x28ae57(%rip), %rsi    # 0x516013
leaq 0x2f5faa(%rip), %rdx    # 0x58116d
leaq 0x2f5fca(%rip), %rcx    # 0x581194
leaq 0x2f5f32(%rip), %r8     # 0x581103
movl $0x90, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x28b1e5
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-spmfind.c
// Function: appendtolset_spm
static inline void appendtolset_spm(GtUword seqnum,
    GtBUstate_spm *state)
{
  /* realloc if necessary */
  if (state->l_nextfree == state->l_allocated)
    expandlset_spm(state);
  /* add element */
  state->l_set[state->l_nextfree] = seqnum;
  state->l_nextfree++;
#ifdef GT_READJOINER_STATISTICS
  (state->nof_terminals)++;
  (state->nof_terminals_in_subtree)++;
  if (state->l_nextfree > state->max_l_nextfree)
    state->max_l_nextfree = state->l_nextfree;
#endif
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x70(%rcx), %rax
jne 0x28b21c
movq 0x8(%rsp), %rdi
callq 0x28b250
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x68(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-spmfind.c
// Function: initwset_spm
static void initwset_spm(GtBUstate_spm *state)
{
  GtUword i;
  state->w_allocated = GT_SPMFIND_WSET_ALLOC_INC;
  state->w_set = gt_malloc(sizeof (WholereadInfo) * (state->w_allocated));
  state->w_nextfree = 0;
  for (i = 0; i < state->w_allocated; i++)
    (state->w_set + i)->blindtrie = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0x400, 0x88(%rax) # imm = 0x400
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rdi
shlq $0x4, %rdi
leaq 0x2f5d93(%rip), %rsi    # 0x581103
movl $0x81, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x78(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x80(%rax)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x88(%rcx), %rax
jae 0x28b3df
movq 0x10(%rsp), %rax
movq 0x78(%rax), %rax
movq 0x8(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x28b39f
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-spmfind.c
// Function: deletewset_spm
static void deletewset_spm(WholereadInfo *w_set,
    GtUword w_allocated)
{
  GtUword i;
  for (i = 0; i < w_allocated; i++)
    gt_blindtrie_delete(w_set[i].blindtrie);
  gt_free(w_set);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x28b438
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x2b8260
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x28b406
movq 0x10(%rsp), %rdi
leaq 0x2f5cbf(%rip), %rsi    # 0x581103
movl $0xe9, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-spmfind.c
// Function: printcurrentspace_spm
static inline void printcurrentspace_spm(const char *label)
{
  GtUword m, f;
  if (gt_ma_bookkeeping_enabled())
  {
    m = gt_ma_get_space_current();
    f = gt_fa_get_space_current();
    gt_log_log("used space %s: %.2f MB (ma: %.2f MB; fa: %.2f MB)", label,
        GT_MEGABYTES(m + f), GT_MEGABYTES(m), GT_MEGABYTES(f));
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0xe8ea0
testb $0x1, %al
jne 0x28b5a7
jmp 0x28b64f
callq 0xe8b80
movq %rax, 0x8(%rsp)
callq 0xdbac0
movq %rax, (%rsp)
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, %rdx
addq %rax, %rdx
movq %rdx, %xmm0
movaps 0x28d356(%rip), %xmm4   # 0x518930
punpckldq %xmm4, %xmm0    # xmm0 = xmm0[0],xmm4[0],xmm0[1],xmm4[1]
movapd 0x28d35a(%rip), %xmm3   # 0x518940
subpd %xmm3, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x28d32b(%rip), %xmm2   # 0x518928
mulsd %xmm2, %xmm0
movq %rcx, %xmm1
punpckldq %xmm4, %xmm1    # xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1]
subpd %xmm3, %xmm1
movaps %xmm1, %xmm5
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm5, %xmm1
mulsd %xmm2, %xmm1
movq %rax, %xmm2
punpckldq %xmm4, %xmm2    # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1]
subpd %xmm3, %xmm2
movaps %xmm2, %xmm3
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
addsd %xmm3, %xmm2
movsd 0x28d2e3(%rip), %xmm3   # 0x518920
divsd %xmm3, %xmm2
leaq 0x298ad3(%rip), %rdi    # 0x52411b
movb $0x3, %al
callq 0xe7740
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jb 0x28b867
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x68(%rcx), %rax
jae 0x28b85a
movq 0x20(%rsp), %rax
movq 0x60(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x60(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xb0530
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x60(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xb09f0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
movq 0x28(%rsp), %rax
movq (%rax), %rcx
movq 0x30(%rsp), %r8
movq 0x20(%rsp), %r9
callq 0x28adf0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x28b7b5
movq 0x20(%rsp), %rax
movq $0x0, 0x68(%rax)
xorl %eax, %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x28bb95
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x28bb5d
jmp 0x28bb95
movq 0x3b043c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x28a4a5(%rip), %rsi    # 0x516013
leaq 0x28a64a(%rip), %rdx    # 0x5161bf
leaq 0x2f599c(%rip), %rcx    # 0x581518
leaq 0x2f58fd(%rip), %r8     # 0x581480
movl $0xf2, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x28bb97
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x2a0432(%rip), %rsi    # 0x52bfda
callq 0xdd320
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x28bbc4
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x28bbfc
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r9
xorl %eax, %eax
movl %eax, %edx
callq 0x28bc10
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rdi
callq 0xde430
movl 0x14(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x28bc8a
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x28bc52
jmp 0x28bc8a
movq 0x3b0347(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x28a3b0(%rip), %rsi    # 0x516013
leaq 0x28a555(%rip), %rdx    # 0x5161bf
leaq 0x2f5973(%rip), %rcx    # 0x5815e4
leaq 0x2f5808(%rip), %r8     # 0x581480
movl $0xd9, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x28bc8c
callq 0x11d4a0
movq %rax, 0x8(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x14(%rsp)
movb %al, 0x7(%rsp)
jne 0x28bcbc
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x11e6f0
cmpl $-0x1, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x28bcc6
jmp 0x28bcf9
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r9
callq 0x28c870
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rdi
callq 0x11e110
jmp 0x28bc96
movq 0x8(%rsp), %rdi
callq 0x11f560
movl 0x14(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-spmlist.c
// Function: gt_spmproc_show_ascii
void gt_spmproc_show_ascii(GtUword suffix_seqnum,
    GtUword prefix_seqnum,
    GtUword length,
    bool suffixseq_direct,
    bool prefixseq_direct,
    void *data)
{
  GtFile *file = data;
  gt_file_xprintf(file, ""GT_WU" %s "GT_WU" %s "GT_WU"\n", suffix_seqnum,
      suffixseq_direct ? "+" : "-", prefix_seqnum,
      prefixseq_direct ? "+" : "-", length);
}

// Assembly:
subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
andb $0x1, %cl
movb %cl, 0x1f(%rsp)
andb $0x1, %al
movb %al, 0x1e(%rsp)
movq %r9, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rdx
movb 0x1f(%rsp), %sil
leaq 0x30f0cf(%rip), %rcx    # 0x59b327
leaq 0x306f19(%rip), %rax    # 0x593178
testb $0x1, %sil
cmovneq %rax, %rcx
movq 0x28(%rsp), %r8
movb 0x1e(%rsp), %sil
leaq 0x30f0af(%rip), %r9     # 0x59b327
leaq 0x306ef9(%rip), %rax    # 0x593178
testb $0x1, %sil
cmovneq %rax, %r9
movq 0x20(%rsp), %rax
leaq 0x2f5323(%rip), %rsi    # 0x5815b6
movq %rax, (%rsp)
movb $0x0, %al
callq 0xddca0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-spmlist.c
// Function: gt_spmproc_a_show_ascii
void gt_spmproc_a_show_ascii(GtUword suffix_seqnum,
    GtUword prefix_seqnum,
    GtUword suffix_length,
    GtUword prefix_length,
    GtUword unit_edist,
    bool suffixseq_direct,
    bool prefixseq_direct,
    void *data)
{
  GtFile *file = data;
  gt_file_xprintf(file, ""GT_WU" %s "GT_WU" %s "GT_WU" "GT_WU" "GT_WU"\n",
                  suffix_seqnum, suffixseq_direct ? "+" : "-", prefix_seqnum,
                  prefixseq_direct ? "+" : "-", suffix_length, prefix_length,
                  unit_edist);
}

// Assembly:
subq $0x68, %rsp
movl %r9d, %eax
movq %rcx, 0x18(%rsp)
movq %rdx, %rcx
movq 0x18(%rsp), %rdx
movq %rcx, 0x20(%rsp)
movq %rsi, %rcx
movq 0x20(%rsp), %rsi
movq %rcx, 0x28(%rsp)
movq %rdi, %r9
movq 0x28(%rsp), %rdi
movb %al, %cl
movq 0x78(%rsp), %rax
movb 0x70(%rsp), %al
movq %r9, 0x60(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
andb $0x1, %cl
movb %cl, 0x3f(%rsp)
andb $0x1, %al
movb %al, 0x3e(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x60(%rsp), %rdx
movb 0x3f(%rsp), %sil
leaq 0x30eff8(%rip), %rcx    # 0x59b327
leaq 0x306e42(%rip), %rax    # 0x593178
testb $0x1, %sil
cmovneq %rax, %rcx
movq 0x58(%rsp), %r8
movb 0x3e(%rsp), %sil
leaq 0x30efd8(%rip), %r9     # 0x59b327
leaq 0x306e22(%rip), %rax    # 0x593178
testb $0x1, %sil
cmovneq %rax, %r9
movq 0x50(%rsp), %r11
movq 0x48(%rsp), %r10
movq 0x40(%rsp), %rax
leaq 0x2f5255(%rip), %rsi    # 0x5815c9
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x0, %al
callq 0xddca0
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-spmlist.c
// Function: gt_spmlist_unit_test
int gt_spmlist_unit_test(GtError *err)
{
  int had_err = 0;
  had_err = gt_spmproc_show_unit_test(err);
  if (had_err == 0)
    had_err = gt_spmlist_parse_unit_test(err);
  return had_err;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x28c3d0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x28c3c4
movq 0x10(%rsp), %rdi
callq 0x28c7e0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-spmlist.c
// Function: gt_spmlist_parse_unit_test
static int gt_spmlist_parse_unit_test(GtError *err)
{
  int had_err = 0;
  gt_error_check(err);
  had_err = parse_plusminus_unit_test(err);
  if (!had_err) had_err = parse_line_unit_test(err);
  return had_err;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x28c841
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x28c809
jmp 0x28c841
movq 0x3af790(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2897f9(%rip), %rsi    # 0x516013
leaq 0x28999e(%rip), %rdx    # 0x5161bf
leaq 0x2f50ac(%rip), %rcx    # 0x5818d4
leaq 0x2f4c51(%rip), %r8     # 0x581480
movl $0x1b0, %r9d            # imm = 0x1B0
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x28c843
movq 0x10(%rsp), %rdi
callq 0x28d0c0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x28c866
movq 0x10(%rsp), %rdi
callq 0x28d330
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-spmlist.c
// Function: parse_plusminus
static inline int parse_plusminus(bool *destination, const char *source)
{
  if (strlen(source) != (size_t)1)
    return -1;
  switch (source[0])
  {
    case '+':
      *destination = true;
      return 0;
    case '-':
      *destination = false;
      return 0;
    default:
      return -1;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x192b0
cmpq $0x1, %rax
je 0x28cee8
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x28cf32
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x2b, %eax
je 0x28cf06
jmp 0x28cefb
movl 0xc(%rsp), %eax
subl $0x2d, %eax
je 0x28cf18
jmp 0x28cf2a
movq 0x18(%rsp), %rax
movb $0x1, (%rax)
movl $0x0, 0x24(%rsp)
jmp 0x28cf32
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
movl $0x0, 0x24(%rsp)
jmp 0x28cf32
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-spmlist.c
// Function: spmproc_show_caller
static void spmproc_show_caller(GtSpmproc proc, void *data)
{
  proc(0UL, 1UL, 10UL, true, true, data);
  proc(0UL, 2UL, 10UL, true, false, data);
  proc(2UL, 0UL, 10UL, false, true, data);
  proc(1UL, 0UL, 10UL, false, true, data);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %r9
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x1, %esi
movl $0xa, %edx
movl $0x1, %r8d
movl %r8d, %ecx
callq *%rax
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %r9
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x2, %esi
movl $0xa, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq *%rax
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %r9
movl $0x2, %edi
xorl %ecx, %ecx
movl %ecx, %esi
movl $0xa, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq *%rax
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %r9
movl $0x1, %edi
xorl %ecx, %ecx
movl %ecx, %esi
movl $0xa, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq *%rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-spmlist.c
// Function: spmproc_a_show_caller
static void spmproc_a_show_caller(GtSpmprocA proc, void *data)
{
  proc(0UL, 1UL, 10UL, 11UL, 1UL, true, true, data);
  proc(0UL, 2UL, 10UL, 10UL, 0UL, true, false, data);
  proc(2UL, 0UL, 10UL, 12UL, 2UL, false, true, data);
  proc(1UL, 0UL, 11UL, 11UL, 0UL, false, true, data);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %r10
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x1, %r8d
movl $0xa, %edx
movl $0xb, %ecx
movl $0x1, %r9d
movq %r8, %rsi
movl $0x1, (%rsp)
movq %r10, 0x8(%rsp)
callq *%rax
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %r10
xorl %ecx, %ecx
movl %ecx, %r8d
movl $0x2, %esi
movl $0xa, %ecx
movl $0x1, %r9d
xorl %edx, %edx
movq %r8, %rdi
movq %rcx, %rdx
movl $0x0, (%rsp)
movq %r10, 0x8(%rsp)
callq *%rax
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %r10
movl $0x2, %r8d
xorl %ecx, %ecx
movl %ecx, %esi
movl $0xa, %edx
movl $0xc, %ecx
xorl %r9d, %r9d
movq %r8, %rdi
movl $0x1, (%rsp)
movq %r10, 0x8(%rsp)
callq *%rax
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %r10
movl $0x1, %edi
xorl %ecx, %ecx
movl %ecx, %r8d
movl $0xb, %ecx
xorl %r9d, %r9d
movq %r8, %rsi
movq %rcx, %rdx
movl $0x1, (%rsp)
movq %r10, 0x8(%rsp)
callq *%rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-spmlist.c
// Function: gt_spmlist_test_save
static void gt_spmlist_test_save(GtUword suffix_seqnum,
    GtUword prefix_seqnum, GtUword length, bool suffixseq_direct,
    bool prefixseq_direct, void* data)
{
  struct GtSpmParseExactResult *r = data;
  r->suffix_seqnum = suffix_seqnum;
  r->prefix_seqnum = prefix_seqnum;
  r->length = length;
  r->suffixseq_direct = suffixseq_direct;
  r->prefixseq_direct = prefixseq_direct;
}

// Assembly:
movb %r8b, %al
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
andb $0x1, %cl
movb %cl, -0x19(%rsp)
andb $0x1, %al
movb %al, -0x1a(%rsp)
movq %r9, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x8(%rsp), %rcx
movq -0x30(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rcx
movq -0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rcx
movq -0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movb -0x19(%rsp), %cl
movq -0x30(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x18(%rax)
movb -0x1a(%rsp), %cl
movq -0x30(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x19(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-spmlist.c
// Function: gt_spmlist_test_save_a
static void gt_spmlist_test_save_a(GtUword suffix_seqnum,
    GtUword prefix_seqnum, GtUword suffix_length,
    GtUword prefix_length, GtUword unit_edist,
    bool suffixseq_direct, bool prefixseq_direct, void* data)
{
  struct GtSpmParseApproxResult *r = data;
  r->suffix_seqnum = suffix_seqnum;
  r->prefix_seqnum = prefix_seqnum;
  r->suffix_length = suffix_length;
  r->prefix_length = prefix_length;
  r->unit_edist = unit_edist;
  r->suffixseq_direct = suffixseq_direct;
  r->prefixseq_direct = prefixseq_direct;
}

// Assembly:
movl %r9d, %eax
movq %rcx, -0x50(%rsp)
movq %rdx, %rcx
movq -0x50(%rsp), %rdx
movq %rcx, -0x48(%rsp)
movq %rsi, %rcx
movq -0x48(%rsp), %rsi
movq %rcx, -0x40(%rsp)
movq %rdi, %r9
movq -0x40(%rsp), %rdi
movb %al, %cl
movq 0x10(%rsp), %rax
movb 0x8(%rsp), %al
movq %r9, -0x8(%rsp)
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
andb $0x1, %cl
movb %cl, -0x29(%rsp)
andb $0x1, %al
movb %al, -0x2a(%rsp)
movq 0x10(%rsp), %rax
movq %rax, -0x38(%rsp)
movq -0x8(%rsp), %rcx
movq -0x38(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rcx
movq -0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rcx
movq -0x38(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rsp), %rcx
movq -0x38(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rsp), %rcx
movq -0x38(%rsp), %rax
movq %rcx, 0x20(%rax)
movb -0x29(%rsp), %cl
movq -0x38(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x28(%rax)
movb -0x2a(%rsp), %cl
movq -0x38(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x29(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-spmproc.c
// Function: gt_spmproc_a_e
void gt_spmproc_a_e(GtUword suffix_seqnum, GtUword prefix_seqnum,
  GtUword suffix_length, GT_UNUSED GtUword prefix_length,
  GtUword unit_edist, bool suffixseq_direct, bool prefixseq_direct,
  void *data)
{
  GtSpmprocWithData* a_e_data = data;
  if (unit_edist == 0)
  {
    a_e_data->proc(suffix_seqnum, prefix_seqnum, suffix_length,
                   suffixseq_direct, prefixseq_direct, a_e_data->data);
  }
}

// Assembly:
subq $0x58, %rsp
movl %r9d, %eax
movq %rcx, 0x8(%rsp)
movq %rdx, %rcx
movq 0x8(%rsp), %rdx
movq %rcx, 0x10(%rsp)
movq %rsi, %rcx
movq 0x10(%rsp), %rsi
movq %rcx, 0x18(%rsp)
movq %rdi, %r9
movq 0x18(%rsp), %rdi
movb %al, %cl
movq 0x68(%rsp), %rax
movb 0x60(%rsp), %al
movq %r9, 0x50(%rsp)
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
andb $0x1, %cl
movb %cl, 0x2f(%rsp)
andb $0x1, %al
movb %al, 0x2e(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x28ec9a
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movb 0x2f(%rsp), %cl
movb 0x2e(%rsp), %r8b
movq 0x20(%rsp), %r9
movq 0x8(%r9), %r9
andb $0x1, %cl
andb $0x1, %r8b
movzbl %cl, %ecx
movzbl %r8b, %r8d
callq *%rax
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
andb $0x1, %cl
movb %cl, 0x1f(%rsp)
andb $0x1, %al
movb %al, 0x1e(%rsp)
movq %r9, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x28ed64
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rsp), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq 0x30(%rsp), %rcx
andq $0x3f, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x28ed4f
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x28(%rsp), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq 0x28(%rsp), %rcx
andq $0x3f, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x28ed62
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
jmp 0x28edaa
jmp 0x28ed64
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x28edaa
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movb 0x1f(%rsp), %cl
movb 0x1e(%rsp), %r8b
movq 0x8(%rsp), %r9
movq 0x10(%r9), %r9
andb $0x1, %cl
andb $0x1, %r8b
movzbl %cl, %ecx
movzbl %r8b, %r8d
callq *%rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movl %r9d, %eax
movq %rcx, 0x18(%rsp)
movq %rdx, %rcx
movq 0x18(%rsp), %rdx
movq %rcx, 0x20(%rsp)
movq %rsi, %rcx
movq 0x20(%rsp), %rsi
movq %rcx, 0x28(%rsp)
movq %rdi, %r9
movq 0x28(%rsp), %rdi
movb %al, %cl
movq 0x78(%rsp), %rax
movb 0x70(%rsp), %al
movq %r9, 0x60(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
andb $0x1, %cl
movb %cl, 0x3f(%rsp)
andb $0x1, %al
movb %al, 0x3e(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x0, (%rax)
je 0x28eeab
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x60(%rsp), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq 0x60(%rsp), %rcx
andq $0x3f, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x28ee96
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x58(%rsp), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq 0x58(%rsp), %rcx
andq $0x3f, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x28eea9
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
jmp 0x28ef07
jmp 0x28eeab
movq 0x30(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x28ef07
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x40(%rsp), %r8
movb 0x3f(%rsp), %r9b
movb 0x3e(%rsp), %r11b
movq 0x30(%rsp), %r10
movq 0x10(%r10), %r10
andb $0x1, %r9b
andb $0x1, %r11b
movzbl %r9b, %r9d
movzbl %r11b, %r11d
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
callq *%rax
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
leaq 0x2f28d9(%rip), %rdi    # 0x581f31
movabsq $0x7ffffffffffffffe, %rsi # imm = 0x7FFFFFFFFFFFFFFE
movb $0x0, %al
callq 0x19070
leaq 0x2f28dd(%rip), %rdi    # 0x581f4d
movq $-0x1, %rsi
movb $0x0, %al
callq 0x19070
leaq 0x2f28e0(%rip), %rdi    # 0x581f65
movq $-0x2, %rsi
movb $0x0, %al
callq 0x19070
leaq 0x2f28ea(%rip), %rdi    # 0x581f84
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movb $0x0, %al
callq 0x19070
leaq 0x2f28ec(%rip), %rdi    # 0x581f9e
movb $0x0, %al
callq 0x19070
leaq 0x2f2905(%rip), %rdi    # 0x581fc5
leaq 0x2f290e(%rip), %rsi    # 0x581fd5
movb $0x0, %al
callq 0x19070
leaq 0x2f2918(%rip), %rdi    # 0x581fed
leaq 0x2f284d(%rip), %rsi    # 0x581f29
movb $0x0, %al
callq 0x19070
leaq 0x2f2915(%rip), %rdi    # 0x581fff
leaq 0x2f2831(%rip), %rsi    # 0x581f22
movb $0x0, %al
callq 0x19070
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jbe 0x28f728
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x28f826
jmp 0x28f72a
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x28f76d
movq 0x3ac864(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2868cd(%rip), %rsi    # 0x516013
leaq 0x2f28c1(%rip), %rdx    # 0x58200e
leaq 0x2f28d3(%rip), %rcx    # 0x582027
leaq 0x2f28e5(%rip), %r8     # 0x582040
movl $0x15b, %r9d            # imm = 0x15B
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x28f76f
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x80(%rcx), %rcx
shrq %rcx
cmpq %rcx, %rax
jae 0x28f7d4
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rsi
callq 0xb09f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jbe 0x28f7c4
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x28f7c6
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x28f780
jmp 0x28f7d6
cmpq $0x0, 0x8(%rsp)
ja 0x28f816
movq 0x3ac7bb(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x286824(%rip), %rsi    # 0x516013
leaq 0x2f2863(%rip), %rdx    # 0x582059
leaq 0x2f282a(%rip), %rcx    # 0x582027
leaq 0x2f283c(%rip), %r8     # 0x582040
movl $0x164, %r9d            # imm = 0x164
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x28f818
jmp 0x28f81a
jmp 0x28f81c
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x28f862
movq 0x20(%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0x28f862
movq 0x20(%rsp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x28f89a
movq 0x3ac737(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2867a0(%rip), %rsi    # 0x516013
leaq 0x2f27ed(%rip), %rdx    # 0x582067
leaq 0x2f283f(%rip), %rcx    # 0x5820c0
leaq 0x2f27b8(%rip), %r8     # 0x582040
movl $0x173, %r9d            # imm = 0x173
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x28f89c
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x80(%rcx), %rax
jae 0x28f97d
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xff, %eax
jge 0x28f8ee
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movq %rax, 0x18(%rsp)
jmp 0x28f952
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x28f990
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x28f944
movq 0x3ac68d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2866f6(%rip), %rsi    # 0x516013
leaq 0x2f27b6(%rip), %rdx    # 0x5820da
leaq 0x2f2795(%rip), %rcx    # 0x5820c0
leaq 0x2f270e(%rip), %r8     # 0x582040
movl $0x176, %r9d            # imm = 0x176
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x28f946
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jbe 0x28f968
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x28f96a
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x28f8a5
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x80(%rcx), %rax
jae 0x28face
jmp 0x28fa14
jmp 0x28fa16
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xff, %eax
jge 0x28fa48
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movq %rax, 0x18(%rsp)
jmp 0x28faac
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x28f990
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x28fa9e
movq 0x3ac533(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x28659c(%rip), %rsi    # 0x516013
leaq 0x2f265c(%rip), %rdx    # 0x5820da
leaq 0x2f2668(%rip), %rcx    # 0x5820ed
leaq 0x2f25b4(%rip), %r8     # 0x582040
movl $0x186, %r9d            # imm = 0x186
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x28faa0
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x28f9fb
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x1, %edi
movl $0xa0, %esi
leaq 0x2f2546(%rip), %rdx    # 0x582040
movl $0x191, %ecx            # imm = 0x191
callq 0xe83c0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x28(%rax)
movq 0x8(%rsp), %rax
movq $-0x1, 0x30(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
callq 0x28f630
movq 0x10(%rsp), %rcx
shlq %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x80(%rax)
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rdi
movl $0x1, %esi
leaq 0x2f24d7(%rip), %rdx    # 0x582040
movl $0x199, %ecx            # imm = 0x199
callq 0xe83c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x40(%rax)
callq 0x28fbb0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_allocate_graph
void gt_strgraph_allocate_graph(GtStrgraph *strgraph, GtUword fixlen,
    const GtEncseq *encseq)
{
  gt_assert(strgraph != NULL);
  gt_assert((fixlen == 0 && encseq != NULL)||
            (fixlen > 0 && encseq == NULL));
  gt_assert(sizeof (GtStrgraphLength) >= sizeof (GtUword) ||
      (fixlen > 0 && fixlen <= (GtUword)GT_STRGRAPH_LENGTH_MAX) ||
      (encseq != NULL && gt_encseq_max_seq_length(encseq)));
  strgraph->fixlen = (GtStrgraphLength)fixlen;
  strgraph->encseq = encseq;
  gt_log_log("minmatchlen = "FormatGtStrgraphLength, strgraph->minmatchlen);
  gt_strgraph_create_vertices(strgraph);
  GT_STRGRAPH_ALLOC_EDGES(strgraph);
  strgraph->state = GT_STRGRAPH_CONSTRUCTION;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x28fc43
movq 0x3ac38e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2863f7(%rip), %rsi    # 0x516013
leaq 0x2f24e1(%rip), %rdx    # 0x582104
leaq 0x2f24eb(%rip), %rcx    # 0x582115
leaq 0x2f240f(%rip), %r8     # 0x582040
movl $0x1ba, %r9d            # imm = 0x1BA
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x28fc45
jmp 0x28fc47
cmpq $0x0, 0x18(%rsp)
jne 0x28fc57
cmpq $0x0, 0x10(%rsp)
jne 0x28fc9f
cmpq $0x0, 0x18(%rsp)
jbe 0x28fc67
cmpq $0x0, 0x10(%rsp)
je 0x28fc9f
movq 0x3ac332(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x28639b(%rip), %rsi    # 0x516013
leaq 0x2f24b1(%rip), %rdx    # 0x582130
leaq 0x2f248f(%rip), %rcx    # 0x582115
leaq 0x2f23b3(%rip), %r8     # 0x582040
movl $0x1bc, %r9d            # imm = 0x1BC
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x28fca1
jmp 0x28fca3
jmp 0x28fca5
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rsi
leaq 0x2f24a1(%rip), %rdi    # 0x582171
movb $0x0, %al
callq 0xe7740
movq 0x20(%rsp), %rdi
callq 0x28fd70
movq 0x20(%rsp), %rdi
callq 0x28f700
movq %rax, %rcx
movq 0x20(%rsp), %rax
subq 0x30(%rax), %rcx
addq $0x1, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x90(%rax)
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rdi
callq 0x46ec80
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq 0x80(%rax), %rdi
callq 0x46ec80
movl 0xc(%rsp), %edi
addl %eax, %edi
addl $0x1, %edi
movq 0x20(%rsp), %rax
movq 0x98(%rax), %rsi
movl $0x1, %edx
callq 0x290040
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x88(%rax)
movq 0x20(%rsp), %rax
movl $0x1, 0x10(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x2901f5
movq (%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x290200
movq (%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x290200
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x290200
movq (%rsp), %rax
movq $0x0, 0x58(%rax)
movq (%rsp), %rax
movq $0x0, 0x70(%rax)
movq (%rsp), %rax
movq $0x0, 0x60(%rax)
movq (%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x290200
movq (%rsp), %rax
movq $0x0, 0x88(%rax)
movq (%rsp), %rax
movq 0x40(%rax), %rdi
leaq 0x2f1ea7(%rip), %rsi    # 0x582040
movl $0x1ce, %edx            # imm = 0x1CE
callq 0xe88c0
movq (%rsp), %rax
movq $0x0, 0x40(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x2901c7
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x290240
movq (%rsp), %rax
movq $0x0, 0x48(%rax)
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x2a8d80
movq (%rsp), %rdi
leaq 0x2f1e55(%rip), %rsi    # 0x582040
movl $0x1d0, %edx            # imm = 0x1D0
callq 0xe88c0
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2902a2
movq 0x3abd2f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x285d98(%rip), %rsi    # 0x516013
leaq 0x2f1e82(%rip), %rdx    # 0x582104
leaq 0x2f1efa(%rip), %rcx    # 0x582183
leaq 0x2f1db0(%rip), %r8     # 0x582040
movl $0x1d7, %r9d            # imm = 0x1D7
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2902a4
jmp 0x2902a6
movq 0x10(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x2902ea
movq 0x3abce7(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x285d50(%rip), %rsi    # 0x516013
leaq 0x2f1ede(%rip), %rdx    # 0x5821a8
leaq 0x2f1eb2(%rip), %rcx    # 0x582183
leaq 0x2f1d68(%rip), %r8     # 0x582040
movl $0x1d8, %r9d            # imm = 0x1D8
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2902ec
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x2a92b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovel %ecx, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)