LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq_bench.c
// Function: gt_sortedlengthinfo_seqstart
GtUword gt_sortedlengthinfo_seqstart(const GtEncseq *encseq,
                                   const GtSortedlengthinfo *sortedlengthinfo,
                                   GtUword seqnum)
{
  if (seqnum == 0)
    return 0;
  else {
    GtUword numberofsequences = gt_encseq_num_of_sequences(encseq),
                  recordnum;

    gt_assert(seqnum < numberofsequences);
    recordnum = gt_encseq_sep2seqnum(sortedlengthinfo->seqlencount,
                                     sortedlengthinfo->numofdifferentseqlen,
                                     numberofsequences,
                                     seqnum);
    if (recordnum == 0)
      return (sortedlengthinfo->seqlentab[0] + 1) * seqnum;

    gt_assert(seqnum >= sortedlengthinfo->seqlencount[recordnum-1]);
    return sortedlengthinfo->seqlenseppos[recordnum-1] +
           (sortedlengthinfo->seqlentab[recordnum] + 1) *
           (seqnum - sortedlengthinfo->seqlencount[recordnum-1]) + 1;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0xa300a
movq %rdx, %rbx
movq %rsi, %r14
callq 0xe7bac
cmpq %rbx, %rax
jbe 0xa3024
movq 0x10(%r14), %rsi
movq 0x20(%r14), %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0xeb47d
testq %rax, %rax
je 0xa300e
movq 0x20(%r14), %rcx
subq -0x8(%rcx,%rax,8), %rbx
jb 0xa3029
movq 0x18(%r14), %rcx
movq 0x28(%r14), %rdx
movq -0x8(%rcx,%rax,8), %rcx
movq (%rdx,%rax,8), %rax
incq %rax
imulq %rbx, %rax
addq %rcx, %rax
incq %rax
jmp 0xa301c
xorl %eax, %eax
jmp 0xa301c
movq 0x28(%r14), %rax
movq (%rax), %rax
incq %rax
imulq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x19f0f
callq 0x19f48
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq_bench.c
// Function: gt_encseq_bench_option_parser_new
static GtOptionParser* gt_encseq_bench_option_parser_new(void *tool_arguments)
{
  GtEncseqBenchArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;

  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] indexname",
                            "Perform benchmark on extractions from encseq.");

  option = gt_option_new_uword("ccext", "specify number of random character "
                                        "extractions",
                               &arguments->ccext, 0UL);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_bool("solepr", "prepare data structure for sequences "
                                         "ordered by their length",
                               &arguments->sortlenprepare, false);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_verbose(&arguments->verbose);
  gt_option_parser_add_option(op, option);

  gt_option_parser_set_min_max_args(op, 1U, 1U);
  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa311f
movq %rdi, %r14
leaq 0x2a7c32(%rip), %rdi    # 0x34acc7
leaq 0x2a7c42(%rip), %rsi    # 0x34acde
callq 0x107bfe
movq %rax, %rbx
leaq 0x2a7c61(%rip), %rdi    # 0x34ad0c
leaq 0x2a7c60(%rip), %rsi    # 0x34ad12
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10a2ab
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x8(%r14), %rdx
leaq 0x2a7c6f(%rip), %rdi    # 0x34ad41
leaq 0x2a7c6f(%rip), %rsi    # 0x34ad48
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
addq $0x9, %r14
movq %r14, %rdi
callq 0x10a257
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x10874b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x19f81
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq_bitextract.c
// Function: gt_encseq_bitextract_option_parser_new
static GtOptionParser* gt_encseq_bitextract_option_parser_new(void
                                                                *tool_arguments)
{
  GtEncseqBitextractArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  op = gt_option_parser_new("[option ...] [indexname]",
                            "Extracts internal data from encoded sequences.");

  option = gt_option_new_bool("mirrored", "mirror sequence",
                               &arguments->mirror, false);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_uword("stoppos", "output stop positions",
                               &arguments->stoppos, GT_UNDEF_UWORD);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_bool("specialranges", "output special ranges",
                               &arguments->specialranges, false);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_uword("bitpos", "extract and display "
                                         "two bit encoding for position",
                               &arguments->bitpos, GT_UNDEF_UWORD);
  gt_option_parser_add_option(op, option);

  gt_encseq_options_add_readmode_option(op, arguments->readmode);

  gt_option_parser_set_min_args(op, 1U);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa385f
movq %rdi, %rbx
leaq 0x2a7938(%rip), %rdi    # 0x34b0cb
leaq 0x2a794a(%rip), %rsi    # 0x34b0e4
callq 0x107bfe
movq %rax, %r14
leaq 0x2aa196(%rip), %rdi    # 0x34d93f
leaq 0x2a7963(%rip), %rsi    # 0x34b113
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x10a235
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x18(%rbx), %rdx
leaq 0x2c435a(%rip), %rdi    # 0x367b2a
leaq 0x2a794c(%rip), %rsi    # 0x34b123
movq $-0x1, %rcx
callq 0x10a2ab
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x1(%rbx), %rdx
leaq 0x2c10fb(%rip), %rdi    # 0x3648f4
leaq 0x2a7939(%rip), %rsi    # 0x34b139
xorl %ecx, %ecx
callq 0x10a235
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x10(%rbx), %rdx
leaq 0x2a7932(%rip), %rdi    # 0x34b14f
leaq 0x2a7932(%rip), %rsi    # 0x34b156
movq $-0x1, %rcx
callq 0x10a2ab
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0xfc654
movq %r14, %rdi
movl $0x1, %esi
callq 0x10872d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1a168
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq_check.c
// Function: gt_encseq_check_option_parser_new
static GtOptionParser* gt_encseq_check_option_parser_new(void *tool_arguments)
{
  GtEncseqCheckArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GT_UNUSED GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] [file]",
                            "Check the consistency of an encoded "
                            "sequence file.");

  option = gt_option_new_uword("scantrials", "specify number of scan trials",
                               &arguments->scantrials, 0);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_uword("multicharcmptrials",
                               "specify number of multicharacter trials",
                               &arguments->multicharcmptrials, 0);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_uword_min_max("prefixlength",
                                       "prefix length",
                                       &arguments->prefixlength, 0,
                                       0, 32);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_bool("nocheckunit","do not run checkextractunitatpos",
                              &arguments->nocheckunit, false);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_bool("mirrored","use mirrored encseq",
                              &arguments->mirror, false);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_verbose(&arguments->verbose);
  gt_option_parser_add_option(op, option);

  gt_option_parser_set_min_args(op, 1);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa3c7a
movq %rdi, %r14
leaq 0x2a6b21(%rip), %rdi    # 0x34a6a1
leaq 0x2a76eb(%rip), %rsi    # 0x34b272
callq 0x107bfe
movq %rax, %rbx
leaq 0x2a770f(%rip), %rdi    # 0x34b2a5
leaq 0x2a7713(%rip), %rsi    # 0x34b2b0
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10a2ab
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x8(%r14), %rdx
leaq 0x2a7711(%rip), %rdi    # 0x34b2ce
leaq 0x2a771d(%rip), %rsi    # 0x34b2e1
xorl %ecx, %ecx
callq 0x10a2ab
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x10(%r14), %rdx
leaq 0x2fb58c(%rip), %rdi    # 0x39f16d
leaq 0x2a7721(%rip), %rsi    # 0x34b309
movl $0x20, %r9d
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10a5ff
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x1a(%r14), %rdx
leaq 0x2a7709(%rip), %rdi    # 0x34b317
leaq 0x2a770e(%rip), %rsi    # 0x34b323
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x19(%r14), %rdx
leaq 0x2a9d0d(%rip), %rdi    # 0x34d93f
leaq 0x2a770b(%rip), %rsi    # 0x34b344
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
addq $0x18, %r14
movq %r14, %rdi
callq 0x10a257
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10872d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1a20d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq_decode.c
// Function: gt_encseq_decode_arguments_check
int gt_encseq_decode_arguments_check(GT_UNUSED int rest_argc,
                                     void *tool_arguments,
                                     GtError* err)
{
  GtEncseqDecodeArguments *args = (GtEncseqDecodeArguments*) tool_arguments;
  int had_err = 0;
  int rval;

  if (gt_str_length(args->dir) > 0) {
    rval = gt_readmode_parse(gt_str_get(args->dir), err);
    if (rval < 0)
      had_err = -1;
    else
      args->rm = (GtReadmode) rval;
  }
  if (!had_err && args->seqrng.start != GT_UNDEF_UWORD &&
        args->seqrng.end != GT_UNDEF_UWORD && args->seq != GT_UNDEF_UWORD) {
    gt_error_set(err, "'-seq' and '-seqrange' cannot be used together");
    had_err = -1;
  }
  if (!had_err && (args->seqrng.start != GT_UNDEF_UWORD ||
        args->seqrng.end != GT_UNDEF_UWORD || args->seq != GT_UNDEF_UWORD)
        && strcmp(gt_str_get(args->mode), "fasta") != 0) {
    gt_error_set(err, "'-seq' and '-seqrange' can only be used with the "
                      "'-output fasta' option");
    had_err = -1;
  }
  if (!had_err && (args->rng.start != GT_UNDEF_UWORD ||
        args->rng.end != GT_UNDEF_UWORD)
        && strcmp(gt_str_get(args->mode), "concat") != 0) {
    gt_error_set(err, "'-range' can only be used with the "
                      "'-output concat' option");
    had_err = -1;
  }
  return had_err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x48(%rsi), %rdi
callq 0x11b0ca
testq %rax, %rax
je 0xa3e98
movq 0x48(%r14), %rdi
callq 0x11b0a1
movq %rax, %rdi
movq %rbx, %rsi
callq 0x113107
testl %eax, %eax
js 0xa3f26
movl %eax, 0x40(%r14)
movq 0x30(%r14), %rax
cmpq $-0x1, 0x28(%r14)
je 0xa3eb9
cmpq $-0x1, %rax
je 0xa3ec6
cmpq $-0x1, 0x50(%r14)
je 0xa3ec6
leaq 0x2a74da(%rip), %rsi    # 0x34b391
jmp 0xa3f1c
cmpq $-0x1, %rax
jne 0xa3ec6
cmpq $-0x1, 0x50(%r14)
je 0xa3eeb
movq 0x8(%r14), %rdi
callq 0x11b0a1
leaq 0x2d5c3a(%rip), %rsi    # 0x379b10
movq %rax, %rdi
callq 0x17a40
testl %eax, %eax
je 0xa3eeb
leaq 0x2a74d7(%rip), %rsi    # 0x34b3c0
jmp 0xa3f1c
cmpq $-0x1, 0x18(%r14)
jne 0xa3ef9
cmpq $-0x1, 0x20(%r14)
je 0xa3f33
movq 0x8(%r14), %rdi
callq 0x11b0a1
leaq 0x2a515b(%rip), %rsi    # 0x349064
movq %rax, %rdi
callq 0x17a40
testl %eax, %eax
je 0xa3f33
leaq 0x2a74ec(%rip), %rsi    # 0x34b408
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
jmp 0xa3f2b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq_decode.c
// Function: gt_encseq_decode_arguments_new
static void* gt_encseq_decode_arguments_new(void)
{
  GtEncseqDecodeArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->mode = gt_str_new();
  arguments->sepchar = gt_str_new();
  arguments->dir = gt_str_new();
  arguments->seqrng.start = arguments->seqrng.end = GT_UNDEF_UWORD;
  arguments->rng.start = arguments->rng.end = GT_UNDEF_UWORD;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2a74dc(%rip), %rdx    # 0x34b443
movl $0x1, %edi
movl $0x58, %esi
movl $0x2f, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x8(%rbx)
callq 0x11ac6c
movq %rax, 0x10(%rbx)
callq 0x11ac6c
movq %rax, 0x48(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x18(%rbx)
movdqu %xmm0, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq_decode.c
// Function: gt_encseq_decode_arguments_delete
static void gt_encseq_decode_arguments_delete(void *tool_arguments)
{
  GtEncseqDecodeArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->mode);
  gt_str_delete(arguments->sepchar);
  gt_str_delete(arguments->dir);
  gt_encseq_options_delete(arguments->eopts);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xa3fee
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x11bdbf
movq 0x10(%rbx), %rdi
callq 0x11bdbf
movq 0x48(%rbx), %rdi
callq 0x11bdbf
movq 0x38(%rbx), %rdi
callq 0xfc961
leaq 0x2a7463(%rip), %rsi    # 0x34b443
movq %rbx, %rdi
movl $0x40, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq_encode.c
// Function: gt_encseq_encode_arguments_delete
static void gt_encseq_encode_arguments_delete(void *tool_arguments)
{
  GtEncseqEncodeArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_encseq_options_delete(arguments->eopts);
  gt_str_delete(arguments->indexname);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xa4757
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xfc961
movq 0x10(%rbx), %rdi
callq 0x11bdbf
leaq 0x2a6f8d(%rip), %rsi    # 0x34b6d6
movq %rbx, %rdi
movl $0x33, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq_encode.c
// Function: gt_encseq_encode_option_parser_new
static GtOptionParser* gt_encseq_encode_option_parser_new(void *tool_arguments)
{
  GtOptionParser *op;
  GtOption *option;
  GtEncseqEncodeArguments *arguments =
                                      (GtEncseqEncodeArguments*) tool_arguments;

  /* init */
  op = gt_option_parser_new("sequence_file [sequence_file "
                            "[sequence_file ...]]",
                            "Encode sequence files (FASTA/FASTQ, GenBank, "
                            "EMBL) efficiently.");

  /* -showstats */
  option = gt_option_new_bool("showstats",
                              "show compression results",
                              &arguments->showstats,
                              false);
  gt_option_parser_add_option(op, option);

  /* -no_esq_header */
  option = gt_option_new_bool("no_esq_header",
                              "omit the header in the .esq file",
                              &arguments->no_esq_header,
                              false);
  gt_option_is_development_option(option);
  gt_option_parser_add_option(op, option);

  /* encoded sequence options */
  arguments->eopts = gt_encseq_options_register_encoding(op,
                                                         arguments->indexname,
                                                         NULL);

  /* -v */
  option = gt_option_new_verbose(&arguments->verbose);
  gt_option_parser_add_option(op, option);

  gt_option_parser_set_min_args(op, 1);

  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x2a6f8c(%rip), %rdi    # 0x34b6f3
leaq 0x2a6fb7(%rip), %rsi    # 0x34b725
callq 0x107bfe
movq %rax, %rbx
leaq 0x8(%r14), %rdx
leaq 0x2a6fe4(%rip), %rdi    # 0x34b765
leaq 0x2a6fe7(%rip), %rsi    # 0x34b76f
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x9(%r14), %rdx
leaq 0x2a6fe3(%rip), %rdi    # 0x34b788
leaq 0x2a6fea(%rip), %rsi    # 0x34b796
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9d4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
movq 0x10(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xfbfcc
movq %rax, (%r14)
addq $0xa, %r14
movq %r14, %rdi
callq 0x10a257
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10872d
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq_encode.c
// Function: index_size
static off_t index_size(const char *prefix, const char *suffix)
{
 off_t size = 0;
 GtStr *index_name = gt_str_new_cstr(prefix);
 gt_str_append_cstr(index_name, suffix);
 if (gt_file_exists(gt_str_get(index_name))) {
   size = gt_file_size(gt_str_get(index_name));
 }
 gt_str_delete(index_name);
 return size;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0x11acc9
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x11acf3
movq %rbx, %rdi
callq 0x11b0a1
movq %rax, %rdi
callq 0xff28c
testb %al, %al
je 0xa4b17
movq %rbx, %rdi
callq 0x11b0a1
movq %rax, %rdi
callq 0xff72f
movq %rax, %r14
jmp 0xa4b1a
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x11bdbf
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq_info.c
// Function: gt_encseq_info_arguments_delete
static void gt_encseq_info_arguments_delete(void *tool_arguments)
{
  GtEncseqInfoArguments *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 0xa4bb0
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xff22c
movq 0x8(%rbx), %rdi
callq 0x10b00c
leaq 0x2a6d29(%rip), %rsi    # 0x34b8cb
movq %rbx, %rdi
movl $0x34, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq_md5.c
// Function: gt_encseq_md5_option_parser_new
static GtOptionParser* gt_encseq_md5_option_parser_new(void *tool_arguments)
{
  GtEncseqInfoArguments *arguments = tool_arguments;
  GtOption *option;
  GtOptionParser *op;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] indexname",
                            "Display MD5 sums for an encoded sequence.");

  /* -fromindex */
  option = gt_option_new_bool("fromindex", "use MD5 table from .md5 file",
                              &arguments->fromindex, true);
  gt_option_parser_add_option(op, option);

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

  gt_option_parser_set_min_max_args(op, 1, 1);
  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa5bfb
movq %rdi, %rbx
leaq 0x2a5131(%rip), %rdi    # 0x34acc7
leaq 0x2a623f(%rip), %rsi    # 0x34bddc
callq 0x107bfe
movq %rax, %r14
leaq 0x10(%rbx), %rdx
leaq 0x2a6256(%rip), %rdi    # 0x34be06
leaq 0x2a6259(%rip), %rsi    # 0x34be10
movl $0x1, %ecx
callq 0x10a235
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
movq (%rbx), %rdi
addq $0x8, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10ad87
movq %r14, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x10874b
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1a51b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq_sample.c
// Function: gt_encseq_sample_arguments_new
static void* gt_encseq_sample_arguments_new(void)
{
  GtEncseqSampleArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->mode = gt_str_new();
  arguments->sepchar = gt_str_new();
  arguments->dir = gt_str_new();
  arguments->seqrng.start = arguments->seqrng.end = GT_UNDEF_UWORD;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2a6042(%rip), %rdx    # 0x34be8e
movl $0x1, %edi
movl $0x48, %esi
movl $0x38, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x8(%rbx)
callq 0x11ac6c
movq %rax, 0x10(%rbx)
callq 0x11ac6c
movq %rax, 0x38(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq_sample.c
// Function: gt_encseq_sample_arguments_delete
static void gt_encseq_sample_arguments_delete(void *tool_arguments)
{
  GtEncseqSampleArguments *arguments = tool_arguments;
  if (arguments != NULL) {
    gt_str_delete(arguments->mode);
    gt_str_delete(arguments->sepchar);
    gt_str_delete(arguments->dir);
    gt_encseq_options_delete(arguments->eopts);
    gt_free(arguments);
  }
}

// Assembly:
testq %rdi, %rdi
je 0xa5ece
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x11bdbf
movq 0x10(%rbx), %rdi
callq 0x11bdbf
movq 0x38(%rbx), %rdi
callq 0x11bdbf
movq 0x28(%rbx), %rdi
callq 0xfc961
leaq 0x2a5fce(%rip), %rsi    # 0x34be8e
movq %rbx, %rdi
movl $0x48, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq_sample.c
// Function: gt_encseq_sample_arguments_check
static int gt_encseq_sample_arguments_check(GT_UNUSED int rest_argc,
                                       void *tool_arguments,
                                       GT_UNUSED GtError *err)
{
  GtEncseqSampleArguments *args = (GtEncseqSampleArguments *) tool_arguments;
  int rval;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(args);

  if (gt_str_length(args->dir) > 0) {
    rval = gt_readmode_parse(gt_str_get(args->dir), err);
    if (rval < 0)
      had_err = -1;
    else
      args->rm = (GtReadmode) rval;
  }
  if (args->len == GT_UNDEF_UWORD) {
    gt_error_set(err, "length must be specified");
    return -1;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
testq %rdx, %rdx
je 0xa6030
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xa6091
testq %r14, %r14
je 0xa608c
movq 0x38(%r14), %rdi
callq 0x11b0ca
xorl %ebp, %ebp
testq %rax, %rax
je 0xa6068
movq 0x38(%r14), %rdi
callq 0x11b0a1
movq %rax, %rdi
movq %rbx, %rsi
callq 0x113107
testl %eax, %eax
js 0xa6063
movl %eax, 0x30(%r14)
jmp 0xa6068
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq $-0x1, 0x40(%r14)
jne 0xa6085
leaq 0x2a5ecb(%rip), %rsi    # 0x34bf41
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1a630
callq 0x1a5f7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq_sample.c
// Function: gt_encseq_sample_get_encseq
static GtEncseq *gt_encseq_sample_get_encseq(const char *seqfile,
                                             GtEncseqSampleArguments *args,
                                             GtError *err)
{
  GtEncseqLoader *encseq_loader;
  GtEncseq *encseq;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(seqfile);
  encseq_loader = gt_encseq_loader_new();
  if (!had_err && gt_encseq_options_lossless_value(args->eopts)) {
    gt_encseq_loader_require_lossless_support(encseq_loader);
  }
  if (!(encseq = gt_encseq_loader_load(encseq_loader, seqfile, err)))
    had_err = -1;
  if (!had_err && gt_encseq_options_mirrored_value(args->eopts)) {
    if (!gt_alphabet_is_dna(gt_encseq_alphabet(encseq))) {
      gt_error_set(err, "mirroring is only defined on DNA sequences");
      had_err = -1;
    }
    if (!had_err)
      had_err = gt_encseq_mirror(encseq, err);
  }
  gt_encseq_loader_delete(encseq_loader);
  if (!had_err) {
    if (!gt_encseq_has_description_support(encseq))
      gt_warning("Missing description support for file %s", seqfile);
    return encseq;
  } else {
    return NULL;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
testq %rdx, %rdx
je 0xa6568
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0xa663a
testq %rbx, %rbx
je 0xa6635
callq 0xef0cd
movq %rax, %r12
movq 0x28(%r13), %rdi
callq 0xfc726
testb %al, %al
je 0xa658e
movq %r12, %rdi
callq 0xf2371
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xef129
testq %rax, %rax
je 0xa6618
movq %rax, %r15
movq 0x28(%r13), %rdi
callq 0xfc76d
testb %al, %al
je 0xa65e0
movq %r15, %rdi
callq 0xebcd9
movq %rax, %rdi
callq 0xd1749
testb %al, %al
je 0xa6607
movq %r15, %rdi
movq %r14, %rsi
callq 0xf24ac
movl %eax, %ebp
movq %r12, %rdi
callq 0xefbe3
testl %ebp, %ebp
jne 0xa6620
jmp 0xa65e8
movq %r12, %rdi
callq 0xefbe3
movq %r15, %rdi
callq 0xec569
testb %al, %al
jne 0xa6623
leaq 0x2a4fea(%rip), %rdi    # 0x34b5e5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x11f68c
jmp 0xa6623
leaq 0x2a4f9c(%rip), %rsi    # 0x34b5aa
movq %r14, %rdi
xorl %eax, %eax
callq 0xfcb67
movq %r12, %rdi
callq 0xefbe3
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1a714
callq 0x1a6db
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_eval.c
// Function: gt_eval_runner
int gt_eval_runner(GT_UNUSED int argc, const char **argv, int parsed_args,
                   void *tool_arguments, GtError *err)
{
  EvalArguments *arguments = tool_arguments;
  GtNodeStream *reference_stream,
               *prediction_stream;
  GtStreamEvaluator *evaluator;
  int had_err;

  gt_error_check(err);
  gt_assert(arguments);

  /* create the reference stream */
  reference_stream = gt_gff3_in_stream_new_sorted(argv[parsed_args]);
  if (arguments->verbose)
    gt_gff3_in_stream_show_progress_bar((GtGFF3InStream*) reference_stream);

  /* create the prediction stream */
  prediction_stream = gt_gff3_in_stream_new_sorted(argv[parsed_args + 1]);
  if (arguments->verbose)
    gt_gff3_in_stream_show_progress_bar((GtGFF3InStream*) prediction_stream);

  /* create the stream evaluator */
  evaluator = gt_stream_evaluator_new(reference_stream, prediction_stream,
                                      arguments->nuceval, arguments->evalLTR,
                                      arguments->LTRdelta);

  /* compute the evaluation */
  had_err = gt_stream_evaluator_evaluate(evaluator, arguments->verbose,
                                         arguments->exondiff,
                                         arguments->exondiffcollapsed, NULL,
                                         err);

  /* show the evaluation */
  if (!had_err)
    gt_stream_evaluator_show(evaluator, arguments->outfp);

  /* free */
  gt_stream_evaluator_delete(evaluator);
  gt_node_stream_delete(prediction_stream);
  gt_node_stream_delete(reference_stream);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r12
testq %r8, %r8
je 0xa666b
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0xa671d
testq %rbx, %rbx
je 0xa6718
movslq %ebp, %r13
movq (%r12,%r13,8), %rdi
callq 0x145d7c
movq %rax, %r15
cmpb $0x1, (%rbx)
jne 0xa6690
movq %r15, %rdi
callq 0x145b36
movq 0x8(%r12,%r13,8), %rdi
callq 0x145d7c
movq %rax, %r12
cmpb $0x1, (%rbx)
jne 0xa66aa
movq %r12, %rdi
callq 0x145b36
movzbl 0x3(%rbx), %edx
movzbl 0x4(%rbx), %ecx
movq 0x8(%rbx), %r8
movq %r15, %rdi
movq %r12, %rsi
callq 0x17b098
movq %rax, %r13
movzbl (%rbx), %esi
movzbl 0x1(%rbx), %edx
movzbl 0x2(%rbx), %ecx
movq %rax, %rdi
xorl %r8d, %r8d
movq %r14, %r9
callq 0x17b488
movl %eax, %ebp
testl %eax, %eax
jne 0xa66ef
movq 0x18(%rbx), %rsi
movq %r13, %rdi
callq 0x17ca94
movq %r13, %rdi
callq 0x17d11c
movq %r12, %rdi
callq 0x162dee
movq %r15, %rdi
callq 0x162dee
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1a786
callq 0x1a74d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_eval.c
// Function: gt_eval_arguments_delete
static void gt_eval_arguments_delete(void *tool_arguments)
{
  EvalArguments *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 0xa67a2
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xff22c
movq 0x10(%rbx), %rdi
callq 0x10b00c
leaq 0x2a58b8(%rip), %rsi    # 0x34c04c
movq %rbx, %rdi
movl $0x34, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_extractfeat.c
// Function: gt_extractfeat_arguments_new
static void* gt_extractfeat_arguments_new(void)
{
  GtExtractFeatArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->type = gt_str_new();
  arguments->s2fi = gt_seqid2file_info_new();
  arguments->ofi = gt_output_file_info_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2a5941(%rip), %rdx    # 0x34c278
movl $0x1, %edi
movl $0x38, %esi
movl $0x31, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x10(%rbx)
callq 0x172c40
movq %rax, 0x18(%rbx)
callq 0x10ad60
movq %rax, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_extractfeat.c
// Function: gt_extractfeat_arguments_delete
static void gt_extractfeat_arguments_delete(void *tool_arguments)
{
  GtExtractFeatArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_seqid2file_info_delete(arguments->s2fi);
  gt_str_delete(arguments->type);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xa69b0
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0xff22c
movq 0x28(%rbx), %rdi
callq 0x10b00c
movq 0x18(%rbx), %rdi
callq 0x172c87
movq 0x10(%rbx), %rdi
callq 0x11bdbf
leaq 0x2a58d6(%rip), %rsi    # 0x34c278
movq %rbx, %rdi
movl $0x40, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_extractfeat.c
// Function: gt_extractfeat_comment_func
static int gt_extractfeat_comment_func(const char *progname,
                                       void *data, GtError *err)
{
  GtStrArray *descs = gt_trans_table_get_scheme_descriptions();
  GtUword i = 0;
  printf("\nGenetic code numbers for option '-gcode':\n\n");
  for (i = 0; i < gt_str_array_size(descs); i++) {
    printf("%s\n", gt_str_array_get(descs, i));
  }
  gt_str_array_delete(descs);
  return gt_gtdata_show_help(progname, data,err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x11df2c
movq %rax, %r12
leaq 0x2a57cd(%rip), %rdi    # 0x34c4aa
callq 0x17bd0
movq %r12, %rdi
callq 0x11c131
testq %rax, %rax
je 0xa6d15
xorl %r13d, %r13d
movq %r12, %rdi
movq %r13, %rsi
callq 0x11bfb3
movq %rax, %rdi
callq 0x17bd0
incq %r13
movq %r12, %rdi
callq 0x11c131
cmpq %rax, %r13
jb 0xa6cf2
movq %r12, %rdi
callq 0x11c144
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x14c8c4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_extractseq.c
// Function: gt_extractseq_arguments_new
static void* gt_extractseq_arguments_new(void)
{
  ExtractSeqArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->pattern = gt_str_new();
  arguments->fastakeyfile = gt_str_new();
  arguments->ofi = gt_output_file_info_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2a5772(%rip), %rdx    # 0x34c4d6
movl $0x1, %edi
movl $0x38, %esi
movl $0x2d, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, (%rbx)
callq 0x11ac6c
movq %rax, 0x8(%rbx)
callq 0x10ad60
movq %rax, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_extractseq.c
// Function: gt_extractseq_arguments_delete
static void gt_extractseq_arguments_delete(void *tool_arguments)
{
  ExtractSeqArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_str_delete(arguments->fastakeyfile);
  gt_str_delete(arguments->pattern);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xa6ddb
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0xff22c
movq 0x28(%rbx), %rdi
callq 0x10b00c
movq 0x8(%rbx), %rdi
callq 0x11bdbf
movq (%rbx), %rdi
callq 0x11bdbf
leaq 0x2a5709(%rip), %rsi    # 0x34c4d6
movq %rbx, %rdi
movl $0x3c, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_extractseq.c
// Function: gt_extractseq_arguments_check
static int gt_extractseq_arguments_check(GT_UNUSED int argc,
                                         void *tool_arguments, GtError *err)
{
  ExtractSeqArguments *arguments = tool_arguments;
  gt_error_check(err);
  gt_assert(arguments);
  if (arguments->frompos > arguments->topos) {
    gt_error_set(err,
              "argument to option '-%s' must be <= argument to option '-%s'",
              FROMPOS_OPTION_STR, TOPOS_OPTION_STR);
    return -1;
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdx, %rdx
je 0xa6f5a
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xa6f9c
testq %r14, %r14
je 0xa6f97
movq 0x10(%r14), %rcx
xorl %eax, %eax
cmpq 0x18(%r14), %rcx
jbe 0xa6f8f
leaq 0x2a5745(%rip), %rsi    # 0x34c6b7
leaq 0x2d2653(%rip), %rdx    # 0x3795cc
leaq 0x2b78f8(%rip), %rcx    # 0x35e878
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1a90f
callq 0x1a8d6
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_extracttarget.c
// Function: gt_extracttarget_option_parser_new
static GtOptionParser* gt_extracttarget_option_parser_new(void *tool_arguments)
{
  ExtractTargetArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *o;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] -seqfile sequence_file GFF3_file",
                         "Extract target sequences given in GFF3_file from "
                         "sequence_file.");

  /* -seqfile */
  o = gt_option_new_filename_array("seqfiles",
                                   "set the sequence file from which "
                                   "to extract the features",
                                   arguments->seqfiles);
  gt_option_is_mandatory(o);
  gt_option_parser_add_option(op, o);

  gt_option_parser_set_min_max_args(op, 1, 1);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa766d
movq %rdi, %rbx
leaq 0x2a521b(%rip), %rdi    # 0x34c830
leaq 0x2a5242(%rip), %rsi    # 0x34c85e
callq 0x107bfe
movq %rax, %r14
movq (%rbx), %rdx
leaq 0x2a52df(%rip), %rdi    # 0x34c90d
leaq 0x2a5269(%rip), %rsi    # 0x34c89e
callq 0x10a7df
movq %rax, %rbx
movq %rax, %rdi
callq 0x10a87b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x107cc0
movq %r14, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x10874b
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1ab49
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_extracttarget.c
// Function: show_target
static bool show_target(GT_UNUSED GtUword pos, void *data)
{
  TargetInfo *ti = data;
  char *seq;
  gt_assert(ti);
  seq = gt_bioseq_get_sequence(ti->bioseq, ti->seqnum);
  gt_fasta_show_entry(gt_bioseq_get_description(ti->bioseq, ti->seqnum),
                      seq,
                      gt_bioseq_get_sequence_length(ti->bioseq, ti->seqnum), 0,
                      NULL);
  gt_free(seq);
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0xa7aba
movq %rsi, %rbx
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
callq 0xd4b0d
movq %rax, %r14
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0xd4bb7
movq %rax, %r15
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0xd4ba3
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xfe000
leaq 0x2a4d4b(%rip), %rsi    # 0x34c7f0
movq %r14, %rdi
movl $0x5d, %edx
callq 0x1045eb
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
callq 0x1ac9b
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_fastq_sample.c
// Function: gt_fastq_sample_option_parser_new
static GtOptionParser* gt_fastq_sample_option_parser_new(void *tool_arguments)
{
  GtFastqSampleArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *optionlength;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] -length <n> <fastq_file> "
                            "[<fastq_file>...]",
                            "Print samples by random choice from given FASTQ "\
                            "files using at least n sequence-chars.\n"\
                            "Output is fastq/fasta format depending on "\
                            "whether qualities are available.");

  /* -length */
  optionlength = gt_option_new_uword("length",
                                     "minimum number of chars to be chosen",
                                     &arguments->length,
                                     GT_UNDEF_UWORD);
  gt_option_is_mandatory(optionlength);
  gt_option_parser_add_option(op, optionlength);

  gt_option_parser_set_min_args(op, 1);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa7b87
movq %rdi, %rbx
leaq 0x2a4e56(%rip), %rdi    # 0x34c983
leaq 0x2a4e87(%rip), %rsi    # 0x34c9bb
callq 0x107bfe
movq %rax, %r14
leaq 0x3198ea(%rip), %rdi    # 0x3c142d
leaq 0x2a4f13(%rip), %rsi    # 0x34ca5d
movq %rbx, %rdx
movq $-0x1, %rcx
callq 0x10a2ab
movq %rax, %rbx
movq %rax, %rdi
callq 0x10a87b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x107cc0
movq %r14, %rdi
movl $0x1, %esi
callq 0x10872d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1acd2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_fastq_sample.c
// Function: gt_fastq_sample_arguments_check
static int gt_fastq_sample_arguments_check(GT_UNUSED int rest_argc,
                                           void *tool_arguments,
                                           GtError *err)
{
  GtFastqSampleArguments *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(arguments);

  if (arguments->length < 1) {
    gt_error_set(err, "length must be a positive integer");
    had_err = -1;
  }
  return had_err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdx, %rdx
je 0xa7ba7
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xa7bd7
testq %r14, %r14
je 0xa7bd2
xorl %eax, %eax
cmpq $0x0, (%r14)
jne 0xa7bca
leaq 0x2a4ee7(%rip), %rsi    # 0x34caa2
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1ad40
callq 0x1ad09
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_featureindex.c
// Function: gt_featureindex_arguments_new
static void* gt_featureindex_arguments_new(void)
{
  GtFeatureindexArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->seqid = gt_str_new();
  arguments->backend = gt_str_new();
  arguments->filename = gt_str_new();
  arguments->host = gt_str_new();
  arguments->user = gt_str_new();
  arguments->database = gt_str_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2a4bab(%rip), %rdx    # 0x34cb6b
movl $0x1, %edi
movl $0x58, %esi
movl $0x3d, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x10(%rbx)
callq 0x11ac6c
movq %rax, 0x18(%rbx)
callq 0x11ac6c
movq %rax, 0x20(%rbx)
callq 0x11ac6c
movq %rax, 0x28(%rbx)
callq 0x11ac6c
movq %rax, 0x30(%rbx)
callq 0x11ac6c
movq %rax, 0x40(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_featureindex.c
// Function: gt_featureindex_arguments_delete
static void gt_featureindex_arguments_delete(void *tool_arguments)
{
  GtFeatureindexArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->seqid);
  gt_str_delete(arguments->backend);
  gt_str_delete(arguments->filename);
  gt_str_delete(arguments->host);
  gt_str_delete(arguments->user);
  gt_str_delete(arguments->pass);
  gt_str_delete(arguments->database);
  gt_option_delete(arguments->rngopt);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xa8078
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x11bdbf
movq 0x18(%rbx), %rdi
callq 0x11bdbf
movq 0x20(%rbx), %rdi
callq 0x11bdbf
movq 0x28(%rbx), %rdi
callq 0x11bdbf
movq 0x30(%rbx), %rdi
callq 0x11bdbf
movq 0x38(%rbx), %rdi
callq 0x11bdbf
movq 0x40(%rbx), %rdi
callq 0x11bdbf
movq 0x50(%rbx), %rdi
callq 0x10a16a
leaq 0x2a4b01(%rip), %rsi    # 0x34cb6b
movq %rbx, %rdi
movl $0x53, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_featureindex.c
// Function: gt_featureindex_arguments_check
static int gt_featureindex_arguments_check(GT_UNUSED int rest_argc,
                                           GT_UNUSED void *tool_arguments,
                                           GT_UNUSED GtError *err)
{
  GT_UNUSED GtFeatureindexArguments *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 0xa8211
movq %rdx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xa821f
testq %rbx, %rbx
je 0xa821a
xorl %eax, %eax
popq %rbx
retq
callq 0x1aecb
callq 0x1ae92
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_fingerprint.c
// Function: gt_fingerprint_arguments_new
static void* gt_fingerprint_arguments_new(void)
{
  FingerprintArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->checklist = gt_str_new();
  arguments->extract = gt_str_new();
  arguments->ofi = gt_output_file_info_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2a4799(%rip), %rdx    # 0x34cd70
movl $0x1, %edi
movl $0x30, %esi
movl $0x2e, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x8(%rbx)
callq 0x11ac6c
movq %rax, 0x10(%rbx)
callq 0x10ad60
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_fingerprint.c
// Function: gt_fingerprint_arguments_delete
static void gt_fingerprint_arguments_delete(void *tool_arguments)
{
  FingerprintArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_str_delete(arguments->extract);
  gt_str_delete(arguments->checklist);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xa8650
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0xff22c
movq 0x20(%rbx), %rdi
callq 0x10b00c
movq 0x10(%rbx), %rdi
callq 0x11bdbf
movq 0x8(%rbx), %rdi
callq 0x11bdbf
leaq 0x2a472e(%rip), %rsi    # 0x34cd70
movq %rbx, %rdi
movl $0x3d, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_fingerprint.c
// Function: proc_superfluous_sequence
static void proc_superfluous_sequence(const char *string,
                                      GT_UNUSED GtUword occurrences,
                                      GT_UNUSED double probability, void *data)
{
  bool *comparisons_failed = data;
  gt_assert(string && occurrences && comparisons_failed);
  printf("%s only in sequence_file(s)\n", string);
  *comparisons_failed = true;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xa9012
testq %rsi, %rsi
je 0xa9012
movq %rdx, %rbx
testq %rdx, %rdx
je 0xa9012
movq %rdi, %rax
leaq 0x2a40c6(%rip), %rdi    # 0x34d0c9
movq %rax, %rsi
xorl %eax, %eax
callq 0x17070
movb $0x1, (%rbx)
popq %rbx
retq
callq 0x1b1e7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_fingerprint.c
// Function: show_duplicate
static void show_duplicate(const char *fingerprint, GtUword occurrences,
                           GT_UNUSED double probability, void *data)
{
  FingerprintInfo *info = data;
  if (occurrences > 1) {
    printf("%s\t"GT_WU"\n", fingerprint, occurrences);
    info->duplicates += occurrences - 1;
  }
  info->num_of_sequences += occurrences;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
cmpq $0x2, %rsi
jb 0xa9047
movq %rdi, %rsi
leaq 0x2a40f1(%rip), %rdi    # 0x34d122
movq %r14, %rdx
xorl %eax, %eax
callq 0x17070
movq (%rbx), %rax
addq %r14, %rax
decq %rax
movq %rax, (%rbx)
addq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_gdiffcalc.c
// Function: gt_gdiffcalc_arguments_new
static void* gt_gdiffcalc_arguments_new(void)
{
  GtGenomediffArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->indexname = gt_str_new();
  arguments->unitfile = gt_str_new();
  arguments->indextype = gt_str_new();
  arguments->filenames = gt_str_array_new();
  arguments->with_esa = arguments->with_pck = false;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2a4144(%rip), %rdx    # 0x34d1c8
movl $0x1, %edi
movl $0x70, %esi
movl $0x2e, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x50(%rbx)
callq 0x11ac6c
movq %rax, 0x60(%rbx)
callq 0x11ac6c
movq %rax, 0x58(%rbx)
callq 0x11be10
movq %rax, 0x68(%rbx)
movw $0x0, 0x2(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_gdiffcalc.c
// Function: gt_gdiffcalc_arguments_delete
static void gt_gdiffcalc_arguments_delete(void *tool_arguments)
{
  GtGenomediffArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->indexname);
  gt_str_delete(arguments->unitfile);
  gt_str_delete(arguments->indextype);
  gt_str_array_delete(arguments->filenames);
  gt_option_delete(arguments->ref_unitfile);
  gt_encseq_options_delete(arguments->loadopts);
  gt_index_options_delete(arguments->idxopts);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xa9127
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
callq 0x11bdbf
movq 0x60(%rbx), %rdi
callq 0x11bdbf
movq 0x58(%rbx), %rdi
callq 0x11bdbf
movq 0x68(%rbx), %rdi
callq 0x11c144
movq 0x48(%rbx), %rdi
callq 0x10a16a
movq 0x38(%rbx), %rdi
callq 0xfc961
movq 0x40(%rbx), %rdi
callq 0x1b5e8c
leaq 0x2a40af(%rip), %rsi    # 0x34d1c8
movq %rbx, %rdi
movl $0x42, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_gdiffcalc.c
// Function: gt_gdiffcalc_arguments_check
static int gt_gdiffcalc_arguments_check(GT_UNUSED int rest_argc,
                                       void *tool_arguments,
                                       GT_UNUSED GtError *err)
{
  GtGenomediffArguments *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(arguments);

  gt_assert(rest_argc == 1);
  if (!had_err)
    arguments->with_units = gt_option_is_set(arguments->ref_unitfile);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
testq %rdx, %rdx
je 0xa9352
movq %rdx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xa937b
testq %rbx, %rbx
je 0xa9371
cmpl $0x1, %ebp
jne 0xa9376
movq 0x48(%rbx), %rdi
callq 0x10ac3f
movb %al, 0x4(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1b2c9
callq 0x1b290
callq 0x1b257
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_genomediff.c
// Function: gt_genomediff_arguments_new
static void* gt_genomediff_arguments_new(void)
{
  GtGenomediffArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->indexname = gt_str_new();
  arguments->unitfile = gt_str_new();
  arguments->indextype = gt_str_new();
  arguments->filenames = gt_str_array_new();
  arguments->with_esa = arguments->with_pck = false;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2a3cde(%rip), %rdx    # 0x34d566
movl $0x1, %edi
movl $0x70, %esi
movl $0x2c, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x50(%rbx)
callq 0x11ac6c
movq %rax, 0x60(%rbx)
callq 0x11ac6c
movq %rax, 0x58(%rbx)
callq 0x11be10
movq %rax, 0x68(%rbx)
movw $0x0, 0x2(%rbx)
movq %rbx, %rax
popq %rbx
retq