LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x652c3
movq 0x5d6d0e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4b0d77(%rip), %rsi    # 0x516013
leaq 0x5158bc(%rip), %rdx    # 0x57ab5f
leaq 0x4c47ec(%rip), %rcx    # 0x529a96
leaq 0x4c47cc(%rip), %r8     # 0x529a7d
movl $0x37, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x652c5
leaq 0x4c4404(%rip), %rdi    # 0x5296d0
leaq 0x4c47e2(%rip), %rsi    # 0x529ab5
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdx
leaq 0x4c4811(%rip), %rdi    # 0x529afa
leaq 0x4c47f9(%rip), %rsi    # 0x529ae9
movl $0x1, %ecx
movl $0x64, %r8d
callq 0xf6570
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0xf5fb0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq $0x18, %rdx
callq 0xf7d50
movq 0x10(%rsp), %rdi
leaq 0x11c982(%rip), %rsi    # 0x181ce0
xorl %eax, %eax
movl %eax, %edx
callq 0xf1770
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x65a34
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x659fc
jmp 0x65a34
movq 0x5d659d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4b0606(%rip), %rsi    # 0x516013
leaq 0x4b07ab(%rip), %rdx    # 0x5161bf
leaq 0x4c42d9(%rip), %rcx    # 0x529cf4
leaq 0x4c40f1(%rip), %r8     # 0x529b13
movl $0x8c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x65a36
jmp 0x65a38
cmpq $0x0, 0x8(%rsp)
jne 0x65a78
movq 0x5d6559(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4b05c2(%rip), %rsi    # 0x516013
leaq 0x4b182c(%rip), %rdx    # 0x517284
leaq 0x4c4295(%rip), %rcx    # 0x529cf4
leaq 0x4c40ad(%rip), %r8     # 0x529b13
movl $0x8d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x65a7a
movq 0x8(%rsp), %rax
testb $0x1, (%rax)
jne 0x65ae1
movq 0x8(%rsp), %rax
testb $0x1, 0x1(%rax)
jne 0x65ae1
movq 0x8(%rsp), %rax
testb $0x1, 0x2(%rax)
jne 0x65ae1
movq 0x8(%rsp), %rax
testb $0x1, 0x4(%rax)
jne 0x65ae1
movq 0x8(%rsp), %rax
testb $0x1, 0x5(%rax)
jne 0x65ae1
movq 0x8(%rsp), %rax
testb $0x1, 0x3(%rax)
jne 0x65ae1
movq 0x8(%rsp), %rax
testb $0x1, 0x6(%rax)
jne 0x65ae1
movl $0x1, 0x4(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x4c4236(%rip), %rsi    # 0x529d10
movb $0x0, %al
callq 0xd88c0
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seqorder.c
// Function: gt_seqorder_runner
static int gt_seqorder_runner(GT_UNUSED int argc,
                              const char **argv,
                              int parsed_args,
                              void *tool_arguments,
                              GtError *err)
{
  GtSeqorderArguments *arguments = tool_arguments;
  int had_err = 0;
  GtEncseq *encseq;
  GtEncseqLoader *loader;

  gt_error_check(err);
  gt_assert(arguments != NULL);

  /* load encseq */
  loader = gt_encseq_loader_new();
  encseq = gt_encseq_loader_load(loader, argv[parsed_args], err);
  gt_encseq_loader_delete(loader);
  if (encseq == NULL)
  {
    had_err = -1;
  }
  if (had_err == 0 && !gt_encseq_has_description_support(encseq))
  {
    gt_warning("%s has no description support", argv[parsed_args]);
  }
  if (!had_err)
  {
    gt_seqorder_handle_cases(encseq,arguments);
  }
  gt_encseq_delete(encseq);
  return had_err;
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x65b6d
movq 0x20(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x65b35
jmp 0x65b6d
movq 0x5d6464(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4b04cd(%rip), %rsi    # 0x516013
leaq 0x4b0672(%rip), %rdx    # 0x5161bf
leaq 0x4c4211(%rip), %rcx    # 0x529d65
leaq 0x4c3fb8(%rip), %r8     # 0x529b13
movl $0x183, %r9d            # imm = 0x183
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x65b6f
jmp 0x65b71
cmpq $0x0, 0x18(%rsp)
jne 0x65bb1
movq 0x5d6420(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4b0489(%rip), %rsi    # 0x516013
leaq 0x4b16f3(%rip), %rdx    # 0x517284
leaq 0x4c41cd(%rip), %rcx    # 0x529d65
leaq 0x4c3f74(%rip), %r8     # 0x529b13
movl $0x184, %r9d            # imm = 0x184
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x65bb3
callq 0xb7a40
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x38(%rsp), %rax
movslq 0x34(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x20(%rsp), %rdx
callq 0xb7aa0
movq %rax, 0x8(%rsp)
movq (%rsp), %rdi
callq 0xb7e50
cmpq $0x0, 0x8(%rsp)
jne 0x65bf6
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
cmpl $0x0, 0x14(%rsp)
jne 0x65c27
movq 0x8(%rsp), %rdi
callq 0xb24d0
testb $0x1, %al
jne 0x65c27
movq 0x38(%rsp), %rax
movslq 0x34(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x4c4158(%rip), %rdi    # 0x529d78
movb $0x0, %al
callq 0x1267d0
cmpl $0x0, 0x14(%rsp)
jne 0x65c3d
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x65c50
movq 0x8(%rsp), %rdi
callq 0xae070
movl 0x14(%rsp), %eax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xb0530
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xb09f0
movq %rax, 0x20(%rsp)
movq 0x5d5e89(%rip), %rax    # 0x63bf38
movq (%rax), %rsi
movl $0x3e, %edi
callq 0x126b70
movq 0x38(%rsp), %rdi
callq 0xb24d0
testb $0x1, %al
jne 0x660cc
jmp 0x66103
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rdx
leaq 0x18(%rsp), %rsi
callq 0xb1b40
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq 0x5d5e42(%rip), %rax    # 0x63bf38
movq (%rax), %rcx
movl $0x1, %esi
callq 0x126d30
movq 0x5d5e2e(%rip), %rax    # 0x63bf38
movq (%rax), %rsi
movl $0xa, %edi
callq 0x126b70
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rdx
xorl %esi, %esi
callq 0xac380
movq %rax, 0x30(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x6616e
movq 0x30(%rsp), %rdi
callq 0xab500
movsbl %al, %edi
movq 0x5d5de2(%rip), %rax    # 0x63bf38
movq (%rax), %rsi
callq 0x126b70
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x66136
movq 0x30(%rsp), %rdi
callq 0xac3f0
movq 0x5d5db9(%rip), %rax    # 0x63bf38
movq (%rax), %rsi
movl $0xa, %edi
callq 0x126b70
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seqorder.c
// Function: gt_seqorder_get_shuffled_seqnums
static void gt_seqorder_get_shuffled_seqnums(GtUword nofseqs,
                                             GtUword *seqnums)
{
  GtUword i, j;

  gt_assert(seqnums != NULL);
  seqnums[0] = 0;
  for (i = 1UL; i < nofseqs; i++)
  {
    j = gt_rand_max(i);
    seqnums[i] = seqnums[j];
    seqnums[j] = i;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x661ee
movq 0x5d5de3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4afe4c(%rip), %rsi    # 0x516013
leaq 0x4c3c1f(%rip), %rdx    # 0x529ded
leaq 0x4c3c28(%rip), %rcx    # 0x529dfd
leaq 0x4c3937(%rip), %r8     # 0x529b13
movl $0xac, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x661f0
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
movq $0x1, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x6625f
movq 0x10(%rsp), %rdi
callq 0xec350
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x66205
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seqorder.c
// Function: seqorder_length_compare
static int seqorder_length_compare(const void *v1, const void *v2, void *data)
{
  GtUword n1 = *(const GtUword*) v1,
          n2 = *(const GtUword*) v2;
  const GtUword *lengthtab = (const GtUword *) data;

  if (lengthtab[n1] < lengthtab[n2])
  {
    return 1;
  }
  if (lengthtab[n1] > lengthtab[n2])
  {
    return -1;
  }
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x20(%rsp), %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rsp), %rcx
movq -0x30(%rsp), %rdx
cmpq (%rcx,%rdx,8), %rax
jae 0x662cb
movl $0x1, -0x4(%rsp)
jmp 0x662fb
movq -0x38(%rsp), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rsp), %rcx
movq -0x30(%rsp), %rdx
cmpq (%rcx,%rdx,8), %rax
jbe 0x662f3
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x662fb
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rdx
leaq 0x40(%rsp), %rsi
callq 0xb1b40
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rdx
leaq 0x38(%rsp), %rsi
callq 0xb1b40
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x6638b
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x66395
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
shlq $0x0, %rdx
callq 0x192f0
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x663ee
movq 0x40(%rsp), %rax
cmpq 0x38(%rsp), %rax
jbe 0x663ce
movl $0x1, 0x74(%rsp)
jmp 0x663f6
movq 0x40(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x663e4
movl $0xffffffff, 0x74(%rsp) # imm = 0xFFFFFFFF
jmp 0x663f6
movl $0x0, 0x74(%rsp)
jmp 0x663f6
movl 0x24(%rsp), %eax
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x20a8, %rsp           # imm = 0x20A8
movq %rdi, 0x2098(%rsp)
movq %rsi, 0x2090(%rsp)
movq %rdx, 0x2088(%rsp)
movq 0x2098(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x2080(%rsp)
movq 0x2090(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x2078(%rsp)
movl $0x0, 0x204c(%rsp)
movq 0x2088(%rsp), %rdi
movq 0x2080(%rsp), %rdx
leaq 0x2070(%rsp), %rsi
callq 0xb1b40
movq %rax, 0x2040(%rsp)
movq 0x2088(%rsp), %rdi
movq 0x2078(%rsp), %rdx
leaq 0x2068(%rsp), %rsi
callq 0xb1b40
movq %rax, 0x2038(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x2040(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x2000, %eax           # imm = 0x2000
cmpq 0x2070(%rsp), %rax
jae 0x664cc
movl $0x2000, %eax           # imm = 0x2000
movq %rax, 0x18(%rsp)
jmp 0x664d9
movq 0x2070(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
shlq $0x0, %rdx
callq 0x19330
movq 0x2070(%rsp), %rax
movb $0x0, 0x30(%rsp,%rax)
leaq 0x30(%rsp), %rsi
leaq 0x2060(%rsp), %rdi
callq 0xf86d0
movl %eax, 0x2054(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x2038(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x2000, %eax           # imm = 0x2000
cmpq 0x2068(%rsp), %rax
jae 0x66548
movl $0x2000, %eax           # imm = 0x2000
movq %rax, (%rsp)
jmp 0x66554
movq 0x2068(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq (%rsp), %rdx
shlq $0x0, %rdx
callq 0x19330
movq 0x2068(%rsp), %rax
movb $0x0, 0x30(%rsp,%rax)
leaq 0x30(%rsp), %rsi
leaq 0x2058(%rsp), %rdi
callq 0xf86d0
movl %eax, 0x2050(%rsp)
cmpl $0x0, 0x2054(%rsp)
jne 0x665be
cmpl $0x0, 0x2050(%rsp)
jne 0x665be
movq 0x2060(%rsp), %rax
subq 0x2058(%rsp), %rax
movl %eax, 0x204c(%rsp)
jmp 0x665fb
cmpl $0x0, 0x2054(%rsp)
jne 0x665d5
movl $0xffffffff, 0x20a4(%rsp) # imm = 0xFFFFFFFF
jmp 0x66609
cmpl $0x0, 0x2050(%rsp)
jne 0x665ec
movl $0x1, 0x20a4(%rsp)
jmp 0x66609
movl $0x0, 0x204c(%rsp)
jmp 0x665f9
jmp 0x665fb
movl 0x204c(%rsp), %eax
movl %eax, 0x20a4(%rsp)
movl 0x20a4(%rsp), %eax
addq $0x20a8, %rsp           # imm = 0x20A8
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seqorder.c
// Function: gt_seqorder_sort
static void gt_seqorder_sort(GtSuffixsortspace *suffixsortspace,
                             const GtEncseq *encseq)
{
  Sfxstrategy sfxstrategy;

  defaultsfxstrategy(&sfxstrategy, false);
  gt_suffixsortspace_init_seqstartpos(suffixsortspace,encseq);
  gt_sortallsuffixesfromstart(suffixsortspace,
                              gt_encseq_num_of_sequences(encseq),
                              encseq, GT_READMODE_FORWARD, NULL, 0,
                              &sfxstrategy, NULL, NULL, NULL);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x666b0
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x2ea2d0
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rdi
callq 0xa9d50
movq 0x28(%rsp), %rdi
movq %rax, %rsi
movq 0x68(%rsp), %rdx
xorl %r9d, %r9d
xorl %eax, %eax
movl %eax, %r8d
leaq 0x30(%rsp), %rax
movl %r9d, %ecx
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
callq 0x2b3bf0
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-strategy.h
// Function: defaultsfxstrategy
static inline void defaultsfxstrategy(Sfxstrategy *sfxstrategy,
                                                    bool cmpcharbychar)
{
  sfxstrategy->maxwidthrealmedian = 1UL;
  sfxstrategy->maxinsertionsort = MAXINSERTIONSORTDEFAULT;
  sfxstrategy->maxbltriesort = MAXBLTRIESORTDEFAULT;
  sfxstrategy->maxcountingsort = MAXCOUNTINGSORTDEFAULT;
  sfxstrategy->differencecover = 0;
  sfxstrategy->cmpcharbychar = cmpcharbychar;
  sfxstrategy->spmopt_minlength = 0;
  sfxstrategy->storespecialcodes = false;
  sfxstrategy->iteratorbasedkmerscanning = false;
  sfxstrategy->suftabuint = false;
  sfxstrategy->onlybucketinsertion = false;
  sfxstrategy->kmerswithencseqreader = false;
  sfxstrategy->dccheck = false;
  sfxstrategy->samplewithprefixlengthnull = false;
  sfxstrategy->outsuftabonfile = true;
  sfxstrategy->noshortreadsort = false;
  sfxstrategy->compressedoutput = false;
  sfxstrategy->withradixsort = false;
  sfxstrategy->userdefinedsortmaxdepth = 0;
}

// Assembly:
movb %sil, %al
movq %rdi, -0x8(%rsp)
andb $0x1, %al
movb %al, -0x9(%rsp)
movq -0x8(%rsp), %rax
movq $0x1, (%rax)
movq -0x8(%rsp), %rax
movq $0x3, 0x8(%rax)
movq -0x8(%rsp), %rax
movq $0x3e8, 0x10(%rax)      # imm = 0x3E8
movq -0x8(%rsp), %rax
movq $0xfa0, 0x18(%rax)      # imm = 0xFA0
movq -0x8(%rsp), %rax
movl $0x0, 0x20(%rax)
movb -0x9(%rsp), %cl
movq -0x8(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x2c(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x2d(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x2e(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x2f(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x30(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x31(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x32(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x33(%rax)
movq -0x8(%rsp), %rax
movb $0x1, 0x35(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x34(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x36(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x37(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x24(%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seqstat.c
// Function: gt_seqstat_arguments_delete
static void gt_seqstat_arguments_delete(void *tool_arguments)
{
  SeqstatArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_array_delete(arguments->nstats);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x6681d
jmp 0x66841
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rdi
leaq 0x4c35e7(%rip), %rsi    # 0x529e1e
movl $0x4d, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seqstat.c
// Function: accumulateastretch
static GtUint64 accumulateastretch(GtDiscDistri *distastretch,
                                             const GtUchar *sequence,
                                             GtUword len)
{
  GtUword i, lenofastretch = 0;
  GtUint64 countA = 0;

  for (i=0; i<len; i++)
  {
    if (sequence[i] == 'A' || sequence[i] == 'a')
    {
      countA++;
      lenofastretch++;
    } else
    {
      if (lenofastretch > 0)
      {
        gt_disc_distri_add(distastretch,lenofastretch);
        lenofastretch = 0;
      }
    }
  }
  if (lenofastretch > 0)
  {
    gt_disc_distri_add(distastretch,lenofastretch);
  }
  return countA;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x67505
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x41, %eax
je 0x674b0
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x61, %eax
jne 0x674ce
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x674f0
cmpq $0x0, 0x10(%rsp)
jbe 0x674ee
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xa50a0
movq $0x0, 0x10(%rsp)
jmp 0x674f0
jmp 0x674f2
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x6747e
cmpq $0x0, 0x10(%rsp)
jbe 0x6751c
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xa50a0
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seqstat.c
// Function: showdistseqlenbinary
static void showdistseqlenbinary(GtUword key, GtUint64 value,
                            void *data)
{
  GtUword value_ul;
  /*@ignore@*/
  FILE *file = data;
  /*@end@*/

  gt_assert(value <= (GtUint64) ULONG_MAX);
  value_ul = (GtUword) value;
  gt_xfwrite(&key, sizeof (key), (size_t)1, file);
  gt_xfwrite(&value_ul, sizeof (value_ul), (size_t)1, file);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $-0x1, 0x18(%rsp)
jbe 0x6758c
movq 0x5d4a45(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4aeaae(%rip), %rsi    # 0x516013
leaq 0x4c2c15(%rip), %rdx    # 0x52a181
leaq 0x4c2c2c(%rip), %rcx    # 0x52a19f
leaq 0x4c28a4(%rip), %r8     # 0x529e1e
movl $0xaf, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x6758e
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rcx
leaq 0x20(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x126d30
movq (%rsp), %rcx
leaq 0x8(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x126d30
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seqstat.c
// Function: showdistseqlen
static void showdistseqlen(GtUword key, GtUint64 value,
                            void *data)
{
  GtUword distvalue;
  unsigned int *bucketsize = data;

  gt_assert(value <= (GtUint64) ULONG_MAX);
  distvalue = (GtUword) value;
  printf(""GT_WU"--"GT_WU" "GT_WU"\n",
         (*bucketsize) * key,
         (*bucketsize) * (key+1) - 1,
         distvalue);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $-0x1, 0x18(%rsp)
jbe 0x6762c
movq 0x5d49a5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4aea0e(%rip), %rsi    # 0x516013
leaq 0x4c2b75(%rip), %rdx    # 0x52a181
leaq 0x4c2ba1(%rip), %rcx    # 0x52a1b4
leaq 0x4c2804(%rip), %r8     # 0x529e1e
movl $0x9f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x6762e
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rax
movl (%rax), %eax
movl %eax, %esi
imulq 0x20(%rsp), %rsi
movq (%rsp), %rax
movl (%rax), %eax
movl %eax, %edx
movq 0x20(%rsp), %rax
addq $0x1, %rax
imulq %rax, %rdx
subq $0x1, %rdx
movq 0x8(%rsp), %rcx
leaq 0x4c2b58(%rip), %rdi    # 0x52a1c3
movb $0x0, %al
callq 0x19070
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seqstat.c
// Function: processastretches
static void processastretches(const GtDiscDistri *distastretch,
                              GT_UNUSED GtUint64 countA)
{
  Astretchinfo astretchinfo;
  GtUword len;

  astretchinfo.sumA = 0;
  astretchinfo.maxvalue = 0;
  astretchinfo.minkey = 10UL;
  gt_disc_distri_foreach(distastretch,showastretches,&astretchinfo);
  astretchinfo.mmercount = gt_malloc(sizeof (*astretchinfo.mmercount) *
                                    (astretchinfo.maxvalue+1));
  memset(astretchinfo.mmercount,0,sizeof (*astretchinfo.mmercount) *
                                  (astretchinfo.maxvalue+1));
  gt_disc_distri_foreach(distastretch,showmeroccurrence,&astretchinfo);
  for (len=astretchinfo.minkey; len<=astretchinfo.maxvalue; len++)
  {
    /*@ignore@*/
    printf("a^{"GT_WU"} occurs "GT_LLU" times\n",
           len,astretchinfo.mmercount[len]);
    /*@end@*/
  }
  gt_assert(astretchinfo.sumA == countA);
  gt_free(astretchinfo.mmercount);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movq $0xa, 0x20(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x10b(%rip), %rsi       # 0x677c0
leaq 0x8(%rsp), %rdx
callq 0xa55e0
movq 0x18(%rsp), %rdi
addq $0x1, %rdi
shlq $0x3, %rdi
leaq 0x4c274b(%rip), %rsi    # 0x529e1e
movl $0xff, %edx
callq 0xe80f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
addq $0x1, %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x19360
movq 0x30(%rsp), %rdi
leaq 0x129(%rip), %rsi       # 0x67830
leaq 0x8(%rsp), %rdx
callq 0xa55e0
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x18(%rsp), %rax
ja 0x67752
movq (%rsp), %rsi
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x4c2a94(%rip), %rdi    # 0x52a1d1
movb $0x0, %al
callq 0x19070
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x6771a
jmp 0x67754
movq 0x8(%rsp), %rax
cmpq 0x28(%rsp), %rax
je 0x67798
movq 0x5d4839(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4ae8a2(%rip), %rsi    # 0x516013
leaq 0x4c2a74(%rip), %rdx    # 0x52a1ec
leaq 0x4c2a89(%rip), %rcx    # 0x52a208
leaq 0x4c2698(%rip), %r8     # 0x529e1e
movl $0x10a, %r9d            # imm = 0x10A
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x6779a
movq 0x10(%rsp), %rdi
leaq 0x4c2678(%rip), %rsi    # 0x529e1e
movl $0x10b, %edx            # imm = 0x10B
callq 0xe88c0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seqstat.c
// Function: showastretches
static void showastretches(GtUword key, GtUint64 value,
                           void *data)
{
  Astretchinfo *astretchinfo = (Astretchinfo *) data;

  astretchinfo->sumA += value * (GtUint64) key;
  if (key > astretchinfo->maxvalue)
  {
    astretchinfo->maxvalue = key;
  }
  /*@ignore@*/
  printf(""GT_WU" "GT_LLU"\n", key,value);
  /*@end@*/
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
imulq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x67811
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x4c29f8(%rip), %rdi    # 0x52a21a
movb $0x0, %al
callq 0x19070
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
ja 0x678f3
jmp 0x6786b
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x678b2
movq 0x5d471f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4ae788(%rip), %rsi    # 0x516013
leaq 0x4c2992(%rip), %rdx    # 0x52a224
leaq 0x4c29a9(%rip), %rcx    # 0x52a242
leaq 0x4c257e(%rip), %r8     # 0x529e1e
movl $0xd2, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x678b4
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rax
subq 0x8(%rsp), %rax
addq $0x1, %rax
imulq %rax, %rdx
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
addq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x67859
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x6798d
jmp 0x679bf
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rdi
leaq 0x4c289f(%rip), %rsi    # 0x52a254
movl $0x2d, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x67a23
movq 0x5d45ae(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4ae617(%rip), %rsi    # 0x516013
leaq 0x51315c(%rip), %rdx    # 0x57ab5f
leaq 0x4c2866(%rip), %rcx    # 0x52a270
leaq 0x4c2843(%rip), %r8     # 0x52a254
movl $0x35, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x67a25
leaq 0x4c1ca4(%rip), %rdi    # 0x5296d0
leaq 0x4c285f(%rip), %rsi    # 0x52a292
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdx
leaq 0x4c2887(%rip), %rdi    # 0x52a2d0
leaq 0x4c288e(%rip), %rsi    # 0x52a2de
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0xf5fb0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq $0x18, %rdx
callq 0xf7d50
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x67dcd
jmp 0x67dfe
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rdi
leaq 0x4c2552(%rip), %rsi    # 0x52a346
movl $0x34, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x67e63
movq 0x5d416e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4ae1d7(%rip), %rsi    # 0x516013
leaq 0x512d1c(%rip), %rdx    # 0x57ab5f
leaq 0x4c2518(%rip), %rcx    # 0x52a362
leaq 0x4c24f5(%rip), %r8     # 0x52a346
movl $0x3c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x67e65
leaq 0x4b3654(%rip), %rdi    # 0x51b4c0
leaq 0x4c2511(%rip), %rsi    # 0x52a384
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdx
addq $0x18, %rdx
leaq 0x4fffdb(%rip), %rdi    # 0x567e68
leaq 0x4c252a(%rip), %rsi    # 0x52a3be
movl $0x1, %ecx
callq 0xf5f20
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdx
addq $0x10, %rdx
leaq 0x4b3283(%rip), %rdi    # 0x51b145
leaq 0x4c2518(%rip), %rsi    # 0x52a3e1
movl $0x3c, %ecx
callq 0xf5fe0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq $0x8, %rdx
callq 0xf7d50
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0xf2980
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x67f94
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x67f5c
jmp 0x67f94
movq 0x5d403d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4ae0a6(%rip), %rsi    # 0x516013
leaq 0x4ae24b(%rip), %rdx    # 0x5161bf
leaq 0x4c2491(%rip), %rcx    # 0x52a40c
leaq 0x4c23c4(%rip), %r8     # 0x52a346
movl $0x58, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x67f96
jmp 0x67f98
cmpq $0x0, 0x8(%rsp)
jne 0x67fd8
movq 0x5d3ff9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4ae062(%rip), %rsi    # 0x516013
leaq 0x512ba7(%rip), %rdx    # 0x57ab5f
leaq 0x4c244d(%rip), %rcx    # 0x52a40c
leaq 0x4c2380(%rip), %r8     # 0x52a346
movl $0x59, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x67fda
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x6860d
jmp 0x6863f
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rdi
leaq 0x4c1e49(%rip), %rsi    # 0x52a47e
movl $0x35, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x48, %edi
leaq 0x4c177d(%rip), %rsi    # 0x52a5ea
movl $0x83, %edx
callq 0xe80f0
movq %rax, (%rsp)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x40(%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x68f39
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rdi
leaq 0x4c16bb(%rip), %rsi    # 0x52a5ea
movl $0x95, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_sfxmap.c
// Function: gt_sfxmap_run_diffcover_check
static int gt_sfxmap_run_diffcover_check(const Sfxmapoptions *arguments,
                                         GtError *err)
{
  int had_err = 0;
  GtEncseqLoader *el = NULL;
  GtEncseq *encseq = NULL;
  const char *indexname;

  gt_error_check(err);
  indexname = gt_str_get(arguments->esaindexname);
  el = gt_encseq_loader_new();
  encseq = gt_encseq_loader_load(el, indexname, err);
  if (!encseq)
    had_err = -1;

  if (!had_err) {
    GtReadmode readmode;
    for (readmode = GT_READMODE_FORWARD;
         readmode <= GT_READMODE_REVCOMPL; readmode++) {
      gt_differencecover_check(encseq, readmode);
    }
  }
  gt_encseq_delete(encseq);
  gt_encseq_loader_delete(el);
  return had_err;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x6bca8
movq 0x28(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x6bc70
jmp 0x6bca8
movq 0x5d0329(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4aa392(%rip), %rsi    # 0x516013
leaq 0x4aa537(%rip), %rdx    # 0x5161bf
leaq 0x4bf8e9(%rip), %rcx    # 0x52b578
leaq 0x4be954(%rip), %r8     # 0x52a5ea
movl $0x573, %r9d            # imm = 0x573
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x6bcaa
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11dee0
movq %rax, 0x8(%rsp)
callq 0xb7a40
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0xb7aa0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x6bcf0
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
cmpl $0x0, 0x24(%rsp)
jne 0x6bd23
movl $0x0, 0x4(%rsp)
cmpl $0x3, 0x4(%rsp)
ja 0x6bd21
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x2bf910
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x6bcff
jmp 0x6bd23
movq 0x10(%rsp), %rdi
callq 0xae070
movq 0x18(%rsp), %rdi
callq 0xb7e50
movl 0x24(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
leaq 0x4bf827(%rip), %rdi    # 0x52b596
movb $0x0, %al
callq 0x19070
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_sfxmap.c
// Function: gt_sfxmap_deletethespranges
static void gt_sfxmap_deletethespranges(const GtEncseq *encseq,
                                        GtUword delspranges)
{
  GtSpecialrangeiterator *sri;
  GtRange range;
  GtUword rangewidth, nextpos = 0, totallength;
  const GtUword fastawidth = 70UL;

  sri = gt_specialrangeiterator_new(encseq,true);
  printf(">\n");
  while (gt_specialrangeiterator_next(sri,&range))
  {
    gt_assert(range.end > range.start);
    rangewidth = range.end - range.start;
    if (rangewidth > (GtUword) delspranges)
    {
      if (range.start == 0)
      {
        nextpos = range.end;
      } else
      {
        if (range.start > nextpos)
        {
          gt_encseq2symbolstring(stdout,
                              encseq,
                              GT_READMODE_FORWARD,
                              nextpos,
                              range.start + delspranges - nextpos,
                              fastawidth);
          nextpos = range.end;
        }
      }
    }
  }
  totallength = gt_encseq_total_length(encseq);
  if (nextpos < totallength-1)
  {
    gt_encseq2symbolstring(stdout,
                        encseq,
                        GT_READMODE_FORWARD,
                        nextpos,
                        totallength - nextpos,
                        fastawidth);
  }
  gt_specialrangeiterator_delete(sri);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x46, (%rsp)
movq 0x40(%rsp), %rdi
movl $0x1, %esi
callq 0xaf650
movq %rax, 0x30(%rsp)
leaq 0x508304(%rip), %rdi    # 0x5742be
movb $0x0, %al
callq 0x19070
movq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xaf770
testb $0x1, %al
jne 0x6bfd9
jmp 0x6c09f
jmp 0x6bfdb
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
ja 0x6c01f
movq 0x5cffb2(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4aa01b(%rip), %rsi    # 0x516013
leaq 0x4bee42(%rip), %rdx    # 0x52ae41
leaq 0x4bee53(%rip), %rcx    # 0x52ae59
leaq 0x4be5dd(%rip), %r8     # 0x52a5ea
movl $0x5c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x6c021
movq 0x28(%rsp), %rax
subq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x38(%rsp), %rax
jbe 0x6c09a
cmpq $0x0, 0x20(%rsp)
jne 0x6c050
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x6c098
movq 0x20(%rsp), %rax
cmpq 0x10(%rsp), %rax
jbe 0x6c096
movq 0x5cfed5(%rip), %rax    # 0x63bf38
movq (%rax), %rdi
movq 0x40(%rsp), %rsi
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %r8
addq 0x38(%rsp), %r8
subq 0x10(%rsp), %r8
xorl %edx, %edx
movl $0x46, %r9d
callq 0x21e3b0
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x6c098
jmp 0x6c09a
jmp 0x6bfc1
movq 0x40(%rsp), %rdi
callq 0xa9d00
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x6c0ec
movq 0x5cfe70(%rip), %rax    # 0x63bf38
movq (%rax), %rdi
movq 0x40(%rsp), %rsi
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
subq 0x10(%rsp), %r8
xorl %edx, %edx
movl $0x46, %r9d
callq 0x21e3b0
movq 0x30(%rsp), %rdi
callq 0xafc80
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_sfxmap.c
// Function: gt_sfxmap_determinenumberofwholeleaves
static GtUword gt_sfxmap_determinenumberofwholeleaves(
                                                  const GtEncseq *encseq,
                                                  GtReadmode readmode)
{
  GtUword idx, wholeleafcount = 0, totallength;
  GtEncseqReader* esr;
  GtUchar cc;
  bool sequencestart = true;

  esr = gt_encseq_create_reader_with_readmode(encseq,readmode,0);
  totallength = gt_encseq_total_length(encseq);
  for (idx = 0; idx < totallength; idx++)
  {
    cc = gt_encseq_reader_next_encoded_char(esr);
    if (cc == (GtUchar) GT_SEPARATOR)
    {
      sequencestart = true;
    } else
    {
      if (sequencestart)
      {
        if (cc != (GtUchar) GT_WILDCARD)
        {
          wholeleafcount++;
        }
        sequencestart = false;
      }
    }
  }
  gt_encseq_reader_delete(esr);
  return wholeleafcount;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq $0x0, 0x18(%rsp)
movb $0x1, 0x6(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xac380
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0xa9d00
movq %rax, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x6cd21
movq 0x8(%rsp), %rdi
callq 0xaae30
movb %al, 0x7(%rsp)
movzbl 0x7(%rsp), %eax
cmpl $0xff, %eax
jne 0x6cce7
movb $0x1, 0x6(%rsp)
jmp 0x6cd0f
testb $0x1, 0x6(%rsp)
je 0x6cd0d
movzbl 0x7(%rsp), %eax
cmpl $0xfe, %eax
je 0x6cd08
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x6(%rsp)
jmp 0x6cd0f
jmp 0x6cd11
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x6ccba
movq 0x8(%rsp), %rdi
callq 0xac3f0
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)