LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/fasta_reader_rec.c
// Function: parse_fasta_sequence
static int parse_fasta_sequence(GtStr *sequence, GtIO *seqio, GtError *err)
{
  char cc;
  gt_error_check(err);
  gt_assert(sequence && seqio);
  gt_assert(!gt_str_length(sequence));
  /* read sequence */
  while (!gt_io_get_char(seqio, &cc) && cc != GT_FASTA_SEPARATOR) {
    if (cc != '\n' && cc != ' ' && cc != '\r')
      gt_str_append_char(sequence, cc);
  }
  if (!gt_str_length(sequence)) {
    gt_error_set(err, "empty sequence given in line "GT_WU"",
              gt_io_get_line_number(seqio));
    return -1;
  }
  if (cc == GT_FASTA_SEPARATOR)
    gt_io_unget_char(seqio, GT_FASTA_SEPARATOR);
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xdcd73
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0xdcd3b
jmp 0xdcd73
movq 0x55f25e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4392c7(%rip), %rsi    # 0x516013
leaq 0x43946c(%rip), %rdx    # 0x5161bf
leaq 0x45eea6(%rip), %rcx    # 0x53bc00
leaq 0x45eda4(%rip), %r8     # 0x53bb05
movl $0x3b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xdcd75
jmp 0xdcd77
cmpq $0x0, 0x28(%rsp)
je 0xdcd87
cmpq $0x0, 0x20(%rsp)
jne 0xdcdbf
movq 0x55f212(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x43927b(%rip), %rsi    # 0x516013
leaq 0x45edec(%rip), %rdx    # 0x53bb8b
leaq 0x45ee5a(%rip), %rcx    # 0x53bc00
leaq 0x45ed58(%rip), %r8     # 0x53bb05
movl $0x3c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xdcdc1
jmp 0xdcdc3
movq 0x28(%rsp), %rdi
callq 0x11dfa0
cmpq $0x0, %rax
je 0xdce0b
movq 0x55f1c6(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x43922f(%rip), %rsi    # 0x516013
leaq 0x45ee2a(%rip), %rdx    # 0x53bc15
leaq 0x45ee0e(%rip), %rcx    # 0x53bc00
leaq 0x45ed0c(%rip), %r8     # 0x53bb05
movl $0x3d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xdce0d
jmp 0xdce0f
movq 0x20(%rsp), %rdi
leaq 0x17(%rsp), %rsi
callq 0xe70d0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x16(%rsp)
jne 0xdce3a
movsbl 0x17(%rsp), %eax
cmpl $0x3e, %eax
setne %al
movb %al, 0x16(%rsp)
movb 0x16(%rsp), %al
testb $0x1, %al
jne 0xdce44
jmp 0xdce73
movsbl 0x17(%rsp), %eax
cmpl $0xa, %eax
je 0xdce71
movsbl 0x17(%rsp), %eax
cmpl $0x20, %eax
je 0xdce71
movsbl 0x17(%rsp), %eax
cmpl $0xd, %eax
je 0xdce71
movq 0x28(%rsp), %rdi
movsbl 0x17(%rsp), %esi
callq 0x11da70
jmp 0xdce0f
movq 0x28(%rsp), %rdi
callq 0x11dfa0
cmpq $0x0, %rax
jne 0xdceb7
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xe73f0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x45ed88(%rip), %rsi    # 0x53bc2e
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xdced8
movsbl 0x17(%rsp), %eax
cmpl $0x3e, %eax
jne 0xdced0
movq 0x20(%rsp), %rdi
movl $0x3e, %esi
callq 0xe71a0
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movb %r9b, %al
movq 0x40(%rsp), %r9
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0xdcf5b
movq 0x55f076(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4390df(%rip), %rsi    # 0x516013
leaq 0x488778(%rip), %rdx    # 0x5656b3
leaq 0x45ed0d(%rip), %rcx    # 0x53bc4f
leaq 0x45ed1a(%rip), %r8     # 0x53bc63
movl $0x2f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xdcf5d
jmp 0xdcf5f
cmpq $0x0, 0x20(%rsp)
jne 0xdcf9f
movq 0x55f032(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x43909b(%rip), %rsi    # 0x516013
leaq 0x478001(%rip), %rdx    # 0x554f80
leaq 0x45ecc9(%rip), %rcx    # 0x53bc4f
leaq 0x45ecd6(%rip), %r8     # 0x53bc63
movl $0x30, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xdcfa1
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x40(%rsp), %r9
movl $0x40, %edi
callq 0xdd010
testb $0x1, 0xf(%rsp)
je 0xdcfd6
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
jmp 0xdcfde
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0xdcfde
movq (%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x40(%rsp), %r9
movl $0x2b, %edi
callq 0xdd010
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movb %dil, %al
movb %al, 0x47(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movsbl 0x47(%rsp), %edi
movq 0x18(%rsp), %rsi
callq 0xddf60
cmpq $0x0, 0x38(%rsp)
je 0xdd05a
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xde030
movq 0x18(%rsp), %rsi
movl $0xa, %edi
callq 0xddf60
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0xdd0e9
cmpq $0x0, 0x20(%rsp)
je 0xdd0b3
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
jne 0xdd0b3
movq 0x18(%rsp), %rsi
movl $0xa, %edi
callq 0xddf60
movq $0x0, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %edi
movq 0x18(%rsp), %rsi
callq 0xddf60
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0xdd07b
movq 0x18(%rsp), %rsi
movl $0xa, %edi
callq 0xddf60
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq %rcx, (%rsp)
cmpq $0x0, (%rsp)
je 0xf82b8
movq (%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0xf8280
jmp 0xf82b8
movq 0x543d19(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x41dd82(%rip), %rsi    # 0x516013
leaq 0x41df27(%rip), %rdx    # 0x5161bf
leaq 0x4472a1(%rip), %rcx    # 0x53f540
leaq 0x4471df(%rip), %r8     # 0x53f485
movl $0x7e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xf82ba
jmp 0xf82bc
cmpq $0x0, 0x18(%rsp)
je 0xf82cc
cmpq $0x0, 0x10(%rsp)
jne 0xf8304
movq 0x543ccd(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x41dd36(%rip), %rsi    # 0x516013
leaq 0x4434b1(%rip), %rdx    # 0x53b795
leaq 0x447255(%rip), %rcx    # 0x53f540
leaq 0x447193(%rip), %r8     # 0x53f485
movl $0x7f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0xf8306
testb $0x1, 0xf(%rsp)
jne 0xf8346
movq 0x18(%rsp), %rdi
callq 0xde820
testb $0x1, %al
jne 0xf831d
jmp 0xf8346
movq (%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x447233(%rip), %rsi    # 0x53f560
leaq 0x4449a7(%rip), %rcx    # 0x53ccdb
movb $0x0, %al
callq 0xd88c0
movq $0x0, 0x20(%rsp)
jmp 0xf835a
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xdd9b0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
shlq $0x3, %rdi
leaq 0x4407dd(%rip), %rsi    # 0x5407eb
movl $0x8e, %edx
callq 0xe80f0
movq %rax, (%rsp)
movq 0x10(%rsp), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movl $0x7, %edi
callq 0x100050
movq (%rsp), %rdi
leaq 0x4407ac(%rip), %rsi    # 0x5407eb
movl $0x94, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/radix_sort.c
// Function: gt_radixsort_lsb_linear_generic
static void gt_radixsort_lsb_linear_generic(size_t enditer,
                                            GtUword *source,
                                            GtUword *dest,
                                            GtUword len)
{
  size_t iter;
  GtUword *origdest, count[UINT8_MAX+1];

  origdest = dest;
  for (iter = 0; iter <= enditer; iter++)
  {
    GtUword *ptr;

    gt_radixsort_lsb_linear_phase (count,source, dest, len,
                                   iter * CHAR_BIT * sizeof (uint8_t));
    ptr = source;
    source = dest;
    dest = ptr;
  }
  if (source == origdest)
  {
    gt_assert(dest != origdest);
    memcpy(dest,source,sizeof (*source) * len);
  }
}

// Assembly:
subq $0x848, %rsp            # imm = 0x848
movq %rdi, 0x840(%rsp)
movq %rsi, 0x838(%rsp)
movq %rdx, 0x830(%rsp)
movq %rcx, 0x828(%rsp)
movq 0x830(%rsp), %rax
movq %rax, 0x818(%rsp)
movq $0x0, 0x820(%rsp)
movq 0x820(%rsp), %rax
cmpq 0x840(%rsp), %rax
ja 0x10011a
leaq 0x10(%rsp), %rdi
movq 0x838(%rsp), %rsi
movq 0x830(%rsp), %rdx
movq 0x828(%rsp), %rcx
movq 0x820(%rsp), %r8
shlq $0x3, %r8
shlq $0x0, %r8
callq 0x101a50
movq 0x838(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x830(%rsp), %rax
movq %rax, 0x838(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x830(%rsp)
movq 0x820(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x820(%rsp)
jmp 0x100093
movq 0x838(%rsp), %rax
cmpq 0x818(%rsp), %rax
jne 0x10019b
jmp 0x10012e
movq 0x830(%rsp), %rax
cmpq 0x818(%rsp), %rax
jne 0x100178
movq 0x53be59(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x415ec2(%rip), %rsi    # 0x516013
leaq 0x4407a3(%rip), %rdx    # 0x5408fb
leaq 0x4407ad(%rip), %rcx    # 0x54090c
leaq 0x440685(%rip), %r8     # 0x5407eb
movl $0x87, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x10017a
movq 0x830(%rsp), %rdi
movq 0x838(%rsp), %rsi
movq 0x828(%rsp), %rdx
shlq $0x3, %rdx
callq 0x19610
addq $0x848, %rsp            # imm = 0x848
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x100bc4
movq 0x53b40d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x415476(%rip), %rsi    # 0x516013
leaq 0x43fdb7(%rip), %rdx    # 0x54095b
leaq 0x43fdbd(%rip), %rcx    # 0x540968
leaq 0x43fc39(%rip), %r8     # 0x5407eb
movl $0x149, %r9d            # imm = 0x149
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x100bc6
movq (%rsp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x100bee
movq (%rsp), %rax
movq 0x48(%rax), %rdi
leaq 0x43fc0c(%rip), %rsi    # 0x5407eb
movl $0x14c, %edx            # imm = 0x14C
callq 0xe88c0
jmp 0x100c87
movq (%rsp), %rax
cmpl $0x0, 0x44(%rax)
jne 0x100c13
movq (%rsp), %rax
movq 0x48(%rax), %rdi
leaq 0x43fbe4(%rip), %rsi    # 0x5407eb
movl $0x151, %edx            # imm = 0x151
callq 0xe88c0
jmp 0x100c85
movq (%rsp), %rax
cmpl $0x2, 0x44(%rax)
jne 0x100c38
movq (%rsp), %rax
movq 0x48(%rax), %rdi
leaq 0x43fbbf(%rip), %rsi    # 0x5407eb
movl $0x156, %edx            # imm = 0x156
callq 0xe88c0
jmp 0x100c83
movq (%rsp), %rax
movq 0x60(%rax), %rdi
leaq 0x43fba4(%rip), %rsi    # 0x5407eb
movl $0x159, %edx            # imm = 0x159
callq 0xe88c0
movq (%rsp), %rax
movq 0x68(%rax), %rdi
leaq 0x43fb8b(%rip), %rsi    # 0x5407eb
movl $0x15a, %edx            # imm = 0x15A
callq 0xe88c0
movq (%rsp), %rax
movq 0x48(%rax), %rdi
leaq 0x43fb72(%rip), %rsi    # 0x5407eb
movl $0x15b, %edx            # imm = 0x15B
callq 0xe88c0
jmp 0x100c85
jmp 0x100c87
movq (%rsp), %rax
movq 0x38(%rax), %rdi
leaq 0x43fb55(%rip), %rsi    # 0x5407eb
movl $0x15f, %edx            # imm = 0x15F
callq 0xe88c0
movq (%rsp), %rax
movq 0x28(%rax), %rdi
leaq 0x43fb3c(%rip), %rsi    # 0x5407eb
movl $0x160, %edx            # imm = 0x160
callq 0xe88c0
movq (%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0x43fb23(%rip), %rsi    # 0x5407eb
movl $0x161, %edx            # imm = 0x161
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x43fb0e(%rip), %rsi    # 0x5407eb
movl $0x162, %edx            # imm = 0x162
callq 0xe88c0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1001b0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rsi
callq 0x100de0
movq 0x8(%rsp), %rdi
callq 0x1008f0
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x100820
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rsi
callq 0x100de0
movq 0x8(%rsp), %rdi
callq 0x1008f0
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x100860
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x8(%rsp), %rsi
callq 0x100de0
movq (%rsp), %rdi
callq 0x1008f0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/radix_sort.c
// Function: gt_radixsort_lsb_linear_phase
static void gt_radixsort_lsb_linear_phase(GtUword *count,
                                          GtUword *source,
                                          GtUword *dest,
                                          GtUword len,
                                          size_t shift)
{
  GtUword idx, *cptr, *countptr, *sptr;

  /* count occurrences of every byte value */
  countptr = count;
  for (cptr = countptr; cptr <= countptr + UINT8_MAX; cptr++)
  {
    *cptr = 0;
  }

  for (sptr = source; sptr < source + len; sptr++)
  {
    countptr[GT_RADIX_KEY_PTR(UINT8_MAX,shift,sptr)]++;
  }

  /* compute partial sums */
  for (cptr = countptr+1; cptr <= countptr + UINT8_MAX; cptr++)
  {
    *cptr += *(cptr-1);
  }

  /* fill dest with the right values in the right place */
  for (sptr = source + len - 1; sptr >= source; sptr--)
  {
    idx = --countptr[GT_RADIX_KEY_PTR(UINT8_MAX,shift,sptr)];
    dest[idx] = *sptr;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x40(%rsp)
movq -0x40(%rsp), %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
movq -0x40(%rsp), %rcx
addq $0x7f8, %rcx            # imm = 0x7F8
cmpq %rcx, %rax
ja 0x101aaf
movq -0x38(%rsp), %rax
movq $0x0, (%rax)
movq -0x38(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rsp)
jmp 0x101a7d
movq -0x10(%rsp), %rax
movq %rax, -0x48(%rsp)
movq -0x48(%rsp), %rax
movq -0x10(%rsp), %rcx
movq -0x20(%rsp), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x101b0f
movq -0x40(%rsp), %rax
movq -0x48(%rsp), %rcx
movq (%rcx), %rdx
movq -0x28(%rsp), %rcx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0xff, %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x48(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rsp)
jmp 0x101ab9
movq -0x40(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
movq -0x40(%rsp), %rcx
addq $0x7f8, %rcx            # imm = 0x7F8
cmpq %rcx, %rax
ja 0x101b57
movq -0x38(%rsp), %rax
movq -0x8(%rax), %rcx
movq -0x38(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x38(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rsp)
jmp 0x101b1d
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x48(%rsp)
movq -0x48(%rsp), %rax
cmpq -0x10(%rsp), %rax
jb 0x101bda
movq -0x40(%rsp), %rax
movq %rax, -0x50(%rsp)
movq -0x48(%rsp), %rax
movq (%rax), %rdx
movq -0x28(%rsp), %rcx
shrq %cl, %rdx
movq -0x50(%rsp), %rcx
andq $0xff, %rdx
movq (%rcx,%rdx,8), %rax
addq $-0x1, %rax
movq %rax, (%rcx,%rdx,8)
movq %rax, -0x30(%rsp)
movq -0x48(%rsp), %rax
movq (%rax), %rdx
movq -0x18(%rsp), %rax
movq -0x30(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x48(%rsp), %rax
addq $-0x8, %rax
movq %rax, -0x48(%rsp)
jmp 0x101b71
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/radix_sort.c
// Function: gt_radixsort_thread_caller
static void *gt_radixsort_thread_caller(void *data)
{
  GtRadixinplacethreadinfo *threadinfo = (GtRadixinplacethreadinfo *) data;
  if (threadinfo->rbuf->elemtype == GtRadixelemtypeGtUwordPair)
  {
    gt_radixsort_ulongpair_sub_inplace(threadinfo->rbuf,&threadinfo->stack);
  } else
  {
    if (threadinfo->rbuf->elemtype == GtRadixelemtypeGtUword)
    {
      gt_radixsort_ulong_sub_inplace(threadinfo->rbuf,&threadinfo->stack);
    } else
    {
      if (threadinfo->rbuf->elemtype == GtRadixelemtypeGtuint64keyPair)
      {
        gt_radixsort_uint64keypair_sub_inplace(threadinfo->rbuf,
                                               &threadinfo->stack);
      } else
      {
        gt_radixsort_flba_sub_inplace(threadinfo->rbuf,&threadinfo->stack);
      }
    }
  }
  return NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x3038(%rax), %rax
cmpl $0x1, 0x44(%rax)
jne 0x10349d
movq 0x8(%rsp), %rax
movq 0x3038(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x102f50
jmp 0x10350b
movq 0x8(%rsp), %rax
movq 0x3038(%rax), %rax
cmpl $0x0, 0x44(%rax)
jne 0x1034c7
movq 0x8(%rsp), %rax
movq 0x3038(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x103010
jmp 0x103509
movq 0x8(%rsp), %rax
movq 0x3038(%rax), %rax
cmpl $0x2, 0x44(%rax)
jne 0x1034f1
movq 0x8(%rsp), %rax
movq 0x3038(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x1030d0
jmp 0x103507
movq 0x8(%rsp), %rax
movq 0x3038(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x103190
jmp 0x103509
jmp 0x10350b
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/radix_sort.c
// Function: gt_radixsort_findfirstlarger
static GtUword gt_radixsort_findfirstlarger(const GtUword *leftborder,
                                            GtUword start,
                                            GtUword end,
                                            GtUword offset)
{
  const GtUword *left = leftborder + start,
                      *right = leftborder + end,
                      *found = leftborder + end;

  while (left <= right)
  {
    const GtUword *mid = left + GT_DIV2(right-left);
    gt_assert(mid >= leftborder + start && mid <= leftborder + end);
    if (offset == *mid)
    {
      return (GtUword) (mid - leftborder);
    }
    if (offset < *mid)
    {
      found = mid;
      right = mid - 1;
    } else
    {
      left = mid + 1;
    }
  }
  gt_assert(found >= leftborder);
  return (GtUword) (found - leftborder);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq 0x30(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq 0x28(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq 0x28(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
ja 0x106f2c
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
subq %rdx, %rcx
sarq $0x3, %rcx
sarq %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jb 0x106e92
movq (%rsp), %rax
movq 0x38(%rsp), %rcx
movq 0x28(%rsp), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jbe 0x106eca
movq 0x535107(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x40f170(%rip), %rsi    # 0x516013
leaq 0x439dff(%rip), %rdx    # 0x540ca9
leaq 0x439e2d(%rip), %rcx    # 0x540cde
leaq 0x439933(%rip), %r8     # 0x5407eb
movl $0xa4, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x106ecc
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
cmpq (%rcx), %rax
jne 0x106ef4
movq (%rsp), %rax
movq 0x38(%rsp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, 0x40(%rsp)
jmp 0x106f8a
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
cmpq (%rcx), %rax
jae 0x106f1a
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rax
addq $-0x8, %rax
movq %rax, 0x10(%rsp)
jmp 0x106f27
movq (%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
jmp 0x106e2a
jmp 0x106f2e
movq 0x8(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x106f72
movq 0x53505f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x40f0c8(%rip), %rsi    # 0x516013
leaq 0x439da9(%rip), %rdx    # 0x540cfb
leaq 0x439d85(%rip), %rcx    # 0x540cde
leaq 0x43988b(%rip), %r8     # 0x5407eb
movl $0xb2, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x106f74
movq 0x8(%rsp), %rax
movq 0x38(%rsp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x10ed91
movq 0x52d240(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4072a9(%rip), %rsi    # 0x516013
leaq 0x461c9e(%rip), %rdx    # 0x570a0f
leaq 0x432e5d(%rip), %rcx    # 0x541bd5
leaq 0x432e6c(%rip), %r8     # 0x541beb
movl $0x20, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x10ed93
movl $0x18, %edi
leaq 0x432e4c(%rip), %rsi    # 0x541beb
movl $0x21, %edx
callq 0xe80f0
movq %rax, (%rsp)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movl 0xc(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0x8(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0xc(%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x10efae
jmp 0x10efec
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x10efcb
movq (%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x10efec
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x10f4c0
movq (%rsp), %rdi
leaq 0x432c09(%rip), %rsi    # 0x541beb
movl $0x51, %edx
callq 0xe88c0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x113d20
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x113273
movq $0x0, 0x20(%rsp)
jmp 0x113294
movq (%rsp), %rdi
callq 0x1132a0
movq %rax, 0x8(%rsp)
movq (%rsp), %rdi
callq 0x113bf0
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x113370
movq %rax, %rdi
callq 0x111790
movq %rax, 0x8(%rsp)
callq 0x113370
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x111820
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
movq (%rsp), %rax
movq $0x0, 0x38(%rax)
movq (%rsp), %rax
movq $0x0, 0x30(%rax)
callq 0xa4110
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rdi
callq 0x113cc0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x114160
movq (%rsp), %rax
movb $0x0, 0x49(%rax)
movq (%rsp), %rax
movq $0x0, 0x40(%rax)
movq (%rsp), %rax
movb $0x1, 0x48(%rax)
movq (%rsp), %rax
movq $0x0, 0x50(%rax)
movq (%rsp), %rax
movq $0x0, 0x58(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x9f220
cmpq $0x0, 0x52f832(%rip)    # 0x642bb0
jne 0x1133bd
movl $0x60, %edi
leaq 0x44(%rip), %rsi        # 0x1133d0
leaq 0xbd(%rip), %rdx        # 0x113450
leaq 0x136(%rip), %rcx       # 0x1134d0
leaq 0x65f(%rip), %r8        # 0x113a00
xorl %eax, %eax
movl %eax, %r9d
leaq 0x6d3(%rip), %rax       # 0x113a80
movq %rax, (%rsp)
callq 0x1116f0
movq %rax, 0x52f7f3(%rip)    # 0x642bb0
callq 0x9f280
movq 0x52f7e7(%rip), %rax    # 0x642bb0
popq %rcx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x113a4e
movq 0x528583(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4025ec(%rip), %rsi    # 0x516013
leaq 0x42e8dc(%rip), %rdx    # 0x54230a
leaq 0x42f084(%rip), %rcx    # 0x542ab9
leaq 0x42ef7c(%rip), %r8     # 0x5429b8
movl $0xc6, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x113a50
callq 0x113370
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x111820
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x58(%rax)
movq (%rsp), %rax
addq $0x50, %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x113a96
jmp 0x113b2a
callq 0x113370
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x111820
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0xa46c0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x113bf0
movq 0x8(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x113b16
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
leaq 0x42eed3(%rip), %rsi    # 0x5429b8
movl $0xd3, %edx
callq 0xe88c0
movq 0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
jmp 0x113b18
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x50(%rax)
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x122a6d
cmpq $0x0, 0x10(%rsp)
jne 0x122aa5
movq 0x51952c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f3595(%rip), %rsi    # 0x516013
leaq 0x421df3(%rip), %rdx    # 0x544878
leaq 0x421e12(%rip), %rcx    # 0x54489e
leaq 0x421e17(%rip), %r8     # 0x5448aa
movl $0x2a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x122aa7
jmp 0x122aa9
cmpq $0x0, 0x30(%rsp)
je 0x122ab9
cmpq $0x0, 0x28(%rsp)
jne 0x122b01
cmpq $0x0, 0x30(%rsp)
jne 0x122ac9
cmpq $0x0, 0x28(%rsp)
je 0x122b01
movq 0x5194d0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f3539(%rip), %rsi    # 0x516013
leaq 0x421dd9(%rip), %rdx    # 0x5448ba
leaq 0x421db6(%rip), %rcx    # 0x54489e
leaq 0x421dbb(%rip), %r8     # 0x5448aa
movl $0x2d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x122b03
movl $0x1, %edi
movl $0x50, %esi
leaq 0x421d96(%rip), %rdx    # 0x5448aa
movl $0x2e, %ecx
callq 0xe83c0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x122f07
movq (%rsp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x122f3f
movq 0x519092(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f30fb(%rip), %rsi    # 0x516013
leaq 0x421a34(%rip), %rdx    # 0x544953
leaq 0x421a4c(%rip), %rcx    # 0x544972
leaq 0x42197d(%rip), %r8     # 0x5448aa
movl $0x81, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x122f41
movq (%rsp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x122f5e
movq (%rsp), %rax
callq *0x28(%rax)
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x40(%rax)
movq (%rsp), %rax
movq 0x40(%rax), %rax
popq %rcx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x122f87
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x122fbf
movq 0x519012(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f307b(%rip), %rsi    # 0x516013
leaq 0x4219e7(%rip), %rdx    # 0x544986
leaq 0x421a05(%rip), %rcx    # 0x5449ab
leaq 0x4218fd(%rip), %r8     # 0x5448aa
movl $0x89, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x122fc1
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x122fe7
movq (%rsp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x122fe7
movq (%rsp), %rax
callq *(%rax)
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x12301a
movq (%rsp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x12301a
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq (%rsp), %rcx
movq 0x30(%rcx), %rdi
callq *%rax
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rax)
movq (%rsp), %rax
movq 0x38(%rax), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x12303e
jmp 0x1230b2
movq (%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x12305b
movq (%rsp), %rax
movq 0x48(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x48(%rax)
jmp 0x1230b2
movq (%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x123083
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x123083
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq (%rsp), %rcx
movq 0x30(%rcx), %rdi
callq *%rax
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x123de0
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0xf5cf0
movq (%rsp), %rdi
leaq 0x421802(%rip), %rsi    # 0x5448aa
movl $0x9c, %edx
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x123109
movq 0x518ec8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f2f31(%rip), %rsi    # 0x516013
leaq 0x40bdf8(%rip), %rdx    # 0x52eee1
leaq 0x4218d5(%rip), %rcx    # 0x5449c5
leaq 0x4218e3(%rip), %r8     # 0x5449da
movl $0x37, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x12310b
movl $0x18, %edi
leaq 0x4218c3(%rip), %rsi    # 0x5449da
movl $0x38, %edx
callq 0xe80f0
movq %rax, 0x18(%rsp)
movl $0x18, %edi
callq 0x80990
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x18(%rsp), %rax
movb $0x20, 0x10(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x2d(%rip), %rsi        # 0x1231a0
leaq 0x8(%rsp), %rdx
callq 0x123bd0
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x80f40
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x1231d5
cmpq $0x0, 0x28(%rsp)
je 0x1231d5
cmpq $0x0, 0x20(%rsp)
jne 0x12320d
movq 0x518dc4(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f2e2d(%rip), %rsi    # 0x516013
leaq 0x42185d(%rip), %rdx    # 0x544a4a
leaq 0x42186b(%rip), %rcx    # 0x544a5f
leaq 0x4217df(%rip), %r8     # 0x5449da
movl $0x2c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x12320f
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11e360
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq %rsp, %rsi
movl $0x18, %edx
callq 0x81100
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movb %dl, %al
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movb %al, 0x7(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1232a4
movq 0x518d2d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f2d96(%rip), %rsi    # 0x516013
leaq 0x410fde(%rip), %rdx    # 0x534262
leaq 0x421768(%rip), %rcx    # 0x5449f3
leaq 0x421748(%rip), %r8     # 0x5449da
movl $0x46, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1232a6
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1232c0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
callq 0x11e360
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movb 0x7(%rsp), %cl
movq 0x10(%rsp), %rax
movb %cl, 0x10(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x12351e
jmp 0x12354c
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x81f80
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq (%rsp), %rdi
leaq 0x421498(%rip), %rsi    # 0x5449da
movl $0x7c, %edx
callq 0xe88c0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x123616
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x12364e
movq 0x518983(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f29ec(%rip), %rsi    # 0x516013
leaq 0x421456(%rip), %rdx    # 0x544a84
leaq 0x42145f(%rip), %rcx    # 0x544a94
leaq 0x421435(%rip), %r8     # 0x544a71
movl $0x3b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x123650
callq 0x123550
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xe0fc0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1236b6
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1236ee
movq 0x5188e3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f294c(%rip), %rsi    # 0x516013
leaq 0x4213b6(%rip), %rdx    # 0x544a84
leaq 0x4213d3(%rip), %rcx    # 0x544aa8
leaq 0x421395(%rip), %r8     # 0x544a71
movl $0x45, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1236f0
callq 0x123550
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movb $0x1, 0x10(%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xe0fc0
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x123751
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x123789
movq 0x518848(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f28b1(%rip), %rsi    # 0x516013
leaq 0x42131b(%rip), %rdx    # 0x544a84
leaq 0x421353(%rip), %rcx    # 0x544ac3
leaq 0x4212fa(%rip), %r8     # 0x544a71
movl $0x4f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x12378b
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xe0f20
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1237b9
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x1237c2
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/toolbox.c
// Function: gt_toolbox_has_tool
bool gt_toolbox_has_tool(const GtToolbox *tb, const char *toolname)
{
  gt_assert(tb && tb->tools);
  if (gt_hashmap_get(tb->tools, toolname))
    return true;
  return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1237f0
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x123828
movq 0x5187a9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f2812(%rip), %rsi    # 0x516013
leaq 0x42127c(%rip), %rdx    # 0x544a84
leaq 0x4212c8(%rip), %rcx    # 0x544ad7
leaq 0x42125b(%rip), %r8     # 0x544a71
movl $0x58, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x12382a
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rsi
callq 0xe0f20
cmpq $0x0, %rax
je 0x123848
movb $0x1, 0x17(%rsp)
jmp 0x12384d
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x123886
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1238be
movq 0x518713(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3f277c(%rip), %rsi    # 0x516013
leaq 0x4211e6(%rip), %rdx    # 0x544a84
leaq 0x421246(%rip), %rcx    # 0x544aeb
leaq 0x4211c5(%rip), %r8     # 0x544a71
movl $0x61, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1238c0
callq 0x123550
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xe0fc0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)