LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_sfxmap.c
// Function: gt_sfxmap_showcomparisonfailureESA
static void gt_sfxmap_showcomparisonfailureESA(const char *filename,
                                     int line,
                                     const char *where,
                                     const GtEncseq *encseq,
                                     GtReadmode readmode,
                                     const ESASuffixptr *suftab,
                                     GtUword depth,
                                     GtUword idx1,
                                     GtUword idx2,
                                     int cmp,
                                     GtUword maxlcp)
{
  fprintf(stderr,"ERROR: file \"%s\", line %d: ",filename,line);
  fprintf(stderr,"%s("GT_WU" vs "GT_WU""
                 " "GT_WU"=\"",
                       where,
                       idx1,
                       idx2,
                       ESASUFFIXPTRGET(suftab,idx1));
  gt_encseq_showatstartposwithdepth(stderr,encseq,readmode,
                                    ESASUFFIXPTRGET(suftab,idx1),depth);
  fprintf(stderr,"\",\"");
  gt_encseq_showatstartposwithdepth(stderr,encseq,readmode,
                                    ESASUFFIXPTRGET(suftab,idx2),depth);
  fprintf(stderr,"\"="GT_WU")=%d with maxlcp "GT_WU"\n",
          ESASUFFIXPTRGET(suftab,idx2),cmp,maxlcp);
}

