LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x17d538
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
cmpq 0x68(%rbx), %rbp
jae 0x17d525
movq 0x38(%rbx), %rdi
movq 0x60(%rbx), %rax
movq (%rax,%rbp,8), %r12
movq %r12, %rsi
callq 0x74d9c
movq %rax, %r13
movq 0x38(%rbx), %rdi
movq 0x60(%rbx), %rax
movq (%rax,%rbp,8), %rsi
callq 0x75173
movq (%r14), %rcx
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %r15, %r8
movq %rbx, %r9
callq 0x17d0e3
incq %rbp
jmp 0x17d4db
andq $0x0, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x17d6b6
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x17d701
leaq 0x17d770(%rip), %rsi    # 0x2fae2d
movq %r13, %rdi
movq %rbx, %rdx
callq 0x8ce05
testq %rax, %rax
je 0x17d6f4
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x17d739
movl %eax, %ebx
movq %r13, %rdi
callq 0x8da06
movl %ebx, %eax
jmp 0x17d6f7
pushq $-0x1
popq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x2ba860(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x167901(%rip), %rsi    # 0x2e5013
leaq 0x167aa6(%rip), %rdx    # 0x2e51bf
leaq 0x1d1561(%rip), %rcx    # 0x34ec81
leaq 0x1d14c2(%rip), %r8     # 0x34ebe9
movl $0xf2, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x17d76e
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x17d7d0
xorl %r15d, %r15d
callq 0xacb84
movq %rax, %r14
testl %r15d, %r15d
jne 0x17d7b6
movq %r14, %rdi
movq %rbp, %rsi
callq 0xad63c
cmpl $-0x1, %eax
je 0x17d7b6
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
movq %rbx, %r9
callq 0x17ec07
movl %eax, %r15d
movq %r14, %rdi
callq 0xad357
jmp 0x17d779
movq %r14, %rdi
callq 0xae103
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2ba791(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x167832(%rip), %rsi    # 0x2e5013
leaq 0x1679d7(%rip), %rdx    # 0x2e51bf
leaq 0x1d155e(%rip), %rcx    # 0x34ed4d
leaq 0x1d13f3(%rip), %r8     # 0x34ebe9
movl $0xd9, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x17efa7
movq %rdi, %rcx
shrq $0x6, %rcx
movq (%r10,%rcx,8), %r11
movl %edi, %ecx
shlq %cl, %r11
shrq $0x3f, %r11
jne 0x17efa2
movabsq $-0x8000000000000000, %r11 # imm = 0x8000000000000000
movl %esi, %ecx
shrq %cl, %r11
movq %rsi, %rcx
shrq $0x6, %rcx
testq %r11, (%r10,%rcx,8)
je 0x17efa7
incq 0x18(%r9)
retq
movq 0x8(%r9), %r11
testq %r11, %r11
je 0x17efbe
movq 0x10(%r9), %r9
movzbl %al, %ecx
movzbl %r8b, %r8d
jmpq *%r11
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x17f008
movq %rdi, %rcx
shrq $0x6, %rcx
movq (%r11,%rcx,8), %rbx
movl %edi, %ecx
shlq %cl, %rbx
shrq $0x3f, %rbx
jne 0x17f002
movabsq $-0x8000000000000000, %rbx # imm = 0x8000000000000000
movl %esi, %ecx
shrq %cl, %rbx
movq %rsi, %rcx
shrq $0x6, %rcx
testq %rbx, (%r11,%rcx,8)
je 0x17f008
incq 0x18(%r10)
jmp 0x17f029
movq 0x8(%r10), %r11
testq %r11, %r11
je 0x17f029
movb 0x10(%rsp), %cl
movzbl %cl, %ebx
movzbl %r9b, %r9d
movq %rax, %rcx
pushq 0x10(%r10)
pushq %rbx
callq *%r11
popq %rax
popq %rcx
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1d006e(%rip), %rdi    # 0x34f68d
movabsq $0x7ffffffffffffffe, %rbx # imm = 0x7FFFFFFFFFFFFFFE
movq %rbx, %rsi
xorl %eax, %eax
callq 0x17070
leaq 0x1d006f(%rip), %rdi    # 0x34f6a9
pushq $-0x1
popq %rsi
xorl %eax, %eax
callq 0x17070
leaq 0x1d0076(%rip), %rdi    # 0x34f6c1
pushq $-0x2
popq %rsi
xorl %eax, %eax
callq 0x17070
incq %rbx
leaq 0x1d0081(%rip), %rdi    # 0x34f6e0
movq %rbx, %rsi
xorl %eax, %eax
callq 0x17070
leaq 0x1d2df4(%rip), %rdi    # 0x352464
callq 0x17b60
leaq 0x1d007e(%rip), %rdi    # 0x34f6fa
leaq 0x1d0087(%rip), %rsi    # 0x34f70a
xorl %eax, %eax
callq 0x17070
leaq 0x1d0091(%rip), %rdi    # 0x34f722
leaq 0x1cffed(%rip), %rsi    # 0x34f685
xorl %eax, %eax
callq 0x17070
leaq 0x1d008e(%rip), %rdi    # 0x34f734
leaq 0x1cffd1(%rip), %rsi    # 0x34f67e
xorl %eax, %eax
popq %rbx
jmp 0x17070
// File: /workspace/github_c_makefile_star2_O2/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), %rbx
testq %rbx, %rbx
jne 0x17f6fc
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x17f705
xorl %ebx, %ebx
xorl %r15d, %r15d
movq 0x80(%r14), %rax
shrq %rax
cmpq %rax, %r15
jae 0x17f6f7
movq (%r14), %rdi
movq %r15, %rsi
callq 0x75173
cmpq %rbx, %rax
cmovaq %rax, %rbx
incq %r15
jmp 0x17f6d1
testq %rbx, %rbx
je 0x17f733
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x2b885c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1658fd(%rip), %rsi    # 0x2e5013
leaq 0x1d0026(%rip), %rdx    # 0x34f743
leaq 0x1d0038(%rip), %rcx    # 0x34f75c
leaq 0x1d004a(%rip), %r8     # 0x34f775
movl $0x15b, %r9d            # imm = 0x15B
jmp 0x17f75f
movq 0x2b882e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1658cf(%rip), %rsi    # 0x2e5013
leaq 0x1d0043(%rip), %rdx    # 0x34f78e
leaq 0x1d000a(%rip), %rcx    # 0x34f75c
leaq 0x1d001c(%rip), %r8     # 0x34f775
movl $0x164, %r9d            # imm = 0x164
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
testq %rdi, %rdi
je 0x17f801
movq %rdi, %rbx
cmpq $0x0, 0x40(%rdi)
je 0x17f801
cmpq $0x0, 0x48(%rbx)
je 0x17f801
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq 0x80(%rbx), %r15
jae 0x17f7ca
movq 0x40(%rbx), %rax
movzbl (%rax,%r15), %eax
cmpq $0xff, %rax
jne 0x17f7be
movq 0x48(%rbx), %rdi
movq %r15, %rsi
callq 0x17f839
testq %rax, %rax
je 0x17f7d3
movq (%rax), %rax
cmpq %r14, %rax
cmovaq %rax, %r14
incq %r15
jmp 0x17f790
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x2b878e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x16582f(%rip), %rsi    # 0x2e5013
leaq 0x1d0024(%rip), %rdx    # 0x34f80f
leaq 0x1d0003(%rip), %rcx    # 0x34f7f5
leaq 0x1cff7c(%rip), %r8     # 0x34f775
movl $0x176, %r9d            # imm = 0x176
jmp 0x17f82d
movq 0x2b8760(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x165801(%rip), %rsi    # 0x2e5013
leaq 0x1cff83(%rip), %rdx    # 0x34f79c
leaq 0x1cffd5(%rip), %rcx    # 0x34f7f5
leaq 0x1cff4e(%rip), %r8     # 0x34f775
movl $0x173, %r9d            # imm = 0x173
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %r14
xorl %ebx, %ebx
xorl %r15d, %r15d
cmpq 0x80(%r14), %r15
jae 0x17f898
movq 0x40(%r14), %rax
movzbl (%rax,%r15), %eax
cmpq $0xff, %rax
jne 0x17f890
movq 0x48(%r14), %rdi
movq %r15, %rsi
callq 0x17f839
testq %rax, %rax
je 0x17f8a1
movq (%rax), %rax
addq %rax, %rbx
incq %r15
jmp 0x17f862
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x2b86c0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x165761(%rip), %rsi    # 0x2e5013
leaq 0x1cff56(%rip), %rdx    # 0x34f80f
leaq 0x1cff62(%rip), %rcx    # 0x34f822
leaq 0x1cfeae(%rip), %r8     # 0x34f775
movl $0x186, %r9d            # imm = 0x186
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
leaq 0x1cfe87(%rip), %r15    # 0x34f775
pushq $0x1
popq %r12
movl $0xa0, %esi
movq %r12, %rdi
movq %r15, %rdx
movl $0x191, %ecx            # imm = 0x191
callq 0x9334a
movq %rax, %rbx
andl $0x0, 0x10(%rax)
movb $0x0, 0x28(%rax)
orq $-0x1, 0x30(%rax)
andq $0x0, 0x38(%rax)
callq 0x17f5fb
addq %r14, %r14
movq %r14, 0x80(%rbx)
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x199, %ecx            # imm = 0x199
callq 0x9334a
movq %rax, 0x40(%rbx)
movups 0x2b9bd7(%rip), %xmm0   # 0x439520
movups %xmm0, 0x20(%rsp)
movups 0x2b9bbb(%rip), %xmm0   # 0x439510
movups %xmm0, 0x10(%rsp)
movups 0x2b9b9f(%rip), %xmm0   # 0x439500
movups %xmm0, (%rsp)
callq 0x8fac7
movq %rax, 0x48(%rbx)
movq 0x80(%rbx), %rax
movq %rax, 0x50(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x17fceb
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
callq 0x17fcec
movq 0x70(%rbx), %rdi
callq 0x17fcec
movq 0x60(%rbx), %rdi
callq 0x17fcec
andq $0x0, 0x70(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rbx)
movq 0x88(%rbx), %rdi
callq 0x17fcec
andq $0x0, 0x88(%rbx)
movq 0x40(%rbx), %rdi
leaq 0x1cfaca(%rip), %rsi    # 0x34f775
movl $0x1ce, %edx            # imm = 0x1CE
callq 0x936f9
andq $0x0, 0x40(%rbx)
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x17fcc8
callq 0x9082d
andq $0x0, 0x48(%rbx)
movq 0x38(%rbx), %rdi
callq 0x18d518
leaq 0x1cfa98(%rip), %rsi    # 0x34f775
movq %rbx, %rdi
movl $0x1d0, %edx            # imm = 0x1D0
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x17fd4e
movq %rdi, %rbx
cmpq $0x0, 0x38(%rdi)
jne 0x17fd7c
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x18d876
movq %rax, 0x38(%rbx)
xorl %ecx, %ecx
cmpq $0x1, %rax
sbbl %ecx, %ecx
movl %ecx, %eax
popq %rbx
retq
movq 0x2b8213(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1652b4(%rip), %rsi    # 0x2e5013
leaq 0x1cfad3(%rip), %rdx    # 0x34f839
leaq 0x1cfb4b(%rip), %rcx    # 0x34f8b8
leaq 0x1cfa01(%rip), %r8     # 0x34f775
movl $0x1d7, %r9d            # imm = 0x1D7
jmp 0x17fda8
movq 0x2b81e5(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x165286(%rip), %rsi    # 0x2e5013
leaq 0x1cfb49(%rip), %rdx    # 0x34f8dd
leaq 0x1cfb1d(%rip), %rcx    # 0x34f8b8
leaq 0x1cf9d3(%rip), %r8     # 0x34f775
movl $0x1d8, %r9d            # imm = 0x1D8
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bitpackarray.h
// Function: bitpackarray_store_uint64
static inline void
bitpackarray_store_uint64(BitPackArray *array, BitOffset index, uint64_t val)
{
  gt_assert(array && index < array->numElems
            && array->bitsPerElem <= sizeof (val)*CHAR_BIT);
  gt_bsStoreUInt64(array->store, array->bitsPerElem * index,
                   array->bitsPerElem, val);
}

// Assembly:
testq %rdi, %rdi
je 0x180049
cmpq %rsi, 0x8(%rdi)
jbe 0x180049
movq %rdx, %rcx
movl 0x10(%rdi), %edx
cmpq $0x41, %rdx
jae 0x180049
movq (%rdi), %rdi
imulq %rdx, %rsi
jmp 0x28dfac
pushq %rax
movq 0x2b7f17(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x164fb8(%rip), %rsi    # 0x2e5013
leaq 0x180c3e(%rip), %rdx    # 0x300ca0
leaq 0x180d0e(%rip), %rcx    # 0x300d77
leaq 0x180bd8(%rip), %r8     # 0x300c48
movl $0x8e, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x89da4
movq %rax, %rbx
movq %r14, %rdi
callq 0xacbd1
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
callq 0xacbfb
testl %r15d, %r15d
je 0x180608
leaq 0x1754eb(%rip), %r15    # 0x2f5af1
jmp 0x180623
movq %r14, %rdi
callq 0xad1fa
movq %rax, %rdi
callq 0x8da98
testb %al, %al
je 0x180682
leaq 0x17a80a(%rip), %r15    # 0x2fae2d
movzbl %bpl, %ebp
movq %r14, %rdi
callq 0xad1fa
movl %ebp, %edi
movq %rax, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x8cea6
testq %rax, %rax
je 0x180663
movq %rax, %r15
movq %r14, %rdi
callq 0xae103
movq %rbx, %rdi
callq 0x8a045
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x2b78fe(%rip), %rax    # 0x437f68
movq (%rax), %r14
movq %rbx, %rdi
callq 0x89f41
movq %rax, %rdi
movq %r14, %rsi
callq 0x17870
jmp 0x1806a8
movq 0x2b78df(%rip), %rax    # 0x437f68
movq (%rax), %rbx
movq %r14, %rdi
callq 0xad1fa
leaq 0x1cc838(%rip), %rsi    # 0x34ced3
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x17a50
pushq $0x1
popq %rdi
callq 0x178f0
// File: /workspace/github_c_makefile_star2_O2/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 0x175132(%rip), %rcx    # 0x2f5af1
leaq 0x1b2f48(%rip), %rax    # 0x33390e
testl %ebp, %ebp
cmovneq %rcx, %rax
leaq 0x1ceda2(%rip), %rcx    # 0x34f775
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
movl $0x267, %r8d            # imm = 0x267
callq 0x8a449
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x180a2d
testq %r14, %r14
je 0x180a0d
andq $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 0x180a38
movq 0x18(%rbx), %rdi
movq 0x80(%rbx), %rax
shrq $0x21, %rax
je 0x180a33
callq 0x17d603
jmp 0x180a38
pushq $-0x1
popq %r14
jmp 0x180a38
callq 0x17d53c
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x180af5
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 0x1806b0
cmpb $0x1, 0x29(%r13)
jne 0x180aad
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 0x180ae6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17d60e
movq 0x18(%r13), %rdi
callq 0x8d2a4
movq %rax, %r13
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %r15d, %ecx
movl %ebp, %r8d
movq %rax, %r9
callq 0x17dab0
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8d080
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17d547
movq 0x2b746c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x16450d(%rip), %rsi    # 0x2e5013
leaq 0x1ced2c(%rip), %rdx    # 0x34f839
leaq 0x1cefa6(%rip), %rcx    # 0x34faba
leaq 0x1cec5a(%rip), %r8     # 0x34f775
movl $0x280, %r9d            # imm = 0x280
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x180ba5
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
jne 0x180bd3
pushq $0x1
popq %rax
movq %rsi, %rdi
movq %rdx, %rsi
movl %eax, %edx
xorl %ecx, %ecx
callq 0x1805c9
movq %rax, %r14
movq 0x40(%rbx), %rsi
movq 0x50(%rbx), %rdx
movq %rax, %rdi
callq 0x8d8e3
movq 0x48(%rbx), %rdi
movq %rsp, %rdx
movq %r14, (%rdx)
leaq -0x15d8(%rip), %rax     # 0x17f5a4
movq %rax, 0x8(%rdx)
andq $0x0, 0x10(%rdx)
leaq 0x67e8(%rip), %rsi      # 0x187374
xorl %ecx, %ecx
callq 0x9059c
movq %r14, %rdi
callq 0x8da06
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x2b73bc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x16445d(%rip), %rsi    # 0x2e5013
leaq 0x1cec7c(%rip), %rdx    # 0x34f839
leaq 0x1cef19(%rip), %rcx    # 0x34fadd
leaq 0x1cebaa(%rip), %r8     # 0x34f775
movl $0x2a3, %r9d            # imm = 0x2A3
jmp 0x180bff
movq 0x2b738e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x16442f(%rip), %rsi    # 0x2e5013
leaq 0x1cef0a(%rip), %rdx    # 0x34faf5
leaq 0x1ceeeb(%rip), %rcx    # 0x34fadd
leaq 0x1ceb7c(%rip), %r8     # 0x34f775
movl $0x2a4, %r9d            # imm = 0x2A4
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x180d19
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
jne 0x180d47
movq %rsi, %rdi
movq %rdx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1805c9
movq %rax, %r14
movq 0x40(%rbx), %rsi
movq 0x50(%rbx), %rdx
movq %rax, %rdi
callq 0x8d861
cmpl 0x50(%rbx), %eax
jne 0x180d75
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
movq %rsp, %r12
pushq $0x8
popq %r13
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x8d861
cmpl $0x8, %eax
jne 0x180cc9
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x8d861
cmpl $0x8, %eax
jne 0x180ce1
movq 0x8(%rsp), %rax
cmpq $0xfe, %rax
ja 0x180ca9
movq 0x40(%rbx), %rcx
movq (%rsp), %rdx
movb %al, (%rcx,%rdx)
jmp 0x180c69
movq 0x40(%rbx), %rax
movq (%rsp), %rcx
movb $-0x1, (%rax,%rcx)
movq 0x48(%rbx), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x180974
jmp 0x180c69
movq %r14, %rdi
callq 0x8da06
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x2b7280(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x164321(%rip), %rsi    # 0x2e5013
leaq 0x1cee98(%rip), %rdx    # 0x34fb91
leaq 0x1cee20(%rip), %rcx    # 0x34fb20
leaq 0x1cea6e(%rip), %r8     # 0x34f775
movl $0x2b5, %r9d            # imm = 0x2B5
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x2b7248(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1642e9(%rip), %rsi    # 0x2e5013
leaq 0x1ceb08(%rip), %rdx    # 0x34f839
leaq 0x1cede8(%rip), %rcx    # 0x34fb20
leaq 0x1cea36(%rip), %r8     # 0x34f775
movl $0x2b1, %r9d            # imm = 0x2B1
jmp 0x180d0d
movq 0x2b721a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1642bb(%rip), %rsi    # 0x2e5013
leaq 0x1ced96(%rip), %rdx    # 0x34faf5
leaq 0x1cedba(%rip), %rcx    # 0x34fb20
leaq 0x1cea08(%rip), %r8     # 0x34f775
movl $0x2b2, %r9d            # imm = 0x2B2
jmp 0x180d0d
movq 0x2b71ec(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x16428d(%rip), %rsi    # 0x2e5013
leaq 0x1cedab(%rip), %rdx    # 0x34fb38
jmp 0x180cf9
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_add_edge
static inline void gt_strgraph_add_edge(GtStrgraph *strgraph,
    GtStrgraphVnum from, GtStrgraphVnum to, GtStrgraphLength spmlen)
{
  GtStrgraphLength edgelen;
  GtStrgraphVEdgenum next_free_edge;

  gt_assert(strgraph != NULL);

  edgelen = GT_STRGRAPH_SEQLEN(strgraph, GT_STRGRAPH_V_READNUM(to)) - spmlen;

  GT_STRGRAPH_CHECK_LEN(from, to, edgelen);
  next_free_edge = GT_STRGRAPH_V_OUTDEG(strgraph, from);
  GT_STRGRAPH_EDGE_INIT(strgraph, from, next_free_edge);
  GT_STRGRAPH_EDGE_SET_DEST(strgraph, from, next_free_edge, to);
  GT_STRGRAPH_EDGE_SET_LEN(strgraph, from, next_free_edge, edgelen);
  GT_STRGRAPH_V_INC_OUTDEG(strgraph, from);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %rbp
movq %rdi, %r14
movq 0x8(%rdi), %rax
testq %rax, %rax
jne 0x18121f
movq (%r14), %rdi
movq %rbx, %rsi
shrq %rsi
callq 0x75173
subq %r12, %rax
movq %rax, 0x20(%rsp)
movq 0x70(%r14), %rdi
movq %rbp, %rsi
callq 0x17ffcd
movq %rax, %r12
movq 0x60(%r14), %rdi
movq 0x88(%r14), %rax
movq %rax, 0x8(%rsp)
movq %rbp, %rsi
callq 0x17ffcd
leaq (%rax,%r12), %r15
movq 0x60(%r14), %rdi
movq 0x88(%r14), %r13
movq %rbp, %rsi
movq %rbp, 0x10(%rsp)
callq 0x17ffcd
leaq (%rax,%r12), %rsi
movq %r13, %rdi
callq 0x17ffcd
andq $-0x2, %rax
movq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x180026
movq 0x60(%r14), %rdi
movq 0x88(%r14), %rax
movq %rax, 0x8(%rsp)
movq %rbp, %rsi
callq 0x17ffcd
addq %r12, %rax
movq %rax, 0x18(%rsp)
movq 0x80(%r14), %rdi
callq 0x28a939
pushq $-0x1
popq %r13
movl %r13d, %ebp
movl %eax, %ecx
shll %cl, %ebp
notl %ebp
movq 0x90(%r14), %rdi
callq 0x28a939
leal 0x1(%rax), %ecx
shll %cl, %ebp
notl %ebp
movslq %ebp, %rbp
movq 0x60(%r14), %rdi
movq 0x88(%r14), %r15
movq 0x10(%rsp), %rsi
callq 0x17ffcd
leaq (%rax,%r12), %rsi
movq %r15, %rdi
callq 0x17ffcd
andq %rax, %rbp
movq 0x90(%r14), %rdi
callq 0x28a939
leal 0x1(%rax), %ecx
shlq %cl, %rbx
addq %rbp, %rbx
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rbx, %rdx
callq 0x180026
movq 0x60(%r14), %rdi
movq 0x88(%r14), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rbx
movq %rbx, %rsi
callq 0x17ffcd
leaq (%rax,%r12), %rbp
movq 0x90(%r14), %rdi
callq 0x28a939
movl %eax, %ecx
shll %cl, %r13d
notl %r13d
addl %r13d, %r13d
notl %r13d
movslq %r13d, %r13
movq 0x60(%r14), %rdi
movq 0x88(%r14), %r15
movq %rbx, %rsi
callq 0x17ffcd
addq %rax, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x17ffcd
andq %r13, %rax
movq 0x20(%rsp), %rcx
leaq (%rax,%rcx,2), %rdx
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x180026
movq 0x70(%r14), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x17ffcd
leaq 0x1(%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x180026
// File: /workspace/github_c_makefile_star2_O2/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 0x181bb4
leaq 0x1(%r14), %r15
xorl %ebp, %ebp
xorl %r13d, %r13d
movq 0x60(%rbx), %rdi
movq %r15, %rsi
callq 0x17ffcd
movq %rax, %r12
movq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x17ffcd
subq %rax, %r12
cmpq %r12, %rbp
jae 0x181b64
movq 0x60(%rbx), %rdi
movq 0x88(%rbx), %r12
movq %r14, %rsi
callq 0x17ffcd
leaq (%rax,%rbp), %rsi
movq %r12, %rdi
callq 0x17ffcd
movq %rax, %r12
movq 0x90(%rbx), %rdi
callq 0x28a939
pushq $-0x1
popq %rdx
movl %eax, %ecx
shll %cl, %edx
notl %edx
addl %edx, %edx
movslq %edx, %rax
andq %r12, %rax
shrq %rax
xorl %ecx, %ecx
cmpq 0x90(%rbx), %rax
setne %cl
addq %rcx, %r13
incq %rbp
jmp 0x181aeb
movq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x17ffcd
movq %r15, %r14
cmpq %rax, %r13
je 0x181ad5
movq 0x2b63e5(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x163486(%rip), %rsi    # 0x2e5013
leaq 0x1cebe9(%rip), %rdx    # 0x35077d
leaq 0x1cec0e(%rip), %rcx    # 0x3507a9
leaq 0x1cdbd3(%rip), %r8     # 0x34f775
movl $0x35e, %r9d            # imm = 0x35E
xorl %eax, %eax
callq 0x17a50
callq 0x17390
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_reduce_marked_edges
static GtUword gt_strgraph_reduce_marked_edges(GtStrgraph *strgraph)
{
  GtStrgraphVnum i;
  GtUword counter = 0;
  GtStrgraphVEdgenum j;

  for (i = 0; i < GT_STRGRAPH_NOFVERTICES(strgraph); i++)
  {
    if (GT_STRGRAPH_V_OUTDEG(strgraph, i) == 0)
      continue;
    for (j = 0; j < GT_STRGRAPH_V_NOFEDGES(strgraph, i); j++)
    {
      if (GT_STRGRAPH_EDGE_IS_REDUCED(strgraph, i, j))
        continue;
      if (GT_STRGRAPH_EDGE_HAS_MARK(strgraph, i, j))
      {
        GT_STRGRAPH_EDGE_REDUCE(strgraph, i, j);
        GT_STRGRAPH_V_DEC_OUTDEG(strgraph, i);
        counter++;
      }
    }
  }
  return counter;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
pushq $-0x1
popq %r15
xorl %r12d, %r12d
cmpq 0x80(%rbx), %r14
jae 0x18275f
movq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x17ffcd
incq %r14
testq %rax, %rax
je 0x1825e8
movq %r12, (%rsp)
leaq -0x1(%r14), %r12
xorl %ebp, %ebp
movq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x17ffcd
movq %rax, %r13
movq 0x60(%rbx), %rdi
movq %r12, %rsi
callq 0x17ffcd
subq %rax, %r13
cmpq %r13, %rbp
jae 0x182756
movq 0x60(%rbx), %rdi
movq 0x88(%rbx), %r13
movq %r12, %rsi
callq 0x17ffcd
leaq (%rax,%rbp), %rsi
movq %r13, %rdi
callq 0x17ffcd
movq %rax, %r13
movq 0x90(%rbx), %rdi
callq 0x28a939
movl %r15d, %edx
movl %eax, %ecx
shll %cl, %edx
notl %edx
addl %edx, %edx
movslq %edx, %rax
andq %r13, %rax
shrq %rax
cmpq 0x90(%rbx), %rax
je 0x18274e
movq 0x60(%rbx), %rdi
movq 0x88(%rbx), %r13
movq %r12, %rsi
callq 0x17ffcd
leaq (%rax,%rbp), %rsi
movq %r13, %rdi
callq 0x17ffcd
testb $0x1, %al
je 0x18274e
movq 0x60(%rbx), %rdi
movq 0x88(%rbx), %rax
movq %rax, 0x10(%rsp)
movq %r12, %rsi
callq 0x17ffcd
addq %rbp, %rax
movq %rax, 0x8(%rsp)
movq 0x90(%rbx), %rdi
callq 0x28a939
movl %r15d, %edx
movl %eax, %ecx
shll %cl, %edx
notl %edx
addl %edx, %edx
notl %edx
movslq %edx, %r13
movq 0x60(%rbx), %rdi
movq 0x88(%rbx), %r15
movq %r12, %rsi
callq 0x17ffcd
leaq (%rax,%rbp), %rsi
movq %r15, %rdi
callq 0x17ffcd
andq %r13, %rax
movq 0x90(%rbx), %rcx
leaq (%rax,%rcx,2), %rdx
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x180026
movq 0x70(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x17ffcd
leaq -0x1(%rax), %rdx
movq %r15, %rdi
pushq $-0x1
popq %r15
movq %r12, %rsi
callq 0x180026
incq (%rsp)
incq %rbp
jmp 0x182613
movq (%rsp), %r12
jmp 0x1825e8
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x70(%rdi), %rdi
callq 0x17ffcd
cmpq $0x1, %rax
jne 0x18317e
leaq 0x1(%rbx), %r12
xorl %r15d, %r15d
pushq $-0x1
popq %rbp
movq 0x60(%r14), %rdi
movq %r12, %rsi
callq 0x17ffcd
movq %rax, %r13
movq 0x60(%r14), %rdi
movq %rbx, %rsi
callq 0x17ffcd
subq %rax, %r13
cmpq %r13, %r15
jae 0x183146
movq 0x60(%r14), %rdi
movq 0x88(%r14), %r13
movq %rbx, %rsi
callq 0x17ffcd
leaq (%rax,%r15), %rsi
movq %r13, %rdi
callq 0x17ffcd
movq %rax, %r13
movq 0x90(%r14), %rdi
callq 0x28a939
movl %ebp, %edx
movl %eax, %ecx
shll %cl, %edx
notl %edx
addl %edx, %edx
movslq %edx, %rax
andq %r13, %rax
shrq %rax
cmpq 0x90(%r14), %rax
jne 0x183134
incq %r15
jmp 0x1830c2
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2b4e1b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x161ebc(%rip), %rsi    # 0x2e5013
leaq 0x1a388e(%rip), %rdx    # 0x3269ec
leaq 0x1cd69c(%rip), %rcx    # 0x350801
leaq 0x1cc609(%rip), %r8     # 0x34f775
movl $0x463, %r9d            # imm = 0x463
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x2b4de3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x161e84(%rip), %rsi    # 0x2e5013
leaq 0x1cd62d(%rip), %rdx    # 0x3507c3
leaq 0x1cd664(%rip), %rcx    # 0x350801
leaq 0x1cc5d1(%rip), %r8     # 0x34f775
movl $0x45d, %r9d            # imm = 0x45D
jmp 0x183172
// File: /workspace/github_c_makefile_star2_O2/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 0x183858
retq
movq 0x18(%rdi), %rcx
xorl %eax, %eax
cmpq 0x18(%rsi), %rcx
seta %al
sbbl $0x0, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x18520f
movq %rdi, %r12
xorl %r13d, %r13d
callq 0x6d958
movq %rax, %rbx
cmpq 0x80(%r12), %r13
jae 0x1851b7
leaq 0x1(%r13), %rbp
xorl %r15d, %r15d
movq 0x60(%r12), %rdi
movq %rbp, %rsi
callq 0x17ffcd
movq %rax, %r14
movq 0x60(%r12), %rdi
movq %r13, %rsi
callq 0x17ffcd
subq %rax, %r14
cmpq %r14, %r15
jae 0x1851af
movq 0x60(%r12), %rdi
movq 0x88(%r12), %r14
movq %r13, %rsi
callq 0x17ffcd
leaq (%rax,%r15), %rsi
movq %r14, %rdi
callq 0x17ffcd
movq %rax, %r14
movq 0x90(%r12), %rdi
callq 0x28a939
pushq $-0x1
popq %rdx
movl %eax, %ecx
shll %cl, %edx
notl %edx
addl %edx, %edx
movslq %edx, %rsi
andq %r14, %rsi
shrq %rsi
movq %rbx, %rdi
callq 0x6d96d
incq %r15
jmp 0x185138
movq %rbp, %r13
jmp 0x185123
pushq $0x1
popq %rdx
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
xorl %ecx, %ecx
callq 0x1805c9
movq %rax, %r14
leaq 0x1caedf(%rip), %rsi    # 0x3500b4
movq %rax, %rdi
xorl %eax, %eax
callq 0x8d432
leaq 0x61(%rip), %rsi        # 0x185247
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6dc7c
movq %rbx, %rdi
callq 0x6e064
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8da06
movq 0x2b2d52(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15fdf3(%rip), %rsi    # 0x2e5013
leaq 0x1ca612(%rip), %rdx    # 0x34f839
leaq 0x1cae5b(%rip), %rcx    # 0x350089
leaq 0x1ca540(%rip), %r8     # 0x34f775
movl $0x86a, %r9d            # imm = 0x86A
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_show_counts_distribution
void gt_strgraph_show_counts_distribution(const GtStrgraph *strgraph,
    const char *indexname, const char *suffix)
{
  GtDiscDistri *d;
  GtFile *outfp;
  GtStrgraphVnum i;

  gt_assert(sizeof (GtUword) >= sizeof (GtStrgraphCount));
  d = gt_disc_distri_new();
  gt_assert(strgraph != NULL &&\
            strgraph->__small_counts != NULL &&
            strgraph->__large_counts != NULL);
  for (i = 0; i < GT_STRGRAPH_NOFVERTICES(strgraph); i++)
  {
    GtStrgraphCount c;
    GT_STRGRAPH_GET_COUNT(strgraph, c, i);
    gt_disc_distri_add(d, (GtUword)c);
  }
  outfp = gt_strgraph_get_file(indexname, suffix, true, false);
  gt_file_xprintf(outfp, "# count nofvertices\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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x6d958
testq %r12, %r12
je 0x185360
cmpq $0x0, 0x40(%r12)
je 0x185360
cmpq $0x0, 0x48(%r12)
je 0x185360
movq %rax, %rbx
xorl %r13d, %r13d
cmpq 0x80(%r12), %r13
jae 0x1852e3
movq 0x40(%r12), %rax
movzbl (%rax,%r13), %esi
cmpq $0xff, %rsi
jne 0x1852d6
movq 0x48(%r12), %rdi
movq %r13, %rsi
callq 0x17f839
testq %rax, %rax
je 0x185332
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x6d96d
incq %r13
jmp 0x1852a4
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x1805c9
movq %rax, %r14
leaq 0x1cadef(%rip), %rsi    # 0x3500ec
movq %rax, %rdi
xorl %eax, %eax
callq 0x8d432
leaq -0xc7(%rip), %rsi       # 0x185247
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6dc7c
movq %rbx, %rdi
callq 0x6e064
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8da06
movq 0x2b2c2f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15fcd0(%rip), %rsi    # 0x2e5013
leaq 0x1ca4c5(%rip), %rdx    # 0x34f80f
leaq 0x1cad76(%rip), %rcx    # 0x3500c7
leaq 0x1ca41d(%rip), %r8     # 0x34f775
movl $0x88c, %r9d            # imm = 0x88C
jmp 0x18538c
movq 0x2b2c01(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15fca2(%rip), %rsi    # 0x2e5013
leaq 0x1ca424(%rip), %rdx    # 0x34f79c
leaq 0x1cad48(%rip), %rcx    # 0x3500c7
leaq 0x1ca3ef(%rip), %r8     # 0x34f775
movl $0x888, %r9d            # imm = 0x888
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_log_space
void gt_strgraph_log_space(const GtStrgraph *strgraph)
{
  size_t space_for_edges, space_for_vertices, total_space;
  gt_assert(strgraph != NULL);
  space_for_edges = GT_STRGRAPH_SIZEOF_EDGES(strgraph);
  space_for_vertices = GT_STRGRAPH_SIZEOF_VERTICES(strgraph);
  total_space = sizeof (GtStrgraph) + space_for_edges + space_for_vertices;
  gt_strgraph_log_space_value("space graph", total_space);
  gt_strgraph_log_space_value("- edges", space_for_edges);
  gt_strgraph_log_space_value("- vertices", space_for_vertices);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x185ad6
movq %rdi, %r15
movq 0x90(%rdi), %rdi
callq 0x28a939
movl %eax, %ebx
movq 0x80(%r15), %rdi
callq 0x28a939
addl %ebx, %eax
incl %eax
imulq 0x98(%r15), %rax
movq %rax, %rbx
shrq $0x3, %rbx
andl $0x7, %eax
cmpq $0x1, %rax
sbbq $-0x1, %rbx
movq 0x68(%r15), %rdi
movq 0x80(%r15), %rax
leaq 0x2(,%rax,2), %r12
movq %r12, %r14
shrq $0x3, %r14
andl $0x6, %r12d
callq 0x28a939
movq 0x78(%r15), %rdi
movq 0x80(%r15), %rcx
incq %rcx
movl %eax, %r13d
imulq %rcx, %r13
movq %r13, %rbp
shrq $0x3, %rbp
andl $0x7, %r13d
callq 0x28a939
movq 0x80(%r15), %rcx
incq %rcx
movl %eax, %eax
imulq %rcx, %rax
movq %rax, %rcx
shrq $0x3, %rcx
andl $0x7, %eax
cmpq $0x1, %r12
sbbq $-0x1, %r14
addq %rbp, %r14
cmpq $0x1, %r13
sbbq $-0x1, %r14
addq %rcx, %r14
cmpq $0x1, %rax
sbbq $-0x1, %r14
leaq (%rbx,%r14), %rsi
addq $0xc8, %rsi
addq $0x28, %r14
leaq 0x1ca6ff(%rip), %rdi    # 0x3501a7
callq 0x185b0e
leaq 0x1ca6ff(%rip), %rdi    # 0x3501b3
movq %rbx, %rsi
callq 0x185b0e
leaq 0x1ca6f8(%rip), %rdi    # 0x3501bb
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x185b0e
movq 0x2b248b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15f52c(%rip), %rsi    # 0x2e5013
leaq 0x1c9d4b(%rip), %rdx    # 0x34f839
leaq 0x1ca69c(%rip), %rcx    # 0x350191
leaq 0x1c9c79(%rip), %r8     # 0x34f775
movl $0x8d0, %r9d            # imm = 0x8D0
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_log_space_value
static void gt_strgraph_log_space_value(const char *prefix, size_t value)
{
  char unit_prefix;
  float float_value;
  if (value < (size_t)1024) {
    gt_log_log("%s = "GT_WU" bytes", prefix, (GtUword)value);
  } else {
    if (value < (size_t)1048576) {
      unit_prefix = 'k';
      float_value = (float)value / 1024.F;
    } else if (value < (size_t)1073741824UL) {
      unit_prefix = 'M';
      float_value = (float)value / 1048576.F;
    } else {
      unit_prefix = 'G';
      float_value = (float)value / 1073741824.F;
    }
    gt_log_log("%s = "GT_WU" bytes (%.2f %cb)", prefix, (GtUword)value,
        float_value, unit_prefix);
  }
}

// Assembly:
movq %rsi, %rdx
movq %rdi, %rsi
cmpq $0x3ff, %rdx            # imm = 0x3FF
ja 0x185b2b
leaq 0x1caf8c(%rip), %rdi    # 0x350ab0
xorl %eax, %eax
jmp 0x92a82
cmpq $0xfffff, %rdx          # imm = 0xFFFFF
ja 0x185b45
cvtsi2ss %rdx, %xmm0
mulss 0x1c9b07(%rip), %xmm0   # 0x34f648
pushq $0x6b
jmp 0x185b87
testq %rdx, %rdx
js 0x185b51
cvtsi2ss %rdx, %xmm0
jmp 0x185b68
movq %rdx, %rax
shrq %rax
movl %edx, %ecx
andl $0x1, %ecx
orq %rax, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cmpq $0x3fffffff, %rdx       # imm = 0x3FFFFFFF
ja 0x185b7d
mulss 0x1c9acb(%rip), %xmm0   # 0x34f644
pushq $0x4d
jmp 0x185b87
mulss 0x1c9abb(%rip), %xmm0   # 0x34f640
pushq $0x47
popq %rcx
cvtss2sd %xmm0, %xmm0
leaq 0x1caf2c(%rip), %rdi    # 0x350abf
movb $0x1, %al
jmp 0x92a82
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_nofvertices_Vnum
static inline GtStrgraphVnum gt_strgraph_nofvertices_Vnum(
    const GtStrgraph *strgraph)
{
  GtStrgraphVnum i, connected_vertices;

  gt_assert(strgraph != NULL);

  connected_vertices = 0;
  for (i = 0; i < GT_STRGRAPH_NOFVERTICES(strgraph); i++)
  {
    if ((GT_STRGRAPH_V_OUTDEG(strgraph, i) > 0) ||
        (GT_STRGRAPH_V_INDEG(strgraph, i) > 0))
    {
      connected_vertices++;
    }
  }
  return connected_vertices;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x185bf8
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq 0x80(%rbx), %r14
jae 0x185bef
movq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x17ffcd
testq %rax, %rax
jne 0x185be7
movq 0x70(%rbx), %rdi
movl %r14d, %esi
andl $0x1, %esi
negq %rsi
orq $0x1, %rsi
addq %r14, %rsi
callq 0x17ffcd
testq %rax, %rax
je 0x185bea
incq %r15
incq %r14
jmp 0x185baf
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x2b2369(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15f40a(%rip), %rsi    # 0x2e5013
leaq 0x1c9c29(%rip), %rdx    # 0x34f839
leaq 0x1caec2(%rip), %rcx    # 0x350ad9
leaq 0x1c9b57(%rip), %r8     # 0x34f775
movl $0x8de, %r9d            # imm = 0x8DE
xorl %eax, %eax
callq 0x17a50
callq 0x17390