LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x1e4997
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x1e4926
movq %rax, %r14
xorl %r15d, %r15d
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0xd47ba
movq %rax, %r12
movq 0x8(%rax), %rdi
callq 0x121b03
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x1e491e
callq 0x121b03
incq %r15
cmpq %r15, %r14
jne 0x1e48f7
movq 0x8(%rbx), %rdi
callq 0xd4ef4
movq 0x98(%rbx), %rdi
callq 0xe9362
movq 0xa0(%rbx), %rdi
callq 0x101f02
movq 0xc0(%rbx), %rdi
callq 0x329817
movq 0x10(%rbx), %rdi
leaq 0x1d6e96(%rip), %r14    # 0x3bb7f4
movq %r14, %rsi
movl $0x87, %edx
callq 0x109670
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x88, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x89, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1e4a6b
movq %rdx, %r15
testq %rdx, %rdx
je 0x1e4a70
movq %r9, %r12
movq %r8, %r13
movq %rcx, %r14
movq %rdi, %rbx
movb %sil, 0x8(%rsp)
movq %r15, %rdi
callq 0x120e13
movq %rax, 0x10(%rsp)
testq %r14, %r14
je 0x1e49f9
movq %r14, %rdi
callq 0x120e13
jmp 0x1e49fb
xorl %eax, %eax
movq %rax, 0x18(%rsp)
movq %r13, 0x20(%rsp)
movq %r12, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rsp)
movq $0x0, 0x48(%rsp)
movq %r15, %rdi
callq 0x120d23
movq %rax, %rdi
callq 0x104631
movq %rax, 0x30(%rsp)
testq %r14, %r14
je 0x1e4a4a
movq %r14, %rdi
callq 0x120d23
movq %rax, %rdi
callq 0x104631
addq %rax, 0x30(%rsp)
movq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movl $0x48, %edx
callq 0xd49ce
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x74bdd
callq 0x74ba4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_decode_sequence
static void gt_reads2twobit_seek_sequence(const GtReads2Twobit *r2t,
    GtUword seqnum, GtUword *seqlen, GtTwobitencoding *firstcode,
    GtUword *charsinfirstcode, GtTwobitencoding **nextcode_ptr)
{
  GtUword pos;
  *seqlen = r2t->seqlen_eqlen;
  if (*seqlen == 0)
  {
    if (seqnum == 0)
    {
      *seqlen = r2t->seppos[0] + 1UL;
      pos = 0;
    }
    else
    {
      *seqlen = r2t->seppos[seqnum] - r2t->seppos[seqnum - 1UL];
      pos = r2t->seppos[seqnum - 1UL] + 1UL;
    }
  }
  else
  {
    pos = seqnum * (*seqlen);
  }
  *nextcode_ptr = r2t->twobitencoding + GT_DIVBYUNITSIN2BITENC(pos);
  *charsinfirstcode = GT_UNITSIN2BITENC - GT_MODBYUNITSIN2BITENC(pos);
  *firstcode = *((*nextcode_ptr)++);
}

