LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_regioncov.c
// Function: gt_regioncov
int gt_regioncov(int argc, const char **argv, GtError *err)
{
  GtNodeVisitor *regioncov_visitor;
  GtNodeStream *gff3_in_stream;
  GtGenomeNode *gn;
  RegionCovArguments arguments;
  int parsed_args, had_err = 0;
  gt_error_check(err);

  /* option parsing */
  switch (parse_options(&parsed_args, &arguments, argc, argv, err)) {
    case GT_OPTION_PARSER_OK: break;
    case GT_OPTION_PARSER_ERROR:
      return -1;
    case GT_OPTION_PARSER_REQUESTS_EXIT:
      return 0;
  }

  /* create gff3 input stream */
  gt_assert(parsed_args < argc);
  gff3_in_stream = gt_gff3_in_stream_new_sorted(argv[parsed_args]);
  if (arguments.verbose)
    gt_gff3_in_stream_show_progress_bar((GtGFF3InStream*) gff3_in_stream);

  /* create region coverage visitor */
  regioncov_visitor = gt_regioncov_visitor_new(arguments.max_feature_dist);

  /* pull the features through the stream and free them afterwards */
  while (!(had_err = gt_node_stream_next(gff3_in_stream, &gn, err)) && gn) {
      had_err = gt_genome_node_accept(gn, regioncov_visitor, err);
      gt_genome_node_delete(gn);
  }

  /* show region coverage */
  if (!had_err)
    gt_regioncov_visitor_show_coverage(regioncov_visitor);

  /* free */
  gt_node_visitor_delete(regioncov_visitor);
  gt_node_stream_delete(gff3_in_stream);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
testq %rdx, %rdx
je 0xbba75
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xbbb6d
leaq 0x4(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
jmp 0xbba87
leaq 0x4(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl %ebp, %edx
movq %r14, %rcx
xorl %r8d, %r8d
callq 0xbbb77
cmpl $0x1, %eax
je 0xbba9d
cmpl $0x2, %eax
jne 0xbbaa7
xorl %ebp, %ebp
jmp 0xbbb5e
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0xbbb5e
movslq 0x4(%rsp), %rax
cmpl %ebp, %eax
jge 0xbbb72
movq (%r14,%rax,8), %rdi
callq 0x145d7c
movq %rax, %r14
cmpb $0x1, 0x18(%rsp)
jne 0xbbacf
movq %r14, %rdi
callq 0x145b36
movq 0x10(%rsp), %rdi
callq 0x16ecb0
movq %rax, %r15
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x162e68
movl %eax, %ebp
testl %eax, %eax
sete %al
movq (%r12), %rdi
testq %rdi, %rdi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xbbb42
leaq 0x8(%rsp), %r12
movq %r15, %rsi
movq %rbx, %rdx
callq 0x14472c
movq 0x8(%rsp), %rdi
callq 0x1451a0
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x162e68
movl %eax, %ebp
testl %eax, %eax
sete %al
jne 0xbbb42
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0xbbb0c
testb %al, %al
je 0xbbb4e
movq %r15, %rdi
callq 0x16ed04
movq %r15, %rdi
callq 0x1632f2
movq %r14, %rdi
callq 0x162dee
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1e02d
callq 0x1e064
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r15
testq %r8, %r8
je 0xbbba5
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xbbc3c
leaq 0x29932d(%rip), %rdi    # 0x354ed9
leaq 0x29933d(%rip), %rsi    # 0x354ef0
callq 0x107bfe
movq %rax, %r12
leaq 0x299376(%rip), %rdi    # 0x354f38
leaq 0x29937e(%rip), %rsi    # 0x354f47
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x10a2ab
movq %r12, %rdi
movq %rax, %rsi
callq 0x107cc0
addq $0x8, %r13
movq %r13, %rdi
callq 0x10a257
movq %r12, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r12, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x10874b
leaq 0x639fe(%rip), %r8      # 0x11f60c
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r9
callq 0x10875d
movl %eax, %ebx
movq %r12, %rdi
callq 0x10a0b4
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1e09b
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x29934c(%rip), %rsi    # 0x354fc0
movl $0xc0, %edi
movl $0xbe, %edx
callq 0x104226
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x60(%rbx)
callq 0x11ac6c
movq %rax, 0x68(%rbx)
callq 0x11ac6c
movq %rax, 0x70(%rbx)
callq 0x11be10
movq %rax, 0x78(%rbx)
callq 0x11be10
movq %rax, 0xb0(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbbd55
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x11bdbf
movq 0x68(%rbx), %rdi
callq 0x11bdbf
movq 0x70(%rbx), %rdi
callq 0x11bdbf
movq 0x78(%rbx), %rdi
callq 0x11c144
movq 0xb0(%rbx), %rdi
callq 0x11c144
movq 0x80(%rbx), %rdi
callq 0x10a16a
movq 0x88(%rbx), %rdi
callq 0x10a16a
movq 0x90(%rbx), %rdi
callq 0x10a16a
movq 0x98(%rbx), %rdi
callq 0x10a16a
movq 0xa0(%rbx), %rdi
callq 0x10a16a
movq 0xa8(%rbx), %rdi
callq 0x10a16a
leaq 0x299279(%rip), %rsi    # 0x354fc0
movq %rbx, %rdi
movl $0xda, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10ac3f
testb %al, %al
jne 0xbc47e
cmpb $0x0, 0x53(%rbx)
jne 0xbc47a
cmpb $0x1, 0x54(%rbx)
jne 0xbc47e
movb $0x0, 0x52(%rbx)
movq 0x90(%rbx), %rdi
callq 0x10ac3f
movl %eax, %ebp
movq 0x88(%rbx), %rdi
callq 0x10ac3f
testb %bpl, %bpl
je 0xbc4aa
testb %al, %al
je 0xbc4b5
movl (%rbx), %eax
cmpl %eax, 0x4(%rbx)
ja 0xbc4b7
jmp 0xbc4c9
testb %al, %al
je 0xbc4bc
movl 0x4(%rbx), %eax
movl %eax, (%rbx)
jmp 0xbc4c9
movl (%rbx), %eax
movl %eax, 0x4(%rbx)
jmp 0xbc4c9
movabsq $0x1400000014, %rax     # imm = 0x1400000014
movq %rax, (%rbx)
movq 0xa8(%rbx), %rdi
callq 0x10ac3f
testb %al, %al
jne 0xbc4ea
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_O3/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 0xbcfcd
movq %rdx, 0x10(%rsp)
testq %rsi, %rsi
je 0xbcfc8
cmpb $0x0, (%rsi)
je 0xbcfc8
movq %r8, %r12
movq %rcx, %r15
movq 0x8(%rsi), %rbp
movq %rbp, %rdi
movq %rcx, %rsi
callq 0xeb655
movq %rbp, %rdi
movq %rax, 0x8(%rsp)
movq %rax, %rsi
callq 0xeb6ee
cmpq %r15, %rax
ja 0xbcfd2
movq %rax, %rbx
movq %rbp, %rdi
movq %r12, %rsi
callq 0xeb655
movq %rax, %r13
movq %rbp, %rdi
movq %rax, %rsi
callq 0xeb6ee
cmpq %r12, %rax
ja 0xbcfd7
movq %rax, %r14
cmpq %r15, %rbx
jne 0xbcf7f
movq %rbp, %rdi
movq %r13, %rsi
callq 0xeb9d2
movq 0x10(%rsp), %rcx
addq %rcx, %r12
subq %r14, %r12
cmpq %rax, %r12
jne 0xbcfb7
leaq 0x2e7691(%rip), %rdi    # 0x3a4606
movq %r13, %rsi
movq 0x8(%rsp), %rdx
jmp 0xbcfb0
cmpq %r12, %r14
jne 0xbcfb7
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
callq 0xeb9d2
movq 0x10(%rsp), %rcx
addq %rcx, %r15
subq %rbx, %r15
cmpq %rax, %r15
jne 0xbcfb7
leaq 0x2e765e(%rip), %rdi    # 0x3a4606
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 0x1e1ef
callq 0x1e144
callq 0x1e1b6
callq 0x1e17d
// File: /workspace/github_c_makefile_star2_O3/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 0x297f9c(%rip), %rdx    # 0x355850
movl $0x1, %edi
movl $0x40, %esi
movl $0x29, %ecx
callq 0x10436a
movq %rax, %rbx
movw $0x0, 0x8(%rax)
callq 0x11ac6c
movq %rax, 0x10(%rbx)
callq 0x11ac6c
movq %rax, 0x18(%rbx)
callq 0x11ac6c
movq %rax, 0x20(%rbx)
callq 0x11ac6c
movq %rax, 0x30(%rbx)
leaq 0x297f68(%rip), %rdi    # 0x355864
callq 0x11acc9
movq %rax, 0x28(%rbx)
movl $0x0, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbd95c
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x11bdbf
movq 0x18(%rbx), %rdi
callq 0x11bdbf
movq 0x20(%rbx), %rdi
callq 0x11bdbf
movq 0x30(%rbx), %rdi
callq 0x11bdbf
movq 0x28(%rbx), %rdi
callq 0x11bdbf
leaq 0x297f02(%rip), %rsi    # 0x355850
movq %rbx, %rdi
movl $0x40, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbdcab
movl %edi, %edx
cmpl $0x1, %edi
leaq 0x30c4e8(%rip), %rax    # 0x3ca170
leaq 0x29da84(%rip), %rcx    # 0x35b713
cmoveq %rax, %rcx
leaq 0x297d8b(%rip), %rsi    # 0x355a25
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xbdccc
movq %rsi, %r14
movq 0x28(%rsi), %rdi
callq 0x11b0a1
movq %rax, %rdi
movq %rbx, %rsi
callq 0x113107
testl %eax, %eax
js 0xbdca4
movl %eax, 0x38(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2974c7(%rip), %rsi    # 0x355850
movl $0x10, %edi
movl $0xcf, %edx
callq 0x104226
movq %rax, %rbx
movq $0x0, (%rax)
movq 0x3fab2f(%rip), %rax    # 0x4b8ed8
movq (%rax), %rdx
leaq 0x288521(%rip), %rsi    # 0x3468d4
movl %ebp, %edi
callq 0x103e40
movq %rax, 0x8(%rbx)
callq 0x119160
testb %al, %al
je 0xbe3f8
testb %bpl, %bpl
je 0xbe3e0
leaq 0x297733(%rip), %rdi    # 0x355b06
callq 0x11c986
movq %rax, %rdi
movq %rax, (%rbx)
jmp 0xbe3f3
callq 0x11c954
movq %rax, (%rbx)
movq %rax, %rdi
callq 0x11d04c
movq (%rbx), %rdi
callq 0x11c9e3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbe42d
movq 0x3faac3(%rip), %rax    # 0x4b8ed8
movq (%rax), %rsi
callq 0x11cf39
movq (%rbx), %rdi
callq 0x11ca28
movq (%rbx), %rdi
callq 0x11d054
movq 0x8(%rbx), %rdi
callq 0x1040e0
leaq 0x297413(%rip), %rsi    # 0x355850
movq %rbx, %rdi
movl $0xec, %edx
popq %rbx
jmp 0x1045eb
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xbe4d1
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x10a16a
movq 0x10(%rbx), %rdi
callq 0x11bdbf
leaq 0x2976a1(%rip), %rsi    # 0x355b64
movq %rbx, %rdi
movl $0x2d, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbe592
movq %rdi, %r14
leaq 0x2976ba(%rip), %rdi    # 0x355ba4
leaq 0x2976c6(%rip), %rsi    # 0x355bb7
callq 0x107bfe
movq %rax, %rbx
leaq 0x28fea3(%rip), %rdi    # 0x34e3a3
leaq 0x2976e6(%rip), %rsi    # 0x355bed
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x10(%r14), %rdx
leaq 0x2976e6(%rip), %rdi    # 0x355c0d
leaq 0x2976e7(%rip), %rsi    # 0x355c15
callq 0x10a7af
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x107bec
movq %rax, 0x8(%r14)
addq $0x4, %r14
leaq 0x309a8e(%rip), %rdi    # 0x3c7fe6
leaq 0x2976d5(%rip), %rsi    # 0x355c34
movq %r14, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x10a44d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x10874b
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1e4ce
// File: /workspace/github_c_makefile_star2_O3/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 0xbe5b1
movq %rdx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xbe5cf
testq %r14, %r14
je 0xbe5c5
cmpl $0x1, %ebx
jne 0xbe5ca
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1e573
callq 0x1e53c
callq 0x1e505
// File: /workspace/github_c_makefile_star2_O3/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 0xbe922
movq %rdi, %r14
leaq 0x29748d(%rip), %rdi    # 0x355ced
leaq 0x2974a4(%rip), %rsi    # 0x355d0b
callq 0x107bfe
movq %rax, %rbx
leaq 0x1(%r14), %rdx
leaq 0x2974c1(%rip), %rdi    # 0x355d3b
leaq 0x2974c3(%rip), %rsi    # 0x355d44
movl $0x1, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x3(%r14), %rdx
leaq 0x32b750(%rip), %rdi    # 0x3e9ff1
leaq 0x2974ba(%rip), %rsi    # 0x355d62
movl $0x1, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x2974b7(%rip), %rdi    # 0x355d7b
leaq 0x2974b8(%rip), %rsi    # 0x355d83
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
addq $0x2, %r14
leaq 0x2974bd(%rip), %rdi    # 0x355da8
leaq 0x2974c1(%rip), %rsi    # 0x355db3
movq %r14, %rdx
movl $0x1, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10872d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1e618
// File: /workspace/github_c_makefile_star2_O3/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 0x297268(%rip), %rdx    # 0x355e58
movl $0x1, %edi
movl $0x138, %esi            # imm = 0x138
movl $0x6c, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, (%rbx)
callq 0x11ac6c
movq %rax, 0x8(%rbx)
callq 0x11ac6c
movq %rax, 0x58(%rbx)
callq 0x11ac6c
movq %rax, 0x68(%rbx)
callq 0x11ac6c
movq %rax, 0x60(%rbx)
callq 0x11ac6c
movq %rax, 0x70(%rbx)
callq 0x11ac6c
movq %rax, 0xb0(%rbx)
callq 0x11ac6c
movq %rax, 0xb8(%rbx)
callq 0x11ac6c
movq %rax, 0xc0(%rbx)
callq 0x11be10
movq %rax, 0xe8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbed40
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x11bdbf
movq 0x8(%rbx), %rdi
callq 0x11bdbf
movq 0x58(%rbx), %rdi
callq 0x11bdbf
movq 0x68(%rbx), %rdi
callq 0x11bdbf
movq 0x60(%rbx), %rdi
callq 0x11bdbf
movq 0x70(%rbx), %rdi
callq 0x11bdbf
movq 0xb0(%rbx), %rdi
callq 0x11bdbf
movq 0xb8(%rbx), %rdi
callq 0x11bdbf
movq 0xc0(%rbx), %rdi
callq 0x11bdbf
movq 0x128(%rbx), %rdi
callq 0x10a16a
movq 0x110(%rbx), %rdi
callq 0x10a16a
movq 0x130(%rbx), %rdi
callq 0x10a16a
movq 0x108(%rbx), %rdi
callq 0x10a16a
movq 0x118(%rbx), %rdi
callq 0x10a16a
movq 0x120(%rbx), %rdi
callq 0x10a16a
movq 0xe8(%rbx), %rdi
callq 0x11c144
leaq 0x297126(%rip), %rsi    # 0x355e58
movq %rbx, %rdi
movl $0x8e, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2965dc(%rip), %rdx    # 0x35715a
movl $0x1, %edi
movl $0xb0, %esi
movl $0x44, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x8(%rbx)
callq 0x11ac6c
movq %rax, 0x10(%rbx)
callq 0x11ac6c
movq %rax, 0x18(%rbx)
movl $0x4, %ebp
movl %ebp, 0x48(%rbx)
callq 0x11ac6c
movq %rax, 0x20(%rbx)
movl %ebp, 0x4c(%rbx)
callq 0x10ad60
movq %rax, 0x88(%rbx)
callq 0x11be10
movq %rax, 0x98(%rbx)
callq 0x11ac6c
movq %rax, 0xa0(%rbx)
callq 0x11ac6c
movq %rax, 0xa8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc0c7c
pushq %rbx
movq %rdi, %rbx
movq 0x90(%rdi), %rdi
callq 0xff22c
movq 0x88(%rbx), %rdi
callq 0x10b00c
movq 0x20(%rbx), %rdi
callq 0x11bdbf
movq 0x18(%rbx), %rdi
callq 0x11bdbf
movq 0x10(%rbx), %rdi
callq 0x11bdbf
movq 0x8(%rbx), %rdi
callq 0x11bdbf
movq 0x98(%rbx), %rdi
callq 0x11c144
movq 0xa0(%rbx), %rdi
callq 0x11bdbf
movq 0xa8(%rbx), %rdi
callq 0x11bdbf
leaq 0x2964ec(%rip), %rsi    # 0x35715a
movq %rbx, %rdi
movl $0x5f, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc1046
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xc1099
testq %r14, %r14
je 0xc1094
movq 0x18(%r14), %rdi
leaq 0x48(%r14), %rsi
leaq 0x29577c(%rip), %rdx    # 0x3567d6
movq %rbx, %rcx
callq 0xc12b0
testl %eax, %eax
je 0xc1073
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x20(%r14), %rdi
addq $0x4c, %r14
leaq 0x2d1508(%rip), %rdx    # 0x39258a
movq %r14, %rsi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc12b0
callq 0x1e967
callq 0x1e92e
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
testq %rcx, %rcx
je 0xc12d8
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0xc1343
movq %r12, %rdi
callq 0x11b0ca
xorl %ebp, %ebp
testq %rax, %rax
je 0xc1332
movq %r12, %rdi
callq 0x11b0a1
movsbl (%rax), %edi
callq 0x11c1bc
movl %eax, %r13d
movq %r12, %rdi
callq 0x11b0ca
cmpq $0x2, %rax
setb %al
cmpl $0x4, %r13d
setne %cl
testb %cl, %al
je 0xc1319
movl %r13d, (%r15)
jmp 0xc1332
leaq 0x29658e(%rip), %rsi    # 0x3578ae
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1ea12
// File: /workspace/github_c_makefile_star2_O3/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 0x296589(%rip), %rdx    # 0x357925
movl $0x1, %edi
movl $0x38, %esi
movl $0x2c, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x10ad60
movq %rax, 0x28(%rbx)
callq 0x11ac6c
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc1403
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0xff22c
movq 0x28(%rbx), %rdi
callq 0x10b00c
movq 0x20(%rbx), %rdi
callq 0x11bdbf
leaq 0x296530(%rip), %rsi    # 0x357925
movq %rbx, %rdi
movl $0x39, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc1685
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xc170a
testq %r14, %r14
je 0xc1705
movq 0x8(%r14), %rax
cmpq $-0x1, %rax
je 0xc16a2
cmpl $0x1, %ebp
jle 0xc16c1
leaq 0x2c37d3(%rip), %rdx    # 0x384e73
jmp 0xc16b8
movq 0x10(%r14), %rax
cmpq $-0x1, %rax
je 0xc16e6
cmpl $0x2, %ebp
jl 0xc16ca
leaq 0x2ffd75(%rip), %rdx    # 0x3c142d
leaq 0x2965cf(%rip), %rsi    # 0x357c8e
jmp 0xc16f1
testq %rax, %rax
je 0xc16d8
movq 0x10(%r14), %rax
testq %rax, %rax
jne 0xc16e6
leaq 0x2ffd57(%rip), %rdx    # 0x3c142d
jmp 0xc16df
leaq 0x2c3794(%rip), %rdx    # 0x384e73
cmpb $0x0, 0x5(%r14)
je 0xc16ea
xorl %eax, %eax
jmp 0xc1700
leaq 0x2965de(%rip), %rsi    # 0x357ccf
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1eb2d
callq 0x1eaf4
// File: /workspace/github_c_makefile_star2_O3/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 0x296374(%rip), %rdx    # 0x357df8
movl $0x1, %edi
movl $0x78, %esi
movl $0x4f, %ecx
callq 0x10436a
movq %rax, %rbx
movb $0x0, 0x5(%rax)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x18(%rbx)
callq 0x11ac6c
movq %rax, 0x38(%rbx)
callq 0x11ac6c
movq %rax, 0x48(%rbx)
callq 0x11ac6c
movq %rax, 0x40(%rbx)
movq $0x0, 0x30(%rbx)
callq 0x11be10
movq %rax, 0x58(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc1b29
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x11bdbf
movq 0x48(%rbx), %rdi
callq 0x11bdbf
movq 0x50(%rbx), %rdi
callq 0x10a16a
movq 0x40(%rbx), %rdi
callq 0x11bdbf
movq 0x58(%rbx), %rdi
callq 0x11c144
leaq 0x2962dd(%rip), %rsi    # 0x357df8
movq %rbx, %rdi
movl $0x64, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc2021
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xc207e
movq 0x50(%r14), %rdi
callq 0x10ac3f
testb %al, %al
je 0xc2050
leaq 0x30(%r14), %rdi
movq 0x40(%r14), %rdx
leaq 0x322b0b(%rip), %rsi    # 0x3e4b48
movq %rbx, %rcx
callq 0x10ac4e
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0xc2076
xorl %eax, %eax
cmpb $0x1, 0x8(%r14)
jne 0xc2076
cmpl $0x1, 0x28(%r14)
je 0xc2076
leaq 0x29604f(%rip), %rsi    # 0x3580b6
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1ec81
// File: /workspace/github_c_makefile_star2_O3/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 0xc2f19
movq %rsi, %rbx
movl 0x24(%rdi), %eax
testl %eax, %eax
je 0xc2eca
movl %eax, (%rbx)
cmpl 0xc(%rdi), %eax
jae 0xc2ee5
cmpl $0x21, %eax
jb 0xc2ee1
leaq 0x287d0c(%rip), %rsi    # 0x34abc3
movq %rdx, %rdi
movl %eax, %edx
movl $0x20, %ecx
xorl %eax, %eax
callq 0xfcb67
jmp 0xc2ef8
movl 0xc(%rdi), %eax
cmpl $0x1, %eax
jbe 0xc2f23
decl %eax
cmpl $0x20, %eax
movl $0x20, %ecx
cmovbl %eax, %ecx
movl %ecx, (%rbx)
xorl %ebp, %ebp
jmp 0xc2efb
leaq 0x2955a7(%rip), %rsi    # 0x358493
movq %rdx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xfcb67
movb $0x1, %bpl
movl (%rbx), %esi
leaq 0x2955f4(%rip), %rdi    # 0x3584f8
xorl %eax, %eax
callq 0x103d72
cmpl $0x0, (%rbx)
je 0xc2f1e
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1edd7
callq 0x1ed9e
callq 0x1ed65
// File: /workspace/github_c_makefile_star2_O3/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 0xc2fa7
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xff22c
movq 0x8(%rbx), %rdi
callq 0x10b00c
leaq 0x295604(%rip), %rsi    # 0x35859d
movq %rbx, %rdi
movl $0x3b, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc3462
movq %r12, %rdi
callq 0xfcc32
testb %al, %al
jne 0xc3514
callq 0xe48d0
movq %rax, %rbx
subl %r15d, %ebp
movslq %r15d, %rax
leaq (%r14,%rax,8), %rsi
movl %ebp, %edi
callq 0x145cdf
movq %rax, %r14
movq %rbx, %rdi
callq 0x129320
movq %r14, %rdi
movq %rax, %rsi
callq 0x1841d5
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x162f5d
movl %eax, %ebp
testl %eax, %eax
jne 0xc34eb
movq %rbx, %rdi
callq 0xe49c2
movq %rax, %r12
movq %rax, %rdi
callq 0x11c131
testq %rax, %rax
je 0xc34e3
xorl %r13d, %r13d
movq %r12, %rdi
movq %r13, %rsi
callq 0x11bfb3
movq %rax, %rdi
callq 0x17bd0
incq %r13
movq %r12, %rdi
callq 0x11c131
cmpq %rax, %r13
jb 0xc34c0
movq %r12, %rdi
callq 0x11c144
movq %r15, %rdi
callq 0x162dee
movq %r14, %rdi
callq 0x162dee
movq %rbx, %rdi
callq 0xe4c43
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1eee8
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x295300(%rip), %rsi    # 0x358847
movl $0x10, %edi
movl $0x1f, %edx
callq 0x104226
movq %rax, %rbx
callq 0x11ac6c
movq %rax, (%rbx)
callq 0x11be10
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc362c
movq %rdi, %r14
leaq 0x2952d0(%rip), %rdi    # 0x358881
leaq 0x2952e8(%rip), %rsi    # 0x3588a0
callq 0x107bfe
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x2a2563(%rip), %rdi    # 0x365b2d
leaq 0x295338(%rip), %rsi    # 0x358909
xorl %ecx, %ecx
callq 0x10a770
movq %rax, %r15
movq %rax, %rdi
callq 0x10ac1f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
movq 0x8(%r14), %rdx
leaq 0x2b1f00(%rip), %rdi    # 0x3754f9
leaq 0x29534c(%rip), %rsi    # 0x35894c
callq 0x10a7df
movq %rax, %r14
movq %rax, %rdi
callq 0x10ac1f
movq %r14, %rdi
callq 0x10a87b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x107cc0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1ef1f