LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_sortbench.c
// Function: gt_sortbench_cmp
static int gt_sortbench_cmp(const void *px, const void *py)
{
  const GtUword x = *(const GtUword*)px;
  const GtUword y = *(const GtUword*)py;
  ncmp++;
  if (val[x]==gas && val[y]==gas) {
    if (x == candidate) {
      freeze(x);
    } else {
      freeze(y);
    }
  }
  if (val[x] == gas)
    candidate = x;
  else if (val[y] == gas)
    candidate = y;
  if (val[x] < val[y])
  {
    return -1;
  }
  if (val[x] > val[y])
  {
    return 1;
  }
  return 0;
}

// Assembly:
movq (%rdi), %rcx
movq (%rsi), %rax
leaq 0x3ece03(%rip), %rdx    # 0x43d428
incq (%rdx)
leaq 0x3ecdf1(%rip), %rdx    # 0x43d420
movq (%rdx), %rdx
movq (%rdx,%rcx,8), %rdi
leaq 0x3ece03(%rip), %rsi    # 0x43d440
cmpq (%rsi), %rdi
jne 0x50673
cmpq %rdi, (%rdx,%rax,8)
jne 0x50673
leaq 0x3ecde9(%rip), %r8     # 0x43d438
leaq 0x3ecdda(%rip), %r9     # 0x43d430
movq (%r9), %rdi
leaq 0x1(%rdi), %r10
movq %r10, (%r9)
cmpq (%r8), %rcx
jne 0x5066b
movq %rdi, (%rdx,%rcx,8)
jmp 0x50673
movq %rdi, (%rdx,%rax,8)
movq (%rdx,%rcx,8), %rdi
movq (%rsi), %r8
movq %rcx, %rsi
cmpq %r8, %rdi
je 0x50687
movq %rax, %rsi
cmpq %r8, (%rdx,%rax,8)
jne 0x50691
leaq 0x3ecdaa(%rip), %rdi    # 0x43d438
movq %rsi, (%rdi)
movq (%rdx,%rcx,8), %rcx
xorl %esi, %esi
cmpq (%rdx,%rax,8), %rcx
seta %sil
pushq $-0x1
popq %rax
cmovael %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_speck.c
// Function: gt_speck_arguments_new
static void *gt_speck_arguments_new(void)
{
  SpeccheckArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->specfile = gt_str_new();
  arguments->format = gt_str_new();
  arguments->s2fi = gt_seqid2file_info_new();
  arguments->ofi = gt_output_file_info_new();
  arguments->tci = gt_typecheck_info_new();
  arguments->outfp = NULL;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2aa3a9(%rip), %rdx    # 0x2fb869
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
pushq $0x38
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, (%rbx)
callq 0xacb84
movq %rax, 0x8(%rbx)
callq 0x116724
movq %rax, 0x18(%rbx)
callq 0x9b6b4
movq %rax, 0x20(%rbx)
callq 0x12aab4
movq %rax, 0x28(%rbx)
andq $0x0, 0x30(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_speck.c
// Function: gt_speck_arguments_delete
static void gt_speck_arguments_delete(void *tool_arguments)
{
  SpeccheckArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->specfile);
  gt_str_delete(arguments->format);
  gt_file_delete(arguments->outfp);
  gt_seqid2file_info_delete(arguments->s2fi);
  gt_output_file_info_delete(arguments->ofi);
  gt_typecheck_info_delete(arguments->tci);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x51558
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xae103
movq 0x8(%rbx), %rdi
callq 0xae103
movq 0x30(%rbx), %rdi
callq 0x8da06
movq 0x18(%rbx), %rdi
callq 0x116765
movq 0x20(%rbx), %rdi
callq 0x9ba24
movq 0x28(%rbx), %rdi
callq 0x12aada
leaq 0x2aa31d(%rip), %rsi    # 0x2fb869
pushq $0x4c
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_speck.c
// Function: gt_speck_arguments_check
static int gt_speck_arguments_check(GT_UNUSED int rest_argc,
                                    void *tool_arguments,
                                    GT_UNUSED GtError *err)
{
  SpeccheckArguments *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(arguments);

  if ((arguments->outfp || (!arguments->outfp && !isatty(STDOUT_FILENO)))
      && arguments->colored) {
    gt_warning("not printing to terminal, disabling colored output");
    arguments->colored = false;
  }

  return had_err = 0;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
je 0x516c5
movq %rdx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x51729
testq %rbx, %rbx
je 0x516fb
cmpq $0x0, 0x30(%rbx)
je 0x516eb
cmpb $0x1, 0x11(%rbx)
jne 0x516f7
leaq 0x2aa39a(%rip), %rdi    # 0x2fba78
xorl %eax, %eax
callq 0xb2cd0
movb $0x0, 0x11(%rbx)
jmp 0x516f7
pushq $0x1
popq %rdi
callq 0x17d00
testl %eax, %eax
je 0x516d1
xorl %eax, %eax
popq %rbx
retq
movq 0x3e6866(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x293907(%rip), %rsi    # 0x2e5013
leaq 0x2f6f40(%rip), %rdx    # 0x348653
leaq 0x2aa345(%rip), %rcx    # 0x2fba5f
leaq 0x2aa148(%rip), %r8     # 0x2fb869
movl $0x8a, %r9d
jmp 0x51755
movq 0x3e6838(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2938d9(%rip), %rsi    # 0x2e5013
leaq 0x293a7e(%rip), %rdx    # 0x2e51bf
leaq 0x2aa317(%rip), %rcx    # 0x2fba5f
leaq 0x2aa11a(%rip), %r8     # 0x2fb869
movl $0x89, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_speck.c
// Function: gt_speck_record_warning
static void gt_speck_record_warning(void *data, const char *format, va_list ap)
{
  char buf[BUFSIZ];
  gt_assert(data && format);
  (void) vsnprintf(buf, (BUFSIZ * sizeof (char)), format, ap);
  gt_spec_results_record_warning((GtSpecResults*) data, buf);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
testq %rdi, %rdi
je 0x51e37
movq %rdx, %rcx
movq %rsi, %rdx
testq %rsi, %rsi
je 0x51e37
movq %rdi, %rbx
movq %rsp, %r14
movl $0x2000, %esi           # imm = 0x2000
movq %r14, %rdi
callq 0x17460
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11a774
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r14
retq
movq 0x3e612a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2931cb(%rip), %rsi    # 0x2e5013
leaq 0x2a9cb3(%rip), %rdx    # 0x2fbb02
leaq 0x2a9cbb(%rip), %rcx    # 0x2fbb11
leaq 0x2a9a0c(%rip), %r8     # 0x2fb869
movl $0x98, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_splicesiteinfo.c
// Function: gt_splicesiteinfo_arguments_new
static void* gt_splicesiteinfo_arguments_new(void)
{
  SpliceSiteInfoArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->s2fi = gt_seqid2file_info_new();
  arguments->ofi = gt_output_file_info_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2a9c8e(%rip), %rdx    # 0x2fbb29
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
pushq $0x28
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0x116724
movq %rax, 0x8(%rbx)
callq 0x9b6b4
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_splicesiteinfo.c
// Function: gt_splicesiteinfo_arguments_delete
static void gt_splicesiteinfo_arguments_delete(void *tool_arguments)
{
  SpliceSiteInfoArguments *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_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x51efa
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x8da06
movq 0x10(%rbx), %rdi
callq 0x9ba24
movq 0x8(%rbx), %rdi
callq 0x116765
leaq 0x2a9c3b(%rip), %rsi    # 0x2fbb29
pushq $0x35
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_splicesiteinfo.c
// Function: gt_splicesiteinfo_option_parser_new
static GtOptionParser* gt_splicesiteinfo_option_parser_new(void *tool_arguments)
{
  SpliceSiteInfoArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  op = gt_option_parser_new("[option ...] [GFF3_file ...]", "Show information "
                            "about splice sites given in GFF3 files.");

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

  /* -addintrons */
  option = gt_option_new_bool("addintrons", "add intron features between "
                              "existing exon features\n(before computing the "
                              "information to be shown)",
                              &arguments->addintrons, false);
  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_comment_func(op, gt_gtdata_show_help, NULL);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x51f7b
movq %rdi, %rbx
leaq 0x2985eb(%rip), %rdi    # 0x2ea4f9
leaq 0x2a9c56(%rip), %rsi    # 0x2fbb6b
callq 0x97df5
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x116b0e
leaq 0x29bf61(%rip), %rdi    # 0x2ede91
leaq 0x2a9c6d(%rip), %rsi    # 0x2fbba4
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x9a997
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x10(%rbx), %rdi
addq $0x18, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9b6d7
leaq 0x95586(%rip), %rsi     # 0xe74ec
movq %r14, %rdi
xorl %edx, %edx
callq 0x98045
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3e5fe6(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x293087(%rip), %rsi    # 0x2e5013
leaq 0x2f66c0(%rip), %rdx    # 0x348653
leaq 0x2a9bad(%rip), %rcx    # 0x2fbb47
leaq 0x2a9b88(%rip), %r8     # 0x2fbb29
pushq $0x3d
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_stat.c
// Function: gt_stat_arguments_delete
static void gt_stat_arguments_delete(void *tool_arguments)
{
  StatArguments *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 0x52a34
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x8da06
movq 0x10(%rbx), %rdi
callq 0x9ba24
leaq 0x2a9480(%rip), %rsi    # 0x2fbea8
pushq $0x37
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_tagerator.c
// Function: gt_tagerator_arguments_new
static void *gt_tagerator_arguments_new(void)
{
  TageratorOptions *arguments;

  arguments = gt_malloc(sizeof (TageratorOptions));
  arguments->indexname = gt_str_new();
  arguments->tagfiles = gt_str_array_new();
  arguments->outputspec = gt_str_array_new();
  arguments->outputmode = 0;
  arguments->numberofmodedescentries = sizeof (outputmodedesctable)/
                                       sizeof (outputmodedesctable[0]);
  arguments->outputhelp
    = gt_getargmodekeywords(outputmodedesctable,
                            arguments->numberofmodedescentries,
                            "output");
  arguments->modedesc = outputmodedesctable;
  return arguments;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2a93a6(%rip), %rsi    # 0x2fc0f1
pushq $0x68
popq %rdi
pushq $0x30
popq %rdx
callq 0x93160
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x10(%rbx)
callq 0xae154
movq %rax, (%rbx)
callq 0xae154
movq %rax, 0x8(%rbx)
andl $0x0, 0x54(%rbx)
movq $0xb, 0x60(%rbx)
leaq 0x3df7da(%rip), %r14    # 0x432560
leaq 0x2b957a(%rip), %rdx    # 0x30c307
pushq $0xb
popq %rsi
movq %r14, %rdi
callq 0x166b0c
movq %rax, 0x18(%rbx)
movq %r14, 0x30(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_tagerator.c
// Function: gt_tagerator_arguments_delete
static void gt_tagerator_arguments_delete(void *tool_arguments)
{
  TageratorOptions *arguments = tool_arguments;

  if (!arguments)
  {
    return;
  }
  gt_str_delete(arguments->indexname);
  gt_str_delete(arguments->outputhelp);
  gt_str_array_delete(arguments->tagfiles);
  gt_str_array_delete(arguments->outputspec);
  gt_option_delete(arguments->refoptionesaindex);
  gt_option_delete(arguments->refoptionpckindex);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x52dfc
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xae103
movq 0x18(%rbx), %rdi
callq 0xae103
movq (%rbx), %rdi
callq 0xae662
movq 0x8(%rbx), %rdi
callq 0xae662
movq 0x20(%rbx), %rdi
callq 0x9a8ea
movq 0x28(%rbx), %rdi
callq 0x9a8ea
leaq 0x2a9301(%rip), %rsi    # 0x2fc0f1
pushq $0x4d
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_tallymer.c
// Function: gt_tyr_arguments_new
static void *gt_tyr_arguments_new(void)
{
  GtToolbox *tyr_toolbox = gt_toolbox_new();
  gt_toolbox_add_tool(tyr_toolbox, "mkindex", gt_tyr_mkindex());
  gt_toolbox_add_tool(tyr_toolbox, "occratio", gt_tyr_occratio());
  gt_toolbox_add_tool(tyr_toolbox, "search", gt_tyr_search());
  return tyr_toolbox;
}

// Assembly:
pushq %rbx
callq 0xb0c26
movq %rax, %rbx
leaq 0x2d7(%rip), %rdi       # 0x537a6
leaq 0x2fd(%rip), %rsi       # 0x537d3
leaq 0x32e(%rip), %rdx       # 0x5380b
leaq 0x533(%rip), %rcx       # 0x53a17
leaq 0x583(%rip), %r8        # 0x53a6e
callq 0xb04d0
leaq 0x29df12(%rip), %rsi    # 0x2f1409
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0c55
leaq 0x755(%rip), %rdi       # 0x53c5e
leaq 0x78e(%rip), %rsi       # 0x53c9e
leaq 0x7e6(%rip), %rdx       # 0x53cfd
leaq 0x984(%rip), %rcx       # 0x53ea2
leaq 0xcf2(%rip), %r8        # 0x54217
callq 0xb04d0
leaq 0x2a91df(%rip), %rsi    # 0x2fc710
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0c55
leaq 0x10e8(%rip), %rdi      # 0x5462b
leaq 0x1126(%rip), %rsi      # 0x54670
leaq 0x1161(%rip), %rdx      # 0x546b2
leaq 0x127c(%rip), %rcx      # 0x547d4
leaq 0x135a(%rip), %r8       # 0x548b9
callq 0xb04d0
leaq 0x294b9d(%rip), %rsi    # 0x2e8108
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0c55
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_tallymer.c
// Function: gt_tyr_option_parser_new
static GtOptionParser* gt_tyr_option_parser_new(void *tool_arguments)
{
  GtToolbox *index_toolbox = tool_arguments;
  GtOptionParser *op;

  gt_assert(index_toolbox != NULL);
  op = gt_option_parser_new(
                    "[option ...] tallymer_tool [argument ...]",
                    "Call a tallymer subtool and pass argument(s) to it.");
  gt_option_parser_set_comment_func(op, gt_toolbox_show, index_toolbox);
  gt_option_parser_set_min_args(op, 1U);
  gt_option_parser_refer_to_manual(op);
  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x535d7
movq %rdi, %rbx
leaq 0x2a9c76(%rip), %rdi    # 0x2fd20e
leaq 0x2a9c99(%rip), %rsi    # 0x2fd238
callq 0x97df5
movq %rax, %r14
leaq 0x5d8ea(%rip), %rsi     # 0xb0e98
movq %rax, %rdi
movq %rbx, %rdx
callq 0x98045
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x98be7
movq %r14, %rdi
callq 0x98002
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3e498a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x291a2b(%rip), %rsi    # 0x2e5013
leaq 0x29685b(%rip), %rdx    # 0x2e9e4a
leaq 0x2a9bff(%rip), %rcx    # 0x2fd1f5
leaq 0x2a911c(%rip), %r8     # 0x2fc719
movl $0x3d7, %r9d            # imm = 0x3D7
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_tallymer.c
// Function: gt_tyr_mkindex_arguments_new
static void *gt_tyr_mkindex_arguments_new(void)
{
  Tyr_mkindex_options *arguments
    = gt_malloc(sizeof (Tyr_mkindex_options));
  arguments->str_storeindex = gt_str_new();
  arguments->str_inputindex = gt_str_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2a8f6b(%rip), %rsi    # 0x2fc719
pushq $0x48
popq %rdi
pushq $0x48
popq %rdx
callq 0x93160
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x30(%rbx)
callq 0xacb84
movq %rax, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_tallymer.c
// Function: gt_tyr_mkindex_arguments_delete
static void gt_tyr_mkindex_arguments_delete(void *tool_arguments)
{
  Tyr_mkindex_options *arguments = tool_arguments;

  if (!arguments)
  {
    return;
  }
  gt_str_delete(arguments->str_storeindex);
  gt_str_delete(arguments->str_inputindex);
  gt_option_delete(arguments->refoptionpl);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x5380a
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0xae103
movq 0x38(%rbx), %rdi
callq 0xae103
movq 0x28(%rbx), %rdi
callq 0x9a8ea
leaq 0x2a8f1b(%rip), %rsi    # 0x2fc719
pushq $0x59
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_tallymer.c
// Function: gt_tyr_mkindex_arguments_check
static int gt_tyr_mkindex_arguments_check(int rest_argc,
                                          void *tool_arguments,
                                          GtError *err)
{
  Tyr_mkindex_options *arguments = tool_arguments;

  if (rest_argc != 0)
  {
    gt_error_set(err,"superfluous arguments");
    return -1;
  }
  if (gt_option_is_set(arguments->refoptionpl))
  {
    if (arguments->userdefinedprefixlength == 0)
    {
      arguments->prefixlength.flag = Autoprefixlength;
      arguments->prefixlength.value = 0;
    } else
    {
      arguments->prefixlength.flag = Determinedprefixlength;
      arguments->prefixlength.value = arguments->userdefinedprefixlength;
    }
  } else
  {
    arguments->prefixlength.flag = Undeterminedprefixlength;
    arguments->prefixlength.value = 0;
  }
  return 0;
}

// Assembly:
pushq %rbx
testl %edi, %edi
je 0x53a32
leaq 0x29c576(%rip), %rsi    # 0x2eff99
movq %rdx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
jmp 0x53a6c
movq %rsi, %rbx
movq 0x28(%rsi), %rdi
callq 0x9b4cb
testb %al, %al
je 0x53a55
movl 0x18(%rbx), %eax
testl %eax, %eax
je 0x53a65
movl $0x2, 0x20(%rbx)
movl %eax, 0x1c(%rbx)
jmp 0x53a6a
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x1c(%rbx)
jmp 0x53a6a
andq $0x0, 0x1c(%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_tallymer.c
// Function: gt_tyr_occratio_arguments_new
static void *gt_tyr_occratio_arguments_new(void)
{
  Tyr_occratio_options *arguments
    = gt_malloc(sizeof (Tyr_occratio_options));
  arguments->mersizesstrings = gt_str_array_new();
  arguments->outputspec = gt_str_array_new();
  arguments->str_inputindex = gt_str_new();
  arguments->outputvector = NULL;
  arguments->outputmode = 0;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2a8ab3(%rip), %rsi    # 0x2fc719
pushq $0x48
popq %rdi
movl $0x142, %edx            # imm = 0x142
callq 0x93160
movq %rax, %rbx
callq 0xae154
movq %rax, (%rbx)
callq 0xae154
movq %rax, 0x8(%rbx)
callq 0xacb84
movq %rax, 0x10(%rbx)
andq $0x0, 0x38(%rbx)
andl $0x0, 0x40(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_tallymer.c
// Function: gt_tyr_occratio_arguments_delete
static void gt_tyr_occratio_arguments_delete(void *tool_arguments)
{
  Tyr_occratio_options *arguments = tool_arguments;

  if (!arguments)
  {
    return;
  }
  gt_str_array_delete(arguments->mersizesstrings);
  gt_str_array_delete(arguments->outputspec);
  gt_str_delete(arguments->str_inputindex);
  gt_option_delete(arguments->refoptionmersizes);
  gt_free(arguments->outputvector);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x53cfc
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xae662
movq 0x8(%rbx), %rdi
callq 0xae662
movq 0x10(%rbx), %rdi
callq 0xae103
movq 0x18(%rbx), %rdi
callq 0x9a8ea
movq 0x38(%rbx), %rdi
leaq 0x2a8a41(%rip), %r14    # 0x2fc719
movq %r14, %rsi
movl $0x157, %edx            # imm = 0x157
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x158, %edx            # imm = 0x158
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_tallymer.c
// Function: showitvdistribution
static void showitvdistribution(const GtArrayuint64_t *dist,
                                const GtBitsequence *outputvector)
{
  GtUword idx;

  gt_assert(outputvector != NULL);
  for (idx=0; idx < dist->nextfreeuint64_t; idx++)
  {
    if (GT_ISIBITSET(outputvector,idx) && dist->spaceuint64_t[idx] > 0)
    {
      /*@ignore@*/
      printf(""GT_WU" " Formatuint64_t "\n",
              idx,
              PRINTuint64_tcast(dist->spaceuint64_t[idx]));
      /*@end@*/
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x545f3
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2cdc54(%rip), %r15    # 0x3221fd
xorl %r12d, %r12d
cmpq 0x10(%r14), %r12
jae 0x545e7
movq %r12, %rax
shrq $0x6, %rax
movq (%rbx,%rax,8), %rax
movl %r12d, %ecx
shlq %cl, %rax
shrq $0x3f, %rax
je 0x545e2
movq (%r14), %rax
movq (%rax,%r12,8), %rdx
testq %rdx, %rdx
je 0x545e2
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x17070
incq %r12
jmp 0x545ac
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x3e396e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x290a0f(%rip), %rsi    # 0x2e5013
leaq 0x2a89a7(%rip), %rdx    # 0x2fcfb2
leaq 0x2a89df(%rip), %rcx    # 0x2fcff1
leaq 0x2a8100(%rip), %r8     # 0x2fc719
movl $0x246, %r9d            # imm = 0x246
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_tallymer.c
// Function: gt_tyr_search_arguments_new
static void *gt_tyr_search_arguments_new(void)
{
  Tyr_search_options *arguments
    = gt_malloc(sizeof (Tyr_search_options));
  arguments->str_inputindex = gt_str_new();
  arguments->strandspec = gt_str_new();
  arguments->queryfilenames = gt_str_array_new();
  arguments->showmodespec = gt_str_array_new();
  arguments->showmode = 0;
  arguments->strand = 0;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2a80e6(%rip), %rsi    # 0x2fc719
pushq $0x30
popq %rdi
movl $0x326, %edx            # imm = 0x326
callq 0x93160
movq %rax, %rbx
callq 0xacb84
movq %rax, (%rbx)
callq 0xacb84
movq %rax, 0x10(%rbx)
callq 0xae154
movq %rax, 0x8(%rbx)
callq 0xae154
movq %rax, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_tallymer.c
// Function: gt_tyr_search_arguments_delete
static void gt_tyr_search_arguments_delete(void *tool_arguments)
{
  Tyr_search_options *arguments = tool_arguments;

  if (!arguments)
  {
    return;
  }
  gt_str_delete(arguments->str_inputindex);
  gt_str_delete(arguments->strandspec);
  gt_str_array_delete(arguments->queryfilenames);
  gt_str_array_delete(arguments->showmodespec);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x546b1
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xae103
movq 0x10(%rbx), %rdi
callq 0xae103
movq 0x8(%rbx), %rdi
callq 0xae662
movq 0x18(%rbx), %rdi
callq 0xae662
leaq 0x2a8076(%rip), %rsi    # 0x2fc719
movq %rbx, %rdi
movl $0x33c, %edx            # imm = 0x33C
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_tallymer.c
// Function: gt_tyr_search_arguments_check
static int gt_tyr_search_arguments_check(int rest_argc,
                                         void *tool_arguments,
                                         GtError *err)
{
  Optionargmodedesc showmodedesctable[] =
  {
    {"qseqnum","query sequence number",SHOWQSEQNUM},
    {"qpos","query position",SHOWQPOS},
    {"counts","number of occurrence counts",SHOWCOUNTS},
    {"sequence","mer-sequence",SHOWSEQUENCE}
  };

  Optionargmodedesc stranddesctable[] =
  {
    {"f","forward strand",STRAND_FORWARD},
    {"p","reverse strand",STRAND_REVERSE},
    {"fp","forward and reverse strand",STRAND_FORWARD | STRAND_REVERSE}
  };
  GtUword idx;
  Tyr_search_options *arguments = tool_arguments;

  if (rest_argc != 0)
  {
    gt_error_set(err,"superfluous arguments");
    return -1;
  }
  for (idx=0; idx<gt_str_array_size(arguments->showmodespec); idx++)
  {
    if (gt_optionargaddbitmask(showmodedesctable,
                         sizeof (showmodedesctable)/
                         sizeof (showmodedesctable[0]),
                         &arguments->showmode,
                         "-output",
                         gt_str_array_get(arguments->showmodespec,idx),
                         err) != 0)
    {
      return -1;
    }
  }
  if (gt_optionargaddbitmask(stranddesctable,
                          sizeof (stranddesctable)/
                          sizeof (stranddesctable[0]),
                          &arguments->strand,
                          "-output",
                          gt_str_get(arguments->strandspec),err) != 0)
  {
    return -1;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %eax
leaq 0x3ddefc(%rip), %rsi    # 0x4326f0
pushq $0xc
popq %rcx
leaq 0x50(%rsp), %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x3ddf4a(%rip), %rsi    # 0x432750
pushq $0x9
popq %rcx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
testl %eax, %eax
je 0x54826
leaq 0x29b77f(%rip), %rsi    # 0x2eff99
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
jmp 0x54872
leaq 0x24(%r14), %r15
xorl %r12d, %r12d
leaq 0x50(%rsp), %rbp
pushq $0x4
popq %r13
movq 0x18(%r14), %rdi
callq 0xae61c
cmpq %rax, %r12
jae 0x54889
movq 0x18(%r14), %rdi
movq %r12, %rsi
callq 0xae386
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
leaq 0x29c4a7(%rip), %rcx    # 0x2f0d07
movq %rax, %r8
movq %rbx, %r9
callq 0x166988
incq %r12
testl %eax, %eax
je 0x54836
pushq $-0x1
popq %rcx
movl %ecx, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r14), %rdi
addq $0x20, %r14
callq 0xad1fa
leaq 0x29c46a(%rip), %rcx    # 0x2f0d07
movq %rsp, %rdi
pushq $0x3
popq %rsi
movq %r14, %rdx
movq %rax, %r8
movq %rbx, %r9
callq 0x166988
xorl %ecx, %ecx
negl %eax
sbbl %ecx, %ecx
jmp 0x54875
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_tallymer.c
// Function: gt_tyr_search_runner
static int gt_tyr_search_runner(GT_UNUSED int argc,
                                GT_UNUSED const char **argv,
                                GT_UNUSED int parsed_args,
                                void *tool_arguments,
                                GtError *err)
{
  Tyr_search_options *arguments = tool_arguments;

  if (gt_tyrsearch(gt_str_get(arguments->str_inputindex),
                   arguments->queryfilenames,
                   arguments->showmode,
                   arguments->strand,
                   arguments->verbose,
                   arguments->performtest,
                   err) != 0)
  {
    return -1;
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq (%rcx), %rdi
callq 0xad1fa
movq 0x8(%r14), %rsi
movl 0x24(%r14), %edx
movl 0x20(%r14), %ecx
movzbl 0x28(%r14), %r8d
movzbl 0x29(%r14), %r9d
movq %rbx, (%rsp)
movq %rax, %rdi
callq 0x1b6d28
xorl %ecx, %ecx
negl %eax
sbbl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_template.c
// Function: gt_template_option_parser_new
static GtOptionParser* gt_template_option_parser_new(void *tool_arguments)
{
  TemplateArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] [file]", /* XXX */
                            "DESCRIBE YOUR TOOL IN ONE LINE HERE."); /* XXX */

  /* -bool */
  option = gt_option_new_bool("bool", "bool option template",
                              &arguments->bool_option_template, false);
  gt_option_parser_add_option(op, option);

  /* -str */
  option = gt_option_new_string("str", "str option template",
                                arguments->str_option_template, NULL);
  gt_option_parser_add_option(op, option);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x549e9
movq %rdi, %r14
leaq 0x295d19(%rip), %rdi    # 0x2ea6a1
leaq 0x2a8acd(%rip), %rsi    # 0x2fd45c
callq 0x97df5
movq %rax, %rbx
leaq 0x311d70(%rip), %rdi    # 0x36670e
leaq 0x2a8adc(%rip), %rsi    # 0x2fd481
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x8(%r14), %rdx
leaq 0x2bd65f(%rip), %rdi    # 0x312024
leaq 0x2a8aca(%rip), %rsi    # 0x2fd496
xorl %ecx, %ecx
callq 0x9ad12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3e3578(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x290619(%rip), %rsi    # 0x2e5013
leaq 0x2f3c52(%rip), %rdx    # 0x348653
leaq 0x2a8a36(%rip), %rcx    # 0x2fd43e
leaq 0x2a8a17(%rip), %r8     # 0x2fd426
pushq $0x30
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_template.c
// Function: gt_template_arguments_check
static int gt_template_arguments_check(GT_UNUSED int rest_argc,
                                       void *tool_arguments,
                                       GT_UNUSED GtError *err)
{
  TemplateArguments *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(arguments);

  /* XXX: do some checking after the option have been parsed (usally this is not
     necessary and this function can be removed completely). */
  if (gt_str_length(arguments->str_option_template))
    printf("%s\n", gt_str_get(arguments->str_option_template));

  return had_err;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
je 0x54a34
movq %rdx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x54a86
testq %rbx, %rbx
je 0x54a5c
movq 0x8(%rbx), %rdi
callq 0xad289
testq %rax, %rax
je 0x54a58
movq 0x8(%rbx), %rdi
callq 0xad1fa
movq %rax, %rdi
callq 0x17b60
xorl %eax, %eax
popq %rbx
retq
movq 0x3e3505(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2905a6(%rip), %rsi    # 0x2e5013
leaq 0x2f3bdf(%rip), %rdx    # 0x348653
leaq 0x2a8a2f(%rip), %rcx    # 0x2fd4aa
leaq 0x2a89a4(%rip), %r8     # 0x2fd426
pushq $0x4a
jmp 0x54aae
movq 0x3e34db(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29057c(%rip), %rsi    # 0x2e5013
leaq 0x290721(%rip), %rdx    # 0x2e51bf
leaq 0x2a8a05(%rip), %rcx    # 0x2fd4aa
leaq 0x2a897a(%rip), %r8     # 0x2fd426
pushq $0x49
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_template.c
// Function: gt_template_runner
static int gt_template_runner(int argc, const char **argv, int parsed_args,
                              void *tool_arguments, GT_UNUSED GtError *err)
{
  TemplateArguments *arguments = tool_arguments;
  int had_err = 0;

  gt_error_check(err);
  gt_assert(arguments);

  /* XXX */
  if (arguments->bool_option_template)
    printf("argc=%d, parsed_args=%d\n", argc, parsed_args);
  printf("argv[0]=%s\n", argv[0]);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %rbx
movl %edi, %r14d
testq %r8, %r8
je 0x54adf
movq %r8, %rdi
callq 0x89eb7
testb %al, %al
jne 0x54b45
testq %r15, %r15
je 0x54b1b
cmpb $0x1, (%r15)
jne 0x54afd
leaq 0x2a89e8(%rip), %rdi    # 0x2fd4d9
movl %r14d, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x17070
movq (%rbx), %rsi
leaq 0x2a89eb(%rip), %rdi    # 0x2fd4f2
xorl %eax, %eax
callq 0x17070
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x3e3446(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2904e7(%rip), %rsi    # 0x2e5013
leaq 0x2f3b20(%rip), %rdx    # 0x348653
leaq 0x2a898c(%rip), %rcx    # 0x2fd4c6
leaq 0x2a88e5(%rip), %r8     # 0x2fd426
pushq $0x5b
jmp 0x54b6d
movq 0x3e341c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2904bd(%rip), %rsi    # 0x2e5013
leaq 0x290662(%rip), %rdx    # 0x2e51bf
leaq 0x2a8962(%rip), %rcx    # 0x2fd4c6
leaq 0x2a88bb(%rip), %r8     # 0x2fd426
pushq $0x5a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_tir.c
// Function: gt_tir_arguments_new
static void* gt_tir_arguments_new(void)
{
  GtTirArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->str_indexname = gt_str_new();
  arguments->str_overlaps = gt_str_new();
  arguments->refseq_file = gt_str_new();
  arguments->cutoffs = gt_str_new();
  arguments->hmm_files = gt_str_array_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2a896c(%rip), %rdx    # 0x2fd518
pushq $0x1
popq %rdi
pushq $0x40
popq %rcx
movl $0xb0, %esi
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, (%rbx)
callq 0xacb84
movq %rax, 0x10(%rbx)
callq 0xacb84
movq %rax, 0x18(%rbx)
callq 0xacb84
movq %rax, 0x8(%rbx)
callq 0xae154
movq %rax, 0xa0(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_tir.c
// Function: gt_tir_arguments_delete
static void gt_tir_arguments_delete(void *tool_arguments)
{
  GtTirArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->str_indexname);
  gt_str_delete(arguments->cutoffs);
  gt_str_delete(arguments->refseq_file);
  gt_str_delete(arguments->str_overlaps);
  gt_str_array_delete(arguments->hmm_files);
  gt_option_delete(arguments->optionoverlaps);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x54c4a
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xae103
movq 0x8(%rbx), %rdi
callq 0xae103
movq 0x18(%rbx), %rdi
callq 0xae103
movq 0x10(%rbx), %rdi
callq 0xae103
movq 0xa0(%rbx), %rdi
callq 0xae662
movq 0x98(%rbx), %rdi
callq 0x9a8ea
leaq 0x2a88da(%rip), %rsi    # 0x2fd518
pushq $0x53
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_trieins.c
// Function: gt_trieins
int gt_trieins(int argc, const char **argv, GtError *err)
{
  bool haserr = false;
  int parsed_args;
  bool onlyins = false;

  gt_error_check(err);

  switch (parse_options(&onlyins,&parsed_args, argc, argv, err)) {
    case GT_OPTION_PARSER_OK: break;
    case GT_OPTION_PARSER_ERROR: return -1;
    case GT_OPTION_PARSER_REQUESTS_EXIT: return 0;
  }
  gt_assert(parsed_args == 1);

  if (gt_test_trieins(onlyins,argv[parsed_args],err) != 0)
  {
    haserr = true;
  }
  return haserr ? -1 : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movb $0x0, 0x3(%rsp)
testq %rdx, %rdx
je 0x5570d
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x557c8
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x557f2
leaq 0x2a84e8(%rip), %rdi    # 0x2fdbfc
leaq 0x2a84f5(%rip), %rsi    # 0x2fdc10
callq 0x97df5
movq %rax, %r15
leaq 0x290ba2(%rip), %rsi    # 0x2e62cc
movq %rax, %rdi
callq 0x98288
leaq 0x2e976d(%rip), %rdi    # 0x33eea6
leaq 0x2a84ff(%rip), %rsi    # 0x2fdc3f
leaq 0x3(%rsp), %rdx
xorl %ecx, %ecx
callq 0x9a997
movq %r15, %rdi
movq %rax, %rsi
callq 0x97f31
pushq $0x1
popq %rdx
movq %r15, %rdi
movl %edx, %esi
callq 0x98c6b
leaq 0x5d4e5(%rip), %r8      # 0xb2c50
leaq 0x4(%rsp), %rsi
movq %r15, %rdi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r9
callq 0x98cb0
movl %eax, %ebp
movq %r15, %rdi
callq 0x9a844
cmpl $0x1, %ebp
je 0x55798
cmpl $0x2, %ebp
jne 0x5579d
xorl %eax, %eax
jmp 0x557bd
pushq $-0x1
popq %rax
jmp 0x557bd
cmpl $0x1, 0x4(%rsp)
jne 0x5581c
movzbl 0x3(%rsp), %edi
movq 0x8(%r14), %rsi
movq %rbx, %rdx
callq 0x1b4770
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x3e2799(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x28f83a(%rip), %rsi    # 0x2e5013
leaq 0x28f9df(%rip), %rdx    # 0x2e51bf
leaq 0x2a83e2(%rip), %rcx    # 0x2fdbc9
leaq 0x2a83e6(%rip), %r8     # 0x2fdbd4
pushq $0x32
jmp 0x55844
movq 0x3e276f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x28f810(%rip), %rsi    # 0x2e5013
leaq 0x28f9b5(%rip), %rdx    # 0x2e51bf
leaq 0x30c6e1(%rip), %rcx    # 0x361ef2
leaq 0x2a83bc(%rip), %r8     # 0x2fdbd4
pushq $0x1f
jmp 0x55844
movq 0x3e2745(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x28f7e6(%rip), %rsi    # 0x2e5013
leaq 0x2a83b7(%rip), %rdx    # 0x2fdbeb
leaq 0x2a838e(%rip), %rcx    # 0x2fdbc9
leaq 0x2a8392(%rip), %r8     # 0x2fdbd4
pushq $0x39
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_uniq.c
// Function: gt_uniq_arguments_delete
static void gt_uniq_arguments_delete(void *tool_arguments)
{
  UniqArguments *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 0x558cc
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x8da06
movq 0x8(%rbx), %rdi
callq 0x9ba24
leaq 0x2a8397(%rip), %rsi    # 0x2fdc57
pushq $0x31
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_uniq.c
// Function: gt_uniq_option_parser_new
static GtOptionParser* gt_uniq_option_parser_new(void *tool_arguments)
{
  UniqArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] [GFF3_file]", "Filter out repeated "
                            "feature node graphs in a sorted GFF3 file.");

  /* -v */
  option = gt_option_new_verbose(&arguments->verbose);
  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_comment_func(op, gt_gtdata_show_help, NULL);
  gt_option_parser_set_max_args(op, 1);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5593c
movq %rdi, %r14
leaq 0x2907af(%rip), %rdi    # 0x2e608f
leaq 0x2a839e(%rip), %rsi    # 0x2fdc85
callq 0x97df5
movq %rax, %rbx
movq %r14, %rdi
callq 0x9a9b6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x8(%r14), %rdi
addq $0x10, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x9b6d7
leaq 0x91bd0(%rip), %rsi     # 0xe74ec
movq %rbx, %rdi
xorl %edx, %edx
callq 0x98045
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x98c29
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3e2625(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x28f6c6(%rip), %rsi    # 0x2e5013
leaq 0x2f2cff(%rip), %rdx    # 0x348653
leaq 0x2a8310(%rip), %rcx    # 0x2fdc6b
leaq 0x2a82f5(%rip), %r8     # 0x2fdc57
pushq $0x39
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_uniq.c
// Function: gt_uniq_runner
static int gt_uniq_runner(GT_UNUSED int argc, const char **argv,
                          int parsed_args, void *tool_arguments, GtError *err)
{
  UniqArguments *arguments = tool_arguments;
  GtNodeStream *gff3_in_stream,
               *uniq_stream = NULL,
               *gff3_out_stream = NULL;
  int had_err;

  gt_error_check(err);
  gt_assert(arguments);

  /* create gff3 input stream */
  gff3_in_stream = gt_gff3_in_stream_new_sorted(argv[parsed_args]);
  if (arguments->verbose && arguments->outfp)
    gt_gff3_in_stream_show_progress_bar((GtGFF3InStream*) gff3_in_stream);

  /* create uniq stream */
  uniq_stream = gt_uniq_stream_new(gff3_in_stream);

  /* create gff3 output stream */
  gff3_out_stream = gt_gff3_out_stream_new(uniq_stream, arguments->outfp);

  /* pull the features through the stream and free them afterwards */
  had_err = gt_node_stream_pull(gff3_out_stream, err);

  /* free */
  gt_node_stream_delete(gff3_out_stream);
  gt_node_stream_delete(uniq_stream);
  gt_node_stream_delete(gff3_in_stream);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
testq %r8, %r8
je 0x5599a
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x55a37
testq %r14, %r14
je 0x55a0d
movslq %ebp, %rax
movq (%r15,%rax,8), %rdi
callq 0xdef57
movq %rax, %r15
cmpb $0x1, (%r14)
jne 0x559c3
cmpq $0x0, 0x10(%r14)
je 0x559c3
movq %r15, %rdi
callq 0xdeb22
movq %r15, %rdi
callq 0x12bdb6
movq %rax, %r12
movq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0xe07df
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102b93
movl %eax, %ebx
movq %r14, %rdi
callq 0x10297b
movq %r12, %rdi
callq 0x10297b
movq %r15, %rdi
callq 0x10297b
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x3e2554(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x28f5f5(%rip), %rsi    # 0x2e5013
leaq 0x2f2c2e(%rip), %rdx    # 0x348653
leaq 0x2a8298(%rip), %rcx    # 0x2fdcc4
leaq 0x2a8224(%rip), %r8     # 0x2fdc57
pushq $0x56
jmp 0x55a5f
movq 0x3e252a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x28f5cb(%rip), %rsi    # 0x2e5013
leaq 0x28f770(%rip), %rdx    # 0x2e51bf
leaq 0x2a826e(%rip), %rcx    # 0x2fdcc4
leaq 0x2a81fa(%rip), %r8     # 0x2fdc57
pushq $0x55
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_wtree.c
// Function: gt_wtree_option_parser_new
static GtOptionParser* gt_wtree_option_parser_new(void *tool_arguments)
{
  GtToolbox *wtree_toolbox = tool_arguments;
  GtOptionParser *op;
  gt_assert(wtree_toolbox);
  op = gt_option_parser_new("[option ...] tool [argument ...]",
                            "Call an wtree manipulation tool "
                            "and pass argument(s) to it.");
  gt_option_parser_set_comment_func(op, gt_toolbox_show, wtree_toolbox);
  gt_option_parser_set_min_args(op, 1U);
  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x55b0c
movq %rdi, %rbx
leaq 0x29101d(%rip), %rdi    # 0x2e6af2
leaq 0x2a8235(%rip), %rsi    # 0x2fdd11
callq 0x97df5
movq %rax, %r14
leaq 0x5b3ad(%rip), %rsi     # 0xb0e98
movq %rax, %rdi
movq %rbx, %rdx
callq 0x98045
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x98be7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3e2455(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x28f4f6(%rip), %rsi    # 0x2e5013
leaq 0x2a81af(%rip), %rdx    # 0x2fdcd3
leaq 0x2a81b6(%rip), %rcx    # 0x2fdce1
leaq 0x2a81ca(%rip), %r8     # 0x2fdcfc
pushq $0x2d
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_wtree.c
// Function: gt_wtree_runner
static int gt_wtree_runner(int argc, const char **argv, int parsed_args,
                              void *tool_arguments, GT_UNUSED GtError *err)
{
  GtToolbox *wtree_toolbox = tool_arguments;
  GtTool *tool = NULL;
  int had_err = 0;
  char **nargv = NULL;

  gt_error_check(err);
  gt_assert(wtree_toolbox);

  /* get wtree tools */
  tool = gt_toolbox_get_tool(wtree_toolbox, argv[parsed_args]);
  if (!tool) {
    gt_error_set(err, "wtree tool '%s' not found; option -help "
                      "lists possible tools", argv[parsed_args]);
    had_err = -1;
  }

  /* call wtree tool */
  if (!had_err) {
    gt_assert(tool);
    nargv = gt_cstr_array_prefix_first(argv + parsed_args,
                                       gt_error_get_progname(err));
    gt_error_set_progname(err, nargv[0]);
    had_err = gt_tool_run(tool, argc - parsed_args, (const char**) nargv, err);
  }

  /* free */
  gt_cstr_array_delete(nargv);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %r14d
movq %rsi, %r12
movl %edi, %ebp
testq %r8, %r8
je 0x55b70
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x55c2a
testq %r15, %r15
je 0x55c00
movslq %r14d, %rax
leaq (%r12,%rax,8), %r13
movq (%r13), %rsi
movq %r15, %rdi
callq 0xb0d2d
testq %rax, %rax
je 0x55bcc
movq %rax, %r12
movq %rbx, %rdi
callq 0x8a001
movq %r13, %rdi
movq %rax, %rsi
callq 0x6c7c9
movq %rax, %r15
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x89f8a
subl %r14d, %ebp
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xb05a1
movl %eax, %ebx
jmp 0x55be7
movq (%r13), %rdx
leaq 0x2a8186(%rip), %rsi    # 0x2fdd5d
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rbx
movq %r15, %rdi
callq 0x6ca1b
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3e2361(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x28f402(%rip), %rsi    # 0x2e5013
leaq 0x2a80bb(%rip), %rdx    # 0x2fdcd3
leaq 0x2a812e(%rip), %rcx    # 0x2fdd4d
leaq 0x2a80d6(%rip), %r8     # 0x2fdcfc
pushq $0x3f
jmp 0x55c52
movq 0x3e2337(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x28f3d8(%rip), %rsi    # 0x2e5013
leaq 0x28f57d(%rip), %rdx    # 0x2e51bf
leaq 0x2a8104(%rip), %rcx    # 0x2fdd4d
leaq 0x2a80ac(%rip), %r8     # 0x2fdcfc
pushq $0x3e
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_wtree_bench.c
// Function: gt_wtree_bench_option_parser_new
static GtOptionParser* gt_wtree_bench_option_parser_new(void *tool_arguments)
{
  GtWaveletBenchArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] encoded_sequence",
                            "Testing and benchmarking for wtree.");

  /* -safe */
  option = gt_option_new_string("safe", "safe files to disk, currently not "
                                "implemented",
                                arguments->safe, NULL);
  gt_option_parser_add_option(op, option);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x55d23
movq %rdi, %rbx
leaq 0x2a80f0(%rip), %rdi    # 0x2fddd6
leaq 0x2a8107(%rip), %rsi    # 0x2fddf4
callq 0x97df5
movq %rax, %r14
movq (%rbx), %rdx
leaq 0x3107ef(%rip), %rdi    # 0x3664ee
leaq 0x2a8112(%rip), %rsi    # 0x2fde18
xorl %ecx, %ecx
callq 0x9ad12
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3e223e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x28f2df(%rip), %rsi    # 0x2e5013
leaq 0x2f2918(%rip), %rdx    # 0x348653
leaq 0x2a8073(%rip), %rcx    # 0x2fddb5
leaq 0x2a8051(%rip), %r8     # 0x2fdd9a
pushq $0x37
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_wtree_bench.c
// Function: gt_wtree_bench_arguments_check
static int gt_wtree_bench_arguments_check(int rest_argc,
                                          void *tool_arguments,
                                          GtError *err)
{
  GtWaveletBenchArguments *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(arguments);

  if (rest_argc == 0) {
    gt_error_set(err, "no encseq basename given");
    had_err = 1;
  }
  else if (rest_argc > 1) {
    gt_error_set(err, "give only one encseq basename");
    had_err = 1;
  }
  if (!had_err && gt_str_length(arguments->safe))
    printf("%s\n", gt_str_get(arguments->safe));

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
testq %rdx, %rdx
je 0x55d76
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x55df3
testq %r14, %r14
je 0x55dc9
testl %ebp, %ebp
je 0x55d8d
cmpl $0x2, %ebp
jl 0x55da3
leaq 0x2a80f3(%rip), %rsi    # 0x2fde7e
jmp 0x55d94
leaq 0x2a80d1(%rip), %rsi    # 0x2fde65
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $0x1
popq %rbx
jmp 0x55dc2
movq (%r14), %rdi
callq 0xad289
xorl %ebx, %ebx
testq %rax, %rax
je 0x55dc2
movq (%r14), %rdi
callq 0xad1fa
movq %rax, %rdi
callq 0x17b60
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x3e2198(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x28f239(%rip), %rsi    # 0x2e5013
leaq 0x2f2872(%rip), %rdx    # 0x348653
leaq 0x2a805e(%rip), %rcx    # 0x2fde46
leaq 0x2a7fab(%rip), %r8     # 0x2fdd9a
pushq $0x4d
jmp 0x55e1b
movq 0x3e216e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x28f20f(%rip), %rsi    # 0x2e5013
leaq 0x28f3b4(%rip), %rdx    # 0x2e51bf
leaq 0x2a8034(%rip), %rcx    # 0x2fde46
leaq 0x2a7f81(%rip), %r8     # 0x2fdd9a
pushq $0x4c
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390