LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/translator.c
// Function: gt_translator_find_startcodon
GtTranslatorStatus gt_translator_find_startcodon(GtTranslator *translator,
                                                 GtUword *pos,
                                                 GtError *err)
{
  char n1, n2, n3;
  unsigned int frame;
  GtCodonIteratorStatus retval;
  gt_assert(translator && pos);
  gt_error_check(err);

  while (!(retval =
             gt_codon_iterator_next(translator->ci,
                                    &n1, &n2, &n3, &frame, err))) {
    if (gt_trans_table_is_start_codon(translator->transtable, n1, n2, n3)) {
      *pos = gt_codon_iterator_current_position(translator->ci)-1;
      return GT_TRANSLATOR_OK;
    }
  }
  if (retval == GT_CODON_ITERATOR_END)
    return GT_TRANSLATOR_END;
  else
    return GT_TRANSLATOR_ERROR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x8704b
testq %rsi, %rsi
je 0x8704b
movq %rdx, %r14
movq %rdi, %r15
movq %rsi, 0x8(%rsp)
testq %rdx, %rdx
je 0x86fd1
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x87075
leaq 0x7(%rsp), %r12
leaq 0x6(%rsp), %r13
leaq 0x5(%rsp), %rbp
leaq 0x14(%rsp), %rbx
movq 0x10(%r15), %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
movq %rbx, %r8
movq %r14, %r9
callq 0x8330c
testl %eax, %eax
jne 0x87034
movq (%r15), %rdi
movsbl 0x7(%rsp), %esi
movsbl 0x6(%rsp), %edx
movsbl 0x5(%rsp), %ecx
callq 0xc11ba
testb %al, %al
je 0x86fe5
movq 0x10(%r15), %rdi
callq 0x83219
decq %rax
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
xorl %eax, %eax
jmp 0x8703c
cmpl $-0x1, %eax
je 0x8703c
pushq $-0x2
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xa6f66(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x4300a(%rip), %rsi     # 0xca066
leaq 0x5d437(%rip), %rdx     # 0xe449a
leaq 0x5d442(%rip), %rcx     # 0xe44ac
leaq 0x5d386(%rip), %r8      # 0xe43f7
pushq $0x55
jmp 0x8709d
movq 0xa6f3c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x42fe0(%rip), %rsi     # 0xca066
leaq 0x435cc(%rip), %rdx     # 0xca659
leaq 0x5d418(%rip), %rcx     # 0xe44ac
leaq 0x5d35c(%rip), %r8      # 0xe43f7
pushq $0x56
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/translator.c
// Function: gt_translator_find_stopcodon
GtTranslatorStatus gt_translator_find_stopcodon(GtTranslator *translator,
                                                GtUword *pos,
                                                GtError *err)
{
  char n1, n2, n3;
  unsigned int frame;
  GtCodonIteratorStatus retval;
  gt_assert(translator && pos);
  gt_error_check(err);

  while (!(retval =
             gt_codon_iterator_next(translator->ci,
                                    &n1, &n2, &n3, &frame, err))) {
    if (gt_trans_table_is_stop_codon(translator->transtable, n1, n2, n3)) {
      *pos = gt_codon_iterator_current_position(translator->ci)-1;
      return GT_TRANSLATOR_OK;
    }
  }
  if (retval == GT_CODON_ITERATOR_END)
    return GT_TRANSLATOR_END;
  else
    return GT_TRANSLATOR_ERROR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x87165
testq %rsi, %rsi
je 0x87165
movq %rdx, %r14
movq %rdi, %r15
movq %rsi, 0x8(%rsp)
testq %rdx, %rdx
je 0x870eb
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x8718f
leaq 0x7(%rsp), %r12
leaq 0x6(%rsp), %r13
leaq 0x5(%rsp), %rbp
leaq 0x14(%rsp), %rbx
movq 0x10(%r15), %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
movq %rbx, %r8
movq %r14, %r9
callq 0x8330c
testl %eax, %eax
jne 0x8714e
movq (%r15), %rdi
movsbl 0x7(%rsp), %esi
movsbl 0x6(%rsp), %edx
movsbl 0x5(%rsp), %ecx
callq 0xc123d
testb %al, %al
je 0x870ff
movq 0x10(%r15), %rdi
callq 0x83219
decq %rax
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
xorl %eax, %eax
jmp 0x87156
cmpl $-0x1, %eax
je 0x87156
pushq $-0x2
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xa6e4c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x42ef0(%rip), %rsi     # 0xca066
leaq 0x5d31d(%rip), %rdx     # 0xe449a
leaq 0x5d346(%rip), %rcx     # 0xe44ca
leaq 0x5d26c(%rip), %r8      # 0xe43f7
pushq $0x6d
jmp 0x871b7
movq 0xa6e22(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x42ec6(%rip), %rsi     # 0xca066
leaq 0x434b2(%rip), %rdx     # 0xca659
leaq 0x5d31c(%rip), %rcx     # 0xe44ca
leaq 0x5d242(%rip), %r8      # 0xe43f7
pushq $0x6e
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/translator.c
// Function: gt_translator_next_with_start
GtTranslatorStatus gt_translator_next_with_start(GtTranslator *translator,
                                                 char *translated,
                                                 unsigned int *frame,
                                                 bool *start,
                                                 GtError *err)
{
  char n1, n2, n3;
  GtCodonIteratorStatus status;
  int retval;
  gt_assert(translator && translated && frame);
  gt_error_check(err);

  status = gt_codon_iterator_next(translator->ci, &n1, &n2, &n3, frame, err);
  if (status == GT_CODON_ITERATOR_END)
    return GT_TRANSLATOR_END;
  if (status == GT_CODON_ITERATOR_ERROR)
    return GT_TRANSLATOR_ERROR;
  retval = gt_trans_table_translate_codon(translator->transtable, n1, n2, n3,
                                          translated, err);
  if (retval)
    return GT_TRANSLATOR_ERROR;
  if (start != NULL)
    *start = gt_trans_table_is_start_codon(translator->transtable, n1, n2, n3);
  gt_assert(*frame < (unsigned int) GT_CODON_LENGTH);
  return GT_TRANSLATOR_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x8743a
movq %rsi, %r13
testq %rsi, %rsi
je 0x8743a
movq %rdx, %rbx
testq %rdx, %rdx
je 0x8743a
movq %r8, %r12
movq %rcx, %r14
movq %rdi, %r15
testq %r8, %r8
je 0x873bd
movq %r12, %rdi
callq 0xc103
testb %al, %al
jne 0x87468
movq 0x10(%r15), %rdi
leaq 0xf(%rsp), %rsi
leaq 0xe(%rsp), %rdx
leaq 0xd(%rsp), %rcx
movq %rbx, %r8
movq %r12, %r9
callq 0x8330c
cmpl $-0x3, %eax
ja 0x8742c
movq (%r15), %rdi
movsbl 0xf(%rsp), %esi
movsbl 0xe(%rsp), %edx
movsbl 0xd(%rsp), %ecx
movq %r13, %r8
movq %r12, %r9
callq 0xc0f5b
testl %eax, %eax
je 0x87406
pushq $-0x2
popq %rax
jmp 0x8742c
testq %r14, %r14
je 0x87425
movq (%r15), %rdi
movsbl 0xf(%rsp), %esi
movsbl 0xe(%rsp), %edx
movsbl 0xd(%rsp), %ecx
callq 0xc11ba
movb %al, (%r14)
xorl %eax, %eax
cmpl $0x3, (%rbx)
jae 0x87496
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xa6b77(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x42c1b(%rip), %rsi     # 0xca066
leaq 0x5d0f0(%rip), %rdx     # 0xe4542
leaq 0x5d10b(%rip), %rcx     # 0xe4564
leaq 0x5cf97(%rip), %r8      # 0xe43f7
movl $0xb7, %r9d
jmp 0x874c2
movq 0xa6b49(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x42bed(%rip), %rsi     # 0xca066
leaq 0x431d9(%rip), %rdx     # 0xca659
leaq 0x5d0dd(%rip), %rcx     # 0xe4564
leaq 0x5cf69(%rip), %r8      # 0xe43f7
movl $0xb8, %r9d
jmp 0x874c2
movq 0xa6b1b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x42bbf(%rip), %rsi     # 0xca066
leaq 0x5d0d4(%rip), %rdx     # 0xe4582
leaq 0x5d0af(%rip), %rcx     # 0xe4564
leaq 0x5cf3b(%rip), %r8      # 0xe43f7
movl $0xc5, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/translator.c
// Function: gt_translator_delete
void gt_translator_delete(GtTranslator *translator)
{
  if (!translator) return;
  if (translator->owntable)
    gt_trans_table_delete(translator->transtable);
  gt_free(translator);
}

// Assembly:
testq %rdi, %rdi
je 0x874fa
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x874e5
movq (%rbx), %rdi
callq 0xc129e
leaq 0x5cf0b(%rip), %rsi     # 0xe43f7
movq %rbx, %rdi
movl $0xce, %edx
popq %rbx
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/luahelper.c
// Function: gt_lua_set_script_dir
void gt_lua_set_script_dir(lua_State *L, const char *scriptpath)
{
  GtStr *scriptdir = gt_str_new();
  gt_file_dirname(scriptdir, scriptpath);
  if (gt_str_length(scriptdir) == 0)
    gt_str_append_cstr(scriptdir, ".");
  lua_getglobal(L, "gt");
  gt_assert(lua_istable(L, -1));
  lua_pushstring(L, gt_str_get(scriptdir));
  lua_setfield(L, -2, "script_dir");
  lua_pop(L, 1);
  gt_str_delete(scriptdir);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
callq 0x13d5c
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x54b8b
movq %rbx, %rdi
callq 0x14461
testq %rax, %rax
jne 0x88812
leaq 0x4abf4(%rip), %rsi     # 0xd33fe
movq %rbx, %rdi
callq 0x13dd3
leaq 0x61a5e(%rip), %rdx     # 0xea277
movq %r14, %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x38a63
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0x37b59
cmpl $0x5, %eax
jne 0x88879
movq %rbx, %rdi
callq 0x143d2
movq %r14, %rdi
movq %rax, %rsi
callq 0x38431
leaq 0x5c24f(%rip), %rdx     # 0xe4a9f
pushq $-0x2
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x38f41
movq %r14, %rdi
movl %ebp, %esi
callq 0x377fa
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x152db
movq 0xa5738(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x417dc(%rip), %rsi     # 0xca066
leaq 0x555ab(%rip), %rdx     # 0xdde3c
leaq 0x5c1fc(%rip), %rcx     # 0xe4a94
leaq 0x5c1b5(%rip), %r8      # 0xe4a54
pushq $0x46
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/luahelper.c
// Function: gt_lua_set_arg
void gt_lua_set_arg(lua_State *L, const char *argv_0, const char **argv)
{
  lua_Integer n = 0;
  gt_assert(L && argv_0);
  /* create table */
  lua_newtable(L);
  /* set arg[0] */
  lua_pushinteger(L, 0);
  lua_pushstring(L, argv_0);
  lua_rawset(L, -3);
  /* set other arguments */
  while (argv[n]) {
    lua_pushinteger(L, n+1);
    lua_pushstring(L, argv[n]);
    lua_rawset(L, -3);
    n++;
  }
  /* register table globally */
  lua_setglobal(L, "arg");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8893f
movq %rsi, %r15
testq %rsi, %rsi
je 0x8893f
movq %rdx, %r14
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x38be5
movq %rbx, %rdi
xorl %esi, %esi
callq 0x38270
movq %rbx, %rdi
movq %r15, %rsi
callq 0x38431
pushq $0x1
popq %r15
pushq $-0x3
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x38f9d
cmpq $0x0, -0x8(%r14,%r15,8)
je 0x88921
movq %rbx, %rdi
movq %r15, %rsi
callq 0x38270
movq -0x8(%r14,%r15,8), %rsi
movq %rbx, %rdi
callq 0x38431
incq %r15
jmp 0x888f2
leaq 0x5104e(%rip), %rdx     # 0xd9976
movq %rbx, %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x38f41
movq 0xa5672(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x41716(%rip), %rsi     # 0xca066
leaq 0x5c153(%rip), %rdx     # 0xe4aaa
leaq 0x5c158(%rip), %rcx     # 0xe4ab6
leaq 0x5c0ef(%rip), %r8      # 0xe4a54
pushq $0x50
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/luahelper.c
// Function: gt_lua_export_metatable
void gt_lua_export_metatable(lua_State *L, const char *metatable_desc)
{
  char *dot, *mt;
  gt_assert(L && metatable_desc);
  mt = gt_cstr_dup(metatable_desc);
  dot = strchr(mt, '.');
  gt_assert(dot);
  *dot = '_';
  lua_setglobal(L, mt);
  gt_free(mt);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x889cd
testq %rsi, %rsi
je 0x889cd
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x4f8ae
movq %rax, %r14
pushq $0x2e
popq %rsi
movq %rax, %rdi
callq 0xb210
testq %rax, %rax
je 0x889f7
movb $0x5f, (%rax)
movq %rbx, %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
movq %r14, %rdx
callq 0x38f41
leaq 0x5c099(%rip), %rsi     # 0xe4a54
pushq $0x6b
popq %rdx
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
movq 0xa55e4(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x41688(%rip), %rsi     # 0xca066
leaq 0x5c0e0(%rip), %rdx     # 0xe4ac5
leaq 0x5c0ed(%rip), %rcx     # 0xe4ad9
leaq 0x5c061(%rip), %r8      # 0xe4a54
pushq $0x65
jmp 0x88a1f
movq 0xa55ba(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x4165e(%rip), %rsi     # 0xca066
leaq 0x5c0e2(%rip), %rdx     # 0xe4af1
leaq 0x5c0c3(%rip), %rcx     # 0xe4ad9
leaq 0x5c037(%rip), %r8      # 0xe4a54
pushq $0x68
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/luahelper.c
// Function: gt_lua_push_strarray_as_table
void gt_lua_push_strarray_as_table(lua_State *L, GtStrArray *sa)
{
  GtUword i;
  gt_assert(L && sa);
  lua_newtable(L);
  for (i = 0; i < gt_str_array_size(sa); i++) {
    lua_pushinteger(L, i+1); /* in Lua we index from 1 on */
    lua_pushstring(L, gt_str_array_get(sa, i));
    lua_rawset(L, -3);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x88a9e
movq %rsi, %rbx
testq %rsi, %rsi
je 0x88a9e
movq %rdi, %r14
xorl %r15d, %r15d
xorl %esi, %esi
xorl %edx, %edx
callq 0x38be5
pushq $-0x3
popq %rbp
movq %rbx, %rdi
callq 0x157f4
cmpq %rax, %r15
jae 0x88a95
leaq 0x1(%r15), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x38270
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1555e
movq %r14, %rdi
movq %rax, %rsi
callq 0x38431
movq %r14, %rdi
movl %ebp, %esi
callq 0x38f9d
movq %r12, %r15
jmp 0x88a54
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xa5513(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x415b7(%rip), %rsi     # 0xca066
leaq 0x5c03f(%rip), %rdx     # 0xe4af5
leaq 0x5c040(%rip), %rcx     # 0xe4afd
leaq 0x5bf90(%rip), %r8      # 0xe4a54
pushq $0x71
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/luahelper.c
// Function: gt_lua_get_table_as_strarray
int gt_lua_get_table_as_strarray(lua_State *L, int index, GtStrArray *outarray,
                                 GtError *err)
{
  int had_err = 0;
  gt_assert(lua_istable(L, index));
  lua_pushnil(L);
  while (!had_err && (lua_next(L, index) != 0))
  {
    if (!lua_isstring(L, -1)) {
      had_err = -1;
      gt_error_set(err, "table contains non-string value!");
      break;
    }
    gt_str_array_add_cstr(outarray, lua_tostring(L, -1));
    lua_pop(L, 1);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
callq 0x37b59
cmpl $0x5, %eax
jne 0x88b6e
movq %r12, %rdi
callq 0x3824a
pushq $-0x1
popq %r15
pushq $-0x2
popq %r13
movq %r12, %rdi
movl %ebp, %esi
callq 0x397b9
testl %eax, %eax
je 0x88b46
movq %r12, %rdi
movl %r15d, %esi
callq 0x37c2b
testl %eax, %eax
je 0x88b4b
movq %r12, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x37f9b
movq %r14, %rdi
movq %rax, %rsi
callq 0x15407
movq %r12, %rdi
movl %r13d, %esi
callq 0x377fa
jmp 0x88b04
xorl %r15d, %r15d
jmp 0x88b5c
leaq 0x5bfe6(%rip), %rsi     # 0xe4b38
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc007
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xa5443(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x414e7(%rip), %rsi     # 0xca066
leaq 0x5523f(%rip), %rdx     # 0xdddc5
leaq 0x5bf8e(%rip), %rcx     # 0xe4b1b
leaq 0x5bec0(%rip), %r8      # 0xe4a54
pushq $0x7e
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/luahelper.c
// Function: gt_lua_error
int gt_lua_error(lua_State *L, GtError *err)
{
  gt_assert(L && err);
  gt_assert(gt_error_is_set(err));
  luaL_where(L, 1);
  lua_pushstring(L, gt_error_get(err));
  gt_error_delete(err);
  lua_concat(L, 2);
  return lua_error(L);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x88c04
movq %rsi, %r14
testq %rsi, %rsi
je 0x88c04
movq %rdi, %rbx
movq %r14, %rdi
callq 0xc103
testb %al, %al
je 0x88c32
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3acbd
movq %r14, %rdi
callq 0xc18d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x38431
movq %r14, %rdi
callq 0xc291
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x39932
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3972e
movq 0xa53ad(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x41451(%rip), %rsi     # 0xca066
leaq 0x5bf3d(%rip), %rdx     # 0xe4b59
leaq 0x5bf3f(%rip), %rcx     # 0xe4b62
leaq 0x5be2a(%rip), %r8      # 0xe4a54
movl $0x8f, %r9d
jmp 0x88c5e
movq 0xa537f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x41423(%rip), %rsi     # 0xca066
leaq 0x680ef(%rip), %rdx     # 0xf0d39
leaq 0x5bf11(%rip), %rcx     # 0xe4b62
leaq 0x5bdfc(%rip), %r8      # 0xe4a54
movl $0x90, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/luahelper.c
// Function: gt_lua_try_checkudata
void* gt_lua_try_checkudata(lua_State *L, int ud, const char *tname)
{
  void *p;
  gt_assert(L && tname);
  p = lua_touserdata(L, ud);
  if (p != NULL) {  /* value is a userdata? */
    if (lua_getmetatable(L, ud)) {  /* does it have a metatable? */
      lua_getfield(L, LUA_REGISTRYINDEX, tname);  /* get correct metatable */
      if (lua_rawequal(L, -1, -2)) {  /* does it have the correct mt? */
        lua_pop(L, 2);  /* remove both metatables */
        return p;
      }
    }
  }
  return NULL;  /* to avoid warnings */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x88cdd
movq %rdx, %r15
testq %rdx, %rdx
je 0x88cdd
movl %esi, %ebp
movq %rdi, %r14
callq 0x381c6
testq %rax, %rax
je 0x88ccd
movq %rax, %rbx
movq %r14, %rdi
movl %ebp, %esi
callq 0x38cb7
testl %eax, %eax
je 0x88ccd
movq %r14, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
movq %r15, %rdx
callq 0x38a63
pushq $-0x1
popq %rsi
pushq $-0x2
popq %rdx
movq %r14, %rdi
callq 0x37c5c
testl %eax, %eax
je 0x88ccd
pushq $-0x3
popq %rsi
movq %r14, %rdi
callq 0x377fa
jmp 0x88ccf
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xa52d4(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x41378(%rip), %rsi     # 0xca066
leaq 0x5be7a(%rip), %rdx     # 0xe4b6f
leaq 0x5be7e(%rip), %rcx     # 0xe4b7a
leaq 0x5bd51(%rip), %r8      # 0xe4a54
movl $0x9b, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/region_mapping.c
// Function: gt_region_mapping_new_mapping
GtRegionMapping* gt_region_mapping_new_mapping(GtStr *mapping_filename,
                                               GtError *err)
{
  GtRegionMapping *rm;
  gt_error_check(err);
  gt_assert(mapping_filename);
  rm = gt_calloc(1, sizeof (GtRegionMapping));
  rm->mapping = gt_mapping_new(mapping_filename, "mapping",
                               GT_MAPPINGTYPE_STRING, err);
  if (!rm->mapping) {
    gt_region_mapping_delete(rm);
    return NULL;
  }
  return rm;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x88d34
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x88dac
testq %r14, %r14
je 0x88d82
leaq 0x5be6e(%rip), %rdx     # 0xe4bae
pushq $0x1
popq %rdi
pushq $0x68
popq %rsi
pushq $0x40
popq %rcx
callq 0xce9a
movq %rax, %r15
leaq 0x69579(%rip), %rsi     # 0xf22d1
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x24c30
movq %rax, 0x20(%r15)
testq %rax, %rax
jne 0x88d79
movq %r15, %rdi
callq 0x88de2
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xa522f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x412d3(%rip), %rsi     # 0xca066
leaq 0x5be32(%rip), %rdx     # 0xe4bcc
leaq 0x5bdef(%rip), %rcx     # 0xe4b90
leaq 0x5be06(%rip), %r8      # 0xe4bae
pushq $0x3f
jmp 0x88dd4
movq 0xa5205(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x412a9(%rip), %rsi     # 0xca066
leaq 0x41895(%rip), %rdx     # 0xca659
leaq 0x5bdc5(%rip), %rcx     # 0xe4b90
leaq 0x5bddc(%rip), %r8      # 0xe4bae
pushq $0x3e
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/region_mapping.c
// Function: gt_region_mapping_delete
void gt_region_mapping_delete(GtRegionMapping *rm)
{
  if (!rm) return;
  if (rm->reference_count) {
    rm->reference_count--;
    return;
  }
  gt_str_array_delete(rm->sequence_filenames);
  gt_str_delete(rm->sequence_file);
  gt_str_delete(rm->sequence_name);
  gt_mapping_delete(rm->mapping);
  gt_bioseq_delete(rm->bioseq);
  gt_encseq_delete(rm->encseq);
  gt_seq_col_delete(rm->seq_col);
  gt_seqid2seqnum_mapping_delete(rm->seqid2seqnum_mapping);
  gt_free(rm);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x88df7
movq %rdi, %rbx
movl 0x60(%rdi), %eax
testl %eax, %eax
je 0x88df9
decl %eax
movl %eax, 0x60(%rbx)
popq %rbx
retq
movq (%rbx), %rdi
callq 0x1583a
movq 0x8(%rbx), %rdi
callq 0x152db
movq 0x10(%rbx), %rdi
callq 0x152db
movq 0x20(%rbx), %rdi
callq 0x24ec0
movq 0x28(%rbx), %rdi
callq 0x9d0c7
movq 0x30(%rbx), %rdi
callq 0xa4fe9
movq 0x38(%rbx), %rdi
callq 0xbfa80
movq 0x40(%rbx), %rdi
callq 0x8aa95
leaq 0x5bd67(%rip), %rsi     # 0xe4bae
movq %rbx, %rdi
movl $0x247, %edx            # imm = 0x247
popq %rbx
jmp 0xd249
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/region_mapping.c
// Function: gt_region_mapping_new_seqfiles
GtRegionMapping* gt_region_mapping_new_seqfiles(GtStrArray *sequence_filenames,
                                                bool matchdesc, bool usedesc)
{
  GtRegionMapping *rm;
  gt_assert(sequence_filenames);
  gt_assert(!(matchdesc && usedesc));
  rm = gt_calloc(1, sizeof (GtRegionMapping));
  rm->sequence_filenames = gt_str_array_ref(sequence_filenames);
  rm->matchdesc = matchdesc;
  rm->matchdescstart = false;
  rm->usedesc = usedesc;
  return rm;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x88eae
movl %edx, %ebx
movl %esi, %ebp
movl %ebp, %eax
andb %bl, %al
cmpb $0x1, %al
je 0x88ed8
movq %rdi, %r14
leaq 0x5bd37(%rip), %rdx     # 0xe4bae
pushq $0x1
popq %rdi
pushq $0x68
popq %rsi
pushq $0x50
popq %rcx
callq 0xce9a
movq %rax, %r15
movq %r14, %rdi
callq 0x15356
movq %rax, (%r15)
movb %bpl, 0x18(%r15)
movb $0x0, 0x1a(%r15)
movb %bl, 0x19(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xa5103(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x411a7(%rip), %rsi     # 0xca066
leaq 0x5c275(%rip), %rdx     # 0xe513b
leaq 0x5bd10(%rip), %rcx     # 0xe4bdd
leaq 0x5bcda(%rip), %r8      # 0xe4bae
pushq $0x4e
jmp 0x88f00
movq 0xa50d9(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x4117d(%rip), %rsi     # 0xca066
leaq 0x5bd0c(%rip), %rdx     # 0xe4bfc
leaq 0x5bce6(%rip), %rcx     # 0xe4bdd
leaq 0x5bcb0(%rip), %r8      # 0xe4bae
pushq $0x4f
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/region_mapping.c
// Function: gt_region_mapping_new_encseq
GtRegionMapping* gt_region_mapping_new_encseq(GtEncseq *encseq, bool matchdesc,
                                              bool usedesc)
{
  GtRegionMapping *rm;
  gt_assert(encseq);
  gt_assert(!(matchdesc && usedesc));
  rm = gt_calloc(1, sizeof (GtRegionMapping));
  rm->encseq = gt_encseq_ref(encseq);
  rm->matchdesc = matchdesc;
  rm->usedesc = usedesc;
  rm->matchdescstart = false;
  return rm;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x88f68
movl %edx, %ebx
movl %esi, %ebp
movl %ebp, %eax
andb %bl, %al
cmpb $0x1, %al
je 0x88f92
movq %rdi, %r14
leaq 0x5bc7e(%rip), %rdx     # 0xe4bae
pushq $0x1
popq %rdi
pushq $0x68
popq %rsi
pushq $0x5e
popq %rcx
callq 0xce9a
movq %rax, %r15
movq %r14, %rdi
callq 0xa56aa
movq %rax, 0x30(%r15)
movb %bpl, 0x18(%r15)
movb %bl, 0x19(%r15)
movb $0x0, 0x1a(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xa5049(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x410ed(%rip), %rsi     # 0xca066
leaq 0x5db96(%rip), %rdx     # 0xe6b16
leaq 0x5bc8d(%rip), %rcx     # 0xe4c14
leaq 0x5bc20(%rip), %r8      # 0xe4bae
pushq $0x5c
jmp 0x88fba
movq 0xa501f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x410c3(%rip), %rsi     # 0xca066
leaq 0x5bc52(%rip), %rdx     # 0xe4bfc
leaq 0x5bc63(%rip), %rcx     # 0xe4c14
leaq 0x5bbf6(%rip), %r8      # 0xe4bae
pushq $0x5d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/region_mapping.c
// Function: gt_region_mapping_new_rawseq
GtRegionMapping* gt_region_mapping_new_rawseq(const char *rawseq,
                                              GtUword length,
                                              GtUword offset)
{
  GtRegionMapping *rm;
  gt_assert(rawseq);
  rm = gt_calloc(1, sizeof (GtRegionMapping));
  rm->userawseq = true;
  rm->rawseq = rawseq;
  rm->rawlength = length;
  rm->rawoffset = offset;
  rm->matchdescstart = false;
  return rm;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x89018
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x5bbbc(%rip), %rdx     # 0xe4bae
pushq $0x1
popq %rdi
pushq $0x68
popq %rsi
pushq $0x74
popq %rcx
callq 0xce9a
movq %r15, 0x48(%rax)
movq %r14, 0x50(%rax)
movq %rbx, 0x58(%rax)
movw $0x100, 0x1a(%rax)      # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
movq 0xa4f99(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x4103d(%rip), %rsi     # 0xca066
leaq 0x5bc17(%rip), %rdx     # 0xe4c47
leaq 0x5bbfa(%rip), %rcx     # 0xe4c31
leaq 0x5bb70(%rip), %r8      # 0xe4bae
pushq $0x73
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/region_mapping.c
// Function: region_mapping_map
static GtStr* region_mapping_map(GtRegionMapping *rm,
                                 const char *sequence_region, GtError *err)
{
  gt_error_check(err);
  gt_assert(rm && sequence_region);
  if (!rm->mapping)
    return gt_str_ref(gt_str_array_get_str(rm->sequence_filenames, 0));
  else
    return gt_mapping_map_string(rm->mapping, sequence_region, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x8a476
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x8a4d9
testq %r14, %r14
je 0x8a4ab
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x8a494
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x24f0a
movq (%r15), %rdi
xorl %esi, %esi
callq 0x155ca
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x146aa
movq 0xa3b06(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3fbaa(%rip), %rsi     # 0xca066
leaq 0x5ac9e(%rip), %rdx     # 0xe5161
leaq 0x5ac84(%rip), %rcx     # 0xe514e
leaq 0x5a6dd(%rip), %r8      # 0xe4bae
movl $0x8e, %r9d
jmp 0x8a505
movq 0xa3ad8(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3fb7c(%rip), %rsi     # 0xca066
leaq 0x40168(%rip), %rdx     # 0xca659
leaq 0x5ac56(%rip), %rcx     # 0xe514e
leaq 0x5a6af(%rip), %r8      # 0xe4bae
movl $0x8d, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/reverse.c
// Function: gt_reverse_complement
int gt_reverse_complement(char *dna_seq, GtUword seqlen, GtError *err)
{
  char *front_char, *back_char, tmp_char;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(dna_seq);
  for (front_char = dna_seq, back_char = dna_seq + seqlen - 1;
       front_char <= back_char;
       front_char++, back_char--) {
    had_err = gt_complement(&tmp_char, *front_char, err);
    if (!had_err)
      had_err = gt_complement(front_char, *back_char, err);
    if (!had_err)
      *back_char = tmp_char;
    if (had_err)
      break;
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdx, %rdx
je 0x8a53a
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x8a5bf
testq %r14, %r14
je 0x8a595
leaq (%r15,%r14), %r12
decq %r12
leaq 0x7(%rsp), %r15
cmpq %r12, %r14
ja 0x8a587
movsbl (%r14), %esi
movq %r15, %rdi
movq %rbx, %rdx
callq 0xa1140
testl %eax, %eax
jne 0x8a589
movsbl (%r12), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xa1140
testl %eax, %eax
jne 0x8a589
movb 0x7(%rsp), %al
movb %al, (%r12)
incq %r14
decq %r12
jmp 0x8a54b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xa3a1c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3fac0(%rip), %rsi     # 0xca066
leaq 0x5abf7(%rip), %rdx     # 0xe51a4
leaq 0x5abc3(%rip), %rcx     # 0xe5177
leaq 0x5abd2(%rip), %r8      # 0xe518d
pushq $0x1b
jmp 0x8a5e7
movq 0xa39f2(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3fa96(%rip), %rsi     # 0xca066
leaq 0x40082(%rip), %rdx     # 0xca659
leaq 0x5ab99(%rip), %rcx     # 0xe5177
leaq 0x5aba8(%rip), %r8      # 0xe518d
pushq $0x1a
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/seqid2seqnum_mapping.c
// Function: gt_seqid2seqnum_mapping_new_bioseq
GtSeqid2SeqnumMapping* gt_seqid2seqnum_mapping_new_bioseq(GtBioseq *bioseq,
                                                          GtError *err)
{
  GtSeqid2SeqnumMapping *mapping;
  gt_error_check(err);
  gt_assert(bioseq);
  mapping = gt_malloc(sizeof *mapping);
  mapping->filename = gt_cstr_dup(gt_bioseq_filename(bioseq));
  mapping->map = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
                                (GtFree) seqid_info_delete);
  if (fill_mapping(mapping, bioseq, NULL, err)) {
    gt_seqid2seqnum_mapping_delete(mapping);
    return NULL;
  }
  mapping->cached_seqid = NULL;
  return mapping;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x8a618
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x8a6be
testq %r14, %r14
je 0x8a690
leaq 0x5abab(%rip), %rsi     # 0xe51cf
pushq $0x38
popq %rdi
movl $0xc4, %edx
callq 0xccb0
movq %rax, %r15
movq %r14, %rdi
callq 0x9dc00
movq %rax, %rdi
callq 0x4f8ae
movq %rax, (%r15)
leaq -0x7d2bf(%rip), %rsi    # 0xd38f
leaq 0xa1(%rip), %rdx        # 0x8a6f6
pushq $0x1
popq %rdi
callq 0x55da4
movq %rax, 0x8(%r15)
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x8a700
testl %eax, %eax
je 0x8a682
movq %r15, %rdi
callq 0x8aa95
xorl %r15d, %r15d
jmp 0x8a687
andq $0x0, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xa3921(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3f9c5(%rip), %rsi     # 0xca066
leaq 0x5ab20(%rip), %rdx     # 0xe51c8
leaq 0x5aafd(%rip), %rcx     # 0xe51ac
leaq 0x5ab19(%rip), %r8      # 0xe51cf
movl $0xc3, %r9d
jmp 0x8a6ea
movq 0xa38f3(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3f997(%rip), %rsi     # 0xca066
leaq 0x3ff83(%rip), %rdx     # 0xca659
leaq 0x5aacf(%rip), %rcx     # 0xe51ac
leaq 0x5aaeb(%rip), %r8      # 0xe51cf
movl $0xc2, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/seqid2seqnum_mapping.c
// Function: gt_seqid2seqnum_mapping_delete
void gt_seqid2seqnum_mapping_delete(GtSeqid2SeqnumMapping *mapping)
{
  if (!mapping) return;
  gt_hashmap_delete(mapping->map);
  gt_free(mapping->filename);
  gt_free(mapping);
}

// Assembly:
testq %rdi, %rdi
je 0x8aad8
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x563a7
movq (%rbx), %rdi
leaq 0x5a71b(%rip), %r14     # 0xe51cf
movq %r14, %rsi
movl $0xe6, %edx
callq 0xd249
movq %rbx, %rdi
movq %r14, %rsi
movl $0xe7, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/seqid2seqnum_mapping.c
// Function: gt_seqid2seqnum_mapping_new_seqcol
GtSeqid2SeqnumMapping* gt_seqid2seqnum_mapping_new_seqcol(GtSeqCol *seqcol,
                                                          GtError *err)
{
  GtSeqid2SeqnumMapping *mapping;
  gt_error_check(err);
  gt_assert(seqcol);
  mapping = gt_malloc(sizeof *mapping);
  mapping->filename = NULL;
  mapping->map = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
                                (GtFree) seqid_info_delete);
  if (fill_mapping(mapping, NULL, seqcol, err)) {
    gt_seqid2seqnum_mapping_delete(mapping);
    return NULL;
  }
  mapping->cached_seqid = NULL;
  return mapping;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x8aaf9
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x8ab90
testq %r14, %r14
je 0x8ab62
leaq 0x5a6ca(%rip), %rsi     # 0xe51cf
pushq $0x38
popq %rdi
movl $0xd6, %edx
callq 0xccb0
movq %rax, %r15
andq $0x0, (%rax)
leaq -0x7d791(%rip), %rsi    # 0xd38f
leaq -0x431(%rip), %rdx      # 0x8a6f6
pushq $0x1
popq %rdi
callq 0x55da4
movq %rax, 0x8(%r15)
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x8a700
testl %eax, %eax
je 0x8ab54
movq %r15, %rdi
callq 0x8aa95
xorl %r15d, %r15d
jmp 0x8ab59
andq $0x0, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xa344f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3f4f3(%rip), %rsi     # 0xca066
leaq 0x5a695(%rip), %rdx     # 0xe520f
leaq 0x5a672(%rip), %rcx     # 0xe51f3
leaq 0x5a647(%rip), %r8      # 0xe51cf
movl $0xd5, %r9d
jmp 0x8abbc
movq 0xa3421(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3f4c5(%rip), %rsi     # 0xca066
leaq 0x3fab1(%rip), %rdx     # 0xca659
leaq 0x5a644(%rip), %rcx     # 0xe51f3
leaq 0x5a619(%rip), %r8      # 0xe51cf
movl $0xd4, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/seqid2seqnum_mapping.c
// Function: seqid_info_add
static int seqid_info_add(SeqidInfo *seqid_info, GtUword seqnum,
                          GtUword filenum, const GtRange *range,
                          GT_UNUSED const char *filename,
                          const char *seqid, GtError *err)
{
  SeqidInfoElem *seqid_info_elem_ptr, seqid_info_elem;
  gt_error_check(err);
  gt_assert(range);
  seqid_info_elem_ptr = gt_array_get_first(seqid_info);
  if (range->end == GT_UNDEF_UWORD ||
      seqid_info_elem_ptr->descrange.end == GT_UNDEF_UWORD) {
    gt_error_set(err, "input sequence(s) contain multiple sequences "
                 "with ID \"%s\" and not all of them have description ranges",
                 seqid);
    return -1;
  }
  seqid_info_elem.seqnum = seqnum;
  seqid_info_elem.filenum = filenum;
  seqid_info_elem.descrange = *range;
  gt_array_add(seqid_info, seqid_info_elem);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r15
testq %r9, %r9
je 0x8ae96
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x8af26
testq %r12, %r12
je 0x8aefc
movq %r15, %rdi
callq 0x4b4dc
cmpq $-0x1, 0x8(%r12)
je 0x8aed6
cmpq $-0x1, 0x18(%rax)
je 0x8aed6
leaq 0x8(%rsp), %rsi
movq %rbp, (%rsi)
movq %r13, 0x8(%rsi)
movups (%r12), %xmm0
movups %xmm0, 0x10(%rsi)
pushq $0x20
popq %rdx
movq %r15, %rdi
callq 0x4b801
xorl %eax, %eax
jmp 0x8aeed
leaq 0x5a41e(%rip), %rsi     # 0xe52fb
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xa30b5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3f159(%rip), %rsi     # 0xca066
leaq 0x42520(%rip), %rdx     # 0xcd434
leaq 0x5a3d1(%rip), %rcx     # 0xe52ec
leaq 0x5a2ad(%rip), %r8      # 0xe51cf
pushq $0x3e
jmp 0x8af4e
movq 0xa308b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3f12f(%rip), %rsi     # 0xca066
leaq 0x3f71b(%rip), %rdx     # 0xca659
leaq 0x5a3a7(%rip), %rcx     # 0xe52ec
leaq 0x5a283(%rip), %r8      # 0xe51cf
pushq $0x3d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/seqid2seqnum_mapping.c
// Function: seqid_info_new
static SeqidInfo* seqid_info_new(GtUword seqnum, GtUword filenum,
                                 const GtRange *descrange)
{
  SeqidInfoElem seqid_info_elem;
  GtArray *seqid_info;
  gt_assert(descrange);
  seqid_info = gt_array_new(sizeof (SeqidInfoElem));
  seqid_info_elem.seqnum = seqnum;
  seqid_info_elem.filenum = filenum;
  seqid_info_elem.descrange = *descrange;
  gt_array_add(seqid_info, seqid_info_elem);
  return seqid_info;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %rdx, %rdx
je 0x8afb3
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x20
popq %r12
movq %r12, %rdi
callq 0x4b380
movq %rax, %r13
movq %rsp, %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
movups (%rbx), %xmm0
movups %xmm0, 0x10(%rsi)
movq %rax, %rdi
movq %r12, %rdx
callq 0x4b801
movq %r13, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xa2ffe(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3f0a2(%rip), %rsi     # 0xca066
leaq 0x5a396(%rip), %rdx     # 0xe5361
leaq 0x5a399(%rip), %rcx     # 0xe536b
leaq 0x5a1f6(%rip), %r8      # 0xe51cf
pushq $0x28
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/stream_evaluator.c
// Function: gt_stream_evaluator_new
GtStreamEvaluator* gt_stream_evaluator_new(GtNodeStream *reference,
                                           GtNodeStream *prediction,
                                           bool nuceval, bool evalLTR,
                                           GtUword LTRdelta)
{
  GtStreamEvaluator *evaluator = gt_calloc(1, sizeof (GtStreamEvaluator));
  evaluator->reference = gt_node_stream_ref(reference);
  evaluator->prediction = gt_node_stream_ref(prediction);
  evaluator->nuceval = nuceval;
  evaluator->evalLTR = evalLTR;
  evaluator->LTRdelta = LTRdelta;
  evaluator->slots = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
                                    (GtFree) slot_delete);
  evaluator->mRNA_gene_evaluator = gt_evaluator_new();
  evaluator->CDS_gene_evaluator = gt_evaluator_new();
  evaluator->mRNA_mRNA_evaluator = gt_evaluator_new();
  evaluator->CDS_mRNA_evaluator = gt_evaluator_new();
  evaluator->LTR_evaluator = gt_evaluator_new();
  evaluator->mRNA_exon_evaluators = gt_transcript_evaluators_new();
  evaluator->mRNA_exon_evaluators_collapsed = gt_transcript_evaluators_new();
  evaluator->CDS_exon_evaluators = gt_transcript_evaluators_new();
  evaluator->CDS_exon_evaluators_collapsed = gt_transcript_evaluators_new();
  return evaluator;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r13
leaq 0x5a404(%rip), %rdx     # 0xe5410
pushq $0x1
popq %rdi
movl $0xd0, %esi
movl $0xef, %ecx
callq 0xce9a
movq %rax, %rbx
movq %r13, %rdi
callq 0x25b74
movq %rax, (%rbx)
movq %r12, %rdi
callq 0x25b74
movq %rax, 0x8(%rbx)
movb %r15b, 0x10(%rbx)
movb %bpl, 0x11(%rbx)
movq %r14, 0x18(%rbx)
leaq -0x7dcbc(%rip), %rsi    # 0xd38f
leaq 0x6f(%rip), %rdx        # 0x8b0c1
pushq $0x1
popq %rdi
callq 0x55da4
movq %rax, 0x20(%rbx)
callq 0xc3704
movq %rax, 0x28(%rbx)
callq 0xc3704
movq %rax, 0x30(%rbx)
callq 0xc3704
movq %rax, 0x38(%rbx)
callq 0xc3704
movq %rax, 0x40(%rbx)
callq 0xc3704
movq %rax, 0x48(%rbx)
callq 0x8ed98
movq %rax, 0x50(%rbx)
callq 0x8ed98
movq %rax, 0x58(%rbx)
callq 0x8ed98
movq %rax, 0x60(%rbx)
callq 0x8ed98
movq %rax, 0x68(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/stream_evaluator.c
// Function: determine_missing_features
static int determine_missing_features(GT_UNUSED void *key, void *value,
                                      void *data, GT_UNUSED GtError *err)
{
  GtStreamEvaluator *se = (GtStreamEvaluator*) data;
  Slot *slot = (Slot*) value;
  gt_error_check(err);
  gt_assert(key && value && data);
  if (slot->overlapped_genes_forward) {
    se->missing_genes +=
      gt_bittab_size(slot->overlapped_genes_forward) -
      gt_bittab_count_set_bits(slot->overlapped_genes_forward);
  }
  if (slot->overlapped_genes_reverse) {
    se->missing_genes +=
      gt_bittab_size(slot->overlapped_genes_reverse) -
      gt_bittab_count_set_bits(slot->overlapped_genes_reverse);
  }
  if (slot->overlapped_mRNAs_forward) {
    se->missing_mRNAs +=
      gt_bittab_size(slot->overlapped_mRNAs_forward) -
      gt_bittab_count_set_bits(slot->overlapped_mRNAs_forward);
  }
  if (slot->overlapped_mRNAs_reverse) {
    se->missing_mRNAs +=
      gt_bittab_size(slot->overlapped_mRNAs_reverse) -
      gt_bittab_count_set_bits(slot->overlapped_mRNAs_reverse);
  }
  if (slot->overlapped_LTRs) {
    se->missing_LTRs  += gt_bittab_size(slot->overlapped_LTRs) -
                         gt_bittab_count_set_bits(slot->overlapped_LTRs);
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rcx, %rcx
je 0x8cbd6
movq %rcx, %rdi
callq 0xc103
testb %al, %al
jne 0x8ccf3
testq %r15, %r15
je 0x8ccc5
testq %r14, %r14
je 0x8ccc5
testq %rbx, %rbx
je 0x8ccc5
movq 0x120(%r14), %rdi
testq %rdi, %rdi
je 0x8cc18
callq 0x4df60
movq %rax, %r15
movq 0x120(%r14), %rdi
callq 0x4e0f8
subq %rax, %r15
addq %r15, 0x70(%rbx)
movq 0x128(%r14), %rdi
testq %rdi, %rdi
je 0x8cc3f
callq 0x4df60
movq %rax, %r15
movq 0x128(%r14), %rdi
callq 0x4e0f8
subq %rax, %r15
addq %r15, 0x70(%rbx)
movq 0x130(%r14), %rdi
testq %rdi, %rdi
je 0x8cc69
callq 0x4df60
movq %rax, %r15
movq 0x130(%r14), %rdi
callq 0x4e0f8
subq %rax, %r15
addq %r15, 0x80(%rbx)
movq 0x138(%r14), %rdi
testq %rdi, %rdi
je 0x8cc93
callq 0x4df60
movq %rax, %r15
movq 0x138(%r14), %rdi
callq 0x4e0f8
subq %rax, %r15
addq %r15, 0x80(%rbx)
movq 0x140(%r14), %rdi
testq %rdi, %rdi
je 0x8ccbd
callq 0x4df60
movq %rax, %r15
movq 0x140(%r14), %rdi
callq 0x4e0f8
subq %rax, %r15
addq %r15, 0x90(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0xa12ec(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3d390(%rip), %rsi     # 0xca066
leaq 0x3da56(%rip), %rdx     # 0xca733
leaq 0x58f87(%rip), %rcx     # 0xe5c6b
leaq 0x58725(%rip), %r8      # 0xe5410
movl $0x4e9, %r9d            # imm = 0x4E9
jmp 0x8cd1f
movq 0xa12be(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3d362(%rip), %rsi     # 0xca066
leaq 0x3d94e(%rip), %rdx     # 0xca659
leaq 0x58f59(%rip), %rcx     # 0xe5c6b
leaq 0x586f7(%rip), %r8      # 0xe5410
movl $0x4e8, %r9d            # imm = 0x4E8
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/stream_evaluator.c
// Function: gt_stream_evaluator_delete
void gt_stream_evaluator_delete(GtStreamEvaluator *se)
{
  if (!se) return;
  gt_node_stream_delete(se->reference);
  gt_node_stream_delete(se->prediction);
  gt_hashmap_delete(se->slots);
  gt_evaluator_delete(se->mRNA_gene_evaluator);
  gt_evaluator_delete(se->CDS_gene_evaluator);
  gt_evaluator_delete(se->mRNA_mRNA_evaluator);
  gt_evaluator_delete(se->CDS_mRNA_evaluator);
  gt_evaluator_delete(se->LTR_evaluator);
  gt_transcript_evaluators_delete(se->mRNA_exon_evaluators);
  gt_transcript_evaluators_delete(se->mRNA_exon_evaluators_collapsed);
  gt_transcript_evaluators_delete(se->CDS_exon_evaluators);
  gt_transcript_evaluators_delete(se->CDS_exon_evaluators_collapsed);
  gt_free(se);
}

// Assembly:
testq %rdi, %rdi
je 0x8d631
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x25bbb
movq 0x8(%rbx), %rdi
callq 0x25bbb
movq 0x20(%rbx), %rdi
callq 0x563a7
movq 0x28(%rbx), %rdi
callq 0xc4420
movq 0x30(%rbx), %rdi
callq 0xc4420
movq 0x38(%rbx), %rdi
callq 0xc4420
movq 0x40(%rbx), %rdi
callq 0xc4420
movq 0x48(%rbx), %rdi
callq 0xc4420
movq 0x50(%rbx), %rdi
callq 0x8f015
movq 0x58(%rbx), %rdi
callq 0x8f015
movq 0x60(%rbx), %rdi
callq 0x8f015
movq 0x68(%rbx), %rdi
callq 0x8f015
leaq 0x57ded(%rip), %rsi     # 0xe5410
movq %rbx, %rdi
movl $0x666, %edx            # imm = 0x666
popq %rbx
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/stream_evaluator.c
// Function: add_real_exon
static void add_real_exon(GtTranscriptExons *te, GtRange range,
                          GtFeatureNode *fn)
{
  gt_assert(te);
  gt_array_add(gt_transcript_exons_get_all(te), range);
  switch (gt_feature_node_get_transcriptfeaturetype(fn)) {
    case TRANSCRIPT_FEATURE_TYPE_UNDETERMINED:
      gt_warning("type of feature (single, initial, internal, or terminal) "
                 "given on line %u in file \"%s\" could not be determined, "
                 "because the feature has no Parent attribute. Treating it as "
                 "single.",
                 gt_genome_node_get_line_number((GtGenomeNode*) fn),
                 gt_genome_node_get_filename((GtGenomeNode*) fn));
      /*@fallthrough@*/
    case TRANSCRIPT_FEATURE_TYPE_SINGLE:
      gt_array_add(gt_transcript_exons_get_single(te), range);
      break;
    case TRANSCRIPT_FEATURE_TYPE_INITIAL:
      gt_array_add(gt_transcript_exons_get_initial(te), range);
      break;
    case TRANSCRIPT_FEATURE_TYPE_INTERNAL:
      gt_array_add(gt_transcript_exons_get_internal(te), range);
      break;
    case TRANSCRIPT_FEATURE_TYPE_TERMINAL:
      gt_array_add(gt_transcript_exons_get_terminal(te), range);
      break;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
testq %rdi, %rdi
je 0x8d6e6
movq %rcx, %r14
movq %rdi, %rbx
callq 0x8f0c3
movq %rsp, %rsi
pushq $0x10
popq %rdx
movq %rax, %rdi
callq 0x4b801
movq %r14, %rdi
callq 0x1a3f7
cmpl $0x4, %eax
ja 0x8d6dd
movl %eax, %eax
leaq 0x57d45(%rip), %rcx     # 0xe53c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x8f144
jmp 0x8d6cf
movq %r14, %rdi
callq 0x1c2d8
movl %eax, %ebp
movq %r14, %rdi
callq 0x1c285
leaq 0x58100(%rip), %rdi     # 0xe57a7
movl %ebp, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x161b0
movq %rbx, %rdi
callq 0x8f103
jmp 0x8d6cf
movq %rbx, %rdi
callq 0x8f185
jmp 0x8d6cf
movq %rbx, %rdi
callq 0x8f1c6
movq %rsp, %rsi
pushq $0x10
popq %rdx
movq %rax, %rdi
callq 0x4b801
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0xa08cb(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3c96f(%rip), %rsi     # 0xca066
leaq 0x428e7(%rip), %rdx     # 0xcffe5
leaq 0x58094(%rip), %rcx     # 0xe5799
leaq 0x57d04(%rip), %r8      # 0xe5410
movl $0x1a1, %r9d            # imm = 0x1A1
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/stream_evaluator.c
// Function: add_nucleotide_exon
static void add_nucleotide_exon(GtBittab *nucleotides, GtRange range,
                                GtRange real_range, GtUword *FP)
{
  GtUword i;
  gt_assert(nucleotides);
  for (i = range.start; i <= range.end; i++) {
    if (gt_range_within(&real_range, i)) {
      gt_assert(i >= real_range.start);
      gt_bittab_set_bit(nucleotides, i - real_range.start);
    }
    else {
      gt_assert(FP);
      (*FP)++;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, (%rsp)
movq %r8, 0x8(%rsp)
testq %rdi, %rdi
je 0x8d7f4
movq %r9, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsp, %r13
cmpq %r14, %r15
ja 0x8d780
movq %r13, %rdi
movq %r15, %rsi
callq 0x5d215
testb %al, %al
je 0x8d773
movq %r15, %rsi
subq (%rsp), %rsi
jb 0x8d78e
movq %r12, %rdi
callq 0x4d737
jmp 0x8d77b
testq %rbx, %rbx
je 0x8d7bc
incq (%rbx)
incq %r15
jmp 0x8d74c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xa0823(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3c8c7(%rip), %rsi     # 0xca066
leaq 0x580d5(%rip), %rdx     # 0xe587b
leaq 0x580ba(%rip), %rcx     # 0xe5867
leaq 0x57c5c(%rip), %r8      # 0xe5410
movl $0x1c2, %r9d            # imm = 0x1C2
jmp 0x8d7e8
movq 0xa07f5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3c899(%rip), %rsi     # 0xca066
leaq 0x580bd(%rip), %rdx     # 0xe5891
leaq 0x5808c(%rip), %rcx     # 0xe5867
leaq 0x57c2e(%rip), %r8      # 0xe5410
movl $0x1c6, %r9d            # imm = 0x1C6
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq 0xa07bd(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3c861(%rip), %rsi     # 0xca066
leaq 0x5804f(%rip), %rdx     # 0xe585b
leaq 0x58054(%rip), %rcx     # 0xe5867
leaq 0x57bf6(%rip), %r8      # 0xe5410
movl $0x1bf, %r9d            # imm = 0x1BF
jmp 0x8d7e8