LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_assembly.c
// Function: gt_readjoiner_assembly_build_contained_reads_list
static int gt_readjoiner_assembly_build_contained_reads_list(
    GtReadjoinerAssemblyArguments *arguments, GtBitsequence **contained,
    GtError *err)
{
  int had_err = 0;
  unsigned int i;
  GtUword nofreads, nofreads_i;
  GtStr *filename;

  filename = gt_str_clone(arguments->readset);
  gt_str_append_cstr(filename, ".0" GT_READJOINER_SUFFIX_CNTLIST);
  had_err = gt_cntlist_parse(gt_str_get(filename), true, contained,
    &nofreads, err);
  for (i = 1U; i < arguments->nspmfiles && had_err == 0; i++)
  {
    gt_str_reset(filename);
    gt_str_append_str(filename, arguments->readset);
    gt_str_append_char(filename, '.');
    gt_str_append_uint(filename, i);
    gt_str_append_cstr(filename, GT_READJOINER_SUFFIX_CNTLIST);
    had_err = gt_cntlist_parse(gt_str_get(filename), false, contained,
        &nofreads_i, err);
    gt_assert(had_err || nofreads == nofreads_i);
  }
  gt_str_delete(filename);
  return had_err;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11e280
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x4d51aa(%rip), %rsi    # 0x523864
callq 0x11d550
movq 0x10(%rsp), %rdi
callq 0x11dee0
movq %rax, %rdi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %r8
movl $0x1, %esi
leaq 0x20(%rsp), %rcx
callq 0x275430
movl %eax, 0x2c(%rsp)
movl $0x1, 0x28(%rsp)
movl 0x28(%rsp), %ecx
movq 0x40(%rsp), %rdx
xorl %eax, %eax
cmpl 0x48(%rdx), %ecx
movb %al, 0xf(%rsp)
jae 0x4e711
cmpl $0x0, 0x2c(%rsp)
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x4e71e
jmp 0x4e7ef
movq 0x10(%rsp), %rdi
callq 0x11e110
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x11d750
movq 0x10(%rsp), %rdi
movl $0x2e, %esi
callq 0x11da70
movq 0x10(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0x11de00
movq 0x10(%rsp), %rdi
leaq 0x4d5102(%rip), %rsi    # 0x523866
callq 0x11d550
movq 0x10(%rsp), %rdi
callq 0x11dee0
movq %rax, %rdi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %r8
xorl %esi, %esi
leaq 0x18(%rsp), %rcx
callq 0x275430
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
jne 0x4e7db
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x4e7db
movq 0x5ed7f6(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4c785f(%rip), %rsi    # 0x516013
leaq 0x4d5767(%rip), %rdx    # 0x523f22
leaq 0x4d5782(%rip), %rcx    # 0x523f44
leaq 0x4d5190(%rip), %r8     # 0x523959
movl $0x1d9, %r9d            # imm = 0x1D9
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4e7dd
jmp 0x4e7df
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x4e6f1
movq 0x10(%rsp), %rdi
callq 0x11f560
movl 0x2c(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_assembly.c
// Function: gt_readjoiner_assembly_load_graph
static void gt_readjoiner_assembly_load_graph(GtStrgraph **strgraph,
    GtEncseq *reads, const char *readset, GtUword rlen,
    GtLogger *default_logger, GtTimer *timer)
{
  *strgraph = gt_strgraph_new_from_file(reads, rlen, readset,
      GT_READJOINER_SUFFIX_SG);

  if (gt_showtime_enabled())
    gt_timer_show_progress(timer, GT_READJOINER_ASSEMBLY_MSG_LOADSG, stdout);
  gt_logger_log(default_logger, GT_READJOINER_ASSEMBLY_MSG_LOADSG);

  gt_readjoiner_assembly_show_current_space("(graph loaded)");
}

// 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)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x4d5480(%rip), %rcx    # 0x523ed8
callq 0x290870
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
callq 0x11aa90
testb $0x1, %al
jne 0x4ea73
jmp 0x4ea8e
movq 0x8(%rsp), %rdi
movq 0x5ed4b9(%rip), %rax    # 0x63bf38
movq (%rax), %rdx
leaq 0x4d5594(%rip), %rsi    # 0x52401d
callq 0x121930
movq 0x10(%rsp), %rdi
leaq 0x4d5583(%rip), %rsi    # 0x52401d
movb $0x0, %al
callq 0xe7cd0
leaq 0x4d5591(%rip), %rdi    # 0x524039
callq 0x4ec70
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_assembly.c
// Function: gt_readjoiner_assembly_show_current_space
static inline void gt_readjoiner_assembly_show_current_space(const char *label)
{
  GtUword m, f;
  if (gt_ma_bookkeeping_enabled())
  {
    m = gt_ma_get_space_current();
    f = gt_fa_get_space_current();
    gt_log_log("used space %s: %.2f MB (ma: %.2f MB; fa: %.2f MB)",
        label == NULL ? "" : label, GT_MEGABYTES(m + f), GT_MEGABYTES(m),
        GT_MEGABYTES(f));
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
callq 0xe8ea0
testb $0x1, %al
jne 0x4ec87
jmp 0x4ed51
callq 0xe8b80
movq %rax, 0x18(%rsp)
callq 0xdbac0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x4ecb1
leaq 0x54e97e(%rip), %rax    # 0x59d628
movq %rax, 0x8(%rsp)
jmp 0x4ecbb
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, %rdx
addq %rax, %rdx
movq %rdx, %xmm0
movaps 0x4c9c54(%rip), %xmm4   # 0x518930
punpckldq %xmm4, %xmm0    # xmm0 = xmm0[0],xmm4[0],xmm0[1],xmm4[1]
movapd 0x4c9c58(%rip), %xmm3   # 0x518940
subpd %xmm3, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x4c9c29(%rip), %xmm2   # 0x518928
mulsd %xmm2, %xmm0
movq %rcx, %xmm1
punpckldq %xmm4, %xmm1    # xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1]
subpd %xmm3, %xmm1
movaps %xmm1, %xmm5
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm5, %xmm1
mulsd %xmm2, %xmm1
movq %rax, %xmm2
punpckldq %xmm4, %xmm2    # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1]
subpd %xmm3, %xmm2
movaps %xmm2, %xmm3
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
addsd %xmm3, %xmm2
movsd 0x4c9be1(%rip), %xmm3   # 0x518920
divsd %xmm3, %xmm2
leaq 0x4d53d1(%rip), %rdi    # 0x52411b
movb $0x3, %al
callq 0xe7740
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_assembly.c
// Function: gt_readjoiner_assembly_count_spm
static int gt_readjoiner_assembly_count_spm(const char *readset, bool eqlen,
    unsigned int minmatchlength, unsigned int nspmfiles, GtStrgraph *strgraph,
    GtBitsequence *contained, GtLogger *default_logger, GtError *err)
{
  GtSpmprocSkipData skipdata;
  int had_err = 0;
  unsigned int i;
  GtStr *filename = gt_str_new();
  gt_logger_log(default_logger, GT_READJOINER_ASSEMBLY_MSG_COUNTSPM);
  if (!eqlen)
  {
    skipdata.out.e.proc = gt_spmproc_strgraph_count;
    skipdata.to_skip = contained;
    skipdata.out.e.data = strgraph;
    skipdata.skipped_counter = 0;
  }
  for (i = 0; i < nspmfiles; i++)
  {
    gt_str_append_cstr(filename, readset);
    gt_str_append_char(filename, '.');
    gt_str_append_uint(filename, i);
    gt_str_append_cstr(filename, GT_READJOINER_SUFFIX_SPMLIST);
    had_err = gt_spmlist_parse(gt_str_get(filename),
        (GtUword)minmatchlength,
        eqlen ? gt_spmproc_strgraph_count : gt_spmproc_skip,
        eqlen ? (void*)strgraph : (void*)&skipdata, err);
    gt_str_reset(filename);
  }
  gt_str_delete(filename);
  return had_err;
}

// Assembly:
subq $0x78, %rsp
movb %sil, %al
movq 0x88(%rsp), %rsi
movq 0x80(%rsp), %rsi
movq %rdi, 0x70(%rsp)
andb $0x1, %al
movb %al, 0x6f(%rsp)
movl %edx, 0x68(%rsp)
movl %ecx, 0x64(%rsp)
movq %r8, 0x58(%rsp)
movq %r9, 0x50(%rsp)
movl $0x0, 0x2c(%rsp)
callq 0x11d4a0
movq %rax, 0x20(%rsp)
movq 0x80(%rsp), %rdi
leaq 0x4d4dbf(%rip), %rsi    # 0x523e04
movb $0x0, %al
callq 0xe7cd0
testb $0x1, 0x6f(%rsp)
jne 0x4f07c
leaq 0x2423b6(%rip), %rax    # 0x291410
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x64(%rsp), %eax
jae 0x4f160
movq 0x20(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x11d550
movq 0x20(%rsp), %rdi
movl $0x2e, %esi
callq 0x11da70
movq 0x20(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0x11de00
movq 0x20(%rsp), %rdi
leaq 0x4d5f06(%rip), %rsi    # 0x524fd0
callq 0x11d550
movq 0x20(%rsp), %rdi
callq 0x11dee0
movq %rax, 0x8(%rsp)
movl 0x68(%rsp), %eax
movq %rax, 0x10(%rsp)
movb 0x6f(%rsp), %dl
leaq 0x23fbae(%rip), %rax    # 0x28eca0
leaq 0x242317(%rip), %rcx    # 0x291410
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x6f(%rsp)
je 0x4f117
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
jmp 0x4f122
leaq 0x30(%rsp), %rax
movq %rax, (%rsp)
jmp 0x4f122
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq (%rsp), %rcx
movq 0x88(%rsp), %r8
callq 0x28bd10
movl %eax, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11e110
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x4f084
movq 0x20(%rsp), %rdi
callq 0x11f560
movl 0x2c(%rsp), %eax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_assembly.c
// Function: gt_readjoiner_assembly_pump_encseq_through_cache
static void gt_readjoiner_assembly_pump_encseq_through_cache(
    const GtEncseq *encseq)
{
  const GtTwobitencoding *twobitencoding = gt_encseq_twobitencoding_export(
      encseq);
  uint64_t sum = 0; /* compute the sum, so that the compiler does no remove the
                       code accessing twobitencoding during optimization */
  GtUword idx, totallength = gt_encseq_total_length(encseq),
                numofunits = ! gt_encseq_is_mirrored(encseq)
                  ? gt_unitsoftwobitencoding(totallength)
                  : gt_unitsoftwobitencoding((totallength - 1)/2);
  for (idx = 0; idx < numofunits; idx++)
    sum += twobitencoding[idx];
  gt_assert(sum > 0);
#ifndef S_SPLINT_S
  gt_log_log("encseq codes-sum: %"PRIu64, sum);
#endif
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0xb5250
movq %rax, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0xa9d00
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0xc2ec0
testb $0x1, %al
jne 0x4f1ce
movq 0x10(%rsp), %rdi
callq 0x4f290
movq %rax, (%rsp)
jmp 0x4f1e3
movq 0x10(%rsp), %rdi
subq $0x1, %rdi
shrq %rdi
callq 0x4f290
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x4f229
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x4f1f5
jmp 0x4f22b
cmpq $0x0, 0x20(%rsp)
ja 0x4f26b
movq 0x5ecd66(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4c6dcf(%rip), %rsi    # 0x516013
leaq 0x4d4f61(%rip), %rdx    # 0x5241ac
leaq 0x4d4f62(%rip), %rcx    # 0x5241b4
leaq 0x4d4700(%rip), %r8     # 0x523959
movl $0x155, %r9d            # imm = 0x155
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4f26d
movq 0x20(%rsp), %rsi
leaq 0x4d4f6c(%rip), %rdi    # 0x5241e5
movb $0x0, %al
callq 0xe7740
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_cgraph.c
// Function: gt_readjoiner_cgraph_arguments_new
static void* gt_readjoiner_cgraph_arguments_new(void)
{
  GtReadjoinerCgraphArguments *arguments = gt_calloc((size_t)1,
      sizeof *arguments);
  arguments->readset = gt_str_new();
  arguments->subgraph = gt_str_array_new();
  return arguments;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x20, %esi
leaq 0x4d4efc(%rip), %rdx    # 0x52424e
movl $0x29, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_cgraph.c
// Function: gt_readjoiner_cgraph_arguments_delete
static void gt_readjoiner_cgraph_arguments_delete(void *tool_arguments)
{
  GtReadjoinerCgraphArguments *arguments = tool_arguments;
  if (!arguments)
    return;
  gt_str_delete(arguments->readset);
  gt_str_array_delete(arguments->subgraph);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x4f3ad
jmp 0x4f3df
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rdi
leaq 0x4d4e79(%rip), %rsi    # 0x52424e
movl $0x36, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_cnttest.c
// Function: gt_readjoiner_cnttest_arguments_new
static void* gt_readjoiner_cnttest_arguments_new(void)
{
  GtReadjoinerCnttestArguments *arguments = gt_calloc((size_t)1,
      sizeof *arguments);
  arguments->readset = gt_str_new();
  arguments->teststr = gt_str_new();
  return arguments;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x18, %esi
leaq 0x4d455b(%rip), %rdx    # 0x52448d
movl $0x30, %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)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_cnttest.c
// Function: gt_readjoiner_cnttest_arguments_delete
static void gt_readjoiner_cnttest_arguments_delete(void *tool_arguments)
{
  GtReadjoinerCnttestArguments *arguments = tool_arguments;
  if (arguments == NULL)
    return;
  gt_str_delete(arguments->readset);
  gt_str_delete(arguments->teststr);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x4ff8d
jmp 0x4ffbe
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4d44d9(%rip), %rsi    # 0x52448d
movl $0x3d, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_cnttest.c
// Function: gt_readjoiner_cnttest_arguments_check
static int gt_readjoiner_cnttest_arguments_check(GT_UNUSED int rest_argc,
    void *tool_arguments, GT_UNUSED GtError *err)
{
  GtReadjoinerCnttestArguments *arguments = tool_arguments;
  const char *teststr = gt_str_get(arguments->teststr);
  int had_err = 0;

  gt_error_check(err);
  gt_assert(arguments);

  if (strcmp(teststr, "showlist") == 0)
    arguments->test = GT_READJOINER_CNTTEST_SHOWLIST;
  else if (strcmp(teststr, "bruteforce") == 0)
    arguments->test = GT_READJOINER_CNTTEST_BRUTEFORCE;
  else if (strcmp(teststr, "kmp") == 0)
    arguments->test = GT_READJOINER_CNTTEST_KMP;
  else if (strcmp(teststr, "esa") == 0)
    arguments->test = GT_READJOINER_CNTTEST_ESA;
  else
  {
    gt_error_set(err, "illegal argument \"%s\" to option -test", teststr);
    had_err = -1;
  }
  return had_err;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11dee0
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x501c7
movq 0x20(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x5018f
jmp 0x501c7
movq 0x5ebe0a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4c5e73(%rip), %rsi    # 0x516013
leaq 0x4c6018(%rip), %rdx    # 0x5161bf
leaq 0x4d449d(%rip), %rcx    # 0x52464b
leaq 0x4d42d8(%rip), %r8     # 0x52448d
movl $0x73, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x501c9
jmp 0x501cb
cmpq $0x0, 0x18(%rsp)
jne 0x5020b
movq 0x5ebdc6(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4c5e2f(%rip), %rsi    # 0x516013
leaq 0x52a974(%rip), %rdx    # 0x57ab5f
leaq 0x4d4459(%rip), %rcx    # 0x52464b
leaq 0x4d4294(%rip), %r8     # 0x52448d
movl $0x74, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x5020d
movq 0x10(%rsp), %rdi
leaq 0x4d4458(%rip), %rsi    # 0x524671
callq 0x19980
cmpl $0x0, %eax
jne 0x50234
movq 0x18(%rsp), %rax
movl $0x0, 0x10(%rax)
jmp 0x502c6
movq 0x10(%rsp), %rdi
leaq 0x4e8d5d(%rip), %rsi    # 0x538f9d
callq 0x19980
cmpl $0x0, %eax
jne 0x50258
movq 0x18(%rsp), %rax
movl $0x1, 0x10(%rax)
jmp 0x502c4
movq 0x10(%rsp), %rdi
leaq 0x56aa81(%rip), %rsi    # 0x5bace5
callq 0x19980
cmpl $0x0, %eax
jne 0x5027c
movq 0x18(%rsp), %rax
movl $0x2, 0x10(%rax)
jmp 0x502c2
movq 0x10(%rsp), %rdi
leaq 0x4daac0(%rip), %rsi    # 0x52ad48
callq 0x19980
cmpl $0x0, %eax
jne 0x502a0
movq 0x18(%rsp), %rax
movl $0x3, 0x10(%rax)
jmp 0x502c0
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x4d43c9(%rip), %rsi    # 0x52467a
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
jmp 0x502c2
jmp 0x502c4
jmp 0x502c6
movl 0xc(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_correct.c
// Function: gt_readjoiner_correct_arguments_delete
static void gt_readjoiner_correct_arguments_delete(void *tool_arguments)
{
  GtReadjoinerCorrectArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->indexname);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x5092d
jmp 0x50951
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4d3d76(%rip), %rsi    # 0x5246bd
movl $0x31, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_gfa.c
// Function: gt_readjoiner_gfa_arguments_delete
static void gt_readjoiner_gfa_arguments_delete(void *tool_arguments)
{
  GtReadjoinerGfaArguments *arguments = tool_arguments;
  if (!arguments)
    return;
  gt_str_delete(arguments->readset);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x50ddd
jmp 0x50e01
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4d39cc(%rip), %rsi    # 0x5247c3
movl $0x3a, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_gfa.c
// Function: gt_readjoiner_gfa_show_current_space
static inline void gt_readjoiner_gfa_show_current_space(const char *label)
{
  GtUword m, f;
  if (gt_ma_bookkeeping_enabled())
  {
    m = gt_ma_get_space_current();
    f = gt_fa_get_space_current();
    gt_log_log("used space after %s: %.2f MB (ma: %.2f MB; fa: %.2f MB)",
        label == NULL ? "" : label, GT_MEGABYTES(m + f), GT_MEGABYTES(m),
        GT_MEGABYTES(f));
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
callq 0xe8ea0
testb $0x1, %al
jne 0x51bf7
jmp 0x51cc1
callq 0xe8b80
movq %rax, 0x18(%rsp)
callq 0xdbac0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x51c21
leaq 0x54ba0e(%rip), %rax    # 0x59d628
movq %rax, 0x8(%rsp)
jmp 0x51c2b
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, %rdx
addq %rax, %rdx
movq %rdx, %xmm0
movaps 0x4c6ce4(%rip), %xmm4   # 0x518930
punpckldq %xmm4, %xmm0    # xmm0 = xmm0[0],xmm4[0],xmm0[1],xmm4[1]
movapd 0x4c6ce8(%rip), %xmm3   # 0x518940
subpd %xmm3, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x4c6cb9(%rip), %xmm2   # 0x518928
mulsd %xmm2, %xmm0
movq %rcx, %xmm1
punpckldq %xmm4, %xmm1    # xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1]
subpd %xmm3, %xmm1
movaps %xmm1, %xmm5
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm5, %xmm1
mulsd %xmm2, %xmm1
movq %rax, %xmm2
punpckldq %xmm4, %xmm2    # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1]
subpd %xmm3, %xmm2
movaps %xmm2, %xmm3
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
addsd %xmm3, %xmm2
movsd 0x4c6c71(%rip), %xmm3   # 0x518920
divsd %xmm3, %xmm2
leaq 0x4d1c67(%rip), %rdi    # 0x523921
movb $0x3, %al
callq 0xe7740
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_graph.c
// Function: gt_readjoiner_graph_arguments_new
static void* gt_readjoiner_graph_arguments_new(void)
{
  GtReadjoinerGraphArguments *arguments = gt_calloc((size_t)1,
      sizeof *arguments);
  arguments->readset = gt_str_new();
  arguments->subgraph = gt_str_array_new();
  arguments->subgraph_other = gt_str_array_new();
  return arguments;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x60, %esi
leaq 0x4d2abf(%rip), %rdx    # 0x524951
movl $0x2e, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_graph.c
// Function: gt_readjoiner_graph_arguments_delete
static void gt_readjoiner_graph_arguments_delete(void *tool_arguments)
{
  GtReadjoinerGraphArguments *arguments = tool_arguments;
  if (!arguments)
    return;
  gt_str_delete(arguments->readset);
  gt_str_array_delete(arguments->subgraph);
  gt_str_array_delete(arguments->subgraph_other);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x51efd
jmp 0x51f3c
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rdi
leaq 0x4d2a1f(%rip), %rsi    # 0x524951
movl $0x3d, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_graph.c
// Function: gt_readjoiner_graph_load_graph
static void gt_readjoiner_graph_load_graph(GtStrgraph **strgraph,
    GtEncseq *reads, const char *readset, GtUword rlen,
    GtLogger *default_logger, GtTimer *timer)
{
  *strgraph = gt_strgraph_new_from_file(reads, rlen, readset,
      GT_READJOINER_SUFFIX_SG);

  if (gt_showtime_enabled())
    gt_timer_show_progress(timer, GT_READJOINER_GRAPH_MSG_LOADSG, stdout);
  gt_logger_log(default_logger, GT_READJOINER_GRAPH_MSG_LOADSG);

  gt_readjoiner_graph_show_current_space("(graph loaded)");
}

// 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)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x4d0af0(%rip), %rcx    # 0x523ed8
callq 0x290870
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
callq 0x11aa90
testb $0x1, %al
jne 0x53403
jmp 0x5341e
movq 0x8(%rsp), %rdi
movq 0x5e8b29(%rip), %rax    # 0x63bf38
movq (%rax), %rdx
leaq 0x4d0c04(%rip), %rsi    # 0x52401d
callq 0x121930
movq 0x10(%rsp), %rdi
leaq 0x4d0bf3(%rip), %rsi    # 0x52401d
movb $0x0, %al
callq 0xe7cd0
leaq 0x4d0c01(%rip), %rdi    # 0x524039
callq 0x53ab0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_overlap.c
// Function: gt_readjoiner_overlap_arguments_new
static void* gt_readjoiner_overlap_arguments_new(void)
{
  GtReadjoinerOverlapArguments *arguments = gt_calloc((size_t) 1,
      sizeof *arguments);
  arguments->encseqinput = gt_str_new();
  arguments->numofparts = 0;
  arguments->memlimitarg = gt_str_new();
  arguments->phase2extraarg = gt_str_new();
  arguments->phase2extra = 0UL; /* in bytes */
  arguments->maximumspace = 0UL; /* in bytes */
  return arguments;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x60, %esi
leaq 0x4d14be(%rip), %rdx    # 0x5250a0
movl $0x3b, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
movl $0x0, 0xc(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rax)
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_overlap.c
// Function: gt_readjoiner_overlap_arguments_delete
static void gt_readjoiner_overlap_arguments_delete(void *tool_arguments)
{
  GtReadjoinerOverlapArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->encseqinput);
  gt_option_delete(arguments->refoptionmemlimit);
  gt_option_delete(arguments->refoptionphase2extra);
  gt_str_delete(arguments->memlimitarg);
  gt_str_delete(arguments->phase2extraarg);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x53c6d
jmp 0x53cc9
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4d13e1(%rip), %rsi    # 0x5250a0
movl $0x4e, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_overlap.c
// Function: gt_readjoiner_overlap_arguments_check
static int gt_readjoiner_overlap_arguments_check(int rest_argc,
                                         void *tool_arguments,
                                         GtError *err)
{
  GtReadjoinerOverlapArguments *arguments = tool_arguments;
  bool haserr = false;

  gt_error_check(err);
  if (rest_argc != 0)
  {
    gt_error_set(err,"unnecessary arguments");
    haserr = true;
  }
  if (!haserr && gt_option_is_set(arguments->refoptionmemlimit))
  {
    if (gt_option_parse_spacespec(&arguments->maximumspace,
          "memlimit",
          arguments->memlimitarg,
          err) != 0)
    {
      haserr = true;
    }
  }
  if (!haserr && gt_option_is_set(arguments->refoptionphase2extra))
  {
    if (gt_option_parse_spacespec(&arguments->phase2extra,
          "phase2extra",
          arguments->phase2extraarg,
          err) != 0)
    {
      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 0x54141
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x54109
jmp 0x54141
movq 0x5e7e90(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4c1ef9(%rip), %rsi    # 0x516013
leaq 0x4c209e(%rip), %rdx    # 0x5161bf
leaq 0x4d1188(%rip), %rcx    # 0x5252b0
leaq 0x4d0f71(%rip), %r8     # 0x5250a0
movl $0xc5, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x54143
cmpl $0x0, 0x24(%rsp)
je 0x54162
movq 0x10(%rsp), %rdi
leaq 0x4c7943(%rip), %rsi    # 0x51ba99
movb $0x0, %al
callq 0xd88c0
movb $0x1, 0x7(%rsp)
testb $0x1, 0x7(%rsp)
jne 0x541ac
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0xf74a0
testb $0x1, %al
jne 0x5417d
jmp 0x541ac
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdx
movq 0x10(%rsp), %rcx
leaq 0x5662ed(%rip), %rsi    # 0x5ba488
callq 0xf7500
cmpl $0x0, %eax
je 0x541aa
movb $0x1, 0x7(%rsp)
jmp 0x541ac
testb $0x1, 0x7(%rsp)
jne 0x541f6
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0xf74a0
testb $0x1, %al
jne 0x541c7
jmp 0x541f6
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdx
movq 0x10(%rsp), %rcx
leaq 0x4c76f8(%rip), %rsi    # 0x51b8dd
callq 0xf7500
cmpl $0x0, %eax
je 0x541f4
movb $0x1, 0x7(%rsp)
jmp 0x541f6
movb 0x7(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_prefilter.c
// Function: gt_readjoiner_prefilter_arguments_new
static void* gt_readjoiner_prefilter_arguments_new(void)
{
  GtReadjoinerPrefilterArguments *arguments = gt_calloc((size_t)1,
      sizeof *arguments);
  arguments->readset = gt_str_new();
  arguments->db = gt_str_array_new();
  return arguments;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x48, %esi
leaq 0x4d066a(%rip), %rdx    # 0x52539c
movl $0x31, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_prefilter.c
// Function: gt_readjoiner_prefilter_arguments_delete
static void gt_readjoiner_prefilter_arguments_delete(void *tool_arguments)
{
  GtReadjoinerPrefilterArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->readset);
  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 0x54d8d
jmp 0x54dbf
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rdi
leaq 0x4d05e7(%rip), %rsi    # 0x52539c
movl $0x3d, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_prefilter.c
// Function: gt_readjoiner_prefilter_list_input_files
static void gt_readjoiner_prefilter_list_input_files(
    GtReadjoinerPrefilterArguments *arguments, GtLogger *verbose_logger)
{
  GtUword i;
  GtStr *inputfileslist = gt_str_new();
  for (i = 0; i < gt_str_array_size(arguments->db); i++)
  {
    gt_str_append_cstr(inputfileslist, gt_str_array_get(arguments->db, i));
    if (i + 1 < gt_str_array_size(arguments->db))
      gt_str_append_cstr(inputfileslist, ", ");
  }
  gt_logger_log(verbose_logger, "input files = %s", gt_str_get(inputfileslist));
  gt_str_delete(inputfileslist);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
callq 0x11d4a0
movq %rax, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11fcc0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x5672f
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0x11f8c0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x11d550
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11fcc0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x5671a
movq 0x28(%rsp), %rdi
leaq 0x5216b4(%rip), %rsi    # 0x577dc9
callq 0x11d550
jmp 0x5671c
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x56691
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x11dee0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x4cf4ca(%rip), %rsi    # 0x525c1c
movb $0x0, %al
callq 0xe7cd0
movq 0x28(%rsp), %rdi
callq 0x11f560
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_spmtest.c
// Function: gt_readjoiner_spmtest_arguments_new
static void* gt_readjoiner_spmtest_arguments_new(void)
{
  GtReadjoinerSpmtestArguments *arguments = gt_calloc((size_t)1,
      sizeof *arguments);
  arguments->readset = gt_str_new();
  arguments->teststr = gt_str_new();
  return arguments;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x20, %esi
leaq 0x4cf47b(%rip), %rdx    # 0x525c2d
movl $0x30, %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)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_spmtest.c
// Function: gt_readjoiner_spmtest_arguments_delete
static void gt_readjoiner_spmtest_arguments_delete(void *tool_arguments)
{
  GtReadjoinerSpmtestArguments *arguments = tool_arguments;
  if (arguments == NULL)
    return;
  gt_str_delete(arguments->readset);
  gt_str_delete(arguments->teststr);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x5680d
jmp 0x5683e
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4cf3f9(%rip), %rsi    # 0x525c2d
movl $0x3d, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_spmtest.c
// Function: gt_readjoiner_spmtest_arguments_check
static int gt_readjoiner_spmtest_arguments_check(GT_UNUSED int rest_argc,
    void *tool_arguments, GT_UNUSED GtError *err)
{
  GtReadjoinerSpmtestArguments *arguments = tool_arguments;
  const char *teststr = gt_str_get(arguments->teststr);
  int had_err = 0;

  gt_error_check(err);
  gt_assert(arguments);

  if (strcmp(teststr, "showlist") == 0)
    arguments->test = GT_READJOINER_SPMTEST_SHOWLIST;
  else if (strcmp(teststr, "bruteforce") == 0)
    arguments->test = GT_READJOINER_SPMTEST_BRUTEFORCE;
  else if (strcmp(teststr, "kmp") == 0)
    arguments->test = GT_READJOINER_SPMTEST_KMP;
  else if (strcmp(teststr, "gusfield") == 0)
    arguments->test = GT_READJOINER_SPMTEST_GUSFIELD;
  else
  {
    gt_error_set(err, "illegal argument \"%s\" to option -test", teststr);
    had_err = -1;
  }
  return had_err;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11dee0
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x56a77
movq 0x20(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x56a3f
jmp 0x56a77
movq 0x5e555a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4bf5c3(%rip), %rsi    # 0x516013
leaq 0x4bf768(%rip), %rdx    # 0x5161bf
leaq 0x4cf36d(%rip), %rcx    # 0x525dcb
leaq 0x4cf1c8(%rip), %r8     # 0x525c2d
movl $0x78, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x56a79
jmp 0x56a7b
cmpq $0x0, 0x18(%rsp)
jne 0x56abb
movq 0x5e5516(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4bf57f(%rip), %rsi    # 0x516013
leaq 0x5240c4(%rip), %rdx    # 0x57ab5f
leaq 0x4cf329(%rip), %rcx    # 0x525dcb
leaq 0x4cf184(%rip), %r8     # 0x525c2d
movl $0x79, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x56abd
movq 0x10(%rsp), %rdi
leaq 0x4cdba8(%rip), %rsi    # 0x524671
callq 0x19980
cmpl $0x0, %eax
jne 0x56ae4
movq 0x18(%rsp), %rax
movl $0x0, 0x10(%rax)
jmp 0x56b76
movq 0x10(%rsp), %rdi
leaq 0x4e24ad(%rip), %rsi    # 0x538f9d
callq 0x19980
cmpl $0x0, %eax
jne 0x56b08
movq 0x18(%rsp), %rax
movl $0x1, 0x10(%rax)
jmp 0x56b74
movq 0x10(%rsp), %rdi
leaq 0x5641d1(%rip), %rsi    # 0x5bace5
callq 0x19980
cmpl $0x0, %eax
jne 0x56b2c
movq 0x18(%rsp), %rax
movl $0x2, 0x10(%rax)
jmp 0x56b72
movq 0x10(%rsp), %rdi
leaq 0x52a11d(%rip), %rsi    # 0x580c55
callq 0x19980
cmpl $0x0, %eax
jne 0x56b50
movq 0x18(%rsp), %rax
movl $0x3, 0x10(%rax)
jmp 0x56b70
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x4cdb19(%rip), %rsi    # 0x52467a
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
jmp 0x56b72
jmp 0x56b74
jmp 0x56b76
movl 0xc(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readreads.c
// Function: gt_readreads_arguments_delete
static void gt_readreads_arguments_delete(void *tool_arguments)
{
  GtReadreads *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->qualformat);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x570dd
jmp 0x57101
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4ced17(%rip), %rsi    # 0x525e0e
movl $0x35, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readreads.c
// Function: gt_readreads_arguments_check
static int gt_readreads_arguments_check(GT_UNUSED int rest_argc,
                                        GT_UNUSED void *tool_arguments,
                                        GT_UNUSED GtError *err)
{
  GT_UNUSED GtReadreads *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(arguments);

  return had_err;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x57364
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x5732c
jmp 0x57364
movq 0x5e4c6d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4becd6(%rip), %rsi    # 0x516013
leaq 0x4bee7b(%rip), %rdx    # 0x5161bf
leaq 0x4cebfa(%rip), %rcx    # 0x525f45
leaq 0x4ceabc(%rip), %r8     # 0x525e0e
movl $0x72, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x57366
jmp 0x57368
cmpq $0x0, 0x8(%rsp)
jne 0x573a8
movq 0x5e4c29(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4bec92(%rip), %rsi    # 0x516013
leaq 0x5237d7(%rip), %rdx    # 0x57ab5f
leaq 0x4cebb6(%rip), %rcx    # 0x525f45
leaq 0x4cea78(%rip), %r8     # 0x525e0e
movl $0x73, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x573aa
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_regioncov.c
// Function: parse_options
static GtOPrval parse_options(int *parsed_args, RegionCovArguments *arguments,
                              int argc, const char **argv, GtError *err)
{
  GtOptionParser *op;
  GtOption *o;
  GtOPrval oprval;
  gt_error_check(err);
  op = gt_option_parser_new("[option ...] GFF3_file",
                         "Show which parts of the given sequence regions are "
                         "covered by features.");
  /* -maxfeaturedist */
  o = gt_option_new_uword("maxfeaturedist", "set the maximum distance two "
                       "features can have while still being in the same "
                       "``cluster''", &arguments->max_feature_dist, 0);
  gt_option_parser_add_option(op, o);
  /* -v */
  o = gt_option_new_verbose(&arguments->verbose);
  gt_option_parser_add_option(op, o);
  /* parse */
  gt_option_parser_set_min_max_args(op, 1, 1);
  oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc,
                                  err);
  gt_option_parser_delete(op);
  return oprval;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x57b3c
movq 0x20(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x57b04
jmp 0x57b3c
movq 0x5e4495(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4be4fe(%rip), %rsi    # 0x516013
leaq 0x4be6a3(%rip), %rdx    # 0x5161bf
leaq 0x53d36f(%rip), %rcx    # 0x594e92
leaq 0x4ce463(%rip), %r8     # 0x525f8d
movl $0x24, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x57b3e
leaq 0x4ce474(%rip), %rdi    # 0x525fb9
leaq 0x4ce484(%rip), %rsi    # 0x525fd0
callq 0xf1420
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdx
leaq 0x4ce4b6(%rip), %rdi    # 0x526018
leaq 0x4ce4be(%rip), %rsi    # 0x526027
xorl %eax, %eax
movl %eax, %ecx
callq 0xf5fe0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf1600
movq 0x38(%rsp), %rdi
addq $0x8, %rdi
callq 0xf5f90
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0xf2a40
movq 0x18(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl 0x34(%rsp), %edx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r9
leaq 0xceb58(%rip), %r8      # 0x126730
callq 0xf2ab0
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
callq 0xf5cf0
movl 0xc(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_repfind.c
// Function: gt_repfind_arguments_new
static void *gt_repfind_arguments_new(void)
{
  GtMaxpairsoptions *arguments;

  arguments = gt_malloc(sizeof (*arguments));
  arguments->indexname = gt_str_new();
  arguments->query_indexname = gt_str_new();
  arguments->cam_string = gt_str_new();
  arguments->query_files = gt_str_array_new();
  arguments->display_args = gt_str_array_new();
  return arguments;
}

// Assembly:
pushq %rax
movl $0xc0, %edi
leaq 0x4ce44b(%rip), %rsi    # 0x526088
movl $0xbe, %edx
callq 0xe80f0
movq %rax, (%rsp)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x60(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x68(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x70(%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x78(%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xb0(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_repfind.c
// Function: gt_repfind_arguments_delete
static void gt_repfind_arguments_delete(void *tool_arguments)
{
  GtMaxpairsoptions *arguments = tool_arguments;

  if (!arguments)
  {
    return;
  }
  gt_str_delete(arguments->indexname);
  gt_str_delete(arguments->query_indexname);
  gt_str_delete(arguments->cam_string);
  gt_str_array_delete(arguments->query_files);
  gt_str_array_delete(arguments->display_args);
  gt_option_delete(arguments->refforwardoption);
  gt_option_delete(arguments->refseedlengthoption);
  gt_option_delete(arguments->refuserdefinedleastlengthoption);
  gt_option_delete(arguments->refextendxdropoption);
  gt_option_delete(arguments->refextendgreedyoption);
  gt_option_delete(arguments->ref_op_evalue);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x57cd0
jmp 0x57d95
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rax
movq 0xb0(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0x88(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0x90(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0x98(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0xa0(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0xa8(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rdi
leaq 0x4ce2fd(%rip), %rsi    # 0x526088
movl $0xda, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_repfind.c
// Function: gt_repfind_arguments_check
static int gt_repfind_arguments_check(GT_UNUSED int rest_argc,
                                      void *tool_arguments,
                                      GT_UNUSED GtError *err)
{
  GtMaxpairsoptions *arguments = tool_arguments;

  if (!gt_option_is_set(arguments->refforwardoption) &&
      (arguments->reverse || arguments->reverse_complement))
  {
    arguments->forward = false;
  }
  if (!gt_option_is_set(arguments->refuserdefinedleastlengthoption))
  {
    if (!gt_option_is_set(arguments->refseedlengthoption))
    {
      arguments->seedlength = arguments->userdefinedleastlength = 20U;
    } else
    {
      arguments->userdefinedleastlength = arguments->seedlength;
    }
  } else
  {
    if (!gt_option_is_set(arguments->refseedlengthoption))
    {
      arguments->seedlength = arguments->userdefinedleastlength;
    } else
    {
      if (arguments->seedlength > arguments->userdefinedleastlength)
      {
        arguments->seedlength = arguments->userdefinedleastlength;
      }
    }
  }
  if (!gt_option_is_set(arguments->ref_op_evalue))
  {
    arguments->evalue_threshold = DBL_MAX;
  }
  return 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)
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rdi
callq 0xf74a0
testb $0x1, %al
jne 0x58790
movq 0x8(%rsp), %rax
testb $0x1, 0x53(%rax)
jne 0x58787
movq 0x8(%rsp), %rax
testb $0x1, 0x54(%rax)
je 0x58790
movq 0x8(%rsp), %rax
movb $0x0, 0x52(%rax)
movq 0x8(%rsp), %rax
movq 0x90(%rax), %rdi
callq 0xf74a0
testb $0x1, %al
jne 0x587e4
movq 0x8(%rsp), %rax
movq 0x88(%rax), %rdi
callq 0xf74a0
testb $0x1, %al
jne 0x587d3
movq 0x8(%rsp), %rax
movl $0x14, (%rax)
movq 0x8(%rsp), %rax
movl $0x14, 0x4(%rax)
jmp 0x587e2
movq 0x8(%rsp), %rax
movl 0x4(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
jmp 0x5882e
movq 0x8(%rsp), %rax
movq 0x88(%rax), %rdi
callq 0xf74a0
testb $0x1, %al
jne 0x5880a
movq 0x8(%rsp), %rax
movl (%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x4(%rax)
jmp 0x5882c
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jbe 0x5882a
movq 0x8(%rsp), %rax
movl (%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x4(%rax)
jmp 0x5882c
jmp 0x5882e
movq 0x8(%rsp), %rax
movq 0xa8(%rax), %rdi
callq 0xf74a0
testb $0x1, %al
jne 0x58858
movq 0x8(%rsp), %rax
movsd 0x4c0500(%rip), %xmm0   # 0x518d50
movsd %xmm0, 0xb8(%rax)
xorl %eax, %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_repfind.c
// Function: gt_generic_extend_selfmatch_xdrop_with_output
static int gt_generic_extend_selfmatch_xdrop_with_output(
                                           void *info,
                                           const GtGenericEncseq *genericencseq,
                                           GtUword len,
                                           GtUword pos1,
                                           GtUword pos2,
                                           GtError *err)
{
  gt_assert(genericencseq != NULL && genericencseq->hasencseq);
  return gt_rf_xdrop_extend_selfmatch_with_output(info,
                                                  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 0x59bd4
movq 0x28(%rsp), %rax
testb $0x1, (%rax)
jne 0x59c0c
movq 0x5e23c5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4bc42e(%rip), %rsi    # 0x516013
leaq 0x4ccc58(%rip), %rdx    # 0x526844
leaq 0x4ccbed(%rip), %rcx    # 0x5267e0
leaq 0x4cc48e(%rip), %r8     # 0x526088
movl $0x212, %r9d            # imm = 0x212
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x59c0e
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 0x2ad510
addq $0x38, %rsp
retq
nopw (%rax,%rax)