LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
leaq 0x2a0ad1(%rip), %rdx    # 0x35db85
movl $0x1, %edi
movl $0x20, %esi
movl $0x30, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, (%rbx)
callq 0x1208f8
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0xbd110
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x121b03
movq 0x8(%rbx), %rdi
callq 0x121b03
leaq 0x2a0a83(%rip), %rsi    # 0x35db85
movq %rbx, %rdi
movl $0x3d, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_readjoiner_spmtest.c
// Function: gt_readjoiner_spmtest_option_parser_new
static GtOptionParser* gt_readjoiner_spmtest_option_parser_new(
    void *tool_arguments)
{
  GtReadjoinerSpmtestArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("-readset [option ...]",
      "Test/development tool for readjoiner overlap phase.");

  /* -readset */
  option = gt_option_new_string("readset", "specify the readset name",
      arguments->readset, NULL);
  gt_option_parser_add_option(op, option);
  gt_option_is_mandatory(option);

  /* -l */
  option = gt_option_new_uint_min("l", "specify the minimum spm length",
      &arguments->minmatchlength, 0, 1U);
  gt_option_parser_add_option(op, option);

  /* -test */
  option = gt_option_new_string("test",
      "select among the available tests:\n"
      "showlist: show content of an spm list (input: spmlist)\n"
      "bruteforce: memcmp all suffixes and prefixes (input: encseq)\n"
      "kmp: variant of Knuth-Morris-Pratt (input: encseq)\n"
      "gusfield: Gusfield all pairs suffix-prefix (input: esa)",
      arguments->teststr, NULL);
  gt_option_parser_add_option(op, option);
  gt_option_is_mandatory(option);

  /* -singlestrand */
  option = gt_option_new_bool("singlestrand", "do not use reads "
      "reverse complements", &arguments->singlestrand, false);
  gt_option_parser_add_option(op, option);

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

  gt_option_parser_set_version_func(op, gt_readjoiner_show_version);
  gt_option_parser_set_max_args(op, 0);

  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xbd21c
movq %rdi, %r14
leaq 0x29f305(%rip), %rdi    # 0x35c42e
leaq 0x2a0a9f(%rip), %rsi    # 0x35dbcf
callq 0x10cc4e
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x29e52a(%rip), %rdi    # 0x35b66c
leaq 0x29e52b(%rip), %rsi    # 0x35b674
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10fa96
leaq 0x14(%r14), %rdx
leaq 0x2d3de5(%rip), %rdi    # 0x390f56
leaq 0x2a0a8b(%rip), %rsi    # 0x35dc03
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x10f73b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x8(%r14), %rdx
leaq 0x293848(%rip), %rdi    # 0x3509e3
leaq 0x2a0a80(%rip), %rsi    # 0x35dc22
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10fa96
leaq 0x18(%r14), %rdx
leaq 0x296614(%rip), %rdi    # 0x3537de
leaq 0x29f3ac(%rip), %rsi    # 0x35c57d
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
addq $0x19, %r14
movq %r14, %rdi
callq 0x10f473
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x127577(%rip), %rsi    # 0x1e4778
movq %rbx, %rdi
callq 0x10cda1
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10d775
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1e0a5
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rsi), %rdi
callq 0x120d23
movq %rax, %r15
testq %rbx, %rbx
je 0xbd24d
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xbd2f0
testq %r14, %r14
je 0xbd2eb
leaq 0x29f36b(%rip), %rsi    # 0x35c5c8
movq %r15, %rdi
callq 0x17a40
testl %eax, %eax
je 0xbd2bd
leaq 0x2b3bd0(%rip), %rsi    # 0x370e40
movq %r15, %rdi
callq 0x17a40
testl %eax, %eax
je 0xbd2c7
leaq 0x33189a(%rip), %rsi    # 0x3eeb1d
movq %r15, %rdi
callq 0x17a40
testl %eax, %eax
je 0xbd2d1
leaq 0x2fa4a7(%rip), %rsi    # 0x3b773d
movq %r15, %rdi
callq 0x17a40
testl %eax, %eax
je 0xbd2db
leaq 0x29f328(%rip), %rsi    # 0x35c5d1
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xbd2e5
movl $0x0, 0x10(%r14)
jmp 0xbd2e3
movl $0x1, 0x10(%r14)
jmp 0xbd2e3
movl $0x2, 0x10(%r14)
jmp 0xbd2e3
movl $0x3, 0x10(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1e113
callq 0x1e0dc
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
je 0xbd771
movq %rdx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xbd77f
testq %rbx, %rbx
je 0xbd77a
xorl %eax, %eax
popq %rbx
retq
callq 0x1e263
callq 0x1e22c
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
leaq 0x2a0364(%rip), %rsi    # 0x35dff0
movl $0xc0, %edi
movl $0xbe, %edx
callq 0x1092b2
movq %rax, %rbx
callq 0x1208f8
movq %rax, 0x60(%rbx)
callq 0x1208f8
movq %rax, 0x68(%rbx)
callq 0x1208f8
movq %rax, 0x70(%rbx)
callq 0x121b54
movq %rax, 0x78(%rbx)
callq 0x121b54
movq %rax, 0xb0(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0xbdd6d
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x121b03
movq 0x68(%rbx), %rdi
callq 0x121b03
movq 0x70(%rbx), %rdi
callq 0x121b03
movq 0x78(%rbx), %rdi
callq 0x121e8b
movq 0xb0(%rbx), %rdi
callq 0x121e8b
movq 0x80(%rbx), %rdi
callq 0x10f386
movq 0x88(%rbx), %rdi
callq 0x10f386
movq 0x90(%rbx), %rdi
callq 0x10f386
movq 0x98(%rbx), %rdi
callq 0x10f386
movq 0xa0(%rbx), %rdi
callq 0x10f386
movq 0xa8(%rbx), %rdi
callq 0x10f386
leaq 0x2a0291(%rip), %rsi    # 0x35dff0
movq %rbx, %rdi
movl $0xda, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x80(%rsi), %rdi
callq 0x10fe52
testb %al, %al
jne 0xbe496
cmpb $0x0, 0x53(%rbx)
jne 0xbe492
cmpb $0x1, 0x54(%rbx)
jne 0xbe496
movb $0x0, 0x52(%rbx)
movq 0x90(%rbx), %rdi
callq 0x10fe52
movl %eax, %ebp
movq 0x88(%rbx), %rdi
callq 0x10fe52
testb %bpl, %bpl
je 0xbe4c2
testb %al, %al
je 0xbe4cd
movl (%rbx), %eax
cmpl %eax, 0x4(%rbx)
ja 0xbe4cf
jmp 0xbe4e1
testb %al, %al
je 0xbe4d4
movl 0x4(%rbx), %eax
movl %eax, (%rbx)
jmp 0xbe4e1
movl (%rbx), %eax
movl %eax, 0x4(%rbx)
jmp 0xbe4e1
movabsq $0x1400000014, %rax     # imm = 0x1400000014
movq %rax, (%rbx)
movq 0xa8(%rbx), %rdi
callq 0x10fe52
testb %al, %al
jne 0xbe502
movabsq $0x7fefffffffffffff, %rax # imm = 0x7FEFFFFFFFFFFFFF
movq %rax, 0xb8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_repfind.c
// Function: gt_suffix_prefix_match_with_output
static int gt_suffix_prefix_match_with_output(GT_UNUSED void *info,
                                              const GtGenericEncseq
                                                *genericencseq,
                                              GtUword matchlen,
                                              GtUword pos1,
                                              GtUword pos2,
                                              GT_UNUSED GtError *err)
{
  GtUword seqnum1, relpos1, seqnum2, relpos2, seqstartpos;
  const GtEncseq *encseq;

  gt_assert(pos1 < pos2);
  gt_assert(genericencseq != NULL && genericencseq->hasencseq);
  encseq = genericencseq->seqptr.encseq;
  seqnum1 = gt_encseq_seqnum(encseq,pos1);
  seqstartpos = gt_encseq_seqstartpos(encseq, seqnum1);
  gt_assert(seqstartpos <= pos1);
  relpos1 = pos1 - seqstartpos;
  seqnum2 = gt_encseq_seqnum(encseq,pos2);
  seqstartpos = gt_encseq_seqstartpos(encseq, seqnum2);
  gt_assert(seqstartpos <= pos2);
  relpos2 = pos2 - seqstartpos;
  if (relpos1 == 0)
  {
    GtUword seqlen2 = gt_encseq_seqlength(encseq,seqnum2);

    if (relpos2 + matchlen == seqlen2)
    {
      printf(GT_WU " " GT_WU " " GT_WU "\n",seqnum2,seqnum1,matchlen);
    }
  } else
  {
    if (relpos2 == 0)
    {
      GtUword seqlen1 = gt_encseq_seqlength(encseq,seqnum1);

      if (relpos1 + matchlen == seqlen1)
      {
        printf(GT_WU " " GT_WU " " GT_WU "\n",seqnum1,seqnum2,matchlen);
      }
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq %r8, %rcx
jae 0xbefaa
movq %rdx, 0x10(%rsp)
testq %rsi, %rsi
je 0xbefa5
cmpb $0x0, (%rsi)
je 0xbefa5
movq %r8, %r12
movq %rcx, %r15
movq 0x8(%rsi), %rbp
movq %rbp, %rdi
movq %rcx, %rsi
callq 0xefc48
movq %rbp, %rdi
movq %rax, 0x8(%rsp)
movq %rax, %rsi
callq 0xefce0
cmpq %r15, %rax
ja 0xbefaf
movq %rax, %rbx
movq %rbp, %rdi
movq %r12, %rsi
callq 0xefc48
movq %rax, %r13
movq %rbp, %rdi
movq %rax, %rsi
callq 0xefce0
cmpq %r12, %rax
ja 0xbefb4
movq %rax, %r14
cmpq %r15, %rbx
jne 0xbef5c
movq %rbp, %rdi
movq %r13, %rsi
callq 0xeffd3
movq 0x10(%rsp), %rcx
addq %rcx, %r12
subq %r14, %r12
cmpq %rax, %r12
jne 0xbef94
leaq 0x2eec46(%rip), %rdi    # 0x3adb98
movq %r13, %rsi
movq 0x8(%rsp), %rdx
jmp 0xbef8d
cmpq %r12, %r14
jne 0xbef94
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
callq 0xeffd3
movq 0x10(%rsp), %rcx
addq %rcx, %r15
subq %rbx, %r15
cmpq %rax, %r15
jne 0xbef94
leaq 0x2eec13(%rip), %rdi    # 0x3adb98
movq 0x8(%rsp), %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x17070
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1e540
callq 0x1e495
callq 0x1e507
callq 0x1e4ce
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
leaq 0x29f03c(%rip), %rdx    # 0x35e880
movl $0x1, %edi
movl $0x40, %esi
movl $0x29, %ecx
callq 0x1093ef
movq %rax, %rbx
movw $0x0, 0x8(%rax)
callq 0x1208f8
movq %rax, 0x10(%rbx)
callq 0x1208f8
movq %rax, 0x18(%rbx)
callq 0x1208f8
movq %rax, 0x20(%rbx)
callq 0x1208f8
movq %rax, 0x30(%rbx)
leaq 0x30a86a(%rip), %rdi    # 0x3ca0f6
callq 0x120955
movq %rax, 0x28(%rbx)
movl $0x0, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0xbf8ec
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x121b03
movq 0x18(%rbx), %rdi
callq 0x121b03
movq 0x20(%rbx), %rdi
callq 0x121b03
movq 0x30(%rbx), %rdi
callq 0x121b03
movq 0x28(%rbx), %rdi
callq 0x121b03
leaq 0x29efa2(%rip), %rsi    # 0x35e880
movq %rbx, %rdi
movl $0x40, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
testl %edi, %edi
jle 0xbfc3b
movl %edi, %edx
cmpl $0x1, %edi
leaq 0x313c78(%rip), %rax    # 0x3d3890
leaq 0x2a4b94(%rip), %rcx    # 0x3647b3
cmoveq %rax, %rcx
leaq 0x29ee27(%rip), %rsi    # 0x35ea51
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xbfc5c
movq %rsi, %r14
movq 0x28(%rsi), %rdi
callq 0x120d23
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1187a3
testl %eax, %eax
js 0xbfc34
movl %eax, 0x38(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
leaq 0x29e52d(%rip), %rsi    # 0x35e880
movl $0x10, %edi
movl $0xcf, %edx
callq 0x1092b2
movq %rax, %rbx
movq $0x0, (%rax)
movq 0x403b75(%rip), %rax    # 0x4c3ee8
movq (%rax), %rdx
leaq 0x28f557(%rip), %rsi    # 0x34f8d4
movl %ebp, %edi
callq 0x108ed0
movq %rax, 0x8(%rbx)
callq 0x11ed94
testb %al, %al
je 0xc03bf
testb %bpl, %bpl
je 0xc03a7
leaq 0x29e795(%rip), %rdi    # 0x35eb32
callq 0x1226d6
movq %rax, (%rbx)
jmp 0xc03b7
callq 0x1226a4
movq %rax, (%rbx)
movq %rax, %rdi
callq 0x122d71
movq (%rbx), %rdi
callq 0x122733
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xc03f4
movq 0x403b0c(%rip), %rax    # 0x4c3ee8
movq (%rax), %rsi
callq 0x122c67
movq (%rbx), %rdi
callq 0x122778
movq (%rbx), %rdi
callq 0x122d79
movq 0x8(%rbx), %rdi
callq 0x10916a
leaq 0x29e47c(%rip), %rsi    # 0x35e880
movq %rbx, %rdi
movl $0xec, %edx
popq %rbx
jmp 0x109670
nop
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0xc0499
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x10f386
movq 0x10(%rbx), %rdi
callq 0x121b03
leaq 0x29e705(%rip), %rsi    # 0x35eb90
movq %rbx, %rdi
movl $0x2d, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xc055a
movq %rdi, %r14
leaq 0x29e71e(%rip), %rdi    # 0x35ebd0
leaq 0x29e72a(%rip), %rsi    # 0x35ebe3
callq 0x10cc4e
movq %rax, %rbx
leaq 0x296f0b(%rip), %rdi    # 0x3573d3
leaq 0x29e74a(%rip), %rsi    # 0x35ec19
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x10(%r14), %rdx
leaq 0x29e74a(%rip), %rdi    # 0x35ec39
leaq 0x29e74b(%rip), %rsi    # 0x35ec41
callq 0x10f9c6
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10cc3c
movq %rax, 0x8(%r14)
addq $0x4, %r14
leaq 0x3111ee(%rip), %rdi    # 0x3d170e
leaq 0x29e739(%rip), %rsi    # 0x35ec60
movq %r14, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x10f669
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x10d784
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1e81f
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebx
testq %rdx, %rdx
je 0xc0579
movq %rdx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xc0597
testq %r14, %r14
je 0xc058d
cmpl $0x1, %ebx
jne 0xc0592
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1e8c4
callq 0x1e88d
callq 0x1e856
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc08ea
movq %rdi, %r14
leaq 0x29e4f1(%rip), %rdi    # 0x35ed19
leaq 0x29e508(%rip), %rsi    # 0x35ed37
callq 0x10cc4e
movq %rax, %rbx
leaq 0x1(%r14), %rdx
leaq 0x29e525(%rip), %rdi    # 0x35ed67
leaq 0x29e527(%rip), %rsi    # 0x35ed70
movl $0x1, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x3(%r14), %rdx
leaq 0x332f78(%rip), %rdi    # 0x3f37e1
leaq 0x29e51e(%rip), %rsi    # 0x35ed8e
movl $0x1, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x29e51b(%rip), %rdi    # 0x35eda7
leaq 0x29e51c(%rip), %rsi    # 0x35edaf
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
addq $0x2, %r14
leaq 0x29e521(%rip), %rdi    # 0x35edd4
leaq 0x29e525(%rip), %rsi    # 0x35eddf
movq %r14, %rdx
movl $0x1, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10d766
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1e969
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
leaq 0x29e26c(%rip), %rdx    # 0x35ee88
movl $0x1, %edi
movl $0x138, %esi            # imm = 0x138
movl $0x6c, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, (%rbx)
callq 0x1208f8
movq %rax, 0x8(%rbx)
callq 0x1208f8
movq %rax, 0x58(%rbx)
callq 0x1208f8
movq %rax, 0x68(%rbx)
callq 0x1208f8
movq %rax, 0x60(%rbx)
callq 0x1208f8
movq %rax, 0x70(%rbx)
callq 0x1208f8
movq %rax, 0xb0(%rbx)
callq 0x1208f8
movq %rax, 0xb8(%rbx)
callq 0x1208f8
movq %rax, 0xc0(%rbx)
callq 0x121b54
movq %rax, 0xe8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0xc0d6c
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x121b03
movq 0x8(%rbx), %rdi
callq 0x121b03
movq 0x58(%rbx), %rdi
callq 0x121b03
movq 0x68(%rbx), %rdi
callq 0x121b03
movq 0x60(%rbx), %rdi
callq 0x121b03
movq 0x70(%rbx), %rdi
callq 0x121b03
movq 0xb0(%rbx), %rdi
callq 0x121b03
movq 0xb8(%rbx), %rdi
callq 0x121b03
movq 0xc0(%rbx), %rdi
callq 0x121b03
movq 0x128(%rbx), %rdi
callq 0x10f386
movq 0x110(%rbx), %rdi
callq 0x10f386
movq 0x130(%rbx), %rdi
callq 0x10f386
movq 0x108(%rbx), %rdi
callq 0x10f386
movq 0x118(%rbx), %rdi
callq 0x10f386
movq 0x120(%rbx), %rdi
callq 0x10f386
movq 0xe8(%rbx), %rdi
callq 0x121e8b
leaq 0x29e12a(%rip), %rsi    # 0x35ee88
movq %rbx, %rdi
movl $0x8e, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %rbx
pushq %rax
leaq 0x29d53b(%rip), %rdx    # 0x3601ad
movl $0x1, %edi
movl $0xb0, %esi
movl $0x44, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, 0x8(%rbx)
callq 0x1208f8
movq %rax, 0x10(%rbx)
callq 0x1208f8
movq %rax, 0x18(%rbx)
movl $0x4, %ebp
movl %ebp, 0x48(%rbx)
callq 0x1208f8
movq %rax, 0x20(%rbx)
movl %ebp, 0x4c(%rbx)
callq 0x10ff7c
movq %rax, 0x88(%rbx)
callq 0x121b54
movq %rax, 0x98(%rbx)
callq 0x1208f8
movq %rax, 0xa0(%rbx)
callq 0x1208f8
movq %rax, 0xa8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0xc2d70
pushq %rbx
movq %rdi, %rbx
movq 0x90(%rdi), %rdi
callq 0x1040fc
movq 0x88(%rbx), %rdi
callq 0x110231
movq 0x20(%rbx), %rdi
callq 0x121b03
movq 0x18(%rbx), %rdi
callq 0x121b03
movq 0x10(%rbx), %rdi
callq 0x121b03
movq 0x8(%rbx), %rdi
callq 0x121b03
movq 0x98(%rbx), %rdi
callq 0x121e8b
movq 0xa0(%rbx), %rdi
callq 0x121b03
movq 0xa8(%rbx), %rdi
callq 0x121b03
leaq 0x29d44b(%rip), %rsi    # 0x3601ad
movq %rbx, %rdi
movl $0x5f, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdx, %rdx
je 0xc313a
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xc3188
testq %r14, %r14
je 0xc3183
movq 0x18(%r14), %rdi
leaq 0x48(%r14), %rsi
leaq 0x29c6b8(%rip), %rdx    # 0x35f806
movq %rbx, %rcx
callq 0xc339c
testl %eax, %eax
je 0xc3162
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x20(%r14), %rdi
addq $0x4c, %r14
leaq 0x2d885c(%rip), %rdx    # 0x39b9cd
movq %r14, %rsi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc339c
callq 0x1ecf1
callq 0x1ecb8
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
testq %rcx, %rcx
je 0xc33c1
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0xc342a
movq %r12, %rdi
callq 0x120d4c
testq %rax, %rax
je 0xc341f
movq %r12, %rdi
callq 0x120d23
movsbl (%rax), %edi
callq 0x121f04
movl %eax, %ebp
movq %r12, %rdi
callq 0x120d4c
cmpq $0x2, %rax
setb %cl
cmpl $0x4, %ebp
setne %r12b
xorl %eax, %eax
andb %cl, %r12b
jne 0xc3416
leaq 0x29d4fd(%rip), %rsi    # 0x360901
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %r12b, %r12b
je 0xc3421
movl %ebp, (%rbx)
jmp 0xc3421
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1ed9c
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
leaq 0x29d4f4(%rip), %rdx    # 0x360978
movl $0x1, %edi
movl $0x38, %esi
movl $0x2c, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x10ff7c
movq %rax, 0x28(%rbx)
callq 0x1208f8
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0xc34eb
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x1040fc
movq 0x28(%rbx), %rdi
callq 0x110231
movq 0x20(%rbx), %rdi
callq 0x121b03
leaq 0x29d49b(%rip), %rsi    # 0x360978
movq %rbx, %rdi
movl $0x39, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
testq %rdx, %rdx
je 0xc376d
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xc37f3
testq %r14, %r14
je 0xc37ee
movq 0x8(%r14), %rax
cmpq $-0x1, %rax
jne 0xc3783
cmpq $-0x1, 0x10(%r14)
je 0xc37ba
cmpl $0x2, %ebp
jl 0xc37a7
cmpq $-0x1, %rax
leaq 0x3073c6(%rip), %rax    # 0x3cab59
leaq 0x2caaac(%rip), %rdx    # 0x38e246
cmoveq %rax, %rdx
leaq 0x29d53c(%rip), %rsi    # 0x360ce1
jmp 0xc37da
testq %rax, %rax
je 0xc37b3
cmpq $0x0, 0x10(%r14)
jne 0xc37ba
cmpb $0x0, 0x5(%r14)
je 0xc37be
xorl %eax, %eax
jmp 0xc37e9
testq %rax, %rax
leaq 0x2caa7e(%rip), %rax    # 0x38e246
leaq 0x30738a(%rip), %rdx    # 0x3cab59
cmoveq %rax, %rdx
leaq 0x29d548(%rip), %rsi    # 0x360d22
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1eeb7
callq 0x1ee7e
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
leaq 0x29d2d3(%rip), %rdx    # 0x360e4b
movl $0x1, %edi
movl $0x78, %esi
movl $0x4f, %ecx
callq 0x1093ef
movq %rax, %rbx
movb $0x0, 0x5(%rax)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x18(%rbx)
callq 0x1208f8
movq %rax, 0x38(%rbx)
callq 0x1208f8
movq %rax, 0x48(%rbx)
callq 0x1208f8
movq %rax, 0x40(%rbx)
movq $0x0, 0x30(%rbx)
callq 0x121b54
movq %rax, 0x58(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0xc3c1d
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x121b03
movq 0x48(%rbx), %rdi
callq 0x121b03
movq 0x50(%rbx), %rdi
callq 0x10f386
movq 0x40(%rbx), %rdi
callq 0x121b03
movq 0x58(%rbx), %rdi
callq 0x121e8b
leaq 0x29d23c(%rip), %rsi    # 0x360e4b
movq %rbx, %rdi
movl $0x64, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdx, %rdx
je 0xc4115
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xc4174
movq 0x50(%r14), %rdi
callq 0x10fe52
testb %al, %al
je 0xc4140
leaq 0x30(%r14), %rdi
movq 0x40(%r14), %rdx
leaq 0x32a1db(%rip), %rsi    # 0x3ee30c
movq %rbx, %rcx
callq 0x10fe61
testl %eax, %eax
setne %al
jmp 0xc4142
xorl %eax, %eax
testb %al, %al
jne 0xc4167
cmpb $0x1, 0x8(%r14)
jne 0xc4167
cmpl $0x1, 0x28(%r14)
je 0xc4167
leaq 0x29cfae(%rip), %rsi    # 0x361109
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movb $0x1, %al
movzbl %al, %eax
negl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1f00b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_seqcorrect.c
// Function: gt_seqcorrect_bucketkey_kmersize
static bool gt_seqcorrect_bucketkey_kmersize(GtSeqcorrectArguments *arguments,
    unsigned int *kmersize, GtError *err)
{
  bool haserr = false;
  gt_assert(kmersize != NULL);
  if (arguments->forcek > 0)
  {
    *kmersize = arguments->forcek;
    if (*kmersize >= arguments->correction_kmersize)
    {
      gt_error_set(err,"argument %u to option -forcek must be < "
          "correction kmersize (-k)", *kmersize);
      haserr = true;
    }
    else if (*kmersize > (unsigned int)GT_UNITSIN2BITENC)
    {
      gt_error_set(err,
          "argument %u to option -forcek > %u (machine word size/2)",
          *kmersize, (unsigned int)GT_UNITSIN2BITENC);
      haserr = true;
    }
  }
  else
  {
    gt_assert(arguments->correction_kmersize > 1U);
    *kmersize = GT_MIN((unsigned int) GT_UNITSIN2BITENC,
        arguments->correction_kmersize - 1);
  }
  gt_log_log("bucketkey kmersize=%u", *kmersize);
  gt_assert(*kmersize > 0);
  return haserr;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xc502e
movq %rsi, %rbx
movl 0x24(%rdi), %eax
testl %eax, %eax
je 0xc4fdf
movl %eax, (%rbx)
cmpl 0xc(%rdi), %eax
jae 0xc4ffa
cmpl $0x21, %eax
jb 0xc4ff6
leaq 0x28ec18(%rip), %rsi    # 0x353be4
movq %rdx, %rdi
movl %eax, %edx
movl $0x20, %ecx
xorl %eax, %eax
callq 0x1019cf
jmp 0xc500d
movl 0xc(%rdi), %eax
cmpl $0x1, %eax
jbe 0xc5038
decl %eax
cmpl $0x20, %eax
movl $0x20, %ecx
cmovbl %eax, %ecx
movl %ecx, (%rbx)
xorl %ebp, %ebp
jmp 0xc5010
leaq 0x29c4e5(%rip), %rsi    # 0x3614e6
movq %rdx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x1019cf
movb $0x1, %bpl
movl (%rbx), %esi
leaq 0x29c532(%rip), %rdi    # 0x36154b
xorl %eax, %eax
callq 0x108e02
cmpl $0x0, (%rbx)
je 0xc5033
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1f161
callq 0x1f128
callq 0x1f0ef
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0xc50bf
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1040fc
movq 0x8(%rbx), %rdi
callq 0x110231
leaq 0x29c53f(%rip), %rsi    # 0x3615f0
movq %rbx, %rdi
movl $0x3b, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movl %edx, %r15d
movq %rsi, %r14
movl %edi, %ebp
testq %r8, %r8
je 0xc557a
movq %r12, %rdi
callq 0x101a9a
testb %al, %al
jne 0xc562c
callq 0xe8d9c
movq %rax, %rbx
subl %r15d, %ebp
movslq %r15d, %rax
leaq (%r14,%rax,8), %rsi
movl %ebp, %edi
callq 0x14d00b
movq %rax, %r14
movq %rbx, %rdi
callq 0x12f1f8
movq %r14, %rdi
movq %rax, %rsi
callq 0x18c917
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x16adca
movl %eax, %ebp
testl %eax, %eax
jne 0xc5603
movq %rbx, %rdi
callq 0xe8e8e
movq %rax, %r12
movq %rax, %rdi
callq 0x121e78
testq %rax, %rax
je 0xc55fb
xorl %r13d, %r13d
movq %r12, %rdi
movq %r13, %rsi
callq 0x121cfa
movq %rax, %rdi
callq 0x17bd0
incq %r13
movq %r12, %rdi
callq 0x121e78
cmpq %rax, %r13
jb 0xc55d8
movq %r12, %rdi
callq 0x121e8b
movq %r15, %rdi
callq 0x16ac6e
movq %r14, %rdi
callq 0x16ac6e
movq %rbx, %rdi
callq 0xe9120
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1f272
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
leaq 0x29c23b(%rip), %rsi    # 0x36189a
movl $0x10, %edi
movl $0x1f, %edx
callq 0x1092b2
movq %rax, %rbx
callq 0x1208f8
movq %rax, (%rbx)
callq 0x121b54
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xc5744
movq %rdi, %r14
leaq 0x29c20b(%rip), %rdi    # 0x3618d4
leaq 0x29c223(%rip), %rsi    # 0x3618f3
callq 0x10cc4e
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x2a9630(%rip), %rdi    # 0x36ed12
leaq 0x29c273(%rip), %rsi    # 0x36195c
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r15
movq %rax, %rdi
callq 0x10fe32
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
movq 0x8(%r14), %rdx
leaq 0x2b9068(%rip), %rdi    # 0x37e779
leaq 0x29c287(%rip), %rsi    # 0x36199f
callq 0x10f9f6
movq %rax, %r14
movq %rax, %rdi
callq 0x10fe32
movq %r14, %rdi
callq 0x10fa96
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10cd10
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1f2a9