// Assembly:
subq $0x38, %rsp
movq 0x60(%rsp), %rax
movl 0x58(%rsp), %eax
movq 0x50(%rsp), %rax
movq 0x48(%rsp), %rax
movq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movq %r9, 0x8(%rsp)
movq 0x5cef40(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x30(%rsp), %rdx
movl 0x2c(%rsp), %ecx
leaq 0x4bdfe9(%rip), %rsi    # 0x52b05c
movb $0x0, %al
callq 0x199f0
movq 0x5cef1f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x50(%rsp), %r8
movq 0x8(%rsp), %rax
movq 0x48(%rsp), %rsi
movq (%rax,%rsi,8), %r9
leaq 0x4bdfd0(%rip), %rsi    # 0x52b078
movb $0x0, %al
callq 0x199f0
movq 0x5ceeea(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
movq 0x8(%rsp), %rax
movq 0x48(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x40(%rsp), %r8
callq 0xb5850
movq 0x5ceebf(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4bdfa1(%rip), %rsi    # 0x52b08c
movb $0x0, %al
callq 0x199f0
movq 0x5ceea7(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
movq 0x8(%rsp), %rax
movq 0x50(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x40(%rsp), %r8
callq 0xb5850
movq 0x5cee7c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x50(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movl 0x58(%rsp), %ecx
movq 0x60(%rsp), %r8
leaq 0x4bdf4b(%rip), %rsi    # 0x52b090
movb $0x0, %al
callq 0x199f0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_sfxmap.c
// Function: gt_sfxmap_sortmaxdepth_processunsortedrange
static void gt_sfxmap_sortmaxdepth_processunsortedrange(void *voiddcov,
                                              GT_UNUSED GtSuffixsortspace *sssp,
                                              GtUword subbucketleft,
                                              GtUword width,
                                              GT_UNUSED GtUword depth)
{
  Checkunsortedrangeinfo *curi = voiddcov;

  gt_checkifprefixesareidentical(__FILE__,
                                 __LINE__,
                                 curi->encseq,
                                 curi->readmode,
                                 curi->sssp,
                                 subbucketleft,
                                 width,
                                 (GtUword) curi->sortmaxdepth);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdx
movq 0x18(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %r8
movq 0x30(%rsp), %r9
movq 0x28(%rsp), %r10
movq 0x18(%rsp), %rax
movl 0xc(%rax), %eax
leaq 0x4bd0e1(%rip), %rdi    # 0x52a5ea
movl $0x522, %esi            # imm = 0x522
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2eb290
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_show_seedext.c
// Function: gt_show_seedext_arguments_new
static void* gt_show_seedext_arguments_new(void)
{
  GtShowSeedextArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->matchfilename = gt_str_new();
  arguments->display_args = gt_str_array_new();
  return arguments;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x18, %esi
leaq 0x4bdf13(%rip), %rdx    # 0x52b5f5
movl $0x32, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_show_seedext.c
// Function: gt_show_seedext_arguments_delete
static void gt_show_seedext_arguments_delete(void *tool_arguments)
{
  GtShowSeedextArguments *arguments = tool_arguments;
  if (arguments != NULL) {
    gt_str_array_delete(arguments->display_args);
    gt_str_delete(arguments->matchfilename);
    gt_free(arguments);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x6d76d
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4bde92(%rip), %rsi    # 0x52b5f5
movl $0x3e, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_show_seedext.c
// Function: gt_show_seedext_arguments_check
static int gt_show_seedext_arguments_check(GT_UNUSED int rest_argc,
                                           void *tool_arguments,
                                           GtError *err)
{
  GtShowSeedextArguments *arguments = tool_arguments;
  int had_err = 0;

  gt_error_check(err);
  gt_assert(arguments != NULL);
  if (arguments->matchfilename == NULL ||
      gt_str_length(arguments->matchfilename) == 0)
  {
    gt_error_set(err,"option -f requires a file name");
    had_err = -1;
  }
  return had_err;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x6d9c4
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x6d98c
jmp 0x6d9c4
movq 0x5ce60d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4a8676(%rip), %rsi    # 0x516013
leaq 0x4a881b(%rip), %rdx    # 0x5161bf
leaq 0x4bddb1(%rip), %rcx    # 0x52b75c
leaq 0x4bdc43(%rip), %r8     # 0x52b5f5
movl $0x84, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x6d9c6
jmp 0x6d9c8
cmpq $0x0, 0x8(%rsp)
jne 0x6da08
movq 0x5ce5c9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4a8632(%rip), %rsi    # 0x516013
leaq 0x4a989c(%rip), %rdx    # 0x517284
leaq 0x4bdd6d(%rip), %rcx    # 0x52b75c
leaq 0x4bdbff(%rip), %r8     # 0x52b5f5
movl $0x85, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x6da0a
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6da2a
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11dfa0
cmpq $0x0, %rax
jne 0x6da45
movq 0x10(%rsp), %rdi
leaq 0x4bdd46(%rip), %rsi    # 0x52b77c
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_shredder.c
// Function: gt_shredder_arguments_delete
static void gt_shredder_arguments_delete(void *tool_arguments)
{
  ShredderArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x6e32d
jmp 0x6e35e
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rdi
leaq 0x4bd48d(%rip), %rsi    # 0x52b7e1
movl $0x35, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_shredder.c
// Function: gt_shredder_arguments_check
static int gt_shredder_arguments_check(GT_UNUSED int rest_argc,
                                       void *tool_arguments, GtError *err)
{
  ShredderArguments *arguments = tool_arguments;
  gt_error_check(err);
  gt_assert(arguments);
  if (arguments->minlength > arguments->maxlength) {
    gt_error_set(err, "-minlength must be <= than -maxlength");
    return -1;
  }
  return 0;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x6e5ec
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x6e5b4
jmp 0x6e5ec
movq 0x5cd9e5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4a7a4e(%rip), %rsi    # 0x516013
leaq 0x4a7bf3(%rip), %rdx    # 0x5161bf
leaq 0x4bd416(%rip), %rcx    # 0x52b9e9
leaq 0x4bd207(%rip), %r8     # 0x52b7e1
movl $0x64, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x6e5ee
jmp 0x6e5f0
cmpq $0x0, 0x8(%rsp)
jne 0x6e630
movq 0x5cd9a1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4a7a0a(%rip), %rsi    # 0x516013
leaq 0x50c54f(%rip), %rdx    # 0x57ab5f
leaq 0x4bd3d2(%rip), %rcx    # 0x52b9e9
leaq 0x4bd1c3(%rip), %r8     # 0x52b7e1
movl $0x65, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x6e632
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jbe 0x6e663
movq 0x10(%rsp), %rdi
leaq 0x4bd3b3(%rip), %rsi    # 0x52ba05
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x6e66b
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_shulen.c
// Function: gt_shulengthdist_arguments_new
static void *gt_shulengthdist_arguments_new(void)
{
  Shulengthoptions *arguments;

  arguments = gt_malloc(sizeof (*arguments));
  arguments->indexname = gt_str_new();
  arguments->queryfilenames = gt_str_array_new();
  return arguments;
}

// Assembly:
pushq %rax
movl $0x18, %edi
leaq 0x4bd0c8(%rip), %rsi    # 0x52ba55
movl $0x72, %edx
callq 0xe80f0
movq %rax, (%rsp)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_shulen.c
// Function: gt_shulengthdist_arguments_delete
static void gt_shulengthdist_arguments_delete(void *tool_arguments)
{
  Shulengthoptions *arguments = tool_arguments;

  if (!arguments)
  {
    return;
  }
  gt_str_delete(arguments->indexname);
  gt_str_array_delete(arguments->queryfilenames);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x6e9ed
jmp 0x6ea1f
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rdi
leaq 0x4bd040(%rip), %rsi    # 0x52ba55
movl $0x82, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_shulen.c
// Function: gt_shulengthdist_option_parser_new
static GtOptionParser *gt_shulengthdist_option_parser_new(void *tool_arguments)
{
  GtOptionParser *op;
  GtOption *option, *queryoption, *scanoption;
  Shulengthoptions *arguments = tool_arguments;

  op = gt_option_parser_new("[options] -ii indexname",
                            "Compute distribution of pairwise "
                            "shustring lengths.");
  gt_option_parser_set_mail_address(op,"<kurtz@zbh.uni-hamburg.de>");

  option = gt_option_new_string("ii",
                                "Specify input index",
                                arguments->indexname, NULL);
  gt_option_parser_add_option(op, option);
  gt_option_is_mandatory(option);

  scanoption = gt_option_new_bool("scan","scan index rather than mapping "
                                  "it to main memory",
                                  &arguments->scanfile,
                                  false);
  gt_option_parser_add_option(op, scanoption);

  queryoption = gt_option_new_filename_array("q",
                                             "Specify query files",
                                             arguments->queryfilenames);
  gt_option_is_development_option(queryoption);
  gt_option_parser_add_option(op, queryoption);

  option = gt_option_new_bool("v",
                              "be verbose ",
                              &arguments->beverbose,
                              false);
  gt_option_parser_add_option(op, option);

  gt_option_exclude(queryoption,scanoption);
  return op;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x4b48d4(%rip), %rdi    # 0x52331e
leaq 0x4bd01a(%rip), %rsi    # 0x52ba6b
callq 0xf1420
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x4a887d(%rip), %rsi    # 0x5172e4
callq 0xf1a10
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
leaq 0x517851(%rip), %rdi    # 0x5862cd
leaq 0x4b497f(%rip), %rsi    # 0x523402
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf1600
movq 0x20(%rsp), %rdi
callq 0xf6ca0
movq 0x8(%rsp), %rdx
leaq 0x4afaa0(%rip), %rdi    # 0x51e556
leaq 0x4bcfe2(%rip), %rsi    # 0x52ba9f
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf1600
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdx
leaq 0x4ea2d7(%rip), %rdi    # 0x558dbf
leaq 0x4b7b76(%rip), %rsi    # 0x526665
callq 0xf6b00
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xf7040
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xf1600
movq 0x8(%rsp), %rdx
addq $0x1, %rdx
leaq 0x4f3501(%rip), %rdi    # 0x562023
leaq 0x4bcfa7(%rip), %rsi    # 0x52bad0
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf7320
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_shulen.c
// Function: callmultishulengthdist
static int callmultishulengthdist(const char *indexname,
                                  bool scanfile,
                                  GtLogger *logger,
                                  GtError *err)
{
  bool haserr = false;
  Sequentialsuffixarrayreader *ssar;

  gt_error_check(err);
  ssar = gt_newSequentialsuffixarrayreaderfromfile(indexname,
                                                   SARR_LCPTAB |
                                                   SARR_SUFTAB |
                                                   SARR_ESQTAB,
                                                   scanfile,
                                                   logger,
                                                   err);
  if (ssar == NULL)
  {
    haserr = true;
  }
  if (!haserr)
  {
    if (gt_multiesa2shulengthdist_print(ssar,
                                  gt_encseqSequentialsuffixarrayreader(ssar),
                                  err) != 0)
    {
      haserr = true;
    }
  }
  if (ssar != NULL)
  {
    gt_freeSequentialsuffixarrayreader(&ssar);
  }
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movb $0x0, 0x17(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x6ed81
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x6ed49
jmp 0x6ed81
movq 0x5cd250(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4a72b9(%rip), %rsi    # 0x516013
leaq 0x4a745e(%rip), %rdx    # 0x5161bf
leaq 0x4bcd8c(%rip), %rcx    # 0x52baf4
leaq 0x4bcce6(%rip), %r8     # 0x52ba55
movl $0x2e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x6ed83
movq 0x30(%rsp), %rdi
movb 0x2f(%rsp), %al
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movl $0x7, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0x23b3e0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x6edb7
movb $0x1, 0x17(%rsp)
testb $0x1, 0x17(%rsp)
jne 0x6edee
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x23bd50
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x18(%rsp), %rdx
callq 0x23c160
cmpl $0x0, %eax
je 0x6edec
movb $0x1, 0x17(%rsp)
jmp 0x6edee
cmpq $0x0, 0x8(%rsp)
je 0x6ee00
leaq 0x8(%rsp), %rdi
callq 0x23b5e0
movb 0x17(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_shulen.c
// Function: callpairswisesshulendistdist
static int callpairswisesshulendistdist(const char *indexname,
                                        const GtStrArray *queryfilenames,
                                        GtLogger *logger,
                                        GtError *err)
{
  bool haserr = false;
  Suffixarray suffixarray;

  if (gt_mapsuffixarray(&suffixarray,
                        SARR_SUFTAB |
                        SARR_ESQTAB,
                        indexname,
                        logger,
                        err) != 0)
  {
    haserr = true;
  }
  if (!haserr)
  {
    GtUword totalgmatchlength = 0;

    if (gt_esa2shulengthqueryfiles(&totalgmatchlength,
                                   &suffixarray,
                                   queryfilenames,
                                   err) != 0)
    {
      haserr = true;
    } else
    {
      printf(""GT_WU"\n",totalgmatchlength);
    }
  }
  gt_freesuffixarray(&suffixarray);
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movq %rdx, 0x120(%rsp)
movq %rcx, 0x118(%rsp)
movb $0x0, 0x117(%rsp)
movq 0x130(%rsp), %rdx
movq 0x120(%rsp), %rcx
movq 0x118(%rsp), %r8
leaq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x233e00
cmpl $0x0, %eax
je 0x6ee83
movb $0x1, 0x117(%rsp)
testb $0x1, 0x117(%rsp)
jne 0x6eed9
movq $0x0, 0x8(%rsp)
movq 0x128(%rsp), %rdx
movq 0x118(%rsp), %rcx
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x23d580
cmpl $0x0, %eax
je 0x6eec4
movb $0x1, 0x117(%rsp)
jmp 0x6eed7
movq 0x8(%rsp), %rsi
leaq 0x4b2bd6(%rip), %rdi    # 0x521aa6
movb $0x0, %al
callq 0x19070
jmp 0x6eed9
leaq 0x10(%rsp), %rdi
callq 0x233320
movb 0x117(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x138, %rsp            # imm = 0x138
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_simreads.c
// Function: gt_simreads_arguments_new
static void* gt_simreads_arguments_new(void)
{
  GtSimreadsArguments *arguments = gt_calloc((size_t)1, sizeof *arguments);
  arguments->ofi = gt_output_file_info_new();
  arguments->distlen_filename = gt_str_new();
  arguments->distlen_file = NULL;
  arguments->dsfilename = gt_str_new();
  arguments->dlfilename = gt_str_new();
  return arguments;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x58, %esi
leaq 0x4bcbc9(%rip), %rdx    # 0x52bb0b
movl $0x2f, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0xf7d20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x48(%rax)
movq (%rsp), %rax
movq $0x0, 0x50(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x40(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_simreads.c
// Function: gt_simreads_arguments_delete
static void gt_simreads_arguments_delete(void *tool_arguments)
{
  GtSimreadsArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  if (arguments->distlen_file != NULL)
    gt_fa_fclose(arguments->distlen_file);
  gt_str_delete(arguments->distlen_filename);
  gt_str_delete(arguments->dsfilename);
  gt_str_delete(arguments->dlfilename);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x6efcd
jmp 0x6f043
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x6f003
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0xd9390
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4bcad2(%rip), %rsi    # 0x52bb0b
movl $0x43, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_simreads.c
// Function: gt_simreads_readlen_from_dist
static GtUword gt_simreads_readlen_from_dist(
    const GtSimreadsDistvalue *dist, const GtUword value,
    const GtUword nofvalues)
{
  GtUword l = 0, r = nofvalues - 1, m = r >> 1;
  while (value != dist[m].value)
  {
    if (value < dist[m].value)
    {
      gt_assert(l <= r);
      if (m == 0 || value > dist[m - 1].value)
        return dist[m].length;
      else
        r = m - 1;
    }
    else
    {
      gt_assert(m < nofvalues - 1);
      l = m + 1;
    }
    m = l + ((r - l) >> 1);
  }
  return dist[m].length;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
shrq %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
je 0x706f5
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
jae 0x7067c
jmp 0x705e4
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jbe 0x70628
movq 0x5cb9a9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4a5a12(%rip), %rsi    # 0x516013
leaq 0x4bb9cd(%rip), %rdx    # 0x52bfd5
leaq 0x4bb9cd(%rip), %rcx    # 0x52bfdc
leaq 0x4bb4f5(%rip), %r8     # 0x52bb0b
movl $0x10d, %r9d            # imm = 0x10D
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x7062a
cmpq $0x0, (%rsp)
je 0x7064f
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rsp), %rdx
subq $0x1, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
jbe 0x7066d
movq 0x28(%rsp), %rax
movq (%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x7070e
movq (%rsp), %rax
subq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x706d7
jmp 0x7067e
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jb 0x706c8
movq 0x5cb909(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4a5972(%rip), %rsi    # 0x516013
leaq 0x4bb952(%rip), %rdx    # 0x52bffa
leaq 0x4bb92d(%rip), %rcx    # 0x52bfdc
leaq 0x4bb455(%rip), %r8     # 0x52bb0b
movl $0x115, %r9d            # imm = 0x115
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x706ca
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
subq 0x10(%rsp), %rcx
shrq %rcx
addq %rcx, %rax
movq %rax, (%rsp)
jmp 0x705a6
movq 0x28(%rsp), %rax
movq (%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_simreads.c
// Function: gt_simreads_write_dist_file
static int gt_simreads_write_dist_file(const char *title, GtDiscDistri *dist,
                                       GtStr *filename, GtError *err)
{
  int had_err = 0;
  GtFile *dfile;

  gt_assert(filename);
  gt_assert(dist);
  gt_error_check(err);
  dfile = gt_file_new(gt_str_get(filename), "w", err);
  if (!dfile)
  {
    had_err = -1;
  }
  else
  {
    gt_file_xprintf(dfile, "%s", title);
    gt_disc_distri_foreach(dist,
     (GtDiscDistriIterFunc) gt_simreads_plot_disc_distri, dfile);
    gt_file_delete(dfile);
  }
  return had_err;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x70780
movq 0x5cb851(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4a58ba(%rip), %rsi    # 0x516013
leaq 0x528d60(%rip), %rdx    # 0x5994c0
leaq 0x4bb8a5(%rip), %rcx    # 0x52c00c
leaq 0x4bb39d(%rip), %r8     # 0x52bb0b
movl $0xed, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x70782
jmp 0x70784
cmpq $0x0, 0x28(%rsp)
jne 0x707c4
movq 0x5cb80d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4a5876(%rip), %rsi    # 0x516013
leaq 0x4bb851(%rip), %rdx    # 0x52bff5
leaq 0x4bb861(%rip), %rcx    # 0x52c00c
leaq 0x4bb359(%rip), %r8     # 0x52bb0b
movl $0xee, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x707c6
jmp 0x707c8
cmpq $0x0, 0x18(%rsp)
je 0x70818
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x707e0
jmp 0x70818
movq 0x5cb7b9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4a5822(%rip), %rsi    # 0x516013
leaq 0x4a59c7(%rip), %rdx    # 0x5161bf
leaq 0x4bb80d(%rip), %rcx    # 0x52c00c
leaq 0x4bb305(%rip), %r8     # 0x52bb0b
movl $0xef, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x7081a
movq 0x20(%rsp), %rdi
callq 0x11dee0
movq %rax, %rdi
movq 0x18(%rsp), %rdx
leaq 0x4f5692(%rip), %rsi    # 0x565ec5
callq 0xdd320
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x7084f
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x70887
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rdx
leaq 0x52b7c1(%rip), %rsi    # 0x59c021
movb $0x0, %al
callq 0xddca0
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x18(%rip), %rsi        # 0x70890
callq 0xa55e0
movq 0x8(%rsp), %rdi
callq 0xde430
movl 0x14(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_skproto.c
// Function: gt_skproto_runner
static int gt_skproto_runner(int argc, const char **argv, int parsed_args,
                             GT_UNUSED void *tool_arguments,
                             GT_UNUSED GtError *err)
{
  FILE *fpin;
  int i;

  gt_error_check(err);

  printf("#ifdef __cplusplus\n");
  printf("extern \"C\" {\n");
  printf("#endif\n");

  if (!argc)
    skproto("(stdout)", stdin);
  else {
    for (i = parsed_args; i < argc; i++) {
      fpin = gt_fa_xfopen(argv[i], "r");
      skproto(argv[i], fpin);
      gt_fa_xfclose(fpin);
    }
  }

  printf("#ifdef __cplusplus\n");
  printf("}\n");
  printf("#endif\n");

  return 0;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x7097b
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x70943
jmp 0x7097b
movq 0x5cb656(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4a56bf(%rip), %rsi    # 0x516013
leaq 0x4a5864(%rip), %rdx    # 0x5161bf
leaq 0x4bb6f7(%rip), %rcx    # 0x52c059
leaq 0x4bb702(%rip), %r8     # 0x52c06b
movl $0xa7, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x7097d
leaq 0x4bb6fe(%rip), %rdi    # 0x52c082
movb $0x0, %al
callq 0x19070
leaq 0x4bb704(%rip), %rdi    # 0x52c096
movb $0x0, %al
callq 0x19070
leaq 0x4bb704(%rip), %rdi    # 0x52c0a4
movb $0x0, %al
callq 0x19070
cmpl $0x0, 0x34(%rsp)
jne 0x709c6
movq 0x5cb5ab(%rip), %rax    # 0x63bf60
movq (%rax), %rsi
leaq 0x4bb6ed(%rip), %rdi    # 0x52c0ac
callq 0x70a70
jmp 0x70a34
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x70a32
movq 0x28(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x4bb5ed(%rip), %rsi    # 0x52bfda
leaq 0x4bb677(%rip), %rdx    # 0x52c06b
movl $0xb1, %ecx
callq 0xd91d0
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%rsp), %rsi
callq 0x70a70
movq 0x8(%rsp), %rdi
callq 0xd9570
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x709ce
jmp 0x70a34
leaq 0x4bb647(%rip), %rdi    # 0x52c082
movb $0x0, %al
callq 0x19070
leaq 0x514267(%rip), %rdi    # 0x584cb0
movb $0x0, %al
callq 0x19070
leaq 0x4bb64d(%rip), %rdi    # 0x52c0a4
movb $0x0, %al
callq 0x19070
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_skproto.c
// Function: forbiddenstring
static unsigned char forbiddenstring(GtStr *line)
{
  size_t slen, i;
  for (i = 0; i < sizeof (forbid) / sizeof (forbid[0]); i++) {
    slen = strlen(forbid[i]);
    if (slen <= (size_t) gt_str_length(line) &&
       !strncmp(forbid[i], gt_str_get(line), slen)) {
      return (unsigned char) 1;
    }
  }
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq $0x0, 0x18(%rsp)
cmpq $0x7, 0x18(%rsp)
jae 0x7104b
movq 0x18(%rsp), %rcx
leaq 0x5cb966(%rip), %rax    # 0x63c930
movq (%rax,%rcx,8), %rdi
callq 0x192b0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x11dfa0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
ja 0x71036
movq 0x18(%rsp), %rcx
leaq 0x5cb92b(%rip), %rax    # 0x63c930
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x11dee0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x20(%rsp), %rdx
callq 0x192f0
cmpl $0x0, %eax
jne 0x71036
movb $0x1, 0x37(%rsp)
jmp 0x71050
jmp 0x71038
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x70fb2
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_snpper.c
// Function: gt_snpper_arguments_new
static void* gt_snpper_arguments_new(void)
{
  GtStrArray *descs;
  GtUword i;
  GtSnpperArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->s2fi = gt_seqid2file_info_new();
  arguments->ofi = gt_output_file_info_new();
  arguments->desc = gt_str_new_cstr("NCBI translation table number, "
                                    "choose from:\n");
  descs = gt_trans_table_get_scheme_descriptions();
  for (i = 0; i < gt_str_array_size(descs); i++) {
    gt_str_append_cstr(arguments->desc, "* ");
    gt_str_append_cstr(arguments->desc, gt_str_array_get(descs, i));
    if (i != gt_str_array_size(descs)-1)
      gt_str_append_cstr(arguments->desc, "\n");
  }
  gt_str_array_delete(descs);
  return arguments;
}

// Assembly:
subq $0x38, %rsp
movl $0x1, %edi
movl $0x28, %esi
leaq 0x4bb09a(%rip), %rdx    # 0x52c13f
movl $0x2b, %ecx
callq 0xe83c0
movq %rax, 0x20(%rsp)
callq 0x1d43b0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
callq 0xf7d20
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
leaq 0x4bb079(%rip), %rdi    # 0x52c155
callq 0x11d510
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
callq 0x123e20
movq %rax, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x11fcc0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x711b3
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0x4bb04d(%rip), %rsi    # 0x52c182
callq 0x11d550
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x11f8c0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x11d550
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x11fcc0
movq %rax, %rcx
movq 0x10(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
je 0x7119e
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0x5220da(%rip), %rsi    # 0x593273
callq 0x11d550
jmp 0x711a0
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x71100
movq 0x30(%rsp), %rdi
callq 0x11fd20
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_snpper.c
// Function: gt_snpper_arguments_delete
static void gt_snpper_arguments_delete(void *tool_arguments)
{
  GtSnpperArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_str_delete(arguments->desc);
  gt_output_file_info_delete(arguments->ofi);
  gt_seqid2file_info_delete(arguments->s2fi);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x711ed
jmp 0x7123a
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x1d4420
movq 0x8(%rsp), %rdi
leaq 0x4baf0f(%rip), %rsi    # 0x52c13f
movl $0x43, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_snpper.c
// Function: gt_snpper_option_parser_new
static GtOptionParser* gt_snpper_option_parser_new(void *tool_arguments)
{
  GtSnpperArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  op = gt_option_parser_new("[option ...] GFF3_file [GVF_file]",
                            "Annotates SNPs according to their effect on "
                            "the genome as given by a genomic annotation.");

  /* -trans_table */
  option = gt_option_new_uint("trans_table", gt_str_get(arguments->desc),
                              &arguments->ttable, 1);
  gt_option_parser_add_option(op, option);

  /* -seqfile, -encseq, -matchdesc, -usedesc and -regionmapping */
  gt_seqid2file_register_options(op, arguments->s2fi);

  /* output file options */
  gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);

  gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);
  gt_option_parser_set_min_max_args(op, 1, 2);

  return op;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x71293
movq 0x5cad3e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4a4da7(%rip), %rsi    # 0x516013
leaq 0x5098ec(%rip), %rdx    # 0x57ab5f
leaq 0x4baf0b(%rip), %rcx    # 0x52c185
leaq 0x4baebe(%rip), %r8     # 0x52c13f
movl $0x4b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x71295
leaq 0x4baf05(%rip), %rdi    # 0x52c1a1
leaq 0x4baf20(%rip), %rsi    # 0x52c1c3
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11dee0
movq %rax, %rsi
movq 0x18(%rsp), %rdx
addq $0x18, %rdx
leaq 0x4de20a(%rip), %rdi    # 0x54f4d8
movl $0x1, %ecx
callq 0xf64b0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
callq 0x1d48c0
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq $0x10, %rdx
callq 0xf7d50
movq 0x10(%rsp), %rdi
leaq 0x1109ba(%rip), %rsi    # 0x181ce0
xorl %eax, %eax
movl %eax, %edx
callq 0xf1770
movq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0xf2a40
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_sortbench.c
// Function: gt_sortbench_arguments_delete
static void gt_sortbench_arguments_delete(void *tool_arguments)
{
  QSortBenchArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->impl);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x7169d
jmp 0x716c0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4bab77(%rip), %rsi    # 0x52c22d
movl $0x3d, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_sortbench.c
// Function: gt_sortbench_arguments_check
static int gt_sortbench_arguments_check(GT_UNUSED int rest_argc,
                                        void *tool_arguments,
                                        GtError *err)
{
  QSortBenchArguments *arguments = tool_arguments;
  int had_err = 0;

  gt_assert(arguments != NULL);
  if (arguments->use_aqsort || arguments->use_permute)
  {
    if (strcmp(gt_str_get(arguments->impl),"radixkeypair") == 0)
    {
      gt_error_set(err,"options -aqsort and -permute are bot not compatible "
                       "with option -impl radixkeypair");
      had_err = -1;
    }
    if (strcmp(gt_str_get(arguments->impl),"radixflba") == 0)
    {
      gt_error_set(err,"options -aqsort and -permute are both not compatible "
                       "with option -impl radixflba");
      had_err = -1;
    }
  }
  if (arguments->use_aqsort && arguments->use_permute)
  {
    gt_error_set(err,"options -aqsort and -permute are not compatible with "
                     "each other");
    had_err = -1;
  }
  return had_err;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x71944
movq 0x5ca68d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4a46f6(%rip), %rsi    # 0x516013
leaq 0x4a5960(%rip), %rdx    # 0x517284
leaq 0x4bab4d(%rip), %rcx    # 0x52c478
leaq 0x4ba8fb(%rip), %r8     # 0x52c22d
movl $0x83, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x71946
movq 0x8(%rsp), %rax
testb $0x1, 0x20(%rax)
jne 0x7195c
movq 0x8(%rsp), %rax
testb $0x1, 0x21(%rax)
je 0x719d6
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11dee0
movq %rax, %rdi
leaq 0x4bab68(%rip), %rsi    # 0x52c4db
callq 0x19980
cmpl $0x0, %eax
jne 0x71998
movq 0x10(%rsp), %rdi
leaq 0x4bab0c(%rip), %rsi    # 0x52c495
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11dee0
movq %rax, %rdi
leaq 0x4bab80(%rip), %rsi    # 0x52c52f
callq 0x19980
cmpl $0x0, %eax
jne 0x719d4
movq 0x10(%rsp), %rdi
leaq 0x4bab23(%rip), %rsi    # 0x52c4e8
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
jmp 0x719d6
movq 0x8(%rsp), %rax
testb $0x1, 0x20(%rax)
je 0x71a07
movq 0x8(%rsp), %rax
testb $0x1, 0x21(%rax)
je 0x71a07
movq 0x10(%rsp), %rdi
leaq 0x4bab41(%rip), %rsi    # 0x52c539
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_sortbench.c
// Function: gt_sortbench_aqsort
static void gt_sortbench_aqsort(GtUword n, GtUword *a)
{
  GtUword i;
  GtUword *ptr = gt_malloc(sizeof (*ptr) * n);

  val = a;
  gas = n-1;
  nsolid = ncmp = candidate = 0;
  for (i=0; i<n; i++) {
    ptr[i] = i;
    val[i] = gas;
  }
  qsort(ptr, (size_t) n, sizeof (*ptr), gt_sortbench_cmp);
  for (i=1UL;i<n;i++)
    gt_assert(val[ptr[i]]==val[ptr[i-1]]+1);
  gt_free(ptr);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
shlq $0x3, %rdi
leaq 0x4b9c0f(%rip), %rsi    # 0x52c22d
movl $0xde, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
leaq 0x5d0497(%rip), %rax    # 0x642ad0
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
subq $0x1, %rcx
leaq 0x5d04a4(%rip), %rax    # 0x642af0
movq %rcx, (%rax)
leaq 0x5d0492(%rip), %rax    # 0x642ae8
movq $0x0, (%rax)
leaq 0x5d0474(%rip), %rax    # 0x642ad8
movq $0x0, (%rax)
leaq 0x5d046e(%rip), %rax    # 0x642ae0
movq $0x0, (%rax)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x726ce
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
leaq 0x5d0448(%rip), %rax    # 0x642af0
movq (%rax), %rdx
leaq 0x5d041e(%rip), %rax    # 0x642ad0
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x72682
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x8, %edx
leaq 0x84c(%rip), %rcx       # 0x72f30
callq 0x19e70
movq $0x1, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x72798
jmp 0x72704
leaq 0x5d03c5(%rip), %rax    # 0x642ad0
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
leaq 0x5d03a9(%rip), %rcx    # 0x642ad0
movq (%rcx), %rcx
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rsi
subq $0x1, %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
je 0x72781
movq 0x5c9850(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4a38b9(%rip), %rsi    # 0x516013
leaq 0x4b9f7a(%rip), %rdx    # 0x52c6db
leaq 0x4b9f90(%rip), %rcx    # 0x52c6f8
leaq 0x4b9abe(%rip), %r8     # 0x52c22d
movl $0xe9, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x72783
jmp 0x72785
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x726f2
movq 0x8(%rsp), %rdi
leaq 0x4b9a89(%rip), %rsi    # 0x52c22d
movl $0xea, %edx
callq 0xe88c0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_sortbench.c
// Function: gt_qbenchsort_permute_ulong_array
static void gt_qbenchsort_permute_ulong_array (GtUword *arr,
                                               GtUword size)
{
  GtUword i, j, c;

  for (i = 0; i < size; ++i)
  {
    j = gt_rand_max(size-1);
    c = arr[i];
    arr[i] = arr[j];
    arr[j] = c;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x72846
movq 0x18(%rsp), %rdi
subq $0x1, %rdi
callq 0xec350
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq (%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x727d7
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_sortbench.c
// Function: gt_uword2flba
static void gt_uword2flba(uint8_t *buffer,GtUword value,size_t unitsize)
{
  GtUword nullmask;
  size_t idx, rshift;

  gt_assert(unitsize > 0 && unitsize <= sizeof (GtUword));
  if (unitsize == sizeof (GtUword))
  {
    nullmask = 0;
  } else
  {
    nullmask = ~((((GtUword) 1) << (unitsize * CHAR_BIT)) - (GtUword) 1);
  }
  if ((value & nullmask) > 0)
  {
    fprintf(stderr,"value" GT_WU "has 1-bits in the most significant %u bits\n",
            value,(
            (unsigned int) (sizeof (GtUword) - unitsize) * CHAR_BIT));
    exit(GT_EXIT_PROGRAMMING_ERROR);
  }
  for (idx = 0, rshift = CHAR_BIT * (unitsize - 1); idx < unitsize;
       rshift -= CHAR_BIT, idx++)
  {
    buffer[idx] = (uint8_t) ((value >> rshift) & (GtUword) (UINT8_MAX));
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jbe 0x72873
cmpq $0x8, 0x20(%rsp)
jbe 0x728ab
movq 0x5c9726(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4a378f(%rip), %rsi    # 0x516013
leaq 0x4b9e81(%rip), %rdx    # 0x52c70c
leaq 0x4b9ea7(%rip), %rcx    # 0x52c739
leaq 0x4b9994(%rip), %r8     # 0x52c22d
movl $0x201, %r9d            # imm = 0x201
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x728ad
cmpq $0x8, 0x20(%rsp)
jne 0x728c0
movq $0x0, 0x18(%rsp)
jmp 0x728de
movq 0x20(%rsp), %rcx
shlq $0x3, %rcx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
xorq $-0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
andq 0x18(%rsp), %rax
cmpq $0x0, %rax
jbe 0x72924
movq 0x5c96ab(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x28(%rsp), %rdx
movl $0x8, %eax
subq 0x20(%rsp), %rax
movl %eax, %ecx
shll $0x3, %ecx
leaq 0x4b9e34(%rip), %rsi    # 0x52c747
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
movq $0x0, 0x10(%rsp)
movq 0x20(%rsp), %rax
subq $0x1, %rax
shlq $0x3, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x7298b
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
shrq %cl, %rax
andq $0xff, %rax
movb %al, %dl
movq 0x30(%rsp), %rax
movq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x8(%rsp), %rax
subq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x7293f
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_sortbench.c
// Function: voidkeypairqsortcmp
static int voidkeypairqsortcmp(const void *va,const void *vb)
{
  const Gtuint64keyPair *a = (const Gtuint64keyPair *) va;
  const Gtuint64keyPair *b = (const Gtuint64keyPair *) vb;

  if (a->uint64_a < b->uint64_a)
  {
    return -1;
  }
  if (a->uint64_a > b->uint64_a)
  {
    return 1;
  }
  if (a->uint64_b < b->uint64_b)
  {
    return -1;
  }
  if (a->uint64_b > b->uint64_b)
  {
    return 1;
  }
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq -0x28(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x729ca
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x72a2a
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq -0x28(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x729e6
movl $0x1, -0x4(%rsp)
jmp 0x72a2a
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x72a04
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x72a2a
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x72a22
movl $0x1, -0x4(%rsp)
jmp 0x72a2a
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_sortbench.c
// Function: voidqsortcmp
static int voidqsortcmp(const void *va,const void *vb)
{
  const GtUword a = *((GtUword *) va);
  const GtUword b = *((GtUword *) vb);

  if (a < b)
  {
    return -1;
  }
  if (a > b)
  {
    return 1;
  }
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x28(%rsp), %rax
jae 0x72a6a
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x72a88
movq -0x20(%rsp), %rax
cmpq -0x28(%rsp), %rax
jbe 0x72a80
movl $0x1, -0x4(%rsp)
jmp 0x72a88
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_sortbench.c
// Function: gt_sortbench_verify_flba
static void gt_sortbench_verify_flba(const uint8_t *flba,
                                     const GtUword *array,
                                     GtUword len,
                                     size_t unitsize)
{
  GtUword idx;

  for (idx = 0UL; idx < len; idx++)
  {
    GtUword value = gt_flba2uword(flba + idx * unitsize,unitsize);
    if (value != array[idx])
    {
      fprintf(stderr,"value=" GT_WU " != " GT_WU "= array[" GT_WU "\n",
               value,array[idx],idx);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
  }
  printf("verified\n");
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x72de7
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rax
imulq 0x18(%rsp), %rax
addq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x75dd0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0x72dd2
movq 0x5c9201(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x10(%rsp), %r8
leaq 0x4b9c2f(%rip), %rsi    # 0x52c9f0
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
jmp 0x72dd4
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x72d51
leaq 0x4b9bf8(%rip), %rdi    # 0x52c9e6
movb $0x0, %al
callq 0x19070
addq $0x38, %rsp
retq
nopw (%rax,%rax)