LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_repfind.c
// Function: gt_generic_simplegreedyselfmatchoutput
static int gt_generic_simplegreedyselfmatchoutput(
                                           void *processinfo,
                                           const GtGenericEncseq *genericencseq,
                                           GtUword len,
                                           GtUword pos1,
                                           GtUword pos2,
                                           GtError *err)
{
  gt_assert(genericencseq != NULL && genericencseq->hasencseq);
  return gt_rf_greedy_extend_selfmatch_with_output(processinfo,
                                                   genericencseq->seqptr.encseq,
                                                   len,
                                                   pos1,
                                                   pos2,
                                                   err);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x59c74
movq 0x28(%rsp), %rax
testb $0x1, (%rax)
jne 0x59cac
movq 0x5e2325(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4bc38e(%rip), %rsi    # 0x516013
leaq 0x4ccbb8(%rip), %rdx    # 0x526844
leaq 0x4ccb7b(%rip), %rcx    # 0x52680e
leaq 0x4cc3ee(%rip), %r8     # 0x526088
movl $0x223, %r9d            # imm = 0x223
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x59cae
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
callq 0x2ad5f0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_sain.c
// Function: gt_sain_arguments_new
static void* gt_sain_arguments_new(void)
{
  GtSainArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->suftabout = false;
  arguments->tistabout = false;
  arguments->encseqfile = gt_str_new();
  arguments->plainseqfile = gt_str_new();
  arguments->fastafile = gt_str_new();
  arguments->smap = gt_str_new();
  arguments->dir = gt_str_new_cstr("fwd");
  arguments->readmode = GT_READMODE_FORWARD;
  return arguments;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x40, %esi
leaq 0x4cbe2e(%rip), %rdx    # 0x526910
movl $0x29, %ecx
callq 0xe83c0
movq %rax, (%rsp)
movq (%rsp), %rax
movb $0x0, 0x8(%rax)
movq (%rsp), %rax
movb $0x0, 0x9(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rax)
leaq 0x53919f(%rip), %rdi    # 0x593ce6
callq 0x11d510
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
movl $0x0, 0x38(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_sain.c
// Function: gt_sain_arguments_delete
static void gt_sain_arguments_delete(void *tool_arguments)
{
  GtSainArguments *arguments = tool_arguments;

  if (arguments != NULL)
  {
    gt_str_delete(arguments->encseqfile);
    gt_str_delete(arguments->plainseqfile);
    gt_str_delete(arguments->fastafile);
    gt_str_delete(arguments->smap);
    gt_str_delete(arguments->dir);
    gt_free(arguments);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x5abe7
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4cbd33(%rip), %rsi    # 0x526910
movl $0x40, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_sain.c
// Function: gt_sain_option_parser_check
static int gt_sain_option_parser_check(int rest_argc,
                                       void *tool_arguments, GtError *err)
{
  int retval;
  GtSainArguments *arguments = tool_arguments;

  if (rest_argc > 0)
  {
    gt_error_set(err,"%d superfluous argument%s",
                 rest_argc,rest_argc > 1 ? "s" : "");
    return -1;
  }
  retval = gt_readmode_parse(gt_str_get(arguments->dir), err);
  if (retval < 0)
  {
    return -1;
  } else
  {
    arguments->readmode = (GtReadmode) retval;
    return 0;
  }
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x0, 0x20(%rsp)
jle 0x5b05c
movq 0x10(%rsp), %rdi
movl 0x20(%rsp), %edx
movl 0x20(%rsp), %esi
leaq 0x5425f2(%rip), %rcx    # 0x59d628
leaq 0x4d186f(%rip), %rax    # 0x52c8ac
cmpl $0x1, %esi
cmovgq %rax, %rcx
leaq 0x4cba96(%rip), %rsi    # 0x526ae1
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x5b09e
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x11dee0
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x1099b0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x5b08b
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x5b09e
movl 0xc(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x38(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_sain.c
// Function: gt_sain_timer_logger_new
static GtSainTimerandLogger *gt_sain_timer_logger_new(bool verbose)
{
  GtSainTimerandLogger *tl = gt_malloc(sizeof (*tl));

  tl->timer = NULL;
  tl->logger = gt_logger_new(verbose,GT_LOGGER_DEFLT_PREFIX,stdout);
  if (gt_showtime_enabled())
  {
    if (verbose)
    {
      tl->timer = gt_timer_new_with_progress_description(
                                       "allocate suftab and undef entries");
    } else
    {
      tl->timer = gt_timer_new();
      gt_timer_omit_last_stage(tl->timer);
    }
    gt_timer_start(tl->timer);
  }
  return tl;
}

// Assembly:
subq $0x18, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x17(%rsp)
movl $0x10, %edi
leaq 0x4cace7(%rip), %rsi    # 0x526910
movl $0xcf, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movb 0x17(%rsp), %al
movq 0x5e02e9(%rip), %rcx    # 0x63bf38
movq (%rcx), %rdx
leaq 0x4bbc93(%rip), %rsi    # 0x5178ec
andb $0x1, %al
movzbl %al, %edi
callq 0xe7870
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x11aa90
testb $0x1, %al
jne 0x5bc7a
jmp 0x5bcc4
testb $0x1, 0x17(%rsp)
je 0x5bc9a
leaq 0x4caf3a(%rip), %rdi    # 0x526bc2
callq 0x1213a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0x5bcb7
callq 0x121340
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x121ee0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x1213f0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_sain.c
// Function: gt_sain_timer_logger_delete
static void gt_sain_timer_logger_delete(GtSainTimerandLogger *tl)
{
  if (tl->timer != NULL)
  {
    gt_timer_show_progress_final(tl->timer, stdout);
    gt_timer_stop(tl->timer);
    gt_timer_delete(tl->timer);
  }
  gt_logger_delete(tl->logger);
  gt_free(tl);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x5bd0d
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x5e024b(%rip), %rax    # 0x63bf38
movq (%rax), %rsi
callq 0x121d70
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x121490
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x121f00
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xe7ed0
movq (%rsp), %rdi
leaq 0x4cabeb(%rip), %rsi    # 0x526910
movl $0xec, %edx
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_sam_interface.c
// Function: gt_sam_interface_arguments_delete
static void gt_sam_interface_arguments_delete(void *tool_arguments)
{
  GtSamInterfaceArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_option_delete(arguments->ref_idxfile);
  gt_str_delete(arguments->indexfilename);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x5bfbd
jmp 0x5bfef
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4cac3b(%rip), %rsi    # 0x526c20
movl $0x2d, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_sam_interface.c
// Function: gt_sam_interface_option_parser_new
static GtOptionParser* gt_sam_interface_option_parser_new(void *tool_arguments)
{
  GtSamInterfaceArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);
  /* init */
  op = gt_option_parser_new("[options] filename",
                         "This tool exists solely as an "
                         "test for the interface.");

  /* -sam */
  option = gt_option_new_bool("sam",
                              "filetype is sam, default is bam",
                              &arguments->bool_is_sam, false);
  gt_option_parser_add_option(op, option);

  /* -idxfile */
  option = gt_option_new_filename("idxfile",
                                  "file containing reference info",
                                  arguments->indexfilename);
  gt_option_parser_add_option(op, option);
  arguments->ref_idxfile = gt_option_ref(option);

  /* -lines */
  option = gt_option_new_int("lines", "number of lines to print"
                             " leave undefined for all",
                             &arguments->lines, -1);
  gt_option_parser_add_option(op, option);

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x5c053
movq 0x5dff7e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4b9fe7(%rip), %rsi    # 0x516013
leaq 0x51eb2c(%rip), %rdx    # 0x57ab5f
leaq 0x4cac03(%rip), %rcx    # 0x526c3d
leaq 0x4cabdf(%rip), %r8     # 0x526c20
movl $0x35, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x5c055
leaq 0x4cac04(%rip), %rdi    # 0x526c60
leaq 0x4cac10(%rip), %rsi    # 0x526c73
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdx
leaq 0x4c33ba(%rip), %rdi    # 0x51f433
leaq 0x4cac29(%rip), %rsi    # 0x526ca9
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdx
leaq 0x4cac1e(%rip), %rdi    # 0x526cc9
leaq 0x4cac1f(%rip), %rsi    # 0x526cd1
callq 0xf6aa0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x8(%rsp), %rdi
callq 0xf13c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rdx
addq $0x4, %rdx
leaq 0x53f472(%rip), %rdi    # 0x59b563
leaq 0x4cabf8(%rip), %rsi    # 0x526cf0
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0xf6310
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x10(%rsp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0xf2a40
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_sam_interface.c
// Function: gt_sam_interface_arguments_check
static int gt_sam_interface_arguments_check(GT_UNUSED int rest_argc,
                                       GT_UNUSED void *tool_arguments,
                                       GT_UNUSED GtError *err)
{
  GT_UNUSED GtSamInterfaceArguments *arguments = tool_arguments;
  int had_err = 0;

  gt_error_check(err);
  gt_assert(arguments);
  gt_assert(rest_argc == 1);

  return had_err;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x5c1b4
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x5c17c
jmp 0x5c1b4
movq 0x5dfe1d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4b9e86(%rip), %rsi    # 0x516013
leaq 0x4ba02b(%rip), %rdx    # 0x5161bf
leaq 0x4cab86(%rip), %rcx    # 0x526d21
leaq 0x4caa7e(%rip), %r8     # 0x526c20
movl $0x59, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x5c1b6
jmp 0x5c1b8
cmpq $0x0, 0x8(%rsp)
jne 0x5c1f8
movq 0x5dfdd9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4b9e42(%rip), %rsi    # 0x516013
leaq 0x51e987(%rip), %rdx    # 0x57ab5f
leaq 0x4cab42(%rip), %rcx    # 0x526d21
leaq 0x4caa3a(%rip), %r8     # 0x526c20
movl $0x5a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x5c1fa
jmp 0x5c1fc
cmpl $0x1, 0x24(%rsp)
je 0x5c23b
movq 0x5dfd96(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4b9dff(%rip), %rsi    # 0x516013
leaq 0x4c22c2(%rip), %rdx    # 0x51e4dd
leaq 0x4caaff(%rip), %rcx    # 0x526d21
leaq 0x4ca9f7(%rip), %r8     # 0x526c20
movl $0x5b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x5c23d
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_script_filter.c
// Function: gt_script_filter_option_parser_new
static GtOptionParser* gt_script_filter_option_parser_new(void *tool_arguments)
{
  GtScriptFilterArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] [script file(s)]",
                            "Get info about and validate Lua script filters.");

  /* -showinfo */
  option = gt_option_new_bool("showinfo", "show information about filter",
                              &arguments->showinfo, true);
  gt_option_parser_add_option(op, option);

  /* -validate */
  option = gt_option_new_bool("validate", "validate filter function",
                              &arguments->validate, true);
  gt_option_parser_add_option(op, option);

  /* -oneline */
  option = gt_option_new_bool("oneline", "show compact information on one line",
                             &arguments->oneline, false);
  gt_option_parser_add_option(op, option);

  /* -scriptname */
  option = gt_option_new_bool("scriptname", "show script name",
                             &arguments->scriptname, true);
  gt_option_parser_add_option(op, option);

  gt_option_parser_set_min_args(op, 1);

  return op;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x5c6d3
movq 0x5df8fe(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4b9967(%rip), %rsi    # 0x516013
leaq 0x51e4ac(%rip), %rdx    # 0x57ab5f
leaq 0x4ca6cc(%rip), %rcx    # 0x526d86
leaq 0x4ca6a8(%rip), %r8     # 0x526d69
movl $0x30, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x5c6d5
leaq 0x4ca6cd(%rip), %rdi    # 0x526da9
leaq 0x4ca6e4(%rip), %rsi    # 0x526dc7
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdx
addq $0x1, %rdx
leaq 0x4ca6fa(%rip), %rdi    # 0x526df7
leaq 0x4ca6fc(%rip), %rsi    # 0x526e00
movl $0x1, %ecx
callq 0xf5f20
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdx
addq $0x3, %rdx
leaq 0x567960(%rip), %rdi    # 0x5c4092
leaq 0x4ca6e5(%rip), %rsi    # 0x526e1e
movl $0x1, %ecx
callq 0xf5f20
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdx
leaq 0x4ca6d4(%rip), %rdi    # 0x526e37
leaq 0x4ca6d5(%rip), %rsi    # 0x526e3f
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdx
addq $0x2, %rdx
leaq 0x4ca6cf(%rip), %rdi    # 0x526e64
leaq 0x4ca6d3(%rip), %rsi    # 0x526e6f
movl $0x1, %ecx
callq 0xf5f20
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0xf2980
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seed_extend.c
// Function: gt_seed_extend_arguments_new
static void* gt_seed_extend_arguments_new(void)
{
  GtSeedExtendArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->dbs_indexname = gt_str_new();
  arguments->dbs_queryname = gt_str_new();
  arguments->dbs_pick_str = gt_str_new();
  arguments->chainarguments = gt_str_new();
  arguments->diagband_statistics_arg = gt_str_new();
  arguments->dbs_memlimit_str = gt_str_new();
  arguments->char_access_mode = gt_str_new();
  arguments->splt_string = gt_str_new();
  arguments->kmplt_string = gt_str_new();
  arguments->display_args = gt_str_array_new();
  return arguments;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x138, %esi            # imm = 0x138
leaq 0x4ca2de(%rip), %rdx    # 0x526f30
movl $0x6c, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x58(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x68(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x60(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x70(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xb0(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xb8(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xc0(%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xe8(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seed_extend.c
// Function: gt_seed_extend_arguments_delete
static void gt_seed_extend_arguments_delete(void *tool_arguments)
{
  GtSeedExtendArguments *arguments = tool_arguments;
  if (arguments != NULL) {
    gt_str_delete(arguments->dbs_indexname);
    gt_str_delete(arguments->dbs_queryname);
    gt_str_delete(arguments->dbs_pick_str);
    gt_str_delete(arguments->chainarguments);
    gt_str_delete(arguments->diagband_statistics_arg);
    gt_str_delete(arguments->dbs_memlimit_str);
    gt_str_delete(arguments->char_access_mode);
    gt_str_delete(arguments->splt_string);
    gt_str_delete(arguments->kmplt_string);
    gt_option_delete(arguments->se_ref_op_gre);
    gt_option_delete(arguments->se_ref_op_spacedseed);
    gt_option_delete(arguments->se_ref_op_xdr);
    gt_option_delete(arguments->se_ref_op_evalue);
    gt_option_delete(arguments->se_ref_op_maxmat);
    gt_option_delete(arguments->ref_diagband_statistics);
    gt_str_array_delete(arguments->display_args);
    gt_free(arguments);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x5ce52
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0xb0(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0xb8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0xc0(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x128(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0x110(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0x130(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0x108(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0x118(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0x120(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0xe8(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rdi
leaq 0x4ca0e8(%rip), %rsi    # 0x526f30
movl $0x8e, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seed_extend.c
// Function: gt_seed_extend_ani_evaluate
static double gt_seed_extend_ani_evaluate(GtUword sum_of_aligned_len,
                                          GtUword sum_of_distance)
{
  return sum_of_aligned_len > 0
             ? (100.0 * (1.0 - (double)
                               (2 * sum_of_distance)/sum_of_aligned_len))
             : 0.0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
cmpq $0x0, -0x8(%rsp)
jbe 0x6050e
movq -0x10(%rsp), %rax
addq %rax, %rax
movq %rax, %xmm0
movaps 0x4b847a(%rip), %xmm3   # 0x518930
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x4b847e(%rip), %xmm2   # 0x518940
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq -0x8(%rsp), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd 0x4b6d4a(%rip), %xmm1   # 0x517240
subsd %xmm0, %xmm1
movsd 0x4ba336(%rip), %xmm0   # 0x51a838
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rsp)
jmp 0x60519
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rsp)
jmp 0x60519
movsd -0x18(%rsp), %xmm0
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_select.c
// Function: gt_select_arguments_new
static void* gt_select_arguments_new(void)
{
  SelectArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->seqid = gt_str_new();
  arguments->source = gt_str_new();
  arguments->gt_strand_char = gt_str_new();
  arguments->strand = GT_NUM_OF_STRAND_TYPES;
  arguments->targetgt_strand_char = gt_str_new();
  arguments->targetstrand = GT_NUM_OF_STRAND_TYPES;
  arguments->ofi = gt_output_file_info_new();
  arguments->filter_files = gt_str_array_new();
  arguments->filter_logic = gt_str_new();
  arguments->dropped_file = gt_str_new();
  return arguments;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0xb0, %esi
leaq 0x4c7cf3(%rip), %rdx    # 0x528255
movl $0x44, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movl $0x4, 0x48(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
movl $0x4, 0x4c(%rax)
callq 0xf7d20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x88(%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x98(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xa0(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xa8(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_select.c
// Function: gt_select_arguments_delete
static void gt_select_arguments_delete(void *tool_arguments)
{
  SelectArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_str_delete(arguments->targetgt_strand_char);
  gt_str_delete(arguments->gt_strand_char);
  gt_str_delete(arguments->source);
  gt_str_delete(arguments->seqid);
  gt_str_array_delete(arguments->filter_files);
  gt_str_delete(arguments->filter_logic);
  gt_str_delete(arguments->dropped_file);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x60640
jmp 0x606e3
movq 0x8(%rsp), %rax
movq 0x90(%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rax
movq 0x88(%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x98(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rax
movq 0xa0(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0xa8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4c7b7c(%rip), %rsi    # 0x528255
movl $0x5f, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_select.c
// Function: gt_select_arguments_check
static int gt_select_arguments_check(GT_UNUSED int rest_argc,
                                     void *tool_arguments, GtError *err)
{
  SelectArguments *arguments = tool_arguments;
  int had_err;
  gt_error_check(err);
  gt_assert(arguments);
  had_err = process_gt_strand_arg(arguments->gt_strand_char, &arguments->strand,
                                  GT_STRAND_OPT, err);
  if (!had_err) {
    had_err = process_gt_strand_arg(arguments->targetgt_strand_char,
                                    &arguments->targetstrand,
                                    TARGETGT_STRAND_OPT, err);
  }

  return had_err;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x60c6c
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x60c34
jmp 0x60c6c
movq 0x5db365(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4b53ce(%rip), %rsi    # 0x516013
leaq 0x4b5573(%rip), %rdx    # 0x5161bf
leaq 0x4c7d26(%rip), %rcx    # 0x528979
leaq 0x4c75fb(%rip), %r8     # 0x528255
movl $0x12d, %r9d            # imm = 0x12D
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x60c6e
jmp 0x60c70
cmpq $0x0, 0x8(%rsp)
jne 0x60cb0
movq 0x5db321(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4b538a(%rip), %rsi    # 0x516013
leaq 0x519ecf(%rip), %rdx    # 0x57ab5f
leaq 0x4c7ce2(%rip), %rcx    # 0x528979
leaq 0x4c75b7(%rip), %r8     # 0x528255
movl $0x12e, %r9d            # imm = 0x12E
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x60cb2
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rsi
addq $0x48, %rsi
movq 0x10(%rsp), %rcx
leaq 0x4c6bde(%rip), %rdx    # 0x5278ae
callq 0x61130
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x60d07
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x8(%rsp), %rsi
addq $0x4c, %rsi
movq 0x10(%rsp), %rcx
leaq 0x50410c(%rip), %rdx    # 0x564e0a
callq 0x61130
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_select.c
// Function: process_gt_strand_arg
static int process_gt_strand_arg(GtStr *gt_strand_char, GtStrand *strand,
                                 const char *optstr, GtError *err)
{
  int had_err = 0;
  gt_error_check(err);
  if (gt_str_length(gt_strand_char)) {
    GtStrand tmpstrand = gt_strand_get(gt_str_get(gt_strand_char)[0]);
    if ((gt_str_length(gt_strand_char) > 1) ||
        (tmpstrand == GT_NUM_OF_STRAND_TYPES)) {
      gt_error_set(err, "argument to option -%s must be one of '"
                        GT_STRAND_CHARS"'", optstr);
      had_err = -1;
    }
    if (!had_err)
      *strand = tmpstrand;
  }
  return had_err;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x611a0
movq 0x8(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x61168
jmp 0x611a0
movq 0x5dae31(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4b4e9a(%rip), %rsi    # 0x516013
leaq 0x4b503f(%rip), %rdx    # 0x5161bf
leaq 0x4c780c(%rip), %rcx    # 0x528993
leaq 0x4c70c7(%rip), %r8     # 0x528255
movl $0x119, %r9d            # imm = 0x119
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x611a2
movq 0x20(%rsp), %rdi
callq 0x11dfa0
cmpq $0x0, %rax
je 0x61210
movq 0x20(%rsp), %rdi
callq 0x11dee0
movsbl (%rax), %edi
callq 0x11fdd0
movl %eax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x11dfa0
cmpq $0x1, %rax
ja 0x611dd
cmpl $0x4, (%rsp)
jne 0x611fd
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x4c77bb(%rip), %rsi    # 0x5289a9
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
cmpl $0x0, 0x4(%rsp)
jne 0x6120e
movl (%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
jmp 0x61210
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seq.c
// Function: gt_seq_arguments_new
static void* gt_seq_arguments_new(void)
{
  SeqArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->ofi = gt_output_file_info_new();
  arguments->showseqnum_inputfile = gt_str_new();
  return arguments;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x38, %esi
leaq 0x4c76de(%rip), %rdx    # 0x528a20
movl $0x2c, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0xf7d20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seq.c
// Function: gt_seq_arguments_delete
static void gt_seq_arguments_delete(void *tool_arguments)
{
  SeqArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_str_delete(arguments->showseqnum_inputfile);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x6139d
jmp 0x613dd
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4c764d(%rip), %rsi    # 0x528a20
movl $0x39, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seq.c
// Function: gt_seq_arguments_check
static int gt_seq_arguments_check(int rest_argc, void *tool_arguments,
                                  GtError *err)
{
  SeqArguments *arguments = tool_arguments;
  gt_error_check(err);
  gt_assert(arguments);
  /* option -showseqnum makes only sense if we got a single sequence file */
  if (arguments->showseqnum != GT_UNDEF_UWORD ||
      arguments->showseqlength != GT_UNDEF_UWORD)
  {
    if (rest_argc > 1)
    {
      gt_error_set(err, "option '-showseq%s' only makes sense with a single "
                        "sequence_file",
                        arguments->showseqnum != GT_UNDEF_UWORD ? "num"
                                                                : "length");
      return -1;
    }
    if ((arguments->showseqnum == 0 || arguments->showseqlength == 0) &&
        !arguments->seqnum_from_0)
    {
      gt_error_set(err, "argument to option '-showseq%s' must be >= 1 if "
                        "option -seqnum_from_0 is not used",
                        arguments->showseqnum == 0 ? "num"
                                                   : "length");
      return -1;
    }
  }
  return 0;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x6178c
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x61754
jmp 0x6178c
movq 0x5da845(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4b48ae(%rip), %rsi    # 0x516013
leaq 0x4b4a53(%rip), %rdx    # 0x5161bf
leaq 0x4c75ff(%rip), %rcx    # 0x528d72
leaq 0x4c72a6(%rip), %r8     # 0x528a20
movl $0xa7, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x6178e
jmp 0x61790
cmpq $0x0, 0x8(%rsp)
jne 0x617d0
movq 0x5da801(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4b486a(%rip), %rsi    # 0x516013
leaq 0x5193af(%rip), %rdx    # 0x57ab5f
leaq 0x4c75bb(%rip), %rcx    # 0x528d72
leaq 0x4c7262(%rip), %r8     # 0x528a20
movl $0xa8, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x617d2
movq 0x8(%rsp), %rax
cmpq $-0x1, 0x8(%rax)
jne 0x617ee
movq 0x8(%rsp), %rax
cmpq $-0x1, 0x10(%rax)
je 0x61892
cmpl $0x1, 0x20(%rsp)
jle 0x61831
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
leaq 0x52d141(%rip), %rdx    # 0x58e94b
leaq 0x4f5dc5(%rip), %rax    # 0x5575d6
cmpq $-0x1, %rcx
cmovneq %rax, %rdx
leaq 0x4c7569(%rip), %rsi    # 0x528d89
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x6189a
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x61849
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x61890
movq 0x8(%rsp), %rax
testb $0x1, 0x5(%rax)
jne 0x61890
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
leaq 0x52d0e2(%rip), %rdx    # 0x58e94b
leaq 0x4f5d66(%rip), %rax    # 0x5575d6
cmpq $0x0, %rcx
cmoveq %rax, %rdx
leaq 0x4c754b(%rip), %rsi    # 0x528dca
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x6189a
jmp 0x61892
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seqcorrect.c
// Function: gt_seqcorrect_arguments_new
static void* gt_seqcorrect_arguments_new(void)
{
  GtSeqcorrectArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->radixlarge = false;
  arguments->numofparts = 0;
  arguments->radixparts = 1U;
  arguments->encseqinput = gt_str_new();
  arguments->indexname = gt_str_new();
  arguments->memlimitarg = gt_str_new();
  arguments->maximumspace = 0UL; /* in bytes */
  arguments->db = gt_str_array_new();
  return arguments;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x78, %esi
leaq 0x4c6fe1(%rip), %rdx    # 0x528ef3
movl $0x4f, %ecx
callq 0xe83c0
movq %rax, (%rsp)
movq (%rsp), %rax
movb $0x0, 0x5(%rax)
movq (%rsp), %rax
movl $0x0, 0x18(%rax)
movq (%rsp), %rax
movl $0x1, 0x1c(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x48(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x40(%rax)
movq (%rsp), %rax
movq $0x0, 0x30(%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x58(%rax)
movq (%rsp), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seqcorrect.c
// Function: gt_seqcorrect_arguments_delete
static void gt_seqcorrect_arguments_delete(void *tool_arguments)
{
  GtSeqcorrectArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->encseqinput);
  gt_str_delete(arguments->indexname);
  gt_option_delete(arguments->refoptionmemlimit);
  gt_str_delete(arguments->memlimitarg);
  gt_str_array_delete(arguments->db);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x61fad
jmp 0x62009
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rdi
leaq 0x4c6ef4(%rip), %rsi    # 0x528ef3
movl $0x64, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seqcorrect.c
// Function: gt_seqcorrect_arguments_check
static int gt_seqcorrect_arguments_check(GT_UNUSED int rest_argc,
                                         void *tool_arguments,
                                         GtError *err)
{
  GtSeqcorrectArguments *arguments = tool_arguments;
  bool haserr = false;

  gt_error_check(err);
  if (!haserr && gt_option_is_set(arguments->refoptionmemlimit))
  {
    if (gt_option_parse_spacespec(&arguments->maximumspace,
                                  "memlimit",
                                  arguments->memlimitarg,
                                  err) != 0)
    {
      haserr = true;
    }
  }
  if (!haserr) {
    if (arguments->find_seldom && arguments->iterations != 1U)
    {
      gt_error_set(err, "The '-find-seldom' option implies '-iter 1'");
      haserr = true;
    }
  }
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x7(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x626f1
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x626b9
jmp 0x626f1
movq 0x5d98e0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4b3949(%rip), %rsi    # 0x516013
leaq 0x4b3aee(%rip), %rdx    # 0x5161bf
leaq 0x4c6abb(%rip), %rcx    # 0x529193
leaq 0x4c6814(%rip), %r8     # 0x528ef3
movl $0x139, %r9d            # imm = 0x139
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x626f3
testb $0x1, 0x7(%rsp)
jne 0x6273d
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0xf74a0
testb $0x1, %al
jne 0x6270e
jmp 0x6273d
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rdx
movq 0x10(%rsp), %rcx
leaq 0x557d5c(%rip), %rsi    # 0x5ba488
callq 0xf7500
cmpl $0x0, %eax
je 0x6273b
movb $0x1, 0x7(%rsp)
jmp 0x6273d
testb $0x1, 0x7(%rsp)
jne 0x62774
movq 0x8(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0x62772
movq 0x8(%rsp), %rax
cmpl $0x1, 0x28(%rax)
je 0x62772
movq 0x10(%rsp), %rdi
leaq 0x4c6a4b(%rip), %rsi    # 0x5291b1
movb $0x0, %al
callq 0xd88c0
movb $0x1, 0x7(%rsp)
jmp 0x62774
movb 0x7(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seqfilter.c
// Function: gt_seqfilter_arguments_delete
static void gt_seqfilter_arguments_delete(void *tool_arguments)
{
  SeqFilterArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x6439d
jmp 0x643ce
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rdi
leaq 0x4c52d4(%rip), %rsi    # 0x529698
movl $0x3b, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seqids.c
// Function: gt_seqids_runner
static int gt_seqids_runner(GT_UNUSED int argc, const char **argv,
                                  int parsed_args,
                                  GT_UNUSED void *tool_arguments, GtError *err)
{
  GtNodeStream *in_stream, *v_stream;
  GtCstrTable *cst;
  int had_err = 0;
  gt_error_check(err);

  cst = gt_cstr_table_new();
  in_stream = gt_gff3_in_stream_new_unsorted(argc - parsed_args,
                                             argv + parsed_args);
  v_stream = gt_visitor_stream_new(in_stream, gt_collect_ids_visitor_new(cst));

  had_err = gt_node_stream_pull(v_stream, err);
  if (!had_err) {
    GtStrArray *seqids;
    GtUword i;
    seqids = gt_cstr_table_get_all(cst);
    for (i = 0; i < gt_str_array_size(seqids); i++) {
      printf("%s\n", gt_str_array_get(seqids, i));
    }
    gt_str_array_delete(seqids);
  }

  gt_node_stream_delete(v_stream);
  gt_node_stream_delete(in_stream);
  gt_cstr_table_delete(cst);
  return had_err;
}

// Assembly:
subq $0x68, %rsp
movl %edi, 0x64(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movl $0x0, 0x24(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x64b63
movq 0x40(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x64b2b
jmp 0x64b63
movq 0x5d746e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4b14d7(%rip), %rsi    # 0x516013
leaq 0x4b167c(%rip), %rdx    # 0x5161bf
leaq 0x4c4dd1(%rip), %rcx    # 0x52991b
leaq 0x4c4ddb(%rip), %r8     # 0x52992c
movl $0x2a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x64b65
callq 0xa39d0
movq %rax, 0x28(%rsp)
movl 0x64(%rsp), %edi
subl 0x54(%rsp), %edi
movq 0x58(%rsp), %rsi
movslq 0x54(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1746b0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x13a1e0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x1f6b70
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x1b1f90
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x64c43
movq 0x28(%rsp), %rdi
callq 0xa3c20
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x11fcc0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x64c39
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11f8c0
movq %rax, %rsi
leaq 0x4c22ca(%rip), %rdi    # 0x526eec
movb $0x0, %al
callq 0x19070
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x64bea
movq 0x18(%rsp), %rdi
callq 0x11fd20
movq 0x30(%rsp), %rdi
callq 0x1b1cb0
movq 0x38(%rsp), %rdi
callq 0x1b1cb0
movq 0x28(%rsp), %rdi
callq 0xa40d0
movl 0x24(%rsp), %eax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seqlensort.c
// Function: gt_seqlensort_arguments_new
static void* gt_seqlensort_arguments_new(void)
{
  GtSeqlensortArguments *arguments = gt_malloc(sizeof (*arguments));
  arguments->indexname = gt_str_new();
  arguments->db = gt_str_array_new();
  return arguments;
}

// Assembly:
pushq %rax
movl $0x10, %edi
leaq 0x4c4c95(%rip), %rsi    # 0x529942
movl $0x1f, %edx
callq 0xe80f0
movq %rax, (%rsp)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seqlensort.c
// Function: gt_seqlensort_arguments_delete
static void gt_seqlensort_arguments_delete(void *tool_arguments)
{
  GtSeqlensortArguments *arguments = tool_arguments;
  gt_str_delete(arguments->indexname);
  gt_str_array_delete(arguments->db);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rdi
leaq 0x4c4c28(%rip), %rsi    # 0x529942
movl $0x2a, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seqlensort.c
// Function: gt_seqlensort_option_parser_new
static GtOptionParser* gt_seqlensort_option_parser_new(void *tool_arguments)
{
  GtSeqlensortArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *indexname_option, *db_option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("-db <fas ...> [-indexname ...]", "Encode DNA "
                            "MultiFasta sequences (with no wildcards) in "
                            "GtEncseq format, sorting the sequences by "
                            "length.");

  /* -indexname */
  indexname_option = gt_option_new_string("indexname",
                                          "specify the indexname to use\n"
                                          "default: first argument of -db "
                                          "option",
                                          arguments->indexname, NULL);
  gt_option_hide_default(indexname_option);
  gt_option_parser_add_option(op, indexname_option);

  /* -db */
  db_option = gt_option_new_filename_array("db", "name of input MultiFasta "
                                           "file(s)", arguments->db);
  gt_option_hide_default(db_option);
  gt_option_is_mandatory(db_option);
  gt_option_parser_add_option(op, db_option);

  return op;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x64d83
movq 0x5d724e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4b12b7(%rip), %rsi    # 0x516013
leaq 0x515dfc(%rip), %rdx    # 0x57ab5f
leaq 0x4c4bf2(%rip), %rcx    # 0x52995c
leaq 0x4c4bd1(%rip), %r8     # 0x529942
movl $0x32, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x64d85
leaq 0x4c4bf0(%rip), %rdi    # 0x52997c
leaq 0x4c4c08(%rip), %rsi    # 0x52999b
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdx
leaq 0x4d2033(%rip), %rdi    # 0x536ddf
leaq 0x4c4c51(%rip), %rsi    # 0x529a04
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xf7400
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdx
leaq 0x4e2957(%rip), %rdi    # 0x547741
leaq 0x4c4c56(%rip), %rsi    # 0x529a47
callq 0xf6b00
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0xf7400
movq (%rsp), %rdi
callq 0xf6ca0
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0xf1600
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seqlensort.c
// Function: gt_seqlensort_cmp
static int gt_seqlensort_cmp(const void *a, const void *b, void *data)
{
  const GtUword seqnum_a = *(const GtUword*)a,
        seqnum_b = *(const GtUword*)b;
  GtUword seqlen_a = GT_SEQLENSORT_SEQLEN(seqnum_a, (GtUword*)data),
          seqlen_b = GT_SEQLENSORT_SEQLEN(seqnum_b, (GtUword*)data);
  if (seqlen_a == seqlen_b)
    return (int)((seqnum_a > seqnum_b) - (seqnum_a < seqnum_b));
  return (int)((seqlen_a > seqlen_b) - (seqlen_a < seqlen_b));
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rsp)
cmpq $0x0, -0x28(%rsp)
jne 0x650a6
movq -0x20(%rsp), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rsp)
jmp 0x650d2
movq -0x20(%rsp), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rsp), %rcx
movq -0x28(%rsp), %rdx
subq $0x1, %rdx
movq (%rcx,%rdx,8), %rcx
addq $0x1, %rcx
subq %rcx, %rax
movq %rax, -0x48(%rsp)
movq -0x48(%rsp), %rax
movq %rax, -0x38(%rsp)
cmpq $0x0, -0x30(%rsp)
jne 0x650f9
movq -0x20(%rsp), %rax
movq -0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x50(%rsp)
jmp 0x65125
movq -0x20(%rsp), %rax
movq -0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rsp), %rcx
movq -0x30(%rsp), %rdx
subq $0x1, %rdx
movq (%rcx,%rdx,8), %rcx
addq $0x1, %rcx
subq %rcx, %rax
movq %rax, -0x50(%rsp)
movq -0x50(%rsp), %rax
movq %rax, -0x40(%rsp)
movq -0x38(%rsp), %rax
cmpq -0x40(%rsp), %rax
jne 0x65168
movq -0x28(%rsp), %rax
cmpq -0x30(%rsp), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x28(%rsp), %rcx
cmpq -0x30(%rsp), %rcx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rsp)
jmp 0x65193
movq -0x38(%rsp), %rax
cmpq -0x40(%rsp), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x38(%rsp), %rcx
cmpq -0x40(%rsp), %rcx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_seqmutate.c
// Function: gt_seqmutate_arguments_delete
static void gt_seqmutate_arguments_delete(void *tool_arguments)
{
  MutateArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x6522d
jmp 0x6525f
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rdi
leaq 0x4c4828(%rip), %rsi    # 0x529a7d
movl $0x2f, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)