LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xe6e75
cmpq %rsi, 0x10(%rdi)
jbe 0xe6e74
movq $-0x2, %rax
movl %esi, %ecx
rolq %cl, %rax
movq (%rdi), %rcx
shrq $0x6, %rsi
andq %rax, (%rcx,%rsi,8)
retq
pushq %rax
callq 0x27143
// File: /workspace/github_c_makefile_star2_O3/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 0xe6ea0
cmpq %rsi, 0x10(%rdi)
jbe 0xe6e9d
movq (%rdi), %rax
movq %rsi, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rcx
movb $0x1, %al
btq %rsi, %rcx
jae 0xe6e9d
retq
xorl %eax, %eax
retq
pushq %rax
callq 0x2717a
// File: /workspace/github_c_makefile_star2_O3/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 0xe6edc
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0xe6ed8
movq (%rdi), %rdx
xorl %eax, %eax
movq %rax, %rsi
shrq $0x6, %rsi
movq (%rdx,%rsi,8), %rsi
btq %rax, %rsi
jb 0xe6eda
incq %rax
cmpq %rax, %rcx
jne 0xe6eba
movq %rcx, %rax
jmp 0xe6eda
xorl %eax, %eax
popq %rcx
retq
callq 0x271b1
// File: /workspace/github_c_makefile_star2_O3/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 0xe6f2b
movq 0x10(%rdi), %rax
cmpq %rsi, %rax
jbe 0xe6f30
incq %rsi
cmpq %rsi, %rax
je 0xe6f29
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 0xe6f03
decq %rcx
movq %rcx, %rax
popq %rcx
retq
callq 0x27256
callq 0x2721f
// File: /workspace/github_c_makefile_star2_O3/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 0xfe3b8
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0xfe3b8
leaq 0x26c1ba(%rip), %rdx    # 0x36a55e
movl $0x1, %edi
movl $0x1a, %ecx
callq 0x10436a
movq %rbx, (%rax)
popq %rbx
retq
callq 0x2f6d6
// File: /workspace/github_c_makefile_star2_O3/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 0xfe3f1
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xfe3f3
movq 0x10(%rax), %rax
testq %rax, %rax
je 0xfe3f3
movq %rbx, %rdi
callq *%rax
leaq 0x26c17b(%rip), %rsi    # 0x36a55e
movq %rbx, %rdi
movl $0x24, %edx
popq %rbx
jmp 0x1045eb
popq %rbx
retq
callq 0x2f70d
// File: /workspace/github_c_makefile_star2_O3/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 0xfe426
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xfe464
testq %rbp, %rbp
je 0xfe45f
movq (%rbp), %rax
testq %rax, %rax
je 0xfe45f
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xfe45f
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 0x2f77b
callq 0x2f744
// File: /workspace/github_c_makefile_star2_O3/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 0x3b5326(%rip), %r14    # 0x4b3b60
movq %r14, %rdi
callq 0xfe38c
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0xfe469
movq %rax, %r14
testq %r15, %r15
je 0xfe865
movq %r15, %rdi
callq 0x11b0a1
movq %rax, %rdi
jmp 0xfe867
xorl %edi, %edi
leaq 0x25c5e7(%rip), %rsi    # 0x35ae55
callq 0x103a1c
movq %rax, 0x8(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xfe8e6
movq %rdx, %r15
testq %rdx, %rdx
je 0xfe8eb
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 0xfe8f0
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 0xfe8f0
callq 0x2f9d8
callq 0x2f9a1
// File: /workspace/github_c_makefile_star2_O3/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 0xff0af
testq %r13, %r13
je 0xfe922
movq %r13, %rdi
movq %rbx, %rsi
callq 0xff0f4
movl $0xa, %edi
movq %rbx, %rsi
callq 0xff0af
testq %r15, %r15
je 0xfe973
xorl %ebp, %ebp
xorl %r13d, %r13d
testq %r14, %r14
setne %al
cmpq %r14, %rbp
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xfe95b
movl $0xa, %edi
movq %rbx, %rsi
callq 0xff0af
xorl %ebp, %ebp
movsbl (%r12,%r13), %edi
movq %rbx, %rsi
callq 0xff0af
incq %r13
incq %rbp
cmpq %r13, %r15
jne 0xfe939
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xff0af
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x10ae93
testq %rdx, %rdx
je 0x10ae93
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x10(%rdi)
movq (%rdi), %rdx
leaq 0x272d9c(%rip), %rdi    # 0x37db54
leaq 0x262a0e(%rip), %rsi    # 0x36d7cd
callq 0x10a7af
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x8(%rbx), %rdx
leaq 0x262a12(%rip), %rdi    # 0x36d7ef
leaq 0x262a10(%rip), %rsi    # 0x36d7f4
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x9(%rbx), %rdx
leaq 0x262a12(%rip), %rdi    # 0x36d816
leaq 0x262a11(%rip), %rsi    # 0x36d81c
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0xa(%rbx), %rdx
leaq 0x260870(%rip), %rdi    # 0x36b69b
leaq 0x246237(%rip), %rsi    # 0x351069
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %rbp
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r12, %rdi
movq %r13, %rsi
callq 0x10ab96
movq %r12, %rdi
movq %r15, %rsi
callq 0x10a9e4
movq %r13, %rdi
movq %r15, %rsi
callq 0x10a9e4
movq %rbp, %rdi
movq %r15, %rsi
callq 0x10a9e4
leaq 0x1e(%rip), %rsi        # 0x10ae98
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x107d66
callq 0x334fc
// File: /workspace/github_c_makefile_star2_O3/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 0x10b056
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x10b0b3
testq %rbx, %rbx
je 0x10b0ae
testq %r15, %r15
je 0x10b0ae
testb %bpl, %bpl
jne 0x10b099
movq %rbx, %rdi
callq 0xff28c
testb %al, %al
je 0x10b099
leaq 0x2627e7(%rip), %rsi    # 0x36d85f
leaq 0x26061c(%rip), %rcx    # 0x36b69b
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xfcb67
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 0xfed58
callq 0x33646
callq 0x3360f
// File: /workspace/github_c_makefile_star2_O3/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 0x261257(%rip), %xmm1   # 0x36e200
movsd 0x247fef(%rip), %xmm0   # 0x354fa0
callq 0x17d90
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x10cfd0
movsd 0x239260(%rip), %xmm1   # 0x346228
ucomisd %xmm0, %xmm1
jb 0x10cfd0
popq %rax
retq
callq 0x33e67
// File: /workspace/github_c_makefile_star2_O3/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 0x247fbe(%rip), %xmm0   # 0x354fa0
divsd %xmm0, %xmm1
callq 0x17d90
movapd %xmm0, %xmm1
movsd 0x239231(%rip), %xmm2   # 0x346228
addsd %xmm2, %xmm1
movapd %xmm2, %xmm0
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x10d015
ucomisd %xmm0, %xmm2
jb 0x10d015
popq %rax
retq
callq 0x33e9e
// File: /workspace/github_c_makefile_star2_O3/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 0x25f832(%rip), %rsi    # 0x36ead0
movq %rdi, (%rsp)
movl $0x8e, %edx
callq 0x104226
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 0x10f2ff
movq (%rdx), %rsi
movl %ebx, %ecx
shrq %cl, %rsi
movzbl %sil, %ecx
incq 0x10(%rsp,%rcx,8)
addq $0x8, %rdx
cmpq %rax, %rdx
jb 0x10f2e5
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 0x10f306
jmp 0x10f340
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 0x10f31f
incq %r14
movq %r13, %rbx
cmpq $0x8, %r14
jne 0x10f2bc
movq 0x8(%rsp), %rbx
cmpq %rbx, %r13
jne 0x10f377
cmpq %rbx, %r12
je 0x10f39c
movq %r12, %rdi
movq %r13, %rsi
movq (%rsp), %rdx
callq 0x17660
leaq 0x25f752(%rip), %rsi    # 0x36ead0
movq %rbx, %rdi
movl $0x94, %edx
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1045eb
callq 0x34296
// File: /workspace/github_c_makefile_star2_O3/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 0x10f778
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3aa7e0(%rip), %rax    # 0x4b9e18
movl (%rax), %r15d
cmpq $0x2, %r15
jb 0x10f6e9
movq 0x3060(%rbx), %rdi
leaq 0x25f47d(%rip), %r14    # 0x36ead0
movq %r14, %rsi
movl $0x211, %edx            # imm = 0x211
callq 0x1045eb
movq 0x3068(%rbx), %rdi
movq %r14, %rsi
movl $0x212, %edx            # imm = 0x212
callq 0x1045eb
imulq $0x3048, %r15, %r15     # imm = 0x3048
xorl %r12d, %r12d
movq 0x3070(%rbx), %rax
movq (%rax,%r12), %rcx
cmpq 0x18(%rax,%r12), %rcx
jbe 0x10f6b8
movq 0x3028(%rax,%r12), %rdi
movq %r14, %rsi
movl $0x215, %edx            # imm = 0x215
callq 0x1045eb
movq 0x3070(%rbx), %rax
movq $0x0, 0x3028(%rax,%r12)
movq 0x3038(%rax,%r12), %rdi
callq 0x10f779
addq $0x3048, %r12           # imm = 0x3048
cmpq %r12, %r15
jne 0x10f67e
movq 0x3070(%rbx), %rdi
leaq 0x25f3f1(%rip), %rsi    # 0x36ead0
movl $0x218, %edx            # imm = 0x218
callq 0x1045eb
cmpq $0x0, 0x3048(%rbx)
je 0x10f721
movl 0x3050(%rbx), %eax
movq 0x3040(%rbx), %rdi
movl $0x22c, %edx            # imm = 0x22C
cmpq $0x2, %rax
ja 0x10f715
leaq 0x25f8b6(%rip), %rcx    # 0x36efc8
movl (%rcx,%rax,4), %edx
leaq 0x25f3b4(%rip), %rsi    # 0x36ead0
callq 0x1045eb
movq 0x3038(%rbx), %rdi
callq 0x10f779
movq (%rbx), %rax
cmpq 0x18(%rbx), %rax
jbe 0x10f759
movq 0x3028(%rbx), %rdi
leaq 0x25f38c(%rip), %rsi    # 0x36ead0
movl $0x232, %edx            # imm = 0x232
callq 0x1045eb
movq $0x0, 0x3028(%rbx)
leaq 0x25f370(%rip), %rsi    # 0x36ead0
movq %rbx, %rdi
movl $0x233, %edx            # imm = 0x233
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/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 0x10f829
movq %rdi, %rbx
movl 0x44(%rdi), %eax
cmpq $0x3, %rax
jae 0x10f79e
leaq 0x25f83b(%rip), %rcx    # 0x36efd4
movl (%rcx,%rax,4), %edx
jmp 0x10f7cc
movq 0x60(%rbx), %rdi
leaq 0x25f327(%rip), %r14    # 0x36ead0
movq %r14, %rsi
movl $0x159, %edx            # imm = 0x159
callq 0x1045eb
movq 0x68(%rbx), %rdi
movq %r14, %rsi
movl $0x15a, %edx            # imm = 0x15A
callq 0x1045eb
movl $0x15b, %edx            # imm = 0x15B
movq 0x48(%rbx), %rdi
leaq 0x25f2f9(%rip), %r14    # 0x36ead0
movq %r14, %rsi
callq 0x1045eb
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x15f, %edx            # imm = 0x15F
callq 0x1045eb
movq 0x28(%rbx), %rdi
movq %r14, %rsi
movl $0x160, %edx            # imm = 0x160
callq 0x1045eb
movq 0x30(%rbx), %rdi
movq %r14, %rsi
movl $0x161, %edx            # imm = 0x161
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x162, %edx            # imm = 0x162
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
callq 0x34308
// File: /workspace/github_c_makefile_star2_O3/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 0x10f3a8
movq %rax, %r15
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %rax, %rdi
movq %rbx, %rdx
callq 0x10f899
movq %r15, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x10f61d
// File: /workspace/github_c_makefile_star2_O3/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 0x10f3a8
movq %rax, %r15
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %rax, %rdi
movq %rbx, %rdx
callq 0x10f899
movq %r15, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x10f61d
// File: /workspace/github_c_makefile_star2_O3/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 0x10f5fa
movq %rax, %r15
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %rax, %rdi
movq %rbx, %rdx
callq 0x10f899
movq %r15, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x10f61d
// File: /workspace/github_c_makefile_star2_O3/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 0x11331c
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x25c6b6(%rip), %rsi    # 0x36f9ad
movl $0x18, %edi
movl $0x21, %edx
callq 0x104226
movq %r14, (%rax)
movl %ebp, 0x8(%rax)
movl %ebx, 0xc(%rax)
movq $0x0, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
callq 0x34ea5
// File: /workspace/github_c_makefile_star2_O3/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 0x11338b
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x11338d
decq %rax
movq %rax, 0x10(%rbx)
popq %rbx
retq
movq (%rbx), %rdi
callq 0x113a12
leaq 0x25c611(%rip), %rsi    # 0x36f9ad
movq %rbx, %rdi
movl $0x51, %edx
popq %rbx
jmp 0x1045eb
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x115472
testq %rax, %rax
je 0x114f39
movq %rax, %rbx
movq %rax, %rdi
callq 0x114f43
movq %rax, %r14
movq %rbx, %rdi
callq 0x1153e9
movq %r14, %rax
jmp 0x114f3b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x114fc2
movq %rax, %rdi
callq 0x11427a
movq %rax, %rbx
callq 0x114fc2
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1142ab
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
xorl %r12d, %r12d
movq %r12, 0x38(%rax)
callq 0xe4c6c
movq %rax, 0x20(%r15)
movq %r14, %rdi
callq 0x11545b
movq %rax, 0x8(%r15)
movq 0x20(%r15), %rsi
movq %rax, %rdi
callq 0x115623
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_O3/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 0xe252f
cmpq $0x0, 0x3a9580(%rip)    # 0x4be550
jne 0x11500d
leaq 0x33f(%rip), %rax       # 0x115318
movq %rax, (%rsp)
leaq 0x37(%rip), %rsi        # 0x11501b
leaq 0x67(%rip), %rdx        # 0x115052
leaq 0x8e(%rip), %rcx        # 0x115080
leaq 0x2eb(%rip), %r8        # 0x1152e4
movl $0x60, %edi
xorl %r9d, %r9d
callq 0x114224
movq %rax, 0x3a9543(%rip)    # 0x4be550
callq 0xe2545
movq 0x3a9537(%rip), %rax    # 0x4be550
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x11504d
movq %rsi, %rbx
movq %rdi, %r14
callq 0x114fc2
movq %rax, %rdi
movq %r14, %rsi
callq 0x1142ab
movq 0x8(%rax), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x115607
callq 0x35fea
// File: /workspace/github_c_makefile_star2_O3/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 0x11507b
movl %esi, %ebx
movq %rdi, %r14
callq 0x114fc2
movq %rax, %rdi
movq %r14, %rsi
callq 0x1142ab
movb %bl, 0x48(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x36021
// File: /workspace/github_c_makefile_star2_O3/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 0x115313
movq %rsi, %rbx
movq %rdi, %r14
callq 0x114fc2
movq %rax, %rdi
movq %r14, %rsi
callq 0x1142ab
movq %rbx, 0x58(%rax)
addq $0x50, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x36136
// File: /workspace/github_c_makefile_star2_O3/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 0x115388
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x114fc2
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1142ab
movq %rax, %rbx
movq 0x20(%rax), %rdi
callq 0xe4e83
movq 0x8(%rbx), %rdi
callq 0x1153e9
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x115379
movq %rbx, %r14
addq $0x28, %r14
leaq 0x25b3fe(%rip), %rsi    # 0x37075e
movl $0xd3, %edx
callq 0x1045eb
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
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x11d73a
movq %r8, %rbx
testq %r8, %r8
je 0x11d73a
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r13
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
cmpb %cl, %al
jne 0x11d73f
movq %rdx, %r15
leaq 0x254dff(%rip), %rdx    # 0x372508
movl $0x1, %edi
movl $0x50, %esi
movl $0x2e, %ecx
callq 0x10436a
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 0x38386
callq 0x383bd
// File: /workspace/github_c_makefile_star2_O3/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 0x11d77d
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x11d85c
testq %rbx, %rbx
je 0x11d857
movq (%rbx), %rax
testq %rax, %rax
je 0x11d79b
cmpq $0x0, 0x30(%rbx)
jne 0x11d79b
callq *%rax
movq %rax, 0x30(%rbx)
movq 0x10(%rbx), %rax
movq 0x38(%rbx), %rdi
testq %rax, %rax
setne %cl
testq %rdi, %rdi
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x11d7c5
movq 0x30(%rbx), %rdi
callq *%rax
movq %rax, %rdi
movq %rax, 0x38(%rbx)
jmp 0x11d7ce
callq 0x107dbf
movq 0x38(%rbx), %rdi
leaq 0x1e37(%rip), %r8       # 0x11f60c
leaq 0xc(%rsp), %rsi
movl %ebp, %edx
movq %r15, %rcx
movq %r14, %r9
callq 0x10875d
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl $0x1, %eax
je 0x11d847
cmpl $0x2, %eax
jne 0x11d810
movq 0x30(%rbx), %rdi
xorl %r12d, %r12d
testq %rdi, %rdi
je 0x11d847
callq *0x8(%rbx)
movq $0x0, 0x30(%rbx)
jmp 0x11d847
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x11d82c
movl %ebp, %edi
subl 0xc(%rsp), %edi
movq 0x30(%rbx), %rsi
movq %r14, %rdx
callq *%rax
testl %eax, %eax
jne 0x11d847
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 0x3842b
callq 0x383f4
// File: /workspace/github_c_makefile_star2_O3/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 0x11d8a8
movq %rdi, %rbx
movq 0x28(%rdi), %rcx
testq %rcx, %rcx
je 0x11d8a8
movq 0x40(%rbx), %rax
testq %rax, %rax
jne 0x11d8a6
callq *%rcx
movq %rax, 0x40(%rbx)
popq %rbx
retq
callq 0x384d0
// File: /workspace/github_c_makefile_star2_O3/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 0x11d8f8
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x11d8f8
movq (%rbx), %rax
testq %rax, %rax
je 0x11d8dd
cmpq $0x0, 0x30(%rbx)
jne 0x11d8dd
callq *%rax
movq %rax, 0x30(%rbx)
movq 0x10(%rbx), %rcx
testq %rcx, %rcx
je 0x11d8f2
movq 0x38(%rbx), %rax
testq %rax, %rax
jne 0x11d8f6
movq 0x30(%rbx), %rdi
callq *%rcx
movq %rax, 0x38(%rbx)
jmp 0x11d8f6
movq 0x38(%rbx), %rax
popq %rbx
retq
callq 0x38509
// File: /workspace/github_c_makefile_star2_O3/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 0x11d916
movq %rdi, %rbx
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x11d918
decq %rax
movq %rax, 0x48(%rbx)
popq %rbx
retq
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x11d92c
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x11d92c
callq *%rax
movq 0x40(%rbx), %rdi
callq 0x11df02
movq 0x38(%rbx), %rdi
callq 0x10a0b4
leaq 0x254bc3(%rip), %rsi    # 0x372508
movq %rbx, %rdi
movl $0x9c, %edx
popq %rbx
jmp 0x1045eb
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x11d9c2
movq %rdi, %rbx
leaq 0x254cce(%rip), %rsi    # 0x372638
movl $0x18, %edi
movl $0x38, %edx
callq 0x104226
movq %rax, %r14
movl $0x18, %edi
callq 0xd214c
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        # 0x11d9c7
movq %rbx, %rdi
callq 0x11de55
movq (%r14), %rdi
callq 0xd2349
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x38542
// File: /workspace/github_c_makefile_star2_O3/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 0x11da0f
testq %rsi, %rsi
je 0x11da0f
movq %rdx, %rbx
testq %rdx, %rdx
je 0x11da0f
movq %rsp, %r14
movq %rdi, (%r14)
movq %rsi, 0x8(%r14)
movq 0x8(%rbx), %rdi
callq 0x11b1f3
movq %rax, 0x10(%r14)
movq (%rbx), %rdi
movl $0x18, %edx
movq %r14, %rsi
callq 0xd2410
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x38579
// File: /workspace/github_c_makefile_star2_O3/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 0x11da4a
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x11da34
callq 0x11bdbf
movq %r15, %rdi
callq 0x11b1f3
movq %rax, 0x8(%r14)
movb %bl, 0x10(%r14)
popq %rbx
popq %r14
popq %r15
retq
callq 0x385b0
// File: /workspace/github_c_makefile_star2_O3/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 0x11db90
movq %rsi, %r13
testq %rsi, %rsi
je 0x11db90
movq %rdx, %r12
testq %rdx, %rdx
je 0x11db90
movq %rdi, %r14
movq (%rdi), %rdi
callq 0xd24e0
movq %rax, %rbx
testq %rax, %rax
je 0x11db7c
movq (%r14), %rdi
callq 0xd2242
movq %rax, %r15
movq (%rax), %rax
movq %rax, (%r13)
movq 0x8(%r15), %rax
movq %rax, (%r12)
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x11dadc
callq 0x11b132
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x11dadc
movq 0x8(%r14), %rdi
callq 0x11adc1
movq 0x8(%r14), %rdi
movsbl 0x10(%r14), %esi
callq 0x11af23
movq 0x8(%r15), %rdi
callq 0x11d871
movq 0x10(%r15), %rdi
testb %al, %al
je 0x11db77
testq %rdi, %rdi
je 0x11db00
callq 0x11b0a1
movq %rax, %rdi
jmp 0x11db07
leaq 0x2ac669(%rip), %rdi    # 0x3ca170
callq 0x11acc9
movq %rax, %r12
movq (%r15), %rsi
movq %rax, %rdi
callq 0x11acf3
movq 0x8(%r15), %rdi
callq 0x11d885
movq %rax, %r13
movl $0x18, %edi
callq 0xd214c
movq %rax, %r15
movq %rsp, %rdx
movq %rax, (%rdx)
movq %r12, 0x8(%rdx)
leaq -0x17d(%rip), %rsi      # 0x11d9c7
movq %r13, %rdi
callq 0x11de55
movq %r15, %rdi
callq 0xd24e0
testq %rax, %rax
je 0x11db6c
movq %r15, %rdi
callq 0xd2349
movq (%r14), %rdi
movq %r15, %rsi
callq 0xd2489
movq %r15, %rdi
callq 0xd2938
movq %r12, %rdi
callq 0x11bdbf
testq %rbx, %rbx
setne %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x385e7
// File: /workspace/github_c_makefile_star2_O3/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 0x11dbc4
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xd2938
movq 0x8(%rbx), %rdi
callq 0x11bdbf
leaq 0x254a82(%rip), %rsi    # 0x372638
movq %rbx, %rdi
movl $0x7c, %edx
popq %rbx
jmp 0x1045eb
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/toolbox.c
// Function: gt_toolbox_add_tool
void gt_toolbox_add_tool(GtToolbox *tb, const char *toolname, GtTool *tool)
{
  GtToolinfo *toolinfo;
  gt_assert(tb && tb->tools);
  toolinfo = gt_toolinfo_new();
  toolinfo->tool= tool;
  gt_hashmap_add(tb->tools, (char*) toolname, toolinfo);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x11dc89
movq %rdi, %r15
cmpq $0x0, (%rdi)
je 0x11dc89
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x254a70(%rip), %rdx    # 0x3726cf
movl $0x1, %edi
movl $0x18, %esi
movl $0x26, %ecx
callq 0x10436a
movq %r14, (%rax)
movq (%r15), %rdi
movq %rbx, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x100b18
callq 0x3861e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/toolbox.c
// Function: gt_toolbox_add_hidden_tool
void gt_toolbox_add_hidden_tool(GtToolbox *tb, const char *toolname,
                                GtTool *tool)
{
  GtToolinfo *toolinfo;
  gt_assert(tb && tb->tools);
  toolinfo = gt_toolinfo_new();
  toolinfo->tool= tool;
  toolinfo->hidden = true;
  gt_hashmap_add(tb->tools, (char*) toolname, toolinfo);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x11dcdc
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x11dcdc
movq %rdx, %r15
movq %rsi, %rbx
leaq 0x254a21(%rip), %rdx    # 0x3726cf
movl $0x1, %edi
movl $0x18, %esi
movl $0x26, %ecx
callq 0x10436a
movq %r15, (%rax)
movb $0x1, 0x10(%rax)
movq (%r14), %rdi
movq %rbx, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x100b18
callq 0x38655
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/toolbox.c
// Function: gt_toolbox_get_tool
GtTool* gt_toolbox_get_tool(GtToolbox *tb, const char *toolname)
{
  GtToolinfo *toolinfo;
  gt_assert(tb && tb->tools);
  toolinfo = gt_hashmap_get(tb->tools, toolname);
  if (toolinfo)
    return toolinfo->tool;
  return NULL;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x11dd02
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x11dd02
callq 0x100add
testq %rax, %rax
je 0x11dcfe
movq (%rax), %rax
jmp 0x11dd00
xorl %eax, %eax
popq %rcx
retq
callq 0x3868c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/toolbox.c
// Function: gt_toolbox_add
void gt_toolbox_add(GtToolbox *tb, const char *toolname, GtToolfunc toolfunc)
{
  GtToolinfo *toolinfo;
  gt_assert(tb && tb->tools);
  toolinfo = gt_toolinfo_new();
  toolinfo->toolfunc = toolfunc;
  gt_hashmap_add(tb->tools, (char*) toolname, toolinfo);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x11dd72
movq %rdi, %r15
cmpq $0x0, (%rdi)
je 0x11dd72
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x254988(%rip), %rdx    # 0x3726cf
movl $0x1, %edi
movl $0x18, %esi
movl $0x26, %ecx
callq 0x10436a
movq %r14, 0x8(%rax)
movq (%r15), %rdi
movq %rbx, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x100b18
callq 0x386fa
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/toolbox.c
// Function: gt_toolbox_get
GtToolfunc gt_toolbox_get(const GtToolbox *tb, const char *toolname)
{
  GtToolinfo *toolinfo;
  gt_assert(tb && tb->tools);
  toolinfo = gt_hashmap_get(tb->tools, toolname);
  if (toolinfo)
    return toolinfo->toolfunc;
  return NULL;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x11dd99
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x11dd99
callq 0x100add
testq %rax, %rax
je 0x11dd95
movq 0x8(%rax), %rax
jmp 0x11dd97
xorl %eax, %eax
popq %rcx
retq
callq 0x38731