LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtr.c
// Function: gtr_parse
GtOPrval gtr_parse(GtR *gtr, int *parsed_args, int argc, const char **argv,
                   GtError *err)
{
  GtOptionParser *op;
  GtOPrval oprval;
  gt_error_check(err);
  gt_assert(gtr);
  op = gtr_option_parser_new(gtr);
  oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc,
                                  err);
  gt_option_parser_delete(op);
  return oprval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
testq %r8, %r8
je 0x99f81
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x99fc5
testq %r12, %r12
je 0x99fc0
movq %r12, %rdi
callq 0x99fca
movq %rax, %r12
leaq 0x8b430(%rip), %r8      # 0x1253c8
movq %rax, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r9
callq 0x10d796
movl %eax, %ebx
movq %r12, %rdi
callq 0x10f2d0
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1810f
callq 0x180d6
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtr.c
// Function: gtr_register_components
void gtr_register_components(GtR *gtr)
{
  gt_assert(gtr);
  /* add tools */
  gt_toolbox_delete(gtr->tools);
  gtr->tools = gtt_tools();
  /* add unit tests */
  gt_hashmap_delete(gtr->unit_tests);
  gtr->unit_tests = gtt_unit_tests();
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x9a296
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x123c12
callq 0x9ace8
movq %rax, 0x20(%rbx)
movq 0x28(%rbx), %rdi
callq 0x105f7d
callq 0x9b43a
movq %rax, 0x28(%rbx)
popq %rbx
retq
callq 0x18148
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtr.c
// Function: gtr_delete
void gtr_delete(GtR *gtr)
{
  if (!gtr) return;
  gt_fa_fclose(gtr->logfp);
  gt_str_delete(gtr->testspacepeak);
  gt_str_delete(gtr->debugfp);
  gt_str_delete(gtr->test_only);
  gt_str_delete(gtr->manoutdir);
  gt_toolbox_delete(gtr->tools);
  gt_hashmap_delete(gtr->unit_tests);
  if (gtr->L) lua_close(gtr->L);
#ifndef WITHOUT_CAIRO
  gt_style_delete_without_state(gtr->style);
#endif
  gt_free(gtr);
}

// Assembly:
testq %rdi, %rdi
je 0x9ab4d
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
callq 0x101e80
movq 0x18(%rbx), %rdi
callq 0x121b03
movq 0x10(%rbx), %rdi
callq 0x121b03
movq 0x38(%rbx), %rdi
callq 0x121b03
movq 0x30(%rbx), %rdi
callq 0x121b03
movq 0x20(%rbx), %rdi
callq 0x123c12
movq 0x28(%rbx), %rdi
callq 0x105f7d
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x9ab2f
callq 0x2307b5
movq 0x48(%rbx), %rdi
callq 0x22b77f
leaq 0x2b3606(%rip), %rsi    # 0x34e145
movq %rbx, %rdi
movl $0x224, %edx            # imm = 0x224
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtr.c
// Function: show_gtr_help
static int show_gtr_help(const char *progname, void *data, GtError *err)
{
  int had_err;
  had_err = gt_toolbox_show(progname, data, err);
  if (!had_err)
    had_err = gt_gtdata_show_help(progname, NULL, err);
  return had_err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0x123aae
testl %eax, %eax
je 0x9ab69
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x153e9c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtr.c
// Function: create_manpage
static int create_manpage(const char *outdir, const char *toolname,
                          GtOptionParser *option_parser, GtError *err)
{
  GtFile *outfile = NULL;
  GtStr *man, *pathbuf;
  char *utoolname;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(outdir && toolname && option_parser);
  man = gt_str_new();
  pathbuf = gt_str_new_cstr(outdir);
  utoolname = gt_cstr_dup(toolname);
  gt_cstr_rep(utoolname, ' ', '_');
  if (!gt_file_exists(gt_str_get(pathbuf)))
    gt_xmkdir(gt_str_get(pathbuf));
  gt_str_append_char(pathbuf, GT_PATH_SEPARATOR);
  gt_str_append_cstr(pathbuf, utoolname);
  gt_str_append_cstr(pathbuf, ".mansrc");
  gt_free(utoolname);
  if (!(outfile = gt_file_new(gt_str_get(pathbuf), "w+", err)))
    had_err = -1;
  if (!had_err)
    had_err = gt_option_parser_manpage(option_parser, toolname, man, err);
  if (!had_err)
    gt_file_xprintf(outfile, "%s", gt_str_get(man));
  gt_file_delete(outfile);
  gt_str_delete(pathbuf);
  gt_str_delete(man);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r14
testq %rcx, %rcx
je 0x9aba9
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0x9ace1
testq %r14, %r14
je 0x9acdc
testq %r12, %r12
je 0x9acdc
testq %r13, %r13
je 0x9acdc
callq 0x1208f8
movq %rax, %rbx
movq %r14, %rdi
callq 0x120955
movq %rax, %r14
movq %r12, %rdi
callq 0xe8760
movq %rax, %rbp
movq %rax, %rdi
movl $0x20, %esi
movl $0x5f, %edx
callq 0xe87ec
movq %r14, %rdi
callq 0x120d23
movq %rax, %rdi
callq 0x10415c
testb %al, %al
jne 0x9ac18
movq %r14, %rdi
callq 0x120d23
movq %rax, %rdi
callq 0x12595b
movq %r14, %rdi
movl $0x2f, %esi
callq 0x120ba5
movq %r14, %rdi
movq %rbp, %rsi
callq 0x12097f
leaq 0x2b3a2a(%rip), %rsi    # 0x34e661
movq %r14, %rdi
callq 0x12097f
leaq 0x2b34ff(%rip), %rsi    # 0x34e145
movq %rbp, %rdi
movl $0x138, %edx            # imm = 0x138
callq 0x109670
movq %r14, %rdi
callq 0x120d23
leaq 0x2b3a07(%rip), %rsi    # 0x34e669
movq %rax, %rdi
movq %r15, %rdx
callq 0x103957
movq %rax, %rbp
testq %rax, %rax
je 0x9ac8b
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x10cec0
movl %eax, %r15d
jmp 0x9ac91
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testl %r15d, %r15d
jne 0x9acb2
movq %rbx, %rdi
callq 0x120d23
leaq 0x33752c(%rip), %rsi    # 0x3d21d1
movq %rbp, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x103d21
movq %rbp, %rdi
callq 0x1040fc
movq %r14, %rdi
callq 0x121b03
movq %rbx, %rdi
callq 0x121b03
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x18382
callq 0x18349
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/interactive.c
// Function: pushline
static int pushline(lua_State *L, bool firstline) {
  char buffer[BUFSIZ];
  char *b = buffer;
  size_t l;
  const char *prmt = get_prompt(L, firstline);
  b = buffer; /* use static buffer */
  fputs(prmt, stdout); fflush(stdout);/* show prompt */
  if (!fgets(b, BUFSIZ, stdin))  /* get line */
    return 0; /* no input */
  l = strlen(b);
  if (l > 0 && b[l-1] == '\n')  /* line ends with newline? */
    b[l-1] = '\0';  /* remove it */
  if (firstline && b[0] == '=')  /* first line starts with `=' ? */
    lua_pushfstring(L, "return %s", b+1);  /* change it to `return' */
  else
    lua_pushstring(L, b);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2000, %rsp           # imm = 0x2000
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x2b30ad(%rip), %rax    # 0x34ef11
leaq 0x2b30ae(%rip), %rdx    # 0x34ef19
testl %esi, %esi
cmovneq %rax, %rdx
leaq 0x31dca1(%rip), %rax    # 0x3b9b19
leaq 0x2b30a3(%rip), %r15    # 0x34ef22
cmovneq %rax, %r15
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x22e6f4
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x22db9e
testq %rax, %rax
cmovneq %rax, %r15
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x22d42e
movq 0x42802e(%rip), %r12    # 0x4c3ee8
movq (%r12), %rsi
movq %r15, %rdi
callq 0x178c0
movq (%r12), %rdi
callq 0x178f0
movq 0x428052(%rip), %rax    # 0x4c3f28
movq (%rax), %rdx
movq %rsp, %rdi
movl $0x2000, %esi           # imm = 0x2000
callq 0x17c30
testq %rax, %rax
je 0x9bf38
movq %rsp, %rdi
callq 0x172f0
testq %rax, %rax
je 0x9bf04
cmpb $0xa, -0x1(%rsp,%rax)
jne 0x9bf04
movb $0x0, -0x1(%rsp,%rax)
testb %bpl, %bpl
je 0x9bf27
cmpb $0x3d, (%rsp)
jne 0x9bf27
leaq 0x1(%rsp), %rdx
leaq 0x2b2fec(%rip), %rsi    # 0x34ef07
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22e3dc
jmp 0x9bf32
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x22e0c4
movl $0x1, %r14d
movl %r14d, %eax
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/interactive.c
// Function: traceback
static int traceback(lua_State *L) {
  lua_getfield(L, LUA_GLOBALSINDEX, "debug");
  if (!lua_istable(L, -1)) {
    lua_pop(L, 1);
    return 1;
  }
  lua_getfield(L, -1, "traceback");
  if (!lua_isfunction(L, -1)) {
    lua_pop(L, 2);
    return 1;
  }
  lua_pushvalue(L, 1);  /* pass error message */
  lua_pushinteger(L, 2);  /* skip this function and traceback */
  lua_call(L, 2, 1);  /* call debug.traceback */
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x2b2fd8(%rip), %rdx    # 0x34ef2e
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x22e6f4
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22d7b8
cmpl $0x5, %eax
jne 0x9bfc6
leaq 0x3497c9(%rip), %rdx    # 0x3e5742
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22e6f4
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22d7b8
cmpl $0x6, %eax
jne 0x9bfd0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x22d798
movl $0x2, %esi
movq %rbx, %rdi
callq 0x22ded3
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x22efe6
jmp 0x9bfdd
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
jmp 0x9bfd8
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x22d42e
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_bed_to_gff3.c
// Function: gt_bed_to_gff3_arguments_new
static void *gt_bed_to_gff3_arguments_new(void)
{
  BEDToGFF3Arguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->feature_type = gt_str_new();
  arguments->thick_feature_type = gt_str_new();
  arguments->block_type = gt_str_new();
  arguments->ofi = gt_output_file_info_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2b2f09(%rip), %rdx    # 0x34ef60
movl $0x1, %edi
movl $0x28, %esi
movl $0x25, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, (%rbx)
callq 0x1208f8
movq %rax, 0x8(%rbx)
callq 0x1208f8
movq %rax, 0x10(%rbx)
callq 0x10ff7c
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_bed_to_gff3.c
// Function: gt_bed_to_gff3_arguments_delete
static void gt_bed_to_gff3_arguments_delete(void *tool_arguments)
{
  BEDToGFF3Arguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_str_delete(arguments->block_type);
  gt_str_delete(arguments->thick_feature_type);
  gt_str_delete(arguments->feature_type);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x9c0e0
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x1040fc
movq 0x18(%rbx), %rdi
callq 0x110231
movq 0x10(%rbx), %rdi
callq 0x121b03
movq 0x8(%rbx), %rdi
callq 0x121b03
movq (%rbx), %rdi
callq 0x121b03
leaq 0x2b2e8e(%rip), %rsi    # 0x34ef60
movq %rbx, %rdi
movl $0x36, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_bed_to_gff3.c
// Function: gt_bed_to_gff3_option_parser_new
static GtOptionParser* gt_bed_to_gff3_option_parser_new(void *tool_arguments)
{
  BEDToGFF3Arguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *o;

  op = gt_option_parser_new("[BED_file]",
                            "Parse BED file and convert it to GFF3.");

  o = gt_option_new_string("featuretype", "Set type of parsed BED features",
                           arguments->feature_type, BED_FEATURE_TYPE);
  gt_option_parser_add_option(op, o);

  o = gt_option_new_string("thicktype", "Set type of parsed thick BED features",
                           arguments->thick_feature_type,
                           BED_THICK_FEATURE_TYPE);
  gt_option_parser_add_option(op, o);

  o = gt_option_new_string("blocktype", "Set type of parsed BED blocks",
                           arguments->block_type, BED_BLOCK_TYPE);
  gt_option_parser_add_option(op, o);

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

  gt_option_parser_set_max_args(op, 1);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x2b2e8c(%rip), %rdi    # 0x34ef7b
leaq 0x2b2e90(%rip), %rsi    # 0x34ef86
callq 0x10cc4e
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x2eb28f(%rip), %rdi    # 0x387397
leaq 0x2b2e9e(%rip), %rsi    # 0x34efad
leaq 0x2b2eb7(%rip), %rcx    # 0x34efcd
callq 0x10f987
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x8(%r14), %rdx
leaq 0x2b2ea8(%rip), %rdi    # 0x34efd9
leaq 0x2b2eab(%rip), %rsi    # 0x34efe3
leaq 0x2b2eca(%rip), %rcx    # 0x34f009
callq 0x10f987
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x10(%r14), %rdx
leaq 0x2b2ec1(%rip), %rdi    # 0x34f01b
leaq 0x2b2ec4(%rip), %rsi    # 0x34f025
leaq 0x2b2edb(%rip), %rcx    # 0x34f043
callq 0x10f987
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x18(%r14), %rdi
addq $0x20, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x10ffa3
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10d775
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_bed_to_gff3.c
// Function: gt_bed_to_gff3_runner
static int gt_bed_to_gff3_runner(GT_UNUSED int argc, const char **argv,
                                 int parsed_args, void *tool_arguments,
                                 GtError *err)
{
  GtNodeStream *bed_in_stream = NULL, *gff3_out_stream = NULL;
  BEDToGFF3Arguments *arguments = tool_arguments;
  int had_err;

  gt_error_check(err);

  /* create a BED input stream */
  bed_in_stream = gt_bed_in_stream_new(argv[parsed_args]);
  gt_bed_in_stream_set_feature_type((GtBEDInStream*) bed_in_stream,
                                    gt_str_get(arguments->feature_type));
  gt_bed_in_stream_set_thick_feature_type((GtBEDInStream*) bed_in_stream,
                                          gt_str_get(arguments
                                                     ->thick_feature_type));
  gt_bed_in_stream_set_block_type((GtBEDInStream*) bed_in_stream,
                                  gt_str_get(arguments->block_type));

  /* create a GFF3 output stream */
  gff3_out_stream = gt_gff3_out_stream_new(bed_in_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(bed_in_stream);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
testq %r8, %r8
je 0x9c1ca
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x9c24d
movslq %ebp, %rax
movq (%r15,%rax,8), %rdi
callq 0x12c509
movq %rax, %r15
movq (%r14), %rdi
callq 0x120d23
movq %r15, %rdi
movq %rax, %rsi
callq 0x12c574
movq 0x8(%r14), %rdi
callq 0x120d23
movq %r15, %rdi
movq %rax, %rsi
callq 0x12c58d
movq 0x10(%r14), %rdi
callq 0x120d23
movq %r15, %rdi
movq %rax, %rsi
callq 0x12c5a6
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x14e310
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16adca
movl %eax, %ebx
movq %r14, %rdi
callq 0x16ac6e
movq %r15, %rdi
callq 0x16ac6e
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1845f
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_cds.c
// Function: gt_cds_arguments_new
static void* gt_cds_arguments_new(void)
{
  CDSArguments *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 0x2b2de4(%rip), %rdx    # 0x34f063
movl $0x1, %edi
movl $0x20, %esi
movl $0x2d, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x17b020
movq %rax, 0x8(%rbx)
callq 0x10ff7c
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_cds.c
// Function: gt_cds_arguments_delete
static void gt_cds_arguments_delete(void *tool_arguments)
{
  CDSArguments *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 0x9c2e6
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x1040fc
movq 0x10(%rbx), %rdi
callq 0x110231
movq 0x8(%rbx), %rdi
callq 0x17b067
leaq 0x2b2d8b(%rip), %rsi    # 0x34f063
movq %rbx, %rdi
movl $0x3a, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_cds.c
// Function: gt_cds_runner
static int gt_cds_runner(GT_UNUSED int argc, const char **argv, int parsed_args,
                         void *tool_arguments, GtError *err)
{
  GtNodeStream *gff3_in_stream, *cds_stream = NULL, *gff3_out_stream = NULL;
  CDSArguments *arguments = tool_arguments;
  GtRegionMapping *region_mapping;
  int had_err = 0;

  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 region mapping */
  region_mapping = gt_seqid2file_region_mapping_new(arguments->s2fi, err);
  if (!region_mapping)
    had_err = -1;

  if (!had_err) {
    /* create CDS stream */
    cds_stream = gt_cds_stream_new(gff3_in_stream, region_mapping,
                                   arguments->minorflen, GT_CDS_SOURCE_TAG,
                                   arguments->start_codon,
                                   arguments->final_stop_codon,
                                   arguments->generic_start_codons);

    /* create gff3 output stream */
    gff3_out_stream = gt_gff3_out_stream_new(cds_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(cds_stream);
  gt_node_stream_delete(gff3_in_stream);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %rbx
testq %r8, %r8
je 0x9c43c
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x9c4fa
testq %r15, %r15
je 0x9c4f5
movslq %ebp, %rax
movq (%rbx,%rax,8), %rdi
callq 0x14d0a8
movq %rax, %rbx
cmpb $0x1, 0x7(%r15)
jne 0x9c46a
cmpq $0x0, 0x18(%r15)
je 0x9c46a
movq %rbx, %rdi
callq 0x14ce62
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0x17b3bd
testq %rax, %rax
je 0x9c4c3
movl (%r15), %edx
movzbl 0x4(%r15), %r8d
movzbl 0x5(%r15), %r9d
movzbl 0x6(%r15), %ecx
movl %ecx, (%rsp)
leaq 0x2b2d88(%rip), %rcx    # 0x34f21f
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12dfec
movq %rax, %r12
movq 0x18(%r15), %rsi
movq %rax, %rdi
callq 0x14e310
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x16adca
movl %eax, %ebp
jmp 0x9c4ce
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x16ac6e
movq %r12, %rdi
callq 0x16ac6e
movq %rbx, %rdi
callq 0x16ac6e
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x18504
callq 0x184cd
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_chain2dim.c
// Function: gt_outputformatchaingeneric
static void gt_outputformatchaingeneric(
                                bool silent,
                                void *data,
                                const GtChain2Dimmatchtable *matchtable,
                                const GtChain2Dim *chain)
{
  GtUword idx, chainlength;
  Counter *counter = (Counter *) data;

  chainlength = gt_chain_chainlength(chain);
  printf("# chain "GT_WU": length "GT_WU" score "GT_WD"\n",
         counter->chaincounter,chainlength,gt_chain_chainscore(chain));
  if (!silent)
  {
    GtChain2Dimmatchvalues value;

    if (gt_chain_storedinreverseorder(chain))
    {
      for (idx=chainlength; idx > 0; idx--)
      {
        gt_chain_extractchainelem(&value, matchtable, chain, idx - 1);
        gt_chain_printchainelem(stdout,&value);
      }
    } else
    {
      for (idx=0; idx < chainlength; idx++)
      {
        gt_chain_extractchainelem(&value, matchtable, chain, idx);
        gt_chain_printchainelem(stdout,&value);
      }
    }
  }
  counter->chaincounter++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movl %edi, %ebp
movq %rcx, %rdi
callq 0x19691e
movq %rax, %r12
movq (%rbx), %r13
movq %r14, %rdi
callq 0x196919
leaq 0x2b2cea(%rip), %rdi    # 0x34f230
movq %r13, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x17070
testl %ebp, %ebp
jne 0x9c5e4
movq %rbx, 0x8(%rsp)
movq %r14, %rdi
callq 0x196923
testb %al, %al
je 0x9c5a7
testq %r12, %r12
je 0x9c5df
decq %r12
leaq 0x10(%rsp), %r13
movq 0x427965(%rip), %rbx    # 0x4c3ee8
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x196927
movq (%rbx), %rdi
movq %r13, %rsi
callq 0x196977
addq $-0x1, %r12
jb 0x9c583
jmp 0x9c5df
testq %r12, %r12
je 0x9c5df
xorl %r13d, %r13d
leaq 0x10(%rsp), %rbp
movq 0x42792d(%rip), %rbx    # 0x4c3ee8
movq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x196927
movq (%rbx), %rdi
movq %rbp, %rsi
callq 0x196977
incq %r13
cmpq %r13, %r12
jne 0x9c5bb
movq 0x8(%rsp), %rbx
incq (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_chain2dim.c
// Function: gt_chain2dim_arguments_delete
static void gt_chain2dim_arguments_delete (void *tool_arguments)
{
  GtChain2dimoptions *arguments = tool_arguments;

  if (!arguments)
  {
    return;
  }
  gt_str_delete (arguments->matchfile);
  gt_str_array_delete (arguments->globalargs);
  gt_str_array_delete (arguments->localargs);
  gt_option_delete (arguments->refoptionmaxgap);
  gt_option_delete (arguments->refoptionweightfactor);
  gt_option_delete (arguments->refoptionglobal);
  gt_option_delete (arguments->refoptionlocal);
  gt_free (arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x9c6a1
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x121b03
movq 0x20(%rbx), %rdi
callq 0x121e8b
movq 0x28(%rbx), %rdi
callq 0x121e8b
movq 0x30(%rbx), %rdi
callq 0x10f386
movq 0x38(%rbx), %rdi
callq 0x10f386
movq 0x40(%rbx), %rdi
callq 0x10f386
movq 0x48(%rbx), %rdi
callq 0x10f386
leaq 0x2b2bc0(%rip), %rsi    # 0x34f253
movq %rbx, %rdi
movl $0x2c, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_chseqids.c
// Function: gt_chseqids_arguments_delete
static void gt_chseqids_arguments_delete(void *tool_arguments)
{
  ChseqidsArguments *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 0x9cbf4
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x1040fc
movq 0x8(%rbx), %rdi
callq 0x110231
leaq 0x2b2cf1(%rip), %rsi    # 0x34f8d7
movq %rbx, %rdi
movl $0x35, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_chseqids.c
// Function: gt_chseqids_option_parser_new
static GtOptionParser* gt_chseqids_option_parser_new(void *tool_arguments)
{
  ChseqidsArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] mapping_file [GFF3_file]",
                         "Change sequence ids by the mapping given in a "
                         "mapping file.");

  /* -sort */
  option = gt_option_new_bool("sort",
                              "sort the GFF3 features after changing the "
                              "sequence ids\n(memory consumption is "
                              "proportional to the input file size)",
                              &arguments->sort, false);
  gt_option_parser_add_option(op, option);

  /* -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);

  /* parse options */
  gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);
  gt_option_parser_set_min_max_args(op, 1, 2);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9cc93
movq %rdi, %r14
leaq 0x2b2d01(%rip), %rdi    # 0x34f90d
leaq 0x2b2d20(%rip), %rsi    # 0x34f933
callq 0x10cc4e
movq %rax, %rbx
leaq 0x3151ae(%rip), %rdi    # 0x3b1dd0
leaq 0x2b2d46(%rip), %rsi    # 0x34f96f
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x1(%r14), %rdi
callq 0x10f473
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x8(%r14), %rdi
addq $0x10, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x10ffa3
leaq 0xb7230(%rip), %rsi     # 0x153e9c
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10cd8d
movq %rbx, %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x10d784
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1868f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_chseqids.c
// Function: gt_chseqids_runnter
static int gt_chseqids_runnter(GT_UNUSED int argc, const char **argv,
                               int parsed_args, void *tool_arguments,
                               GtError *err)
{
  ChseqidsArguments *arguments = tool_arguments;
  GtNodeStream *gff3_in_stream, *chseqids_stream, *sort_stream = NULL,
               *gff3_out_stream = NULL;
  GtStr *chseqids;
  int had_err = 0;

  gt_error_check(err);
  gt_assert(arguments);

  /* create the streams */
  gff3_in_stream = gt_gff3_in_stream_new_sorted(argv[parsed_args + 1]);
  if (arguments->verbose && arguments->outfp)
    gt_gff3_in_stream_show_progress_bar((GtGFF3InStream*) gff3_in_stream);
  chseqids = gt_str_new_cstr(argv[parsed_args]);
  chseqids_stream = gt_chseqids_stream_new(gff3_in_stream, chseqids, err);
  if (!chseqids_stream)
    had_err = -1;
  gt_str_delete(chseqids);
  if (!had_err) {
    if (arguments->sort) {
      sort_stream = gt_sort_stream_new(chseqids_stream);
      gff3_out_stream = gt_gff3_out_stream_new(sort_stream, arguments->outfp);
    }
    else {
      gff3_out_stream = gt_gff3_out_stream_new(chseqids_stream,
                                               arguments->outfp);
    }
  }

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

  /* free */
  gt_node_stream_delete(gff3_out_stream);
  gt_node_stream_delete(chseqids_stream);
  gt_node_stream_delete(sort_stream);
  gt_node_stream_delete(gff3_in_stream);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %r15
testq %r8, %r8
je 0x9ccc3
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x9cda9
testq %r12, %r12
je 0x9cda4
movslq %ebp, %r13
movq 0x8(%r15,%r13,8), %rdi
callq 0x14d0a8
movq %rax, %r14
cmpb $0x1, 0x1(%r12)
jne 0x9ccf4
cmpq $0x0, 0x10(%r12)
je 0x9ccf4
movq %r14, %rdi
callq 0x14ce62
movq (%r15,%r13,8), %rdi
callq 0x120955
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x12efdf
movq %rax, %r15
movq %r13, %rdi
callq 0x121b03
testq %r15, %r15
je 0x9cd42
cmpb $0x1, (%r12)
jne 0x9cd47
movq %r15, %rdi
callq 0x17e1d7
movq %rax, %r13
movq 0x10(%r12), %rsi
movq %rax, %rdi
callq 0x14e310
movq %rax, %r12
jmp 0x9cd5a
xorl %r12d, %r12d
jmp 0x9cd57
movq 0x10(%r12), %rsi
movq %r15, %rdi
callq 0x14e310
movq %rax, %r12
xorl %r13d, %r13d
testq %r15, %r15
je 0x9cd6e
movq %r12, %rdi
movq %rbx, %rsi
callq 0x16adca
movl %eax, %ebx
jmp 0x9cd73
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %r12, %rdi
callq 0x16ac6e
movq %r15, %rdi
callq 0x16ac6e
movq %r13, %rdi
callq 0x16ac6e
movq %r14, %rdi
callq 0x16ac6e
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x186fd
callq 0x186c6
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_clean.c
// Function: gt_clean_runner
int gt_clean_runner(GT_UNUSED int argc, GT_UNUSED const char **argv,
                    GT_UNUSED int parsed_args, GT_UNUSED void *tool_arguments,
                    GT_UNUSED GtError *err)
{
  gt_error_check(err);

#ifndef _WIN32
  remove_pattern_in_current_dir(GT_ENCSEQFILESUFFIX);
  remove_pattern_in_current_dir(GT_SSPTABFILESUFFIX);
  remove_pattern_in_current_dir(GT_DESTABFILESUFFIX);
  remove_pattern_in_current_dir(GT_SDSTABFILESUFFIX);
  remove_pattern_in_current_dir(GT_OISTABFILESUFFIX);
  remove_pattern_in_current_dir(GT_MD5TABFILESUFFIX);
#else
  /* XXX */
  gt_error_set(err, "gt_clean_runner() not implemented");
  return -1;
#endif

  return 0;
}

// Assembly:
pushq %rax
testq %r8, %r8
je 0x9cdc2
movq %r8, %rdi
callq 0x101a9a
testb %al, %al
jne 0x9ce0e
leaq 0x2b2c52(%rip), %rdi    # 0x34fa1b
callq 0x9ce13
leaq 0x2b2c4b(%rip), %rdi    # 0x34fa20
callq 0x9ce13
leaq 0x2b2c44(%rip), %rdi    # 0x34fa25
callq 0x9ce13
leaq 0x2b2c3d(%rip), %rdi    # 0x34fa2a
callq 0x9ce13
leaq 0x2b2c36(%rip), %rdi    # 0x34fa2f
callq 0x9ce13
leaq 0x2b2c2f(%rip), %rdi    # 0x34fa34
callq 0x9ce13
xorl %eax, %eax
popq %rcx
retq
callq 0x18734
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_clean.c
// Function: remove_pattern_in_current_dir
static void remove_pattern_in_current_dir(const char *pattern)
{
  char **files_to_remove;
  GtStr *path;
  glob_t g;

  path = gt_str_new_cstr("./*");
  gt_str_append_cstr(path, pattern);
  gt_xglob(gt_str_get(path), GLOB_NOCHECK, NULL, &g);

  /* remove found files */
  if (g.gl_pathc) {
    files_to_remove = g.gl_pathv;
    if (strcmp(*files_to_remove, gt_str_get(path))) {
      while (*files_to_remove) {
        gt_xunlink(*files_to_remove);
        files_to_remove++;
      }
    }
  }

  /* free */
  globfree(&g);
  gt_str_delete(path);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
leaq 0x2b2c13(%rip), %rdi    # 0x34fa39
callq 0x120955
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x12097f
movq %rbx, %rdi
callq 0x120d23
leaq 0x8(%rsp), %r14
movq %rax, %rdi
movl $0x10, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x1258f9
cmpq $0x0, (%r14)
je 0x9ce9a
movq 0x10(%rsp), %r15
movq (%r15), %r14
movq %rbx, %rdi
callq 0x120d23
movq %r14, %rdi
movq %rax, %rsi
callq 0x17a40
testl %eax, %eax
je 0x9ce9a
movq (%r15), %rdi
testq %rdi, %rdi
je 0x9ce9a
addq $0x8, %r15
callq 0x1259fb
movq (%r15), %rdi
addq $0x8, %r15
testq %rdi, %rdi
jne 0x9ce89
leaq 0x8(%rsp), %rdi
callq 0x17500
movq %rbx, %rdi
callq 0x121b03
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_compreads.c
// Function: gt_compreads_arguments_new
static void* gt_compreads_arguments_new(void)
{
  GtToolbox *compreads_toolbox = gt_toolbox_new();
  gt_toolbox_add_tool(compreads_toolbox,
      "refcompress", gt_compreads_refcompress());
  gt_toolbox_add_tool(compreads_toolbox,
      "refdecompress", gt_compreads_refdecompress());
  gt_toolbox_add_tool(compreads_toolbox,
      "compress", gt_compreads_compress());
  gt_toolbox_add_tool(compreads_toolbox,
      "decompress", gt_compreads_decompress());
  return compreads_toolbox;
}

// Assembly:
pushq %rbx
callq 0x12391a
movq %rax, %rbx
callq 0x9dd9c
leaq 0x2b2b3e(%rip), %rsi    # 0x34fa8e
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12394f
callq 0x9e27c
leaq 0x2b2b33(%rip), %rsi    # 0x34fa9a
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12394f
callq 0x9d110
leaq 0x2b2b21(%rip), %rsi    # 0x34fa9f
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12394f
callq 0x9d728
leaq 0x2b2b08(%rip), %rsi    # 0x34fa9d
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12394f
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_compreads.c
// Function: gt_compreads_option_parser_new
static GtOptionParser* gt_compreads_option_parser_new(void *tool_arguments)
{
  GtToolbox *compreads_toolbox = tool_arguments;
  GtOptionParser *op;
  gt_assert(compreads_toolbox);
  op = gt_option_parser_new("[option ...] tool [argument ...]",
                            "Call a fastq file compression tool.");
  gt_option_parser_set_comment_func(op, gt_toolbox_show, compreads_toolbox);
  gt_option_parser_set_min_args(op, 1U);
  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9cffb
movq %rdi, %rbx
leaq 0x2b2b30(%rip), %rdi    # 0x34faf2
leaq 0x2b2b4a(%rip), %rsi    # 0x34fb13
callq 0x10cc4e
movq %rax, %r14
leaq 0x86ad6(%rip), %rsi     # 0x123aae
movq %rax, %rdi
movq %rbx, %rdx
callq 0x10cd8d
movq %r14, %rdi
movl $0x1, %esi
callq 0x10d766
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1876b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_compreads.c
// Function: gt_compreads_runner
static int gt_compreads_runner(GT_UNUSED int argc,
                         const char **argv,
                         int parsed_args,
                         void *tool_arguments, GtError *err)
{
  GtToolbox *compreads_toolbox = tool_arguments;
  GtToolfunc toolfunc;
  GtTool *tool = NULL;
  int had_err = 0;
  char **nargv = NULL;

  gt_error_check(err);
  gt_assert(compreads_toolbox);
  if (!gt_toolbox_has_tool(compreads_toolbox, argv[parsed_args])) {
    gt_error_set(err, "compreads tool '%s' not found; option -help lists "
                      "possible tools", argv[parsed_args]);
    had_err = -1;
  }

  if (!had_err) {
    if (!(toolfunc = gt_toolbox_get(compreads_toolbox, argv[parsed_args]))) {
      tool = gt_toolbox_get_tool(compreads_toolbox, argv[parsed_args]);
      gt_assert(tool);
    }

    nargv = gt_cstr_array_prefix_first(argv + parsed_args,
                                       gt_error_get_progname(err));
    gt_error_set_progname(err, nargv[0]);
    if (toolfunc != NULL)
      had_err = toolfunc(argc - parsed_args, (const char**) nargv, err);
    else
      had_err = gt_tool_run(tool, argc - parsed_args, (const char**) nargv,
                            err);
  }
  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 0x9d02e
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x9d106
testq %r15, %r15
je 0x9d101
movslq %r14d, %r13
movq (%r12,%r13,8), %rsi
movq %r15, %rdi
callq 0x123a17
movq (%r12,%r13,8), %rdx
testb %al, %al
je 0x9d06f
leaq (%r12,%r13,8), %r13
movq %r15, %rdi
movq %rdx, %rsi
callq 0x123a87
movq %rax, %r12
testq %rax, %rax
je 0x9d08a
movq $0x0, (%rsp)
jmp 0x9d09f
leaq 0x2b2ad5(%rip), %rsi    # 0x34fb4b
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x9d0e8
movq (%r13), %rsi
movq %r15, %rdi
callq 0x1239f1
movq %rax, (%rsp)
testq %rax, %rax
je 0x9d10b
movq %rbx, %rdi
callq 0x101b22
movq %r13, %rdi
movq %rax, %rsi
callq 0xe8b1a
movq %rax, %r15
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x101ada
subl %r14d, %ebp
testq %r12, %r12
je 0x9d0d5
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq *%r12
jmp 0x9d0e6
movq (%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x123470
movl %eax, %ebx
movq %r15, %rdi
callq 0xe8d46
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x18810
callq 0x187a2
callq 0x187d9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_compreads_compress.c
// Function: gt_compreads_compress_arguments_new
static void* gt_compreads_compress_arguments_new(void)
{
  GtCsrHcrEncodeArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->smap = gt_str_new();
  arguments->name = gt_str_new();
  arguments->files = gt_str_array_new();
  arguments->qrng.start = GT_UNDEF_UINT;
  arguments->qrng.end = GT_UNDEF_UINT;
  arguments->arg_range.start = GT_UNDEF_UWORD;
  arguments->arg_range.end = GT_UNDEF_UWORD;
  arguments->method = gt_str_new();
  arguments->pagewise = false;
  arguments->regular = false;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2b2a4c(%rip), %rdx    # 0x34fb8c
movl $0x1, %edi
movl $0x48, %esi
movl $0x34, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, 0x8(%rbx)
callq 0x1208f8
movq %rax, 0x18(%rbx)
callq 0x121b54
movq %rax, 0x20(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x30(%rbx)
movq $-0x1, 0x40(%rbx)
callq 0x1208f8
movq %rax, 0x10(%rbx)
movw $0x0, 0x1(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_compreads_compress.c
// Function: gt_compreads_compress_arguments_delete
static void gt_compreads_compress_arguments_delete(void *tool_arguments)
{
  GtCsrHcrEncodeArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->name);
  gt_str_array_delete(arguments->files);
  gt_str_delete(arguments->smap);
  gt_str_delete(arguments->method);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x9d1d9
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x121b03
movq 0x20(%rbx), %rdi
callq 0x121e8b
movq 0x8(%rbx), %rdi
callq 0x121b03
movq 0x10(%rbx), %rdi
callq 0x121b03
leaq 0x2b29c1(%rip), %rsi    # 0x34fb8c
movq %rbx, %rdi
movl $0x4a, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_compreads_decompress.c
// Function: gt_compreads_decompress_arguments_new
static void* gt_compreads_decompress_arguments_new(void)
{
  GtCsrHcrDecodeArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->file = gt_str_new();
  arguments->smap = gt_str_new();
  arguments->name = gt_str_new();
  arguments->rng.start = GT_UNDEF_UWORD;
  arguments->rng.end = GT_UNDEF_UWORD;
  arguments->bench = 0;

  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2b290b(%rip), %rdx    # 0x35005e
movl $0x1, %edi
movl $0x48, %esi
movl $0x32, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, 0x18(%rbx)
callq 0x1208f8
movq %rax, 0x20(%rbx)
callq 0x1208f8
movq %rax, 0x30(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x38(%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_compreads_decompress.c
// Function: gt_compreads_decompress_arguments_delete
static void gt_compreads_decompress_arguments_delete(void *tool_arguments)
{
  GtCsrHcrDecodeArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->file);
  gt_str_delete(arguments->name);
  gt_str_delete(arguments->smap);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x9d7d4
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x121b03
movq 0x30(%rbx), %rdi
callq 0x121b03
movq 0x20(%rbx), %rdi
callq 0x121b03
leaq 0x2b2898(%rip), %rsi    # 0x35005e
movq %rbx, %rdi
movl $0x44, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_compreads_refcompress.c
// Function: gt_compreads_refcompress_arguments_new
static void* gt_compreads_refcompress_arguments_new(void)
{
  GtCsrRcrEncodeArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->name = gt_str_new();
  arguments->ref = gt_str_new();
  arguments->align = gt_str_new();
  arguments->qrng.start = GT_UNDEF_UWORD;
  arguments->qrng.end = GT_UNDEF_UWORD;

  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2b25fa(%rip), %rdx    # 0x3503c1
movl $0x1, %edi
movl $0x38, %esi
movl $0x35, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, 0x8(%rbx)
callq 0x1208f8
movq %rax, 0x10(%rbx)
callq 0x1208f8
movq %rax, 0x18(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_compreads_refcompress.c
// Function: gt_compreads_refcompress_arguments_delete
static void gt_compreads_refcompress_arguments_delete(void *tool_arguments)
{
  GtCsrRcrEncodeArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->name);
  gt_str_delete(arguments->ref);
  gt_str_delete(arguments->align);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x9de40
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x121b03
movq 0x10(%rbx), %rdi
callq 0x121b03
movq 0x18(%rbx), %rdi
callq 0x121b03
leaq 0x2b258f(%rip), %rsi    # 0x3503c1
movq %rbx, %rdi
movl $0x46, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_compreads_refdecompress.c
// Function: gt_compreads_refdecompress_arguments_new
static void* gt_compreads_refdecompress_arguments_new(void)
{
  GtCsrRcrDecodeArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->file = gt_str_new();
  arguments->ref = gt_str_new();
  arguments->name = gt_str_new();

  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2b24a7(%rip), %rdx    # 0x35074e
movl $0x1, %edi
movl $0x20, %esi
movl $0x2c, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, (%rbx)
callq 0x1208f8
movq %rax, 0x8(%rbx)
callq 0x1208f8
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_compreads_refdecompress.c
// Function: gt_compreads_refdecompress_arguments_delete
static void gt_compreads_refdecompress_arguments_delete(void *tool_arguments)
{
  GtCsrRcrDecodeArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->file);
  gt_str_delete(arguments->name);
  gt_str_delete(arguments->ref);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x9e315
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x121b03
movq 0x10(%rbx), %rdi
callq 0x121b03
movq 0x8(%rbx), %rdi
callq 0x121b03
leaq 0x2b2447(%rip), %rsi    # 0x35074e
movq %rbx, %rdi
movl $0x3b, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_compreads_refdecompress.c
// Function: gt_compreads_refdecompress_option_parser_new
static GtOptionParser* gt_compreads_refdecompress_option_parser_new(
                                void *tool_arguments)
{
  GtCsrRcrDecodeArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] (-file file)",
                         "Decodes a given RCR (Reference Compressed Reads).");

  option = gt_option_new_bool("v", "be verbose",
                              &arguments->verbose, false);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_bool("qnames", "decode read names, default is "
                              "to just number them",
                              &arguments->qnames, false);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_string("ref", "Index file (generated by the gt encseq"
                                " tool) for reference genome.",
                                arguments->ref, NULL);
  gt_option_is_mandatory(option);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_string("rcr", "specify base name of file containing"
                                " RCR.",
                                arguments->file, NULL);
  gt_option_is_mandatory(option);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_string("name", "specify base name for decoded RCR"
                                " (suffix will be \".rcr.decoded\")",
                                arguments->name, NULL);
  gt_option_parser_add_option(op, option);

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x9e41b
movq %rdi, %r14
leaq 0x2b1d7e(%rip), %rdi    # 0x3500ac
leaq 0x2b246d(%rip), %rsi    # 0x3507a2
callq 0x10cc4e
movq %rax, %rbx
leaq 0x18(%r14), %rdx
leaq 0x2fa912(%rip), %rdi    # 0x398c5a
leaq 0x2b1d9b(%rip), %rsi    # 0x3500ea
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x19(%r14), %rdx
leaq 0x2b2468(%rip), %rdi    # 0x3507d4
leaq 0x2b2468(%rip), %rsi    # 0x3507db
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x8(%r14), %rdx
leaq 0x2e1f3a(%rip), %rdi    # 0x3802ca
leaq 0x2b225f(%rip), %rsi    # 0x3505f6
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r15
movq %rax, %rdi
callq 0x10fa96
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
movq (%r14), %rdx
leaq 0x2f9ee9(%rip), %rdi    # 0x3982a7
leaq 0x2b2448(%rip), %rsi    # 0x35080d
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r15
movq %rax, %rdi
callq 0x10fa96
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
movq 0x10(%r14), %rdx
leaq 0x2ed735(%rip), %rdi    # 0x38bb22
leaq 0x2b2443(%rip), %rsi    # 0x350837
xorl %ecx, %ecx
callq 0x10f987
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10d784
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x18b98
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_condenseq.c
// Function: gt_condenseq_toolbox_new
static void* gt_condenseq_toolbox_new(void)
{
  GtToolbox *condenseq_toolbox = gt_toolbox_new();
  gt_toolbox_add_tool(condenseq_toolbox, "compress", gt_condenseq_compress());
  gt_toolbox_add_tool(condenseq_toolbox, "search", gt_condenseq_search());
  gt_toolbox_add_tool(condenseq_toolbox, "extract", gt_condenseq_extract());
  gt_toolbox_add_tool(condenseq_toolbox, "info", gt_condenseq_info());
  return condenseq_toolbox;
}

// Assembly:
pushq %rbx
callq 0x12391a
movq %rax, %rbx
callq 0xa0930
leaq 0x2b0e8b(%rip), %rsi    # 0x34fa9f
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12394f
callq 0xa2edc
leaq 0x2b24ef(%rip), %rsi    # 0x35111a
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12394f
callq 0xa11cc
leaq 0x2b66f1(%rip), %rsi    # 0x355333
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12394f
callq 0xa28f4
leaq 0x2fdfa0(%rip), %rsi    # 0x39cbf9
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12394f
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_condenseq.c
// Function: gt_condenseq_option_parser_new
static GtOptionParser* gt_condenseq_option_parser_new(void *tool_arguments)
{
  GtToolbox *condenseq_toolbox = tool_arguments;
  GtOptionParser *op;
  gt_assert(condenseq_toolbox);

  /* init */
  op = gt_option_parser_new("tool [option ...]",
                            "Call one of the CONDENSER tools to prepare "
                            "or manipulate redundancy compressed genomic data."
                            );
  gt_option_parser_set_comment_func(op, gt_toolbox_show, condenseq_toolbox);
  gt_option_parser_set_min_args(op, 1U);
  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9ecba
movq %rdi, %rbx
leaq 0x2b1fbc(%rip), %rdi    # 0x350c3d
leaq 0x2b1fc7(%rip), %rsi    # 0x350c4f
callq 0x10cc4e
movq %rax, %r14
leaq 0x84e17(%rip), %rsi     # 0x123aae
movq %rax, %rdi
movq %rbx, %rdx
callq 0x10cd8d
movq %r14, %rdi
movl $0x1, %esi
callq 0x10d766
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x18e01