LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x2b5ba4(%rip), %rsi    # 0x2f4fd0
movl $0xc0, %edi
movl $0xbe, %edx
callq 0x93160
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x60(%rbx)
callq 0xacb84
movq %rax, 0x68(%rbx)
callq 0xacb84
movq %rax, 0x70(%rbx)
callq 0xae154
movq %rax, 0x78(%rbx)
callq 0xae154
movq %rax, 0xb0(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3f50d
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0xae103
movq 0x68(%rbx), %rdi
callq 0xae103
movq 0x70(%rbx), %rdi
callq 0xae103
movq 0x78(%rbx), %rdi
callq 0xae662
movq 0xb0(%rbx), %rdi
callq 0xae662
movq 0x80(%rbx), %rdi
callq 0x9a8ea
movq 0x88(%rbx), %rdi
callq 0x9a8ea
movq 0x90(%rbx), %rdi
callq 0x9a8ea
movq 0x98(%rbx), %rdi
callq 0x9a8ea
movq 0xa0(%rbx), %rdi
callq 0x9a8ea
movq 0xa8(%rbx), %rdi
callq 0x9a8ea
leaq 0x2b5ad1(%rip), %rsi    # 0x2f4fd0
movq %rbx, %rdi
movl $0xda, %edx
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9b4cb
testb %al, %al
jne 0x3fc16
cmpb $0x0, 0x53(%rbx)
jne 0x3fc12
cmpb $0x1, 0x54(%rbx)
jne 0x3fc16
movb $0x0, 0x52(%rbx)
movq 0x90(%rbx), %rdi
callq 0x9b4cb
movl %eax, %ebp
movq 0x88(%rbx), %rdi
callq 0x9b4cb
testb %bpl, %bpl
je 0x3fc42
testb %al, %al
je 0x3fc4d
movl (%rbx), %eax
cmpl %eax, 0x4(%rbx)
ja 0x3fc4f
jmp 0x3fc61
testb %al, %al
je 0x3fc54
movl 0x4(%rbx), %eax
movl %eax, (%rbx)
jmp 0x3fc61
movl (%rbx), %eax
movl %eax, 0x4(%rbx)
jmp 0x3fc61
movabsq $0x1400000014, %rax     # imm = 0x1400000014
movq %rax, (%rbx)
movq 0xa8(%rbx), %rdi
callq 0x9b4cb
testb %al, %al
jne 0x3fc82
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_O2/genometools[P]genometools/src/tools/gt_repfind.c
// Function: gt_generic_extend_selfmatch_xdrop_with_output
static int gt_generic_extend_selfmatch_xdrop_with_output(
                                           void *info,
                                           const GtGenericEncseq *genericencseq,
                                           GtUword len,
                                           GtUword pos1,
                                           GtUword pos2,
                                           GtError *err)
{
  gt_assert(genericencseq != NULL && genericencseq->hasencseq);
  return gt_rf_xdrop_extend_selfmatch_with_output(info,
                                                  genericencseq->seqptr.encseq,
                                                  len,
                                                  pos1,
                                                  pos2,
                                                  err);
}

// Assembly:
testq %rsi, %rsi
je 0x4089d
cmpb $0x0, (%rsi)
je 0x4089d
movq 0x8(%rsi), %rsi
jmp 0x18ff4a
pushq %rax
movq 0x3f76c3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2a4764(%rip), %rsi    # 0x2e5013
leaq 0x2b4ede(%rip), %rdx    # 0x2f5794
leaq 0x2b4e73(%rip), %rcx    # 0x2f5730
leaq 0x2b470c(%rip), %r8     # 0x2f4fd0
movl $0x212, %r9d            # imm = 0x212
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_repfind.c
// Function: gt_generic_simplegreedyselfmatchoutput
static int gt_generic_simplegreedyselfmatchoutput(
                                           void *processinfo,
                                           const GtGenericEncseq *genericencseq,
                                           GtUword len,
                                           GtUword pos1,
                                           GtUword pos2,
                                           GtError *err)
{
  gt_assert(genericencseq != NULL && genericencseq->hasencseq);
  return gt_rf_greedy_extend_selfmatch_with_output(processinfo,
                                                   genericencseq->seqptr.encseq,
                                                   len,
                                                   pos1,
                                                   pos2,
                                                   err);
}

// Assembly:
testq %rsi, %rsi
je 0x408e9
cmpb $0x0, (%rsi)
je 0x408e9
movq 0x8(%rsi), %rsi
jmp 0x190174
pushq %rax
movq 0x3f7677(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2a4718(%rip), %rsi    # 0x2e5013
leaq 0x2b4e92(%rip), %rdx    # 0x2f5794
leaq 0x2b4e55(%rip), %rcx    # 0x2f575e
leaq 0x2b46c0(%rip), %r8     # 0x2f4fd0
movl $0x223, %r9d            # imm = 0x223
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2b45e0(%rip), %rdx    # 0x2f5860
pushq $0x1
popq %rdi
pushq $0x40
popq %rsi
pushq $0x29
popq %rcx
callq 0x9334a
movq %rax, %rbx
andw $0x0, 0x8(%rax)
callq 0xacb84
movq %rax, 0x10(%rbx)
callq 0xacb84
movq %rax, 0x18(%rbx)
callq 0xacb84
movq %rax, 0x20(%rbx)
callq 0xacb84
movq %rax, 0x30(%rbx)
leaq 0x2b45b3(%rip), %rdi    # 0x2f5874
callq 0xacbd1
movq %rax, 0x28(%rbx)
andl $0x0, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4131c
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xae103
movq 0x18(%rbx), %rdi
callq 0xae103
movq 0x20(%rbx), %rdi
callq 0xae103
movq 0x30(%rbx), %rdi
callq 0xae103
movq 0x28(%rbx), %rdi
callq 0xae103
leaq 0x2b4550(%rip), %rsi    # 0x2f5860
pushq $0x40
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4169a
movl %edi, %edx
cmpl $0x1, %edi
leaq 0x328ef7(%rip), %rax    # 0x36a570
leaq 0x2b9fe9(%rip), %rcx    # 0x2fb669
cmoveq %rax, %rcx
leaq 0x2b43aa(%rip), %rsi    # 0x2f5a35
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
jmp 0x416bb
movq %rsi, %r14
movq 0x28(%rsi), %rdi
callq 0xad1fa
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa45d3
testl %eax, %eax
js 0x41695
movl %eax, 0x38(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2b39f2(%rip), %rsi    # 0x2f5860
pushq $0x10
popq %rdi
movl $0xcf, %edx
callq 0x93160
movq %rax, %rbx
andq $0x0, (%rax)
movq 0x3f6027(%rip), %rax    # 0x437eb0
movq (%rax), %rdx
leaq 0x2a4a41(%rip), %rsi    # 0x2e68d4
movl %ebp, %edi
callq 0x92b50
movq %rax, 0x8(%rbx)
callq 0xaaf34
testb %al, %al
je 0x41ed8
testb %bpl, %bpl
je 0x41ec0
leaq 0x2b3c63(%rip), %rdi    # 0x2f5b16
callq 0xaf4a5
movq %rax, %rdi
movq %rax, (%rbx)
jmp 0x41ed3
callq 0xaf478
movq %rax, (%rbx)
movq %rax, %rdi
callq 0xafc53
movq (%rbx), %rdi
callq 0xaf4d6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x41f0d
movq 0x3f5fbb(%rip), %rax    # 0x437eb0
movq (%rax), %rsi
callq 0xafb49
movq (%rbx), %rdi
callq 0xaf549
movq (%rbx), %rdi
callq 0xafc5b
movq 0x8(%rbx), %rdi
callq 0x92fd0
leaq 0x2b3943(%rip), %rsi    # 0x2f5860
movq %rbx, %rdi
movl $0xec, %edx
popq %rbx
jmp 0x936f9
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x41fa9
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x9a8ea
movq 0x10(%rbx), %rdi
callq 0xae103
leaq 0x2b3bd7(%rip), %rsi    # 0x2f5b74
pushq $0x2d
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x42063
movq %rdi, %r14
leaq 0x2b3bf2(%rip), %rdi    # 0x2f5bb4
leaq 0x2b3bfe(%rip), %rsi    # 0x2f5bc7
callq 0x97df5
movq %rax, %rbx
leaq 0x2ac3cb(%rip), %rdi    # 0x2ee3a3
leaq 0x2b3c1e(%rip), %rsi    # 0x2f5bfd
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x10(%r14), %rdx
leaq 0x2b3c1e(%rip), %rdi    # 0x2f5c1d
leaq 0x2b3c1f(%rip), %rsi    # 0x2f5c25
callq 0x9ad51
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r15, %rdi
callq 0x97db0
movq %rax, 0x8(%r14)
addq $0x4, %r14
leaq 0x3263b6(%rip), %rdi    # 0x3683e6
leaq 0x2b3c0d(%rip), %rsi    # 0x2f5c44
pushq $-0x1
popq %rcx
movq %r14, %rdx
callq 0x9ab66
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %edx, %esi
callq 0x98c6b
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x3f5efe(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2a2f9f(%rip), %rsi    # 0x2e5013
leaq 0x3065d8(%rip), %rdx    # 0x348653
leaq 0x2b3b0f(%rip), %rcx    # 0x2f5b91
leaq 0x2b3aeb(%rip), %r8     # 0x2f5b74
pushq $0x35
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x420b3
movq %rdx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x4211b
testq %r14, %r14
je 0x420c7
cmpl $0x1, %ebx
jne 0x420f1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3f5e9a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2a2f3b(%rip), %rsi    # 0x2e5013
leaq 0x306574(%rip), %rdx    # 0x348653
leaq 0x2b3b8f(%rip), %rcx    # 0x2f5c75
leaq 0x2b3a87(%rip), %r8     # 0x2f5b74
pushq $0x5a
jmp 0x42143
movq 0x3f5e70(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2a2f11(%rip), %rsi    # 0x2e5013
leaq 0x2ab334(%rip), %rdx    # 0x2ed43d
leaq 0x2b3b65(%rip), %rcx    # 0x2f5c75
leaq 0x2b3a5d(%rip), %r8     # 0x2f5b74
pushq $0x5b
jmp 0x42143
movq 0x3f5e46(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2a2ee7(%rip), %rsi    # 0x2e5013
leaq 0x2a308c(%rip), %rdx    # 0x2e51bf
leaq 0x2b3b3b(%rip), %rcx    # 0x2f5c75
leaq 0x2b3a33(%rip), %r8     # 0x2f5b74
pushq $0x59
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x424ca
movq %rdi, %r14
leaq 0x2b38e9(%rip), %rdi    # 0x2f5cfd
leaq 0x2b3900(%rip), %rsi    # 0x2f5d1b
callq 0x97df5
movq %rax, %rbx
leaq 0x1(%r14), %rdx
leaq 0x2b391d(%rip), %rdi    # 0x2f5d4b
leaq 0x2b391f(%rip), %rsi    # 0x2f5d54
pushq $0x1
popq %rbp
movl %ebp, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x3(%r14), %rdx
leaq 0x347e1c(%rip), %rdi    # 0x38a271
leaq 0x2b3916(%rip), %rsi    # 0x2f5d72
movl %ebp, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x2b3916(%rip), %rdi    # 0x2f5d8b
leaq 0x2b3917(%rip), %rsi    # 0x2f5d93
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
addq $0x2, %r14
leaq 0x2b391c(%rip), %rdi    # 0x2f5db8
leaq 0x2b3920(%rip), %rsi    # 0x2f5dc3
movq %r14, %rdx
movl %ebp, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %rbx, %rdi
movl %ebp, %esi
callq 0x98be7
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x3f5a97(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2a2b38(%rip), %rsi    # 0x2e5013
leaq 0x306171(%rip), %rdx    # 0x348653
leaq 0x2b37f1(%rip), %rcx    # 0x2f5cda
leaq 0x2b37cd(%rip), %r8     # 0x2f5cbd
pushq $0x30
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2b3658(%rip), %rdx    # 0x2f5e68
pushq $0x1
popq %rdi
pushq $0x6c
popq %rcx
movl $0x138, %esi            # imm = 0x138
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, (%rbx)
callq 0xacb84
movq %rax, 0x8(%rbx)
callq 0xacb84
movq %rax, 0x58(%rbx)
callq 0xacb84
movq %rax, 0x68(%rbx)
callq 0xacb84
movq %rax, 0x60(%rbx)
callq 0xacb84
movq %rax, 0x70(%rbx)
callq 0xacb84
movq %rax, 0xb0(%rbx)
callq 0xacb84
movq %rax, 0xb8(%rbx)
callq 0xacb84
movq %rax, 0xc0(%rbx)
callq 0xae154
movq %rax, 0xe8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4295c
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xae103
movq 0x8(%rbx), %rdi
callq 0xae103
movq 0x58(%rbx), %rdi
callq 0xae103
movq 0x68(%rbx), %rdi
callq 0xae103
movq 0x60(%rbx), %rdi
callq 0xae103
movq 0x70(%rbx), %rdi
callq 0xae103
movq 0xb0(%rbx), %rdi
callq 0xae103
movq 0xb8(%rbx), %rdi
callq 0xae103
movq 0xc0(%rbx), %rdi
callq 0xae103
movq 0x128(%rbx), %rdi
callq 0x9a8ea
movq 0x110(%rbx), %rdi
callq 0x9a8ea
movq 0x130(%rbx), %rdi
callq 0x9a8ea
movq 0x108(%rbx), %rdi
callq 0x9a8ea
movq 0x118(%rbx), %rdi
callq 0x9a8ea
movq 0x120(%rbx), %rdi
callq 0x9a8ea
movq 0xe8(%rbx), %rdi
callq 0xae662
leaq 0x2b351a(%rip), %rsi    # 0x2f5e68
movq %rbx, %rdi
movl $0x8e, %edx
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2b2888(%rip), %rdx    # 0x2f716a
pushq $0x1
popq %rdi
pushq $0x44
popq %rcx
movl $0xb0, %esi
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x8(%rbx)
callq 0xacb84
movq %rax, 0x10(%rbx)
callq 0xacb84
movq %rax, 0x18(%rbx)
pushq $0x4
popq %rbp
movl %ebp, 0x48(%rbx)
callq 0xacb84
movq %rax, 0x20(%rbx)
movl %ebp, 0x4c(%rbx)
callq 0x9b6b4
movq %rax, 0x88(%rbx)
callq 0xae154
movq %rax, 0x98(%rbx)
callq 0xacb84
movq %rax, 0xa0(%rbx)
callq 0xacb84
movq %rax, 0xa8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x449d8
pushq %rbx
movq %rdi, %rbx
movq 0x90(%rdi), %rdi
callq 0x8da06
movq 0x88(%rbx), %rdi
callq 0x9ba24
movq 0x20(%rbx), %rdi
callq 0xae103
movq 0x18(%rbx), %rdi
callq 0xae103
movq 0x10(%rbx), %rdi
callq 0xae103
movq 0x8(%rbx), %rdi
callq 0xae103
movq 0x98(%rbx), %rdi
callq 0xae662
movq 0xa0(%rbx), %rdi
callq 0xae103
movq 0xa8(%rbx), %rdi
callq 0xae103
leaq 0x2b279e(%rip), %rsi    # 0x2f716a
pushq $0x5f
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x44dd1
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x44e4b
testq %r14, %r14
je 0x44e1d
movq 0x18(%r14), %rdi
leaq 0x48(%r14), %rsi
leaq 0x2b1a01(%rip), %rdx    # 0x2f67e6
movq %rbx, %rcx
callq 0x450ef
testl %eax, %eax
je 0x44dfc
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x20(%r14), %rdi
addq $0x4c, %r14
leaq 0x2edabf(%rip), %rdx    # 0x3328ca
movq %r14, %rsi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x450ef
movq 0x3f3144(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2a01e5(%rip), %rsi    # 0x2e5013
leaq 0x30381e(%rip), %rdx    # 0x348653
leaq 0x2b2a52(%rip), %rcx    # 0x2f788e
leaq 0x2b2327(%rip), %r8     # 0x2f716a
movl $0x12e, %r9d            # imm = 0x12E
jmp 0x44e77
movq 0x3f3116(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2a01b7(%rip), %rsi    # 0x2e5013
leaq 0x2a035c(%rip), %rdx    # 0x2e51bf
leaq 0x2b2a24(%rip), %rcx    # 0x2f788e
leaq 0x2b22f9(%rip), %r8     # 0x2f716a
movl $0x12d, %r9d            # imm = 0x12D
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x45117
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x45180
movq %r12, %rdi
callq 0xad289
xorl %ebp, %ebp
testq %rax, %rax
je 0x4516f
movq %r12, %rdi
callq 0xad1fa
movsbl (%rax), %edi
callq 0xae6cc
movl %eax, %r13d
movq %r12, %rdi
callq 0xad289
cmpq $0x2, %rax
setb %al
cmpl $0x4, %r13d
setne %cl
testb %cl, %al
je 0x45158
movl %r13d, (%r15)
jmp 0x4516f
leaq 0x2b275f(%rip), %rsi    # 0x2f78be
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3f2de1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29fe82(%rip), %rsi    # 0x2e5013
leaq 0x2a0027(%rip), %rdx    # 0x2e51bf
leaq 0x2b2709(%rip), %rcx    # 0x2f78a8
leaq 0x2b1fc4(%rip), %r8     # 0x2f716a
movl $0x119, %r9d            # imm = 0x119
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2b26c5(%rip), %rdx    # 0x2f7935
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
pushq $0x2c
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0x9b6b4
movq %rax, 0x28(%rbx)
callq 0xacb84
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x452cf
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x8da06
movq 0x28(%rbx), %rdi
callq 0x9ba24
movq 0x20(%rbx), %rdi
callq 0xae103
leaq 0x2b2672(%rip), %rsi    # 0x2f7935
pushq $0x39
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4557c
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x45628
testq %r14, %r14
je 0x455fa
movq 0x8(%r14), %rax
cmpq $-0x1, %rax
je 0x45599
cmpl $0x1, %ebp
jle 0x455b8
leaq 0x2dfcf7(%rip), %rdx    # 0x32528e
jmp 0x455af
movq 0x10(%r14), %rax
cmpq $-0x1, %rax
je 0x455dd
cmpl $0x2, %ebp
jl 0x455c1
leaq 0x31c28e(%rip), %rdx    # 0x36183d
leaq 0x2b26e8(%rip), %rsi    # 0x2f7c9e
jmp 0x455e8
testq %rax, %rax
je 0x455cf
movq 0x10(%r14), %rax
testq %rax, %rax
jne 0x455dd
leaq 0x31c270(%rip), %rdx    # 0x36183d
jmp 0x455d6
leaq 0x2dfcb8(%rip), %rdx    # 0x32528e
cmpb $0x0, 0x5(%r14)
je 0x455e1
xorl %eax, %eax
jmp 0x455f5
leaq 0x2b26f7(%rip), %rsi    # 0x2f7cdf
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x3f2967(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29fa08(%rip), %rsi    # 0x2e5013
leaq 0x303041(%rip), %rdx    # 0x348653
leaq 0x2b266e(%rip), %rcx    # 0x2f7c87
leaq 0x2b2315(%rip), %r8     # 0x2f7935
movl $0xa8, %r9d
jmp 0x45654
movq 0x3f2939(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29f9da(%rip), %rsi    # 0x2e5013
leaq 0x29fb7f(%rip), %rdx    # 0x2e51bf
leaq 0x2b2640(%rip), %rcx    # 0x2f7c87
leaq 0x2b22e7(%rip), %r8     # 0x2f7935
movl $0xa7, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2b239c(%rip), %rdx    # 0x2f7e08
pushq $0x1
popq %rdi
pushq $0x78
popq %rsi
pushq $0x4f
popq %rcx
callq 0x9334a
movq %rax, %rbx
movb $0x0, 0x5(%rax)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x18(%rbx)
callq 0xacb84
movq %rax, 0x38(%rbx)
callq 0xacb84
movq %rax, 0x48(%rbx)
callq 0xacb84
movq %rax, 0x40(%rbx)
andq $0x0, 0x30(%rbx)
callq 0xae154
movq %rax, 0x58(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x45b06
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0xae103
movq 0x48(%rbx), %rdi
callq 0xae103
movq 0x50(%rbx), %rdi
callq 0x9a8ea
movq 0x40(%rbx), %rdi
callq 0xae103
movq 0x58(%rbx), %rdi
callq 0xae662
leaq 0x2b230e(%rip), %rsi    # 0x2f7e08
pushq $0x64
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
testq %rdx, %rdx
je 0x4601a
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x4606d
movq 0x50(%r14), %rdi
callq 0x9b4cb
pushq $-0x1
popq %rbp
testb %al, %al
je 0x46045
leaq 0x30(%r14), %rdi
movq 0x40(%r14), %rdx
leaq 0x33eeef(%rip), %rsi    # 0x384f28
movq %rbx, %rcx
callq 0x9b50d
testl %eax, %eax
jne 0x46066
xorl %eax, %eax
cmpb $0x1, 0x8(%r14)
jne 0x46068
cmpl $0x1, 0x28(%r14)
je 0x46068
leaq 0x2b206a(%rip), %rsi    # 0x2f80c6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x3f1ef4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29ef95(%rip), %rsi    # 0x2e5013
leaq 0x29f13a(%rip), %rdx    # 0x2e51bf
leaq 0x2b201c(%rip), %rcx    # 0x2f80a8
leaq 0x2b1d75(%rip), %r8     # 0x2f7e08
movl $0x139, %r9d            # imm = 0x139
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x46f17
movq %rsi, %rbx
movl 0x24(%rdi), %eax
testl %eax, %eax
je 0x46ec6
movl %eax, (%rbx)
cmpl 0xc(%rdi), %eax
jae 0x46ee3
cmpl $0x21, %eax
jb 0x46edf
leaq 0x2a3d0e(%rip), %rsi    # 0x2eabc3
pushq $0x20
popq %rcx
movq %rdx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x89dbb
jmp 0x46ef6
movl 0xc(%rdi), %eax
cmpl $0x1, %eax
jbe 0x46f73
decl %eax
cmpl $0x20, %eax
pushq $0x20
popq %rcx
cmovbl %eax, %ecx
movl %ecx, (%rbx)
xorl %ebp, %ebp
jmp 0x46ef9
leaq 0x2b15b9(%rip), %rsi    # 0x2f84a3
movq %rdx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x89dbb
movb $0x1, %bpl
movl (%rbx), %esi
leaq 0x2b1606(%rip), %rdi    # 0x2f8508
xorl %eax, %eax
callq 0x92a82
cmpl $0x0, (%rbx)
je 0x46f45
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x3f104a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29e0eb(%rip), %rsi    # 0x2e5013
leaq 0x2a3c4a(%rip), %rdx    # 0x2eab79
leaq 0x2b154c(%rip), %rcx    # 0x2f8482
leaq 0x2b0ecb(%rip), %r8     # 0x2f7e08
movl $0x115, %r9d            # imm = 0x115
jmp 0x46f9f
movq 0x3f101c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29e0bd(%rip), %rsi    # 0x2e5013
leaq 0x2a3c9f(%rip), %rdx    # 0x2eabfc
leaq 0x2b151e(%rip), %rcx    # 0x2f8482
leaq 0x2b0e9d(%rip), %r8     # 0x2f7e08
movl $0x12e, %r9d            # imm = 0x12E
jmp 0x46f9f
movq 0x3f0fee(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29e08f(%rip), %rsi    # 0x2e5013
leaq 0x2b1559(%rip), %rdx    # 0x2f84e4
leaq 0x2b14f0(%rip), %rcx    # 0x2f8482
leaq 0x2b0e6f(%rip), %r8     # 0x2f7e08
movl $0x129, %r9d            # imm = 0x129
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x47023
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x8da06
movq 0x8(%rbx), %rdi
callq 0x9ba24
leaq 0x2b1596(%rip), %rsi    # 0x2f85ad
pushq $0x3b
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4753d
movq %r12, %rdi
callq 0x89eb7
testb %al, %al
jne 0x475e4
callq 0x6ca6c
movq %rax, %rbx
subl %r15d, %ebp
movslq %r15d, %rax
leaq (%r14,%rax,8), %rsi
movl %ebp, %edi
callq 0xdeebd
movq %rax, %r14
movq %rbx, %rdi
callq 0xbeebc
movq %r14, %rdi
movq %rax, %rsi
callq 0x12bf59
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x102b93
movl %eax, %ebp
testl %eax, %eax
jne 0x475bb
movq %rbx, %rdi
callq 0x6cbf8
movq %rax, %r12
xorl %r13d, %r13d
movq %r12, %rdi
callq 0xae61c
cmpq %rax, %r13
jae 0x475b3
movq %r12, %rdi
movq %r13, %rsi
callq 0xae386
movq %rax, %rdi
callq 0x17b60
incq %r13
jmp 0x4758e
movq %r12, %rdi
callq 0xae662
movq %r15, %rdi
callq 0x10297b
movq %r14, %rdi
callq 0x10297b
movq %rbx, %rdi
callq 0x6cf6b
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3f097d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29da1e(%rip), %rsi    # 0x2e5013
leaq 0x29dbc3(%rip), %rdx    # 0x2e51bf
leaq 0x2b122d(%rip), %rcx    # 0x2f8830
leaq 0x2b1237(%rip), %r8     # 0x2f8841
pushq $0x2a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2b1210(%rip), %rsi    # 0x2f8857
pushq $0x10
popq %rdi
pushq $0x1f
popq %rdx
callq 0x93160
movq %rax, %rbx
callq 0xacb84
movq %rax, (%rbx)
callq 0xae154
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x47726
movq %rdi, %r14
leaq 0x2b11e6(%rip), %rdi    # 0x2f8891
leaq 0x2b11fe(%rip), %rsi    # 0x2f88b0
callq 0x97df5
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x2be399(%rip), %rdi    # 0x305a5d
leaq 0x2b124e(%rip), %rsi    # 0x2f8919
xorl %ecx, %ecx
callq 0x9ad12
movq %rax, %r15
movq %rax, %rdi
callq 0x9b445
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
movq 0x8(%r14), %rdx
leaq 0x2ce116(%rip), %rdi    # 0x315809
leaq 0x2b1262(%rip), %rsi    # 0x2f895c
callq 0x9ad7e
movq %rax, %r14
movq %rax, %rdi
callq 0x9b445
movq %r14, %rdi
callq 0x9ae37
movq %rbx, %rdi
movq %r14, %rsi
callq 0x97f31
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x3f083b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29d8dc(%rip), %rsi    # 0x2e5013
leaq 0x300f15(%rip), %rdx    # 0x348653
leaq 0x2b112c(%rip), %rcx    # 0x2f8871
leaq 0x2b110b(%rip), %r8     # 0x2f8857
pushq $0x32
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_seqlensort.c
// Function: gt_seqlensort_runner
static int gt_seqlensort_runner(GT_UNUSED int argc,
                                GT_UNUSED const char **argv,
                                GT_UNUSED int parsed_args,
                                void *tool_arguments,
                                GtError *err)
{
  GtSeqlensortArguments *arguments = tool_arguments;
  int had_err = 0;
  GtUword i;
  GtReads2Twobit *r2t = NULL;

  gt_error_check(err);
  gt_assert(arguments);

  if (gt_str_length(arguments->indexname) == 0)
  {
    gt_str_append_cstr(arguments->indexname,
                       gt_str_array_get(arguments->db, 0));
  }

  r2t = gt_reads2twobit_new(arguments->indexname);

  for (i = 0; i < gt_str_array_size(arguments->db) && !had_err; i++)
    had_err = gt_reads2twobit_add_library(r2t,
                                          gt_str_array_get_str(arguments->db,
                                                               i),
                                          err);

  if (!had_err)
    had_err = gt_reads2twobit_encode(r2t, err);

  if (!had_err)
  {
    if (gt_reads2twobit_seqlen_eqlen(r2t) == 0)
    {
      gt_reads2twobit_sort(r2t, gt_seqlensort_cmp,
                           gt_reads2twobit_export_seppos(r2t));
    }
    had_err = gt_reads2twobit_write_encseq(r2t, err);
  }

  gt_reads2twobit_delete(r2t);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
testq %r8, %r8
je 0x47780
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x47880
testq %r15, %r15
je 0x47856
movq (%r15), %rdi
callq 0xad289
testq %rax, %rax
jne 0x477af
movq (%r15), %r14
movq 0x8(%r15), %rdi
xorl %esi, %esi
callq 0xae386
movq %r14, %rdi
movq %rax, %rsi
callq 0xacbfb
movq (%r15), %rdi
callq 0x18875c
movq %rax, %r14
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%r15), %rdi
callq 0xae61c
cmpq %rax, %r13
jae 0x477f5
testl %r12d, %r12d
jne 0x477f5
movq 0x8(%r15), %rdi
movq %r13, %rsi
callq 0xae3f2
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x188a9d
movl %eax, %r12d
incq %r13
jmp 0x477c0
testl %r12d, %r12d
jne 0x47841
movq %r14, %rdi
movq %rbx, %rsi
callq 0x188e84
movl %eax, %r12d
testl %eax, %eax
jne 0x47841
movq %r14, %rdi
callq 0x18bc9e
testq %rax, %rax
jne 0x47833
movq %r14, %rdi
callq 0x18bb92
leaq 0x8e(%rip), %rsi        # 0x478b6
movq %r14, %rdi
movq %rax, %rdx
callq 0x18b8bd
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18b4d6
movl %eax, %r12d
movq %r14, %rdi
callq 0x18886e
movl %r12d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x3f070b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29d7ac(%rip), %rsi    # 0x2e5013
leaq 0x300de5(%rip), %rdx    # 0x348653
leaq 0x2b1108(%rip), %rcx    # 0x2f897d
leaq 0x2b0fdb(%rip), %r8     # 0x2f8857
pushq $0x69
jmp 0x478a8
movq 0x3f06e1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29d782(%rip), %rsi    # 0x2e5013
leaq 0x29d927(%rip), %rdx    # 0x2e51bf
leaq 0x2b10de(%rip), %rcx    # 0x2f897d
leaq 0x2b0fb1(%rip), %r8     # 0x2f8857
pushq $0x68
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390