LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_spmproc_strgraph_count
void gt_spmproc_strgraph_count(GtUword suffix_readnum,
    GtUword prefix_readnum, GtUword length,
    bool suffixseq_direct, bool prefixseq_direct, void *strgraph)
{
  GtStrgraph* g;
  GtStrgraphVnum position;

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %r9, %r9
je 0x1d8b96
movq %r9, %rbx
cmpl $0x0, 0x10(%r9)
jne 0x1d8b9b
movq %rdx, %r14
movq 0x40(%rbx), %rdx
testq %rdx, %rdx
je 0x1d8b8c
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x1d8b8c
movl %r8d, %ebp
movq %rsi, %r15
movzbl %cl, %ecx
leaq (%rcx,%rdi,2), %r12
movb (%rdx,%r12), %cl
cmpb $-0x3, %cl
ja 0x1d8a30
incb %cl
movb %cl, (%rdx,%r12)
jmp 0x1d8abb
cmpb $-0x2, %cl
jne 0x1d8a85
movb $-0x1, (%rdx,%r12)
movq 0x48(%rbx), %rdi
leaq 0x10(%rsp), %rsi
movq %r12, (%rsi)
callq 0x10620e
testq %rax, %rax
jne 0x1d8ba0
movq 0x48(%rbx), %rdi
leaq 0x10(%rsp), %rsi
movq %r12, (%rsi)
movq $0xff, 0x8(%rsi)
leaq 0x8(%rsp), %rdx
callq 0x106536
testl %eax, %eax
jne 0x1d8abb
movq 0x8(%rsp), %rax
movq $0xff, 0x8(%rax)
jmp 0x1d8abb
leaq 0x10(%rsp), %rsi
movq %r12, (%rsi)
movq %rax, %rdi
callq 0x10620e
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq 0x40(%rbx), %rdx
cmpb $-0x1, (%rdx,%r12)
jne 0x1d8ba5
testq %rax, %rax
je 0x1d8baa
incq (%rcx)
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x1d8b91
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x1d8b91
xorb $0x1, %bpl
movzbl %bpl, %ecx
leaq (%rcx,%r15,2), %r15
movb (%rax,%r15), %cl
cmpb $-0x3, %cl
ja 0x1d8af5
incb %cl
movb %cl, (%rax,%r15)
jmp 0x1d8b75
cmpb $-0x2, %cl
jne 0x1d8b4a
movb $-0x1, (%rax,%r15)
movq 0x48(%rbx), %rdi
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
callq 0x10620e
testq %rax, %rax
jne 0x1d8baf
movq 0x48(%rbx), %rdi
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
movq $0xff, 0x8(%rsi)
leaq 0x8(%rsp), %rdx
callq 0x106536
testl %eax, %eax
jne 0x1d8b75
movq 0x8(%rsp), %rax
movq $0xff, 0x8(%rax)
jmp 0x1d8b75
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
callq 0x10620e
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq 0x40(%rbx), %rdx
cmpb $-0x1, (%rdx,%r15)
jne 0x1d8bb4
testq %rax, %rax
je 0x1d8bb9
incq (%rcx)
cmpq %r14, 0x30(%rbx)
jbe 0x1d8b7f
movq %r14, 0x30(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x6e179
callq 0x6e140
callq 0x6e1b2
callq 0x6dfb1
callq 0x6e05c
callq 0x6dfea
callq 0x6e023
callq 0x6e107
callq 0x6e095
callq 0x6e0ce
// File: /workspace/github_c_makefile_star2_O1/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 0x185f38(%rip), %rcx    # 0x35eb0d
leaq 0x1c3e55(%rip), %rax    # 0x39ca31
testl %ebp, %ebp
cmovneq %rcx, %rax
leaq 0x1dfd44(%rip), %rcx    # 0x3b892d
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
movl $0x267, %r8d            # imm = 0x267
callq 0x101dff
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x1d8c46
testq %r14, %r14
je 0x1d8c26
movq $0x0, 0x20(%rbx)
shlq $0x14, %r14
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x17050
xorl %r14d, %r14d
testb %bpl, %bpl
je 0x1d8c53
movq 0x18(%rbx), %rdi
movq 0x80(%rbx), %rax
shrq $0x21, %rax
je 0x1d8c4e
callq 0x1d59ba
jmp 0x1d8c53
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x1d8c53
callq 0x1d5948
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1d8d10
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 0x1d89cf
cmpb $0x1, 0x29(%r13)
jne 0x1d8cc8
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 0x1d8d01
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1d59c7
movq 0x18(%r13), %rdi
callq 0x103c55
movq %rax, %r13
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %r15d, %ecx
movl %ebp, %r8d
movq %rax, %r9
callq 0x1d5e18
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x103ae6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1d5955
callq 0x6e1eb
// File: /workspace/github_c_makefile_star2_O1/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 0x1d8d8c
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
jne 0x1d8d91
movq %rsi, %rdi
movq %rdx, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x1d8925
movq %rax, %r14
movq 0x40(%rbx), %rsi
movq 0x50(%rbx), %rdx
movq %rax, %rdi
callq 0x104060
movq 0x48(%rbx), %rdi
movq %rsp, %rdx
movq %r14, (%rdx)
leaq -0x16b4(%rip), %rax     # 0x1d76ac
movq %rax, 0x8(%rdx)
movq $0x0, 0x10(%rdx)
leaq 0x9de2(%rip), %rsi      # 0x1e2b55
xorl %ecx, %ecx
callq 0x106adc
movq %r14, %rdi
callq 0x1040fc
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x6e25d
callq 0x6e224
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_load_counts
int gt_strgraph_load_counts(GtStrgraph *strgraph, const char *indexname,
    const char *suffix, GT_UNUSED GtError *err)
{
  GtFile *infp;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x1d8ebb
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
jne 0x1d8ec0
movq %rsi, %rdi
movq %rdx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1d8925
movq %rax, %r14
movq 0x40(%rbx), %rsi
movq 0x50(%rbx), %rdx
movq %rax, %rdi
callq 0x104009
cmpl 0x50(%rbx), %eax
jne 0x1d8ec5
movq $0x0, 0x8(%rsp)
movq %rsp, %rsi
movl $0x8, %edx
movq %r14, %rdi
callq 0x104009
cmpl $0x8, %eax
jne 0x1d8e9d
leaq 0x8(%rsp), %r15
movq %rsp, %r12
leaq 0x10(%rsp), %rbp
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x104009
cmpl $0x8, %eax
jne 0x1d8eb6
movq 0x8(%rsp), %rax
cmpq $0xfe, %rax
ja 0x1d8e47
movq 0x40(%rbx), %rcx
movq (%rsp), %rdx
movb %al, (%rcx,%rdx)
jmp 0x1d8e84
movq 0x40(%rbx), %rax
movq (%rsp), %rcx
movb $-0x1, (%rax,%rcx)
movq 0x48(%rbx), %rdi
movq (%rsp), %rax
movq 0x8(%rsp), %r13
movq %rax, 0x18(%rsp)
movq %r13, 0x20(%rsp)
leaq 0x18(%rsp), %rsi
movq %rbp, %rdx
callq 0x106536
testl %eax, %eax
jne 0x1d8e84
movq 0x10(%rsp), %rax
movq %r13, 0x8(%rax)
movl $0x8, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x104009
cmpl $0x8, %eax
je 0x1d8e14
movq %r14, %rdi
callq 0x1040fc
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x6e308
callq 0x6e341
callq 0x6e296
callq 0x6e2cf
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_spmproc_strgraph_add
void gt_spmproc_strgraph_add(GtUword suffix_readnum,
    GtUword prefix_readnum, GtUword length,
    bool suffixseq_direct, bool prefixseq_direct, void *graph)
{
  GtStrgraph *strgraph = graph;
  GtStrgraphLength edgelen = (GtStrgraphLength)length;
  gt_assert(strgraph != NULL);
  gt_assert(suffixseq_direct || prefixseq_direct);

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %r9, %r9
je 0x1d9486
movl %ecx, %eax
orb %r8b, %al
je 0x1d948b
movq %r9, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
cmpq %rsi, %rdi
jne 0x1d93e3
cmpb $0x1, 0x28(%r15)
jne 0x1d9433
addq %r12, %r12
testb %cl, %cl
je 0x1d940d
movq %r12, %rsi
orq $0x1, %rsi
addq %r14, %r14
testb %r8b, %r8b
je 0x1d943d
movq %r14, %rdx
orq $0x1, %rdx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x1d949f
jmp 0x1d944f
addq %r14, %r14
movq %r12, %r13
orq $0x1, %r13
testb %r8b, %r8b
je 0x1d945a
movq %r14, %rdx
orq $0x1, %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rcx
callq 0x1d949f
jmp 0x1d946f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1d949f
orq $0x1, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
jmp 0x1d9478
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1d949f
orq $0x1, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1d949f
callq 0x6e70a
callq 0x6e6d1
// File: /workspace/github_c_makefile_star2_O1/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 0x1da76f
movq 0x60(%rbx), %rax
testq %rax, %rax
je 0x1da77e
leaq 0x1(%r14), %r12
xorl %r13d, %r13d
xorl %ebp, %ebp
cmpq %r12, 0x8(%rax)
jbe 0x1da77e
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1da77e
movq (%rax), %rdi
movq %rdx, %rsi
imulq %r12, %rsi
callq 0x2fcc2c
movq %rax, %r15
movq 0x60(%rbx), %rax
testq %rax, %rax
je 0x1da783
cmpq %r14, 0x8(%rax)
jbe 0x1da783
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1da783
movq (%rax), %rdi
movq %rdx, %rsi
imulq %r14, %rsi
callq 0x2fcc2c
subq %rax, %r15
cmpq %r15, %rbp
jae 0x1da737
movq 0x60(%rbx), %rax
testq %rax, %rax
je 0x1da788
cmpq %r14, 0x8(%rax)
jbe 0x1da788
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1da788
movq 0x88(%rbx), %r15
movq (%rax), %rdi
movq %rdx, %rsi
imulq %r14, %rsi
callq 0x2fcc2c
testq %r15, %r15
je 0x1da78d
addq %rbp, %rax
cmpq %rax, 0x8(%r15)
jbe 0x1da78d
movl 0x10(%r15), %edx
cmpq $0x41, %rdx
jae 0x1da78d
movq (%r15), %rdi
imulq %rdx, %rax
movq %rax, %rsi
callq 0x2fcc2c
movq %rax, %r15
movq 0x90(%rbx), %rdi
callq 0x2f9d41
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %eax, %ecx
shll %cl, %edx
notl %edx
addl %edx, %edx
movslq %edx, %rax
andq %r15, %rax
shrq %rax
xorl %ecx, %ecx
cmpq 0x90(%rbx), %rax
setne %cl
addq %rcx, %r13
incq %rbp
movq 0x60(%rbx), %rax
testq %rax, %rax
jne 0x1da61c
jmp 0x1da77e
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x1da792
cmpq %r14, 0x8(%rax)
jbe 0x1da792
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1da792
movq (%rax), %rdi
imulq %rdx, %r14
movq %r14, %rsi
callq 0x2fcc2c
movq %r12, %r14
cmpq %rax, %r13
je 0x1da5f9
callq 0x6f3bb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x6f4d8
callq 0x6f49f
callq 0x6f466
callq 0x6f42d
callq 0x6f3f4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_find_only_edge
static inline GtStrgraphVEdgenum gt_strgraph_find_only_edge(
    GtStrgraph *strgraph, GtStrgraphVnum from)
{
  GtStrgraphVEdgenum j;
  gt_assert(GT_STRGRAPH_V_OUTDEG(strgraph, from) == (GtStrgraphVEdgenum)1);
  for (j = 0; j < GT_STRGRAPH_V_NOFEDGES(strgraph, from); j++)
  {
    if (!GT_STRGRAPH_EDGE_IS_REDUCED(strgraph, from, j))
      return j;
  }
  gt_assert(false); /* outdeg error */
  return 0; /* to avoid warnings */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x70(%rdi), %rax
testq %rax, %rax
je 0x1dd13a
movq %rsi, %rbx
cmpq %rsi, 0x8(%rax)
jbe 0x1dd13a
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1dd13a
movq %rdi, %r14
movq (%rax), %rdi
movq %rdx, %rsi
imulq %rbx, %rsi
callq 0x2fcc2c
cmpq $0x1, %rax
jne 0x1dd13f
movq 0x60(%r14), %rax
testq %rax, %rax
je 0x1dd114
leaq 0x1(%rbx), %r13
xorl %r15d, %r15d
cmpq %r13, 0x8(%rax)
jbe 0x1dd114
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1dd114
movq (%rax), %rdi
movq %rdx, %rsi
imulq %r13, %rsi
callq 0x2fcc2c
movq %rax, %r12
movq 0x60(%r14), %rax
testq %rax, %rax
je 0x1dd126
cmpq %rbx, 0x8(%rax)
jbe 0x1dd126
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1dd126
movq (%rax), %rdi
movq %rdx, %rsi
imulq %rbx, %rsi
callq 0x2fcc2c
subq %rax, %r12
cmpq %r12, %r15
jae 0x1dd135
movq 0x60(%r14), %rax
testq %rax, %rax
je 0x1dd12b
cmpq %rbx, 0x8(%rax)
jbe 0x1dd12b
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1dd12b
movq 0x88(%r14), %r12
movq (%rax), %rdi
movq %rdx, %rsi
imulq %rbx, %rsi
callq 0x2fcc2c
testq %r12, %r12
je 0x1dd130
addq %r15, %rax
cmpq %rax, 0x8(%r12)
jbe 0x1dd130
movl 0x10(%r12), %edx
cmpq $0x41, %rdx
jae 0x1dd130
movq (%r12), %rdi
imulq %rdx, %rax
movq %rax, %rsi
callq 0x2fcc2c
movq %rax, %r12
movq 0x90(%r14), %rdi
callq 0x2f9d41
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %eax, %ecx
shll %cl, %edx
notl %edx
addl %edx, %edx
movslq %edx, %rax
andq %r12, %rax
shrq %rax
cmpq 0x90(%r14), %rax
jne 0x1dd119
incq %r15
movq 0x60(%r14), %rax
testq %rax, %rax
jne 0x1dd00a
callq 0x71191
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x71158
callq 0x7111f
callq 0x710e6
callq 0x710ad
callq 0x711ca
callq 0x71074
// File: /workspace/github_c_makefile_star2_O1/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 0x1dde93
retq
movq 0x18(%rdi), %rcx
xorl %eax, %eax
cmpq 0x18(%rsi), %rcx
seta %al
sbbl $0x0, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1e0516
movq %rdi, %r12
callq 0xe99dc
movq %rax, %rbx
cmpq $0x0, 0x80(%r12)
je 0x1e04a8
xorl %ebp, %ebp
movq 0x60(%r12), %rax
testq %rax, %rax
je 0x1e0502
leaq 0x1(%rbp), %r14
xorl %r15d, %r15d
cmpq %r14, 0x8(%rax)
jbe 0x1e0502
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1e0502
movq (%rax), %rdi
movq %rdx, %rsi
imulq %r14, %rsi
callq 0x2fcc2c
movq %rax, %r13
movq 0x60(%r12), %rax
testq %rax, %rax
je 0x1e0507
cmpq %rbp, 0x8(%rax)
jbe 0x1e0507
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1e0507
movq (%rax), %rdi
movq %rdx, %rsi
imulq %rbp, %rsi
callq 0x2fcc2c
subq %rax, %r13
cmpq %r13, %r15
jae 0x1e0497
movq 0x60(%r12), %rax
testq %rax, %rax
je 0x1e0511
cmpq %rbp, 0x8(%rax)
jbe 0x1e0511
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1e0511
movq 0x88(%r12), %r13
movq (%rax), %rdi
movq %rdx, %rsi
imulq %rbp, %rsi
callq 0x2fcc2c
testq %r13, %r13
je 0x1e050c
addq %r15, %rax
cmpq %rax, 0x8(%r13)
jbe 0x1e050c
movl 0x10(%r13), %edx
cmpq $0x41, %rdx
jae 0x1e050c
movq (%r13), %rdi
imulq %rdx, %rax
movq %rax, %rsi
callq 0x2fcc2c
movq %rax, %r13
movq 0x90(%r12), %rdi
callq 0x2f9d41
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %eax, %ecx
shll %cl, %edx
notl %edx
addl %edx, %edx
movslq %edx, %rsi
andq %r13, %rsi
shrq %rsi
movq %rbx, %rdi
callq 0xe99f7
incq %r15
movq 0x60(%r12), %rax
testq %rax, %rax
jne 0x1e037d
jmp 0x1e0502
movq %r14, %rbp
cmpq 0x80(%r12), %r14
jb 0x1e0368
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x1d8925
movq %rax, %r14
leaq 0x1d8da4(%rip), %rsi    # 0x3b926c
movq %rax, %rdi
xorl %eax, %eax
callq 0x103d21
leaq 0x42(%rip), %rsi        # 0x1e051b
movq %rbx, %rdi
movq %r14, %rdx
callq 0xe9bdf
movq %rbx, %rdi
callq 0xe9ff6
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040fc
callq 0x72be4
callq 0x72bab
callq 0x72b39
callq 0x72b72
callq 0x72c1d
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0xe99dc
testq %r12, %r12
je 0x1e0624
cmpq $0x0, 0x40(%r12)
je 0x1e0624
cmpq $0x0, 0x48(%r12)
je 0x1e0624
movq %rax, %rbx
cmpq $0x0, 0x80(%r12)
je 0x1e05c8
xorl %ebp, %ebp
movq %rsp, %r13
movq 0x40(%r12), %rax
movzbl (%rax,%rbp), %esi
cmpq $0xff, %rsi
jne 0x1e05b3
movq 0x48(%r12), %rdi
movq %rbp, (%rsp)
movq %r13, %rsi
callq 0x10620e
testq %rax, %rax
je 0x1e061f
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0xe99f7
incq %rbp
cmpq 0x80(%r12), %rbp
jb 0x1e0587
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x1d8925
movq %rax, %r14
leaq 0x1d8cc0(%rip), %rsi    # 0x3b92a4
movq %rax, %rdi
xorl %eax, %eax
callq 0x103d21
leaq -0xda(%rip), %rsi       # 0x1e051b
movq %rbx, %rdi
movq %r14, %rdx
callq 0xe9bdf
movq %rbx, %rdi
callq 0xe9ff6
movq %r14, %rdi
callq 0x1040fc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x72c56
callq 0x72c8f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_show_context
int gt_strgraph_show_context(GtStrgraph *strgraph, GtStrgraphFormat format,
    const char *indexname, const char *suffix, GtUword *readnums,
    GtUword nofreadnums, GtUword *otherreadnums,
    GtUword nofotherreadnums, GtUword maxdepth, bool extend,
    GtError *err)
{
  int had_err = 0;
  GtFile *outfp = NULL;
  GtStrgraphVnum i;

  gt_assert(strgraph != NULL);
  gt_assert(format == GT_STRGRAPH_DOT || format == GT_STRGRAPH_DOT_BI);

  outfp = gt_strgraph_get_file(indexname, suffix, true, false);
  gt_file_xprintf(outfp, format == GT_STRGRAPH_DOT ?
      GT_STRGRAPH_DOT_HEADER : GT_STRGRAPH_DOT_BC_HEADER);
  gt_assert(sizeof (GtStrgraphVnum) >= sizeof (GtUword));

  for (i = 0; i < GT_STRGRAPH_NOFVERTICES(strgraph); i++)
    GT_STRGRAPH_V_SET_MARK(strgraph, i, GT_STRGRAPH_V_VACANT);

  had_err = gt_strgraph_dot_show_context(strgraph, format, outfp, readnums,
      nofreadnums, maxdepth, extend, 1UL, err);
  if (!had_err && nofotherreadnums > 0)
    had_err = gt_strgraph_dot_show_context(strgraph, format, outfp,
        otherreadnums, nofotherreadnums, maxdepth, extend, 2UL, err);
  gt_file_xprintf(outfp, GT_STRGRAPH_DOT_FOOTER);
  gt_file_delete(outfp);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1e0779
movl %esi, %ebp
cmpl $0x2, %esi
jae 0x1e077e
movq %rdi, %r14
movq %r8, %r12
movq %r9, (%rsp)
movq %rdx, %rdi
movq %rcx, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x1d8925
movq %rax, %rbx
testl %ebp, %ebp
leaq 0x1d8c9c(%rip), %rax    # 0x3b930c
leaq 0x1d8cac(%rip), %rsi    # 0x3b9323
cmoveq %rax, %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x103d21
cmpq $0x0, 0x80(%r14)
je 0x1e06d3
xorl %r15d, %r15d
movq 0x58(%r14), %rax
testq %rax, %rax
je 0x1e0774
cmpq %r15, 0x8(%rax)
jbe 0x1e0774
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1e0774
movq (%rax), %rdi
movq %rdx, %rsi
imulq %r15, %rsi
xorl %ecx, %ecx
callq 0x2fcd13
incq %r15
cmpq 0x80(%r14), %r15
jb 0x1e0692
movb 0x58(%rsp), %al
movq 0x50(%rsp), %r9
movq 0x48(%rsp), %r15
subq $0x8, %rsp
movzbl %al, %r13d
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movq %r12, %rcx
movq 0x8(%rsp), %r8
pushq 0x68(%rsp)
pushq $0x1
pushq %r13
callq 0x1e0783
addq $0x20, %rsp
movl %eax, %r12d
testl %eax, %eax
setne %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0x1e0749
movq 0x40(%rsp), %rcx
subq $0x8, %rsp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movq %r15, %r8
movq 0x58(%rsp), %r9
pushq 0x68(%rsp)
pushq $0x2
pushq %r13
callq 0x1e0783
addq $0x20, %rsp
movl %eax, %r12d
leaq 0x1dad81(%rip), %rsi    # 0x3bb4d1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x103d21
movq %rbx, %rdi
callq 0x1040fc
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x72d01
callq 0x72d3a
callq 0x72cc8
// File: /workspace/github_c_makefile_star2_O1/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 0x1e1114
movq %rdi, %r15
movq 0x90(%rdi), %rdi
callq 0x2f9d41
movl %eax, %ebx
movq 0x80(%r15), %rdi
callq 0x2f9d41
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 0x2f9d41
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 0x2f9d41
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 0x1d8279(%rip), %rdi    # 0x3b935f
callq 0x1e1119
leaq 0x1d8279(%rip), %rdi    # 0x3b936b
movq %rbx, %rsi
callq 0x1e1119
leaq 0x1d8272(%rip), %rdi    # 0x3b9373
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1e1119
callq 0x731e7
// File: /workspace/github_c_makefile_star2_O1/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 0x1e1136
leaq 0x1d8b39(%rip), %rdi    # 0x3b9c68
xorl %eax, %eax
jmp 0x108e02
cmpq $0xfffff, %rdx          # imm = 0xFFFFF
ja 0x1e1153
cvtsi2ss %rdx, %xmm0
mulss 0x1d76b4(%rip), %xmm0   # 0x3b8800
movl $0x6b, %ecx
jmp 0x1e119b
testq %rdx, %rdx
js 0x1e115f
cvtsi2ss %rdx, %xmm0
jmp 0x1e1176
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 0x1e118e
mulss 0x1d7675(%rip), %xmm0   # 0x3b87fc
movl $0x4d, %ecx
jmp 0x1e119b
mulss 0x1d7662(%rip), %xmm0   # 0x3b87f8
movl $0x47, %ecx
cvtss2sd %xmm0, %xmm0
leaq 0x1d8ad1(%rip), %rdi    # 0x3b9c77
movb $0x1, %al
jmp 0x108e02
// File: /workspace/github_c_makefile_star2_O1/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 0x1e125c
movq %rdi, %rbx
cmpq $0x0, 0x80(%rdi)
je 0x1e1246
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x1e1252
cmpq %r15, 0x8(%rax)
jbe 0x1e1252
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1e1252
movq (%rax), %rdi
movq %rdx, %rsi
imulq %r15, %rsi
callq 0x2fcc2c
testq %rax, %rax
jne 0x1e1235
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x1e1257
movl %r15d, %esi
andl $0x1, %esi
negq %rsi
orq $0x1, %rsi
addq %r15, %rsi
cmpq %rsi, 0x8(%rax)
jbe 0x1e1257
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1e1257
movq (%rax), %rdi
imulq %rdx, %rsi
callq 0x2fcc2c
testq %rax, %rax
je 0x1e1238
incq %r14
incq %r15
cmpq 0x80(%rbx), %r15
jb 0x1e11d0
jmp 0x1e1249
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x73259
callq 0x73220
callq 0x73292
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_nofreads
GtUword gt_strgraph_nofreads(const GtStrgraph *strgraph)
{
  GtStrgraphVnum i;
  GtUword connected_reads = 0;
  bool already_counted = false;

  gt_assert(strgraph != NULL);
  for (i = 0; i < GT_STRGRAPH_NOFVERTICES(strgraph); i++)
  {
    if (GT_STRGRAPH_V_IS_B(i))
      already_counted = false;
      /* if IS_E, then the read may already have been counted,
         in the case B was connected*/
    if (GT_STRGRAPH_V_OUTDEG(strgraph, i) > 0)
    {
      if (already_counted == false)
      {
        connected_reads++;
        already_counted = true;
      }
    }
  }
  return connected_reads;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x1e12fe
movq %rdi, %rbx
xorl %r15d, %r15d
cmpq $0x0, 0x80(%rdi)
je 0x1e12ea
xorl %eax, %eax
xorl %r14d, %r14d
xorl %r12d, %r12d
testb $0x1, %r12b
movzbl %al, %ebp
cmovel %r15d, %ebp
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x1e12f9
cmpq %r12, 0x8(%rax)
jbe 0x1e12f9
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1e12f9
movq (%rax), %rdi
movq %rdx, %rsi
imulq %r12, %rsi
callq 0x2fcc2c
testq %rax, %rax
setne %dl
testb $0x1, %bpl
sete %cl
movl $0x1, %eax
andb %dl, %cl
jne 0x1e12d6
movzbl %bpl, %eax
movzbl %cl, %ecx
addq %rcx, %r14
incq %r12
cmpq 0x80(%rbx), %r12
jb 0x1e128a
jmp 0x1e12ed
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x732cb
callq 0x73304
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_nofedges
static inline GtStrgraphEdgenum gt_strgraph_nofedges_Edgenum(
    const GtStrgraph *strgraph)
{
  GtStrgraphVnum i;
  GtStrgraphEdgenum total_degree = 0;
  gt_assert(strgraph != NULL);
  for (i = 0; i < GT_STRGRAPH_NOFVERTICES(strgraph); i++)
    total_degree += GT_STRGRAPH_V_OUTDEG(strgraph, i);
  return total_degree;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1e1369
movq %rdi, %rbx
cmpq $0x0, 0x80(%rdi)
je 0x1e1358
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x1e1364
cmpq %r15, 0x8(%rax)
jbe 0x1e1364
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1e1364
movq (%rax), %rdi
movq %rdx, %rsi
imulq %r15, %rsi
callq 0x2fcc2c
addq %rax, %r14
incq %r15
cmpq 0x80(%rbx), %r15
jb 0x1e1320
jmp 0x1e135b
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x7333d
callq 0x73376
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_nofspm
GtUword gt_strgraph_nofspm(const GtStrgraph *strgraph)
{
  GtUword total_degree;
  gt_assert(strgraph != NULL);
  /* nofspm is half of total degree */
  total_degree = gt_strgraph_nofedges(strgraph);
  /*  gt_assert(!(total_degree & 1)); */
  return ((total_degree >> 1));
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1e137e
callq 0x1e1303
shrq %rax
popq %rcx
retq
callq 0x733af
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_log_stats
void gt_strgraph_log_stats(const GtStrgraph *strgraph, GtLogger *logger)
{
  GtStrgraphVnum v = 0;
  GtStrgraphEdgenum e = 0;
  float avg_deg;

  gt_assert(strgraph != NULL);

  v = gt_strgraph_nofvertices_Vnum(strgraph);
  e = gt_strgraph_nofedges_Edgenum(strgraph);

  avg_deg = (v == 0UL) ? (float)0 : (float)(e) / (float)(v);

  gt_logger_log(logger, "vertices: "FormatGtStrgraphVnum
      " (reads: "FormatGtStrgraphVnum") -- edges: "FormatGtStrgraphEdgenum" "
      "(spm: "FormatGtStrgraphEdgenum") -- e/v: %.4f", v, v >> 1, e, e >> 1,
      avg_deg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x1e147a
movq %rsi, %rbx
movq %rdi, %r12
callq 0x1e11af
movq %rax, %r14
cmpq $0x0, 0x80(%r12)
je 0x1e13fa
xorl %r15d, %r15d
xorl %r13d, %r13d
movq 0x70(%r12), %rax
testq %rax, %rax
je 0x1e1475
cmpq %r13, 0x8(%rax)
jbe 0x1e1475
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1e1475
movq (%rax), %rdi
movq %rdx, %rsi
imulq %r13, %rsi
callq 0x2fcc2c
addq %rax, %r15
incq %r13
cmpq 0x80(%r12), %r13
jb 0x1e13b4
jmp 0x1e13fd
xorl %r15d, %r15d
movq %r15, %r9
shrq %r9
testq %r15, %r15
js 0x1e140f
cvtsi2ss %r15, %xmm1
jmp 0x1e1421
movl %r15d, %eax
andl $0x1, %eax
orq %r9, %rax
cvtsi2ss %rax, %xmm1
addss %xmm1, %xmm1
movl %r14d, %eax
andl $0x1, %eax
movq %r14, %rcx
shrq %rcx
orq %rcx, %rax
testq %r14, %r14
js 0x1e143c
cvtsi2ss %r14, %xmm2
jmp 0x1e1445
cvtsi2ss %rax, %xmm2
addss %xmm2, %xmm2
xorps %xmm0, %xmm0
je 0x1e1455
divss %xmm2, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x1d7f60(%rip), %rsi    # 0x3b93bc
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %r8
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10906e
callq 0x733e8
callq 0x73421
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_spell_vertex
static void gt_strgraph_spell_vertex(GtStrgraphVnum firstvertex, void *data)
{
  GtStrgraphSpellData *sdata = data;

  if ((sdata->current_depth >= sdata->min_depth) &&
      (sdata->current_length >= sdata->min_length))
  {
    sdata->total_depth += sdata->current_depth;
    gt_contigs_writer_write(sdata->cw);
    (sdata->contignum)++;
  }
  else
    gt_contigs_writer_abort(sdata->cw);

  gt_contigs_writer_start(sdata->cw,
      GT_STRGRAPH_V_MIRROR_SEQNUM(GT_STRGRAPH_NOFVERTICES(sdata->strgraph),
        firstvertex));
  sdata->current_length = (GtUword)GT_STRGRAPH_SEQLEN(sdata->strgraph,
      firstvertex);
  sdata->current_depth = 1UL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
cmpq 0x10(%rsi), %rax
jb 0x1e3790
movq 0x18(%rbx), %rcx
cmpq 0x20(%rbx), %rcx
jae 0x1e379b
movq 0x38(%rbx), %rdi
callq 0x1d13ee
jmp 0x1e37ab
addq %rax, (%rbx)
movq 0x38(%rbx), %rdi
callq 0x1d1426
incq 0x28(%rbx)
movq 0x38(%rbx), %rdi
testb $0x1, %r14b
jne 0x1e37cb
movq 0x30(%rbx), %rax
movq %r14, %rsi
shrq %rsi
notq %rsi
addq 0x80(%rax), %rsi
jmp 0x1e37d1
movq %r14, %rsi
shrq %rsi
callq 0x1d18b4
movq 0x30(%rbx), %rcx
movq 0x8(%rcx), %rax
testq %rax, %rax
jne 0x1e37ee
movq (%rcx), %rdi
movq %r14, %rsi
callq 0xeffd3
movq %rax, 0x18(%rbx)
movq $0x1, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_show_contigpath_vertex
static void gt_strgraph_show_contigpath_vertex(GtStrgraphVnum firstvertex,
    void *data)
{
  GtStrgraphContigpathsData *pdata = data;

  if (pdata->current_depth >= pdata->min_depth)
    gt_strgraph_end_contigpath(pdata);

  gt_strgraph_begin_contigpath(pdata, firstvertex);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
cmpq 0x18(%rsi), %rax
jb 0x1e3fe9
movq %r14, %rdi
callq 0x1e41b8
movq $0x1, 0x8(%r14)
movq %rbx, 0x30(%r14)
movq $0x0, 0x70(%r14)
cmpq $0x0, 0x68(%r14)
jne 0x1e402a
movq $0x4000, 0x68(%r14)     # imm = 0x4000
movq 0x60(%r14), %rdi
leaq 0x1d4916(%rip), %rdx    # 0x3b892d
movl $0x10000, %esi          # imm = 0x10000
movl $0xa27, %ecx            # imm = 0xA27
callq 0x1094e6
movq %rax, 0x60(%r14)
movq 0x60(%r14), %rdi
testq %rdi, %rdi
je 0x1e40b8
movq 0x70(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x70(%r14)
movl $0x0, (%rdi,%rax,4)
movq 0x68(%r14), %rax
cmpq %rax, %rcx
jb 0x1e407b
leaq 0x4000(%rax), %rcx
movq %rcx, 0x68(%r14)
leaq 0x10000(,%rax,4), %rsi
leaq 0x1d48c0(%rip), %rdx    # 0x3b892d
movl $0xa2c, %ecx            # imm = 0xA2C
callq 0x1094e6
movq %rax, 0x60(%r14)
movq 0x60(%r14), %rax
testq %rax, %rax
je 0x1e40bd
movq 0x70(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x70(%r14)
testb $0x1, %bl
jne 0x1e40a1
shrq %rbx
notq %rbx
addq 0x28(%r14), %rbx
jmp 0x1e40a4
shrq %rbx
movq %rbx, %rdx
shrq $0x20, %rdx
jne 0x1e40c2
movl %ebx, (%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x74738
callq 0x746ff
callq 0x746c6
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_show_contigpath_edge
static void gt_strgraph_show_contigpath_edge(GtStrgraphVnum v,
    GtStrgraphLength len, void *data)
{
  GtStrgraphContigpathsData *pdata = data;
  GtContigpathElem *value;
  GtUword seqnum;

  (pdata->current_depth)++;

  /* first element: length */
  GT_GETNEXTFREEINARRAY(value, &pdata->contig, GtContigpathElem,
      GT_STRGRAPH_CONTIG_INC);
  gt_assert(sizeof (GtContigpathElem) >= sizeof (GtStrgraphLength) ||
      len <= (GtStrgraphLength)GT_CONTIGPATH_ELEM_MAX);
  *value = (GtContigpathElem)len;

  /* second element: vertex number */
  GT_GETNEXTFREEINARRAY(value, &pdata->contig, GtContigpathElem,
      GT_STRGRAPH_CONTIG_INC);
  seqnum = GT_STRGRAPH_V_MIRROR_SEQNUM(pdata->nof_v, v);
  gt_assert(sizeof (GtContigpathElem) >= sizeof (GtStrgraphVnum) ||
      seqnum <= (GtUword)GT_CONTIGPATH_ELEM_MAX);
  *value = (GtContigpathElem)seqnum;

  pdata->lastnode = v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
incq 0x8(%rdx)
movq %rdi, %r14
movq 0x68(%rdx), %rax
cmpq %rax, 0x70(%rdx)
jb 0x1e410f
leaq 0x4000(%rax), %rcx
movq %rcx, 0x68(%rbx)
movq 0x60(%rbx), %rdi
leaq 0x10000(,%rax,4), %rsi
leaq 0x1d482c(%rip), %rdx    # 0x3b892d
movl $0x9dd, %ecx            # imm = 0x9DD
callq 0x1094e6
movq %rax, 0x60(%rbx)
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x1e41a4
movq 0x70(%rbx), %rcx
leaq 0x1(%rcx), %rax
movq %rax, 0x70(%rbx)
movq %r15, %rdx
shrq $0x20, %rdx
jne 0x1e41a9
movl %r15d, (%rdi,%rcx,4)
movq 0x68(%rbx), %rcx
cmpq %rcx, %rax
jb 0x1e4166
leaq 0x4000(%rcx), %rax
movq %rax, 0x68(%rbx)
leaq 0x10000(,%rcx,4), %rsi
leaq 0x1d47d5(%rip), %rdx    # 0x3b892d
movl $0x9e4, %ecx            # imm = 0x9E4
callq 0x1094e6
movq %rax, 0x60(%rbx)
movq 0x60(%rbx), %rax
testq %rax, %rax
je 0x1e41ae
movq 0x70(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x70(%rbx)
movq %r14, %rdx
shrq %rdx
testb $0x1, %r14b
jne 0x1e418e
notq %rdx
addq 0x28(%rbx), %rdx
movq %rdx, %rsi
shrq $0x20, %rsi
jne 0x1e41b3
movl %edx, (%rax,%rcx,4)
movq %r14, 0x38(%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x7481c
callq 0x74771
callq 0x747e3
callq 0x747aa
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/rdj-twobitenc-editor.c
// Function: gt_twobitenc_editor_new
GtTwobitencEditor *gt_twobitenc_editor_new(const GtEncseq *encseq,
    const char* indexname, GtError *err)
{
  GtTwobitencEditor *twobitenc_editor;
  size_t t_offset;
  size_t c_offset;
  GtStr *encseqfilename;
  int had_err = 0;

  twobitenc_editor = gt_malloc(sizeof (GtTwobitencEditor));
  had_err = gt_twobitenc_editor_check(encseq, err);
  if (had_err == 0)
  {
    t_offset = gt_encseq_sequence_mapoffset(encseq);
    c_offset = gt_encseq_chardistri_mapoffset(encseq);
    encseqfilename = gt_str_new_cstr(indexname);
    gt_str_append_cstr(encseqfilename, GT_ENCSEQFILESUFFIX);
    twobitenc_editor->mapptr = (unsigned char*)gt_fa_mmap_write(gt_str_get(
          encseqfilename), NULL, err);
    twobitenc_editor->twobitencoding = (GtTwobitencoding*)
      (twobitenc_editor->mapptr + t_offset);
    twobitenc_editor->charcount = (GtUword*)
      (twobitenc_editor->mapptr + c_offset);
    gt_str_delete(encseqfilename);
  }
  return (had_err == 0) ? twobitenc_editor : NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
leaq 0x1d700d(%rip), %rsi    # 0x3bb642
movl $0x18, %edi
movl $0x38, %edx
callq 0x1092b2
movq %rax, %rbx
movq %r13, %rdi
callq 0xed91a
testb %al, %al
je 0x1e46cc
movq %r13, %rdi
callq 0xfac0f
cmpl $0x2, %eax
jne 0x1e46d5
movq %r13, %rdi
callq 0xf1c84
movq %rax, %r12
movq %r13, %rdi
callq 0xf1ccc
movq %rax, %r13
movq %r15, %rdi
callq 0x120955
movq %rax, %r15
leaq 0x16b393(%rip), %rsi    # 0x34fa1b
movq %rax, %rdi
callq 0x12097f
movq %r15, %rdi
callq 0x120d23
leaq 0x1d6fa3(%rip), %rdx    # 0x3bb642
movq %rax, %rdi
xorl %esi, %esi
movl $0x41, %ecx
movq %r14, %r8
callq 0x10288f
movq %rax, 0x10(%rbx)
addq %rax, %r12
movq %r12, (%rbx)
addq %rax, %r13
movq %r13, 0x8(%rbx)
movq %r15, %rdi
callq 0x121b03
jmp 0x1e46e8
leaq 0x1d6fd5(%rip), %rsi    # 0x3bb6a8
jmp 0x1e46dc
leaq 0x1d7014(%rip), %rsi    # 0x3bb6f0
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1019cf
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/rdj-twobitenc-editor.c
// Function: gt_twobitenc_editor_edit
void gt_twobitenc_editor_edit(GtTwobitencEditor *twobitenc_editor,
    GtUword pos, GtUchar newchar)
{
  size_t codenum, posincode;
  GtTwobitencoding oldcode, newcode;
  GtUchar oldchar;

  gt_assert(twobitenc_editor);
  codenum = (size_t)pos / GT_UNITSIN2BITENC;
  oldcode = twobitenc_editor->twobitencoding[codenum];
  posincode = (GT_UNITSIN2BITENC - 1 -
      ((size_t)pos % GT_UNITSIN2BITENC)) << 1;
  oldchar = (GtUchar) (oldcode & ((GtTwobitencoding)3 << posincode))
               >> posincode;
  newcode = (oldcode & (~((GtTwobitencoding)3 << posincode)));
  newcode |= ((GtTwobitencoding)newchar << posincode);
  twobitenc_editor->twobitencoding[codenum] = newcode;

  /* fix counts */
  twobitenc_editor->charcount[oldchar]--;
  twobitenc_editor->charcount[newchar]++;
}

// Assembly:
testq %rdi, %rdi
je 0x1e4745
movq %rsi, %rcx
movq (%rdi), %rax
shrq $0x5, %rsi
notl %ecx
addl %ecx, %ecx
movl $0x3, %r8d
shlq %cl, %r8
movq (%rax,%rsi,8), %r9
movl %r8d, %r10d
andl %r9d, %r10d
movzbl %r10b, %r10d
shrl %cl, %r10d
movzbl %dl, %edx
movq %rdx, %r11
shlq %cl, %r11
notq %r8
andq %r9, %r8
orq %r8, %r11
movq %r11, (%rax,%rsi,8)
movq 0x8(%rdi), %rax
decq (%rax,%r10,8)
incq (%rax,%rdx,8)
retq
pushq %rax
callq 0x74a8f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/rdj-version.c
// Function: gt_readjoiner_show_version
void gt_readjoiner_show_version(const char *progname)
{
  char *clean_progname = NULL;
  size_t pnsize = strlen(progname), rdjsize = strlen(" "GT_READJOINER_CMD);
  printf("Readjoiner: a string graph-based sequence assembler\n\n");
  printf("version "GT_READJOINER_VERSION"\n\n");

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
callq 0x172f0
movq %rax, %r14
leaq 0x1d6fe8(%rip), %rdi    # 0x3bb777
callq 0x17bd0
leaq 0x1d7011(%rip), %rdi    # 0x3bb7ac
callq 0x17bd0
leaq 0x1d6fac(%rip), %rsi    # 0x3bb753
movq %r14, %rdi
movl $0x1f, %edx
callq 0x1092b2
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x17770
cmpq $0xc, %r14
jb 0x1e47e6
addq %rbx, %r14
addq $-0xb, %r14
leaq 0x1d6f95(%rip), %rsi    # 0x3bb76b
movq %r14, %rdi
callq 0x17a40
testl %eax, %eax
jne 0x1e47e6
movb $0x0, (%r14)
leaq 0x1d6fcc(%rip), %rdi    # 0x3bb7b9
callq 0x17bd0
movq %rbx, %rdi
callq 0x1253c8
leaq 0x1d6f52(%rip), %rsi    # 0x3bb753
movq %rbx, %rdi
movl $0x28, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x109670
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_new
GtReads2Twobit* gt_reads2twobit_new(GtStr *indexname)
{
  GtReads2Twobit *r2t;
  gt_assert(indexname != NULL);
  r2t = gt_malloc(sizeof (*r2t));
  r2t->indexname = indexname;
  r2t->collection = gt_array_new(sizeof (GtReadsLibraryInfo));
  r2t->twobitencoding = NULL;
  r2t->seppos = NULL;
  r2t->invalid_sequences = 0;
  r2t->invalid_total_length = 0;
  r2t->seqlen_eqlen = 0;
  r2t->seqlen_max = 0;
  r2t->seqlen_min = 0;
  r2t->total_seqlength = 0;
  r2t->nofseqs = 0;
  r2t->phredbase = (char)33;
  r2t->maxlow = GT_UNDEF_UWORD;
  r2t->lowqual = 0;
  r2t->has_paired = false;
  r2t->use_rle = false;
  r2t->hplengths = NULL;
  r2t->approx_avhlen = 0.0;
  r2t->descs = NULL;
  r2t->descsfp = NULL;
  r2t->clipdes = true;
  r2t->longestdesc = 0;
  r2t->n_descs = 0;
  return r2t;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1e48b7
movq %rdi, %rbx
leaq 0x1d6fc9(%rip), %rsi    # 0x3bb7f4
movl $0xd0, %edi
movl $0x54, %edx
callq 0x1092b2
movq %rax, %r14
movq %rbx, (%rax)
movl $0x48, %edi
callq 0xd46fc
movq %rax, 0x8(%r14)
movq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x58(%r14)
movups %xmm0, 0x70(%r14)
movw $0x21, 0x80(%r14)
movq $-0x1, 0x88(%r14)
movw $0x0, 0x90(%r14)
movups %xmm0, 0x98(%r14)
movups %xmm0, 0xc0(%r14)
movb $0x1, 0xa8(%r14)
movups %xmm0, 0xb0(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x74afd