LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/countingsort.c
// Function: gt_countingsort_unit_test
int gt_countingsort_unit_test(GtError *err)
{
  unsigned int numbers[]        = { 1, 2, 1, 2, 0 }, numbers_out[5],
               sorted_numbers[] = { 0, 1, 1, 2, 2 };
  int had_err = 0;
  gt_error_check(err);
  gt_countingsort(numbers_out, numbers, sizeof (unsigned int), 5,
                  gt_countingsort_get_max(numbers, sizeof (unsigned int), 5,
                                          NULL, get_int),
                  NULL,  get_int);
  gt_ensure(
         !memcmp(sorted_numbers, numbers_out, sizeof (unsigned int) * 5));
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movaps 0x283656(%rip), %xmm0   # 0x36bbb0
movaps %xmm0, 0x10(%rsp)
movl $0x0, 0x20(%rsp)
testq %rdi, %rdi
je 0xe857c
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xe863d
xorl %r15d, %r15d
xorl %r14d, %r14d
leaq (%rsp,%r15), %rdi
addq $0x10, %rdi
callq 0xe8642
cmpq %r14, %rax
cmovaq %rax, %r14
addq $0x4, %r15
cmpq $0x14, %r15
jne 0xe8582
leaq 0x9b(%rip), %rax        # 0xe8642
movq %rax, (%rsp)
xorl %r15d, %r15d
leaq 0x30(%rsp), %r12
leaq 0x10(%rsp), %rsi
movl $0x4, %edx
movl $0x5, %ecx
movq %r12, %rdi
movq %r14, %r8
xorl %r9d, %r9d
callq 0xe8388
movdqa (%r12), %xmm0
movd 0x10(%r12), %xmm1
pcmpeqb 0x2834cb(%rip), %xmm1   # 0x36bab0
pcmpeqb 0x2834d3(%rip), %xmm0   # 0x36bac0
pand %xmm1, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0xe862e
leaq 0x27ef37(%rip), %rsi    # 0x36753a
leaq 0x28355c(%rip), %rdx    # 0x36bb66
leaq 0x28353b(%rip), %rcx    # 0x36bb4c
leaq 0x283509(%rip), %r8     # 0x36bb21
movq %rbx, %rdi
movl $0x56, %r9d
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x26724
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/dyn_bittab.c
// Function: gt_dyn_bittab_set_bit
void gt_dyn_bittab_set_bit(GtDynBittab *b, GtUword bit)
{
  GtUword new_tabsize;
  gt_assert(b);
  /* make sure tab is large enough */
  if (bit >= b->num_of_bits) {
    if ((new_tabsize = determine_tabsize(bit + 1)) > b->tabsize) {
      b->tabptr = gt_realloc(b->tabptr, new_tabsize * sizeof (GtUword));
      memset(b->tabptr + b->tabsize, 0,
             (new_tabsize - b->tabsize) * sizeof (GtUword));
      b->tabsize = new_tabsize;
    }
    b->num_of_bits = bit + 1;
  }
  /* set bit */
  b->tabptr[(bit >> 3) / sizeof (GtUword)] |=
    1UL << (bit & (8UL * sizeof (GtUword) - 1));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xeb3cb
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x10(%rdi)
ja 0xeb3aa
leaq 0x1(%rbx), %r15
movq %rbx, %rax
shrq $0x6, %rax
incq %rax
cmpq $0x40, %r15
movl $0x1, %r12d
cmovaeq %rax, %r12
cmpq 0x8(%r14), %r12
jbe 0xeb3a6
movq (%r14), %rdi
leaq (,%r12,8), %rsi
leaq 0x2813f4(%rip), %rdx    # 0x36c770
movl $0x31, %ecx
callq 0x1094e6
movq %rax, (%r14)
movq 0x8(%r14), %rcx
leaq (%rax,%rcx,8), %rdi
movq %r12, %rdx
subq %rcx, %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x173a0
movq %r12, 0x8(%r14)
movq %r15, 0x10(%r14)
movl $0x1, %eax
movl %ebx, %ecx
shlq %cl, %rax
movq (%r14), %rcx
shrq $0x6, %rbx
orq %rax, (%rcx,%rbx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2765c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/dyn_bittab.c
// Function: gt_dyn_bittab_unset_bit
void gt_dyn_bittab_unset_bit(GtDynBittab *b, GtUword bit)
{
  gt_assert(b);
  if (bit < b->num_of_bits) {
    b->tabptr[(bit >> 3) / sizeof (GtUword)] &=
      ~(1UL << (bit & (8UL * sizeof (GtUword) - 1)));
  }
}

// Assembly:
testq %rdi, %rdi
je 0xeb3f3
cmpq %rsi, 0x10(%rdi)
jbe 0xeb3f2
movq $-0x2, %rax
movl %esi, %ecx
rolq %cl, %rax
movq (%rdi), %rcx
shrq $0x6, %rsi
andq %rax, (%rcx,%rsi,8)
retq
pushq %rax
callq 0x27693
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/dyn_bittab.c
// Function: gt_dyn_bittab_bit_is_set
bool gt_dyn_bittab_bit_is_set(const GtDynBittab *b, GtUword bit)
{
  gt_assert(b);
  if (bit < b->num_of_bits &&
      (b->tabptr[(bit >> 3) / sizeof (GtUword)] &
       1UL << (bit & (8UL * sizeof (GtUword) - 1)))) {
    return true;
  }
  return false;
}

// Assembly:
testq %rdi, %rdi
je 0xeb41e
cmpq %rsi, 0x10(%rdi)
jbe 0xeb41b
movq (%rdi), %rax
movq %rsi, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rcx
movb $0x1, %al
btq %rsi, %rcx
jae 0xeb41b
retq
xorl %eax, %eax
retq
pushq %rax
callq 0x276ca
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/dyn_bittab.c
// Function: gt_dyn_bittab_get_first_bitnum
GtUword gt_dyn_bittab_get_first_bitnum(const GtDynBittab *b)
{
  GtUword i, rval = GT_UNDEF_UWORD;
  gt_assert(b);
  for (i = 0; i < b->num_of_bits; i++)
    if (gt_dyn_bittab_bit_is_set(b, i)) {
      rval = i;
      break;
    }
  if (rval == GT_UNDEF_UWORD)
    return b->num_of_bits;
  return rval;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xeb467
movq 0x10(%rdi), %rax
movq $-0x1, %rcx
testq %rax, %rax
je 0xeb45d
movq (%rdi), %rsi
xorl %edx, %edx
movq %rdx, %rdi
shrq $0x6, %rdi
movq (%rsi,%rdi,8), %rdi
btq %rdx, %rdi
jb 0xeb45a
incq %rdx
cmpq %rdx, %rax
jne 0xeb43f
jmp 0xeb45d
movq %rdx, %rcx
cmpq $-0x1, %rcx
cmovneq %rcx, %rax
popq %rcx
retq
callq 0x27701
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/dyn_bittab.c
// Function: gt_dyn_bittab_get_next_bitnum
GtUword gt_dyn_bittab_get_next_bitnum(const GtDynBittab *b,
                                            GtUword curnum)
{
  GtUword i, rval = GT_UNDEF_UWORD;

  gt_assert(b);
  gt_assert(curnum < b->num_of_bits);
  for (i = curnum + 1; i < b->num_of_bits; i++)
    if (gt_dyn_bittab_bit_is_set(b, i)) {
      rval = i;
      break;
    }
  if (rval == GT_UNDEF_UWORD)
    return b->num_of_bits;
  return rval;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xeb4c4
movq 0x10(%rdi), %rax
cmpq %rsi, %rax
jbe 0xeb4c9
incq %rsi
cmpq %rsi, %rax
je 0xeb4b3
movq (%rdi), %rcx
movq %rsi, %rdx
shrq $0x6, %rdx
movq (%rcx,%rdx,8), %rdx
leaq 0x1(%rsi), %rcx
btq %rsi, %rdx
movq %rcx, %rsi
jae 0xeb48e
decq %rcx
jmp 0xeb4ba
movq $-0x1, %rcx
cmpq $-0x1, %rcx
cmovneq %rcx, %rax
popq %rcx
retq
callq 0x277a6
callq 0x2776f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fasta_reader.c
// Function: gt_fasta_reader_create
GtFastaReader* gt_fasta_reader_create(const GtFastaReaderClass *frc)
{
  GtFastaReader *fr;
  gt_assert(frc && frc->size);
  fr = gt_calloc(1, frc->size);
  fr->c_class = frc;
  return fr;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x103278
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x103278
leaq 0x27054a(%rip), %rdx    # 0x3737ae
movl $0x1, %edi
movl $0x1a, %ecx
callq 0x1093ef
movq %rbx, (%rax)
popq %rbx
retq
callq 0x30028
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fasta_reader.c
// Function: gt_fasta_reader_delete
void gt_fasta_reader_delete(GtFastaReader *fr)
{
  if (!fr) return;
  gt_assert(fr->c_class && fr->c_class->free);
  fr->c_class->free(fr);
  gt_free(fr);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1032b1
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x1032b3
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x1032b3
movq %rbx, %rdi
callq *%rax
leaq 0x27050b(%rip), %rsi    # 0x3737ae
movq %rbx, %rdi
movl $0x24, %edx
popq %rbx
jmp 0x109670
popq %rbx
retq
callq 0x3005f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fasta_reader.c
// Function: gt_fasta_reader_run
int gt_fasta_reader_run(GtFastaReader *fr,
                     GtFastaReaderProcDescription proc_description,
                     GtFastaReaderProcSequencePart proc_sequence_part,
                     GtFastaReaderProcSequenceLength proc_sequence_length,
                     void *data, GtError *err)
{
  gt_error_check(err);
  gt_assert(fr && fr->c_class && fr->c_class->run);
  return fr->c_class->run(fr, proc_description, proc_sequence_part,
                          proc_sequence_length, data, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
testq %r9, %r9
je 0x1032e6
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x103324
testq %rbp, %rbp
je 0x10331f
movq (%rbp), %rax
testq %rax, %rax
je 0x10331f
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x10331f
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
callq 0x300cd
callq 0x30096
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fasta_reader_rec.c
// Function: gt_fasta_reader_rec_new
GtFastaReader* gt_fasta_reader_rec_new(const GtStr *sequence_filename)
{
  GtFastaReader *fr = gt_fasta_reader_create(gt_fasta_reader_rec_class());
  GtFastaReaderRec *gt_fasta_reader_rec = gt_fasta_reader_rec_cast(fr);
  gt_fasta_reader_rec->seqio = gt_io_new(sequence_filename
                                   ? gt_str_get(sequence_filename) : NULL,
                                   "r");
  return fr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
leaq 0x3bb45e(%rip), %r14    # 0x4beb70
movq %r14, %rdi
callq 0x10324c
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x103329
movq %rax, %r14
testq %r15, %r15
je 0x10373d
movq %r15, %rdi
callq 0x120d23
movq %rax, %rdi
jmp 0x10373f
xorl %edi, %edi
leaq 0x260783(%rip), %rsi    # 0x363ec9
callq 0x108aa8
movq %rax, 0x8(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fastq.c
// Function: gt_fastq_show_entry
void gt_fastq_show_entry(const char *description, const char *sequence,
                         const char *qualities, GtUword sequence_length,
                         GtUword width, bool repeat_description,
                         GtFile *outfp)
{
  gt_assert(sequence);
  gt_assert(qualities);
  gt_fastq_show_buffer(GT_FASTQ_SEPARATOR_SEQ, description, sequence,
      sequence_length, width, outfp);
  gt_fastq_show_buffer(GT_FASTQ_SEPARATOR_QUAL,
      repeat_description ? description : NULL, qualities,
      sequence_length, width, outfp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1037be
movq %rdx, %r15
testq %rdx, %rdx
je 0x1037c3
movl %r9d, %ebp
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %rdx
movq %rdi, %r12
movq 0x40(%rsp), %r13
movl $0x40, %edi
movq %r12, %rsi
movq %r13, %r9
callq 0x1037c8
xorl %esi, %esi
testb %bpl, %bpl
cmovneq %r12, %rsi
movl $0x2b, %edi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movq %r13, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1037c8
callq 0x3032a
callq 0x302f3
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fastq.c
// Function: gt_fastq_show_buffer
static void gt_fastq_show_buffer(char separator, const char *description,
    const char *buffer, GtUword buffer_length, GtUword width,
    GtFile *outfp)
{
  GtUword i, current_length;
  gt_file_xfputc(separator, outfp);
  if (description != NULL)
    gt_file_xfputs(description, outfp);
  gt_file_xfputc('\n', outfp);
  for (i = 0, current_length = 0; i < buffer_length;
       i++, current_length++) {
    if (width && current_length == width) {
      gt_file_xfputc('\n', outfp);
      current_length = 0;
    }
    gt_file_xfputc(buffer[i], outfp);
  }
  gt_file_xfputc('\n', outfp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %r9, %rsi
callq 0x103f7f
testq %r13, %r13
je 0x1037fa
movq %r13, %rdi
movq %rbx, %rsi
callq 0x103fc4
movl $0xa, %edi
movq %rbx, %rsi
callq 0x103f7f
testq %r15, %r15
je 0x10384b
xorl %ebp, %ebp
xorl %r13d, %r13d
testq %r14, %r14
setne %al
cmpq %r14, %rbp
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x103833
movl $0xa, %edi
movq %rbx, %rsi
callq 0x103f7f
xorl %ebp, %ebp
movsbl (%r12,%r13), %edi
movq %rbx, %rsi
callq 0x103f7f
incq %r13
incq %rbp
cmpq %r13, %r15
jne 0x103811
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x103f7f
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/output_file.c
// Function: gt_output_file_info_register_options
void gt_output_file_info_register_options(GtOutputFileInfo *ofi,
                                          GtOptionParser *op, GtFile **outfp)
{
  GtOption *opto, *optgzip, *optbzip2, *optforce;
  gt_assert(outfp && ofi);
  ofi->outfp = outfp;
  /* register option -o */
  opto = gt_option_new_filename("o", "redirect output to specified file",
                                ofi->output_filename);
  gt_option_parser_add_option(op, opto);
  /* register option -gzip */
  optgzip = gt_option_new_bool("gzip", "write gzip compressed output file",
                               &ofi->gzip, false);
  gt_option_parser_add_option(op, optgzip);
  /* register option -bzip2 */
  optbzip2 = gt_option_new_bool("bzip2", "write bzip2 compressed output file",
                                &ofi->bzip2, false);
  gt_option_parser_add_option(op, optbzip2);
  /* register option -force */
  optforce = gt_option_new_bool(GT_FORCE_OPT_CSTR,
                                "force writing to output file",
                                &ofi->force, false);
  gt_option_parser_add_option(op, optforce);
  /* options -gzip and -bzip2 exclude each other */
  gt_option_exclude(optgzip, optbzip2);
  /* option implications */
  gt_option_imply(optgzip, opto);
  gt_option_imply(optbzip2, opto);
  gt_option_imply(optforce, opto);
  /* set hook function to determine <outfp> */
  gt_option_parser_register_hook(op, determine_outfp, ofi);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1100af
testq %rdx, %rdx
je 0x1100af
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x10(%rdi)
movq (%rdi), %rdx
leaq 0x276ef0(%rip), %rdi    # 0x386ec4
leaq 0x266a42(%rip), %rsi    # 0x376a1d
callq 0x10f9c6
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x8(%rbx), %rdx
leaq 0x266a46(%rip), %rdi    # 0x376a3f
leaq 0x266a44(%rip), %rsi    # 0x376a44
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x9(%rbx), %rdx
leaq 0x266a46(%rip), %rdi    # 0x376a66
leaq 0x266a45(%rip), %rsi    # 0x376a6c
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0xa(%rbx), %rdx
leaq 0x2648a4(%rip), %rdi    # 0x3748eb
leaq 0x24a056(%rip), %rsi    # 0x35a0a4
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %rbp
movq %r14, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r12, %rdi
movq %r13, %rsi
callq 0x10fd9f
movq %r12, %rdi
movq %r15, %rsi
callq 0x10fbff
movq %r13, %rdi
movq %r15, %rsi
callq 0x10fbff
movq %rbp, %rdi
movq %r15, %rsi
callq 0x10fbff
leaq 0x1e(%rip), %rsi        # 0x1100b4
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10cdb6
callq 0x33e28
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/output_file.c
// Function: gt_output_file_xopen_forcecheck
GtFile* gt_output_file_xopen_forcecheck(const char *path, const char *mode,
                                       bool force, GtError *err)
{
  gt_error_check(err);
  gt_assert(path && mode);
  if (!force && gt_file_exists(path)) {
    gt_error_set(err, "file \"%s\" exists already, use option -%s to overwrite",
                 path, GT_FORCE_OPT_CSTR);
    return NULL;
  }
  return gt_file_xopen(path, mode);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
testq %rcx, %rcx
je 0x11027b
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x1102d8
testq %rbx, %rbx
je 0x1102d3
testq %r15, %r15
je 0x1102d3
testb %bpl, %bpl
jne 0x1102be
movq %rbx, %rdi
callq 0x10415c
testb %al, %al
je 0x1102be
leaq 0x266812(%rip), %rsi    # 0x376aaf
leaq 0x264647(%rip), %rcx    # 0x3748eb
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1019cf
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x103c28
callq 0x33f72
callq 0x33f3b
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/quality.c
// Function: gt_quality_phred_to_errorprob
double gt_quality_phred_to_errorprob(double phredscore)
{
  double rval;
  rval = pow(10.0, (double)(-0.1*phredscore));
  gt_assert(rval >= 0.0 && rval <= 1.0);
  return rval;
}

// Assembly:
pushq %rax
movapd %xmm0, %xmm1
mulsd 0x2651ff(%rip), %xmm1   # 0x377470
movsd 0x24bd5f(%rip), %xmm0   # 0x35dfd8
callq 0x17d90
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x112298
movsd 0x23cf98(%rip), %xmm1   # 0x34f228
ucomisd %xmm0, %xmm1
jb 0x112298
popq %rax
retq
callq 0x347cc
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/quality.c
// Function: gt_quality_solexa_to_errorprob
double gt_quality_solexa_to_errorprob(double solexascore)
{
  double rval;
  rval = 1.0/(1.0 + pow(10.0, (solexascore/10.0)));
  gt_assert(rval >= 0.0 && rval <= 1.0);
  return rval;
}

// Assembly:
pushq %rax
movapd %xmm0, %xmm1
movsd 0x24bd2e(%rip), %xmm0   # 0x35dfd8
divsd %xmm0, %xmm1
callq 0x17d90
movapd %xmm0, %xmm1
movsd 0x23cf69(%rip), %xmm2   # 0x34f228
addsd %xmm2, %xmm1
movapd %xmm2, %xmm0
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1122dd
ucomisd %xmm0, %xmm2
jb 0x1122dd
popq %rax
retq
callq 0x34803
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/radix_sort.c
// Function: gt_radixsort_lsb_linear
void gt_radixsort_lsb_linear(GtUword *source,GtUword len)
{
  GtUword *dest = gt_malloc(sizeof (*dest) * len);

  gt_radixsort_lsb_linear_generic(sizeof (GtUword) - 1,
                                  source,
                                  dest,
                                  len);
  gt_free(dest);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
movq %rsi, %r15
movq %rdi, %rbx
leaq (,%rsi,8), %rdi
leaq 0x2634e2(%rip), %rsi    # 0x377d40
movq %rdi, (%rsp)
movl $0x8e, %edx
callq 0x1092b2
movq %rax, %r12
xorl %r14d, %r14d
leaq 0x10(%rsp), %rbp
movq %rax, 0x8(%rsp)
movq %r12, %r13
movq %rbx, %r12
leaq (,%r14,8), %rbx
movl $0x800, %edx            # imm = 0x800
movq %rbp, %rdi
xorl %esi, %esi
callq 0x173a0
leaq (%r12,%r15,8), %rax
movq %r12, %rdx
testq %r15, %r15
jle 0x1148bf
movq (%rdx), %rsi
movl %ebx, %ecx
shrq %cl, %rsi
movzbl %sil, %ecx
incq 0x10(%rsp,%rcx,8)
addq $0x8, %rdx
cmpq %rax, %rdx
jb 0x1148a5
movq 0x10(%rsp), %rcx
xorl %edx, %edx
addq 0x18(%rsp,%rdx), %rcx
movq %rcx, 0x18(%rsp,%rdx)
addq $0x8, %rdx
cmpq $0x7f0, %rdx            # imm = 0x7F0
jbe 0x1148c6
jmp 0x114900
movq (%rax), %rdx
movl %ebx, %ecx
shrq %cl, %rdx
movzbl %dl, %ecx
movq 0x10(%rsp,%rcx,8), %rdx
leaq -0x1(%rdx), %rsi
movq %rsi, 0x10(%rsp,%rcx,8)
movq (%rax), %rcx
movq %rcx, -0x8(%r13,%rdx,8)
addq $-0x8, %rax
cmpq %r12, %rax
jae 0x1148df
incq %r14
movq %r13, %rbx
cmpq $0x8, %r14
jne 0x11487c
movq 0x8(%rsp), %rbx
cmpq %rbx, %r13
jne 0x114937
cmpq %rbx, %r12
je 0x11495c
movq %r12, %rdi
movq %r13, %rsi
movq (%rsp), %rdx
callq 0x17660
leaq 0x263402(%rip), %rsi    # 0x377d40
movq %rbx, %rdi
movl $0x94, %edx
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x109670
callq 0x34bfb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/radix_sort.c
// Function: gt_radixsort_delete
void gt_radixsort_delete(GtRadixsortinfo *radixsortinfo)
{
  if (radixsortinfo != NULL)
  {
#ifdef GT_THREADS_ENABLED
    const unsigned int threads = GT_THREADS_JOBS;

    if (threads > 1U)
    {
      unsigned int t;
      gt_free(radixsortinfo->lentab);
      gt_free(radixsortinfo->endindexes);
      for (t = 0; t < threads; t++)
      {
        GT_STACK_DELETE(&radixsortinfo->threadinfo[t].stack);
        gt_radixbuffer_delete(radixsortinfo->threadinfo[t].rbuf);
      }
      gt_free(radixsortinfo->threadinfo);
    }
#endif
    if (radixsortinfo->maxlen > 0)
    {
      if (radixsortinfo->elemtype == GtRadixelemtypeGtUwordPair)
      {
        gt_free(radixsortinfo->sortspace.ulongpairptr);
      } else
      {
        if (radixsortinfo->elemtype == GtRadixelemtypeGtUword)
        {
          gt_free(radixsortinfo->sortspace.ulongptr);
        } else
        {
          if (radixsortinfo->elemtype == GtRadixelemtypeGtuint64keyPair)
          {
            gt_free(radixsortinfo->sortspace.uint64keypairptr);
          } else
          {
            gt_free(radixsortinfo->sortspace.flbaptr);
          }
        }
      }
    }
    gt_radixbuffer_delete(radixsortinfo->rbuf);
    GT_STACK_DELETE(&radixsortinfo->stack);
    gt_free(radixsortinfo);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x114d29
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3b0236(%rip), %rax    # 0x4c4e18
movl (%rax), %r15d
cmpq $0x2, %r15
jb 0x114c9a
movq 0x3060(%rbx), %rdi
leaq 0x263143(%rip), %r14    # 0x377d40
movq %r14, %rsi
movl $0x211, %edx            # imm = 0x211
callq 0x109670
movq 0x3068(%rbx), %rdi
movq %r14, %rsi
movl $0x212, %edx            # imm = 0x212
callq 0x109670
imulq $0x3048, %r15, %r15     # imm = 0x3048
xorl %r12d, %r12d
movq 0x3070(%rbx), %rax
movq (%rax,%r12), %rcx
cmpq 0x18(%rax,%r12), %rcx
jbe 0x114c62
movq 0x3028(%rax,%r12), %rdi
movq %r14, %rsi
movl $0x215, %edx            # imm = 0x215
callq 0x109670
movq 0x3070(%rbx), %rax
movq $0x0, 0x3028(%rax,%r12)
movq 0x3070(%rbx), %rax
movq 0x3038(%rax,%r12), %rdi
callq 0x114d2a
addq $0x3048, %r12           # imm = 0x3048
cmpq %r12, %r15
jne 0x114c28
movq 0x3070(%rbx), %rdi
leaq 0x2630b0(%rip), %rsi    # 0x377d40
movl $0x218, %edx            # imm = 0x218
callq 0x109670
cmpq $0x0, 0x3048(%rbx)
je 0x114cd2
movl 0x3050(%rbx), %eax
movq 0x3040(%rbx), %rdi
movl $0x22c, %edx            # imm = 0x22C
cmpq $0x2, %rax
ja 0x114cc6
leaq 0x263575(%rip), %rcx    # 0x378238
movl (%rcx,%rax,4), %edx
leaq 0x263073(%rip), %rsi    # 0x377d40
callq 0x109670
movq 0x3038(%rbx), %rdi
callq 0x114d2a
movq (%rbx), %rax
cmpq 0x18(%rbx), %rax
jbe 0x114d0a
movq 0x3028(%rbx), %rdi
leaq 0x26304b(%rip), %rsi    # 0x377d40
movl $0x232, %edx            # imm = 0x232
callq 0x109670
movq $0x0, 0x3028(%rbx)
leaq 0x26302f(%rip), %rsi    # 0x377d40
movq %rbx, %rdi
movl $0x233, %edx            # imm = 0x233
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/core/radix_sort.c
// Function: gt_radixbuffer_delete
static void gt_radixbuffer_delete(GtRadixbuffer *rbuf)
{
  gt_assert(rbuf != NULL);
  if (rbuf->elemtype == GtRadixelemtypeGtUwordPair)
  {
    gt_free(rbuf->values.ulongpairptr);
  } else
  {
    if (rbuf->elemtype == GtRadixelemtypeGtUword)
    {
      gt_free(rbuf->values.ulongptr);
    } else
    {
      if (rbuf->elemtype == GtRadixelemtypeGtuint64keyPair)
      {
        gt_free(rbuf->values.uint64keypairptr);
      } else
      {
        gt_free(rbuf->tmpvalue_ptr);
        gt_free(rbuf->tmpswap_ptr);
        gt_free(rbuf->values.flbaptr);
      }
    }
  }
  gt_free(rbuf->nextidx);
  gt_free(rbuf->startofbin);
  gt_free(rbuf->endofbin);
  gt_free(rbuf);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x114dda
movq %rdi, %rbx
movl 0x44(%rdi), %eax
cmpq $0x3, %rax
jae 0x114d4f
leaq 0x2634fa(%rip), %rcx    # 0x378244
movl (%rcx,%rax,4), %edx
jmp 0x114d7d
movq 0x60(%rbx), %rdi
leaq 0x262fe6(%rip), %r14    # 0x377d40
movq %r14, %rsi
movl $0x159, %edx            # imm = 0x159
callq 0x109670
movq 0x68(%rbx), %rdi
movq %r14, %rsi
movl $0x15a, %edx            # imm = 0x15A
callq 0x109670
movl $0x15b, %edx            # imm = 0x15B
movq 0x48(%rbx), %rdi
leaq 0x262fb8(%rip), %r14    # 0x377d40
movq %r14, %rsi
callq 0x109670
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x15f, %edx            # imm = 0x15F
callq 0x109670
movq 0x28(%rbx), %rdi
movq %r14, %rsi
movl $0x160, %edx            # imm = 0x160
callq 0x109670
movq 0x30(%rbx), %rdi
movq %r14, %rsi
movl $0x161, %edx            # imm = 0x161
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x162, %edx            # imm = 0x162
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
callq 0x34c6d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/radix_sort.c
// Function: gt_radixsort_inplace_ulong
void gt_radixsort_inplace_ulong(GtUword *source, GtUword len)
{
  GtRadixvalues radixvalues;
  GtRadixsortinfo *radixsortinfo;

  radixsortinfo = gt_radixsort_new_ulong(0);
  radixvalues.ulongptr = source;
  gt_radixsort_inplace(radixsortinfo,&radixvalues,len);
  gt_radixsort_delete(radixsortinfo);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
xorl %esi, %esi
callq 0x114968
movq %rax, %r15
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %rax, %rdi
movq %rbx, %rdx
callq 0x114e4a
movq %r15, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x114bc7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/radix_sort.c
// Function: gt_radixsort_inplace_GtUwordPair
void gt_radixsort_inplace_GtUwordPair(GtUwordPair *source, GtUword len)
{
  GtRadixvalues radixvalues;
  GtRadixsortinfo *radixsortinfo;

  radixsortinfo = gt_radixsort_new_ulongpair(0);
  radixvalues.ulongpairptr = source;
  gt_radixsort_inplace(radixsortinfo,&radixvalues,len);
  gt_radixsort_delete(radixsortinfo);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
xorl %esi, %esi
callq 0x114968
movq %rax, %r15
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %rax, %rdi
movq %rbx, %rdx
callq 0x114e4a
movq %r15, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x114bc7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/radix_sort.c
// Function: gt_radixsort_inplace_flba
void gt_radixsort_inplace_flba(uint8_t *source,GtUword len,size_t unitsize)
{
  GtRadixvalues radixvalues;
  GtRadixsortinfo *radixsortinfo;

  radixsortinfo = gt_radixsort_new_flba(0,unitsize);
  radixvalues.flbaptr = source;
  gt_radixsort_inplace(radixsortinfo,&radixvalues,len);
  gt_radixsort_delete(radixsortinfo);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
movq %rdx, %rsi
callq 0x114ba4
movq %rax, %r15
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %rax, %rdi
movq %rbx, %rdx
callq 0x114e4a
movq %r15, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x114bc7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/score_function.c
// Function: gt_score_function_new
GtScoreFunction* gt_score_function_new(GtScoreMatrix *sm, int deletion_score,
                                 int insertion_score)
{
  GtScoreFunction *sf;
  gt_assert(sm);
  sf = gt_malloc(sizeof (GtScoreFunction));
  sf->sm = sm;
  sf->deletion_score = deletion_score;
  sf->insertion_score = insertion_score;
  sf->reference_count = 0;
  return sf;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1189b8
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x26028a(%rip), %rsi    # 0x378c1d
movl $0x18, %edi
movl $0x21, %edx
callq 0x1092b2
movq %r14, (%rax)
movl %ebp, 0x8(%rax)
movl %ebx, 0xc(%rax)
movq $0x0, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
callq 0x3580a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/score_function.c
// Function: gt_score_function_delete
void gt_score_function_delete(GtScoreFunction *sf)
{
  if (!sf) return;
  if (sf->reference_count) {
    sf->reference_count--;
    return;
  }
  gt_score_matrix_delete(sf->sm);
  gt_free(sf);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x118a2a
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x118a2c
decq %rax
movq %rax, 0x10(%rbx)
popq %rbx
retq
movq (%rbx), %rdi
callq 0x1190e9
leaq 0x2601e2(%rip), %rsi    # 0x378c1d
movq %rbx, %rdi
movl $0x51, %edx
popq %rbx
jmp 0x109670
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/seq_iterator_sequence_buffer.c
// Function: gt_seq_iterator_sequence_buffer_new
GtSeqIterator* gt_seq_iterator_sequence_buffer_new(const GtStrArray
                                                                   *filenametab,
                                                  GtError *err)
{
  GtSeqIterator *si;
  GtSequenceBuffer *sb = gt_sequence_buffer_new_guess_type(filenametab, err);
  if (!sb)
    return NULL;
  si = gt_seq_iterator_sequence_buffer_new_with_buffer(sb);
  gt_sequence_buffer_delete(sb); /* drop this reference */
  return si;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x11abe6
testq %rax, %rax
je 0x11a671
movq %rax, %rbx
movq %rax, %rdi
callq 0x11a67b
movq %rax, %r14
movq %rbx, %rdi
callq 0x11ab5d
movq %r14, %rax
jmp 0x11a673
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/seq_iterator_sequence_buffer.c
// Function: gt_seq_iterator_sequence_buffer_new_with_buffer
GtSeqIterator* gt_seq_iterator_sequence_buffer_new_with_buffer(
                                                       GtSequenceBuffer *buffer)
{
  GtSeqIterator *si;
  GtSeqIteratorSequenceBuffer *seqit;
  si = gt_seq_iterator_create(gt_seq_iterator_sequence_buffer_class());
  seqit = gt_seq_iterator_sequence_buffer_cast(si);
  GT_INITARRAY(&seqit->sequencebuffer, GtUchar);
  seqit->descptr = gt_desc_buffer_new();
  seqit->fb = gt_sequence_buffer_ref(buffer);
  gt_sequence_buffer_set_desc_buffer(seqit->fb, seqit->descptr);
  seqit->exhausted = false;
  seqit->unitnum = 0;
  seqit->withsequence = true;
  seqit->currentread = 0;
  seqit->maxread = 0;
  return si;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x11a6fa
movq %rax, %rdi
callq 0x11994e
movq %rax, %rbx
callq 0x11a6fa
movq %rax, %rdi
movq %rbx, %rsi
callq 0x11997f
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
xorl %r12d, %r12d
movq %r12, 0x38(%rax)
callq 0xe9148
movq %rax, 0x20(%r15)
movq %r14, %rdi
callq 0x11abcf
movq %rax, 0x8(%r15)
movq 0x20(%r15), %rsi
movq %rax, %rdi
callq 0x11ad97
movq %r12, 0x40(%r15)
movw $0x1, 0x48(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/seq_iterator_sequence_buffer.c
// Function: gt_seq_iterator_sequence_buffer_class
const GtSeqIteratorClass* gt_seq_iterator_sequence_buffer_class(void)
{
  static const GtSeqIteratorClass *sic = NULL;
  gt_class_alloc_lock_enter();
  if (!sic) {
    sic = gt_seq_iterator_class_new(sizeof (GtSeqIteratorSequenceBuffer),
                            gt_seq_iterator_sequence_buffer_set_symbolmap,
                            gt_seq_iterator_sequence_buffer_set_sequence_output,
                            gt_seq_iterator_sequence_buffer_next,
                            gt_seq_iterator_sequence_buffer_getcurrentcounter,
                            NULL,
                            gt_seq_iterator_sequence_buffer_delete);
  }
  gt_class_alloc_lock_leave();
  return sic;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x3aee48(%rip)    # 0x4c9550
jne 0x11a745
leaq 0x37c(%rip), %rax       # 0x11aa8d
movq %rax, (%rsp)
leaq 0x37(%rip), %rsi        # 0x11a753
leaq 0x67(%rip), %rdx        # 0x11a78a
leaq 0x8e(%rip), %rcx        # 0x11a7b8
leaq 0x328(%rip), %r8        # 0x11aa59
movl $0x60, %edi
xorl %r9d, %r9d
callq 0x1198f8
movq %rax, 0x3aee0b(%rip)    # 0x4c9550
callq 0xe6a19
movq 0x3aedff(%rip), %rax    # 0x4c9550
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/seq_iterator_sequence_buffer.c
// Function: gt_seq_iterator_sequence_buffer_set_symbolmap
static void gt_seq_iterator_sequence_buffer_set_symbolmap(GtSeqIterator *si,
                                                         const GtUchar
                                                           *symbolmap)
{
  GtSeqIteratorSequenceBuffer *seqit;
  gt_assert(si);
  seqit = gt_seq_iterator_sequence_buffer_cast(si);
  gt_sequence_buffer_set_symbolmap(seqit->fb, symbolmap);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x11a785
movq %rsi, %rbx
movq %rdi, %r14
callq 0x11a6fa
movq %rax, %rdi
movq %r14, %rsi
callq 0x11997f
movq 0x8(%rax), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11ad7b
callq 0x3694f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/seq_iterator_sequence_buffer.c
// Function: gt_seq_iterator_sequence_buffer_set_sequence_output
static void gt_seq_iterator_sequence_buffer_set_sequence_output(
                                                          GtSeqIterator *si,
                                                          bool withsequence)
{
  GtSeqIteratorSequenceBuffer *seqit;
  gt_assert(si);
  seqit = gt_seq_iterator_sequence_buffer_cast(si);
  seqit->withsequence = withsequence;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x11a7b3
movl %esi, %ebx
movq %rdi, %r14
callq 0x11a6fa
movq %rax, %rdi
movq %r14, %rsi
callq 0x11997f
movb %bl, 0x48(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x36986
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/seq_iterator_sequence_buffer.c
// Function: gt_seq_iterator_sequence_buffer_getcurrentcounter
static const GtUint64*
gt_seq_iterator_sequence_buffer_getcurrentcounter(GtSeqIterator *si,
                                                 GtUint64 maxread)
{
  GtSeqIteratorSequenceBuffer *seqit;
  gt_assert(si);
  seqit = gt_seq_iterator_sequence_buffer_cast(si);
  seqit->maxread = maxread;
  return &seqit->currentread;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x11aa88
movq %rsi, %rbx
movq %rdi, %r14
callq 0x11a6fa
movq %rax, %rdi
movq %r14, %rsi
callq 0x11997f
movq %rbx, 0x58(%rax)
addq $0x50, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x36a9b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/seq_iterator_sequence_buffer.c
// Function: gt_seq_iterator_sequence_buffer_delete
static void gt_seq_iterator_sequence_buffer_delete(GtSeqIterator *si)
{
  GtSeqIteratorSequenceBuffer *seqit;
  if (!si) return;
  seqit = gt_seq_iterator_sequence_buffer_cast(si);
  gt_desc_buffer_delete(seqit->descptr);
  gt_sequence_buffer_delete(seqit->fb);
  GT_FREEARRAY(&seqit->sequencebuffer, GtUchar);
  seqit->currentread = seqit->maxread;
}

// Assembly:
testq %rdi, %rdi
je 0x11aafd
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x11a6fa
movq %rax, %rdi
movq %rbx, %rsi
callq 0x11997f
movq %rax, %rbx
movq 0x20(%rax), %rdi
callq 0xe9362
movq 0x8(%rbx), %rdi
callq 0x11ab5d
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x11aaee
movq %rbx, %r14
addq $0x28, %r14
leaq 0x25eef9(%rip), %rsi    # 0x3799ce
movl $0xd3, %edx
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x58(%rbx), %rax
movq %rax, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/tool.c
// Function: gt_tool_new
GtTool* gt_tool_new(GtToolArgumentsNew tool_arguments_new,
                    GtToolArgumentsDelete tool_arguments_delete,
                    GtToolOptionParserNew tool_option_parser_new,
                    GtToolArgumentsCheck tool_arguments_check,
                    GtToolRunner tool_runner)
{
  GtTool *tool;
  gt_assert(tool_option_parser_new && tool_runner); /* required arguments */
  /* <tool_arguments_new> and <tool_arguments_delete> imply each other */
  gt_assert(( tool_arguments_new &&  tool_arguments_delete) ||
         (!tool_arguments_new && !tool_arguments_delete));
  tool = gt_calloc(1, sizeof *tool);
  tool->tool_arguments_new = tool_arguments_new;
  tool->tool_arguments_delete = tool_arguments_delete;
  tool->tool_option_parser_new = tool_option_parser_new;
  tool->tool_arguments_check = tool_arguments_check;
  tool->tool_runner = tool_runner;
  return tool;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x123456
movq %r8, %rbx
testq %r8, %r8
je 0x123456
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r13
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
cmpb %cl, %al
jne 0x12345b
movq %rdx, %r15
leaq 0x258363(%rip), %rdx    # 0x37b788
movl $0x1, %edi
movl $0x50, %esi
movl $0x2e, %ecx
callq 0x1093ef
movq %r13, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x38d22
callq 0x38d59
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/tool.c
// Function: gt_tool_run
int gt_tool_run(GtTool *tool, int argc, const char **argv, GtError *err)
{
  GtOPrval oprval;
  int parsed_args, had_err = 0;
  gt_error_check(err);
  gt_assert(tool);

  /* create tool arguments object */
  if (tool->tool_arguments_new && !tool->arguments)
    tool->arguments = tool->tool_arguments_new();

  /* create option parser object */
  if (tool->tool_option_parser_new && !tool->op)
    tool->op = tool->tool_option_parser_new(tool->arguments);
  else {
    /* make sure defaults are restored when reusing option parsers */
    gt_option_parser_reset(tool->op);
  }

  /* parse options */
  oprval = gt_option_parser_parse(tool->op, &parsed_args, argc, argv,
                                  gt_versionfunc, err);

  switch (oprval) {
    case GT_OPTION_PARSER_OK:
      break;
    case GT_OPTION_PARSER_ERROR:
      had_err = -1;
      break;
    case GT_OPTION_PARSER_REQUESTS_EXIT:
      if (tool->arguments) {
        tool->tool_arguments_delete(tool->arguments);
        tool->arguments = NULL;
      }
      return 0;
  }

  /* check tool arguments */
  if (!had_err && tool->tool_arguments_check) {
    had_err = tool->tool_arguments_check(argc - parsed_args, tool->arguments,
                                         err);
  }

  /* run tool */
  if (!had_err)
    had_err = tool->tool_runner(argc, argv, parsed_args, tool->arguments, err);

  /* return */
  if (had_err)
    return -1;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
testq %rcx, %rcx
je 0x12349c
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x123571
testq %rbx, %rbx
je 0x12356c
movq (%rbx), %rax
testq %rax, %rax
je 0x1234ba
cmpq $0x0, 0x30(%rbx)
jne 0x1234ba
callq *%rax
movq %rax, 0x30(%rbx)
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x1234ca
cmpq $0x0, 0x38(%rbx)
je 0x1234d5
movq 0x38(%rbx), %rdi
callq 0x10ce0e
jmp 0x1234df
movq 0x30(%rbx), %rdi
callq *%rax
movq %rax, 0x38(%rbx)
movq 0x38(%rbx), %rdi
leaq 0x1ede(%rip), %r8       # 0x1253c8
leaq 0xc(%rsp), %rsi
movl %ebp, %edx
movq %r15, %rcx
movq %r14, %r9
callq 0x10d796
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl $0x1, %eax
je 0x12355c
cmpl $0x2, %eax
jne 0x123525
movq 0x30(%rbx), %rdi
xorl %r12d, %r12d
testq %rdi, %rdi
je 0x12355c
callq *0x8(%rbx)
movq $0x0, 0x30(%rbx)
jmp 0x12355c
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x123541
movl %ebp, %edi
subl 0xc(%rsp), %edi
movq 0x30(%rbx), %rsi
movq %r14, %rdx
callq *%rax
testl %eax, %eax
jne 0x12355c
movl 0xc(%rsp), %edx
movq 0x30(%rbx), %rcx
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %r8
callq *0x20(%rbx)
xorl %r12d, %r12d
negl %eax
sbbl %r12d, %r12d
movl %r12d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x38dc7
callq 0x38d90
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/tool.c
// Function: gt_tool_get_toolbox
GtToolbox* gt_tool_get_toolbox(GtTool *tool)
{
  gt_assert(tool && tool->tool_toolbox_new);
  if (!tool->toolbox)
    tool->toolbox = tool->tool_toolbox_new();
  return tool->toolbox;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1235bf
movq %rdi, %rbx
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x1235bf
cmpq $0x0, 0x40(%rbx)
jne 0x1235b9
callq *%rax
movq %rax, 0x40(%rbx)
movq 0x40(%rbx), %rax
popq %rbx
retq
callq 0x38e6c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/tool.c
// Function: gt_tool_get_option_parser
GtOptionParser* gt_tool_get_option_parser(GtTool *tool)
{
  gt_assert(tool && tool->tool_option_parser_new);
  if (tool->tool_arguments_new && !tool->arguments)
    tool->arguments = tool->tool_arguments_new();
  if (tool->tool_option_parser_new && !tool->op)
    tool->op = tool->tool_option_parser_new(tool->arguments);
  return tool->op;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x123609
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x123609
movq (%rbx), %rax
testq %rax, %rax
je 0x1235e9
cmpq $0x0, 0x30(%rbx)
jne 0x1235e9
callq *%rax
movq %rax, 0x30(%rbx)
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x123603
cmpq $0x0, 0x38(%rbx)
jne 0x123603
movq 0x30(%rbx), %rdi
callq *%rax
movq %rax, 0x38(%rbx)
movq 0x38(%rbx), %rax
popq %rbx
retq
callq 0x38ea5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/tool.c
// Function: gt_tool_delete
void gt_tool_delete(GtTool *tool)
{
  if (!tool) return;
  if (tool->reference_count) {
    tool->reference_count--;
    return;
  }
  if (tool->arguments && tool->tool_arguments_delete)
    tool->tool_arguments_delete(tool->arguments);
  gt_toolbox_delete(tool->toolbox);
  gt_option_parser_delete(tool->op);
  gt_free(tool);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x123627
movq %rdi, %rbx
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x123629
decq %rax
movq %rax, 0x48(%rbx)
popq %rbx
retq
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x12363d
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x12363d
callq *%rax
movq 0x40(%rbx), %rdi
callq 0x123c12
movq 0x38(%rbx), %rdi
callq 0x10f2d0
leaq 0x258132(%rip), %rsi    # 0x37b788
movq %rbx, %rdi
movl $0x9c, %edx
popq %rbx
jmp 0x109670
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/tool_iterator.c
// Function: gt_tool_iterator_new
GtToolIterator* gt_tool_iterator_new(GtToolbox *toolbox)
{
  GtToolIterator *ti;
  ToolIterationInfo tii;
  gt_assert(toolbox);
  ti = gt_malloc(sizeof *ti);
  ti->tool_stack = gt_array_new(sizeof (ToolEntry));
  ti->prefixptr = NULL;
  ti->prefixsep = ' ';
  tii.arr = ti->tool_stack;
  tii.str = NULL;
  gt_toolbox_iterate(toolbox, add_tool_to_stack, &tii);
  gt_array_reverse(ti->tool_stack); /* alphabetical order */
  return ti;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x1236d2
movq %rdi, %rbx
leaq 0x25823e(%rip), %rsi    # 0x37b8b8
movl $0x18, %edi
movl $0x38, %edx
callq 0x1092b2
movq %rax, %r14
movl $0x18, %edi
callq 0xd46fc
movq %rax, (%r14)
xorl %ecx, %ecx
movq %rcx, 0x8(%r14)
movb $0x20, 0x10(%r14)
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rdx)
leaq 0x20(%rip), %rsi        # 0x1236d7
movq %rbx, %rdi
callq 0x123b65
movq (%r14), %rdi
callq 0xd4906
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x38ede
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/tool_iterator.c
// Function: add_tool_to_stack
static void add_tool_to_stack(const char *name, GtTool *tool, void *data)
{
  ToolIterationInfo *ti_info = data;
  ToolEntry entry;
  gt_assert(name && tool && data);
  entry.name = name;
  entry.tool = tool;
  entry.prefix = gt_str_ref(ti_info->str);
  gt_array_add(ti_info->arr, entry);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x12371f
testq %rsi, %rsi
je 0x12371f
movq %rdx, %rbx
testq %rdx, %rdx
je 0x12371f
movq %rsp, %r14
movq %rdi, (%r14)
movq %rsi, 0x8(%r14)
movq 0x8(%rbx), %rdi
callq 0x120e79
movq %rax, 0x10(%r14)
movq (%rbx), %rdi
movl $0x18, %edx
movq %r14, %rsi
callq 0xd49ce
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x38f15
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/tool_iterator.c
// Function: gt_tool_iterator_set_prefix_target
void gt_tool_iterator_set_prefix_target(GtToolIterator *ti, GtStr *prefix,
                                        char sep)
{
  gt_assert(ti);
  if (ti->prefixptr)
    gt_str_delete(ti->prefixptr);
  ti->prefixptr = gt_str_ref(prefix);
  ti->prefixsep = sep;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x12375a
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x123744
callq 0x121b03
movq %r15, %rdi
callq 0x120e79
movq %rax, 0x8(%r14)
movb %bl, 0x10(%r14)
popq %rbx
popq %r14
popq %r15
retq
callq 0x38f4c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/tool_iterator.c
// Function: gt_tool_iterator_next
bool gt_tool_iterator_next(GtToolIterator *tool_iterator, const char **name,
                           GtTool **tool)
{
  ToolIterationInfo tii;
  gt_assert(tool_iterator && name && tool);
  if (gt_array_size(tool_iterator->tool_stack)) {
    ToolEntry *entry = gt_array_pop(tool_iterator->tool_stack);
    *name = entry->name;
    *tool = entry->tool;
    if (tool_iterator->prefixptr) {
      gt_str_reset(tool_iterator->prefixptr);
      if (entry->prefix) {
        gt_str_append_str(tool_iterator->prefixptr, entry->prefix);
        gt_str_append_char(tool_iterator->prefixptr, tool_iterator->prefixsep);
      }
    }
    if (gt_tool_is_toolbox(entry->tool)) {
      GtToolbox *toolbox;
      GtArray *toollist;
      GtStr *myprefix;
      myprefix =
                gt_str_new_cstr(entry->prefix ? gt_str_get(entry->prefix) : "");
      gt_str_append_cstr(myprefix, entry->name);
      toolbox = gt_tool_get_toolbox(entry->tool);
      toollist = gt_array_new(sizeof (ToolEntry));
      tii.arr = toollist;
      tii.str = myprefix;
      gt_toolbox_iterate(toolbox, add_tool_to_stack, &tii);
      if (gt_array_size(toollist)) {
        gt_array_reverse(toollist); /* alphabetical order */
        gt_array_add_array(tool_iterator->tool_stack, toollist);
      }
      gt_array_delete(toollist);
      gt_str_delete(myprefix);
    } else
      gt_str_delete(entry->prefix);
    return true;
  }
  else
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x1238a3
movq %rsi, %r13
testq %rsi, %rsi
je 0x1238a3
movq %rdx, %r12
testq %rdx, %rdx
je 0x1238a3
movq %rdi, %r14
movq (%rdi), %rdi
callq 0xd4a9a
movq %rax, %rbx
testq %rax, %rax
je 0x12388f
movq (%r14), %rdi
callq 0xd47f5
movq %rax, %r15
movq (%rax), %rax
movq %rax, (%r13)
movq 0x8(%r15), %rax
movq %rax, (%r12)
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x1237ec
callq 0x120db4
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x1237ec
movq 0x8(%r14), %rdi
callq 0x120a43
movq 0x8(%r14), %rdi
movsbl 0x10(%r14), %esi
callq 0x120ba5
movq 0x8(%r15), %rdi
callq 0x123586
movq 0x10(%r15), %r12
testb %al, %al
je 0x123887
testq %r12, %r12
je 0x123813
movq %r12, %rdi
callq 0x120d23
movq %rax, %rdi
jmp 0x12381a
leaq 0x2b0076(%rip), %rdi    # 0x3d3890
callq 0x120955
movq %rax, %r12
movq (%r15), %rsi
movq %rax, %rdi
callq 0x12097f
movq 0x8(%r15), %rdi
callq 0x12359a
movq %rax, %r13
movl $0x18, %edi
callq 0xd46fc
movq %rax, %r15
movq %rsp, %rdx
movq %rax, (%rdx)
movq %r12, 0x8(%rdx)
leaq -0x180(%rip), %rsi      # 0x1236d7
movq %r13, %rdi
callq 0x123b65
movq %r15, %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x12387f
movq %r15, %rdi
callq 0xd4906
movq (%r14), %rdi
movq %r15, %rsi
callq 0xd4a43
movq %r15, %rdi
callq 0xd4ef4
movq %r12, %rdi
callq 0x121b03
testq %rbx, %rbx
setne %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x38f83
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/tool_iterator.c
// Function: gt_tool_iterator_delete
void gt_tool_iterator_delete(GtToolIterator *tool_iterator)
{
  if (!tool_iterator) return;
  gt_array_delete(tool_iterator->tool_stack);
  gt_str_delete(tool_iterator->prefixptr);
  gt_free(tool_iterator);
}

// Assembly:
testq %rdi, %rdi
je 0x1238d7
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xd4ef4
movq 0x8(%rbx), %rdi
callq 0x121b03
leaq 0x257fef(%rip), %rsi    # 0x37b8b8
movq %rbx, %rdi
movl $0x7c, %edx
popq %rbx
jmp 0x109670
retq