LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_seqlensort.c
// Function: gt_seqlensort_runner
static int gt_seqlensort_runner(GT_UNUSED int argc,
                                GT_UNUSED const char **argv,
                                GT_UNUSED int parsed_args,
                                void *tool_arguments,
                                GtError *err)
{
  GtSeqlensortArguments *arguments = tool_arguments;
  int had_err = 0;
  GtUword i;
  GtReads2Twobit *r2t = NULL;

  gt_error_check(err);
  gt_assert(arguments);

  if (gt_str_length(arguments->indexname) == 0)
  {
    gt_str_append_cstr(arguments->indexname,
                       gt_str_array_get(arguments->db, 0));
  }

  r2t = gt_reads2twobit_new(arguments->indexname);

  for (i = 0; i < gt_str_array_size(arguments->db) && !had_err; i++)
    had_err = gt_reads2twobit_add_library(r2t,
                                          gt_str_array_get_str(arguments->db,
                                                               i),
                                          err);

  if (!had_err)
    had_err = gt_reads2twobit_encode(r2t, err);

  if (!had_err)
  {
    if (gt_reads2twobit_seqlen_eqlen(r2t) == 0)
    {
      gt_reads2twobit_sort(r2t, gt_seqlensort_cmp,
                           gt_reads2twobit_export_seppos(r2t));
    }
    had_err = gt_reads2twobit_write_encseq(r2t, err);
  }

  gt_reads2twobit_delete(r2t);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
testq %r8, %r8
je 0xc3654
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xc3734
testq %r15, %r15
je 0xc372f
movq (%r15), %rdi
callq 0x11b0ca
testq %rax, %rax
jne 0xc3683
movq (%r15), %r14
movq 0x8(%r15), %rdi
xorl %esi, %esi
callq 0x11bfb3
movq %r14, %rdi
movq %rax, %rsi
callq 0x11acf3
movq (%r15), %rdi
callq 0x1dafec
movq %rax, %r14
movq 0x8(%r15), %rdi
callq 0x11c131
testq %rax, %rax
je 0xc36d9
movl $0x1, %r12d
leaq -0x1(%r12), %rsi
movq 0x8(%r15), %rdi
callq 0x11bfee
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x1db253
movl %eax, %ebp
movq 0x8(%r15), %rdi
callq 0x11c131
cmpq %rax, %r12
jae 0xc36d5
incq %r12
testl %ebp, %ebp
je 0xc36a2
testl %ebp, %ebp
jne 0xc371c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1db597
testl %eax, %eax
jne 0xc371a
movq %r14, %rdi
callq 0x1de164
testq %rax, %rax
jne 0xc370f
movq %r14, %rdi
callq 0x1de124
leaq 0x35(%rip), %rsi        # 0xc3739
movq %r14, %rdi
movq %rax, %rdx
callq 0x1dde8f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ddad9
movl %eax, %ebp
movq %r14, %rdi
callq 0x1db0a7
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1ef8d
callq 0x1ef56
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_seqlensort.c
// Function: gt_seqlensort_cmp
static int gt_seqlensort_cmp(const void *a, const void *b, void *data)
{
  const GtUword seqnum_a = *(const GtUword*)a,
        seqnum_b = *(const GtUword*)b;
  GtUword seqlen_a = GT_SEQLENSORT_SEQLEN(seqnum_a, (GtUword*)data),
          seqlen_b = GT_SEQLENSORT_SEQLEN(seqnum_b, (GtUword*)data);
  if (seqlen_a == seqlen_b)
    return (int)((seqnum_a > seqnum_b) - (seqnum_a < seqnum_b));
  return (int)((seqlen_a > seqlen_b) - (seqlen_a < seqlen_b));
}

// Assembly:
movq (%rdi), %rax
movq (%rsi), %rcx
testq %rax, %rax
je 0xc3752
movq -0x8(%rdx,%rax,8), %rsi
notq %rsi
addq (%rdx,%rax,8), %rsi
jmp 0xc3755
movq (%rdx), %rsi
testq %rcx, %rcx
je 0xc3768
movq -0x8(%rdx,%rcx,8), %rdi
notq %rdi
addq (%rdx,%rcx,8), %rdi
jmp 0xc376b
movq (%rdx), %rdi
xorl %edx, %edx
xorl %r8d, %r8d
cmpq %rcx, %rax
seta %dl
setb %r8b
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rdi, %rsi
seta %al
setb %cl
cmovel %r8d, %ecx
cmovel %edx, %eax
movl $0xff, %edx
andl %edx, %eax
andl %edx, %ecx
subl %ecx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_seqmutate.c
// Function: gt_seqmutate_arguments_delete
static void gt_seqmutate_arguments_delete(void *tool_arguments)
{
  MutateArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xc381c
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xff22c
movq 0x10(%rbx), %rdi
callq 0x10b00c
leaq 0x295174(%rip), %rsi    # 0x358982
movq %rbx, %rdi
movl $0x2f, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_seqmutate.c
// Function: gt_seqmutate_option_parser_new
static GtOptionParser* gt_seqmutate_option_parser_new(void *tool_arguments)
{
  MutateArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *o;
  gt_assert(arguments);
  op = gt_option_parser_new("[option ...] [sequence_file ...]",
                            "Mutate the sequences of the given sequence "
                            "file(s).");
  /* -rate */
  o = gt_option_new_uint_max("rate", "set the mutation rate", &arguments->rate,
                             1, 100);
  gt_option_parser_add_option(op, o);

  /* -width */
  o = gt_option_new_width(&arguments->width);
  gt_option_parser_add_option(op, o);

  gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);

  gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc38b2
movq %rdi, %r14
leaq 0x294da1(%rip), %rdi    # 0x3585d5
leaq 0x29517f(%rip), %rsi    # 0x3589ba
callq 0x107bfe
movq %rax, %rbx
leaq 0x2951b5(%rip), %rdi    # 0x3589ff
leaq 0x29519d(%rip), %rsi    # 0x3589ee
movq %r14, %rdx
movl $0x1, %ecx
movl $0x64, %r8d
callq 0x10a548
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x8(%r14), %rdi
callq 0x10a280
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x10(%r14), %rdi
addq $0x18, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x10ad87
leaq 0x89027(%rip), %rsi     # 0x14c8c4
movq %rbx, %rdi
xorl %edx, %edx
callq 0x107d3d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1efc4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_seqorder.c
// Function: gt_seqorder_arguments_check
static int gt_seqorder_arguments_check(GT_UNUSED int rest_argc,
                                       void *tool_arguments,
                                       GT_UNUSED GtError *err)
{
  GtSeqorderArguments *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(arguments != NULL);

  if (!(arguments->invert || arguments->sort || arguments->revsort ||
        arguments->sorthdr || arguments->sorthdrnum || arguments->shuffle ||
        arguments->sort_length))
  {
    had_err = 1;
    gt_error_set(err, "order option needed: -invert|-sort|-revsort|"
                      "-sorthdr|-sorthdrnum|shuffle|sort_length");
  }
  return had_err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdx, %rdx
je 0xc3d53
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xc3dad
testq %r14, %r14
je 0xc3da8
xorl %eax, %eax
cmpb $0x0, (%r14)
jne 0xc3da0
cmpb $0x0, 0x1(%r14)
jne 0xc3da0
cmpb $0x0, 0x2(%r14)
jne 0xc3da0
cmpb $0x0, 0x4(%r14)
jne 0xc3da0
cmpb $0x0, 0x5(%r14)
jne 0xc3da0
cmpb $0x0, 0x3(%r14)
jne 0xc3da0
cmpb $0x0, 0x6(%r14)
jne 0xc3da0
leaq 0x294ebc(%rip), %rsi    # 0x358c4d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1f0d9
callq 0x1f0a0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_seqorder.c
// Function: gt_seqorder_output
static void gt_seqorder_output(GtUword seqnum,const GtEncseq *encseq)
{
  GtEncseqReader *esr;
  GtUword startpos, len, desclen = 0;
  const char *desc = NULL;
  GtUword i;

  startpos = gt_encseq_seqstartpos(encseq, seqnum);
  len = gt_encseq_seqlength(encseq, seqnum);
  gt_xfputc(GT_FASTA_SEPARATOR, stdout);
  if (gt_encseq_has_description_support(encseq))
  {
    desc = gt_encseq_description(encseq, &desclen, seqnum);
    gt_xfwrite(desc, (size_t)1, (size_t)desclen, stdout);
  }
  gt_xfputc('\n', stdout);
  esr = gt_encseq_create_reader_with_readmode(encseq, GT_READMODE_FORWARD,
                                              startpos);
  for (i = 0; i < len; i++)
  {
    gt_xfputc(gt_encseq_reader_next_decoded_char(esr), stdout);
  }
  gt_encseq_reader_delete(esr);
  gt_xfputc('\n', stdout);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r12
movq $0x0, (%rsp)
movq %rsi, %rdi
movq %r12, %rsi
callq 0xeb6ee
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0xeb9d2
movq %rax, %rbx
movq 0x3f4d0a(%rip), %rbp    # 0x4b8ed8
movq (%rbp), %rsi
movl $0x3e, %edi
callq 0x11f81a
movq %r14, %rdi
callq 0xec569
testb %al, %al
je 0xc420e
movq %rsp, %r13
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xec19e
movq (%r13), %rdx
movq (%rbp), %rcx
movl $0x1, %esi
movq %rax, %rdi
callq 0x11f89c
movq (%rbp), %rsi
movl $0xa, %edi
callq 0x11f81a
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0xe91b2
movq %rax, %r14
testq %rbx, %rbx
je 0xc424a
movq %r14, %rdi
callq 0xe8b85
movsbl %al, %edi
movq (%rbp), %rsi
callq 0x11f81a
decq %rbx
jne 0xc4231
movq %r14, %rdi
callq 0xe9204
movq (%rbp), %rsi
movl $0xa, %edi
callq 0x11f81a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_seqorder.c
// Function: seqorder_str_compare_num
static int seqorder_str_compare_num(const void *v1, const void *v2, void *data)
{
  GtUword n1 = *(const GtUword*) v1,
          n2 = *(const GtUword*) v2,
          desclen1, desclen2,
          anum, bnum;
  int arval, brval, rval = 0;
  const char *desc1, *desc2;
  char buf[BUFSIZ];
  desc1 = gt_encseq_description((GtEncseq*) data, &desclen1, n1);
  desc2 = gt_encseq_description((GtEncseq*) data, &desclen2, n2);
  (void) strncpy(buf, desc1, GT_MIN(BUFSIZ, desclen1) * sizeof (char));
  buf[desclen1] = '\0';
  arval = gt_parse_uword(&anum, buf);
  (void) strncpy(buf, desc2, GT_MIN(BUFSIZ, desclen2) * sizeof (char));
  buf[desclen2] = '\0';
  brval = gt_parse_uword(&bnum, buf);
  if (arval == 0 && brval == 0)
    rval = anum-bnum;
  else if (arval == 0)
    return -1;
  else if (brval == 0)
    return 1;
  else
    rval = 0;
  return rval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2028, %rsp           # imm = 0x2028
movq %rdx, %rbx
movq (%rdi), %rdx
movq (%rsi), %r14
leaq 0x18(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xec19e
movq %rax, %r12
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xec19e
movq %rax, %r14
movq (%r15), %rbp
movl $0x2000, %r15d          # imm = 0x2000
cmpq %r15, %rbp
movl $0x2000, %edx           # imm = 0x2000
cmovbq %rbp, %rdx
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x17370
xorl %ebx, %ebx
movb %bl, 0x20(%rsp,%rbp)
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x10b217
movl %eax, %ebp
leaq 0x10(%rsp), %rax
movq (%rax), %r12
cmpq %r15, %r12
cmovbq %r12, %r15
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x17370
movb %bl, 0x20(%rsp,%r12)
movq %rsp, %rdi
movq %r13, %rsi
callq 0x10b217
movl %ebp, %ecx
orl %eax, %ecx
jne 0xc43be
movl 0x8(%rsp), %ebx
subl (%rsp), %ebx
jmp 0xc43cc
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
cmpl $0x1, %ebp
sbbl %ebx, %ebx
orl %ecx, %ebx
movl %ebx, %eax
addq $0x2028, %rsp           # imm = 0x2028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_seqstat.c
// Function: showmeroccurrence
static void showmeroccurrence(GtUword key, GtUint64 value,
                              void *data)
{
  GtUword len;
  Astretchinfo *astretchinfo = (Astretchinfo *) data;

  for (len=astretchinfo->minkey; len<= key; len++)
  {
    gt_assert(len <= astretchinfo->maxvalue);
    astretchinfo->mmercount[len] += value * (GtUint64) (key-len+1);
  }
}

// Assembly:
pushq %rax
movq 0x18(%rdx), %rax
cmpq %rdi, %rax
ja 0xc4e3f
movq 0x10(%rdx), %rcx
movq %rdi, %r8
subq %rax, %r8
incq %r8
imulq %rsi, %r8
cmpq %rcx, %rax
ja 0xc4e41
movq 0x8(%rdx), %r9
addq %r8, (%r9,%rax,8)
incq %rax
subq %rsi, %r8
cmpq %rdi, %rax
jbe 0xc4e27
popq %rax
retq
callq 0x1f3bc
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_seqtransform.c
// Function: gt_seqtransform_arguments_delete
static void gt_seqtransform_arguments_delete(void *tool_arguments)
{
  SeqtransformArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xc4ec8
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xff22c
movq 0x10(%rbx), %rdi
callq 0x10b00c
leaq 0x294284(%rip), %rsi    # 0x35913e
movq %rbx, %rdi
movl $0x2d, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_seqtransform.c
// Function: gt_seqtransform_option_parser_new
static GtOptionParser* gt_seqtransform_option_parser_new(void *tool_arguments)
{
  SeqtransformArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *o;
  gt_assert(arguments);
  op = gt_option_parser_new("[option ...] [sequence_file ...]",
                            "Perform simple transformations on the given "
                            "sequence file(s).");

  /* -addstopaminos */
  o = gt_option_new_bool("addstopaminos", "append stop amino acids ('"
                         GT_STOP_AMINO_CSTR"') to given protein sequences, if "
                         "not already present", &arguments->addstopaminos,
                         false);
  gt_option_parser_add_option(op, o);

  /* -width */
  o = gt_option_new_width(&arguments->width);
  gt_option_parser_add_option(op, o);

  gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc4f40
movq %rdi, %rbx
leaq 0x2936f9(%rip), %rdi    # 0x3585d5
leaq 0x294299(%rip), %rsi    # 0x35917c
callq 0x107bfe
movq %rax, %r14
leaq 0x2942c8(%rip), %rdi    # 0x3591ba
leaq 0x2942cf(%rip), %rsi    # 0x3591c8
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x10a235
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x8(%rbx), %rdi
callq 0x10a280
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x10(%rbx), %rdi
addq $0x18, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10ad87
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1f3f5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_seqtranslate.c
// Function: gt_seqtranslate_arguments_delete
static void gt_seqtranslate_arguments_delete(void *tool_arguments)
{
  GtTranslateArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_output_file_info_delete(arguments->ofi);
  gt_file_delete(arguments->outfp);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xc514f
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x10b00c
movq 0x8(%rbx), %rdi
callq 0xff22c
leaq 0x2940ef(%rip), %rsi    # 0x359230
movq %rbx, %rdi
movl $0x34, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_seqtranslate.c
// Function: gt_seqtranslate_option_parser_new
static GtOptionParser* gt_seqtranslate_option_parser_new(void *tool_arguments)
{
  GtTranslateArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] [files]",
                            "Translates a nucleotide sequence into a protein "
                            "sequence.");

  option = gt_option_new_bool("reverse", "also translate reverse complements",
                              &arguments->reverse, true);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_uword("fastawidth",
                               "width of the FASTA output, 0 for unlimited",
                              &arguments->fasta_width, 60);
  gt_option_parser_add_option(op, option);

  gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);
  gt_option_parser_set_min_args(op, 1);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc51ee
movq %rdi, %rbx
leaq 0x285310(%rip), %rdi    # 0x34a477
leaq 0x294100(%rip), %rsi    # 0x35926e
callq 0x107bfe
movq %rax, %r14
leaq 0x18(%rbx), %rdx
leaq 0x2d0363(%rip), %rdi    # 0x3954e4
leaq 0x294120(%rip), %rsi    # 0x3592a8
movl $0x1, %ecx
callq 0x10a235
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x10(%rbx), %rdx
leaq 0x284f54(%rip), %rdi    # 0x34a0fc
leaq 0x29411c(%rip), %rsi    # 0x3592cb
movl $0x3c, %ecx
callq 0x10a2ab
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
movq (%rbx), %rdi
addq $0x8, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10ad87
movq %r14, %rdi
movl $0x1, %esi
callq 0x10872d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1f49a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_seqtranslate.c
// Function: gt_seqtranslate_arguments_check
static int gt_seqtranslate_arguments_check(GT_UNUSED int rest_argc,
                                        GT_UNUSED void *tool_arguments,
                                        GT_UNUSED GtError *err)
{
  GT_UNUSED GtTranslateArguments *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(arguments);

  return had_err;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
je 0xc5208
movq %rdx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xc5216
testq %rbx, %rbx
je 0xc5211
xorl %eax, %eax
popq %rbx
retq
callq 0x1f508
callq 0x1f4d1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_sequniq.c
// Function: gt_sequniq_arguments_delete
static void gt_sequniq_arguments_delete(void *tool_arguments)
{
  GtSequniqArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xc5670
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0xff22c
movq 0x18(%rbx), %rdi
callq 0x10b00c
leaq 0x293d06(%rip), %rsi    # 0x359368
movq %rbx, %rdi
movl $0x35, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_sfxmap.c
// Function: gt_sfxmap_arguments_new
static void *gt_sfxmap_arguments_new(void)
{
  Sfxmapoptions *arguments;

  arguments = gt_malloc(sizeof (*arguments));
  arguments->esaindexname = gt_str_new();
  arguments->pckindexname = gt_str_new();
  arguments->streamesq = gt_str_array_new();
  arguments->algbounds = gt_str_array_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2939ab(%rip), %rsi    # 0x3594d4
movl $0x48, %edi
movl $0x83, %edx
callq 0x104226
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x20(%rbx)
callq 0x11ac6c
movq %rax, 0x28(%rbx)
callq 0x11be10
movq %rax, 0x40(%rbx)
callq 0x11be10
movq %rax, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_sfxmap.c
// Function: gt_sfxmap_arguments_delete
static void gt_sfxmap_arguments_delete(void *tool_arguments)
{
  Sfxmapoptions *arguments = tool_arguments;

  if (arguments != NULL)
  {
    gt_str_delete(arguments->esaindexname);
    gt_str_delete(arguments->pckindexname);
    gt_str_array_delete(arguments->streamesq);
    gt_str_array_delete(arguments->algbounds);
    gt_free(arguments);
  }
}

// Assembly:
testq %rdi, %rdi
je 0xc5ba6
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x11bdbf
movq 0x28(%rbx), %rdi
callq 0x11bdbf
movq 0x40(%rbx), %rdi
callq 0x11c144
movq 0x38(%rbx), %rdi
callq 0x11c144
leaq 0x29393c(%rip), %rsi    # 0x3594d4
movq %rbx, %rdi
movl $0x95, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_sfxmap.c
// Function: showlcpinterval
static int showlcpinterval(GT_UNUSED void *data,const Lcpinterval *lcpinterval)
{
  printf("N "GT_WU" "GT_WU" "GT_WU"\n",lcpinterval->offset,
                           lcpinterval->left,
                           lcpinterval->right);
  return 0;
}

// Assembly:
pushq %rax
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %rcx
leaq 0x292d54(%rip), %rdi    # 0x35a411
movq %rax, %rsi
xorl %eax, %eax
callq 0x17070
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_sfxmap.c
// Function: gt_sfxmap_comparelcpvalue
static int gt_sfxmap_comparelcpvalue(void *info,GtUword lcp,GtError *err)
{
  GtUword currentlcpvalue;
  Sequentialsuffixarrayreader *ssar = (Sequentialsuffixarrayreader *) info;
  bool haserr = false;

  gt_error_check(err);
  do /* fake loop to allow for the use of a break statement */
  {
    SSAR_NEXTSEQUENTIALLCPTABVALUE(currentlcpvalue,ssar);
    if (lcp != currentlcpvalue)
    {
      gt_error_set(err,"lcp="GT_WU" != "GT_WU"=currentlcpvalue",
                   lcp,currentlcpvalue);
      haserr = true;
      break;
    }
    break;
  } while (true);
  return haserr ? -1 : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0xc7e6a
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0xc7f63
cmpb $0x1, 0x40(%r15)
jne 0xc7ec0
movl $0xd0, %esi
addq (%r15), %rsi
leaq 0x7(%rsp), %rdi
callq 0xc76d0
testl %eax, %eax
je 0xc7f32
movzbl 0x7(%rsp), %ecx
cmpq $0xff, %rcx
jne 0xc7f09
movl $0xe8, %esi
addq (%r15), %rsi
leaq 0x8(%rsp), %rdi
callq 0xc773d
testl %eax, %eax
sete %bpl
je 0xc7f3f
xorl %eax, %eax
movq 0x10(%rsp), %rcx
jmp 0xc7f0d
movq 0x20(%r15), %rax
cmpq 0x10(%r15), %rax
jae 0xc7f32
movq (%r15), %rdx
movq 0x60(%rdx), %rcx
leaq 0x1(%rax), %rsi
movq %rsi, 0x20(%r15)
movzbl (%rcx,%rax), %ecx
cmpq $0xff, %rcx
jne 0xc7f09
movq 0x68(%rdx), %rcx
movq 0x28(%r15), %rdx
movq %rdx, %rsi
shlq $0x4, %rsi
cmpq %rax, (%rcx,%rsi)
jne 0xc7f68
addq %rsi, %rcx
incq %rdx
movq %rdx, 0x28(%r15)
movq 0x8(%rcx), %rcx
xorl %eax, %eax
xorl %ebp, %ebp
testb %bpl, %bpl
jne 0xc7f34
cmpq %rbx, %rcx
je 0xc7f34
leaq 0x292143(%rip), %rsi    # 0x35a061
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xc7f34
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x291bff(%rip), %rsi    # 0x359b45
leaq 0x291587(%rip), %rdx    # 0x3594d4
movq %r14, %rdi
movl $0x420, %ecx            # imm = 0x420
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xc7f0d
callq 0x1fee2
callq 0x1ff1b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_show_seedext.c
// Function: gt_show_seedext_arguments_new
static void* gt_show_seedext_arguments_new(void)
{
  GtShowSeedextArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->matchfilename = gt_str_new();
  arguments->display_args = gt_str_array_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2923b2(%rip), %rdx    # 0x35a470
movl $0x1, %edi
movl $0x18, %esi
movl $0x32, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x8(%rbx)
callq 0x11be10
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_show_seedext.c
// Function: gt_show_seedext_arguments_delete
static void gt_show_seedext_arguments_delete(void *tool_arguments)
{
  GtShowSeedextArguments *arguments = tool_arguments;
  if (arguments != NULL) {
    gt_str_array_delete(arguments->display_args);
    gt_str_delete(arguments->matchfilename);
    gt_free(arguments);
  }
}

// Assembly:
testq %rdi, %rdi
je 0xc811c
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x11c144
movq 0x8(%rbx), %rdi
callq 0x11bdbf
leaq 0x292362(%rip), %rsi    # 0x35a470
movq %rbx, %rdi
movl $0x3e, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_show_seedext.c
// Function: gt_show_seedext_arguments_check
static int gt_show_seedext_arguments_check(GT_UNUSED int rest_argc,
                                           void *tool_arguments,
                                           GtError *err)
{
  GtShowSeedextArguments *arguments = tool_arguments;
  int had_err = 0;

  gt_error_check(err);
  gt_assert(arguments != NULL);
  if (arguments->matchfilename == NULL ||
      gt_str_length(arguments->matchfilename) == 0)
  {
    gt_error_set(err,"option -f requires a file name");
    had_err = -1;
  }
  return had_err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdx, %rdx
je 0xc826d
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xc82ad
testq %r14, %r14
je 0xc82a8
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xc828a
callq 0x11b0ca
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
jne 0xc82a0
leaq 0x292366(%rip), %rsi    # 0x35a5f7
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1fffd
callq 0x1ffc4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_shredder.c
// Function: gt_shredder_arguments_delete
static void gt_shredder_arguments_delete(void *tool_arguments)
{
  ShredderArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xc8933
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xff22c
movq (%rbx), %rdi
callq 0x10b00c
leaq 0x291d37(%rip), %rsi    # 0x35a65c
movq %rbx, %rdi
movl $0x35, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_shredder.c
// Function: gt_shredder_arguments_check
static int gt_shredder_arguments_check(GT_UNUSED int rest_argc,
                                       void *tool_arguments, GtError *err)
{
  ShredderArguments *arguments = tool_arguments;
  gt_error_check(err);
  gt_assert(arguments);
  if (arguments->minlength > arguments->maxlength) {
    gt_error_set(err, "-minlength must be <= than -maxlength");
    return -1;
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdx, %rdx
je 0xc8aa9
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xc8add
testq %r14, %r14
je 0xc8ad8
movq 0x18(%r14), %rcx
xorl %eax, %eax
cmpq 0x20(%r14), %rcx
jbe 0xc8ad0
leaq 0x291dbf(%rip), %rsi    # 0x35a880
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x20116
callq 0x200df
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_shulen.c
// Function: gt_shulengthdist_arguments_new
static void *gt_shulengthdist_arguments_new(void)
{
  Shulengthoptions *arguments;

  arguments = gt_malloc(sizeof (*arguments));
  arguments->indexname = gt_str_new();
  arguments->queryfilenames = gt_str_array_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x291b88(%rip), %rsi    # 0x35a8d0
movl $0x18, %edi
movl $0x72, %edx
callq 0x104226
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x8(%rbx)
callq 0x11be10
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_shulen.c
// Function: gt_shulengthdist_arguments_delete
static void gt_shulengthdist_arguments_delete(void *tool_arguments)
{
  Shulengthoptions *arguments = tool_arguments;

  if (!arguments)
  {
    return;
  }
  gt_str_delete(arguments->indexname);
  gt_str_array_delete(arguments->queryfilenames);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xc8da1
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x11bdbf
movq 0x10(%rbx), %rdi
callq 0x11c144
leaq 0x291b3d(%rip), %rsi    # 0x35a8d0
movq %rbx, %rdi
movl $0x82, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_shulen.c
// Function: gt_shulengthdist_option_parser_new
static GtOptionParser *gt_shulengthdist_option_parser_new(void *tool_arguments)
{
  GtOptionParser *op;
  GtOption *option, *queryoption, *scanoption;
  Shulengthoptions *arguments = tool_arguments;

  op = gt_option_parser_new("[options] -ii indexname",
                            "Compute distribution of pairwise "
                            "shustring lengths.");
  gt_option_parser_set_mail_address(op,"<kurtz@zbh.uni-hamburg.de>");

  option = gt_option_new_string("ii",
                                "Specify input index",
                                arguments->indexname, NULL);
  gt_option_parser_add_option(op, option);
  gt_option_is_mandatory(option);

  scanoption = gt_option_new_bool("scan","scan index rather than mapping "
                                  "it to main memory",
                                  &arguments->scanfile,
                                  false);
  gt_option_parser_add_option(op, scanoption);

  queryoption = gt_option_new_filename_array("q",
                                             "Specify query files",
                                             arguments->queryfilenames);
  gt_option_is_development_option(queryoption);
  gt_option_parser_add_option(op, queryoption);

  option = gt_option_new_bool("v",
                              "be verbose ",
                              &arguments->beverbose,
                              false);
  gt_option_parser_add_option(op, option);

  gt_option_exclude(queryoption,scanoption);
  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x2894ea(%rip), %rdi    # 0x35229e
leaq 0x291b2b(%rip), %rsi    # 0x35a8e6
callq 0x107bfe
movq %rax, %rbx
leaq 0x27d502(%rip), %rsi    # 0x3462cc
movq %rax, %rdi
callq 0x107e5c
movq 0x8(%r14), %rdx
leaq 0x2ea696(%rip), %rdi    # 0x3b3473
leaq 0x28959e(%rip), %rsi    # 0x352382
xorl %ecx, %ecx
callq 0x10a770
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x10a87b
leaq 0x2846ae(%rip), %rdi    # 0x34d4b6
leaq 0x291b0b(%rip), %rsi    # 0x35a91a
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x10(%r14), %rdx
leaq 0x2bd816(%rip), %rdi    # 0x386648
leaq 0x28c76c(%rip), %rsi    # 0x3555a5
callq 0x10a7df
movq %rax, %r12
movq %rax, %rdi
callq 0x10a9d4
movq %rbx, %rdi
movq %r12, %rsi
callq 0x107cc0
incq %r14
leaq 0x2c69d4(%rip), %rdi    # 0x38f832
leaq 0x291ae6(%rip), %rsi    # 0x35a94b
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r12, %rdi
movq %r15, %rsi
callq 0x10ab96
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/tools/gt_simreads.c
// Function: gt_simreads_arguments_new
static void* gt_simreads_arguments_new(void)
{
  GtSimreadsArguments *arguments = gt_calloc((size_t)1, sizeof *arguments);
  arguments->ofi = gt_output_file_info_new();
  arguments->distlen_filename = gt_str_new();
  arguments->distlen_file = NULL;
  arguments->dsfilename = gt_str_new();
  arguments->dlfilename = gt_str_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x29192a(%rip), %rdx    # 0x35a986
movl $0x1, %edi
movl $0x58, %esi
movl $0x2f, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x10ad60
movq %rax, 0x28(%rbx)
callq 0x11ac6c
movq %rax, 0x48(%rbx)
movq $0x0, 0x50(%rbx)
callq 0x11ac6c
movq %rax, 0x38(%rbx)
callq 0x11ac6c
movq %rax, 0x40(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_simreads.c
// Function: gt_simreads_arguments_delete
static void gt_simreads_arguments_delete(void *tool_arguments)
{
  GtSimreadsArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  if (arguments->distlen_file != NULL)
    gt_fa_fclose(arguments->distlen_file);
  gt_str_delete(arguments->distlen_filename);
  gt_str_delete(arguments->dsfilename);
  gt_str_delete(arguments->dlfilename);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xc90fd
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0xff22c
movq 0x28(%rbx), %rdi
callq 0x10b00c
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0xc90cd
callq 0xfd018
movq 0x48(%rbx), %rdi
callq 0x11bdbf
movq 0x38(%rbx), %rdi
callq 0x11bdbf
movq 0x40(%rbx), %rdi
callq 0x11bdbf
leaq 0x291897(%rip), %rsi    # 0x35a986
movq %rbx, %rdi
movl $0x43, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_simreads.c
// Function: gt_simreads_arguments_check
static int gt_simreads_arguments_check(GT_UNUSED int rest_argc,
                                       void *tool_arguments, GtError *err)
{
  GtSimreadsArguments *arguments = tool_arguments;
  int had_err = 0;

  gt_error_check(err);
  gt_assert(arguments);

  arguments->dl = (gt_str_length(arguments->dlfilename) > 0);
  arguments->ds = (gt_str_length(arguments->dsfilename) > 0);

  if ((arguments->maxlen != GT_UNDEF_UWORD) &&
      (arguments->minlen > arguments->maxlen)) {
    gt_error_set(err,
      "argument to option '-minlen' must be <= argument to option '-maxlen'");
    had_err = -1;
  }

  /* cannot use imply with outputfile_register_options registered options: */
  if (!had_err && arguments->show_progressbar && !arguments->outfp)
  {
    gt_error_set(err, "option \"-p\" requires option \"-o\"");
    had_err = -1;
  }

  if (!had_err && gt_str_length(arguments->distlen_filename) > 0)
  {
    if (gt_file_exists(gt_str_get(arguments->distlen_filename)))
    {
      arguments->distlen_file =
        gt_fa_fopen(gt_str_get(arguments->distlen_filename), "rb", err);
      if (arguments->distlen_file == NULL)
        had_err = -1;
    }
    else
    {
      gt_error_set(err, "file %s not found",
          gt_str_get(arguments->distlen_filename));
      had_err = -1;
    }
  }

  if (had_err != 0)
    gt_file_delete(arguments->outfp);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
testq %rdx, %rdx
je 0xc9405
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0xc94fd
testq %rbx, %rbx
je 0xc94f8
movq 0x40(%rbx), %rdi
callq 0x11b0ca
testq %rax, %rax
setne 0x23(%rbx)
movq 0x38(%rbx), %rdi
callq 0x11b0ca
testq %rax, %rax
setne 0x22(%rbx)
movq 0x10(%rbx), %rax
cmpq $-0x1, %rax
je 0xc944a
cmpq %rax, 0x8(%rbx)
jbe 0xc944a
leaq 0x291780(%rip), %rsi    # 0x35abc5
jmp 0xc94d3
cmpb $0x1, 0x20(%rbx)
jne 0xc9457
cmpq $0x0, 0x30(%rbx)
je 0xc94cc
movq 0x48(%rbx), %rdi
callq 0x11b0ca
xorl %ebp, %ebp
testq %rax, %rax
je 0xc94eb
movq 0x48(%rbx), %rdi
callq 0x11b0a1
movq %rax, %rdi
callq 0xff28c
movl %eax, %r15d
movq 0x48(%rbx), %rdi
callq 0x11b0a1
testb %r15b, %r15b
je 0xc94b6
leaq 0x2dc289(%rip), %rsi    # 0x3a571d
leaq 0x2914eb(%rip), %rdx    # 0x35a986
movq %rax, %rdi
movl $0xcd, %ecx
movq %r14, %r8
callq 0xfcdbb
movq %rax, 0x50(%rbx)
testq %rax, %rax
jne 0xc94eb
jmp 0xc94dd
leaq 0x29176e(%rip), %rsi    # 0x35ac2b
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfcb67
jmp 0xc94dd
leaq 0x291737(%rip), %rsi    # 0x35ac0a
movq %r14, %rdi
xorl %eax, %eax
callq 0xfcb67
movq 0x30(%rbx), %rdi
callq 0xff22c
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2029b
callq 0x20262
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_simreads.c
// Function: gt_simreads_write_dist_file
static int gt_simreads_write_dist_file(const char *title, GtDiscDistri *dist,
                                       GtStr *filename, GtError *err)
{
  int had_err = 0;
  GtFile *dfile;

  gt_assert(filename);
  gt_assert(dist);
  gt_error_check(err);
  dfile = gt_file_new(gt_str_get(filename), "w", err);
  if (!dfile)
  {
    had_err = -1;
  }
  else
  {
    gt_file_xprintf(dfile, "%s", title);
    gt_disc_distri_foreach(dist,
     (GtDiscDistriIterFunc) gt_simreads_plot_disc_distri, dfile);
    gt_file_delete(dfile);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0xc9e66
movq %rsi, %rbx
testq %rsi, %rsi
je 0xc9e6b
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r14
testq %rcx, %rcx
je 0xc9e02
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
jne 0xc9e70
movq %r12, %rdi
callq 0x11b0a1
leaq 0x2c97a4(%rip), %rsi    # 0x3935b5
movq %rax, %rdi
movq %r15, %rdx
callq 0xfea8a
testq %rax, %rax
je 0xc9e56
movq %rax, %r15
leaq 0x2fec7e(%rip), %rsi    # 0x3c8aa9
xorl %ebp, %ebp
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xfee51
leaq 0x34(%rip), %rsi        # 0xc9e75
movq %rbx, %rdi
movq %r15, %rdx
callq 0xe56e5
movq %r15, %rdi
callq 0xff22c
jmp 0xc9e5b
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x20547
callq 0x2050e
callq 0x204d5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_skproto.c
// Function: gt_skproto_runner
static int gt_skproto_runner(int argc, const char **argv, int parsed_args,
                             GT_UNUSED void *tool_arguments,
                             GT_UNUSED GtError *err)
{
  FILE *fpin;
  int i;

  gt_error_check(err);

  printf("#ifdef __cplusplus\n");
  printf("extern \"C\" {\n");
  printf("#endif\n");

  if (!argc)
    skproto("(stdout)", stdin);
  else {
    for (i = parsed_args; i < argc; i++) {
      fpin = gt_fa_xfopen(argv[i], "r");
      skproto(argv[i], fpin);
      gt_fa_xfclose(fpin);
    }
  }

  printf("#ifdef __cplusplus\n");
  printf("}\n");
  printf("#endif\n");

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movl %edi, %ebx
testq %r8, %r8
je 0xc9ee7
movq %r8, %rdi
callq 0xfcc32
testb %al, %al
jne 0xc9fab
leaq 0x2910a8(%rip), %rdi    # 0x35af96
callq 0x17bd0
leaq 0x29108f(%rip), %rdi    # 0x35af89
callq 0x17bd0
leaq 0x2910a3(%rip), %rdi    # 0x35afa9
callq 0x17bd0
testl %ebx, %ebx
je 0xc9f60
subl %ebp, %ebx
jle 0xc9f76
movslq %ebp, %rax
leaq (%r14,%rax,8), %r13
xorl %ebp, %ebp
leaq 0x290f32(%rip), %r14    # 0x35ae55
leaq 0x290fbc(%rip), %r15    # 0x35aee6
movq (%r13,%rbp,8), %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0xb1, %ecx
callq 0xfcf55
movq %rax, %r12
movq (%r13,%rbp,8), %rdi
movq %rax, %rsi
callq 0xc9fb0
movq %r12, %rdi
callq 0xfd09a
incq %rbp
cmpl %ebp, %ebx
jne 0xc9f2a
jmp 0xc9f76
movq 0x3eefb9(%rip), %rax    # 0x4b8f20
movq (%rax), %rsi
leaq 0x290f8c(%rip), %rdi    # 0x35aefd
callq 0xc9fb0
leaq 0x291019(%rip), %rdi    # 0x35af96
callq 0x17bd0
leaq 0x2fcc6c(%rip), %rdi    # 0x3c6bf5
callq 0x17bd0
leaq 0x291014(%rip), %rdi    # 0x35afa9
callq 0x17bd0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x20580
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_snpper.c
// Function: gt_snpper_arguments_new
static void* gt_snpper_arguments_new(void)
{
  GtStrArray *descs;
  GtUword i;
  GtSnpperArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->s2fi = gt_seqid2file_info_new();
  arguments->ofi = gt_output_file_info_new();
  arguments->desc = gt_str_new_cstr("NCBI translation table number, "
                                    "choose from:\n");
  descs = gt_trans_table_get_scheme_descriptions();
  for (i = 0; i < gt_str_array_size(descs); i++) {
    gt_str_append_cstr(arguments->desc, "* ");
    gt_str_append_cstr(arguments->desc, gt_str_array_get(descs, i));
    if (i != gt_str_array_size(descs)-1)
      gt_str_append_cstr(arguments->desc, "\n");
  }
  gt_str_array_delete(descs);
  return arguments;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x290c03(%rip), %rdx    # 0x35afb0
movl $0x1, %edi
movl $0x28, %esi
movl $0x2b, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x172c40
movq %rax, (%rbx)
callq 0x10ad60
movq %rax, 0x8(%rbx)
leaq 0x290bea(%rip), %rdi    # 0x35afc6
callq 0x11acc9
movq %rax, 0x20(%rbx)
callq 0x11df2c
movq %rax, %r14
movq %rax, %rdi
callq 0x11c131
testq %rax, %rax
je 0xca45d
xorl %r15d, %r15d
leaq 0x290bef(%rip), %r12    # 0x35aff3
leaq 0x2f5c94(%rip), %r13    # 0x3c009f
movq 0x20(%rbx), %rdi
movq %r12, %rsi
callq 0x11acf3
movq 0x20(%rbx), %rbp
movq %r14, %rdi
movq %r15, %rsi
callq 0x11bfb3
movq %rbp, %rdi
movq %rax, %rsi
callq 0x11acf3
movq %r14, %rdi
callq 0x11c131
decq %rax
cmpq %rax, %r15
je 0xca44d
movq 0x20(%rbx), %rdi
movq %r13, %rsi
callq 0x11acf3
incq %r15
movq %r14, %rdi
callq 0x11c131
cmpq %rax, %r15
jb 0xca40b
movq %r14, %rdi
callq 0x11c144
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_snpper.c
// Function: gt_snpper_arguments_delete
static void gt_snpper_arguments_delete(void *tool_arguments)
{
  GtSnpperArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_str_delete(arguments->desc);
  gt_output_file_info_delete(arguments->ofi);
  gt_seqid2file_info_delete(arguments->s2fi);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xca4b8
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xff22c
movq 0x20(%rbx), %rdi
callq 0x11bdbf
movq 0x8(%rbx), %rdi
callq 0x10b00c
movq (%rbx), %rdi
callq 0x172c87
leaq 0x290b06(%rip), %rsi    # 0x35afb0
movq %rbx, %rdi
movl $0x43, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_snpper.c
// Function: gt_snpper_option_parser_new
static GtOptionParser* gt_snpper_option_parser_new(void *tool_arguments)
{
  GtSnpperArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  op = gt_option_parser_new("[option ...] GFF3_file [GVF_file]",
                            "Annotates SNPs according to their effect on "
                            "the genome as given by a genomic annotation.");

  /* -trans_table */
  option = gt_option_new_uint("trans_table", gt_str_get(arguments->desc),
                              &arguments->ttable, 1);
  gt_option_parser_add_option(op, option);

  /* -seqfile, -encseq, -matchdesc, -usedesc and -regionmapping */
  gt_seqid2file_register_options(op, arguments->s2fi);

  /* output file options */
  gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);

  gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);
  gt_option_parser_set_min_max_args(op, 1, 2);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xca557
movq %rdi, %r14
leaq 0x290b42(%rip), %rdi    # 0x35b012
leaq 0x290b5d(%rip), %rsi    # 0x35b034
callq 0x107bfe
movq %rax, %rbx
movq 0x20(%r14), %rdi
callq 0x11b0a1
leaq 0x18(%r14), %rdx
leaq 0x2b2a3d(%rip), %rdi    # 0x37cf30
movq %rax, %rsi
movl $0x1, %ecx
callq 0x10a4fd
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x172f86
movq 0x8(%r14), %rdi
addq $0x10, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x10ad87
leaq 0x82394(%rip), %rsi     # 0x14c8c4
movq %rbx, %rdi
xorl %edx, %edx
callq 0x107d3d
movq %rbx, %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x10874b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x205f0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_sortbench.c
// Function: gt_sortbench_arguments_check
static int gt_sortbench_arguments_check(GT_UNUSED int rest_argc,
                                        void *tool_arguments,
                                        GtError *err)
{
  QSortBenchArguments *arguments = tool_arguments;
  int had_err = 0;

  gt_assert(arguments != NULL);
  if (arguments->use_aqsort || arguments->use_permute)
  {
    if (strcmp(gt_str_get(arguments->impl),"radixkeypair") == 0)
    {
      gt_error_set(err,"options -aqsort and -permute are bot not compatible "
                       "with option -impl radixkeypair");
      had_err = -1;
    }
    if (strcmp(gt_str_get(arguments->impl),"radixflba") == 0)
    {
      gt_error_set(err,"options -aqsort and -permute are both not compatible "
                       "with option -impl radixflba");
      had_err = -1;
    }
  }
  if (arguments->use_aqsort && arguments->use_permute)
  {
    gt_error_set(err,"options -aqsort and -permute are not compatible with "
                     "each other");
    had_err = -1;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0xca933
movq %rdx, %rbx
movq %rsi, %r14
cmpb $0x0, 0x20(%rsi)
jne 0xca8a4
xorl %ebp, %ebp
cmpb $0x1, 0x21(%r14)
jne 0xca908
movq (%r14), %rdi
callq 0x11b0a1
leaq 0x290b1b(%rip), %rsi    # 0x35b3ce
movq %rax, %rdi
callq 0x17a40
xorl %ebp, %ebp
testl %eax, %eax
jne 0xca8d7
leaq 0x290ac0(%rip), %rsi    # 0x35b388
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq (%r14), %rdi
callq 0x11b0a1
leaq 0x290b3c(%rip), %rsi    # 0x35b422
movq %rax, %rdi
callq 0x17a40
testl %eax, %eax
jne 0xca908
leaq 0x290ae2(%rip), %rsi    # 0x35b3db
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpb $0x1, 0x20(%r14)
jne 0xca92c
cmpb $0x1, 0x21(%r14)
jne 0xca92c
leaq 0x290b0f(%rip), %rsi    # 0x35b42c
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x206cc
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_sortbench.c
// Function: gt_sortbench_cmp
static int gt_sortbench_cmp(const void *px, const void *py)
{
  const GtUword x = *(const GtUword*)px;
  const GtUword y = *(const GtUword*)py;
  ncmp++;
  if (val[x]==gas && val[y]==gas) {
    if (x == candidate) {
      freeze(x);
    } else {
      freeze(y);
    }
  }
  if (val[x] == gas)
    candidate = x;
  else if (val[y] == gas)
    candidate = y;
  if (val[x] < val[y])
  {
    return -1;
  }
  if (val[x] > val[y])
  {
    return 1;
  }
  return 0;
}

// Assembly:
movq (%rdi), %rcx
movq (%rsi), %rax
leaq 0x3f2f19(%rip), %rdx    # 0x4be478
incq (%rdx)
leaq 0x3f2f07(%rip), %rdx    # 0x4be470
movq (%rdx), %rdx
movq (%rdx,%rcx,8), %rdi
leaq 0x3f2f19(%rip), %rsi    # 0x4be490
cmpq (%rsi), %rdi
jne 0xcb5ad
cmpq %rdi, (%rdx,%rax,8)
jne 0xcb5ad
leaq 0x3f2eff(%rip), %r8     # 0x4be488
leaq 0x3f2ef0(%rip), %r9     # 0x4be480
movq (%r9), %rdi
leaq 0x1(%rdi), %r10
movq %r10, (%r9)
cmpq (%r8), %rcx
jne 0xcb5a5
movq %rdi, (%rdx,%rcx,8)
jmp 0xcb5ad
movq %rdi, (%rdx,%rax,8)
movq (%rdx,%rcx,8), %rdi
movq (%rsi), %r8
movq %rcx, %rsi
cmpq %r8, %rdi
je 0xcb5c1
movq %rax, %rsi
cmpq %r8, (%rdx,%rax,8)
jne 0xcb5cb
leaq 0x3f2ec0(%rip), %rdi    # 0x4be488
movq %rsi, (%rdi)
movq (%rdx,%rcx,8), %rcx
xorl %esi, %esi
cmpq (%rdx,%rax,8), %rcx
seta %sil
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovael %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_speck.c
// Function: gt_speck_arguments_new
static void *gt_speck_arguments_new(void)
{
  SpeccheckArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->specfile = gt_str_new();
  arguments->format = gt_str_new();
  arguments->s2fi = gt_seqid2file_info_new();
  arguments->ofi = gt_output_file_info_new();
  arguments->tci = gt_typecheck_info_new();
  arguments->outfp = NULL;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x28f4d3(%rip), %rdx    # 0x35b913
movl $0x1, %edi
movl $0x38, %esi
movl $0x38, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, (%rbx)
callq 0x11ac6c
movq %rax, 0x8(%rbx)
callq 0x172c40
movq %rax, 0x18(%rbx)
callq 0x10ad60
movq %rax, 0x20(%rbx)
callq 0x1832ac
movq %rax, 0x28(%rbx)
movq $0x0, 0x30(%rbx)
movq %rbx, %rax
popq %rbx
retq