// Assembly:
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x1e66b2
imulq %rax, %rsi
movq %rsi, %rcx
jmp 0x1e66d4
movq 0x38(%rdi), %rax
testq %rsi, %rsi
je 0x1e66cc
movq -0x8(%rax,%rsi,8), %rcx
movq (%rax,%rsi,8), %rax
subq %rcx, %rax
incq %rcx
jmp 0x1e66d4
movq (%rax), %rax
incq %rax
xorl %ecx, %ecx
movq 0x10(%rdi), %rdi
movq %rcx, %r8
shrq $0x5, %r8
movq (%rdi,%r8,8), %rsi
movw $0xa3e, (%rdx)          # imm = 0xA3E
addq $0x2, %rdx
decq %rax
je 0x1e673d
leaq (%rdi,%r8,8), %rdi
addq $0x8, %rdi
andl $0x1f, %ecx
movl $0x20, %r9d
subq %rcx, %r9
leaq 0x180c70(%rip), %r8     # 0x36737c
testq %r9, %r9
jne 0x1e671e
movq (%rdi), %rsi
addq $0x8, %rdi
movl $0x20, %r9d
decq %r9
leal (%r9,%r9), %ecx
movq %rsi, %r10
shrq %cl, %r10
andl $0x3, %r10d
movb (%r10,%r8), %cl
movb %cl, (%rdx)
incq %rdx
decq %rax
jne 0x1e670c
movw $0xa, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1b6040(%rip), %rsi    # 0x39ca31
movq %rax, %rdi
movq %rcx, %rdx
callq 0x103957
testq %rax, %rax
je 0x1e6a25
movq %rax, %r12
movq 0x40(%r15), %rcx
xorl %r14d, %r14d
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %rbx, %r8
callq 0x1e6743
movq %r12, %rdi
callq 0x1040fc
jmp 0x1e6a2b
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_mark_mates_of_contained
GtUword gt_reads2twobit_mark_mates_of_contained(GtReads2Twobit *r2t,
    GtBitsequence *list)
{
  GtUword libnum, noflibs = gt_array_size(r2t->collection), nofmarked = 0;
  for (libnum = 0; libnum < noflibs; libnum++)
  {
    GtReadsLibraryInfo *rli = gt_array_get(r2t->collection, libnum);
    if (rli->paired && rli->nofseqs > 0)
    {
      GtUword seqnum,
                    last_seqnum = rli->first_seqnum + rli->nofseqs - 1UL;
      gt_assert(rli->nofseqs % 2 == 0);
      for (seqnum = rli->first_seqnum; seqnum < last_seqnum; seqnum += 2UL)
      {
        if (GT_ISIBITSET(list, seqnum) && !GT_ISIBITSET(list, seqnum + 1))
        {
          GT_SETIBIT(list, seqnum + 1UL);
          nofmarked++;
        }
        else if (GT_ISIBITSET(list, seqnum + 1UL) &&
            !GT_ISIBITSET(list, seqnum))
        {
          GT_SETIBIT(list, seqnum);
          nofmarked++;
        }
      }
    }
  }
  return nofmarked;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x1e6d2d
movq %rax, %r15
movabsq $-0x8000000000000000, %rbp # imm = 0x8000000000000000
xorl %r13d, %r13d
xorl %r12d, %r12d
movq 0x8(%r14), %rdi
movq %r13, %rsi
callq 0xd47ba
cmpb $0x1, (%rax)
jne 0x1e6d1f
movq 0x40(%rax), %rcx
testq %rcx, %rcx
je 0x1e6d1f
testb $0x1, %cl
jne 0x1e6d42
movq 0x38(%rax), %rax
leaq (%rcx,%rax), %rdx
decq %rdx
cmpq %rdx, %rax
jae 0x1e6d1f
movq %rax, %rsi
shrq $0x6, %rsi
movq (%rbx,%rsi,8), %rdi
movq %rbp, %r8
movl %eax, %ecx
shrq %cl, %r8
testq %r8, %rdi
je 0x1e6ced
leaq 0x1(%rax), %rcx
movq %rcx, %r9
shrq $0x6, %r9
movq (%rbx,%r9,8), %r10
movq %rbp, %r11
shrq %cl, %r11
testq %r11, %r10
je 0x1e6d0f
leaq 0x1(%rax), %rcx
movq %rbp, %r9
shrq %cl, %r9
testq %r8, %rdi
jne 0x1e6d19
shrq $0x6, %rcx
andq (%rbx,%rcx,8), %r9
je 0x1e6d19
orq %r8, %rdi
movq %rdi, (%rbx,%rsi,8)
jmp 0x1e6d16
orq %r11, %r10
movq %r10, (%rbx,%r9,8)
incq %r12
addq $0x2, %rax
jmp 0x1e6cb6
incq %r13
cmpq %r15, %r13
jne 0x1e6c84
jmp 0x1e6d30
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x75018
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_sort
void gt_reads2twobit_sort(GtReads2Twobit *r2t, GtCompareWithData cmp,
    void *cmp_data)
{
  GtTwobitencoding *tbe, *tbe_next, offset;
  GtUword i, *order;

  gt_assert(r2t != NULL);

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

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x1e7843
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
shlq $0x3, %rdi
leaq 0x1d40f4(%rip), %rsi    # 0x3bb7f4
movl $0x86e, %edx            # imm = 0x86E
callq 0x1092b2
movq %rax, %r14
movq 0x40(%rbx), %rsi
testq %rsi, %rsi
je 0x1e7728
xorl %eax, %eax
movq %rax, (%r14,%rax,8)
incq %rax
movq 0x40(%rbx), %rsi
cmpq %rsi, %rax
jb 0x1e7718
movl $0x8, %edx
movq %r14, %rdi
movq %r12, %rcx
movq %r15, %r8
callq 0x1118d4
movq 0x60(%rbx), %rax
shrq $0x5, %rax
leaq 0x2(,%rax,8), %rdi
leaq 0x1d40a2(%rip), %rsi    # 0x3bb7f4
movl $0x875, %edx            # imm = 0x875
callq 0x1092b2
movq %rax, %r15
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x40(%rbx)
je 0x1e77db
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movq %r15, %rax
movq (%r14,%r13,8), %rsi
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %rax, %rdx
movq %r12, %r8
callq 0x1e6a3a
cmpq $0x0, 0x48(%rbx)
jne 0x1e77d2
movq (%r14,%r13,8), %rdx
testq %rdx, %rdx
je 0x1e77b3
movq 0x38(%rbx), %rsi
movq -0x8(%rsi,%rdx,8), %rcx
notq %rcx
addq (%rsi,%rdx,8), %rcx
jmp 0x1e77ba
movq 0x38(%rbx), %rcx
movq (%rcx), %rcx
movq %rcx, (%r14,%r13,8)
testq %r13, %r13
je 0x1e77d2
movq -0x8(%r14,%r13,8), %rdx
addq %rdx, %rcx
incq %rcx
movq %rcx, (%r14,%r13,8)
incq %r13
cmpq 0x40(%rbx), %r13
jb 0x1e777a
movq 0x10(%rbx), %rdi
leaq 0x1d400e(%rip), %rsi    # 0x3bb7f4
movl $0x888, %edx            # imm = 0x888
callq 0x109670
movq %r15, 0x10(%rbx)
cmpq $0x0, 0x48(%rbx)
je 0x1e781c
leaq 0x1d3ff2(%rip), %rsi    # 0x3bb7f4
movq %r14, %rdi
movl $0x892, %edx            # imm = 0x892
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x109670
movq 0x38(%rbx), %rdi
leaq 0x1d3fcd(%rip), %rsi    # 0x3bb7f4
movl $0x88d, %edx            # imm = 0x88D
callq 0x109670
movq %r14, 0x38(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x753e1
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_write_seppos
int gt_reads2twobit_write_seppos(GtReads2Twobit *r2t, char* path,
    GtBitsequence *skip, GtError *err)
{
  int had_err = 0;
  FILE *file;
  GtUword pos, seqnum;
  if (r2t->seppos == NULL)
    return 0;
  file = gt_fa_fopen(path, "wb", err);
  if (file == NULL)
    had_err = -1;
  if (!had_err)
  {
    if (!GT_ISIBITSET(skip, 0))
    {
      gt_xfwrite(r2t->seppos, sizeof (r2t->seppos), (size_t)1, file);
      pos = r2t->seppos[0] + 1UL;
    }
    else
      pos = 0;
    for (seqnum = 1UL; seqnum < r2t->nofseqs; seqnum++)
    {
      if (!GT_ISIBITSET(skip, seqnum))
      {
        pos += r2t->seppos[seqnum] - r2t->seppos[seqnum - 1UL] - 1UL;
        gt_xfwrite(&pos, sizeof (pos), (size_t)1, file);
        pos++;
      }
    }
    gt_fa_fclose(file);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x38(%rdi)
je 0x1e78c0
movq %rcx, %r8
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x1772a3(%rip), %rax    # 0x35eb0d
leaq 0x1d3f83(%rip), %rdx    # 0x3bb7f4
movq %rsi, %rdi
movq %rax, %rsi
movl $0x89e, %ecx            # imm = 0x89E
callq 0x101c23
xorl %ebp, %ebp
testq %rax, %rax
sete %bpl
negl %ebp
testq %rax, %rax
je 0x1e792f
movq %rax, %r15
cmpq $0x0, (%rbx)
js 0x1e78c4
movq 0x38(%r14), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x125658
movq 0x38(%r14), %rax
movq (%rax), %rax
incq %rax
jmp 0x1e78c6
xorl %ebp, %ebp
jmp 0x1e792f
xorl %eax, %eax
movq %rax, (%rsp)
cmpq $0x2, 0x40(%r14)
jb 0x1e7927
movl $0x1, %r12d
movq %rsp, %r13
movq %r12, %rax
shrq $0x6, %rax
movq (%rbx,%rax,8), %rax
movl %r12d, %ecx
shlq %cl, %rax
shrq $0x3f, %rax
jne 0x1e791e
movq 0x38(%r14), %rax
movq -0x8(%rax,%r12,8), %rcx
notq %rcx
addq (%rax,%r12,8), %rcx
addq %rcx, (%rsp)
movl $0x8, %esi
movl $0x1, %edx
movq %r13, %rdi
movq %r15, %rcx
callq 0x125658
incq (%rsp)
incq %r12
cmpq 0x40(%r14), %r12
jb 0x1e78da
movq %r15, %rdi
callq 0x101e80
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd4a9a
testq %rax, %rax
je 0x1e7a46
movq %rax, %r15
movq %rax, %rdi
callq 0x1e8c0c
movq %rax, %r12
xorl %r13d, %r13d
movq 0x8(%r14), %rdi
movq %r13, %rsi
callq 0xd47ba
movq 0x38(%rax), %rsi
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rcx
movzbl (%rax), %r8d
movq %r12, %rdi
callq 0x1e8caf
incq %r13
cmpq %r13, %r15
jne 0x1e79fe
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1e8d83
movq %r12, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1e8c73
callq 0x7561b
// File: /workspace/github_c_makefile_star2_O1/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 0x1e7a68
movq 0xc0(%rdi), %rdi
testq %rdi, %rdi
je 0x1e7a6d
testq %rsi, %rsi
je 0x1e7a72
popq %rax
jmp 0x329af9
callq 0x756c6
callq 0x7568d
callq 0x75654
// File: /workspace/github_c_makefile_star2_O1/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 0x1e7add
movl %esi, %ebp
movq %rdi, %rbx
movb %bpl, 0xa8(%rdi)
testb %dl, %dl
je 0x1e7ab7
callq 0xe9148
movq %rax, 0x98(%rbx)
testb %bpl, %bpl
je 0x1e7ad6
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe91c8
leaq 0x1d3d36(%rip), %rdx    # 0x3bb7f4
xorl %edi, %edi
movl $0x1, %esi
movl $0x91e, %ecx            # imm = 0x91E
callq 0x1021c2
movq %rax, 0xa0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x756ff
// File: /workspace/github_c_makefile_star2_O1/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 0x1e7e60
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x17f00
testl %eax, %eax
je 0x1e7e49
movq %r15, %rdi
callq 0x120d23
movq %rax, %r15
callq 0x17060
movl (%rax), %edi
callq 0x17240
leaq 0x1d4469(%rip), %rsi    # 0x3bc29b
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x1e7e4b
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x101e80
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x75939
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_clip_str
static void gt_reads2twobit_clip_str(GtStr *str)
{
  GtUword i;
  for (i = 0; i < gt_str_length(str); i++)
  {
    if (isspace(gt_str_get(str)[i]))
    {
      gt_str_get(str)[i] = '\n';
      gt_str_set_length(str, i+1);
      return;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x120d4c
testq %rax, %rax
je 0x1e8352
xorl %r14d, %r14d
callq 0x17870
movq %rax, %r15
movq (%r15), %r12
movq %rbx, %rdi
callq 0x120d23
movsbq (%rax,%r14), %rax
testb $0x20, 0x1(%r12,%rax,2)
jne 0x1e835e
incq %r14
movq %rbx, %rdi
callq 0x120d4c
cmpq %rax, %r14
jb 0x1e832a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x120d23
movb $0xa, (%rax,%r14)
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x120d59
// File: /workspace/github_c_makefile_star2_O1/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 0x1e8403
cmpq $0x0, 0x8d0(%rbx)
jne 0x1e8403
movq 0x8e8(%rbx), %rsi
leaq 0x1d3c69(%rip), %rdi    # 0x3bc03c
xorl %eax, %eax
callq 0x108e02
movq 0x908(%rbx), %rdi
leaq 0x1d340c(%rip), %rsi    # 0x3bb7f4
movl $0x224, %edx            # imm = 0x224
callq 0x109670
movb $0x0, 0x8f0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x908(%rbx)
leaq 0x820(%rbx), %rdi
addq $0x888, %rbx            # imm = 0x888
movl $0xd, %ecx
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_apply_quality_filter
static void gt_reads2twobit_apply_quality_filter(
    GtReads2TwobitEncodeState *state, const char *qbuf, GtUword nofq)
{
  GtUword i, low = 0;
  for (i = 0; i < nofq; i++)
    if (qbuf[i] <= state->lowqual)
      low++;
  if (low > state->maxlow)
    gt_reads2twobit_switch_to_invalid_mode(state);
}

// Assembly:
testq %rdx, %rdx
je 0x1e8446
movb 0x930(%rdi), %cl
xorl %eax, %eax
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpb %cl, (%rsi,%r8)
setle %r9b
addq %r9, %rax
incq %r8
cmpq %r8, %rdx
jne 0x1e842e
jmp 0x1e8448
xorl %eax, %eax
cmpq 0x958(%rdi), %rax
ja 0x1e8384
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rdi, %rbx
movq 0x908(%rdi), %rdi
testq %rdi, %rdi
je 0x1e84cb
movq %rsi, %r14
movq 0x910(%rbx), %rax
cmpq %rax, 0x868(%rbx)
jne 0x1e84aa
leaq 0x4000(%rax), %rcx
movq %rcx, 0x910(%rbx)
leaq 0x20000(,%rax,8), %rsi
leaq 0x1d335b(%rip), %rdx    # 0x3bb7f4
movl $0x1a0, %ecx            # imm = 0x1A0
callq 0x1094e6
movq %rax, 0x908(%rbx)
movq 0x868(%rbx), %rax
movq 0x908(%rbx), %rcx
movq %r14, (%rcx,%rax,8)
incq 0x868(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x75a8f
// File: /workspace/github_c_makefile_star2_O1/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 0xd4a9a
movq %rax, %r15
callq 0x121b54
movq %rbx, 0x10(%rsp)
movq %rax, (%rbx)
testq %r14, %r14
je 0x1e8a0f
movq %r15, %rdi
shlq $0x4, %rdi
leaq 0x1d2df2(%rip), %rsi    # 0x3bb7f4
movl $0x5be, %edx            # imm = 0x5BE
callq 0x1092b2
movq %rax, (%r14)
testq %r15, %r15
je 0x1e8b07
leaq -0x1(%r15), %rax
movq %rax, 0x8(%rsp)
movl $0x8, %r12d
xorl %r13d, %r13d
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq %r13, %rsi
callq 0xd47ba
movq %rax, %rbp
testq %r14, %r14
je 0x1e8a74
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 0x1e8a6b
addq $-0x2, %rcx
movq %rcx, (%rax,%r12)
movq 0x28(%rbp), %rcx
movq %rcx, -0x8(%rax,%r12)
movq 0x8(%rbp), %rdi
callq 0x120e13
movq %rax, %rbx
cmpq $0x0, 0x10(%rbp)
je 0x1e8aa0
movq %rbx, %rdi
movl $0x3a, %esi
callq 0x120ba5
movq 0x10(%rbp), %rsi
movq %rbx, %rdi
callq 0x120a43
cmpb $0x1, (%rbp)
jne 0x1e8adf
movq %rbx, %rdi
movl $0x3a, %esi
callq 0x120ba5
movq 0x18(%rbp), %rsi
movq %rbx, %rdi
callq 0x120af4
cmpq $0x0, 0x20(%rbp)
je 0x1e8adf
movq %rbx, %rdi
movl $0x2c, %esi
callq 0x120ba5
movq 0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x120af4
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x121cc0
movq %rbx, %rdi
callq 0x121b03
incq %r13
addq $0x10, %r12
cmpq %r13, %r15
jne 0x1e8a2a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_set_separators_to_less_frequent_char
static void gt_reads2twobit_set_separators_to_less_frequent_char(
    GtReads2Twobit *r2t)
{
  GtUword seqnum, pos, codenum, posincode;
  GtTwobitencoding sepcode, code, mask, shift;
  sepcode = gt_reads2twobit_less_frequent_char(r2t);
  if (sepcode != r2t->current_sepcode && r2t->nofseqs > 1UL)
  {
    GtUword from, to;
    gt_log_log("changing sepcode from "GT_WU" to "GT_WU"",
                (GtUword) r2t->current_sepcode,
                (GtUword) sepcode);
    from = r2t->seqlen_eqlen > 0 ? 1UL : 0;
    to = r2t->seqlen_eqlen > 0 ? r2t->nofseqs - 1UL : r2t->nofseqs - 2UL;
    for (seqnum = from; seqnum <= to; seqnum++)
    {
      pos = r2t->seqlen_eqlen > 0
        ? seqnum * r2t->seqlen_eqlen - 1UL
        : r2t->seppos[seqnum];
      codenum = GT_DIVBYUNITSIN2BITENC(pos);
      posincode = GT_MODBYUNITSIN2BITENC(pos);
      code = r2t->twobitencoding[codenum];
      shift = (GtTwobitencoding)GT_MULT2(GT_UNITSIN2BITENC - 1UL - posincode);
      mask = ~((GtTwobitencoding)(3UL) << shift);
      gt_assert((code & ~mask) >> shift ==
          (GtTwobitencoding)r2t->current_sepcode);
      code = (code & mask) | ((GtTwobitencoding)sepcode << shift);
      r2t->twobitencoding[codenum] = code;
    }
    r2t->current_sepcode = sepcode;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
xorl %ecx, %ecx
xorl %r14d, %r14d
movq 0x20(%rbx,%rcx,8), %rdx
incq %rcx
cmpq %rax, %rdx
cmovbq %rcx, %r14
cmovbq %rdx, %rax
cmpq $0x3, %rcx
jne 0x1e8b26
leaq 0x1d3ad2(%rip), %rdi    # 0x3bc618
movq %r14, %rsi
xorl %eax, %eax
callq 0x108e02
movq 0x68(%rbx), %rsi
cmpq %rsi, %r14
je 0x1e8bfc
cmpq $0x2, 0x40(%rbx)
jb 0x1e8bfc
leaq 0x1d3a11(%rip), %rdi    # 0x3bc580
movq %r14, %rdx
xorl %eax, %eax
callq 0x108e02
xorl %eax, %eax
cmpq $0x0, 0x48(%rbx)
setne %al
movq 0x40(%rbx), %rcx
leaq (%rcx,%rax), %rdx
addq $-0x2, %rdx
cmpq %rax, %rdx
jb 0x1e8bf8
movq 0x10(%rbx), %rsi
movq 0x48(%rbx), %rcx
testq %rcx, %rcx
je 0x1e8baa
imulq %rax, %rcx
decq %rcx
jmp 0x1e8bb2
movq 0x38(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
movq %rcx, %rdi
shrq $0x5, %rdi
movq (%rsi,%rdi,8), %r8
notl %ecx
addl %ecx, %ecx
andl $0x3e, %ecx
movq %r8, %r9
shrq %cl, %r9
andl $0x3, %r9d
cmpq 0x68(%rbx), %r9
jne 0x1e8c04
movl $0x3, %r9d
shlq %cl, %r9
notq %r9
andq %r9, %r8
movq %r14, %r9
shlq %cl, %r9
orq %r8, %r9
movq %r9, (%rsi,%rdi,8)
incq %rax
cmpq %rdx, %rax
jbe 0x1e8b98
movq %r14, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x75c1e
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/reads_libraries_table.c
// Function: gt_reads_libraries_table_new
GtReadsLibrariesTable* gt_reads_libraries_table_new(GtUword noflibraries)
{
  GtReadsLibrariesTable *rlt;
  gt_assert(noflibraries > 0);
  rlt = gt_malloc(sizeof (*rlt));
  rlt->library = gt_malloc(sizeof (*rlt->library) * noflibraries);
  rlt->noflibraries = noflibraries;
  rlt->nextfreelibrary = 0;
  rlt->firstunpaired = GT_UNDEF_UWORD;
  return rlt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1e8c6e
movq %rdi, %rbx
leaq 0x1d3a6a(%rip), %r14    # 0x3bc68a
movl $0x20, %edi
movq %r14, %rsi
movl $0x29, %edx
callq 0x1092b2
movq %rax, %r15
leaq (,%rbx,8), %rax
leaq (%rax,%rax,2), %rdi
movq %r14, %rsi
movl $0x2a, %edx
callq 0x1092b2
movq %rax, 0x10(%r15)
movq %rbx, (%r15)
movq $0x0, 0x18(%r15)
movq $-0x1, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x75c57
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/reads_libraries_table.c
// Function: gt_reads_libraries_table_add
void gt_reads_libraries_table_add(GtReadsLibrariesTable *rlt,
    GtUword first_seqnum, GtUword insertlength,
    GtUword stdev, bool paired)
{
  gt_assert(rlt != NULL);
  gt_assert(rlt->nextfreelibrary < rlt->noflibraries);
  if (!paired)
  {
    if (rlt->firstunpaired == GT_UNDEF_UWORD)
    {
      rlt->firstunpaired = first_seqnum;
    }
    else
    {
      gt_assert(rlt->firstunpaired < first_seqnum);
    }
  }
  else
  {
    gt_assert(rlt->firstunpaired == GT_UNDEF_UWORD);
  }
  rlt->library[rlt->nextfreelibrary].first_seqnum = first_seqnum;
  rlt->library[rlt->nextfreelibrary].insertlength = insertlength;
  rlt->library[rlt->nextfreelibrary].stdev = stdev;
  rlt->nextfreelibrary++;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1e8d05
movq 0x18(%rdi), %rax
cmpq (%rdi), %rax
jae 0x1e8d0a
movq 0x8(%rdi), %r9
testb %r8b, %r8b
je 0x1e8cd2
cmpq $-0x1, %r9
je 0x1e8ce6
callq 0x75cfc
cmpq $-0x1, %r9
je 0x1e8ce2
cmpq %rsi, %r9
jb 0x1e8ce6
callq 0x75cc5
movq %rsi, 0x8(%rdi)
movq 0x10(%rdi), %r8
leaq (%rax,%rax,2), %r9
movq %rsi, (%r8,%r9,8)
movq %rdx, 0x8(%r8,%r9,8)
movq %rcx, 0x10(%r8,%r9,8)
incq %rax
movq %rax, 0x18(%rdi)
popq %rax
retq
callq 0x75d33
callq 0x75c8e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/reads_libraries_table.c
// Function: gt_reads_libraries_table_get_library
void gt_reads_libraries_table_get_library(GtReadsLibrariesTable *rlt,
    GtUword libnum, GtUword *first_seqnum,
    GtUword *insertlength, GtUword *stdev)
{
  gt_assert(rlt != NULL);
  gt_assert(libnum < rlt->noflibraries);
  if (first_seqnum != NULL)
    *first_seqnum = rlt->library[libnum].first_seqnum;
  if (insertlength != NULL)
    *insertlength = rlt->library[libnum].insertlength;
  if (stdev != NULL)
    *stdev = rlt->library[libnum].stdev;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1e8d5a
cmpq %rsi, (%rdi)
jbe 0x1e8d5f
testq %rdx, %rdx
je 0x1e8d2e
movq 0x10(%rdi), %rax
leaq (%rsi,%rsi,2), %r9
movq (%rax,%r9,8), %rax
movq %rax, (%rdx)
testq %rcx, %rcx
je 0x1e8d43
movq 0x10(%rdi), %rax
leaq (%rsi,%rsi,2), %rdx
movq 0x8(%rax,%rdx,8), %rax
movq %rax, (%rcx)
testq %r8, %r8
je 0x1e8d58
movq 0x10(%rdi), %rax
leaq (%rsi,%rsi,2), %rcx
movq 0x10(%rax,%rcx,8), %rax
movq %rax, (%r8)
popq %rax
retq
callq 0x75da1
callq 0x75d6a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/reads_libraries_table.c
// Function: gt_reads_libraries_table_save
void gt_reads_libraries_table_save(GtReadsLibrariesTable *rlt, FILE *rlt_fp)
{
  gt_assert(rlt != NULL);
  gt_assert(rlt_fp != NULL);
  gt_xfwrite(&(rlt->noflibraries), sizeof (rlt->noflibraries), (size_t)1,
      rlt_fp);
  gt_xfwrite(&(rlt->firstunpaired), sizeof (rlt->firstunpaired), (size_t)1,
      rlt_fp);
  gt_assert(rlt->noflibraries > 0);
  gt_xfwrite(&(rlt->library), sizeof (*(rlt->library)),
      (size_t)rlt->noflibraries, rlt_fp);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1e8de2
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1e8de7
movq %rdi, %r14
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x125658
leaq 0x8(%r14), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x125658
movq (%r14), %rdx
testq %rdx, %rdx
je 0x1e8dec
addq $0x10, %r14
movl $0x18, %esi
movq %r14, %rdi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x125658
callq 0x75eb4
callq 0x75e7d
callq 0x75e46
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/reads_libraries_table.c
// Function: gt_reads_libraries_table_load
GtReadsLibrariesTable* gt_reads_libraries_table_load(FILE *rlt_fp,
                                                     GtError *err)
{
  GtReadsLibrariesTable *rlt;
  size_t count;
  gt_assert(rlt_fp != NULL);
  gt_error_check(err);
  rlt = gt_malloc(sizeof (*rlt));
  count = fread(&(rlt->noflibraries), sizeof (rlt->noflibraries), (size_t)1,
      rlt_fp);
  if (count != (size_t)1 || rlt->noflibraries == 0)
  {
    gt_error_set(err, "libraries table: error by reading number of libraries");
    gt_free(rlt);
    return NULL;
  }
  else
  {
    rlt->library = gt_malloc(sizeof (*(rlt->library)) * rlt->noflibraries);
    count = fread(rlt->library, sizeof (*(rlt->library)),
        (size_t)rlt->noflibraries, rlt_fp);
    if (count != (size_t)rlt->noflibraries)
    {
      gt_error_set(err, "library table: "GT_WU" libraries expected, "GT_WU
                   " found", rlt->noflibraries, (GtUword)count);
      gt_free(rlt->library);
      gt_free(rlt);
      return NULL;
    }
  }
  return rlt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1e8ef7
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
je 0x1e8e1a
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x1e8efc
leaq 0x1d3869(%rip), %rsi    # 0x3bc68a
movl $0x20, %edi
movl $0x83, %edx
callq 0x1092b2
movq %rax, %rbx
movl $0x8, %esi
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rcx
callq 0x17b40
cmpq $0x1, %rax
jne 0x1e8ec7
movq (%rbx), %rax
testq %rax, %rax
je 0x1e8ec7
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdi
leaq 0x1d3825(%rip), %rsi    # 0x3bc68a
movl $0x8e, %edx
callq 0x1092b2
movq %rax, 0x10(%rbx)
movq (%rbx), %rdx
movl $0x18, %esi
movq %rax, %rdi
movq %r15, %rcx
callq 0x17b40
movq (%rbx), %rdx
cmpq %rdx, %rax
je 0x1e8eee
leaq 0x1d39c5(%rip), %rsi    # 0x3bc85a
movq %r14, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x1019cf
movq 0x10(%rbx), %rdi
leaq 0x1d37dd(%rip), %r14    # 0x3bc68a
movq %r14, %rsi
movl $0x95, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x96, %edx
jmp 0x1e8ee7
leaq 0x1d3956(%rip), %rsi    # 0x3bc824
movq %r14, %rdi
xorl %eax, %eax
callq 0x1019cf
leaq 0x1d37ab(%rip), %rsi    # 0x3bc68a
movq %rbx, %rdi
movl $0x89, %edx
callq 0x109670
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x75f24
callq 0x75eeb
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/rectangle-store.c
// Function: gt_rectangle_store_add
void gt_rectangle_store_add(GtArrayGtDiagbandseedRectangle *rectangle_store,
                            const GtDiagbandseedRectangle *key)
{
  GtDiagbandseedRectangle *ptr;

  GT_CHECKARRAYSPACE(rectangle_store,GtDiagbandseedRectangle,
                     256UL +
                     rectangle_store->allocatedGtDiagbandseedRectangle * 0.2);
  for (ptr = rectangle_store->spaceGtDiagbandseedRectangle +
             rectangle_store->nextfreeGtDiagbandseedRectangle;
       ptr > rectangle_store->spaceGtDiagbandseedRectangle &&
       gt_rectangle_cmp(ptr-1,key) > 0; ptr--)
  {
    *ptr = *(ptr-1);
  }
  *ptr = *key;
  rectangle_store->nextfreeGtDiagbandseedRectangle++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq %rax, 0x10(%rdi)
jb 0x1e8ff7
movq %rax, %xmm0
punpckldq 0x16794e(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x167956(%rip), %xmm0   # 0x3508f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x1c005a(%rip), %xmm1   # 0x3a9008
addsd 0x1c0042(%rip), %xmm1   # 0x3a8ff8
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x167d56(%rip), %xmm1   # 0x350d20
cvttsd2si %xmm1, %rsi
andq %rdx, %rsi
orq %rcx, %rsi
addq %rax, %rsi
movq %rsi, 0x8(%rbx)
movq (%rbx), %rdi
shlq $0x4, %rsi
leaq 0x1d38a1(%rip), %rdx    # 0x3bc88b
movl $0x3f, %ecx
callq 0x1094e6
movq %rax, (%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x1e904f
movq 0x10(%rbx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq (%rbx), %rax
jbe 0x1e9039
leaq -0x10(%rax), %rcx
movl 0x4(%r14), %edx
cmpl %edx, -0xc(%rax)
jb 0x1e9039
ja 0x1e9027
movl -0x4(%rax), %edx
cmpl 0xc(%r14), %edx
jbe 0x1e9039
movupd (%rcx), %xmm0
movupd %xmm0, (%rax)
movq %rcx, %rax
cmpq (%rbx), %rcx
ja 0x1e900f
jmp 0x1e903c
movq %rax, %rcx
movups (%r14), %xmm0
movups %xmm0, (%rcx)
incq 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x75f5d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/rectangle-store.c
// Function: gt_rectangle_previous_equal
const GtDiagbandseedRectangle *gt_rectangle_previous_equal(
                   const GtArrayGtDiagbandseedRectangle *rectangle_store,
                   const GtDiagbandseedRectangle *key)
{
  const GtDiagbandseedRectangle
    *midptr,
    *found = NULL,
    *leftptr = rectangle_store->spaceGtDiagbandseedRectangle,
    *rightptr = leftptr + rectangle_store->nextfreeGtDiagbandseedRectangle - 1;

  while (leftptr <= rightptr)
  {
    midptr = leftptr + (GtUword) (rightptr-leftptr)/2;
    if (gt_rectangle_cmp(key,midptr) < 0)
    {
      rightptr = midptr - 1;
    } else
    {
      /* Now key *midptr <= key. Hence *midptr satisfies the
         requirement, but it may not be the largest element <= key. */
      found = midptr;
      /* if *midptr < key, then there may be a larger element and
         therefore we search for it in the range
         midptr+1 .. rightptr. if *midptr == key, then we have found
         the largest element and we can stop the search. */
      if (gt_rectangle_cmp(key,midptr) > 0)
      {
        leftptr = midptr + 1;
      } else
      {
        break;
      }
    }
  }
  /* if found == NULL, then we have never seen an element <= key and
     so we return NULL. Otherwise found has been set in the else case
     of the loop */
  return found;
}

// Assembly:
movq (%rdi), %r8
movq 0x10(%rdi), %rax
shlq $0x4, %rax
leaq (%r8,%rax), %rdx
addq $-0x10, %rdx
cmpq %rdx, %r8
jbe 0x1e906f
xorl %eax, %eax
retq
movl 0x4(%rsi), %ecx
xorl %eax, %eax
movq %rdx, %r9
subq %r8, %r9
sarq %r9
andq $-0x10, %r9
leaq (%r8,%r9), %rdi
movl 0x4(%r8,%r9), %r9d
cmpl %r9d, %ecx
jae 0x1e9098
addq $-0x10, %rdi
movq %rdi, %rdx
jmp 0x1e90ba
ja 0x1e90a4
movl 0xc(%rsi), %r10d
cmpl 0xc(%rdi), %r10d
jb 0x1e908f
cmpl %r9d, %ecx
jb 0x1e90c0
ja 0x1e90b3
movl 0xc(%rsi), %eax
cmpl 0xc(%rdi), %eax
jbe 0x1e90c0
leaq 0x10(%rdi), %r8
movq %rdi, %rax
cmpq %rdx, %r8
jbe 0x1e9074
retq
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/rectangle-store.c
// Function: gt_rectangle_store_show
void gt_rectangle_store_show(const GtArrayGtDiagbandseedRectangle
                                *rectangle_store)
{
  const GtDiagbandseedRectangle *key;

  printf("# %s\n",__func__);
  for (key = rectangle_store->spaceGtDiagbandseedRectangle;
       key < rectangle_store->spaceGtDiagbandseedRectangle +
             rectangle_store->nextfreeGtDiagbandseedRectangle; key++)
  {
     printf("# %u %u %u %u\n",key->a_start,key->a_end,
                              key->b_start,key->b_end);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1d37da(%rip), %rdi    # 0x3bc8f6
leaq 0x1d37d9(%rip), %rsi    # 0x3bc8fc
xorl %eax, %eax
callq 0x17070
cmpq $0x0, 0x10(%rbx)
jle 0x1e9168
movq (%rbx), %r15
leaq 0x1d37d9(%rip), %r14    # 0x3bc914
movl (%r15), %esi
movl 0x4(%r15), %edx
movl 0x8(%r15), %ecx
movl 0xc(%r15), %r8d
movq %r14, %rdi
xorl %eax, %eax
callq 0x17070
addq $0x10, %r15
movq 0x10(%rbx), %rax
shlq $0x4, %rax
addq (%rbx), %rax
cmpq %rax, %r15
jb 0x1e913b
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/revcompl.c
// Function: gt_inplace_reverse_complement
void gt_inplace_reverse_complement(GtUchar *seq,GtUword len)
{
  GtUchar tmp, *frontptr, *backptr;

  for (frontptr = seq, backptr = seq + len - 1;
       frontptr <= backptr; frontptr++, backptr--)
  {
    tmp = *frontptr;
    gt_assert((GT_ISSPECIAL(*backptr) || *backptr < 4) &&
              (GT_ISSPECIAL(tmp) || tmp < 4));
    *frontptr = GT_ISSPECIAL(*backptr) ? *backptr : GT_COMPLEMENTBASE(*backptr);
    *backptr = GT_ISSPECIAL(tmp) ? tmp : GT_COMPLEMENTBASE(tmp);
  }
}

// Assembly:
pushq %rax
leaq (%rdi,%rsi), %rax
decq %rax
cmpq %rdi, %rax
jb 0x1e91d9
incq %rdi
movb -0x1(%rdi), %cl
movzbl (%rax), %edx
cmpl $0x4, %edx
jb 0x1e9196
leal -0xfe(%rdx), %esi
cmpl $0x1, %esi
ja 0x1e91db
leal 0x2(%rcx), %esi
cmpb $0x6, %sil
jae 0x1e91db
movb $0x3, %sil
subb %dl, %sil
cmpb $-0x2, %dl
movzbl %sil, %esi
movzbl %dl, %edx
cmovbl %esi, %edx
movb $0x3, %sil
subb %cl, %sil
cmpb $-0x2, %cl
movb %dl, -0x1(%rdi)
movzbl %sil, %edx
movzbl %cl, %ecx
cmovbl %edx, %ecx
movb %cl, (%rax)
decq %rax
leaq 0x1(%rdi), %rcx
cmpq %rax, %rdi
movq %rcx, %rdi
jbe 0x1e9180
popq %rax
retq
callq 0x75f94
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/revcompl.c
// Function: gt_inplace_reverse
void gt_inplace_reverse(GtUchar *seq,GtUword len)
{
  GtUchar tmp, *frontptr, *backptr;

  for (frontptr = seq, backptr = seq + len - 1;
       frontptr < backptr; frontptr++, backptr--)
  {
    tmp = *frontptr;
    *frontptr = *backptr;
    *backptr = tmp;
  }
}

// Assembly:
leaq (%rdi,%rsi), %rax
decq %rax
cmpq %rdi, %rax
jbe 0x1e9208
incq %rdi
movb -0x1(%rdi), %cl
movb (%rax), %dl
movb %dl, -0x1(%rdi)
movb %cl, (%rax)
decq %rax
leaq 0x1(%rdi), %rcx
cmpq %rax, %rdi
movq %rcx, %rdi
jb 0x1e91ef
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/revcompl.c
// Function: gt_inplace_complement
void gt_inplace_complement(GtUchar *seq,GtUword len)
{
  GtUchar *ptr;

  for (ptr = seq; ptr < seq + len; ptr++)
  {
    gt_assert(GT_ISSPECIAL(*ptr) || *ptr < 4);
    *ptr = GT_COMPLEMENTBASE(*ptr);
  }
}

// Assembly:
pushq %rax
testq %rsi, %rsi
jle 0x1e9233
addq %rdi, %rsi
movzbl (%rdi), %eax
cmpl $0x4, %eax
jb 0x1e9225
leal -0xfe(%rax), %ecx
cmpl $0x2, %ecx
jae 0x1e9235
movb $0x3, %cl
subb %al, %cl
movb %cl, (%rdi)
incq %rdi
cmpq %rsi, %rdi
jb 0x1e9212
popq %rax
retq
callq 0x75fcb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/revcompl.c
// Function: gt_copy_reverse_complement
void gt_copy_reverse_complement(GtUchar *dest,const GtUchar *src,
                               GtUword len)
{
  GtUchar *destptr;
  const GtUchar *srcptr;

  for (destptr = dest, srcptr = src + len - 1;
       destptr < dest + len; destptr++, srcptr--)
  {
    *destptr = GT_COMPLEMENTBASE(*srcptr);
  }
}

// Assembly:
testq %rdx, %rdx
jle 0x1e925b
leaq (%rdi,%rdx), %rax
leaq (%rdx,%rsi), %rcx
decq %rcx
movb $0x3, %dl
subb (%rcx), %dl
movb %dl, (%rdi)
incq %rdi
decq %rcx
cmpq %rax, %rdi
jb 0x1e924a
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed-extend-iter.c
// Function: gt_seedextend_match_iterator_delete
void gt_seedextend_match_iterator_delete(GtSeedextendMatchIterator *semi)
{
  if (semi == NULL)
  {
    return;
  }
  gt_str_delete(semi->ii);
  gt_str_delete(semi->qii);
  gt_encseq_delete(semi->aencseq);
  gt_encseq_delete(semi->bencseq);
  gt_str_delete(semi->line_buffer);
  gt_querymatch_delete(semi->querymatchptr);
  GT_FREEARRAY(&semi->querymatch_table,GtQuerymatch);
  gt_querymatchoutoptions_delete(semi->querymatchoutoptions);
  if (semi->inputfileptr != NULL)
  {
    fclose(semi->inputfileptr);
  }
  gt_querymatch_display_flag_delete(semi->in_display_flag);
  gt_str_delete(semi->saved_options_line);
  gt_free(semi);
}

// Assembly:
testq %rdi, %rdi
je 0x1e9321
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x121b03
movq 0x8(%rbx), %rdi
callq 0x121b03
movq 0x18(%rbx), %rdi
callq 0xee90c
movq 0x20(%rbx), %rdi
callq 0xee90c
movq 0x40(%rbx), %rdi
callq 0x121b03
movq 0x78(%rbx), %rdi
callq 0x1c3b35
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x1e92d4
leaq 0x88(%rbx), %r14
leaq 0x1d3735(%rip), %rsi    # 0x3bc9f0
movl $0x3b, %edx
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x80(%rbx), %rdi
callq 0x1c1ffa
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x1e92ee
callq 0x17800
movq 0xa0(%rbx), %rdi
callq 0x1c2da6
movq 0xa8(%rbx), %rdi
callq 0x121b03
leaq 0x1d36e3(%rip), %rsi    # 0x3bc9f0
movq %rbx, %rdi
movl $0x43, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed-extend-iter.c
// Function: gt_seedextend_match_iterator_next
GtQuerymatch *gt_seedextend_match_iterator_next(GtSeedextendMatchIterator *semi)
{
  bool selfmatch;

  gt_assert(semi != NULL);
  if (semi->currentmatchindex < GT_UWORD_MAX)
  {
    if (semi->currentmatchindex == semi->querymatch_table.nextfreeGtQuerymatch)
    {
      semi->currentmatch = NULL;
    } else
    {
      semi->currentmatch = gt_querymatch_table_get(&semi->querymatch_table,
                                                   semi->currentmatchindex++);
    }
    return semi->currentmatch;
  }
  selfmatch = semi->aencseq == semi->bencseq ? true : false;
  while (true)
  {
    const char *line_ptr;

    semi->linenum++;
    if (gt_str_read_next_line(semi->line_buffer, semi->inputfileptr) == EOF)
    {
      break;
    }
    line_ptr = gt_str_get(semi->line_buffer);
    gt_assert(line_ptr != NULL);
    if (line_ptr[0] != '\n' && line_ptr[0] != '#')
    {
      if (semi->in_display_flag == NULL)
      {
        return NULL;
      }
      gt_querymatch_read_line(semi->querymatchptr,
                              &semi->evalue,
                              &semi->bitscore,
                              line_ptr,
                              semi->in_display_flag,
                              selfmatch,
                              semi->aencseq,
                              semi->bencseq);
      gt_str_reset(semi->line_buffer);
      return semi->querymatchptr;
    }
    gt_str_reset(semi->line_buffer);
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x1e9a51
movq %rdi, %rbx
movq 0x68(%rdi), %rsi
cmpq $-0x1, %rsi
je 0x1e9961
cmpq 0x98(%rbx), %rsi
jne 0x1e9a1f
xorl %r12d, %r12d
jmp 0x1e9a36
movq 0x18(%rbx), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rbx), %rbp
leaq 0x58(%rbx), %r14
leaq 0x60(%rbx), %r15
incq 0x48(%rbx)
movq 0x40(%rbx), %rdi
movq 0x50(%rbx), %rsi
callq 0x120e88
cmpl $-0x1, %eax
je 0x1e99b9
movq 0x40(%rbx), %rdi
callq 0x120d23
testq %rax, %rax
je 0x1e9a4c
movzbl (%rax), %ecx
cmpl $0xa, %ecx
je 0x1e99ab
cmpl $0x23, %ecx
jne 0x1e99c1
movq 0x40(%rbx), %rdi
callq 0x120db4
xorl %r13d, %r13d
jmp 0x1e9a0b
movl $0x5, %r13d
jmp 0x1e9a0b
movq 0xa0(%rbx), %r8
movl $0x1, %r13d
testq %r8, %r8
je 0x1e9a08
xorl %r9d, %r9d
cmpq %rbp, 0x10(%rsp)
sete %r9b
movq 0x78(%rbx), %rdi
movups 0x18(%rbx), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x1c46ae
movq 0x40(%rbx), %rdi
callq 0x120db4
movq 0x78(%rbx), %r12
jmp 0x1e9a0b
xorl %r12d, %r12d
testl %r13d, %r13d
je 0x1e9976
cmpl $0x5, %r13d
jne 0x1e9a3a
xorl %r12d, %r12d
jmp 0x1e9a3a
leaq 0x88(%rbx), %rdi
leaq 0x1(%rsi), %rax
movq %rax, 0x68(%rbx)
callq 0x1c501d
movq %rax, %r12
movq %r12, 0x70(%rbx)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x7603b
callq 0x76074
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/seed-extend-iter.c
// Function: gt_seedextend_match_iterator_trace_delta
GtUword gt_seedextend_match_iterator_trace_delta(
                        const GtSeedextendMatchIterator *semi)
{
  gt_assert(semi != NULL);
  return (gt_querymatch_trace_display(semi->in_display_flag) ||
          gt_querymatch_dtrace_display(semi->in_display_flag))
           ? semi->trace_delta : 0;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1e9b21
movq %rdi, %rbx
movq 0xa0(%rdi), %rdi
callq 0x1c2b65
testb %al, %al
jne 0x1e9b14
movq 0xa0(%rbx), %rdi
callq 0x1c2b76
testb %al, %al
je 0x1e9b1d
movq 0xb0(%rbx), %rax
jmp 0x1e9b1f
xorl %eax, %eax
popq %rbx
retq
callq 0x7623c