LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/string_matching.c
// Function: store_match
static bool store_match(GtUword pos, void *data)
{
  GtArray *positions = data;
  gt_assert(positions);
  gt_array_add(positions, pos);
  return false;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
testq %rsi, %rsi
je 0x187255
movq %rsp, %rax
movl $0x8, %edx
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd49ce
xorl %eax, %eax
popq %rcx
retq
callq 0x58377
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/string_matching.c
// Function: store_first_match
static bool store_first_match(GtUword pos, void *data)
{
  GtUword *match = data;
  gt_assert(match);
  *match = pos;
  return true;
}

// Assembly:
testq %rsi, %rsi
je 0x187265
movq %rdi, (%rsi)
movb $0x1, %al
retq
pushq %rax
callq 0x583b0
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/targetbest_select_stream.c
// Function: gt_targetbest_select_stream_class
const GtNodeStreamClass* gt_targetbest_select_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtTargetbestSelectStream),
                                   targetbest_select_stream_free,
                                   targetbest_select_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x340bce(%rip)    # 0x4c98d0
jne 0x188d23
leaq 0x26(%rip), %rsi        # 0x188d31
leaq 0x7a(%rip), %rdx        # 0x188d8c
movl $0x38, %edi
callq 0x16abb4
movq %rax, 0x340bad(%rip)    # 0x4c98d0
callq 0xe6a19
movq 0x340ba1(%rip), %rax    # 0x4c98d0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/targetbest_select_stream.c
// Function: targetbest_select_stream_free
static void targetbest_select_stream_free(GtNodeStream *ns)
{
  GtTargetbestSelectStream *tfs = targetbest_select_stream_cast(ns);
  for (; tfs->next != NULL; tfs->next = gt_dlistelem_next(tfs->next))
    gt_genome_node_delete(gt_dlistelem_get_data(tfs->next));
  gt_dlist_delete(tfs->trees);
  gt_hashmap_delete(tfs->target_to_elem);
  gt_node_stream_delete(tfs->in_stream);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x188cf4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movq %rax, %rbx
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x188d70
movq %rax, %rdi
callq 0xea174
movq %rax, %rdi
callq 0x14c43a
movq 0x20(%rbx), %rdi
callq 0xea184
movq %rax, 0x20(%rbx)
jmp 0x188d4c
movq 0x18(%rbx), %rdi
callq 0xea3f1
movq 0x28(%rbx), %rdi
callq 0x105f7d
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x16ac6e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/targetbest_select_stream.c
// Function: gt_targetbest_select_stream_new
GtNodeStream* gt_targetbest_select_stream_new(GtNodeStream *in_stream)
{
  GtTargetbestSelectStream *tfs;
  GtNodeStream *ns;
  gt_assert(in_stream);
  ns = gt_node_stream_create(gt_targetbest_select_stream_class(),
                             gt_node_stream_is_sorted(in_stream));
  tfs = targetbest_select_stream_cast(ns);
  tfs->in_stream = gt_node_stream_ref(in_stream);
  tfs->in_stream_processed = false;
  tfs->trees = gt_dlist_new(NULL);
  tfs->target_to_elem = gt_hashmap_new(GT_HASH_STRING, gt_free_func, NULL);
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1890e6
movq %rdi, %r14
callq 0x188cf4
movq %rax, %rbx
movq %r14, %rdi
callq 0x16ae51
movzbl %al, %esi
movq %rbx, %rdi
callq 0x16abec
movq %rax, %rbx
callq 0x188cf4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movq %rax, %r15
movq %r14, %rdi
callq 0x16ac58
movq %rax, 0x10(%r15)
movb $0x0, 0x30(%r15)
xorl %edi, %edi
callq 0xea08c
movq %rax, 0x18(%r15)
leaq -0x7f99e(%rip), %rsi    # 0x10972f
movl $0x1, %edi
xorl %edx, %edx
callq 0x105830
movq %rax, 0x28(%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x590b3
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/tir_stream.c
// Function: gt_tir_stream_free
static void gt_tir_stream_free(GtNodeStream *ns)
{
  GtTIRStream *tir_stream = gt_node_stream_cast(gt_tir_stream_class(), ns);
  GT_FREEARRAY(&tir_stream->first_pairs, TIRPair);
  gt_str_delete(tir_stream->str_indexname);
  if (tir_stream->ssar != NULL)
    gt_freeSequentialsuffixarrayreader(&tir_stream->ssar);
  if (tir_stream->tir_pairs != NULL)
    gt_free(tir_stream->tir_pairs);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x340197(%rip)    # 0x4c98e8
jne 0x189772
leaq -0x18(%rip), %rsi       # 0x189742
leaq 0x98(%rip), %rdx        # 0x1897f9
movl $0x120, %edi            # imm = 0x120
callq 0x16abb4
movq %rax, 0x340176(%rip)    # 0x4c98e8
movq 0x34016f(%rip), %rdi    # 0x4c98e8
movq %rbx, %rsi
callq 0x16ae64
movq %rax, %rbx
movq 0x78(%rax), %rdi
testq %rdi, %rdi
je 0x1897b1
leaq 0x78(%rbx), %r14
leaq 0x2165a2(%rip), %rsi    # 0x39fd3a
movl $0x3be, %edx            # imm = 0x3BE
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0xb0(%rbx), %rdi
callq 0x121b03
cmpq $0x0, 0x18(%rbx)
je 0x1897d0
movq %rbx, %rdi
addq $0x18, %rdi
callq 0x1ae1ac
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x1897f1
leaq 0x21655a(%rip), %rsi    # 0x39fd3a
movl $0x3c3, %edx            # imm = 0x3C3
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/tir_stream.c
// Function: gt_tir_store_seeds
static int gt_tir_store_seeds(void *info, const GtGenericEncseq *genericencseq,
                              GtUword len, GtUword pos1,
                              GtUword pos2, GT_UNUSED GtError *err)
{
  GtUword seqnum1,
                seqnum2;
  Seed *nextfreeseedpointer;
  GtUword distance;
  SeedInfo *seeds = (SeedInfo *) info;
  const GtEncseq *encseq;
  gt_error_check(err);

  gt_assert(genericencseq->hasencseq);
  encseq = genericencseq->seqptr.encseq;
  /* ensure order of seeds */
  gt_assert(pos1 < pos2);

  /* match mirrored vs. unmirrored */
  if (pos1 > seeds->midpos || pos2 < seeds->midpos)
    return 0;

  /* check distance constraints */
  distance = (GT_REVERSEPOS(seeds->totallength, pos2) - len + 1) - pos1;
  if (distance < seeds->min_tir_distance || distance > seeds->max_tir_distance)
    return 0;

  /* check whether matches are on the `same' contig */
  seqnum1 = gt_encseq_seqnum(encseq, pos1);
  seqnum2 = gt_encseq_seqnum(encseq, pos2);
  if (seqnum2 != seeds->num_of_contigs - seqnum1 - 1)
    return 0;

  /* check length constraints */
  if (len > seeds->max_tir_length)
    return 0;

  GT_GETNEXTFREEINARRAY(nextfreeseedpointer, &seeds->seed, Seed, 256);
  nextfreeseedpointer->pos1 = pos1;
  nextfreeseedpointer->pos2 = pos2;
  nextfreeseedpointer->offset = distance;
  nextfreeseedpointer->len = len;
  nextfreeseedpointer->contignumber = seqnum1;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r12
testq %r9, %r9
je 0x18add5
movq %r9, %rdi
callq 0x101a9a
testb %al, %al
jne 0x18aee6
cmpb $0x0, (%r13)
je 0x18aedc
cmpq %r14, %r15
jae 0x18aee1
movq 0x40(%r12), %rax
cmpq %r15, %rax
setb %cl
cmpq %r14, %rax
seta %al
orb %cl, %al
jne 0x18aecb
movq 0x48(%r12), %rbp
leaq (%r15,%rbx), %rax
addq %r14, %rax
subq %rax, %rbp
cmpq 0x30(%r12), %rbp
jb 0x18aecb
cmpq 0x28(%r12), %rbp
ja 0x18aecb
movq 0x8(%r13), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xefc48
movq %r13, %rdi
movq %rax, %r13
movq %r14, %rsi
callq 0xefc48
movq %r13, %rcx
notq %rcx
addq 0x38(%r12), %rcx
cmpq %rcx, %rax
jne 0x18aecb
cmpq %rbx, 0x18(%r12)
jb 0x18aecb
movq 0x8(%r12), %rax
cmpq %rax, 0x10(%r12)
jb 0x18ae98
leaq 0x100(%rax), %rcx
movq %rcx, 0x8(%r12)
movq (%r12), %rdi
leaq 0x800(,%rax,8), %rax
leaq (%rax,%rax,4), %rsi
leaq 0x214eb0(%rip), %rdx    # 0x39fd3a
movl $0xab, %ecx
callq 0x1094e6
movq %rax, (%r12)
movq (%r12), %rax
testq %rax, %rax
je 0x18aeeb
movq 0x10(%r12), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r12)
leaq (%rcx,%rcx,4), %rcx
movq %r15, (%rax,%rcx,8)
movq %r14, 0x8(%rax,%rcx,8)
movq %rbp, 0x10(%rax,%rcx,8)
movq %rbx, 0x18(%rax,%rcx,8)
movq %r13, 0x20(%rax,%rcx,8)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5978e
callq 0x597c7
callq 0x59755
callq 0x59800
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/tir_stream.c
// Function: gt_tir_store_TSDs
static void gt_tir_store_TSDs(void *info, const GtQuerymatch *querymatch)
{
  Seed *nextfree;
  TSDinfo *TSDs = (TSDinfo *) info;

  /* store the TSD  */
  GT_GETNEXTFREEINARRAY(nextfree, &TSDs->TSDs, Seed, 100);
  nextfree->pos1 = TSDs->left_start_pos + gt_querymatch_dbstart(querymatch);
  nextfree->offset = TSDs->right_start_pos
                       + gt_querymatch_querystart(querymatch)
                       - (nextfree->pos1);
  nextfree->len = gt_querymatch_querylen(querymatch);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rax
cmpq %rax, 0x20(%rdi)
jb 0x18af6b
leaq 0x64(%rax), %rcx
movq %rcx, 0x18(%r14)
movq 0x10(%r14), %rdi
leaq 0x320(,%rax,8), %rax
leaq (%rax,%rax,4), %rsi
leaq 0x214ddd(%rip), %rdx    # 0x39fd3a
movl $0xba, %ecx
callq 0x1094e6
movq %rax, 0x10(%r14)
movq 0x10(%r14), %r15
testq %r15, %r15
je 0x18afc5
movq (%r14), %r12
movq 0x20(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%r14)
leaq (%rax,%rax,4), %r13
movq %rbx, %rdi
callq 0x1c3985
addq %r12, %rax
movq %rax, (%r15,%r13,8)
movq 0x8(%r14), %r14
movq %rbx, %rdi
callq 0x1c3998
addq %r14, %rax
subq (%r15,%r13,8), %rax
movq %rax, 0x10(%r15,%r13,8)
movq %rbx, %rdi
callq 0x1c3980
movq %rax, 0x18(%r15,%r13,8)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x59839
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/typecheck_info.c
// Function: gt_typecheck_info_delete
void gt_typecheck_info_delete(GtTypecheckInfo *tci)
{
  if (!tci) return;
  gt_option_delete(tci->typecheck_option);
  gt_str_delete(tci->typecheck);
  gt_free(tci);
}

// Assembly:
testq %rdi, %rdi
je 0x18ba17
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x10f386
movq (%rbx), %rdi
callq 0x121b03
leaq 0x214ff9(%rip), %rsi    # 0x3a0a02
movq %rbx, %rdi
movl $0x2c, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/typecheck_info.c
// Function: gt_typecheck_info_register_options_with_default
void gt_typecheck_info_register_options_with_default(GtTypecheckInfo *tci,
                                                     GtOptionParser *op,
                                                     const char *default_v)
{
  GtOption *typecheck_option, *built_in_option;
  gt_assert(tci && op);
  gt_assert(!tci->typecheck_option); /* can only called once */

  /* -typecheck */
  typecheck_option =
    gt_option_new_string("typecheck", "use an ontology given in an OBO file "
                         "to validate parent-child relationships.\n"
                         "If no argument is given, "
                         "the sofa.obo file from the gtdata/obo_files "
                         "directory is used.\nIf an argument is given, it is "
                         "used as an OBO filename.\nIn the case that such a "
                         "file does not exist '.obo' is added to the argument "
                         "and loading the resulting filename from the "
                         "gtdata/obo_files directory is attempted.",
                         tci->typecheck, default_v);
  gt_option_argument_is_optional(typecheck_option);
  gt_option_parser_add_option(op, typecheck_option);
  tci->typecheck_option = gt_option_ref(typecheck_option);

  /* -typecheck-built-in */
  built_in_option = gt_option_new_bool("typecheck-built-in",
                                       "use built-in type checker",
                                       &tci->typecheck_built_in, false);
  gt_option_is_development_option(built_in_option);
  gt_option_parser_add_option(op, built_in_option);
  gt_option_exclude(typecheck_option, built_in_option);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x18babd
movq %rsi, %rbx
testq %rsi, %rsi
je 0x18babd
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
jne 0x18bac2
movq %rdx, %rcx
movq (%r14), %rdx
leaq 0x215024(%rip), %rdi    # 0x3a0a71
leaq 0x215027(%rip), %rsi    # 0x3a0a7b
callq 0x10f987
movq %rax, %r15
movq %rax, %rdi
callq 0x10fe42
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10cc3c
movq %rax, 0x8(%r14)
addq $0x10, %r14
leaq 0x215173(%rip), %rdi    # 0x3a0bf9
leaq 0x21517f(%rip), %rsi    # 0x3a0c0c
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r14
movq %rax, %rdi
callq 0x10fbef
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10cd10
movq %r15, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x10fd9f
callq 0x5a2f9
callq 0x5a330
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/typecheck_info.c
// Function: gt_typecheck_info_option_used
bool gt_typecheck_info_option_used(const GtTypecheckInfo *tci)
{
  gt_assert(tci && tci->typecheck_option);
  if (gt_option_is_set(tci->typecheck_option) || tci->typecheck_built_in)
    return true;
  return false;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x18baf2
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x18baf2
callq 0x10fe52
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x18baf0
movb 0x10(%rbx), %al
popq %rbx
retq
callq 0x5a367
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/typecheck_info.c
// Function: gt_typecheck_info_create_type_checker
GtTypeChecker* gt_typecheck_info_create_type_checker(const GtTypecheckInfo *tci,
                                                     GtError *err)
{
  GtTypeChecker *type_checker = NULL;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(tci);
  if (tci->typecheck_built_in)
    type_checker = gt_type_checker_builtin_new();
  else {
    GtStr *obo_file;
    gt_assert(gt_option_is_set(tci->typecheck_option));
    if (!gt_str_length(tci->typecheck)) {
      /* a. */
      if (!(obo_file = get_obo_path(err)))
        had_err = -1;
      if (!had_err)
        gt_str_append_cstr(obo_file, "sofa.obo");
    }
    else if (gt_file_exists(gt_str_get(tci->typecheck))) {
      /* b. */
      obo_file = gt_str_new_cstr(gt_str_get(tci->typecheck));
    }
    else {
      /* c. */
      if (!(obo_file = get_obo_path(err)))
        had_err = -1;
      if (!had_err) {
        gt_str_append_str(obo_file, tci->typecheck);
        gt_str_append_cstr(obo_file, ".obo");
      }
    }

    if (!had_err)
      type_checker = gt_type_checker_obo_new(gt_str_get(obo_file), err);

    gt_str_delete(obo_file);
  }
  return type_checker;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
testq %rsi, %rsi
je 0x18bb17
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x18bbf7
testq %r15, %r15
je 0x18bbf2
cmpb $0x1, 0x10(%r15)
jne 0x18bb33
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x18b990
movq 0x8(%r15), %rdi
callq 0x10fe52
testb %al, %al
je 0x18bbfc
movq (%r15), %rdi
callq 0x120d4c
testq %rax, %rax
je 0x18bb7a
movq (%r15), %rdi
callq 0x120d23
movq %rax, %rdi
callq 0x10415c
testb %al, %al
je 0x18bb93
movq (%r15), %rdi
callq 0x120d23
movq %rax, %rdi
callq 0x120955
movq %rax, %r14
jmp 0x18bbbd
movq %rbx, %rdi
callq 0x18bc01
movq %rax, %r14
testq %rax, %rax
je 0x18bbc1
leaq 0x215122(%rip), %rsi    # 0x3a0cb3
jmp 0x18bbb5
movq %rbx, %rdi
callq 0x18bc01
movq %rax, %r14
testq %rax, %rax
je 0x18bbc1
movq (%r15), %rsi
movq %r14, %rdi
callq 0x120a43
leaq 0x215102(%rip), %rsi    # 0x3a0cb7
movq %r14, %rdi
callq 0x12097f
movb $0x1, %al
jmp 0x18bbc3
xorl %eax, %eax
testb %al, %al
je 0x18bbdf
movq %r14, %rdi
callq 0x120d23
movq %rax, %rdi
movq %rbx, %rsi
callq 0x30c953
movq %rax, %rbx
jmp 0x18bbe1
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x121b03
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x5a40c
callq 0x5a39e
callq 0x5a3d5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/typecheck_info.c
// Function: get_obo_path
static GtStr* get_obo_path(GtError *err)
{
  const char *progname;
  GtStr *obo_path, *prog;
  gt_error_check(err);
  progname = gt_error_get_progname(err);
  gt_assert(progname != NULL);
  prog = gt_str_new();
  gt_str_append_cstr_nt(prog, progname,
                        gt_cstr_length_up_to_char(progname, ' '));
  obo_path = gt_get_gtdata_path(gt_str_get(prog), err);
  if (obo_path)
    gt_str_append_cstr(obo_path, "/obo_files/");
  gt_str_delete(prog);
  return obo_path;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x18bc1a
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x18bc8d
movq %rbx, %rdi
callq 0x101b22
testq %rax, %rax
je 0x18bc88
movq %rax, %r15
callq 0x1208f8
movq %rax, %r14
movq %r15, %rdi
movl $0x20, %esi
callq 0xe885c
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x120a9d
movq %r14, %rdi
callq 0x120d23
movq %rax, %rdi
movq %rbx, %rsi
callq 0x105688
movq %rax, %rbx
testq %rax, %rax
je 0x18bc77
leaq 0x21505a(%rip), %rsi    # 0x3a0cc9
movq %rbx, %rdi
callq 0x12097f
movq %r14, %rdi
callq 0x121b03
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x5a47a
callq 0x5a443
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/uint64hashtable.c
// Function: gt_uint64hashtable_new
GtUint64hashtable *gt_uint64hashtable_new(size_t nof_elements)
{
  GtUint64hashtable *table;
  const double loadfactor = 1.30;

  table = gt_malloc(sizeof (*table));
  table->countcollisions = 0;
  table->allentries = 0;
  table->zero_occurs = false;
  table->zero_count = 0;
  table->alloc
    = gt_uint64hashtable_get_size((size_t)(1 + loadfactor *
                                               (double) nof_elements));
  table->hspace = gt_calloc(table->alloc, sizeof (*table->hspace));
  return table;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x215041(%rip), %rsi    # 0x3a0ce0
movl $0x38, %edi
movl $0x7e, %edx
callq 0x1092b2
movq %rbx, %xmm0
punpckldq 0x1c4c25(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1c4c2d(%rip), %xmm0   # 0x3508f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x215001(%rip), %xmm1   # 0x3a0cd8
addsd 0x1c3549(%rip), %xmm1   # 0x34f228
movq %rax, %rbx
cvttsd2si %xmm1, %rax
movq %rax, %rcx
subsd 0x1c502e(%rip), %xmm1   # 0x350d20
cvttsd2si %xmm1, %rdi
sarq $0x3f, %rcx
andq %rcx, %rdi
orq %rax, %rdi
movabsq $0x7fc0002764, %rax     # imm = 0x7FC0002764
xorpd %xmm0, %xmm0
movupd %xmm0, 0x18(%rbx)
movupd %xmm0, 0x21(%rbx)
cmpq %rax, %rdi
jae 0x18bda6
movl $0x100007, %eax         # imm = 0x100007
cmpq $0x100007, %rdi         # imm = 0x100007
jb 0x18bd81
movl $0x97f, %ecx            # imm = 0x97F
movl $0x4bf, %r8d            # imm = 0x4BF
xorl %esi, %esi
leaq 0x2152cc(%rip), %rdx    # 0x3a1010
movq %rcx, %rax
subq %rsi, %rax
cmpq $0x1, %rax
je 0x18bd74
movq (%rdx,%r8,8), %rax
cmpq %rdi, %rax
jbe 0x18bd5e
movq %r8, %rcx
jmp 0x18bd63
movq %r8, %rsi
jae 0x18bd81
leaq (%rcx,%rsi), %r8
shrq %r8
cmpq %rsi, %rcx
jae 0x18bd44
callq 0x5a4b1
movq %rdi, %rax
cmpq %rdi, (%rdx,%rsi,8)
je 0x18bd81
movq (%rdx,%rcx,8), %rax
movq %rax, 0x10(%rbx)
leaq 0x214f54(%rip), %rdx    # 0x3a0ce0
movl $0x10, %esi
movq %rax, %rdi
movl $0x86, %ecx
callq 0x1093ef
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
retq
callq 0x5a4e8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/uint64hashtable.c
// Function: gt_uint64hashtable_countsum_get
GtUword gt_uint64hashtable_countsum_get(const GtUint64hashtable *table)
{
  size_t idx;
  GtUword sumcount = 0;

  for (idx=0; idx < table->alloc; idx++)
  {
    if (table->hspace[idx].count > 0)
    {
      sumcount += table->hspace[idx].count;
    }
  }
  return sumcount + table->zero_count;
}

// Assembly:
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x18c0d4
movq (%rdi), %rdx
addq $0x8, %rdx
xorl %eax, %eax
addq (%rdx), %rax
addq $0x10, %rdx
decq %rcx
jne 0x18c0c6
jmp 0x18c0d6
xorl %eax, %eax
addq 0x20(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/uniq_stream.c
// Function: gt_uniq_stream_class
const GtNodeStreamClass* gt_uniq_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtUniqStream),
                                   uniq_stream_free,
                                   uniq_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x33d3f6(%rip)    # 0x4c98f0
jne 0x18c51b
leaq 0x26(%rip), %rsi        # 0x18c529
leaq 0x52(%rip), %rdx        # 0x18c55c
movl $0x28, %edi
callq 0x16abb4
movq %rax, 0x33d3d5(%rip)    # 0x4c98f0
callq 0xe6a19
movq 0x33d3c9(%rip), %rax    # 0x4c98f0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/uniq_stream.c
// Function: uniq_stream_free
static void uniq_stream_free(GtNodeStream *ns)
{
  GtUniqStream *us = uniq_stream_cast(ns);
  gt_genome_node_delete(us->first_node);
  gt_genome_node_delete(us->second_node);
  gt_node_stream_delete(us->in_stream);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x18c4ec
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0x14c43a
movq 0x20(%rbx), %rdi
callq 0x14c43a
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x16ac6e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/uniq_stream.c
// Function: gt_uniq_stream_new
GtNodeStream* gt_uniq_stream_new(GtNodeStream *in_stream)
{
  GtNodeStream *ns;
  GtUniqStream *us;
  gt_assert(in_stream && gt_node_stream_is_sorted(in_stream));
  ns = gt_node_stream_create(gt_uniq_stream_class(), true);
  us = uniq_stream_cast(ns);
  us->in_stream = gt_node_stream_ref(in_stream);
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x18c823
movq %rdi, %rbx
callq 0x16ae51
testb %al, %al
je 0x18c823
callq 0x18c4ec
movq %rax, %rdi
movl $0x1, %esi
callq 0x16abec
movq %rax, %r14
callq 0x18c4ec
movq %rax, %rdi
movq %r14, %rsi
callq 0x16ae64
movq %rax, %r15
movq %rbx, %rdi
callq 0x16ac58
movq %rax, 0x10(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x5a9e0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/wtree.c
// Function: gt_wtree_create
GtWtree *gt_wtree_create(const GtWtreeClass *wtree_c)
{
  GtWtree *wtree;
  gt_assert(wtree_c && wtree_c->size);
  wtree = gt_calloc((size_t) 1, wtree_c->size);
  wtree->c_class = wtree_c;
  wtree->members = gt_calloc((size_t) 1, sizeof (GtWtreeMembers));
  return wtree;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x18c9e5
movq %rdi, %rbx
movq 0x20(%rdi), %rsi
testq %rsi, %rsi
je 0x18c9e5
leaq 0x219394(%rip), %r14    # 0x3a5d3d
movl $0x1, %edi
movq %r14, %rdx
movl $0x1d, %ecx
callq 0x1093ef
movq %rax, %r15
movq %rbx, (%rax)
movl $0x1, %edi
movl $0x18, %esi
movq %r14, %rdx
movl $0x1f, %ecx
callq 0x1093ef
movq %rax, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x5aa87
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/wtree.c
// Function: gt_wtree_access
GtWtreeSymbol gt_wtree_access(GtWtree *wtree,
                              GtUword pos)
{
  gt_assert(wtree != NULL);
  gt_assert(wtree->c_class != NULL);
  if (wtree->c_class->access_func != NULL)
    return wtree->c_class->access_func(wtree, pos);
  return (GtWtreeSymbol) ULONG_MAX;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x18ca3c
movq (%rdi), %rax
testq %rax, %rax
je 0x18ca41
movq (%rax), %rax
testq %rax, %rax
je 0x18ca33
popq %rcx
jmpq *%rax
movq $-0x1, %rax
popq %rcx
retq
callq 0x5ab63
callq 0x5ab2c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/wtree.c
// Function: gt_wtree_rank
GtUword gt_wtree_rank(GtWtree *wtree,
                      GtUword pos,
                      GtWtreeSymbol symbol)
{
  gt_assert(wtree != NULL);
  gt_assert(wtree->c_class != NULL);
  if (wtree->c_class->rank_func != NULL)
    return wtree->c_class->rank_func(wtree, pos, symbol);
  return ULONG_MAX;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x18ca69
movq (%rdi), %rax
testq %rax, %rax
je 0x18ca6e
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x18ca60
popq %rcx
jmpq *%rax
movq $-0x1, %rax
popq %rcx
retq
callq 0x5abd1
callq 0x5ab9a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/wtree.c
// Function: gt_wtree_select
GtUword gt_wtree_select(GtWtree *wtree,
                        GtUword i,
                        GtWtreeSymbol symbol)
{
  gt_assert(wtree != NULL);
  gt_assert(wtree->c_class != NULL);
  if (wtree->c_class->select_func != NULL)
    return wtree->c_class->select_func(wtree, i, symbol);
  return ULONG_MAX;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x18ca96
movq (%rdi), %rax
testq %rax, %rax
je 0x18ca9b
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x18ca8d
popq %rcx
jmpq *%rax
movq $-0x1, %rax
popq %rcx
retq
callq 0x5ac3f
callq 0x5ac08
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/wtree.c
// Function: gt_wtree_class_new
const GtWtreeClass* gt_wtree_class_new(size_t size,
                                       GtWtreeAccessFunc access_func,
                                       GtWtreeRankFunc rank_func,
                                       GtWtreeSelectFunc select_func,
                                       GtWtreeDeleteFunc delete_func)
{
  GtWtreeClass *wtree_c = gt_malloc(sizeof (*wtree_c));
  wtree_c->size = size;
  wtree_c->access_func = access_func;
  wtree_c->rank_func = rank_func;
  wtree_c->select_func = select_func;
  wtree_c-> delete_func = delete_func;
  return wtree_c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x21926d(%rip), %rsi    # 0x3a5d3d
movl $0x28, %edi
movl $0x62, %edx
callq 0x1092b2
movq %r13, 0x20(%rax)
movq %r12, (%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x8(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/wtree.c
// Function: gt_wtree_delete
void gt_wtree_delete(GtWtree *wtree)
{
  if (wtree != NULL) {
    if (wtree->members->refcount) {
      wtree->members->refcount--;
      return;
    }
    gt_assert(wtree->c_class);
    if (wtree->c_class->delete_func != NULL)
      wtree->c_class->delete_func(wtree);
    gt_free(wtree->members);
    gt_free(wtree);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x18cb1c
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x18cb24
decq %rcx
movq %rcx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rax
testq %rax, %rax
je 0x18cb69
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x18cb3a
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
leaq 0x2191f8(%rip), %r14    # 0x3a5d3d
movq %r14, %rsi
movl $0x75, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x76, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
callq 0x5ac76
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/wtree_encseq.c
// Function: gt_wtree_encseq_unmap_decoded
char gt_wtree_encseq_unmap_decoded(GtWtree *wtree,
                                   GtWtreeSymbol symbol)
{
  GtWtreeEncseq *wtree_encseq;
  GtUchar encseq_sym = (GtUchar) symbol;
  gt_assert((symbol & ((GtUchar) 0)) == 0);
  gt_assert(wtree != NULL);
  wtree_encseq = gt_wtree_encseq_cast(wtree);
  switch (wtree_encseq->alpha_size - encseq_sym) {
    case 1:
      return (char) GT_SEPARATOR;
    case 2:
      return gt_alphabet_decode(wtree_encseq->alpha, (GtUchar) GT_WILDCARD);
    case 3:
      return (char) GT_UNDEFCHAR;
    default:
      return gt_alphabet_decode(wtree_encseq->alpha, encseq_sym);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x18cbd2
movq %rsi, %rbx
movq %rdi, %r14
callq 0x18cbd7
movq %rax, %rdi
movq %r14, %rsi
callq 0x18ca01
movl 0x58(%rax), %ecx
movzbl %bl, %edx
subl %edx, %ecx
cmpl $0x1, %ecx
je 0x18cbb5
cmpl $0x3, %ecx
je 0x18cbb1
cmpl $0x2, %ecx
jne 0x18cbbf
movq 0x18(%rax), %rdi
movl $0xfe, %esi
jmp 0x18cbc6
movb $-0x3, %al
jmp 0x18cbb7
movb $-0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x18(%rax), %rdi
movzbl %bl, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd3da7
callq 0x5acad
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/wtree_encseq.c
// Function: gt_wtree_encseq_class
const GtWtreeClass* gt_wtree_encseq_class(void)
{
  static const GtWtreeClass *this_c = NULL;
  if (this_c == NULL) {
    this_c =
      gt_wtree_class_new(sizeof (GtWtreeEncseq), gt_wtree_encseq_access,
                         gt_wtree_encseq_rank, gt_wtree_encseq_select,
                         gt_wtree_encseq_delete);
  }
  return this_c;
}

// Assembly:
cmpq $0x0, 0x33cd21(%rip)    # 0x4c9900
jne 0x18cc13
pushq %rax
leaq 0x32(%rip), %rsi        # 0x18cc1b
leaq 0x7e(%rip), %rdx        # 0x18cc6e
leaq 0xd9(%rip), %rcx        # 0x18ccd0
leaq 0x13e(%rip), %r8        # 0x18cd3c
movl $0x60, %edi
callq 0x18cab1
movq %rax, 0x33ccf1(%rip)    # 0x4c9900
addq $0x8, %rsp
movq 0x33cce6(%rip), %rax    # 0x4c9900
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/wtree_encseq.c
// Function: gt_wtree_encseq_access
static GtWtreeSymbol gt_wtree_encseq_access(GtWtree *wtree,
                                            GtUword pos)
{
  unsigned int alpha_start = 0,
               alpha_end;
  GtUword node_start = 0,
          node_size;
  GtWtreeEncseq *we;
  gt_assert(wtree != NULL);

  we = gt_wtree_encseq_cast(wtree);
  gt_assert(pos < wtree->members->length);

  alpha_end = we->alpha_size - 1;
  node_size = wtree->members->length;

  return gt_wtree_encseq_access_rec(we, pos, node_start, node_size, alpha_start,
                                    alpha_end);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x18cc64
movq %rsi, %rbx
movq %rdi, %r14
callq 0x18cbd7
movq %rax, %rdi
movq %r14, %rsi
callq 0x18ca01
movq 0x8(%r14), %rcx
movq (%rcx), %rcx
cmpq %rbx, %rcx
jbe 0x18cc69
movl 0x58(%rax), %r9d
decl %r9d
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18d12b
callq 0x5ad1d
callq 0x5ace6
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/wtree_encseq.c
// Function: gt_wtree_encseq_rank
static GtUword gt_wtree_encseq_rank(GtWtree *wtree,
                                    GtUword pos,
                                    GtWtreeSymbol symbol)
{
  unsigned int alpha_start = 0,
               alpha_end;
  GtUword node_start = 0,
          node_size;
  GtWtreeEncseq *we;
  gt_assert(wtree != NULL);

  we = gt_wtree_encseq_cast(wtree);
  gt_assert(pos < wtree->members->length);

  alpha_end = we->alpha_size - 1;
  node_size = wtree->members->length;

  return gt_wtree_encseq_rank_rec(we, pos, symbol, node_start, node_size,
                                  alpha_start, alpha_end);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x18ccc6
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x18cbd7
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ca01
movq 0x8(%r15), %rcx
movq (%rcx), %r8
cmpq %r14, %r8
jbe 0x18cccb
movl 0x58(%rax), %ecx
decl %ecx
movl %ecx, (%rsp)
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x18d272
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x5ad8d
callq 0x5ad54
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/wtree_encseq.c
// Function: gt_wtree_encseq_select
static GtUword gt_wtree_encseq_select(GtWtree *wtree,
                                      GtUword i,
                                      GtWtreeSymbol symbol)
{
  unsigned int alpha_start = 0,
               alpha_end;
  GtUword node_start = 0,
          node_size;
  GtWtreeEncseq *we;
  gt_assert(wtree != NULL);

  we = gt_wtree_encseq_cast(wtree);
  gt_assert(i <= wtree->members->length);
  gt_assert(i != 0);

  alpha_end = we->alpha_size - 1;
  node_size = wtree->members->length;

  return gt_wtree_encseq_select_rec(we, i, symbol, node_start, node_size,
                                    alpha_start, alpha_end);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x18cd2d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x18cbd7
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ca01
movq 0x8(%r15), %rcx
movq (%rcx), %r8
cmpq %r14, %r8
jb 0x18cd32
testq %r14, %r14
je 0x18cd37
movl 0x58(%rax), %ecx
decl %ecx
movl %ecx, (%rsp)
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x18d439
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x5ae38
callq 0x5adff
callq 0x5adc6
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/wtree_encseq.c
// Function: gt_wtree_encseq_delete
static void gt_wtree_encseq_delete(GT_UNUSED GtWtree *wtree)
{
  if (wtree != NULL) {
    GtWtreeEncseq *wtree_encseq = gt_wtree_encseq_cast(wtree);
    gt_encseq_delete(wtree_encseq->encseq);
    gt_alphabet_delete(wtree_encseq->alpha);
    gt_free(wtree_encseq->bits);
    gt_compressed_bitsequence_delete(wtree_encseq->c_bits);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x18cd89
pushq %rbx
movq %rdi, %rbx
callq 0x18cbd7
movq %rax, %rdi
movq %rbx, %rsi
callq 0x18ca01
movq %rax, %rbx
movq 0x10(%rax), %rdi
callq 0xee90c
movq 0x18(%rbx), %rdi
callq 0xd335d
movq 0x20(%rbx), %rdi
leaq 0x2190b6(%rip), %rsi    # 0x3a5e2b
movl $0x130, %edx            # imm = 0x130
callq 0x109670
movq 0x38(%rbx), %rdi
popq %rbx
jmp 0x130eb7
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/wtree_encseq.c
// Function: gt_wtree_encseq_fill_offset_delete
static inline void
gt_wtree_encseq_fill_offset_delete(GtWtreeEncseqFillOffset *fo)
{
  if (fo != NULL) {
    gt_wtree_encseq_fill_offset_delete(fo->left);
    gt_wtree_encseq_fill_offset_delete(fo->right);
    gt_free(fo);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x18d5d6
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x18d5a7
movq 0x8(%rbx), %rdi
callq 0x18d5a7
leaq 0x218863(%rip), %rsi    # 0x3a5e2b
movq %rbx, %rdi
movl $0x175, %edx            # imm = 0x175
popq %rbx
jmp 0x109670
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/xrfcheck_info.c
// Function: gt_xrfcheck_info_delete
void gt_xrfcheck_info_delete(GtXRFCheckInfo *xci)
{
  if (!xci) return;
  gt_option_delete(xci->xrfcheck_option);
  gt_str_delete(xci->xrfcheck);
  gt_free(xci);
}

// Assembly:
testq %rdi, %rdi
je 0x18e6ab
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x10f386
movq (%rbx), %rdi
callq 0x121b03
leaq 0x217ff6(%rip), %rsi    # 0x3a6693
movq %rbx, %rdi
movl $0x2a, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/xrfcheck_info.c
// Function: gt_xrfcheck_info_register_options
void gt_xrfcheck_info_register_options(GtXRFCheckInfo *xci,
                                        GtOptionParser *op)
{
  GtOption *xrfcheck_option;
  gt_assert(xci && op);
  gt_assert(!xci->xrfcheck_option); /* can only called once */

  /* -xrfcheck */
  xrfcheck_option =
    gt_option_new_string("xrfcheck", "check Dbxref and Ontology_term "
                         "attributes for correct syntax according to a "
                         "abbreviation definition file.\nIf no argument is "
                         "given, the GO.xrf_abbs file from the "
                         "gtdata/xrf_abbr directory is used.\nIf an argument "
                         "is given, it is used as an specific filename for an "
                         "abbreviation file.\nIn the case that such a "
                         "file does not exist, '.xrf_abbr' is added to the "
                         "argument and loading the resulting filename from the "
                         "gtdata/xrf_abbr directory is attempted.",
                         xci->xrfcheck, NULL);
  gt_option_argument_is_optional(xrfcheck_option);
  gt_option_parser_add_option(op, xrfcheck_option);
  xci->xrfcheck_option = gt_option_ref(xrfcheck_option);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x18e708
movq %rsi, %r14
testq %rsi, %rsi
je 0x18e708
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
jne 0x18e70d
movq (%rbx), %rdx
leaq 0x218020(%rip), %rdi    # 0x3a66f2
leaq 0x218022(%rip), %rsi    # 0x3a66fb
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r15
movq %rax, %rdi
callq 0x10fe42
movq %r14, %rdi
movq %r15, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10cc3c
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x5b620
callq 0x5b657
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/xrfcheck_info.c
// Function: gt_xrfcheck_info_create_xrf_checker
GtXRFChecker* gt_xrfcheck_info_create_xrf_checker(const GtXRFCheckInfo *xci,
                                                  GtError *err)
{
  GtXRFChecker *xrf_checker = NULL;
  int had_err = 0;
  GtStr *xrf_file;
  gt_error_check(err);
  gt_assert(xci);
  gt_assert(gt_option_is_set(xci->xrfcheck_option));
  if (!gt_str_length(xci->xrfcheck)) {
    /* a. */
    if (!(xrf_file = get_xrf_path(err)))
      had_err = -1;
    if (!had_err)
      gt_str_append_cstr(xrf_file, "GO.xrf_abbr");
  }
  else if (gt_file_exists(gt_str_get(xci->xrfcheck))) {
    /* b. */
    xrf_file = gt_str_new_cstr(gt_str_get(xci->xrfcheck));
  }
  else {
    /* c. */
    if (!(xrf_file = get_xrf_path(err)))
      had_err = -1;
    if (!had_err) {
      gt_str_append_str(xrf_file, xci->xrfcheck);
      gt_str_append_cstr(xrf_file, ".xrf_abbr");
    }
  }

  if (!had_err)
    xrf_checker = gt_xrf_checker_new(gt_str_get(xrf_file), err);

  gt_str_delete(xrf_file);
  return xrf_checker;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
testq %rsi, %rsi
je 0x18e74a
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x18e81c
testq %r15, %r15
je 0x18e812
movq 0x8(%r15), %rdi
callq 0x10fe52
testb %al, %al
je 0x18e817
movq (%r15), %rdi
callq 0x120d4c
testq %rax, %rax
je 0x18e79a
movq (%r15), %rdi
callq 0x120d23
movq %rax, %rdi
callq 0x10415c
testb %al, %al
je 0x18e7b3
movq (%r15), %rdi
callq 0x120d23
movq %rax, %rdi
callq 0x120955
movq %rax, %r14
jmp 0x18e7dd
movq %rbx, %rdi
callq 0x18e821
movq %rax, %r14
testq %rax, %rax
je 0x18e7e1
leaq 0x218192(%rip), %rsi    # 0x3a6943
jmp 0x18e7d5
movq %rbx, %rdi
callq 0x18e821
movq %rax, %r14
testq %rax, %rax
je 0x18e7e1
movq (%r15), %rsi
movq %r14, %rdi
callq 0x120a43
leaq 0x218170(%rip), %rsi    # 0x3a6945
movq %r14, %rdi
callq 0x12097f
movb $0x1, %al
jmp 0x18e7e3
xorl %eax, %eax
testb %al, %al
je 0x18e7ff
movq %r14, %rdi
callq 0x120d23
movq %rax, %rdi
movq %rbx, %rsi
callq 0x18e4e5
movq %rax, %rbx
jmp 0x18e801
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x121b03
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x5b733
callq 0x5b6fc
callq 0x5b6c5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/xrfcheck_info.c
// Function: get_xrf_path
static GtStr* get_xrf_path(GtError *err)
{
  const char *progname;
  GtStr *xrf_path, *prog;
  gt_error_check(err);
  progname = gt_error_get_progname(err);
  gt_assert(progname != NULL);
  prog = gt_str_new();
  gt_str_append_cstr_nt(prog, progname,
                        gt_cstr_length_up_to_char(progname, ' '));
  xrf_path = gt_get_gtdata_path(gt_str_get(prog), err);
  if (xrf_path)
    gt_str_append_cstr(xrf_path, "/xrf_abbr/");
  gt_str_delete(prog);
  return xrf_path;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x18e83a
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x18e8ad
movq %rbx, %rdi
callq 0x101b22
testq %rax, %rax
je 0x18e8a8
movq %rax, %r15
callq 0x1208f8
movq %rax, %r14
movq %r15, %rdi
movl $0x20, %esi
callq 0xe885c
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x120a9d
movq %r14, %rdi
callq 0x120d23
movq %rax, %rdi
movq %rbx, %rsi
callq 0x105688
movq %rax, %rbx
testq %rax, %rax
je 0x18e897
leaq 0x2180cd(%rip), %rsi    # 0x3a695c
movq %rbx, %rdi
callq 0x12097f
movq %r14, %rdi
callq 0x121b03
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x5b7a1
callq 0x5b76a
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/asqg_writer.c
// Function: gt_asqg_writer_new
GtAsqgWriter* gt_asqg_writer_new(GtFile *file, const GtEncseq *encseq)
{
  GtAsqgWriter *aw;
  aw = gt_malloc(sizeof (*aw));
  aw->file = file;
  aw->encseq = encseq;
  return aw;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x214a7f(%rip), %rsi    # 0x3a7544
movl $0x10, %edi
movl $0x1f, %edx
callq 0x1092b2
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/asqg_writer.c
// Function: gt_asqg_writer_show_header
int gt_asqg_writer_show_header(GtAsqgWriter *aw, float erate,
    GtUword minlen, const char *inputfilename, bool has_containments,
    bool has_transitives, GT_UNUSED GtError *err)
{
  gt_assert(aw != NULL);
  gt_file_xprintf(aw->file,
      "HT\tVN:i:%d\tER:f:%g\tOL:i:"GT_WU"\tIN:Z:%s\tCN:i:%c\tTE:i:%c\n",
      GT_ASQG_VERSION, erate, minlen, inputfilename,
      has_containments ? '1' : '0', has_transitives ? '1' : '0');
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x192b25
movq %rdx, %rax
movq %rsi, %r10
movq (%rdi), %rdi
cvtss2sd %xmm0, %xmm0
movzbl %cl, %r9d
orl $0x30, %r9d
movzbl %r8b, %ecx
orl $0x30, %ecx
movl %ecx, (%rsp)
leaq 0x214a73(%rip), %rsi    # 0x3a7582
movl $0x1, %edx
movq %r10, %rcx
movq %rax, %r8
movb $0x1, %al
callq 0x103d21
xorl %eax, %eax
popq %rcx
retq
callq 0x5c86e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/asqg_writer.c
// Function: gt_spmproc_show_asqg
void gt_spmproc_show_asqg(GtUword suffix_readnum,
    GtUword prefix_readnum, GtUword length,
    bool suffixseq_direct, bool prefixseq_direct, void *asqg_writer)
{
  GtAsqgWriter *aw = asqg_writer;
  const GtUword sl1 = gt_encseq_seqlength(aw->encseq, suffix_readnum),
                      sl2 = gt_encseq_seqlength(aw->encseq, prefix_readnum);
  gt_asqg_writer_show_edge_line(aw->file, suffix_readnum, prefix_readnum,
      suffixseq_direct ? sl1 - length : 0,
      suffixseq_direct ? sl1 - 1UL : length - 1UL, sl1,
      prefixseq_direct ? 0 : sl2 - length,
      prefixseq_direct ? length - 1UL : sl2 - 1UL, sl2,
      !suffixseq_direct || !prefixseq_direct, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r13
movl %r8d, %ebp
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rsi
movq %rdi, (%rsp)
movq 0x8(%r9), %rdi
callq 0xeffd3
movq %rax, %r14
movq 0x8(%r13), %rdi
movq %r12, %rsi
callq 0xeffd3
movq %rax, %r10
movq (%r13), %rdi
movq %r14, %r8
subq %r15, %r8
leaq -0x1(%r14), %r9
leaq -0x1(%r15), %rax
xorl %ecx, %ecx
testl %ebx, %ebx
cmoveq %rcx, %r8
cmoveq %rax, %r9
movq %r10, %r11
subq %r15, %r11
leaq -0x1(%r10), %r15
testl %ebp, %ebp
cmovneq %rcx, %r11
cmovneq %rax, %r15
andl %ebp, %ebx
xorl $0x31, %ebx
leaq 0x2148dc(%rip), %rsi    # 0x3a75ec
movq (%rsp), %rdx
movq %r12, %rcx
xorl %eax, %eax
pushq $0x0
pushq %rbx
pushq %r10
pushq %r15
pushq %r11
pushq %r14
callq 0x103d21
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/bare-encseq.c
// Function: gt_bare_encseq_delete
void gt_bare_encseq_delete(GtBareEncseq *bare_encseq)
{
  if (bare_encseq != NULL)
  {
    gt_free(bare_encseq->charcount);
    GT_FREEARRAY(&bare_encseq->specialranges,GtBareSpecialrange);
    gt_free(bare_encseq);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x192db5
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
leaq 0x2148b4(%rip), %rsi    # 0x3a7617
movl $0x30, %edx
callq 0x109670
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x192d9a
leaq 0x28(%rbx), %r14
leaq 0x214896(%rip), %rsi    # 0x3a7617
movl $0x31, %edx
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x214876(%rip), %rsi    # 0x3a7617
movq %rbx, %rdi
movl $0x32, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/bare-encseq.c
// Function: gt_bare_encseq_specialrangeiterator_new
GtBareSpecialrangeiterator* gt_bare_encseq_specialrangeiterator_new(
                       const GtBareEncseq *bare_encseq,
                       bool moveforward)
{
  gt_assert(bare_encseq != NULL);
  if (bare_encseq->specialranges.nextfreeGtBareSpecialrange == 0)
  {
    return NULL;
  } else
  {
    GtBareSpecialrangeiterator *sri = gt_malloc(sizeof *sri);

    sri->startptr = bare_encseq->specialranges.spaceGtBareSpecialrange;
    sri->endptr = bare_encseq->specialranges.spaceGtBareSpecialrange +
                  bare_encseq->specialranges.nextfreeGtBareSpecialrange;
    sri->moveforward = moveforward;
    sri->current = moveforward ? sri->startptr : sri->endptr - 1;
    return sri;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x19331b
movq %rdi, %r14
cmpq $0x0, 0x38(%rdi)
je 0x193311
movl %esi, %ebx
leaq 0x214342(%rip), %rsi    # 0x3a7617
movl $0x20, %edi
movl $0xfc, %edx
callq 0x1092b2
movq 0x28(%r14), %rcx
movq %rcx, (%rax)
movq 0x38(%r14), %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rsi
movq %rsi, 0x8(%rax)
movb %bl, 0x18(%rax)
addq %rcx, %rdx
addq $-0x10, %rdx
testb %bl, %bl
cmovneq %rcx, %rdx
movq %rdx, 0x10(%rax)
jmp 0x193313
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x5cbf2
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/bare-encseq.c
// Function: bare_encseq_convert
void bare_encseq_convert(GtBareEncseq *bare_encseq,bool forward,bool direct)
{
  GtUchar *leftptr, *rightptr;

  if (forward)
  {
    gt_assert(!direct);
    for (leftptr = bare_encseq->sequence;
         leftptr < bare_encseq->sequence + bare_encseq->totallength;
         leftptr++)
    {
      if (GT_ISNOTSPECIAL(*leftptr))
      {
        *leftptr = GT_COMPLEMENTBASE(*leftptr);
      }
    }
  } else
  {
    if (direct)
    {
      for (leftptr = bare_encseq->sequence,
           rightptr = bare_encseq->sequence + bare_encseq->totallength - 1;
           leftptr < rightptr; leftptr++, rightptr--)
      {
        GtUchar tmp = *leftptr;
        *leftptr = *rightptr;
        *rightptr = tmp;
      }
    } else
    {
      for (leftptr = bare_encseq->sequence,
           rightptr = bare_encseq->sequence + bare_encseq->totallength - 1;
           leftptr <= rightptr; leftptr++, rightptr--)
      {
        GtUchar tmp = *leftptr;
        *leftptr = GT_ISSPECIAL(*rightptr) ? *rightptr
                                        : GT_COMPLEMENTBASE(*rightptr);
        *rightptr = GT_ISSPECIAL(tmp) ? tmp
                                   : GT_COMPLEMENTBASE(tmp);
      }
    }
  }
}

// Assembly:
pushq %rax
testl %esi, %esi
je 0x1933c5
testb %dl, %dl
jne 0x193443
cmpq $0x0, 0x8(%rdi)
jle 0x193441
movq (%rdi), %rax
movb (%rax), %cl
cmpb $-0x3, %cl
ja 0x1933b4
movb $0x3, %dl
subb %cl, %dl
movb %dl, (%rax)
incq %rax
movq (%rdi), %rcx
addq 0x8(%rdi), %rcx
cmpq %rcx, %rax
jb 0x1933a7
jmp 0x193441
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
addq %rax, %rcx
decq %rcx
testb %dl, %dl
je 0x1933fb
cmpq %rcx, %rax
jae 0x193441
incq %rax
movb -0x1(%rax), %dl
movb (%rcx), %sil
movb %sil, -0x1(%rax)
movb %dl, (%rcx)
decq %rcx
leaq 0x1(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x1933de
jmp 0x193441
cmpq %rcx, %rax
ja 0x193441
incq %rax
movzbl -0x1(%rax), %edx
movzbl (%rcx), %esi
movb $0x3, %dil
subb %sil, %dil
cmpb $-0x2, %sil
movzbl %dil, %edi
cmovael %esi, %edi
movb %dil, -0x1(%rax)
movb $0x3, %sil
subb %dl, %sil
cmpb $-0x2, %dl
movzbl %sil, %esi
cmovael %edx, %esi
movb %sil, (%rcx)
decq %rcx
leaq 0x1(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jbe 0x193403
popq %rax
retq
callq 0x5cc2b