LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x29eb55
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jb 0x29eb55
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x20(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x281ed0
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
jmp 0x29eb63
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x281da0
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
andq $0x1, %rax
cmpq $0x1, %rax
jne 0x29eb8f
movq 0x30(%rsp), %rax
shrq %rax
movq %rax, 0x10(%rsp)
jmp 0x29ebb3
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x80(%rax), %rax
movq 0x30(%rsp), %rcx
shrq %rcx
subq %rcx, %rax
subq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2827f0
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
cmpq $0x0, 0x8(%rax)
jbe 0x29ebe6
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x29ec01
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0xb09f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rax
movq $0x1, 0x8(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_spell_edge
static void gt_strgraph_spell_edge(GtStrgraphVnum v, GtStrgraphLength len,
    void *data)
{

  GtStrgraphSpellData *sdata = data;
  gt_contigs_writer_append(sdata->cw, GT_STRGRAPH_V_MIRROR_SEQNUM(
        GT_STRGRAPH_NOFVERTICES(sdata->strgraph), v), (GtUword)len);
  (sdata->current_depth)++;
  sdata->current_length += len;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
andq $0x1, %rax
cmpq $0x1, %rax
jne 0x29ec79
movq 0x30(%rsp), %rax
shrq %rax
movq %rax, 0x8(%rsp)
jmp 0x29ec9d
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x80(%rax), %rax
movq 0x30(%rsp), %rcx
shrq %rcx
subq %rcx, %rax
subq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x282450
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rcx
movq 0x18(%rsp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq (%rsp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x29f482
movq (%rsp), %rdi
callq 0x29f820
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x29f890
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-strgraph.c
// Function: gt_strgraph_end_contigpath
static inline void gt_strgraph_end_contigpath(GtStrgraphContigpathsData *pdata)
{
  (void)gt_xfwrite(pdata->contig.spaceGtContigpathElem,
    sizeof (GtContigpathElem), (size_t)pdata->contig.nextfreeGtContigpathElem,
    pdata->p_file);
  pdata->total_depth += pdata->current_depth;

  if (pdata->show_contigs_info)
    gt_strgraph_show_contiginfo(pdata);
  (pdata->contignum)++;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x60(%rax), %rdi
movq (%rsp), %rax
movq 0x70(%rax), %rdx
movq (%rsp), %rax
movq 0x40(%rax), %rcx
movl $0x4, %esi
callq 0x126d30
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq (%rsp), %rax
testb $0x1, 0x80(%rax)
je 0x29f86f
movq (%rsp), %rdi
callq 0x29fbb0
movq (%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x18, %edi
leaq 0x2e4bf4(%rip), %rsi    # 0x584dfb
movl $0x38, %edx
callq 0xe80f0
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x2a0300
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x2a02dc
movq 0x40(%rsp), %rdi
callq 0xb52b0
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
callq 0xb5390
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x11d510
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x2777c6(%rip), %rsi    # 0x517a33
callq 0x11d550
movq 0x10(%rsp), %rdi
callq 0x11dee0
movq %rax, %rdi
movq 0x30(%rsp), %r8
xorl %eax, %eax
movl %eax, %esi
leaq 0x2e4b6c(%rip), %rdx    # 0x584dfb
movl $0x41, %ecx
callq 0xdab10
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rcx
addq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rcx
addq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rdi
callq 0x11f560
cmpl $0x0, 0xc(%rsp)
jne 0x2a02ee
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
jmp 0x2a02f6
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x2a02f6
movq (%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rdj-twobitenc-editor.c
// Function: gt_twobitenc_editor_check
static int gt_twobitenc_editor_check(const GtEncseq *encseq, GtError *err)
{
  int had_err = 0;
  if (!gt_encseq_has_twobitencoding(encseq))
  {
    gt_error_set(err, "encseq correction is only "
        "possible if the sequence has a twobitencoding");
    had_err = -1;
  }
  else if (gt_encseq_accesstype_get(encseq) != GT_ACCESS_TYPE_EQUALLENGTH)
  {
    gt_error_set(err, "twobitencoding correction is currently only "
        "implemented if the sequence access type is EQUALLENGTH");
    had_err = -1;
  }
  return had_err;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x10(%rsp), %rdi
callq 0xac6d0
testb $0x1, %al
jne 0x2a0341
movq 0x8(%rsp), %rdi
leaq 0x2e4b31(%rip), %rsi    # 0x584e61
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
jmp 0x2a036d
movq 0x10(%rsp), %rdi
callq 0xc2d90
cmpl $0x2, %eax
je 0x2a036b
movq 0x8(%rsp), %rdi
leaq 0x2e4b4d(%rip), %rsi    # 0x584ea9
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
jmp 0x2a036d
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movb %al, 0x37(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x2a03d4
movq 0x39bbfd(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x275c66(%rip), %rsi    # 0x516013
leaq 0x2e4a68(%rip), %rdx    # 0x584e1c
leaq 0x2e4a72(%rip), %rcx    # 0x584e2d
leaq 0x2e4a39(%rip), %r8     # 0x584dfb
movl $0x52, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a03d6
movq 0x38(%rsp), %rax
shrq $0x5, %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rcx
andq $0x1f, %rcx
movl $0x1f, %eax
subq %rcx, %rax
shlq %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movl $0x3, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
movzbl %al, %eax
movq 0x20(%rsp), %rcx
sarl %cl, %eax
movb %al, 0xf(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movl $0x3, %edx
shlq %cl, %rdx
movq %rdx, %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, 0x10(%rsp)
movzbl 0x37(%rsp), %eax
movq 0x20(%rsp), %rcx
shlq %cl, %rax
orq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdx
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x28(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movzbl 0xf(%rsp), %ecx
movq (%rax,%rcx,8), %rdx
addq $-0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movzbl 0x37(%rsp), %ecx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x192b0
movq %rax, 0x10(%rsp)
movq $0xb, 0x8(%rsp)
leaq 0x2e49ab(%rip), %rdi    # 0x584f0c
movb $0x0, %al
callq 0x19070
leaq 0x2e49d3(%rip), %rdi    # 0x584f42
movb $0x0, %al
callq 0x19070
movq 0x10(%rsp), %rdi
leaq 0x2e49ce(%rip), %rsi    # 0x584f50
movl $0x1f, %edx
callq 0xe80f0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x19700
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jbe 0x2a05e2
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
subq 0x8(%rsp), %rax
addq %rax, %rdi
leaq 0x2e49a3(%rip), %rsi    # 0x584f68
callq 0x19980
cmpl $0x0, %eax
jne 0x2a05e2
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
subq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
leaq 0x2e498b(%rip), %rdi    # 0x584f74
movb $0x0, %al
callq 0x19070
movq 0x18(%rsp), %rdi
callq 0x126730
movq 0x18(%rsp), %rdi
leaq 0x2e494a(%rip), %rsi    # 0x584f50
movl $0x28, %edx
callq 0xe88c0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2a0669
movq 0x39b968(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2759d1(%rip), %rsi    # 0x516013
leaq 0x2e4941(%rip), %rdx    # 0x584f8a
leaq 0x2e494c(%rip), %rcx    # 0x584f9c
leaq 0x2e4959(%rip), %r8     # 0x584fb0
movl $0x53, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a066b
movl $0xd0, %edi
leaq 0x2e4939(%rip), %rsi    # 0x584fb0
movl $0x54, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movl $0x48, %edi
callq 0x80990
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x70(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x78(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x48(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x50(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x58(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x60(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x40(%rax)
movq 0x8(%rsp), %rax
movb $0x21, 0x80(%rax)
movq 0x8(%rsp), %rax
movq $-0x1, 0x88(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x81(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x90(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x91(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0xc0(%rax)
movq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0xc8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x98(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0xa0(%rax)
movq 0x8(%rsp), %rax
movb $0x1, 0xa8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0xb0(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0xb8(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x2a095a
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x81370
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x2a08cf
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x80b60
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2a08bd
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11f560
jmp 0x2a08bf
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2a0871
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x81f80
movq 0x20(%rsp), %rax
movq 0x98(%rax), %rdi
callq 0xa46c0
movq 0x20(%rsp), %rax
movq 0xa0(%rax), %rdi
callq 0xd9570
movq 0x20(%rsp), %rax
movq 0xc0(%rax), %rdi
callq 0x4d12a0
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x2e4690(%rip), %rsi    # 0x584fb0
movl $0x87, %edx
callq 0xe88c0
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rdi
leaq 0x2e4676(%rip), %rsi    # 0x584fb0
movl $0x88, %edx
callq 0xe88c0
movq 0x20(%rsp), %rdi
leaq 0x2e4660(%rip), %rsi    # 0x584fb0
movl $0x89, %edx
callq 0xe88c0
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x78, %rsp
movb %sil, %al
movq %rdi, 0x70(%rsp)
andb $0x1, %al
movb %al, 0x6f(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x48(%rsp)
cmpq $0x0, 0x70(%rsp)
jne 0x2a0a26
movq 0x39b5ab(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x275614(%rip), %rsi    # 0x516013
leaq 0x2e45c3(%rip), %rdx    # 0x584fc9
leaq 0x2e45fb(%rip), %rcx    # 0x585008
leaq 0x2e459c(%rip), %r8     # 0x584fb0
movl $0x98, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a0a28
jmp 0x2a0a2a
cmpq $0x0, 0x60(%rsp)
jne 0x2a0a6a
movq 0x39b567(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2755d0(%rip), %rsi    # 0x516013
leaq 0x2e508e(%rip), %rdx    # 0x585ad8
leaq 0x2e45b7(%rip), %rcx    # 0x585008
leaq 0x2e4558(%rip), %r8     # 0x584fb0
movl $0x99, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a0a6c
movb 0x6f(%rsp), %al
andb $0x1, %al
movb %al, (%rsp)
movq 0x60(%rsp), %rdi
callq 0x11e280
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x2a0a9d
movq 0x58(%rsp), %rdi
callq 0x11e280
movq %rax, 0x10(%rsp)
jmp 0x2a0aa6
movq $0x0, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq $0x0, 0x40(%rsp)
movq 0x60(%rsp), %rdi
callq 0x11dee0
movq %rax, %rdi
callq 0xdf2a0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x2a0b10
movq 0x58(%rsp), %rdi
callq 0x11dee0
movq %rax, %rdi
callq 0xdf2a0
addq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rax
movq 0x8(%rax), %rdi
movq %rsp, %rsi
movl $0x48, %edx
callq 0x81100
addq $0x78, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_encode
int gt_reads2twobit_encode(GtReads2Twobit *r2t, GtError *err)
{
  int had_err = 0;
  const GtUword noflibraries = gt_array_size(r2t->collection);
  GtUword libnum;
  GtReads2TwobitEncodeState state;

  gt_error_check(err);
  gt_assert(r2t != NULL);
  gt_assert(r2t->twobitencoding == NULL);
  gt_reads2twobit_init_encode(r2t, &state);
  for (libnum = 0; libnum < noflibraries && !had_err; libnum++)
  {
    GtReadsLibraryInfo *rli = gt_array_get(r2t->collection, libnum);
    if (!rli->paired)
    {
      had_err = gt_reads2twobit_encode_unpaired_library(&state, rli, err);
    }
    else
    {
      had_err = gt_reads2twobit_encode_paired_library(&state, rli, err);
    }
  }
  gt_reads2twobit_finalize_encode(r2t, &state);
  return had_err;
}

// Assembly:
subq $0x9f8, %rsp            # imm = 0x9F8
movq %rdi, 0x9f0(%rsp)
movq %rsi, 0x9e8(%rsp)
movl $0x0, 0x9e4(%rsp)
movq 0x9f0(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x81370
movq %rax, 0x9d8(%rsp)
cmpq $0x0, 0x9e8(%rsp)
je 0x2a1131
movq 0x9e8(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x2a10f9
jmp 0x2a1131
movq 0x39aea0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x274f09(%rip), %rsi    # 0x516013
leaq 0x2750ae(%rip), %rdx    # 0x5161bf
leaq 0x2e406b(%rip), %rcx    # 0x585183
leaq 0x2e3e91(%rip), %r8     # 0x584fb0
movl $0x5a2, %r9d            # imm = 0x5A2
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a1133
jmp 0x2a1135
cmpq $0x0, 0x9f0(%rsp)
jne 0x2a1178
movq 0x39ae59(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x274ec2(%rip), %rsi    # 0x516013
leaq 0x2e3e71(%rip), %rdx    # 0x584fc9
leaq 0x2e4024(%rip), %rcx    # 0x585183
leaq 0x2e3e4a(%rip), %r8     # 0x584fb0
movl $0x5a3, %r9d            # imm = 0x5A3
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a117a
jmp 0x2a117c
movq 0x9f0(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2a11c3
movq 0x39ae0e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x274e77(%rip), %rsi    # 0x516013
leaq 0x2e3ff7(%rip), %rdx    # 0x58519a
leaq 0x2e3fd9(%rip), %rcx    # 0x585183
leaq 0x2e3dff(%rip), %r8     # 0x584fb0
movl $0x5a4, %r9d            # imm = 0x5A4
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a11c5
movq 0x9f0(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x2a12c0
movq $0x0, 0x9d0(%rsp)
movq 0x9d0(%rsp), %rcx
xorl %eax, %eax
cmpq 0x9d8(%rsp), %rcx
movb %al, 0xf(%rsp)
jae 0x2a120c
cmpl $0x0, 0x9e4(%rsp)
setne %al
xorb $-0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x2a1219
jmp 0x2a129a
movq 0x9f0(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x9d0(%rsp), %rsi
callq 0x80b60
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
jne 0x2a1261
movq 0x10(%rsp), %rsi
movq 0x9e8(%rsp), %rdx
leaq 0x18(%rsp), %rdi
callq 0x2a1720
movl %eax, 0x9e4(%rsp)
jmp 0x2a127f
movq 0x10(%rsp), %rsi
movq 0x9e8(%rsp), %rdx
leaq 0x18(%rsp), %rdi
callq 0x2a1b50
movl %eax, 0x9e4(%rsp)
jmp 0x2a1281
movq 0x9d0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x9d0(%rsp)
jmp 0x2a11e3
movq 0x9f0(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x2a2170
movl 0x9e4(%rsp), %eax
addq $0x9f8, %rsp            # imm = 0x9F8
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl 0x28cf23(%rip), %eax    # 0x52f43c
movl %eax, 0x13(%rsp)
movb 0x28cf1d(%rip), %al     # 0x52f440
movb %al, 0x17(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x38(%rsp), %rcx
leaq 0x20(%rsp), %r8
leaq 0x18(%rsp), %r9
callq 0x2a2630
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movb $0x3e, (%rax)
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movb $0xa, (%rax)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x2a2609
cmpq $0x0, 0x20(%rsp)
jne 0x2a25c2
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x18(%rsp)
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq $0x20, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq 0x20(%rsp), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rsp)
shlq %rcx
shrq %cl, %rax
andq $0x3, %rax
movb 0x13(%rsp,%rax), %cl
movq 0x8(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rsp)
movb %cl, (%rax)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x2a2585
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movb $0xa, (%rax)
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
movq -0x8(%rsp), %rax
movq 0x48(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x2a26e6
cmpq $0x0, -0x10(%rsp)
jne 0x2a2695
movq -0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq $0x0, -0x38(%rsp)
jmp 0x2a26e4
movq -0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rsp), %rdx
subq $0x1, %rdx
subq (%rax,%rdx,8), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
addq $0x1, %rax
movq %rax, -0x38(%rsp)
jmp 0x2a26f9
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
imulq (%rcx), %rax
movq %rax, -0x38(%rsp)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movq -0x38(%rsp), %rax
shrq $0x5, %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x30(%rsp), %rax
movq %rcx, (%rax)
movq -0x38(%rsp), %rax
andq $0x1f, %rax
movl $0x20, %ecx
subq %rax, %rcx
movq -0x28(%rsp), %rax
movq %rcx, (%rax)
movq -0x30(%rsp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, (%rcx)
movq (%rax), %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x2c31cc(%rip), %rsi    # 0x565ec5
callq 0xdd320
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2a2d15
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x2a2d48
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rax
movq 0x40(%rax), %rcx
movq 0x18(%rsp), %r8
xorl %eax, %eax
movl %eax, %edx
callq 0x2a2760
movq 0x8(%rsp), %rdi
callq 0xde430
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_write_encoded_nocodesshift
static void gt_reads2twobit_write_encoded_nocodesshift(GtReads2Twobit *r2t,
    GtTwobitencoding *outputbuffer, GtTwobitencoding offset,
    GtUword firstcodeidx, GtUword lastcodeidx)
{
  if (offset == 0)
    outputbuffer[0] = r2t->twobitencoding[firstcodeidx];
  else
  {
    GtTwobitencoding mask;
    mask =
      ((GtTwobitencoding)1 << GT_MULT2(GT_UNITSIN2BITENC - offset)) - 1;
    outputbuffer[0] =
      (r2t->twobitencoding[firstcodeidx] & mask) |
      (outputbuffer[0] & ~mask);
  }
  if (lastcodeidx > firstcodeidx)
    memcpy(outputbuffer + 1, r2t->twobitencoding + firstcodeidx + 1,
        sizeof (GtTwobitencoding) * (lastcodeidx - firstcodeidx));
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x2a2fc1
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
jmp 0x2a3015
movl $0x20, %ecx
subq 0x20(%rsp), %rcx
shlq %rcx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
andq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rdx
xorq $-0x1, %rdx
andq %rdx, %rax
orq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jbe 0x2a3056
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
addq $0x8, %rsi
movq 0x10(%rsp), %rdx
subq 0x18(%rsp), %rdx
shlq $0x3, %rdx
callq 0x19610
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_write_encoded_leftcodesshift
static void gt_reads2twobit_write_encoded_leftcodesshift(
    GtReads2Twobit *r2t, GtTwobitencoding *outputbuffer,
    GtTwobitencoding inputoffset, GtTwobitencoding outputoffset,
    GtUword firstcodeidx, GtUword lastcodeidx)
{
  const GtTwobitencoding netoffset = inputoffset - outputoffset;
  const GtTwobitencoding shiftright =
    GT_MULT2(GT_UNITSIN2BITENC - netoffset);
  const GtTwobitencoding shiftleft = GT_MULT2(netoffset);
  GtUword i;
  GtTwobitencoding *nextinoutputbuffer = outputbuffer;
  if (outputoffset == 0)
    outputbuffer[0] = r2t->twobitencoding[firstcodeidx] << shiftleft;
  else
  {
    GtTwobitencoding mask;
    mask = ((GtTwobitencoding)1 << GT_MULT2(GT_UNITSIN2BITENC -
          outputoffset)) - 1;
    outputbuffer[0] =
      ((r2t->twobitencoding[firstcodeidx] << shiftleft) & mask) |
      (outputbuffer[0] & ~mask);
  }
  for (i = firstcodeidx + 1UL; i <= lastcodeidx; i++)
  {
    *(nextinoutputbuffer) |= (r2t->twobitencoding[i] >> shiftright);
    *(++nextinoutputbuffer) = (r2t->twobitencoding[i] << shiftleft);
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
movq -0x18(%rsp), %rax
subq -0x20(%rsp), %rax
movq %rax, -0x38(%rsp)
movl $0x20, %eax
subq -0x38(%rsp), %rax
shlq %rax
movq %rax, -0x40(%rsp)
movq -0x38(%rsp), %rax
shlq %rax
movq %rax, -0x48(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x58(%rsp)
cmpq $0x0, -0x20(%rsp)
jne 0x2a30e5
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x48(%rsp), %rcx
shlq %cl, %rax
movq %rax, %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
jmp 0x2a3144
movl $0x20, %ecx
subq -0x20(%rsp), %rcx
shlq %rcx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x60(%rsp)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x48(%rsp), %rcx
shlq %cl, %rax
movq %rax, %rcx
andq -0x60(%rsp), %rcx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x60(%rsp), %rdx
xorq $-0x1, %rdx
andq %rdx, %rax
orq %rax, %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rsp)
movq -0x50(%rsp), %rax
cmpq -0x30(%rsp), %rax
ja 0x2a31c8
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x50(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x40(%rsp), %rcx
shrq %cl, %rax
movq %rax, %rcx
movq -0x58(%rsp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x50(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x48(%rsp), %rcx
shlq %cl, %rax
movq %rax, %rcx
movq -0x58(%rsp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x58(%rsp)
movq %rcx, 0x8(%rax)
movq -0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rsp)
jmp 0x2a3152
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_write_encoded_rightcodesshift
static void gt_reads2twobit_write_encoded_rightcodesshift(
    GtReads2Twobit *r2t, GtTwobitencoding *outputbuffer,
    GtTwobitencoding inputoffset, GtTwobitencoding outputoffset,
    GtUword firstcodeidx, GtUword lastcodeidx)
{
  const GtTwobitencoding netoffset = outputoffset - inputoffset;
  const GtTwobitencoding shiftright = GT_MULT2(netoffset);
  const GtTwobitencoding shiftleft =
    GT_MULT2(GT_UNITSIN2BITENC - netoffset);
  GtUword i;
  GtTwobitencoding *nextinoutputbuffer = outputbuffer + 1;
  GtTwobitencoding mask;
  mask = ((GtTwobitencoding)1 << GT_MULT2(GT_UNITSIN2BITENC -
        outputoffset)) - 1;
  outputbuffer[0] =
    ((r2t->twobitencoding[firstcodeidx] >> shiftright) & mask) |
    (outputbuffer[0] & ~mask);
  outputbuffer[1] =
    r2t->twobitencoding[firstcodeidx] << shiftleft;
  for (i = firstcodeidx + 1; i <= lastcodeidx; i++)
  {
    *(nextinoutputbuffer) |= (r2t->twobitencoding[i] >> shiftright);
    *(++nextinoutputbuffer) = (r2t->twobitencoding[i] << shiftleft);
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
movq -0x20(%rsp), %rax
subq -0x18(%rsp), %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
shlq %rax
movq %rax, -0x40(%rsp)
movl $0x20, %eax
subq -0x38(%rsp), %rax
shlq %rax
movq %rax, -0x48(%rsp)
movq -0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x58(%rsp)
movl $0x20, %ecx
subq -0x20(%rsp), %rcx
shlq %rcx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x60(%rsp)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x40(%rsp), %rcx
shrq %cl, %rax
movq %rax, %rcx
andq -0x60(%rsp), %rcx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x60(%rsp), %rdx
xorq $-0x1, %rdx
andq %rdx, %rax
orq %rax, %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x48(%rsp), %rcx
shlq %cl, %rax
movq %rax, %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rsp)
movq -0x50(%rsp), %rax
cmpq -0x30(%rsp), %rax
ja 0x2a3333
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x50(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x40(%rsp), %rcx
shrq %cl, %rax
movq %rax, %rcx
movq -0x58(%rsp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x50(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x48(%rsp), %rcx
shlq %cl, %rax
movq %rax, %rcx
movq -0x58(%rsp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x58(%rsp)
movq %rcx, 0x8(%rax)
movq -0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rsp)
jmp 0x2a32bd
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_subtract_from_chardistri
static GtUword gt_reads2twobit_subtract_from_chardistri(
    GtReads2Twobit *r2t, GtUword seqnum)
{
  GtTwobitencoding code;
  GtUword pos, seqlen, charsincode;
  GtTwobitencoding *nextencoded;

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x20(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rsp, %r9
callq 0x2a2630
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x2a3d06
cmpq $0x0, 0x8(%rsp)
jne 0x2a3cc3
movq (%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, (%rsp)
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq $0x20, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %rdx
movq 0x8(%rsp), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rsp)
shlq %rcx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0x3, %rcx
movq 0x18(%rax,%rcx,8), %rdx
addq $-0x1, %rdx
movq %rdx, 0x18(%rax,%rcx,8)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2a3c88
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_write_encseq
int gt_reads2twobit_write_encseq(GtReads2Twobit *r2t, GtError *err)
{
  int had_err = 0;
  gt_error_check(err);
  gt_assert(r2t != NULL);
  if (r2t->nofseqs == 0)
  {
    gt_log_log("read set is empty, no encseq was written");
    return had_err;
  }
  gt_assert(r2t->twobitencoding != NULL);
  gt_log_log("write encseq %s", gt_str_get(r2t->indexname));
  gt_log_log("seqlen_eqlen = "GT_WU"", r2t->seqlen_eqlen);
  if (r2t->seqlen_eqlen > 0)
  {
    had_err = gt_reads2twobit_write_encseq_eqlen(r2t, err);
  }
  else
  {
    had_err = gt_reads2twobit_write_encseq_varlen(r2t, err);
  }
  return had_err;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2a4226
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x2a41ee
jmp 0x2a4226
movq 0x397dab(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x271e14(%rip), %rsi    # 0x516013
leaq 0x271fb9(%rip), %rdx    # 0x5161bf
leaq 0x2e11d3(%rip), %rcx    # 0x5853e0
leaq 0x2e0d9c(%rip), %r8     # 0x584fb0
movl $0x851, %r9d            # imm = 0x851
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a4228
jmp 0x2a422a
cmpq $0x0, 0x18(%rsp)
jne 0x2a426a
movq 0x397d67(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x271dd0(%rip), %rsi    # 0x516013
leaq 0x2e0d7f(%rip), %rdx    # 0x584fc9
leaq 0x2e118f(%rip), %rcx    # 0x5853e0
leaq 0x2e0d58(%rip), %r8     # 0x584fb0
movl $0x852, %r9d            # imm = 0x852
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a426c
movq 0x18(%rsp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x2a4293
leaq 0x2e117e(%rip), %rdi    # 0x5853fd
movb $0x0, %al
callq 0xe7740
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x2a434c
jmp 0x2a4295
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x2a42d9
movq 0x397cf8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x271d61(%rip), %rsi    # 0x516013
leaq 0x2e116d(%rip), %rdx    # 0x585426
leaq 0x2e1120(%rip), %rcx    # 0x5853e0
leaq 0x2e0ce9(%rip), %r8     # 0x584fb0
movl $0x858, %r9d            # imm = 0x858
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a42db
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x11dee0
movq %rax, %rsi
leaq 0x2e1150(%rip), %rdi    # 0x585442
movb $0x0, %al
callq 0xe7740
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rsi
leaq 0x2e1149(%rip), %rdi    # 0x585452
movb $0x0, %al
callq 0xe7740
movq 0x18(%rsp), %rax
cmpq $0x0, 0x48(%rax)
jbe 0x2a4331
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2a4360
movl %eax, 0xc(%rsp)
jmp 0x2a4344
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2a44c0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_write_encseq_eqlen
static int gt_reads2twobit_write_encseq_eqlen(GtReads2Twobit *r2t,
    GtError *err)
{
  int had_err = 0;
  GtFilelengthvalues *filelengthtab;
  GtStrArray *filenametab;

  gt_assert(r2t->seqlen_eqlen > 0);
  gt_reads2twobit_collect_fileinfo(r2t, &filelengthtab, &filenametab);
  gt_reads2twobit_set_separators_to_less_frequent_char(r2t);
  gt_reads2twobit_zeropad_tbe(r2t);
  had_err = gt_encseq_equallength_write_twobitencoding_to_file(
      gt_str_get(r2t->indexname), r2t->total_seqlength,
      r2t->seqlen_eqlen - 1UL, r2t->twobitencoding, r2t->nofseqs,
      gt_array_size(r2t->collection), filelengthtab, filenametab,
      r2t->chardistri, err);
  gt_free(filelengthtab);
  gt_str_array_delete(filenametab);
  return had_err;
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movl $0x0, 0x5c(%rsp)
movq 0x68(%rsp), %rax
cmpq $0x0, 0x48(%rax)
ja 0x2a43bb
movq 0x397c16(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x271c7f(%rip), %rsi    # 0x516013
leaq 0x2e1a00(%rip), %rdx    # 0x585d9b
leaq 0x2e1a0f(%rip), %rcx    # 0x585db1
leaq 0x2e0c07(%rip), %r8     # 0x584fb0
movl $0x810, %r9d            # imm = 0x810
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a43bd
movq 0x68(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x2a8760
movq 0x68(%rsp), %rdi
callq 0x2a8950
movq 0x68(%rsp), %rdi
callq 0x2a8b80
movq 0x68(%rsp), %rax
movq (%rax), %rdi
callq 0x11dee0
movq %rax, 0x20(%rsp)
movq 0x68(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rax
movq 0x48(%rax), %rax
subq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x68(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x81370
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %r8
movq %rax, %r9
movq 0x50(%rsp), %rbx
movq 0x48(%rsp), %r11
movq 0x68(%rsp), %r10
addq $0x18, %r10
movq 0x60(%rsp), %rax
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0xae750
movl %eax, 0x5c(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x2e0b13(%rip), %rsi    # 0x584fb0
movl $0x819, %edx            # imm = 0x819
callq 0xe88c0
movq 0x48(%rsp), %rdi
callq 0x11fd20
movl 0x5c(%rsp), %eax
addq $0x70, %rsp
popq %rbx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x38(%rsp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x2a4b89
movl $0x0, 0x44(%rsp)
jmp 0x2a4ced
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %r8
leaq 0x282003(%rip), %rsi    # 0x526b9d
leaq 0x2e040f(%rip), %rdx    # 0x584fb0
movl $0x89e, %ecx            # imm = 0x89E
callq 0xd8df0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2a4bc0
movl $0xffffffff, 0x1c(%rsp) # imm = 0xFFFFFFFF
cmpl $0x0, 0x1c(%rsp)
jne 0x2a4ce5
movq 0x28(%rsp), %rcx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq (%rcx), %rax
cmpq $0x0, %rax
jne 0x2a4c17
movq 0x38(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x10(%rsp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x126d30
movq 0x38(%rsp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2a4c20
movq $0x0, 0x8(%rsp)
movq $0x1, (%rsp)
movq (%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x2a4cdb
movq 0x28(%rsp), %rax
movq (%rsp), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq (%rsp), %rcx
andq $0x3f, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x2a4cc8
movq 0x38(%rsp), %rax
movq 0x38(%rax), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x38(%rsp), %rcx
movq 0x38(%rcx), %rcx
movq (%rsp), %rdx
subq $0x1, %rdx
subq (%rcx,%rdx,8), %rax
subq $0x1, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
leaq 0x8(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x126d30
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2a4cca
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x2a4c28
movq 0x10(%rsp), %rdi
callq 0xd9390
movl 0x1c(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x81370
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
ja 0x2a5031
movq 0x396fa0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x271009(%rip), %rsi    # 0x516013
leaq 0x2e0582(%rip), %rdx    # 0x585593
leaq 0x2e0587(%rip), %rcx    # 0x58559f
leaq 0x2dff91(%rip), %r8     # 0x584fb0
movl $0x8f6, %r9d            # imm = 0x8F6
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a5033
movq 0x20(%rsp), %rdi
callq 0x2a8cc0
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x2a50b1
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x80b60
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdx
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x8(%rsp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x2a8dc0
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2a504b
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2a9170
movq 0x10(%rsp), %rdi
callq 0x2a8d80
addq $0x38, %rsp
retq
nop