LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x478cf
movq -0x8(%rdx,%rax,8), %rsi
notq %rsi
addq (%rdx,%rax,8), %rsi
jmp 0x478d2
movq (%rdx), %rsi
testq %rcx, %rcx
je 0x478e5
movq -0x8(%rdx,%rcx,8), %rdi
notq %rdi
addq (%rdx,%rcx,8), %rdi
jmp 0x478e8
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_O2/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 0x47990
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x8da06
movq 0x10(%rbx), %rdi
callq 0x9ba24
leaq 0x2b100e(%rip), %rsi    # 0x2f8992
pushq $0x2f
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x47a22
movq %rdi, %r14
leaq 0x2b0c3d(%rip), %rdi    # 0x2f85e5
leaq 0x2b101b(%rip), %rsi    # 0x2f89ca
callq 0x97df5
movq %rax, %rbx
leaq 0x2b1051(%rip), %rdi    # 0x2f8a0f
leaq 0x2b1039(%rip), %rsi    # 0x2f89fe
pushq $0x1
popq %rcx
pushq $0x64
popq %r8
movq %r14, %rdx
callq 0x9ac01
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x8(%r14), %rdi
callq 0x9a9ce
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x10(%r14), %rdi
addq $0x18, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x9b6d7
leaq 0x9fadf(%rip), %rsi     # 0xe74ec
movq %rbx, %rdi
xorl %edx, %edx
callq 0x98045
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3f053f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29d5e0(%rip), %rsi    # 0x2e5013
leaq 0x300c19(%rip), %rdx    # 0x348653
leaq 0x2b0f6a(%rip), %rcx    # 0x2f89ab
leaq 0x2b0f4a(%rip), %r8     # 0x2f8992
pushq $0x37
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x47f27
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x47fa8
testq %r14, %r14
je 0x47f7a
xorl %eax, %eax
cmpb $0x0, (%r14)
jne 0x47f72
cmpb $0x0, 0x1(%r14)
jne 0x47f72
cmpb $0x0, 0x2(%r14)
jne 0x47f72
cmpb $0x0, 0x4(%r14)
jne 0x47f72
cmpb $0x0, 0x5(%r14)
jne 0x47f72
cmpb $0x0, 0x3(%r14)
jne 0x47f72
cmpb $0x0, 0x6(%r14)
jne 0x47f72
leaq 0x2b0cc0(%rip), %rsi    # 0x2f8c25
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3effe7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29d088(%rip), %rsi    # 0x2e5013
leaq 0x29e2da(%rip), %rdx    # 0x2e626c
leaq 0x2b0c70(%rip), %rcx    # 0x2f8c09
leaq 0x2b0a88(%rip), %r8     # 0x2f8a28
movl $0x8d, %r9d
jmp 0x47fd4
movq 0x3effb9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29d05a(%rip), %rsi    # 0x2e5013
leaq 0x29d1ff(%rip), %rdx    # 0x2e51bf
leaq 0x2b0c42(%rip), %rcx    # 0x2f8c09
leaq 0x2b0a5a(%rip), %r8     # 0x2f8a28
movl $0x8c, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rsp)
movq %rsi, %rdi
movq %r12, %rsi
callq 0x74d9c
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x75173
movq %rax, %rbx
movq 0x3efa8a(%rip), %rbp    # 0x437eb0
movq (%rbp), %rsi
pushq $0x3e
popq %rdi
callq 0xb2f2e
movq %r14, %rdi
callq 0x7609a
testb %al, %al
je 0x48462
movq %rsp, %r13
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x75b24
movq (%r13), %rdx
movq (%rbp), %rcx
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xb302c
movq (%rbp), %rsi
pushq $0xa
popq %rdi
callq 0xb2f2e
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x72260
movq %rax, %r14
subq $0x1, %rbx
jb 0x4849a
movq %r14, %rdi
callq 0x719ea
movsbl %al, %edi
movq (%rbp), %rsi
callq 0xb2f2e
jmp 0x4847e
movq %r14, %rdi
callq 0x722ae
movq (%rbp), %rsi
pushq $0xa
popq %rdi
callq 0xb2f2e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x75b24
movq %rax, %r12
movq %rsp, %r13
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x75b24
movq (%r15), %rcx
movq (%r13), %rdx
xorl %esi, %esi
cmpq %rdx, %rcx
sbbl %esi, %esi
cmpq %rdx, %rcx
cmovbq %rcx, %rdx
pushq $0x1
popq %rbx
cmovbel %esi, %ebx
movq %r12, %rdi
movq %rax, %rsi
callq 0x17310
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_O2/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 0x75b24
movq %rax, %r12
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x75b24
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 0x17350
xorl %ebx, %ebx
movb %bl, 0x20(%rsp,%rbp)
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x9bd05
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 0x17350
movb %bl, 0x20(%rsp,%r12)
movq %rsp, %rdi
movq %r13, %rsi
callq 0x9bd05
movl %ebp, %ecx
orl %eax, %ecx
jne 0x48608
movl 0x8(%rsp), %ebx
subl (%rsp), %ebx
jmp 0x48616
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
nop
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rcx
subq %rax, %rcx
incq %rcx
imulq %rsi, %rcx
cmpq %rdi, %rax
ja 0x49173
cmpq 0x10(%rdx), %rax
ja 0x49175
movq 0x8(%rdx), %r8
addq %rcx, (%r8,%rax,8)
incq %rax
subq %rsi, %rcx
jmp 0x49158
popq %rax
retq
movq 0x3eedec(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29be8d(%rip), %rsi    # 0x2e5013
leaq 0x2aff59(%rip), %rdx    # 0x2f90e6
leaq 0x2aff70(%rip), %rcx    # 0x2f9104
leaq 0x2afb80(%rip), %r8     # 0x2f8d1b
movl $0xd2, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x49228
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x8da06
movq 0x10(%rbx), %rdi
callq 0x9ba24
leaq 0x2afefa(%rip), %rsi    # 0x2f9116
pushq $0x2d
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x492a0
movq %rdi, %rbx
leaq 0x2af3a9(%rip), %rdi    # 0x2f85e5
leaq 0x2aff11(%rip), %rsi    # 0x2f9154
callq 0x97df5
movq %rax, %r14
leaq 0x2aff40(%rip), %rdi    # 0x2f9192
leaq 0x2aff47(%rip), %rsi    # 0x2f91a0
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x9a997
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x8(%rbx), %rdi
callq 0x9a9ce
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x10(%rbx), %rdi
addq $0x18, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9b6d7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3eecc1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29bd62(%rip), %rsi    # 0x2e5013
leaq 0x2ff39b(%rip), %rdx    # 0x348653
leaq 0x2afe73(%rip), %rcx    # 0x2f9132
leaq 0x2afe50(%rip), %r8     # 0x2f9116
pushq $0x35
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x494f7
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x9ba24
movq 0x8(%rbx), %rdi
callq 0x8da06
leaq 0x2afd1d(%rip), %rsi    # 0x2f9208
pushq $0x34
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x4958e
movq %rdi, %rbx
leaq 0x2a0f68(%rip), %rdi    # 0x2ea477
leaq 0x2afd30(%rip), %rsi    # 0x2f9246
callq 0x97df5
movq %rax, %r14
leaq 0x18(%rbx), %rdx
leaq 0x2ec32b(%rip), %rdi    # 0x335854
leaq 0x2afd50(%rip), %rsi    # 0x2f9280
pushq $0x1
popq %rbp
movl %ebp, %ecx
callq 0x9a997
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x10(%rbx), %rdx
leaq 0x2a0bac(%rip), %rdi    # 0x2ea0fc
leaq 0x2afd4c(%rip), %rsi    # 0x2f92a3
pushq $0x3c
popq %rcx
callq 0x9a9e6
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
movq (%rbx), %rdi
addq $0x8, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9b6d7
movq %r14, %rdi
movl %ebp, %esi
callq 0x98be7
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x3ee9d3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29ba74(%rip), %rsi    # 0x2e5013
leaq 0x2ff0ad(%rip), %rdx    # 0x348653
leaq 0x2afc77(%rip), %rcx    # 0x2f9224
leaq 0x2afc54(%rip), %r8     # 0x2f9208
pushq $0x3c
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x495d9
movq %rdx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x4960c
testq %rbx, %rbx
je 0x495e2
xorl %eax, %eax
popq %rbx
retq
movq 0x3ee97f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29ba20(%rip), %rsi    # 0x2e5013
leaq 0x2ff059(%rip), %rdx    # 0x348653
leaq 0x2afccd(%rip), %rcx    # 0x2f92ce
leaq 0x2afc00(%rip), %r8     # 0x2f9208
pushq $0x59
jmp 0x49634
movq 0x3ee955(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29b9f6(%rip), %rsi    # 0x2e5013
leaq 0x29bb9b(%rip), %rdx    # 0x2e51bf
leaq 0x2afca3(%rip), %rcx    # 0x2f92ce
leaq 0x2afbd6(%rip), %r8     # 0x2f9208
pushq $0x58
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x49ad8
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x8da06
movq 0x18(%rbx), %rdi
callq 0x9ba24
leaq 0x2af874(%rip), %rsi    # 0x2f9340
pushq $0x35
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2af4b7(%rip), %rsi    # 0x2f94ac
pushq $0x48
popq %rdi
movl $0x83, %edx
callq 0x93160
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x20(%rbx)
callq 0xacb84
movq %rax, 0x28(%rbx)
callq 0xae154
movq %rax, 0x40(%rbx)
callq 0xae154
movq %rax, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4a070
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0xae103
movq 0x28(%rbx), %rdi
callq 0xae103
movq 0x40(%rbx), %rdi
callq 0xae662
movq 0x38(%rbx), %rdi
callq 0xae662
leaq 0x2af44a(%rip), %rsi    # 0x2f94ac
movq %rbx, %rdi
movl $0x95, %edx
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2adc0a(%rip), %rdi    # 0x2fa3e9
movq %rax, %rsi
xorl %eax, %eax
callq 0x17070
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4c930
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x4ca2c
cmpb $0x1, 0x40(%r15)
jne 0x4c986
movl $0xd0, %esi
addq (%r15), %rsi
leaq 0x7(%rsp), %rdi
callq 0x4c7f2
testl %eax, %eax
je 0x4c9fb
movzbl 0x7(%rsp), %ecx
cmpq $0xff, %rcx
jne 0x4c9d3
movl $0xe8, %esi
addq (%r15), %rsi
leaq 0x8(%rsp), %rdi
callq 0x4c87a
testl %eax, %eax
sete %r15b
je 0x4ca0a
xorl %ebp, %ebp
movq 0x10(%rsp), %rcx
jmp 0x4c9d8
movq 0x20(%r15), %rax
cmpq 0x10(%r15), %rax
jae 0x4c9fb
movq (%r15), %rdx
movq 0x60(%rdx), %rcx
leaq 0x1(%rax), %rsi
movq %rsi, 0x20(%r15)
movzbl (%rcx,%rax), %ecx
cmpq $0xff, %rcx
jne 0x4c9d3
movq 0x68(%rdx), %rcx
movq 0x28(%r15), %rdx
movq %rdx, %rsi
shlq $0x4, %rsi
cmpq %rax, (%rcx,%rsi)
jne 0x4ca64
addq %rsi, %rcx
incq %rdx
movq %rdx, 0x28(%r15)
movq 0x8(%rcx), %rcx
xorl %ebp, %ebp
xorl %r15d, %r15d
testb %r15b, %r15b
jne 0x4c9fd
cmpq %rbx, %rcx
je 0x4c9fd
pushq $-0x1
popq %rbp
leaq 0x2ad64d(%rip), %rsi    # 0x2fa039
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x89dbb
jmp 0x4c9fd
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ad10c(%rip), %rsi    # 0x2f9b1d
leaq 0x2aca94(%rip), %rdx    # 0x2f94ac
movq %r14, %rdi
movl $0x420, %ecx            # imm = 0x420
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rbp
jmp 0x4c9d8
movq 0x3eb535(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2985d6(%rip), %rsi    # 0x2e5013
leaq 0x29877b(%rip), %rdx    # 0x2e51bf
leaq 0x2ad5d4(%rip), %rcx    # 0x2fa01f
leaq 0x2aca5a(%rip), %r8     # 0x2f94ac
movl $0x41d, %r9d            # imm = 0x41D
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x3eb4fd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29859e(%rip), %rsi    # 0x2e5013
leaq 0x2ad0de(%rip), %rdx    # 0x2f9b5a
leaq 0x2ad59c(%rip), %rcx    # 0x2fa01f
leaq 0x2aca22(%rip), %r8     # 0x2f94ac
movl $0x420, %r9d            # imm = 0x420
jmp 0x4ca58
// File: /workspace/github_c_makefile_star2_O2/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 0x2ac9fe(%rip), %rdi    # 0x2f94ac
movl $0x522, %esi            # imm = 0x522
pushq %r10
pushq %rax
callq 0x1b0404
popq %rax
popq %rcx
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2ad831(%rip), %rdx    # 0x2fa448
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
pushq $0x32
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x8(%rbx)
callq 0xae154
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4cc6d
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xae662
movq 0x8(%rbx), %rdi
callq 0xae103
leaq 0x2ad7e7(%rip), %rsi    # 0x2fa448
pushq $0x3e
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4cdef
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x4ce56
testq %r14, %r14
je 0x4ce28
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x4ce0c
callq 0xad289
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
jne 0x4ce20
leaq 0x2ad7bc(%rip), %rsi    # 0x2fa5cf
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3eb139(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2981da(%rip), %rsi    # 0x2e5013
leaq 0x29942c(%rip), %rdx    # 0x2e626c
leaq 0x2ad768(%rip), %rcx    # 0x2fa5af
leaq 0x2ad5fa(%rip), %r8     # 0x2fa448
movl $0x85, %r9d
jmp 0x4ce82
movq 0x3eb10b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2981ac(%rip), %rsi    # 0x2e5013
leaq 0x298351(%rip), %rdx    # 0x2e51bf
leaq 0x2ad73a(%rip), %rcx    # 0x2fa5af
leaq 0x2ad5cc(%rip), %r8     # 0x2fa448
movl $0x84, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x4d503
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x8da06
movq (%rbx), %rdi
callq 0x9ba24
leaq 0x2ad13d(%rip), %rsi    # 0x2fa634
pushq $0x35
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4d6a5
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x4d6fc
testq %r14, %r14
je 0x4d6d2
movq 0x18(%r14), %rcx
xorl %eax, %eax
cmpq 0x20(%r14), %rcx
jbe 0x4d6ca
leaq 0x2ad19b(%rip), %rsi    # 0x2fa858
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3ea88f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x297930(%rip), %rsi    # 0x2e5013
leaq 0x2faf69(%rip), %rdx    # 0x348653
leaq 0x2ad14b(%rip), %rcx    # 0x2fa83c
leaq 0x2acf3c(%rip), %r8     # 0x2fa634
pushq $0x65
jmp 0x4d724
movq 0x3ea865(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x297906(%rip), %rsi    # 0x2e5013
leaq 0x297aab(%rip), %rdx    # 0x2e51bf
leaq 0x2ad121(%rip), %rcx    # 0x2fa83c
leaq 0x2acf12(%rip), %r8     # 0x2fa634
pushq $0x64
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2acf08(%rip), %rsi    # 0x2fa8a8
pushq $0x18
popq %rdi
pushq $0x72
popq %rdx
callq 0x93160
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x8(%rbx)
callq 0xae154
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4d9f5
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xae103
movq 0x10(%rbx), %rdi
callq 0xae662
leaq 0x2acec1(%rip), %rsi    # 0x2fa8a8
movq %rbx, %rdi
movl $0x82, %edx
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2a48a6(%rip), %rdi    # 0x2f22ae
leaq 0x2aceaf(%rip), %rsi    # 0x2fa8be
callq 0x97df5
movq %rax, %rbx
leaq 0x2988ae(%rip), %rsi    # 0x2e62cc
movq %rax, %rdi
callq 0x98288
movq 0x8(%r14), %rdx
leaq 0x305ea2(%rip), %rdi    # 0x3538d3
leaq 0x2a495a(%rip), %rsi    # 0x2f2392
xorl %ecx, %ecx
callq 0x9ad12
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r15, %rdi
callq 0x9ae37
leaq 0x29fa5a(%rip), %rdi    # 0x2ed4b6
leaq 0x2ace8f(%rip), %rsi    # 0x2fa8f2
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x10(%r14), %rdx
leaq 0x2d8fc2(%rip), %rdi    # 0x326a48
leaq 0x2a7b28(%rip), %rsi    # 0x2f55b5
callq 0x9ad7e
movq %rax, %r12
movq %rax, %rdi
callq 0x9b10a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x97f31
incq %r14
leaq 0x2e20be(%rip), %rdi    # 0x32fb70
leaq 0x2ace6a(%rip), %rsi    # 0x2fa923
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r12, %rdi
movq %r15, %rsi
callq 0x9b38d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2acc5a(%rip), %rdx    # 0x2fa95e
pushq $0x1
popq %rdi
pushq $0x58
popq %rsi
pushq $0x2f
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0x9b6b4
movq %rax, 0x28(%rbx)
callq 0xacb84
movq %rax, 0x48(%rbx)
andq $0x0, 0x50(%rbx)
callq 0xacb84
movq %rax, 0x38(%rbx)
callq 0xacb84
movq %rax, 0x40(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4dd9a
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x8da06
movq 0x28(%rbx), %rdi
callq 0x9ba24
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x4dd6c
callq 0x8a4fd
movq 0x48(%rbx), %rdi
callq 0xae103
movq 0x38(%rbx), %rdi
callq 0xae103
movq 0x40(%rbx), %rdi
callq 0xae103
leaq 0x2acbd0(%rip), %rsi    # 0x2fa95e
pushq $0x43
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4ecf6
movq %rsi, %rbx
testq %rsi, %rsi
je 0x4ed24
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r14
testq %rcx, %rcx
je 0x4ec94
movq %r15, %rdi
callq 0x89eb7
testb %al, %al
jne 0x4ed52
movq %r12, %rdi
callq 0xad1fa
leaq 0x2e4c6b(%rip), %rsi    # 0x33390e
movq %rax, %rdi
movq %r15, %rdx
callq 0x8ce05
testq %rax, %rax
je 0x4ece8
movq %rax, %r15
leaq 0x31a1ec(%rip), %rsi    # 0x368ea9
xorl %ebp, %ebp
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x8d432
leaq 0xb7(%rip), %rsi        # 0x4ed8a
movq %rbx, %rdi
movq %r15, %rdx
callq 0x6dc7c
movq %r15, %rdi
callq 0x8da06
jmp 0x4eceb
pushq $-0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x3e926b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29630c(%rip), %rsi    # 0x2e5013
leaq 0x31782a(%rip), %rdx    # 0x366538
leaq 0x2ac14a(%rip), %rcx    # 0x2fae5f
leaq 0x2abc42(%rip), %r8     # 0x2fa95e
movl $0xed, %r9d
jmp 0x4ed7e
movq 0x3e923d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2962de(%rip), %rsi    # 0x2e5013
leaq 0x2ac10c(%rip), %rdx    # 0x2fae48
leaq 0x2ac11c(%rip), %rcx    # 0x2fae5f
leaq 0x2abc14(%rip), %r8     # 0x2fa95e
movl $0xee, %r9d
jmp 0x4ed7e
movq 0x3e920f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2962b0(%rip), %rsi    # 0x2e5013
leaq 0x296455(%rip), %rdx    # 0x2e51bf
leaq 0x2ac0ee(%rip), %rcx    # 0x2fae5f
leaq 0x2abbe6(%rip), %r8     # 0x2fa95e
movl $0xef, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movl %edi, %r14d
testq %r8, %r8
je 0x4ee00
movq %r8, %rdi
callq 0x89eb7
testb %al, %al
jne 0x4eebd
leaq 0x2ac167(%rip), %rdi    # 0x2faf6e
callq 0x17b60
leaq 0x2ac14e(%rip), %rdi    # 0x2faf61
callq 0x17b60
leaq 0x2ac162(%rip), %rdi    # 0x2faf81
callq 0x17b60
testl %r14d, %r14d
je 0x4ee72
movslq %ebp, %r13
movslq %r14d, %rbp
leaq 0x2abff7(%rip), %r14    # 0x2fae2d
leaq 0x2ac081(%rip), %r15    # 0x2faebe
cmpq %rbp, %r13
jge 0x4ee88
movq (%rbx,%r13,8), %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0xb1, %ecx
callq 0x8a3a7
movq %rax, %r12
movq (%rbx,%r13,8), %rdi
movq %rax, %rsi
callq 0x4eef5
movq %r12, %rdi
callq 0x8a5e5
incq %r13
jmp 0x4ee3d
movq 0x3e907f(%rip), %rax    # 0x437ef8
movq (%rax), %rsi
leaq 0x2ac052(%rip), %rdi    # 0x2faed5
callq 0x4eef5
leaq 0x2ac0df(%rip), %rdi    # 0x2faf6e
callq 0x17b60
leaq 0x31816a(%rip), %rdi    # 0x367005
callq 0x17b60
leaq 0x2ac0da(%rip), %rdi    # 0x2faf81
callq 0x17b60
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3e90a4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x296145(%rip), %rsi    # 0x2e5013
leaq 0x2962ea(%rip), %rdx    # 0x2e51bf
leaq 0x2abfd0(%rip), %rcx    # 0x2faeac
leaq 0x2abfdb(%rip), %r8     # 0x2faebe
movl $0xa7, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2abc63(%rip), %rdx    # 0x2faf88
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
pushq $0x2b
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0x116724
movq %rax, (%rbx)
callq 0x9b6b4
movq %rax, 0x8(%rbx)
leaq 0x2abc50(%rip), %rdi    # 0x2faf9e
callq 0xacbd1
movq %rax, 0x20(%rbx)
xorl %r14d, %r14d
callq 0xb11bc
movq %rax, %r15
leaq 0x2abc62(%rip), %r12    # 0x2fafcb
leaq 0x31117f(%rip), %r13    # 0x3604ef
movq %r15, %rdi
callq 0xae61c
cmpq %rax, %r14
jae 0x4f3c4
movq 0x20(%rbx), %rdi
movq %r12, %rsi
callq 0xacbfb
movq 0x20(%rbx), %rbp
movq %r15, %rdi
movq %r14, %rsi
callq 0xae386
movq %rbp, %rdi
movq %rax, %rsi
callq 0xacbfb
movq %r15, %rdi
callq 0xae61c
decq %rax
cmpq %rax, %r14
je 0x4f3bf
movq 0x20(%rbx), %rdi
movq %r13, %rsi
callq 0xacbfb
incq %r14
jmp 0x4f370
movq %r15, %rdi
callq 0xae662
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_O2/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 0x4f41d
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x8da06
movq 0x20(%rbx), %rdi
callq 0xae103
movq 0x8(%rbx), %rdi
callq 0x9ba24
movq (%rbx), %rdi
callq 0x116765
leaq 0x2abb77(%rip), %rsi    # 0x2faf88
pushq $0x43
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x4f4b4
movq %rdi, %r14
leaq 0x2abbb5(%rip), %rdi    # 0x2fafea
leaq 0x2abbd0(%rip), %rsi    # 0x2fb00c
callq 0x97df5
movq %rax, %rbx
movq 0x20(%r14), %rdi
callq 0xad1fa
leaq 0x18(%r14), %rdx
leaq 0x2cdee0(%rip), %rdi    # 0x31d338
pushq $0x1
popq %rbp
movq %rax, %rsi
movl %ebp, %ecx
callq 0x9abcd
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x116b0e
movq 0x8(%r14), %rdi
addq $0x10, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x9b6d7
leaq 0x98057(%rip), %rsi     # 0xe74ec
movq %rbx, %rdi
xorl %edx, %edx
callq 0x98045
pushq $0x2
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x98c6b
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x3e8aad(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x295b4e(%rip), %rsi    # 0x2e5013
leaq 0x2f9187(%rip), %rdx    # 0x348653
leaq 0x2abafb(%rip), %rcx    # 0x2fafce
leaq 0x2abaae(%rip), %r8     # 0x2faf88
pushq $0x4b
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x4f930
movq %rdx, %rbx
movq %rsi, %r14
cmpb $0x0, 0x20(%rsi)
jne 0x4f8a7
xorl %ebp, %ebp
cmpb $0x1, 0x21(%r14)
jne 0x4f907
movq (%r14), %rdi
callq 0xad1fa
leaq 0x2aba6e(%rip), %rsi    # 0x2fb324
movq %rax, %rdi
callq 0x179e0
xorl %ebp, %ebp
testl %eax, %eax
jne 0x4f8d8
leaq 0x2aba13(%rip), %rsi    # 0x2fb2de
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rbp
movq (%r14), %rdi
callq 0xad1fa
leaq 0x2aba91(%rip), %rsi    # 0x2fb378
movq %rax, %rdi
callq 0x179e0
testl %eax, %eax
jne 0x4f907
leaq 0x2aba37(%rip), %rsi    # 0x2fb331
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rbp
cmpb $0x1, 0x20(%r14)
jne 0x4f929
cmpb $0x1, 0x21(%r14)
jne 0x4f929
pushq $-0x1
popq %rbp
leaq 0x2aba63(%rip), %rsi    # 0x2fb382
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x3e8631(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2956d2(%rip), %rsi    # 0x2e5013
leaq 0x296924(%rip), %rdx    # 0x2e626c
leaq 0x2ab972(%rip), %rcx    # 0x2fb2c1
leaq 0x2ab720(%rip), %r8     # 0x2fb076
movl $0x83, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390