LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xc576c
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xc5859
testq %r15, %r15
je 0xc5854
movq (%r15), %rdi
callq 0x120d4c
testq %rax, %rax
jne 0xc579b
movq (%r15), %r14
movq 0x8(%r15), %rdi
xorl %esi, %esi
callq 0x121cfa
movq %r14, %rdi
movq %rax, %rsi
callq 0x12097f
movq (%r15), %rdi
callq 0x1e4814
movq %rax, %r14
movq 0x8(%r15), %rdi
callq 0x121e78
testq %rax, %rax
je 0xc57f4
movl $0x1, %r12d
leaq -0x1(%r12), %rsi
movq 0x8(%r15), %rdi
callq 0x121d35
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x1e4a75
movl %eax, %ebp
movq 0x8(%r15), %rdi
callq 0x121e78
testl %ebp, %ebp
sete %cl
cmpq %rax, %r12
jae 0xc57f8
incq %r12
testl %ebp, %ebp
je 0xc57ba
jmp 0xc57f8
movb $0x1, %cl
xorl %ebp, %ebp
testb %cl, %cl
je 0xc5809
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e4dba
movl %eax, %ebp
testl %ebp, %ebp
jne 0xc5841
movq %r14, %rdi
callq 0x1e7990
testq %rax, %rax
jne 0xc5834
movq %r14, %rdi
callq 0x1e7950
leaq 0x35(%rip), %rsi        # 0xc585e
movq %r14, %rdi
movq %rax, %rdx
callq 0x1e76d2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e732a
movl %eax, %ebp
movq %r14, %rdi
callq 0x1e48cf
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1f317
callq 0x1f2e0
// File: /workspace/github_c_makefile_star2_O1/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 0xc5877
movq -0x8(%rdx,%rax,8), %rsi
notq %rsi
addq (%rdx,%rax,8), %rsi
jmp 0xc587a
movq (%rdx), %rsi
testq %rcx, %rcx
je 0xc588d
movq -0x8(%rdx,%rcx,8), %rdi
notq %rdi
addq (%rdx,%rcx,8), %rdi
jmp 0xc5890
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_O1/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 0xc5940
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x1040fc
movq 0x10(%rbx), %rdi
callq 0x110231
leaq 0x29c0a3(%rip), %rsi    # 0x3619d5
movq %rbx, %rdi
movl $0x2f, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc59d6
movq %rdi, %r14
leaq 0x29bcd0(%rip), %rdi    # 0x361628
leaq 0x29c0ae(%rip), %rsi    # 0x361a0d
callq 0x10cc4e
movq %rax, %rbx
leaq 0x29c0e4(%rip), %rdi    # 0x361a52
leaq 0x29c0cc(%rip), %rsi    # 0x361a41
movq %r14, %rdx
movl $0x1, %ecx
movl $0x64, %r8d
callq 0x10f764
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x8(%r14), %rdi
callq 0x10f49c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x10(%r14), %rdi
addq $0x18, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x10ffa3
leaq 0x8e4db(%rip), %rsi     # 0x153e9c
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10cd8d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1f34e
// File: /workspace/github_c_makefile_star2_O1/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 0xc5e6f
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xc5ec9
testq %r14, %r14
je 0xc5ec4
xorl %eax, %eax
cmpb $0x0, (%r14)
jne 0xc5ebc
cmpb $0x0, 0x1(%r14)
jne 0xc5ebc
cmpb $0x0, 0x2(%r14)
jne 0xc5ebc
cmpb $0x0, 0x4(%r14)
jne 0xc5ebc
cmpb $0x0, 0x5(%r14)
jne 0xc5ebc
cmpb $0x0, 0x3(%r14)
jne 0xc5ebc
cmpb $0x0, 0x6(%r14)
jne 0xc5ebc
leaq 0x29bdf0(%rip), %rsi    # 0x361c9d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1f463
callq 0x1f42a
// File: /workspace/github_c_makefile_star2_O1/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 0xefce0
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0xeffd3
movq %rax, %rbx
movq 0x3fdbf9(%rip), %rbp    # 0x4c3ee8
movq (%rbp), %rsi
movl $0x3e, %edi
callq 0x1255d6
movq %r14, %rdi
callq 0xf0b65
testb %al, %al
je 0xc632f
movq %rsp, %r13
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xf079f
movq (%r13), %rdx
movq (%rbp), %rcx
movl $0x1, %esi
movq %rax, %rdi
callq 0x125658
movq (%rbp), %rsi
movl $0xa, %edi
callq 0x1255d6
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0xed76d
movq %rax, %r14
testq %rbx, %rbx
je 0xc636b
movq %r14, %rdi
callq 0xed12b
movsbl %al, %edi
movq (%rbp), %rsi
callq 0x1255d6
decq %rbx
jne 0xc6352
movq %r14, %rdi
callq 0xed7bf
movq (%rbp), %rsi
movl $0xa, %edi
callq 0x1255d6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_seqorder.c
// Function: seqorder_str_compare_lex
static int seqorder_str_compare_lex(const void *v1, const void *v2, void *data)
{
  GtUword n1 = *(const GtUword*) v1,
          n2 = *(const GtUword*) v2,
          desclen1, desclen2;
  const char *desc1, *desc2;
  int rval;

  desc1 = gt_encseq_description((GtEncseq*) data, &desclen1, n1);
  desc2 = gt_encseq_description((GtEncseq*) data, &desclen2, n2);
  rval = strncmp(desc1, desc2, GT_MIN(desclen1, desclen2) * sizeof *desc1);
  if (rval == 0)
  {
    if (desclen1 > desclen2)
    {
      return 1;
    }
    if (desclen1 < desclen2)
    {
      return -1;
    }
    return 0;
  }
  return rval;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq (%rdi), %rdx
movq (%rsi), %r14
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf079f
movq %rax, %r12
movq %rsp, %r13
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0xf079f
movq (%r15), %rcx
movq (%r13), %rdx
xorl %esi, %esi
cmpq %rdx, %rcx
sbbl %esi, %esi
cmpq %rdx, %rcx
cmovbq %rcx, %rdx
movl $0x1, %ebx
cmovbel %esi, %ebx
movq %r12, %rdi
movq %rax, %rsi
callq 0x17330
testl %eax, %eax
cmovel %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xf079f
movq %rax, %r12
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xf079f
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 0x11043f
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 0x11043f
movl %ebp, %ecx
orl %eax, %ecx
jne 0xc64df
movl 0x8(%rsp), %ebx
subl (%rsp), %ebx
jmp 0xc64ed
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
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0xc6fc9
movq 0x10(%rdx), %rcx
movq %rdi, %r8
subq %rax, %r8
incq %r8
imulq %rsi, %r8
cmpq %rcx, %rax
ja 0xc6fcb
movq 0x8(%rdx), %r9
addq %r8, (%r9,%rax,8)
incq %rax
subq %rsi, %r8
cmpq %rdi, %rax
jbe 0xc6fb1
popq %rax
retq
callq 0x1f746
// File: /workspace/github_c_makefile_star2_O1/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 0xc7050
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x1040fc
movq 0x10(%rbx), %rdi
callq 0x110231
leaq 0x29b14c(%rip), %rsi    # 0x36218e
movq %rbx, %rdi
movl $0x2d, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc70c8
movq %rdi, %rbx
leaq 0x29a5c4(%rip), %rdi    # 0x361628
leaq 0x29b161(%rip), %rsi    # 0x3621cc
callq 0x10cc4e
movq %rax, %r14
leaq 0x29b190(%rip), %rdi    # 0x36220a
leaq 0x29b197(%rip), %rsi    # 0x362218
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x10f451
movq %r14, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x8(%rbx), %rdi
callq 0x10f49c
movq %r14, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x10(%rbx), %rdi
addq $0x18, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10ffa3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1f77f
// File: /workspace/github_c_makefile_star2_O1/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 0xc72d7
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x110231
movq 0x8(%rbx), %rdi
callq 0x1040fc
leaq 0x29afb7(%rip), %rsi    # 0x362280
movq %rbx, %rdi
movl $0x34, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc7376
movq %rdi, %rbx
leaq 0x28c198(%rip), %rdi    # 0x353487
leaq 0x29afc8(%rip), %rsi    # 0x3622be
callq 0x10cc4e
movq %rax, %r14
leaq 0x18(%rbx), %rdx
leaq 0x2d7683(%rip), %rdi    # 0x39e98c
leaq 0x29afe8(%rip), %rsi    # 0x3622f8
movl $0x1, %ecx
callq 0x10f451
movq %r14, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x10(%rbx), %rdx
leaq 0x28bddc(%rip), %rdi    # 0x35310c
leaq 0x29afe4(%rip), %rsi    # 0x36231b
movl $0x3c, %ecx
callq 0x10f4c7
movq %r14, %rdi
movq %rax, %rsi
callq 0x10cd10
movq (%rbx), %rdi
addq $0x8, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10ffa3
movq %r14, %rdi
movl $0x1, %esi
callq 0x10d766
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1f824
// File: /workspace/github_c_makefile_star2_O1/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 0xc7390
movq %rdx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xc739e
testq %rbx, %rbx
je 0xc7399
xorl %eax, %eax
popq %rbx
retq
callq 0x1f892
callq 0x1f85b
// File: /workspace/github_c_makefile_star2_O1/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 0xc77f8
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x1040fc
movq 0x18(%rbx), %rdi
callq 0x110231
leaq 0x29abce(%rip), %rsi    # 0x3623b8
movq %rbx, %rdi
movl $0x35, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x29a897(%rip), %rsi    # 0x362524
movl $0x48, %edi
movl $0x83, %edx
callq 0x1092b2
movq %rax, %rbx
callq 0x1208f8
movq %rax, 0x20(%rbx)
callq 0x1208f8
movq %rax, 0x28(%rbx)
callq 0x121b54
movq %rax, 0x40(%rbx)
callq 0x121b54
movq %rax, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc7d0a
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x121b03
movq 0x28(%rbx), %rdi
callq 0x121b03
movq 0x40(%rbx), %rdi
callq 0x121e8b
movq 0x38(%rbx), %rdi
callq 0x121e8b
leaq 0x29a828(%rip), %rsi    # 0x362524
movq %rbx, %rdi
movl $0x95, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x299c56(%rip), %rdi    # 0x363485
movq %rax, %rsi
xorl %eax, %eax
callq 0x17070
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xca077
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0xca181
cmpb $0x1, 0x40(%r15)
jne 0xca0cd
movl $0xd0, %esi
addq (%r15), %rsi
leaq 0x7(%rsp), %rdi
callq 0xc9842
xorl %ebp, %ebp
testl %eax, %eax
je 0xca128
movzbl 0x7(%rsp), %ecx
cmpq $0xff, %rcx
jne 0xca11a
movl $0xe8, %esi
addq (%r15), %rsi
leaq 0x8(%rsp), %rdi
callq 0xc98b3
testl %eax, %eax
sete %r15b
je 0xca15d
movq 0x10(%rsp), %rcx
jmp 0xca12b
movq 0x20(%r15), %rax
cmpq 0x10(%r15), %rax
jae 0xca121
movq (%r15), %rdx
movq 0x60(%rdx), %rcx
leaq 0x1(%rax), %rsi
movq %rsi, 0x20(%r15)
movzbl (%rcx,%rax), %ecx
movb %cl, 0x7(%rsp)
cmpq $0xff, %rcx
jne 0xca11a
movq 0x68(%rdx), %rcx
movq 0x28(%r15), %rdx
movq %rdx, %rsi
shlq $0x4, %rsi
cmpq %rax, (%rcx,%rsi)
jne 0xca186
addq %rsi, %rcx
incq %rdx
movq %rdx, 0x28(%r15)
movq 0x8(%rcx), %rcx
xorl %ebp, %ebp
xorl %r15d, %r15d
jmp 0xca12b
movb $0x1, %r15b
xorl %ebp, %ebp
jmp 0xca12b
movb $0x1, %r15b
testb %r15b, %r15b
jne 0xca14e
cmpq %rbx, %rcx
je 0xca14e
leaq 0x298f99(%rip), %rsi    # 0x3630d5
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1019cf
movl $0x1, %ebp
negl %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x298a3e(%rip), %rsi    # 0x362ba2
leaq 0x2983b9(%rip), %rdx    # 0x362524
movq %r14, %rdi
movl $0x420, %ecx            # imm = 0x420
xorl %eax, %eax
callq 0x1019cf
movl $0x1, %ebp
jmp 0xca12b
callq 0x202de
callq 0x20317
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_sfxmap.c
// Function: gt_sfxmap_sortmaxdepth_processunsortedrange
static void gt_sfxmap_sortmaxdepth_processunsortedrange(void *voiddcov,
                                              GT_UNUSED GtSuffixsortspace *sssp,
                                              GtUword subbucketleft,
                                              GtUword width,
                                              GT_UNUSED GtUword depth)
{
  Checkunsortedrangeinfo *curi = voiddcov;

  gt_checkifprefixesareidentical(__FILE__,
                                 __LINE__,
                                 curi->encseq,
                                 curi->readmode,
                                 curi->sssp,
                                 subbucketleft,
                                 width,
                                 (GtUword) curi->sortmaxdepth);
}

// Assembly:
pushq %rax
movq %rcx, %rax
movq %rdx, %r9
movq (%rdi), %rdx
movl 0x8(%rdi), %ecx
movq 0x10(%rdi), %r8
movl 0xc(%rdi), %r10d
leaq 0x29837d(%rip), %rdi    # 0x362524
movl $0x522, %esi            # imm = 0x522
pushq %r10
pushq %rax
callq 0x2066e8
addq $0x10, %rsp
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x299206(%rip), %rdx    # 0x3634e4
movl $0x1, %edi
movl $0x18, %esi
movl $0x32, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, 0x8(%rbx)
callq 0x121b54
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xca33c
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x121e8b
movq 0x8(%rbx), %rdi
callq 0x121b03
leaq 0x2991b6(%rip), %rsi    # 0x3634e4
movq %rbx, %rdi
movl $0x3e, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xca48d
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xca4cd
testq %r14, %r14
je 0xca4c8
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xca4aa
callq 0x120d4c
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
jne 0xca4c0
leaq 0x2991ba(%rip), %rsi    # 0x36366b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x203f9
callq 0x203c0
// File: /workspace/github_c_makefile_star2_O1/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 0xcab5b
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1040fc
movq (%rbx), %rdi
callq 0x110231
leaq 0x298b83(%rip), %rsi    # 0x3636d0
movq %rbx, %rdi
movl $0x35, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcacd1
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xcad05
testq %r14, %r14
je 0xcad00
movq 0x18(%r14), %rcx
xorl %eax, %eax
cmpq 0x20(%r14), %rcx
jbe 0xcacf8
leaq 0x298c0b(%rip), %rsi    # 0x3638f4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x20512
callq 0x204db
// File: /workspace/github_c_makefile_star2_O1/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 0x2989d4(%rip), %rsi    # 0x363944
movl $0x18, %edi
movl $0x72, %edx
callq 0x1092b2
movq %rax, %rbx
callq 0x1208f8
movq %rax, 0x8(%rbx)
callq 0x121b54
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcafc9
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x121b03
movq 0x10(%rbx), %rdi
callq 0x121e8b
leaq 0x298989(%rip), %rsi    # 0x363944
movq %rbx, %rdi
movl $0x82, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2902fa(%rip), %rdi    # 0x35b2d6
leaq 0x298977(%rip), %rsi    # 0x36395a
callq 0x10cc4e
movq %rax, %rbx
leaq 0x2842da(%rip), %rsi    # 0x34f2cc
movq %rax, %rdi
callq 0x10ceab
movq 0x8(%r14), %rdx
leaq 0x2f1a8e(%rip), %rdi    # 0x3bca93
leaq 0x2903ae(%rip), %rsi    # 0x35b3ba
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10fa96
leaq 0x28b4b6(%rip), %rdi    # 0x3564e6
leaq 0x298957(%rip), %rsi    # 0x36398e
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x10(%r14), %rdx
leaq 0x2c49ce(%rip), %rdi    # 0x38fa28
leaq 0x293574(%rip), %rsi    # 0x35e5d5
callq 0x10f9f6
movq %rax, %r12
movq %rax, %rdi
callq 0x10fbef
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10cd10
incq %r14
leaq 0x2cdbd4(%rip), %rdi    # 0x398c5a
leaq 0x298932(%rip), %rsi    # 0x3639bf
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r12, %rdi
movq %r15, %rsi
callq 0x10fd9f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/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 0x29874e(%rip), %rdx    # 0x3639fa
movl $0x1, %edi
movl $0x58, %esi
movl $0x2f, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x10ff7c
movq %rax, 0x28(%rbx)
callq 0x1208f8
movq %rax, 0x48(%rbx)
movq $0x0, 0x50(%rbx)
callq 0x1208f8
movq %rax, 0x38(%rbx)
callq 0x1208f8
movq %rax, 0x40(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcb34d
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x1040fc
movq 0x28(%rbx), %rdi
callq 0x110231
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0xcb31d
callq 0x101e80
movq 0x48(%rbx), %rdi
callq 0x121b03
movq 0x38(%rbx), %rdi
callq 0x121b03
movq 0x40(%rbx), %rdi
callq 0x121b03
leaq 0x2986bb(%rip), %rsi    # 0x3639fa
movq %rbx, %rdi
movl $0x43, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcb655
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0xcb766
testq %rbx, %rbx
je 0xcb761
movq 0x40(%rbx), %rdi
callq 0x120d4c
testq %rax, %rax
setne 0x23(%rbx)
movq 0x38(%rbx), %rdi
callq 0x120d4c
testq %rax, %rax
setne 0x22(%rbx)
movq 0x10(%rbx), %rax
cmpq $-0x1, %rax
je 0xcb69a
cmpq %rax, 0x8(%rbx)
jbe 0xcb69a
leaq 0x2985a4(%rip), %rsi    # 0x363c39
jmp 0xcb734
cmpb $0x1, 0x20(%rbx)
jne 0xcb6ab
cmpq $0x0, 0x30(%rbx)
je 0xcb72d
movq 0x48(%rbx), %rdi
callq 0x120d4c
testq %rax, %rax
je 0xcb70d
movq 0x48(%rbx), %rdi
callq 0x120d23
movq %rax, %rdi
callq 0x10415c
movl %eax, %ebp
movq 0x48(%rbx), %rdi
callq 0x120d23
testb %bpl, %bpl
je 0xcb714
leaq 0x2e35de(%rip), %rsi    # 0x3aecbf
leaq 0x298312(%rip), %rdx    # 0x3639fa
movq %rax, %rdi
movl $0xcd, %ecx
movq %r14, %r8
callq 0x101c23
movq %rax, 0x50(%rbx)
xorl %ebp, %ebp
testq %rax, %rax
setne %r15b
sete %bpl
negl %ebp
jmp 0xcb746
xorl %ebp, %ebp
movb $0x1, %r15b
jmp 0xcb746
leaq 0x298584(%rip), %rsi    # 0x363c9f
xorl %r15d, %r15d
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1019cf
jmp 0xcb741
leaq 0x29854a(%rip), %rsi    # 0x363c7e
xorl %r15d, %r15d
movq %r14, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb %r15b, %r15b
jne 0xcb754
movq 0x30(%rbx), %rdi
callq 0x1040fc
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x20697
callq 0x2065e
// File: /workspace/github_c_makefile_star2_O1/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 0xcc139
movq %rsi, %rbx
testq %rsi, %rsi
je 0xcc13e
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r14
testq %rcx, %rcx
je 0xcc0d5
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0xcc143
movq %r12, %rdi
callq 0x120d23
leaq 0x2d094d(%rip), %rsi    # 0x39ca31
movq %rax, %rdi
movq %r15, %rdx
callq 0x103957
testq %rax, %rax
je 0xcc129
movq %rax, %r15
leaq 0x3060d3(%rip), %rsi    # 0x3d21d1
xorl %ebp, %ebp
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x103d21
leaq 0x34(%rip), %rsi        # 0xcc148
movq %rbx, %rdi
movq %r15, %rdx
callq 0xe9bdf
movq %r15, %rdi
callq 0x1040fc
jmp 0xcc12e
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x20943
callq 0x2090a
callq 0x208d1
// File: /workspace/github_c_makefile_star2_O1/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 0xcc1bb
movq %r8, %rdi
callq 0x101a9a
testb %al, %al
jne 0xcc27f
leaq 0x297e4f(%rip), %rdi    # 0x364011
callq 0x17bd0
leaq 0x297e36(%rip), %rdi    # 0x364004
callq 0x17bd0
leaq 0x297e4a(%rip), %rdi    # 0x364024
callq 0x17bd0
testl %ebx, %ebx
je 0xcc234
subl %ebp, %ebx
jle 0xcc24a
movslq %ebp, %rax
leaq (%r14,%rax,8), %r13
xorl %ebp, %ebp
leaq 0x297cd2(%rip), %r14    # 0x363ec9
leaq 0x297d5c(%rip), %r15    # 0x363f5a
movq (%r13,%rbp,8), %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0xb1, %ecx
callq 0x101dbd
movq %rax, %r12
movq (%r13,%rbp,8), %rdi
movq %rax, %rsi
callq 0xcc284
movq %r12, %rdi
callq 0x101f02
incq %rbp
cmpl %ebp, %ebx
jne 0xcc1fe
jmp 0xcc24a
movq 0x3f7ced(%rip), %rax    # 0x4c3f28
movq (%rax), %rsi
leaq 0x297d2c(%rip), %rdi    # 0x363f71
callq 0xcc284
leaq 0x297dc0(%rip), %rdi    # 0x364011
callq 0x17bd0
leaq 0x3040c8(%rip), %rdi    # 0x3d0325
callq 0x17bd0
leaq 0x297dbb(%rip), %rdi    # 0x364024
callq 0x17bd0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2097c
// File: /workspace/github_c_makefile_star2_O1/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 0x29799e(%rip), %rdx    # 0x36402b
movl $0x1, %edi
movl $0x28, %esi
movl $0x2b, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x17b020
movq %rax, (%rbx)
callq 0x10ff7c
movq %rax, 0x8(%rbx)
leaq 0x297985(%rip), %rdi    # 0x364041
callq 0x120955
movq %rax, 0x20(%rbx)
callq 0x123c3c
movq %rax, %r14
movq %rax, %rdi
callq 0x121e78
testq %rax, %rax
je 0xcc73d
xorl %r15d, %r15d
leaq 0x29798a(%rip), %r12    # 0x36406e
leaq 0x2fd034(%rip), %r13    # 0x3c971f
movq 0x20(%rbx), %rdi
movq %r12, %rsi
callq 0x12097f
movq 0x20(%rbx), %rbp
movq %r14, %rdi
movq %r15, %rsi
callq 0x121cfa
movq %rbp, %rdi
movq %rax, %rsi
callq 0x12097f
movq %r14, %rdi
callq 0x121e78
decq %rax
cmpq %rax, %r15
je 0xcc72d
movq 0x20(%rbx), %rdi
movq %r13, %rsi
callq 0x12097f
incq %r15
movq %r14, %rdi
callq 0x121e78
cmpq %rax, %r15
jb 0xcc6eb
movq %r14, %rdi
callq 0x121e8b
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_O1/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 0xcc798
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x1040fc
movq 0x20(%rbx), %rdi
callq 0x121b03
movq 0x8(%rbx), %rdi
callq 0x110231
movq (%rbx), %rdi
callq 0x17b067
leaq 0x2978a1(%rip), %rsi    # 0x36402b
movq %rbx, %rdi
movl $0x43, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcc837
movq %rdi, %r14
leaq 0x2978dd(%rip), %rdi    # 0x36408d
leaq 0x2978f8(%rip), %rsi    # 0x3640af
callq 0x10cc4e
movq %rax, %rbx
movq 0x20(%r14), %rdi
callq 0x120d23
leaq 0x18(%r14), %rdx
leaq 0x2b9acd(%rip), %rdi    # 0x3862a0
movq %rax, %rsi
movl $0x1, %ecx
callq 0x10f719
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x17b366
movq 0x8(%r14), %rdi
addq $0x10, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x10ffa3
leaq 0x8768c(%rip), %rsi     # 0x153e9c
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10cd8d
movq %rbx, %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x10d784
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x209ec
// File: /workspace/github_c_makefile_star2_O1/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 0xccc3b
movq %rdx, %rbx
movq %rsi, %r14
cmpb $0x0, 0x20(%rsi)
jne 0xccbac
xorl %ebp, %ebp
cmpb $0x1, 0x21(%r14)
jne 0xccc10
movq (%r14), %rdi
callq 0x120d23
leaq 0x2978b3(%rip), %rsi    # 0x36446e
movq %rax, %rdi
callq 0x17a40
xorl %ebp, %ebp
testl %eax, %eax
jne 0xccbdf
leaq 0x297858(%rip), %rsi    # 0x364428
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq (%r14), %rdi
callq 0x120d23
leaq 0x2978d4(%rip), %rsi    # 0x3644c2
movq %rax, %rdi
callq 0x17a40
testl %eax, %eax
jne 0xccc10
leaq 0x29787a(%rip), %rsi    # 0x36447b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpb $0x1, 0x20(%r14)
jne 0xccc34
cmpb $0x1, 0x21(%r14)
jne 0xccc34
leaq 0x2978a7(%rip), %rsi    # 0x3644cc
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x20b01