LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xe54e0
testq %r12, %r12
je 0x1d6edb
cmpq $0x0, 0x40(%r12)
je 0x1d6edb
cmpq $0x0, 0x48(%r12)
je 0x1d6edb
movq %rax, %rbx
cmpq $0x0, 0x80(%r12)
je 0x1d6e7f
xorl %ebp, %ebp
movq %rsp, %r13
movq 0x40(%r12), %rax
movzbl (%rax,%rbp), %esi
cmpq $0xff, %rsi
jne 0x1d6e6a
movq 0x48(%r12), %rdi
movq %rbp, (%rsp)
movq %r13, %rsi
callq 0x1012ee
testq %rax, %rax
je 0x1d6ed6
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0xe54fb
incq %rbp
cmpq 0x80(%r12), %rbp
jb 0x1d6e3e
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x1cf1bf
movq %rax, %r14
leaq 0x1d8e09(%rip), %rsi    # 0x3afca4
movq %rax, %rdi
xorl %eax, %eax
callq 0xfee51
leaq -0xda(%rip), %rsi       # 0x1d6dd2
movq %rbx, %rdi
movq %r14, %rdx
callq 0xe56e5
movq %rbx, %rdi
callq 0xe5a93
movq %r14, %rdi
callq 0xff22c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x7104f
callq 0x71088
// File: /workspace/github_c_makefile_star2_O3/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 0x1d7030
movl %esi, %ebp
cmpl $0x2, %esi
jae 0x1d7035
movq %rdi, %r14
movq %r8, %r12
movq %r9, (%rsp)
movq %rdx, %rdi
movq %rcx, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x1cf1bf
movq %rax, %rbx
testl %ebp, %ebp
leaq 0x1d8de5(%rip), %rax    # 0x3afd0c
leaq 0x1d8df5(%rip), %rsi    # 0x3afd23
cmoveq %rax, %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfee51
cmpq $0x0, 0x80(%r14)
je 0x1d6f8a
xorl %r15d, %r15d
movq 0x58(%r14), %rax
testq %rax, %rax
je 0x1d702b
cmpq %r15, 0x8(%rax)
jbe 0x1d702b
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1d702b
movq (%rax), %rdi
movq %rdx, %rsi
imulq %r15, %rsi
xorl %ecx, %ecx
callq 0x2f388c
incq %r15
cmpq 0x80(%r14), %r15
jb 0x1d6f49
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 0x1d703a
addq $0x20, %rsp
movl %eax, %r12d
testl %eax, %eax
setne %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0x1d7000
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 0x1d703a
addq $0x20, %rsp
movl %eax, %r12d
leaq 0x1daeca(%rip), %rsi    # 0x3b1ed1
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfee51
movq %rbx, %rdi
callq 0xff22c
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x710fa
callq 0x71133
callq 0x710c1
// File: /workspace/github_c_makefile_star2_O3/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 0x1d79aa
movq %rdi, %r15
movq 0x90(%rdi), %rdi
callq 0x2f09dd
movl %eax, %ebx
movq 0x80(%r15), %rdi
callq 0x2f09dd
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 0x2f09dd
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 0x2f09dd
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 0x1d83e3(%rip), %rdi    # 0x3afd5f
callq 0x1d79af
leaq 0x1d83e3(%rip), %rdi    # 0x3afd6b
movq %rbx, %rsi
callq 0x1d79af
leaq 0x1d83dc(%rip), %rdi    # 0x3afd73
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1d79af
callq 0x715e0
// File: /workspace/github_c_makefile_star2_O3/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 0x1d79cc
leaq 0x1d8ca3(%rip), %rdi    # 0x3b0668
xorl %eax, %eax
jmp 0x103d72
cmpq $0xfffff, %rdx          # imm = 0xFFFFF
ja 0x1d79e9
cvtsi2ss %rdx, %xmm0
mulss 0x1d781e(%rip), %xmm0   # 0x3af200
movl $0x6b, %ecx
jmp 0x1d7a31
testq %rdx, %rdx
js 0x1d79f5
cvtsi2ss %rdx, %xmm0
jmp 0x1d7a0c
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 0x1d7a24
mulss 0x1d77df(%rip), %xmm0   # 0x3af1fc
movl $0x4d, %ecx
jmp 0x1d7a31
mulss 0x1d77cc(%rip), %xmm0   # 0x3af1f8
movl $0x47, %ecx
cvtss2sd %xmm0, %xmm0
leaq 0x1d8c3b(%rip), %rdi    # 0x3b0677
movb $0x1, %al
jmp 0x103d72
// File: /workspace/github_c_makefile_star2_O3/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 0x1d7af2
movq %rdi, %rbx
cmpq $0x0, 0x80(%rdi)
je 0x1d7adc
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x1d7ae8
cmpq %r15, 0x8(%rax)
jbe 0x1d7ae8
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1d7ae8
movq (%rax), %rdi
movq %rdx, %rsi
imulq %r15, %rsi
callq 0x2f37dc
testq %rax, %rax
jne 0x1d7acb
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x1d7aed
movl %r15d, %esi
andl $0x1, %esi
negq %rsi
orq $0x1, %rsi
addq %r15, %rsi
cmpq %rsi, 0x8(%rax)
jbe 0x1d7aed
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1d7aed
movq (%rax), %rdi
imulq %rdx, %rsi
callq 0x2f37dc
testq %rax, %rax
je 0x1d7ace
incq %r14
incq %r15
cmpq 0x80(%rbx), %r15
jb 0x1d7a66
jmp 0x1d7adf
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x71652
callq 0x71619
callq 0x7168b
// File: /workspace/github_c_makefile_star2_O3/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 0x1d7b94
movq %rdi, %rbx
xorl %r15d, %r15d
cmpq $0x0, 0x80(%rdi)
je 0x1d7b80
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 0x1d7b8f
cmpq %r12, 0x8(%rax)
jbe 0x1d7b8f
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1d7b8f
movq (%rax), %rdi
movq %rdx, %rsi
imulq %r12, %rsi
callq 0x2f37dc
testq %rax, %rax
setne %dl
testb $0x1, %bpl
sete %cl
movl $0x1, %eax
andb %dl, %cl
jne 0x1d7b6c
movzbl %bpl, %eax
movzbl %cl, %ecx
addq %rcx, %r14
incq %r12
cmpq 0x80(%rbx), %r12
jb 0x1d7b20
jmp 0x1d7b83
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x716c4
callq 0x716fd
// File: /workspace/github_c_makefile_star2_O3/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 0x1d7bff
movq %rdi, %rbx
cmpq $0x0, 0x80(%rdi)
je 0x1d7bee
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x1d7bfa
cmpq %r15, 0x8(%rax)
jbe 0x1d7bfa
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1d7bfa
movq (%rax), %rdi
movq %rdx, %rsi
imulq %r15, %rsi
callq 0x2f37dc
addq %rax, %r14
incq %r15
cmpq 0x80(%rbx), %r15
jb 0x1d7bb6
jmp 0x1d7bf1
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x71736
callq 0x7176f
// File: /workspace/github_c_makefile_star2_O3/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 0x1d7c14
callq 0x1d7b99
shrq %rax
popq %rcx
retq
callq 0x717a8
// File: /workspace/github_c_makefile_star2_O3/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 0x1d7d10
movq %rsi, %rbx
movq %rdi, %r12
callq 0x1d7a45
movq %rax, %r14
cmpq $0x0, 0x80(%r12)
je 0x1d7c90
xorl %r15d, %r15d
xorl %r13d, %r13d
movq 0x70(%r12), %rax
testq %rax, %rax
je 0x1d7d0b
cmpq %r13, 0x8(%rax)
jbe 0x1d7d0b
movl 0x10(%rax), %edx
cmpq $0x41, %rdx
jae 0x1d7d0b
movq (%rax), %rdi
movq %rdx, %rsi
imulq %r13, %rsi
callq 0x2f37dc
addq %rax, %r15
incq %r13
cmpq 0x80(%r12), %r13
jb 0x1d7c4a
jmp 0x1d7c93
xorl %r15d, %r15d
movq %r15, %r9
shrq %r9
testq %r15, %r15
js 0x1d7ca5
cvtsi2ss %r15, %xmm1
jmp 0x1d7cb7
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 0x1d7cd2
cvtsi2ss %r14, %xmm2
jmp 0x1d7cdb
cvtsi2ss %rax, %xmm2
addss %xmm2, %xmm2
xorps %xmm0, %xmm0
je 0x1d7ceb
divss %xmm2, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x1d80ca(%rip), %rsi    # 0x3afdbc
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %r8
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x103fe1
callq 0x717e1
callq 0x7181a
// File: /workspace/github_c_makefile_star2_O3/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 0x1d9f62
movq 0x18(%rbx), %rcx
cmpq 0x20(%rbx), %rcx
jae 0x1d9f6d
movq 0x38(%rbx), %rdi
callq 0x1c8192
jmp 0x1d9f7d
addq %rax, (%rbx)
movq 0x38(%rbx), %rdi
callq 0x1c81ca
incq 0x28(%rbx)
movq 0x38(%rbx), %rdi
testb $0x1, %r14b
jne 0x1d9f9d
movq 0x30(%rbx), %rax
movq %r14, %rsi
shrq %rsi
notq %rsi
addq 0x80(%rax), %rsi
jmp 0x1d9fa3
movq %r14, %rsi
shrq %rsi
callq 0x1c865e
movq 0x30(%rbx), %rcx
movq 0x8(%rcx), %rax
testq %rax, %rax
jne 0x1d9fc0
movq (%rcx), %rdi
movq %r14, %rsi
callq 0xeb9d2
movq %rax, 0x18(%rbx)
movq $0x1, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1da7bb
movq %r14, %rdi
callq 0x1da98c
movq $0x1, 0x8(%r14)
movq %rbx, 0x30(%r14)
movq $0x0, 0x70(%r14)
cmpq $0x0, 0x68(%r14)
je 0x1da7dc
movq 0x60(%r14), %rax
jmp 0x1da802
movq $0x4000, 0x68(%r14)     # imm = 0x4000
movq 0x60(%r14), %rdi
leaq 0x1d4b3e(%rip), %rdx    # 0x3af32d
movl $0x10000, %esi          # imm = 0x10000
movl $0xa27, %ecx            # imm = 0xA27
callq 0x104461
movq %rax, 0x60(%r14)
testq %rax, %rax
je 0x1da88b
movq 0x70(%r14), %rdx
leaq 0x1(%rdx), %rcx
movq %rcx, 0x70(%r14)
movl $0x0, (%rax,%rdx,4)
movq 0x68(%r14), %rdx
cmpq %rdx, %rcx
jb 0x1da85b
leaq 0x4000(%rdx), %rcx
movq %rcx, 0x68(%r14)
leaq 0x10000(,%rdx,4), %rsi
leaq 0x1d4aec(%rip), %rdx    # 0x3af32d
movq %rax, %rdi
movl $0xa2c, %ecx            # imm = 0xA2C
callq 0x104461
movq %rax, 0x60(%r14)
testq %rax, %rax
je 0x1da895
movq 0x70(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x70(%r14)
testb $0x1, %bl
jne 0x1da874
shrq %rbx
notq %rbx
addq 0x28(%r14), %rbx
jmp 0x1da877
shrq %rbx
movq %rbx, %rdx
shrq $0x20, %rdx
jne 0x1da890
movl %ebx, (%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x72b56
callq 0x72b1d
callq 0x72ae4
// File: /workspace/github_c_makefile_star2_O3/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)
jae 0x1da8bc
movq 0x60(%rbx), %rax
jmp 0x1da8e8
leaq 0x4000(%rax), %rcx
movq %rcx, 0x68(%rbx)
movq 0x60(%rbx), %rdi
leaq 0x10000(,%rax,4), %rsi
leaq 0x1d4a53(%rip), %rdx    # 0x3af32d
movl $0x9dd, %ecx            # imm = 0x9DD
callq 0x104461
movq %rax, 0x60(%rbx)
testq %rax, %rax
je 0x1da978
movq 0x70(%rbx), %rdx
leaq 0x1(%rdx), %rcx
movq %rcx, 0x70(%rbx)
movq %r15, %rsi
shrq $0x20, %rsi
jne 0x1da97d
movl %r15d, (%rax,%rdx,4)
movq 0x68(%rbx), %rdx
cmpq %rdx, %rcx
jb 0x1da943
leaq 0x4000(%rdx), %rcx
movq %rcx, 0x68(%rbx)
leaq 0x10000(,%rdx,4), %rsi
leaq 0x1d4a00(%rip), %rdx    # 0x3af32d
movq %rax, %rdi
movl $0x9e4, %ecx            # imm = 0x9E4
callq 0x104461
movq %rax, 0x60(%rbx)
testq %rax, %rax
je 0x1da987
movq 0x70(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x70(%rbx)
movq %r14, %rdx
shrq %rdx
testb $0x1, %r14b
jne 0x1da962
notq %rdx
addq 0x28(%rbx), %rdx
movq %rdx, %rsi
shrq $0x20, %rsi
jne 0x1da982
movl %edx, (%rax,%rcx,4)
movq %r14, 0x38(%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x72c3a
callq 0x72b8f
callq 0x72c01
callq 0x72bc8
// File: /workspace/github_c_makefile_star2_O3/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 0x1d7235(%rip), %rsi    # 0x3b2042
movl $0x18, %edi
movl $0x38, %edx
callq 0x104226
movq %rax, %rbx
movq %r13, %rdi
callq 0xe935b
testb %al, %al
je 0x1daea4
movq %r13, %rdi
callq 0xf64f6
cmpl $0x2, %eax
jne 0x1daead
movq %r13, %rdi
callq 0xed640
movq %rax, %r12
movq %r13, %rdi
callq 0xed688
movq %rax, %r13
movq %r15, %rdi
callq 0x11acc9
movq %rax, %r15
leaq 0x16bbbb(%rip), %rsi    # 0x346a1b
movq %rax, %rdi
callq 0x11acf3
movq %r15, %rdi
callq 0x11b0a1
leaq 0x1d71cb(%rip), %rdx    # 0x3b2042
movq %rax, %rdi
xorl %esi, %esi
movl $0x41, %ecx
movq %r14, %r8
callq 0xfd9dd
movq %rax, 0x10(%rbx)
addq %rax, %r12
movq %r12, (%rbx)
addq %rax, %r13
movq %r13, 0x8(%rbx)
movq %r15, %rdi
callq 0x11bdbf
jmp 0x1daec0
leaq 0x1d71fd(%rip), %rsi    # 0x3b20a8
jmp 0x1daeb4
leaq 0x1d723c(%rip), %rsi    # 0x3b20f0
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0xfcb67
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1d7210(%rip), %rdi    # 0x3b2177
callq 0x17bd0
leaq 0x1d7239(%rip), %rdi    # 0x3b21ac
callq 0x17bd0
leaq 0x1d71d4(%rip), %rsi    # 0x3b2153
movq %r14, %rdi
movl $0x1f, %edx
callq 0x104226
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x17770
cmpq $0xc, %r14
jb 0x1dafbe
addq %rbx, %r14
addq $-0xb, %r14
leaq 0x1d71bd(%rip), %rsi    # 0x3b216b
movq %r14, %rdi
callq 0x17a40
testl %eax, %eax
jne 0x1dafbe
movb $0x0, (%r14)
leaq 0x1d71f4(%rip), %rdi    # 0x3b21b9
callq 0x17bd0
movq %rbx, %rdi
callq 0x11f60c
leaq 0x1d717a(%rip), %rsi    # 0x3b2153
movq %rbx, %rdi
movl $0x28, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x1045eb
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x1db08f
movq %rdi, %rbx
leaq 0x1d71f1(%rip), %rsi    # 0x3b21f4
movl $0xd0, %edi
movl $0x54, %edx
callq 0x104226
movq %rax, %r14
movq %rbx, (%rax)
movl $0x48, %edi
callq 0xd214c
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 0x72f1b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_delete
void gt_reads2twobit_delete(GtReads2Twobit *r2t)
{
  if (r2t != NULL)
  {
    GtUword lnum, noflibs;
    noflibs = gt_array_size(r2t->collection);
    for (lnum = 0; lnum < noflibs; lnum++)
    {
      GtReadsLibraryInfo *rli;
      rli = gt_array_get(r2t->collection, lnum);
      gt_str_delete(rli->filename1);
      if (rli->filename2 != NULL)
        gt_str_delete(rli->filename2);
    }
    gt_array_delete(r2t->collection);
    gt_desc_buffer_delete(r2t->descs);
    gt_fa_xfclose(r2t->descsfp);
    gt_hplstore_delete(r2t->hplengths);
    gt_free(r2t->twobitencoding);
    gt_free(r2t->seppos);
    gt_free(r2t);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1db16f
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xd24e0
testq %rax, %rax
je 0x1db0fe
movq %rax, %r14
xorl %r15d, %r15d
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0xd2207
movq %rax, %r12
movq 0x8(%rax), %rdi
callq 0x11bdbf
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x1db0f6
callq 0x11bdbf
incq %r15
cmpq %r15, %r14
jne 0x1db0cf
movq 0x8(%rbx), %rdi
callq 0xd2938
movq 0x98(%rbx), %rdi
callq 0xe4e83
movq 0xa0(%rbx), %rdi
callq 0xfd09a
movq 0xc0(%rbx), %rdi
callq 0x31f57f
movq 0x10(%rbx), %rdi
leaq 0x1d70be(%rip), %r14    # 0x3b21f4
movq %r14, %rsi
movl $0x87, %edx
callq 0x1045eb
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x88, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x89, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_add
void gt_reads2twobit_add(GtReads2Twobit *r2t, bool paired,
    const GtStr *filename1, const GtStr *filename2, GtUword insertlength,
    GtUword stdev)
{
  GtReadsLibraryInfo rli;
  gt_assert(r2t != NULL);
  gt_assert(filename1 != NULL);
  rli.paired = paired;
  rli.filename1 = gt_str_clone(filename1);
  if (filename2 != NULL)
    rli.filename2 = gt_str_clone(filename2);
  else
    rli.filename2 = NULL;
  rli.insertlength = insertlength;
  rli.stdev = stdev;
  rli.total_seqlength = 0;
  rli.first_seqnum = 0;
  rli.nofseqs = 0;
  rli.total_filelength = (GtUword)gt_file_size(gt_str_get(filename1));
  if (filename2 != NULL)
    rli.total_filelength += (GtUword)gt_file_size(gt_str_get(filename2));
  gt_array_add(r2t->collection, rli);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
testq %rdi, %rdi
je 0x1db249
movq %rdx, %r15
testq %rdx, %rdx
je 0x1db24e
movq %r9, %r12
movq %r8, %r13
movq %rcx, %r14
movq %rdi, %rbx
movb %sil, 0x8(%rsp)
movq %r15, %rdi
callq 0x11b191
movq %rax, 0x10(%rsp)
testq %r14, %r14
je 0x1db1d1
movq %r14, %rdi
callq 0x11b191
jmp 0x1db1d3
xorl %eax, %eax
movq %rax, 0x18(%rsp)
movq %r13, 0x20(%rsp)
movq %r12, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rsp)
movq $0x0, 0x48(%rsp)
movq %r15, %rdi
callq 0x11b0a1
movq %rax, %rdi
callq 0xff72f
movq %rax, 0x30(%rsp)
testq %r14, %r14
je 0x1db228
movq %rax, %r15
movq %r14, %rdi
callq 0x11b0a1
movq %rax, %rdi
callq 0xff72f
addq %rax, %r15
movq %r15, 0x30(%rsp)
movq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movl $0x48, %edx
callq 0xd2410
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x72ffb
callq 0x72fc2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_decode_sequence
static void gt_reads2twobit_seek_sequence(const GtReads2Twobit *r2t,
    GtUword seqnum, GtUword *seqlen, GtTwobitencoding *firstcode,
    GtUword *charsinfirstcode, GtTwobitencoding **nextcode_ptr)
{
  GtUword pos;
  *seqlen = r2t->seqlen_eqlen;
  if (*seqlen == 0)
  {
    if (seqnum == 0)
    {
      *seqlen = r2t->seppos[0] + 1UL;
      pos = 0;
    }
    else
    {
      *seqlen = r2t->seppos[seqnum] - r2t->seppos[seqnum - 1UL];
      pos = r2t->seppos[seqnum - 1UL] + 1UL;
    }
  }
  else
  {
    pos = seqnum * (*seqlen);
  }
  *nextcode_ptr = r2t->twobitencoding + GT_DIVBYUNITSIN2BITENC(pos);
  *charsinfirstcode = GT_UNITSIN2BITENC - GT_MODBYUNITSIN2BITENC(pos);
  *firstcode = *((*nextcode_ptr)++);
}

// Assembly:
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x1dce83
imulq %rax, %rsi
movq %rsi, %rcx
jmp 0x1dcea5
movq 0x38(%rdi), %rax
testq %rsi, %rsi
je 0x1dce9d
movq -0x8(%rax,%rsi,8), %rcx
movq (%rax,%rsi,8), %rax
subq %rcx, %rax
incq %rcx
jmp 0x1dcea5
movq (%rax), %rax
incq %rax
xorl %ecx, %ecx
movq 0x10(%rdi), %rdi
movq %rcx, %r8
shrq $0x5, %r8
movq (%rdi,%r8,8), %rsi
movw $0xa3e, (%rdx)          # imm = 0xA3E
addq $0x2, %rdx
decq %rax
je 0x1dcf0e
leaq (%rdi,%r8,8), %rdi
addq $0x8, %rdi
andl $0x1f, %ecx
movl $0x20, %r9d
subq %rcx, %r9
leaq 0x1813a3(%rip), %r8     # 0x35e280
testq %r9, %r9
jne 0x1dceef
movq (%rdi), %rsi
addq $0x8, %rdi
movl $0x20, %r9d
decq %r9
leal (%r9,%r9), %ecx
movq %rsi, %r10
shrq %cl, %r10
andl $0x3, %r10d
movb (%r10,%r8), %cl
movb %cl, (%rdx)
incq %rdx
decq %rax
jne 0x1dcedd
movw $0xa, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_write_fasta
int gt_reads2twobit_write_fasta(const GtReads2Twobit *r2t, char *path,
    GtBitsequence *skip, GtError *err)
{
  GtFile *file;
  file = gt_file_new(path, "w", err);
  if (file == NULL)
    return -1;
  gt_reads2twobit_decode_range(r2t, file, 0, r2t->nofseqs, skip);
  gt_file_delete(file);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r15
leaq 0x1b6410(%rip), %rsi    # 0x3935b5
movq %rax, %rdi
movq %rcx, %rdx
callq 0xfea8a
testq %rax, %rax
je 0x1dd1d9
movq %rax, %r12
movq 0x40(%r15), %rcx
xorl %r14d, %r14d
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %rbx, %r8
callq 0x1dcf14
movq %r12, %rdi
callq 0xff22c
jmp 0x1dd1df
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_mark_mates_of_contained
GtUword gt_reads2twobit_mark_mates_of_contained(GtReads2Twobit *r2t,
    GtBitsequence *list)
{
  GtUword libnum, noflibs = gt_array_size(r2t->collection), nofmarked = 0;
  for (libnum = 0; libnum < noflibs; libnum++)
  {
    GtReadsLibraryInfo *rli = gt_array_get(r2t->collection, libnum);
    if (rli->paired && rli->nofseqs > 0)
    {
      GtUword seqnum,
                    last_seqnum = rli->first_seqnum + rli->nofseqs - 1UL;
      gt_assert(rli->nofseqs % 2 == 0);
      for (seqnum = rli->first_seqnum; seqnum < last_seqnum; seqnum += 2UL)
      {
        if (GT_ISIBITSET(list, seqnum) && !GT_ISIBITSET(list, seqnum + 1))
        {
          GT_SETIBIT(list, seqnum + 1UL);
          nofmarked++;
        }
        else if (GT_ISIBITSET(list, seqnum + 1UL) &&
            !GT_ISIBITSET(list, seqnum))
        {
          GT_SETIBIT(list, seqnum);
          nofmarked++;
        }
      }
    }
  }
  return nofmarked;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0xd24e0
testq %rax, %rax
je 0x1dd4e6
movq %rax, %r15
movabsq $-0x8000000000000000, %rbp # imm = 0x8000000000000000
xorl %r13d, %r13d
xorl %r12d, %r12d
movq 0x8(%r14), %rdi
movq %r13, %rsi
callq 0xd2207
cmpb $0x1, (%rax)
jne 0x1dd4d8
movq 0x40(%rax), %rcx
testq %rcx, %rcx
je 0x1dd4d8
testb $0x1, %cl
jne 0x1dd4fb
movq 0x38(%rax), %rax
leaq (%rcx,%rax), %rdx
decq %rdx
cmpq %rdx, %rax
jae 0x1dd4d8
movq %rax, %rsi
shrq $0x6, %rsi
movq (%rbx,%rsi,8), %r8
movq %rbp, %r9
movl %eax, %ecx
shrq %cl, %r9
leaq 0x1(%rax), %rcx
movq %rcx, %rdi
shrq $0x6, %rdi
testq %r9, %r8
je 0x1dd4b7
movq (%rbx,%rdi,8), %rsi
movq %rbp, %r8
shrq %cl, %r8
testq %r8, %rsi
jne 0x1dd4d2
orq %r8, %rsi
movq %rsi, (%rbx,%rdi,8)
jmp 0x1dd4cf
movq %rbp, %r10
shrq %cl, %r10
testq %r9, %r8
jne 0x1dd4d2
andq (%rbx,%rdi,8), %r10
je 0x1dd4d2
orq %r9, %r8
movq %r8, (%rbx,%rsi,8)
incq %r12
addq $0x2, %rax
jmp 0x1dd477
incq %r13
cmpq %r15, %r13
jne 0x1dd449
jmp 0x1dd4e9
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x733fd
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_sort
void gt_reads2twobit_sort(GtReads2Twobit *r2t, GtCompareWithData cmp,
    void *cmp_data)
{
  GtTwobitencoding *tbe, *tbe_next, offset;
  GtUword i, *order;

  gt_assert(r2t != NULL);

  order = gt_malloc(sizeof (*order) * r2t->nofseqs);
  for (i = 0; i < r2t->nofseqs; i++)
    order[i] = i;

  gt_qsort_r(order, (size_t)r2t->nofseqs, sizeof *order, cmp_data, cmp);

  tbe = gt_malloc(sizeof (*tbe) *
      GT_DIVBYUNITSIN2BITENC(r2t->total_seqlength) + 2UL);

  offset = 0;
  tbe_next = tbe;
  for (i = 0; i < r2t->nofseqs; i++)
  {
    tbe_next = gt_reads2twobit_write_encoded(r2t, order[i], tbe_next, offset,
        &offset);
    if (r2t->seqlen_eqlen == 0)
    {
      /* recycle order memory to store new seppos */
      order[i] = (order[i] == 0)
        ? r2t->seppos[0]
        : r2t->seppos[order[i]] - (r2t->seppos[order[i] - 1UL] + 1UL);
      if (i > 0)
        order[i] += (order[i - 1UL] + 1UL);
    }
  }

  gt_free(r2t->twobitencoding);
  r2t->twobitencoding = tbe;

  if (r2t->seqlen_eqlen == 0)
  {
    gt_free(r2t->seppos);
    r2t->seppos = order;
  }
  else
  {
    gt_free(order);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x1ddffe
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
shlq $0x3, %rdi
leaq 0x1d4337(%rip), %rsi    # 0x3b21f4
movl $0x86e, %edx            # imm = 0x86E
callq 0x104226
movq %rax, %r14
cmpq $0x0, 0x40(%rbx)
je 0x1ddee5
xorl %eax, %eax
movq %rax, (%r14,%rax,8)
incq %rax
movq 0x40(%rbx), %rsi
cmpq %rsi, %rax
jb 0x1dded3
jmp 0x1ddee7
xorl %esi, %esi
movl $0x8, %edx
movq %r14, %rdi
movq %r12, %rcx
movq %r15, %r8
callq 0x10c638
movq 0x60(%rbx), %rax
shrq $0x5, %rax
leaq 0x2(,%rax,8), %rdi
leaq 0x1d42e3(%rip), %rsi    # 0x3b21f4
movl $0x875, %edx            # imm = 0x875
callq 0x104226
movq %rax, %r15
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x40(%rbx)
je 0x1ddf96
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movq %r15, %rax
movq (%r14,%r13,8), %rsi
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %rax, %rdx
movq %r12, %r8
callq 0x1dd1ee
cmpq $0x0, 0x48(%rbx)
jne 0x1ddf8d
movq (%r14,%r13,8), %rdx
movq 0x38(%rbx), %rsi
testq %rdx, %rdx
je 0x1ddf72
movq -0x8(%rsi,%rdx,8), %rcx
notq %rcx
addq (%rsi,%rdx,8), %rcx
jmp 0x1ddf75
movq (%rsi), %rcx
movq %rcx, (%r14,%r13,8)
testq %r13, %r13
je 0x1ddf8d
movq -0x8(%r14,%r13,8), %rdx
addq %rdx, %rcx
incq %rcx
movq %rcx, (%r14,%r13,8)
incq %r13
cmpq 0x40(%rbx), %r13
jb 0x1ddf39
movq 0x10(%rbx), %rdi
leaq 0x1d4253(%rip), %rsi    # 0x3b21f4
movl $0x888, %edx            # imm = 0x888
callq 0x1045eb
movq %r15, 0x10(%rbx)
cmpq $0x0, 0x48(%rbx)
je 0x1ddfd7
leaq 0x1d4237(%rip), %rsi    # 0x3b21f4
movq %r14, %rdi
movl $0x892, %edx            # imm = 0x892
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1045eb
movq 0x38(%rbx), %rdi
leaq 0x1d4212(%rip), %rsi    # 0x3b21f4
movl $0x88d, %edx            # imm = 0x88D
callq 0x1045eb
movq %r14, 0x38(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x7378d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_write_seppos
int gt_reads2twobit_write_seppos(GtReads2Twobit *r2t, char* path,
    GtBitsequence *skip, GtError *err)
{
  int had_err = 0;
  FILE *file;
  GtUword pos, seqnum;
  if (r2t->seppos == NULL)
    return 0;
  file = gt_fa_fopen(path, "wb", err);
  if (file == NULL)
    had_err = -1;
  if (!had_err)
  {
    if (!GT_ISIBITSET(skip, 0))
    {
      gt_xfwrite(r2t->seppos, sizeof (r2t->seppos), (size_t)1, file);
      pos = r2t->seppos[0] + 1UL;
    }
    else
      pos = 0;
    for (seqnum = 1UL; seqnum < r2t->nofseqs; seqnum++)
    {
      if (!GT_ISIBITSET(skip, seqnum))
      {
        pos += r2t->seppos[seqnum] - r2t->seppos[seqnum - 1UL] - 1UL;
        gt_xfwrite(&pos, sizeof (pos), (size_t)1, file);
        pos++;
      }
    }
    gt_fa_fclose(file);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x38(%rdi)
je 0x1de072
movq %rcx, %r8
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x177abc(%rip), %rax    # 0x355ae1
leaq 0x1d41c8(%rip), %rdx    # 0x3b21f4
movq %rsi, %rdi
movq %rax, %rsi
movl $0x89e, %ecx            # imm = 0x89E
callq 0xfcdbb
xorl %ebp, %ebp
testq %rax, %rax
sete %r12b
je 0x1de079
movq %rax, %r15
cmpq $0x0, (%rbx)
js 0x1de083
movq 0x38(%r14), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x11f89c
movq 0x38(%r14), %rax
movq (%rax), %rax
incq %rax
jmp 0x1de085
xorl %ebp, %ebp
jmp 0x1de103
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x1de103
xorl %eax, %eax
movb %r12b, %bpl
movq %rax, (%rsp)
movq 0x40(%r14), %rdx
cmpq $0x2, %rdx
jb 0x1de0f9
movl $0x1, %r12d
movq %rsp, %r13
movq %r12, %rcx
shrq $0x6, %rcx
movq (%rbx,%rcx,8), %rsi
movl %r12d, %ecx
shlq %cl, %rsi
shrq $0x3f, %rsi
jne 0x1de0f1
movq 0x38(%r14), %rcx
movq -0x8(%rcx,%r12,8), %rdx
notq %rdx
addq (%rcx,%r12,8), %rdx
addq %rax, %rdx
movq %rdx, (%rsp)
movl $0x8, %esi
movl $0x1, %edx
movq %r13, %rdi
movq %r15, %rcx
callq 0x11f89c
movq (%rsp), %rax
incq %rax
movq %rax, (%rsp)
movq 0x40(%r14), %rdx
incq %r12
cmpq %rdx, %r12
jb 0x1de09f
negl %ebp
movq %r15, %rdi
callq 0xfd018
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_write_libraries_table
void gt_reads2twobit_write_libraries_table(const GtReads2Twobit *r2t,
    FILE *rlt_fp)
{
  GtUword noflibs, lnum;
  GtReadsLibrariesTable *rlt;
  noflibs = gt_array_size(r2t->collection);
  gt_assert(noflibs > 0);
  rlt = gt_reads_libraries_table_new(noflibs);
  for (lnum = 0; lnum < noflibs; lnum++)
  {
    GtReadsLibraryInfo *rli;
    rli = gt_array_get(r2t->collection, lnum);
    gt_reads_libraries_table_add(rlt, rli->first_seqnum, rli->insertlength,
        rli->stdev, rli->paired);
  }
  gt_reads_libraries_table_save(rlt, rlt_fp);
  gt_reads_libraries_table_delete(rlt);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0xd24e0
testq %rax, %rax
je 0x1de21a
movq %rax, %r15
movq %rax, %rdi
callq 0x1df3c0
movq %rax, %r12
xorl %r13d, %r13d
movq 0x8(%r14), %rdi
movq %r13, %rsi
callq 0xd2207
movq 0x38(%rax), %rsi
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rcx
movzbl (%rax), %r8d
movq %r12, %rdi
callq 0x1df463
incq %r13
cmpq %r13, %r15
jne 0x1de1d2
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1df537
movq %r12, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1df427
callq 0x739c7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_write_hplengths
void gt_reads2twobit_write_hplengths(const GtReads2Twobit *r2t, FILE *out_fp)
{
  gt_assert(r2t != NULL);
  gt_assert(r2t->hplengths != NULL);
  gt_assert(out_fp != NULL);
  gt_hplstore_save(r2t->hplengths, out_fp);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1de23c
movq 0xc0(%rdi), %rdi
testq %rdi, %rdi
je 0x1de241
testq %rsi, %rsi
je 0x1de246
popq %rax
jmp 0x31f861
callq 0x73a72
callq 0x73a39
callq 0x73a00
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_enable_descs
void gt_reads2twobit_enable_descs(GtReads2Twobit *r2t, bool clipped,
                                  bool membased)
{
  gt_assert(r2t != NULL);
  r2t->clipdes = clipped;
  if (membased)
  {
    r2t->descs = gt_desc_buffer_new();
    if (clipped)
      gt_desc_buffer_set_clip_at_whitespace(r2t->descs);
  }
  else
  {
    r2t->descsfp = gt_xtmpfp_generic(NULL, GT_TMPFP_AUTOREMOVE);
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1de2b1
movl %esi, %ebp
movq %rdi, %rbx
movb %bpl, 0xa8(%rdi)
testb %dl, %dl
je 0x1de28b
callq 0xe4c6c
movq %rax, 0x98(%rbx)
testb %bpl, %bpl
je 0x1de2aa
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe4cec
leaq 0x1d3f62(%rip), %rdx    # 0x3b21f4
xorl %edi, %edi
movl $0x1, %esi
movl $0x91e, %ecx            # imm = 0x91E
callq 0xfd35a
movq %rax, 0xa0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x73aab
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_close_file
static int gt_reads2twobit_close_file(FILE *file, GtStr *filename, GtError *err)
{
  int had_err = 0;
  gt_assert(file != NULL);
  if (ferror(file) != 0)
  {
    gt_error_set(err, "Error by reading file %s: %s", gt_str_get(filename),
        strerror(errno));
    had_err = -1;
  }
  gt_fa_fclose(file);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1de634
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x17f00
testl %eax, %eax
je 0x1de61d
movq %r15, %rdi
callq 0x11b0a1
movq %rax, %r15
callq 0x17060
movl (%rax), %edi
callq 0x17240
leaq 0x1d467a(%rip), %rsi    # 0x3b2c80
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x1de61f
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0xfd018
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x73ce5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_clip_str
static void gt_reads2twobit_clip_str(GtStr *str)
{
  GtUword i;
  for (i = 0; i < gt_str_length(str); i++)
  {
    if (isspace(gt_str_get(str)[i]))
    {
      gt_str_get(str)[i] = '\n';
      gt_str_set_length(str, i+1);
      return;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x11b0ca
testq %rax, %rax
je 0x1deb31
xorl %r14d, %r14d
callq 0x17870
movq %rax, %r15
movq (%r15), %r12
movq %rbx, %rdi
callq 0x11b0a1
movsbq (%rax,%r14), %rax
testb $0x20, 0x1(%r12,%rax,2)
jne 0x1deb3d
incq %r14
movq %rbx, %rdi
callq 0x11b0ca
cmpq %rax, %r14
jb 0x1deb09
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x11b0a1
movb $0xa, (%rax,%r14)
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x11b0d7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_switch_to_invalid_mode
static void gt_reads2twobit_switch_to_invalid_mode(
    GtReads2TwobitEncodeState *state)
{
  state->invalid_mode = true;
  state->invalid_sequences++;
  state->invalid_total_length += state->seqlen;
  state->invalid_total_length += state->seqlen_mate;
  if (state->varlen_mode && state->backup.seppos_nextfree == 0)
  {
    gt_log_log("switch back to eqlen mode, seqlen = "GT_WU"",
        state->backup.seqlen_first);
    gt_free(state->seppos);
    state->seppos = NULL;
    state->seppos_alloc = 0;
    state->varlen_mode = false;
  }
  GT_READS2TWOBIT_COPY_ENCODE_INFO(state->backup, state->current);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb $0x1, 0x8f1(%rdi)
incq 0x8f8(%rdi)
movq 0x900(%rdi), %rax
addq 0x808(%rdi), %rax
addq 0x810(%rdi), %rax
movq %rax, 0x900(%rdi)
cmpb $0x1, 0x8f0(%rdi)
jne 0x1debe2
cmpq $0x0, 0x8d0(%rbx)
jne 0x1debe2
movq 0x8e8(%rbx), %rsi
leaq 0x1d3e6f(%rip), %rdi    # 0x3b2a21
xorl %eax, %eax
callq 0x103d72
movq 0x908(%rbx), %rdi
leaq 0x1d362d(%rip), %rsi    # 0x3b21f4
movl $0x224, %edx            # imm = 0x224
callq 0x1045eb
movb $0x0, 0x8f0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x908(%rbx)
leaq 0x820(%rbx), %rdi
addq $0x888, %rbx            # imm = 0x888
movl $0xd, %ecx
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_apply_quality_filter
static void gt_reads2twobit_apply_quality_filter(
    GtReads2TwobitEncodeState *state, const char *qbuf, GtUword nofq)
{
  GtUword i, low = 0;
  for (i = 0; i < nofq; i++)
    if (qbuf[i] <= state->lowqual)
      low++;
  if (low > state->maxlow)
    gt_reads2twobit_switch_to_invalid_mode(state);
}

// Assembly:
testq %rdx, %rdx
je 0x1dec30
movb 0x930(%rdi), %cl
xorl %eax, %eax
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpb %cl, (%rsi,%r8)
setle %r9b
addq %r9, %rax
incq %r8
cmpq %r8, %rdx
jne 0x1dec0d
cmpq 0x958(%rdi), %rax
ja 0x1deb63
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_append_seppos
static void gt_reads2twobit_append_seppos(GtReads2TwobitEncodeState *state,
    GtUword pos)
{
  gt_assert(state->seppos != NULL);
  if (state->current.seppos_nextfree == state->seppos_alloc)
  {
    (state->seppos_alloc) += GT_READS2TWOBIT_SEPPOS_INC;
    state->seppos = gt_realloc(state->seppos,
        sizeof (state->seppos) * state->seppos_alloc);
  }
  state->seppos[state->current.seppos_nextfree] = pos;
  state->current.seppos_nextfree++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x908(%rdi), %rax
testq %rax, %rax
je 0x1deca2
movq %rsi, %r14
movq %rdi, %rbx
movq 0x868(%rdi), %rcx
cmpq 0x910(%rdi), %rcx
jne 0x1dec8f
leaq 0x4000(%rcx), %rdx
movq %rdx, 0x910(%rbx)
leaq 0x20000(,%rcx,8), %rsi
leaq 0x1d3580(%rip), %rdx    # 0x3b21f4
movq %rax, %rdi
movl $0x1a0, %ecx            # imm = 0x1A0
callq 0x104461
movq %rax, 0x908(%rbx)
movq 0x868(%rbx), %rcx
movq %r14, (%rax,%rcx,8)
incq 0x868(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x73e02