LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x185ca5
movq %rdi, %rbx
xorl %r12d, %r12d
pushq $0x1
popq %rbp
xorl %r15d, %r15d
xorl %r14d, %r14d
xorl %eax, %eax
cmpq 0x80(%rbx), %r15
jae 0x185c93
testb $0x1, %r15b
movzbl %al, %r13d
cmovel %r12d, %r13d
movq 0x70(%rbx), %rdi
movq %r15, %rsi
callq 0x17ffcd
testq %rax, %rax
setne %dl
testb $0x1, %r13b
sete %cl
movl %ebp, %eax
andb %dl, %cl
jne 0x185c88
movl %r13d, %eax
movzbl %cl, %ecx
addq %rcx, %r14
incq %r15
jmp 0x185c51
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2b22bc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15f35d(%rip), %rsi    # 0x2e5013
leaq 0x1c9b7c(%rip), %rdx    # 0x34f839
leaq 0x1ca502(%rip), %rcx    # 0x3501c6
leaq 0x1c9aaa(%rip), %r8     # 0x34f775
movl $0x8fb, %r9d            # imm = 0x8FB
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_nofedges_Edgenum
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 0x185d18
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq 0x80(%rbx), %r14
jae 0x185d0f
movq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x17ffcd
addq %rax, %r15
incq %r14
jmp 0x185cf2
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x2b2249(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15f2ea(%rip), %rsi    # 0x2e5013
leaq 0x1c9b09(%rip), %rdx    # 0x34f839
leaq 0x1cadbf(%rip), %rcx    # 0x350af6
leaq 0x1c9a37(%rip), %r8     # 0x34f775
movl $0x913, %r9d            # imm = 0x913
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_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 0x185d60
callq 0x185cdf
shrq %rax
popq %rcx
retq
movq 0x2b2201(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15f2a2(%rip), %rsi    # 0x2e5013
leaq 0x1c9ac1(%rip), %rdx    # 0x34f839
leaq 0x1ca45c(%rip), %rcx    # 0x3501db
leaq 0x1c99ef(%rip), %r8     # 0x34f775
movl $0x925, %r9d            # imm = 0x925
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_log_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 %rbx
testq %rdi, %rdi
je 0x185e2c
movq %rsi, %rbx
movq %rdi, %r15
callq 0x185b9c
movq %rax, %r14
movq %r15, %rdi
callq 0x185cdf
movq %rax, %r9
shrq %r9
testq %rax, %rax
js 0x185dce
cvtsi2ss %rax, %xmm1
jmp 0x185ddf
movl %eax, %ecx
andl $0x1, %ecx
orq %r9, %rcx
cvtsi2ss %rcx, %xmm1
addss %xmm1, %xmm1
movl %r14d, %edx
andl $0x1, %edx
movq %r14, %rcx
shrq %rcx
orq %rcx, %rdx
testq %r14, %r14
js 0x185dfa
cvtsi2ss %r14, %xmm2
jmp 0x185e03
cvtsi2ss %rdx, %xmm2
addss %xmm2, %xmm2
xorps %xmm0, %xmm0
je 0x185e10
divss %xmm2, %xmm1
cvtss2sd %xmm1, %xmm0
leaq 0x1ca3ed(%rip), %rsi    # 0x350204
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %r8
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
jmp 0x92e71
movq 0x2b2135(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15f1d6(%rip), %rsi    # 0x2e5013
leaq 0x1c99f5(%rip), %rdx    # 0x34f839
leaq 0x1ca3a3(%rip), %rcx    # 0x3501ee
leaq 0x1c9923(%rip), %r8     # 0x34f775
movl $0x932, %r9d            # imm = 0x932
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_dot_show_edge
static inline void gt_strgraph_dot_show_edge(GtFile *outfp,
    GtStrgraphVnum from, GtStrgraphVnum to, GtStrgraphLength length)
{
  gt_file_xprintf(outfp,
      " \""GT_WU"%c\" -> \""GT_WU"%c\" "
      "[label="FormatGtStrgraphLength"];\n",
      GT_STRGRAPH_V_READNUM(from),
      GT_STRGRAPH_V_CHAR(from),
      GT_STRGRAPH_V_READNUM(to),
      GT_STRGRAPH_V_CHAR(to),
      PRINTGtStrgraphLengthcast(length));
}

// Assembly:
pushq %rax
movq %rsi, %rax
shrq %rax
andl $0x1, %esi
leal (%rsi,%rsi,2), %r10d
addl $0x42, %r10d
movq %rdx, %r8
shrq %r8
andl $0x1, %edx
leal (%rdx,%rdx,2), %r9d
addl $0x42, %r9d
movq %rcx, (%rsp)
leaq 0x1c9171(%rip), %rsi    # 0x3508fd
movq %rax, %rdx
movl %r10d, %ecx
xorl %eax, %eax
callq 0x8d432
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_dot_show_vertex
static inline void gt_strgraph_dot_show_vertex(GtFile *outfp,
    GtStrgraphFormat format, GtStrgraph *strgraph, GtStrgraphVnum v,
    GtUword depth, GtUword group)
{
  const char *shape = GT_STRGRAPH_DOT_SELECT_VSHAPE(strgraph, v),
             *color = GT_STRGRAPH_DOT_SELECT_VCOLOR(strgraph, v, depth, group);
  if (format == GT_STRGRAPH_DOT)
  {
    gt_file_xprintf(outfp, " \""GT_WU"%c\" [shape=%s,%s]\n",
        GT_STRGRAPH_V_READNUM(v), GT_STRGRAPH_V_CHAR(v), shape, color);
  }
  else
  {
    gt_assert(format == GT_STRGRAPH_DOT_BI);
    gt_file_xprintf(outfp, " "GT_WU" [shape=%s,%s]\n",
        GT_STRGRAPH_V_READNUM(v), shape, color);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
movq 0x70(%rdx), %rdi
movq %rcx, %rsi
callq 0x17ffcd
cmpq $0x1, %rax
jne 0x18782a
movq 0x70(%r12), %rdi
movl %ebx, %esi
andl $0x1, %esi
negq %rsi
orq $0x1, %rsi
addq %rbx, %rsi
callq 0x17ffcd
cmpq $0x1, %rax
jne 0x18782a
leaq 0x1c6987(%rip), %r15    # 0x34e1ac
jmp 0x1878af
movq 0x70(%r12), %rdi
movq %rbx, %rsi
callq 0x17ffcd
cmpq $0x2, %rax
jb 0x187864
movq 0x70(%r12), %rdi
movl %ebx, %esi
andl $0x1, %esi
negq %rsi
orq $0x1, %rsi
addq %rbx, %rsi
callq 0x17ffcd
testq %rax, %rax
je 0x187864
leaq 0x1d7408(%rip), %r15    # 0x35ec6a
jmp 0x1878af
movq 0x70(%r12), %rdi
movq %rbx, %rsi
callq 0x17ffcd
cmpq $0x1, %rax
jne 0x1878a8
movq 0x70(%r12), %rdi
movl %ebx, %esi
andl $0x1, %esi
negq %rsi
orq $0x1, %rsi
addq %rbx, %rsi
callq 0x17ffcd
cmpq $0x2, %rax
leaq 0x1d73cf(%rip), %rax    # 0x35ec6a
leaq 0x1c9158(%rip), %r15    # 0x3509fa
cmovaeq %rax, %r15
jmp 0x1878af
leaq 0x1c914b(%rip), %r15    # 0x3509fa
cmpq $0x1, %r13
jbe 0x1878be
leaq 0x1e2cb4(%rip), %r9     # 0x36a570
jmp 0x1878f0
movq 0x58(%r12), %rdi
movq %rbx, %rsi
callq 0x17ffcd
cmpl $0x3, %eax
jne 0x1878d9
leaq 0x1c912c(%rip), %r9     # 0x350a03
jmp 0x1878f0
cmpq $0x1, (%rsp)
leaq 0x1c913e(%rip), %rax    # 0x350a23
leaq 0x1c9158(%rip), %r9     # 0x350a44
cmoveq %rax, %r9
cmpl $0x1, %ebp
je 0x18792a
testl %ebp, %ebp
jne 0x187955
movq %rbx, %rdx
shrq %rdx
andl $0x1, %ebx
leal (%rbx,%rbx,2), %ecx
addl $0x42, %ecx
leaq 0x1c9159(%rip), %rsi    # 0x350a68
movq %r14, %rdi
movq %r15, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8d432
shrq %rbx
leaq 0x1c9168(%rip), %rsi    # 0x350a9c
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
movq %r9, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8d432
movq 0x2b060c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15d6ad(%rip), %rsi    # 0x2e5013
leaq 0x1c87ca(%rip), %rdx    # 0x350137
leaq 0x1c910c(%rip), %rcx    # 0x350a80
leaq 0x1c7dfa(%rip), %r8     # 0x34f775
movl $0x580, %r9d            # imm = 0x580
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_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 0x187b29
movq 0x18(%rbx), %rcx
cmpq 0x20(%rbx), %rcx
jae 0x187b34
movq 0x38(%rbx), %rdi
callq 0x178934
jmp 0x187b44
addq %rax, (%rbx)
movq 0x38(%rbx), %rdi
callq 0x17899d
incq 0x28(%rbx)
movq 0x38(%rbx), %rdi
testb $0x1, %r14b
jne 0x187b64
movq 0x30(%rbx), %rax
movq %r14, %rsi
shrq %rsi
notq %rsi
addq 0x80(%rax), %rsi
jmp 0x187b6a
movq %r14, %rsi
shrq %rsi
callq 0x178e88
movq 0x30(%rbx), %rcx
movq 0x8(%rcx), %rax
testq %rax, %rax
jne 0x187b87
movq (%rcx), %rdi
movq %r14, %rsi
callq 0x75173
movq %rax, 0x18(%rbx)
movq $0x1, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x187f59
movq %r14, %rdi
callq 0x188266
movq $0x1, 0x8(%r14)
movq %rbx, 0x30(%r14)
andq $0x0, 0x70(%r14)
cmpq $0x0, 0x68(%r14)
je 0x187f77
movq 0x60(%r14), %rax
jmp 0x187f9d
movq $0x4000, 0x68(%r14)     # imm = 0x4000
movq 0x60(%r14), %rdi
leaq 0x1c77eb(%rip), %rdx    # 0x34f775
movl $0x10000, %esi          # imm = 0x10000
movl $0xa27, %ecx            # imm = 0xA27
callq 0x93472
movq %rax, 0x60(%r14)
testq %rax, %rax
je 0x188027
movq 0x70(%r14), %rdx
leaq 0x1(%rdx), %rcx
movq %rcx, 0x70(%r14)
andl $0x0, (%rax,%rdx,4)
movq 0x68(%r14), %rdx
cmpq %rdx, %rcx
jb 0x187ff7
leaq 0x4000(%rdx), %rcx
movq %rcx, 0x68(%r14)
leaq 0x10000(,%rdx,4), %rsi
leaq 0x1c779c(%rip), %rdx    # 0x34f775
movq %rax, %rdi
movl $0xa2c, %ecx            # imm = 0xA2C
callq 0x93472
movq %rax, 0x60(%r14)
testq %rax, %rax
je 0x188083
movq 0x70(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x70(%r14)
testb $0x1, %bl
jne 0x188010
shrq %rbx
notq %rbx
addq 0x28(%r14), %rbx
jmp 0x188013
shrq %rbx
movq %rbx, %rdx
shrq $0x20, %rdx
jne 0x188055
movl %ebx, (%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2aff3a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15cfdb(%rip), %rsi    # 0x2e5013
leaq 0x1c8b61(%rip), %rdx    # 0x350ba0
leaq 0x1c8b3d(%rip), %rcx    # 0x350b83
leaq 0x1c7728(%rip), %r8     # 0x34f775
movl $0xa27, %r9d            # imm = 0xA27
jmp 0x1880af
movq 0x2aff0c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15cfad(%rip), %rsi    # 0x2e5013
leaq 0x1c8b63(%rip), %rdx    # 0x350bd0
leaq 0x1c8b0f(%rip), %rcx    # 0x350b83
leaq 0x1c76fa(%rip), %r8     # 0x34f775
movl $0xa2f, %r9d            # imm = 0xA2F
jmp 0x1880af
movq 0x2afede(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15cf7f(%rip), %rsi    # 0x2e5013
leaq 0x1c8b05(%rip), %rdx    # 0x350ba0
leaq 0x1c8ae1(%rip), %rcx    # 0x350b83
leaq 0x1c76cc(%rip), %r8     # 0x34f775
movl $0xa2c, %r9d            # imm = 0xA2C
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1c9f61(%rip), %rsi    # 0x35248a
pushq $0x18
popq %rdi
pushq $0x38
popq %rdx
callq 0x93160
movq %rax, %rbx
movq %r13, %rdi
callq 0x72478
testb %al, %al
je 0x1885ba
movq %r13, %rdi
callq 0x81d17
cmpl $0x2, %eax
jne 0x1885c3
movq %r13, %rdi
callq 0x77721
movq %rax, %r12
movq %r13, %rdi
callq 0x7779c
movq %rax, %r13
movq %r15, %rdi
callq 0xacbd1
movq %rax, %r15
leaq 0x15e4a3(%rip), %rsi    # 0x2e6a1b
movq %rax, %rdi
callq 0xacbfb
movq %r15, %rdi
callq 0xad1fa
leaq 0x1c9efb(%rip), %rdx    # 0x35248a
pushq $0x41
popq %rcx
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %r8
callq 0x8b515
movq %rax, 0x10(%rbx)
addq %rax, %r12
movq %r12, (%rbx)
addq %rax, %r13
movq %r13, 0x8(%rbx)
movq %r15, %rdi
callq 0xae103
jmp 0x1885d6
leaq 0x1c9f2f(%rip), %rsi    # 0x3524f0
jmp 0x1885ca
leaq 0x1c9f6e(%rip), %rsi    # 0x352538
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0x89dbb
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x188631
movq %rsi, %rcx
movq (%rdi), %rax
shrq $0x5, %rsi
notl %ecx
addl %ecx, %ecx
pushq $0x3
popq %r8
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
movq 0x2af92f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15c9d0(%rip), %rsi    # 0x2e5013
leaq 0x1c9e61(%rip), %rdx    # 0x3524ab
leaq 0x1c9e6b(%rip), %rcx    # 0x3524bc
leaq 0x1c9e32(%rip), %r8     # 0x35248a
pushq $0x52
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x172d0
movq %rax, %r14
leaq 0x1c9ee4(%rip), %rdi    # 0x3525bf
callq 0x17b60
leaq 0x1c9f0d(%rip), %rdi    # 0x3525f4
callq 0x17b60
leaq 0x1c9ea8(%rip), %rsi    # 0x35259b
pushq $0x1f
popq %rdx
movq %r14, %rdi
callq 0x93160
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x17730
cmpq $0xc, %r14
jb 0x188730
addq %rbx, %r14
addq $-0xb, %r14
leaq 0x1c9e93(%rip), %rsi    # 0x3525b3
movq %r14, %rdi
callq 0x179e0
testl %eax, %eax
jne 0x188730
movb $0x0, (%r14)
leaq 0x1c9eca(%rip), %rdi    # 0x352601
callq 0x17b60
movq %rbx, %rdi
callq 0xb2c50
leaq 0x1c9e50(%rip), %rsi    # 0x35259b
pushq $0x28
popq %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x936f9
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x1887f4
movq %rdi, %rbx
leaq 0x1c9ee3(%rip), %rsi    # 0x352656
pushq $0x54
popq %rdx
movl $0xd0, %edi
callq 0x93160
movq %rax, %r14
movq %rbx, (%rax)
pushq $0x48
popq %rdi
callq 0x5809c
movq %rax, 0x8(%r14)
andq $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)
orq $-0x1, 0x88(%r14)
andw $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
movq 0x2af76d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15c80e(%rip), %rsi    # 0x2e5013
leaq 0x1c9e24(%rip), %rdx    # 0x352630
leaq 0x1c9e2f(%rip), %rcx    # 0x352642
leaq 0x1c9e3c(%rip), %r8     # 0x352656
pushq $0x53
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x18892f
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x586a4
movq %rax, %r14
xorl %r15d, %r15d
movq 0x8(%rbx), %rdi
cmpq %r15, %r14
je 0x1888c2
movq %r15, %rsi
callq 0x581aa
movq %rax, %r12
movq 0x8(%rax), %rdi
callq 0xae103
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x1888bd
callq 0xae103
incq %r15
jmp 0x188891
callq 0x58eb9
movq 0x98(%rbx), %rdi
callq 0x6d2bb
movq 0xa0(%rbx), %rdi
callq 0x8a5e5
movq 0xc0(%rbx), %rdi
callq 0x2c020a
movq 0x10(%rbx), %rdi
leaq 0x1c9d60(%rip), %r14    # 0x352656
movq %r14, %rsi
movl $0x87, %edx
callq 0x936f9
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x88, %edx
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x89, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x188a37
movq %rdx, %r15
testq %rdx, %rdx
je 0x188a65
movq %r9, %r12
movq %r8, %r13
movq %rcx, %r14
movq %rdi, %rbx
movb %sil, 0x8(%rsp)
movq %r15, %rdi
callq 0xad442
movq %rax, 0x10(%rsp)
testq %r14, %r14
je 0x1889c4
movq %r14, %rdi
callq 0xad442
jmp 0x1889c6
xorl %eax, %eax
movq %rax, 0x18(%rsp)
movq %r13, 0x20(%rsp)
movq %r12, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rsp)
andq $0x0, 0x48(%rsp)
movq %r15, %rdi
callq 0xad1fa
movq %rax, %rdi
callq 0x8e0a6
movq %rax, 0x30(%rsp)
testq %r14, %r14
je 0x188a18
movq %rax, %r15
movq %r14, %rdi
callq 0xad1fa
movq %rax, %rdi
callq 0x8e0a6
addq %rax, %r15
movq %r15, 0x30(%rsp)
movq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x48
popq %rdx
callq 0x5851d
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x2af52a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15c5cb(%rip), %rsi    # 0x2e5013
leaq 0x1c9c20(%rip), %rdx    # 0x35266f
leaq 0x1c9c58(%rip), %rcx    # 0x3526ae
leaq 0x1c9bf9(%rip), %r8     # 0x352656
movl $0x98, %r9d
jmp 0x188a91
movq 0x2af4fc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15c59d(%rip), %rsi    # 0x2e5013
leaq 0x1ca687(%rip), %rdx    # 0x353104
leaq 0x1c9c2a(%rip), %rcx    # 0x3526ae
leaq 0x1c9bcb(%rip), %r8     # 0x352656
movl $0x99, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_decode_sequence
void gt_reads2twobit_decode_sequence(const GtReads2Twobit *r2t,
    GtUword seqnum, char *decoded)
{
  GtTwobitencoding code;
  GtUword pos, seqlen, charsincode;
  GtTwobitencoding *nextencoded;
  const char code2char[] = "acgt";
  char *nextdecoded = decoded;

  gt_reads2twobit_seek_sequence(r2t, seqnum, &seqlen, &code, &charsincode,
      &nextencoded);
  *(nextdecoded++) = '>';
  *(nextdecoded++) = '\n';
  for (pos = 0; pos < seqlen - 1UL; pos++)
  {
    if (charsincode == 0)
    {
      code = *(nextencoded++);
      charsincode = (GtUword)GT_UNITSIN2BITENC;
    }
    *(nextdecoded++) = code2char[code >> ((--charsincode) << 1) & 3];
  }
  *(nextdecoded++) = '\n';
  *(nextdecoded) = '\0';
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
leaq 0x10(%rsp), %r14
leaq 0x18(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %rsp, %r13
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0x18a6d9
movw $0xa3e, (%rbx)          # imm = 0xA3E
movq (%r14), %rax
movq (%r12), %r10
movq (%r13), %rsi
pushq $0x1
popq %rdx
movq (%r15), %r8
pushq $0x20
popq %rdi
leaq 0x173ba2(%rip), %r9     # 0x2fe234
cmpq %rdx, %rax
je 0x18a6c4
testq %r10, %r10
jne 0x18a6a6
movq (%rsi), %r8
addq $0x8, %rsi
movq %rdi, %r10
decq %r10
leal (%r10,%r10), %ecx
movq %r8, %r11
shrq %cl, %r11
andl $0x3, %r11d
movb (%r11,%r9), %cl
movb %cl, 0x1(%rbx,%rdx)
incq %rdx
jmp 0x18a692
movw $0xa, 0x1(%rbx,%rdx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_seek_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
movq %rax, (%rdx)
testq %rax, %rax
je 0x18a6eb
imulq %rsi, %rax
jmp 0x18a715
movq 0x38(%rdi), %rax
testq %rsi, %rsi
je 0x18a70a
movq (%rax,%rsi,8), %r10
subq -0x8(%rax,%rsi,8), %r10
movq %r10, (%rdx)
movq -0x8(%rax,%rsi,8), %rax
incq %rax
jmp 0x18a715
movq (%rax), %rax
incq %rax
movq %rax, (%rdx)
xorl %eax, %eax
movq 0x10(%rdi), %rdx
movq %rax, %rsi
shrq $0x5, %rsi
andl $0x1f, %eax
pushq $0x20
popq %rdi
subq %rax, %rdi
movq %rdi, (%r8)
leaq (%rdx,%rsi,8), %rax
addq $0x8, %rax
movq %rax, (%r9)
movq -0x8(%rax), %rax
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1a8ede(%rip), %rsi    # 0x33390e
movq %rax, %rdi
movq %rcx, %rdx
callq 0x8ce05
testq %rax, %rax
je 0x18aa64
movq %rax, %r12
movq 0x40(%r15), %rcx
xorl %r14d, %r14d
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %rbx, %r8
callq 0x18a73f
movq %r12, %rdi
callq 0x8da06
jmp 0x18aa68
pushq $-0x1
popq %r14
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
movabsq $-0x8000000000000000, %rbp # imm = 0x8000000000000000
movq 0x8(%rdi), %rdi
callq 0x586a4
movq %rax, %r12
xorl %r15d, %r15d
xorl %r13d, %r13d
cmpq %r12, %r13
je 0x18ad54
movq 0x8(%r14), %rdi
movq %r13, %rsi
callq 0x581aa
cmpb $0x1, (%rax)
jne 0x18ad4c
movq 0x40(%rax), %rcx
testq %rcx, %rcx
je 0x18ad4c
testb $0x1, %cl
jne 0x18ad66
movq 0x38(%rax), %rax
leaq (%rcx,%rax), %rdx
decq %rdx
cmpq %rdx, %rax
jae 0x18ad4c
movq %rax, %rsi
shrq $0x6, %rsi
movq (%rbx,%rsi,8), %rdi
movq %rbp, %r8
movl %eax, %ecx
shrq %cl, %r8
leaq 0x1(%rax), %rcx
movq %rcx, %r9
shrq $0x6, %r9
testq %r8, %rdi
je 0x18ad2b
movq (%rbx,%r9,8), %r11
movq %rbp, %r10
shrq %cl, %r10
testq %r10, %r11
jne 0x18ad31
orq %r10, %r11
movq %r11, (%rbx,%r9,8)
jmp 0x18ad43
movq %rbp, %r10
shrq %cl, %r10
testq %r8, %rdi
jne 0x18ad46
andq (%rbx,%r9,8), %r10
je 0x18ad46
orq %r8, %rdi
movq %rdi, (%rbx,%rsi,8)
incq %r15
addq $0x2, %rax
jmp 0x18aceb
incq %r13
jmp 0x18acb4
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2ad1fb(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15a29c(%rip), %rsi    # 0x2e5013
leaq 0x1c7b30(%rip), %rdx    # 0x3528ae
leaq 0x1c7b3f(%rip), %rcx    # 0x3528c4
leaq 0x1c78ca(%rip), %r8     # 0x352656
movl $0x73d, %r9d            # imm = 0x73D
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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:
cmpq $0x0, 0x38(%rdi)
je 0x18babd
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r8
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x16a07f(%rip), %rax    # 0x2f5af1
leaq 0x1c6bdd(%rip), %rdx    # 0x352656
movq %rsi, %rdi
movq %rax, %rsi
movl $0x89e, %ecx            # imm = 0x89E
callq 0x8a156
movq %rax, %r15
xorl %ebp, %ebp
testq %rax, %rax
sete %al
je 0x18bac0
movb %al, %bpl
cmpq $0x0, (%rbx)
js 0x18bac5
movq 0x38(%r14), %rdi
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rcx
callq 0xb302c
movq 0x38(%r14), %rax
movq (%rax), %rax
incq %rax
jmp 0x18bac7
xorl %eax, %eax
retq
pushq $-0x1
popq %rax
jmp 0x18bb40
xorl %eax, %eax
negl %ebp
movl %ebp, 0x14(%rsp)
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
pushq $0x1
popq %rbp
movq %rbp, %r13
cmpq 0x40(%r14), %r13
jae 0x18bb34
movq %r13, %rcx
shrq $0x6, %rcx
movq (%rbx,%rcx,8), %rdx
movl %r13d, %ecx
shlq %cl, %rdx
shrq $0x3f, %rdx
jne 0x18bb2f
movq 0x38(%r14), %rcx
movq -0x8(%rcx,%r13,8), %rdx
notq %rdx
addq (%rcx,%r13,8), %rdx
addq %rax, %rdx
movq %rdx, 0x8(%rsp)
movq %r12, %rdi
pushq $0x8
popq %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0xb302c
movq 0x8(%rsp), %rax
incq %rax
movq %rax, 0x8(%rsp)
incq %r13
jmp 0x18badc
movq %r15, %rdi
callq 0x8a4fd
movl 0x14(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/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 0x586a4
testq %rax, %rax
je 0x18be22
movq %rax, %r15
movq %rax, %rdi
callq 0x18d494
movq %rax, %r12
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x18be06
movq 0x8(%r14), %rdi
movq %r13, %rsi
callq 0x581aa
movq 0x38(%rax), %rsi
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rcx
movzbl (%rax), %r8d
movq %r12, %rdi
callq 0x18d550
incq %r13
jmp 0x18bdd8
movq %r12, %rdi
movq %rbx, %rsi
callq 0x18d787
movq %r12, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x18d518
movq 0x2ac13f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1591e0(%rip), %rsi    # 0x2e5013
leaq 0x1c6dfb(%rip), %rdx    # 0x352c35
leaq 0x1c6e00(%rip), %rcx    # 0x352c41
leaq 0x1c680e(%rip), %r8     # 0x352656
movl $0x8f6, %r9d            # imm = 0x8F6
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x18be77
movq 0xc0(%rdi), %rdi
testq %rdi, %rdi
je 0x18bea5
testq %rsi, %rsi
je 0x18bed3
popq %rax
jmp 0x2c078f
movq 0x2ac0ea(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15918b(%rip), %rsi    # 0x2e5013
leaq 0x1c67e0(%rip), %rdx    # 0x35266f
leaq 0x1c6dd1(%rip), %rcx    # 0x352c67
leaq 0x1c67b9(%rip), %r8     # 0x352656
movl $0x905, %r9d            # imm = 0x905
jmp 0x18beff
movq 0x2ac0bc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15915d(%rip), %rsi    # 0x2e5013
leaq 0x1c6dca(%rip), %rdx    # 0x352c87
leaq 0x1c6da3(%rip), %rcx    # 0x352c67
leaq 0x1c678b(%rip), %r8     # 0x352656
movl $0x906, %r9d            # imm = 0x906
jmp 0x18beff
movq 0x2ac08e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x15912f(%rip), %rsi    # 0x2e5013
leaq 0x1c6db3(%rip), %rdx    # 0x352c9e
leaq 0x1c6d75(%rip), %rcx    # 0x352c67
leaq 0x1c675d(%rip), %r8     # 0x352656
movl $0x907, %r9d            # imm = 0x907
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x18bf6f
movl %esi, %ebp
movq %rdi, %rbx
movb %bpl, 0xa8(%rdi)
testb %dl, %dl
je 0x18bf4b
callq 0x6cf90
movq %rax, 0x98(%rbx)
testb %bpl, %bpl
je 0x18bf68
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6d002
leaq 0x1c6704(%rip), %rdx    # 0x352656
pushq $0x1
popq %rsi
xorl %edi, %edi
movl $0x91e, %ecx            # imm = 0x91E
callq 0x8abea
movq %rax, 0xa0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x2abff2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x159093(%rip), %rsi    # 0x2e5013
leaq 0x1c66e8(%rip), %rdx    # 0x35266f
leaq 0x1c6d1f(%rip), %rcx    # 0x352cad
leaq 0x1c66c1(%rip), %r8     # 0x352656
movl $0x914, %r9d            # imm = 0x914
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x18c495
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x17e70
testl %eax, %eax
je 0x18c47e
movq %r15, %rdi
callq 0xad1fa
movq %rax, %r15
callq 0x17060
movl (%rax), %edi
callq 0x17220
leaq 0x1c6c79(%rip), %rsi    # 0x3530e2
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rbp
jmp 0x18c480
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x8a4fd
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x2abacc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x158b6d(%rip), %rsi    # 0x2e5013
leaq 0x1cbb87(%rip), %rdx    # 0x358034
leaq 0x1c6c13(%rip), %rcx    # 0x3530c7
leaq 0x1c619b(%rip), %r8     # 0x352656
movl $0x284, %r9d            # imm = 0x284
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0xad289
cmpq %rax, %r14
jae 0x18ca74
callq 0x17820
movq (%rax), %r15
movq %rbx, %rdi
callq 0xad1fa
movsbq (%rax,%r14), %rax
testb $0x20, 0x1(%r15,%rax,2)
jne 0x18ca7a
incq %r14
jmp 0x18ca45
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0xad1fa
movb $0xa, (%rax,%r14)
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xad296
// File: /workspace/github_c_makefile_star2_O2/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 0x18cb19
cmpq $0x0, 0x8d0(%rbx)
jne 0x18cb19
movq 0x8e8(%rbx), %rsi
leaq 0x1c639a(%rip), %rdi    # 0x352e83
xorl %eax, %eax
callq 0x92a82
movq 0x908(%rbx), %rdi
leaq 0x1c5b58(%rip), %rsi    # 0x352656
movl $0x224, %edx            # imm = 0x224
callq 0x936f9
movb $0x0, 0x8f0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x908(%rbx)
leaq 0x820(%rbx), %rdi
addq $0x888, %rbx            # imm = 0x888
pushq $0xd
popq %rcx
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rax, %rdx
je 0x18cb84
movb (%rsi,%rax), %r8b
xorl %r9d, %r9d
cmpb 0x930(%rdi), %r8b
setle %r9b
addq %r9, %rcx
incq %rax
jmp 0x18cb65
cmpq 0x958(%rdi), %rcx
ja 0x18ca9a
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x18cc03
movq %rsi, %r14
movq %rdi, %rbx
movq 0x868(%rdi), %rcx
cmpq 0x910(%rdi), %rcx
jne 0x18cbf0
leaq 0x4000(%rcx), %rdx
movq %rdx, 0x910(%rbx)
leaq 0x20000(,%rcx,8), %rsi
leaq 0x1c5a81(%rip), %rdx    # 0x352656
movq %rax, %rdi
movl $0x1a0, %ecx            # imm = 0x1A0
callq 0x93472
movq %rax, 0x908(%rbx)
movq 0x868(%rbx), %rcx
movq %r14, (%rax,%rcx,8)
incq 0x868(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2ab35e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1583ff(%rip), %rsi    # 0x2e5013
leaq 0x1c62d4(%rip), %rdx    # 0x352eef
leaq 0x1c62e3(%rip), %rcx    # 0x352f05
leaq 0x1c5a2d(%rip), %r8     # 0x352656
movl $0x19b, %r9d            # imm = 0x19B
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_collect_fileinfo
static void gt_reads2twobit_collect_fileinfo(const GtReads2Twobit *r2t,
    GtFilelengthvalues **filelengthtab, GtStrArray **filenametab)
{
  GtUword i, noflibraries;
  noflibraries = gt_array_size(r2t->collection);
  *filenametab = gt_str_array_new();
  if (filelengthtab != NULL)
  {
    *filelengthtab = gt_malloc(sizeof (**filelengthtab) * noflibraries);
  }
  for (i = 0; i < noflibraries; i++)
  {
    GtStr *libname;
    GtReadsLibraryInfo *rli;
    rli = gt_array_get(r2t->collection, i);
    if (filelengthtab != NULL)
    {
      (*filelengthtab)[i].effectivelength =
        (uint64_t)rli->total_seqlength - 1UL;
      if (r2t->seqlen_eqlen == 0 && i == noflibraries - 1UL)
        (*filelengthtab)[i].effectivelength--;
      (*filelengthtab)[i].length = (uint64_t)rli->total_filelength;
    }
    libname = gt_str_clone(rli->filename1);
    if (rli->filename2 != NULL)
    {
      gt_str_append_char(libname, GT_READS2TWOBIT_LIBSPECSEP);
      gt_str_append_str(libname, rli->filename2);
    }
    if (rli->paired)
    {
      gt_str_append_char(libname, GT_READS2TWOBIT_LIBSPECSEP);
      gt_str_append_uword(libname, rli->insertlength);
      if (rli->stdev > 0)
      {
        gt_str_append_char(libname, GT_READS2TWOBIT_INSERTSEP);
        gt_str_append_uword(libname, rli->stdev);
      }
    }
    gt_str_array_add(*filenametab, libname);
    gt_str_delete(libname);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, (%rsp)
movq 0x8(%rdi), %rdi
callq 0x586a4
movq %rax, %r15
callq 0xae154
movq %rbx, 0x10(%rsp)
movq %rax, (%rbx)
testq %r14, %r14
je 0x18d23a
movq %r15, %rdi
shlq $0x4, %rdi
leaq 0x1c5429(%rip), %rsi    # 0x352656
movl $0x5be, %edx            # imm = 0x5BE
callq 0x93160
movq %rax, (%r14)
leaq -0x1(%r15), %rax
movq %rax, 0x8(%rsp)
pushq $0x8
popq %r12
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x18d326
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq %r13, %rsi
callq 0x581aa
movq %rax, %rbp
testq %r14, %r14
je 0x18d29d
movq 0x30(%rbp), %rcx
leaq -0x1(%rcx), %rdx
movq (%r14), %rax
movq %rdx, (%rax,%r12)
movq 0x8(%rsp), %rdx
xorq %r13, %rdx
movq (%rsp), %rsi
orq 0x48(%rsi), %rdx
jne 0x18d294
addq $-0x2, %rcx
movq %rcx, (%rax,%r12)
movq 0x28(%rbp), %rcx
movq %rcx, -0x8(%rax,%r12)
movq 0x8(%rbp), %rdi
callq 0xad442
movq %rax, %rbx
cmpq $0x0, 0x10(%rbp)
je 0x18d2c7
movq %rbx, %rdi
pushq $0x3a
popq %rsi
callq 0xaced9
movq 0x10(%rbp), %rsi
movq %rbx, %rdi
callq 0xacd13
cmpb $0x1, (%rbp)
jne 0x18d302
movq %rbx, %rdi
pushq $0x3a
popq %rsi
callq 0xaced9
movq 0x18(%rbp), %rsi
movq %rbx, %rdi
callq 0xace26
cmpq $0x0, 0x20(%rbp)
je 0x18d302
movq %rbx, %rdi
pushq $0x2c
popq %rsi
callq 0xaced9
movq 0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0xace26
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq %rbx, %rsi
callq 0xae31d
movq %rbx, %rdi
callq 0xae103
incq %r13
addq $0x10, %r12
jmp 0x18d24a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq