LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/tokenizer.c
// Function: gt_tokenizer_get_token
GtStr* gt_tokenizer_get_token(GtTokenizer *t)
{
  char c;
  bool has_eof = true;
  int rval = 0;
  gt_assert(t);

  /* if we have no current token, get it if possible */
  if (!t->token) {
    if (t->skip_comment_lines && gt_io_line_start(t->io)) {
      for (;;) {
        gt_assert(gt_io_line_start(t->io));
        if ((gt_io_get_char(t->io, (char*) &c) != -1)) {
          if ((char) c == '#') {
            /* skip line */
            while ((gt_io_get_char(t->io, &c) != -1) && c != '\n');
            has_eof = true;
          }
          else {
            gt_io_unget_char(t->io, c);
            has_eof = false;
            break;
          }
        }
        else {
          c = EOF;
          break;
        }
      }
    }
    /* skip blanks */
    while (((rval = gt_io_get_char(t->io, &c)) != -1) && c == ' ');
    if (rval == -1)
      has_eof = true;
    else
      has_eof = false;
    do {
      if (!has_eof) {
        if (!t->token)
          t->token = gt_str_new();
        if (c == '\n')
          break;
        gt_str_append_char(t->token, c);
      }
    } while (((rval = gt_io_get_char(t->io, &c)) != -1)
              && c != ' ' && c != '\n');
    if (rval == -1)
      has_eof = true;
    else
      has_eof = false;
    if (c == '\n' && !has_eof) {
      gt_assert(t->token);
      gt_str_append_char(t->token, c);
    }
  }
  /* return token */
  if (t->token)
    return gt_str_ref(t->token);
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa6881
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
jne 0xa6864
cmpb $0x1, 0x8(%rbx)
jne 0xa67d1
movq (%rbx), %rdi
callq 0xa4e76
testb %al, %al
je 0xa67d1
movq (%rbx), %rdi
callq 0xa4e76
testb %al, %al
je 0xa67ba
leaq 0x7(%rsp), %r14
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xa4e15
cmpl $-0x1, %eax
je 0xa67bf
movb 0x7(%rsp), %al
cmpb $0x23, %al
jne 0xa67c6
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xa4e15
cmpl $-0x1, %eax
je 0xa67ae
cmpb $0xa, 0x7(%rsp)
jne 0xa6797
movq (%rbx), %rdi
callq 0xa4e76
testb %al, %al
jne 0xa677f
callq 0x2319a
movb $-0x1, 0x7(%rsp)
jmp 0xa67d1
movq (%rbx), %rdi
movsbl %al, %esi
callq 0xa4e5f
leaq 0x7(%rsp), %r14
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xa4e15
movl %eax, %ebp
cmpl $-0x1, %eax
je 0xa67ef
cmpb $0x20, 0x7(%rsp)
je 0xa67d6
leaq 0x7(%rsp), %r14
movl %ebp, %r15d
cmpl $-0x1, %ebp
je 0xa6820
cmpq $0x0, 0x10(%rbx)
jne 0xa680c
callq 0x3bfe0
movq %rax, 0x10(%rbx)
movb 0x7(%rsp), %al
cmpb $0xa, %al
je 0xa683f
movq 0x10(%rbx), %rdi
movsbl %al, %esi
callq 0x3c28d
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xa4e15
movl %eax, %r15d
cmpl $-0x1, %eax
je 0xa683f
movb 0x7(%rsp), %al
cmpb $0x20, %al
je 0xa683f
cmpb $0xa, %al
jne 0xa67f7
cmpl $-0x1, %r15d
sete %cl
movb 0x7(%rsp), %al
cmpb $0xa, %al
setne %dl
orb %cl, %dl
jne 0xa6864
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xa6886
movsbl %al, %esi
callq 0x3c28d
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xa6874
callq 0x3c561
jmp 0xa6876
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x23208
callq 0x231d1
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/tokenizer.c
// Function: gt_tokenizer_has_token
bool gt_tokenizer_has_token(GtTokenizer *t)
{
  bool has_token = false;
  GtStr *token;
  gt_assert(t);
  token = gt_tokenizer_get_token(t);
  if (token) {
    has_token = true;
    gt_str_delete(token);
  }
  return has_token;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xa68ae
callq 0xa673e
movq %rax, %rbx
testq %rax, %rax
je 0xa68a6
movq %rbx, %rdi
callq 0x3d1eb
testq %rbx, %rbx
setne %al
popq %rbx
retq
callq 0x2323f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/tokenizer.c
// Function: gt_tokenizer_delete
void gt_tokenizer_delete(GtTokenizer *t)
{
  if (!t) return;
  gt_io_delete(t->io);
  gt_str_delete(t->token);
  gt_free(t);
}

// Assembly:
testq %rdi, %rdi
je 0xa6d32
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xa4de5
movq 0x10(%rbx), %rdi
callq 0x3d1eb
leaq 0x54240(%rip), %rsi     # 0xfaf64
movq %rbx, %rdi
movl $0xd1, %edx
popq %rbx
jmp 0x362a0
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/translator.c
// Function: gt_translator_new_with_table
GtTranslator* gt_translator_new_with_table(GtTransTable *tt,
                                           GtCodonIterator *ci)
{
  GtTranslator *tr;
  gt_assert(tt && ci);
  tr = gt_calloc((size_t) 1, sizeof (GtTranslator));
  tr->transtable = tt;
  tr->ci = ci;
  tr->owntable = false;
  return tr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa6d76
movq %rsi, %rbx
testq %rsi, %rsi
je 0xa6d76
movq %rdi, %r14
leaq 0x54428(%rip), %rdx     # 0xfb177
movl $0x1, %edi
movl $0x18, %esi
movl $0x26, %ecx
callq 0x3601f
movq %r14, (%rax)
movq %rbx, 0x10(%rax)
movb $0x0, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x23391
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/translator.c
// Function: gt_translator_new
GtTranslator* gt_translator_new(GtCodonIterator *ci)
{
  GtTranslator *tr;
  gt_assert(ci);
  tr = gt_translator_new_with_table(gt_trans_table_new_standard(NULL), ci);
  tr->owntable = true;
  return tr;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xa6d9c
movq %rdi, %rbx
xorl %edi, %edi
callq 0xd89f2
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa6d34
movb $0x1, 0x8(%rax)
popq %rbx
retq
callq 0x233c8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/translator.c
// Function: gt_translator_set_translation_table
void gt_translator_set_translation_table(GtTranslator *translator,
                                         GtTransTable *tt)
{
  gt_assert(translator && tt);
  if (translator->owntable) {
    gt_trans_table_delete(translator->transtable);
    translator->owntable = false;
  }
  translator->transtable = tt;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa6dfd
movq %rsi, %rbx
testq %rsi, %rsi
je 0xa6dfd
movq %rdi, %r14
cmpb $0x1, 0x8(%rdi)
jne 0xa6df2
movq (%r14), %rdi
callq 0xd8cb0
movb $0x0, 0x8(%r14)
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x2346d
// File: /workspace/github_c_makefile_star2_O1/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 0xa6ec5
testq %rsi, %rsi
je 0xa6ec5
movq %rdx, %r14
movq %rdi, %r15
movq %rsi, 0x8(%rsp)
testq %rdx, %rdx
je 0xa6e42
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0xa6eca
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 0xa3f3f
testl %eax, %eax
jne 0xa6ea5
movq (%r15), %rdi
movsbl 0x7(%rsp), %esi
movsbl 0x6(%rsp), %edx
movsbl 0x5(%rsp), %ecx
callq 0xd8c2f
testb %al, %al
je 0xa6e56
movq 0x10(%r15), %rdi
callq 0xa3edf
decq %rax
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
xorl %eax, %eax
jmp 0xa6eb6
cmpl $-0x1, %eax
jne 0xa6eb1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xa6eb6
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x234a4
callq 0x234db
// File: /workspace/github_c_makefile_star2_O1/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 0xa6f92
testq %rsi, %rsi
je 0xa6f92
movq %rdx, %r14
movq %rdi, %r15
movq %rsi, 0x8(%rsp)
testq %rdx, %rdx
je 0xa6f0f
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0xa6f97
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 0xa3f3f
testl %eax, %eax
jne 0xa6f72
movq (%r15), %rdi
movsbl 0x7(%rsp), %esi
movsbl 0x6(%rsp), %edx
movsbl 0x5(%rsp), %ecx
callq 0xd8c82
testb %al, %al
je 0xa6f23
movq 0x10(%r15), %rdi
callq 0xa3edf
decq %rax
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
xorl %eax, %eax
jmp 0xa6f83
cmpl $-0x1, %eax
jne 0xa6f7e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xa6f83
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x23512
callq 0x23549
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/translator.c
// Function: gt_translator_find_codon
GtTranslatorStatus gt_translator_find_codon(GtTranslator *translator,
                                            GtStrArray *codons,
                                            GtUword *pos,
                                            GtError *err)
{
  char n1, n2, n3;
  unsigned int frame;
  GtUword i;
  GtCodonIteratorStatus retval;
  gt_assert(translator && codons && pos);
  gt_error_check(err);

  for (i = 0; i<gt_str_array_size(codons); i++) {
    int len;
    if ((len = (int) strlen(gt_str_array_get(codons, i))) != GT_CODON_LENGTH) {
      gt_error_set(err, "invalid codon length for codon %s: %d",
                   gt_str_array_get(codons, i), len);
      return GT_TRANSLATOR_ERROR;
    }
  }

  while (!(retval =
             gt_codon_iterator_next(translator->ci,
                                    &n1, &n2, &n3, &frame, err))) {
    for (i = 0; i<gt_str_array_size(codons); i++) {
      const char *codon;
      codon = gt_str_array_get(codons, i);
      if (n1 == codon[0] && n2 == codon[1] && n3 == codon[2]) {
        *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
pushq %rax
testq %rdi, %rdi
je 0xa70f7
movq %rsi, %r14
testq %rsi, %rsi
je 0xa70f7
movq %rdx, %r15
testq %rdx, %rdx
je 0xa70f7
movq %rcx, %rbx
movq %rdi, %r12
testq %rcx, %rcx
je 0xa6fe3
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0xa70fc
movq %r14, %rdi
callq 0x3d560
testq %rax, %rax
je 0xa7022
xorl %r13d, %r13d
movq %r14, %rdi
movq %r13, %rsi
callq 0x3d3e2
movq %rax, %rdi
callq 0xb260
movq %rax, %rbp
cmpl $0x3, %ebp
jne 0xa70b4
incq %r13
movq %r14, %rdi
callq 0x3d560
cmpq %rax, %r13
jb 0xa6ff3
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
movq 0x10(%r12), %rdi
leaq 0x3(%rsp), %rsi
leaq 0x2(%rsp), %rdx
leaq 0x1(%rsp), %rcx
leaq 0x4(%rsp), %r8
movq %rbx, %r9
callq 0xa3f3f
testl %eax, %eax
jne 0xa70eb
movq %r14, %rdi
callq 0x3d560
testq %rax, %rax
je 0xa7027
xorl %r13d, %r13d
movq %r14, %rdi
movq %r13, %rsi
callq 0x3d3e2
movb 0x3(%rsp), %dl
movb $0x1, %cl
cmpb (%rax), %dl
jne 0xa709b
movb 0x2(%rsp), %dl
cmpb 0x1(%rax), %dl
jne 0xa709b
movb 0x1(%rsp), %dl
cmpb 0x2(%rax), %dl
jne 0xa709b
movq 0x10(%r12), %rdi
callq 0xa3edf
decq %rax
movq %rax, (%r15)
xorl %ecx, %ecx
xorl %ebp, %ebp
testb %cl, %cl
je 0xa70da
incq %r13
movq %r14, %rdi
callq 0x3d560
cmpq %rax, %r13
jb 0xa7060
jmp 0xa7027
movq %r14, %rdi
movq %r13, %rsi
callq 0x3d3e2
leaq 0x541d6(%rip), %rsi     # 0xfb29c
movq %rbx, %rdi
movq %rax, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x3559f
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $-0x1, %eax
jne 0xa70d5
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0xa70da
callq 0x23580
callq 0x235b9
// File: /workspace/github_c_makefile_star2_O1/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 0xa71d6
movq %rsi, %r13
testq %rsi, %rsi
je 0xa71d6
movq %rdx, %rbx
testq %rdx, %rdx
je 0xa71d6
movq %r8, %r12
movq %rcx, %r14
movq %rdi, %r15
testq %r8, %r8
je 0xa7157
movq %r12, %rdi
callq 0x3566a
testb %al, %al
jne 0xa71db
movq 0x10(%r15), %rdi
leaq 0xf(%rsp), %rsi
leaq 0xe(%rsp), %rdx
leaq 0xd(%rsp), %rcx
movq %rbx, %r8
movq %r12, %r9
callq 0xa3f3f
cmpl $-0x3, %eax
ja 0xa71c8
movq (%r15), %rdi
movsbl 0xf(%rsp), %esi
movsbl 0xe(%rsp), %edx
movsbl 0xd(%rsp), %ecx
movq %r13, %r8
movq %r12, %r9
callq 0xd8a2c
movl %eax, %ecx
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
testl %ecx, %ecx
jne 0xa71c8
testq %r14, %r14
je 0xa71c1
movq (%r15), %rdi
movsbl 0xf(%rsp), %esi
movsbl 0xe(%rsp), %edx
movsbl 0xd(%rsp), %ecx
callq 0xd8c2f
movb %al, (%r14)
xorl %eax, %eax
cmpl $0x3, (%rbx)
jae 0xa71e0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x235f2
callq 0x2362b
callq 0x23664
// File: /workspace/github_c_makefile_star2_O1/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 0xa7211
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0xa71fc
movq (%rbx), %rdi
callq 0xd8cb0
leaq 0x53f74(%rip), %rsi     # 0xfb177
movq %rbx, %rdi
movl $0xce, %edx
popq %rbx
jmp 0x362a0
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x3bfe0
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x75d63
movq %rbx, %rdi
callq 0x3c434
testq %rax, %rax
jne 0xa845c
leaq 0x4200a(%rip), %rsi     # 0xea45e
movq %rbx, %rdi
callq 0x3c067
leaq 0x58c24(%rip), %rdx     # 0x101087
movq %r14, %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x58b98
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c5c
cmpl $0x5, %eax
jne 0xa84c3
movq %rbx, %rdi
callq 0x3c40b
movq %r14, %rdi
movq %rax, %rsi
callq 0x58568
leaq 0x53383(%rip), %rdx     # 0xfb81f
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59137
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3d1eb
callq 0x23939
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xa8568
movq %rsi, %r15
testq %rsi, %rsi
je 0xa8568
movq %rdx, %r14
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x58da0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58377
movq %rbx, %rdi
movq %r15, %rsi
callq 0x58568
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x59193
cmpq $0x0, (%r14)
je 0xa854f
movl $0x1, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x58377
movq -0x8(%r14,%r15,8), %rsi
movq %rbx, %rdi
callq 0x58568
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x59193
cmpq $0x0, (%r14,%r15,8)
leaq 0x1(%r15), %r15
jne 0xa851f
leaq 0x484c0(%rip), %rdx     # 0xf0a16
movq %rbx, %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
popq %rbx
popq %r14
popq %r15
jmp 0x59137
callq 0x23970
// File: /workspace/github_c_makefile_star2_O1/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 0xa85c9
testq %rsi, %rsi
je 0xa85c9
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x722dc
movq %rax, %r14
movq %rax, %rdi
movl $0x2e, %esi
callq 0xb210
testq %rax, %rax
je 0xa85ce
movb $0x5f, (%rax)
movq %rbx, %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
movq %r14, %rdx
callq 0x59137
leaq 0x5321f(%rip), %rsi     # 0xfb7d4
movq %r14, %rdi
movl $0x6b, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
callq 0x239a7
callq 0x239de
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa8652
movq %rsi, %rbx
testq %rsi, %rsi
je 0xa8652
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x58da0
movq %rbx, %rdi
callq 0x3d560
testq %rax, %rax
je 0xa8646
xorl %r15d, %r15d
leaq 0x1(%r15), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x58377
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3d3e2
movq %r14, %rdi
movq %rax, %rsi
callq 0x58568
movq %r14, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x59193
movq %rbx, %rdi
callq 0x3d560
movq %r12, %r15
cmpq %rax, %r12
jb 0xa8604
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x23a15
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
callq 0x57c5c
cmpl $0x5, %eax
jne 0xa8701
movq %r15, %rdi
callq 0x5834e
movq %r15, %rdi
movl %ebp, %esi
callq 0x59a33
testl %eax, %eax
je 0xa86d9
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57d30
testl %eax, %eax
je 0xa86de
xorl %r12d, %r12d
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x58042
movq %r14, %rdi
movq %rax, %rsi
callq 0x3d318
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq %r15, %rdi
movl %ebp, %esi
callq 0x59a33
testl %eax, %eax
jne 0xa868e
jmp 0xa86f5
xorl %r12d, %r12d
jmp 0xa86f5
leaq 0x531d3(%rip), %rsi     # 0xfb8b8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x23a4c
// File: /workspace/github_c_makefile_star2_O1/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 0xa876a
movq %rsi, %r14
testq %rsi, %rsi
je 0xa876a
movq %rdi, %rbx
movq %r14, %rdi
callq 0x3566a
testb %al, %al
je 0xa876f
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5b070
movq %r14, %rdi
callq 0x35692
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58568
movq %r14, %rdi
callq 0x35705
movq %rbx, %rdi
movl $0x2, %esi
callq 0x59be2
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5999c
callq 0x23a83
callq 0x23abc
// File: /workspace/github_c_makefile_star2_O1/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 0xa87ed
movq %rdx, %r15
testq %rdx, %rdx
je 0xa87ed
movl %esi, %ebp
movq %rdi, %r14
callq 0x582b2
testq %rax, %rax
je 0xa87dd
movq %rax, %rbx
movq %r14, %rdi
movl %ebp, %esi
callq 0x58e77
testl %eax, %eax
je 0xa87dd
movq %r14, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
movq %r15, %rdx
callq 0x58b98
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
callq 0x57d6f
testl %eax, %eax
je 0xa87dd
movq %r14, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x578d2
jmp 0xa87df
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x23af5
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xa8810
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0xa8869
testq %r14, %r14
je 0xa8864
leaq 0x53112(%rip), %rdx     # 0xfb92e
movl $0x1, %edi
movl $0x68, %esi
movl $0x40, %ecx
callq 0x3601f
movq %rax, %r15
leaq 0x609c3(%rip), %rsi     # 0x1091fd
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x48e48
movq %rax, 0x20(%r15)
testq %rax, %rax
jne 0xa885b
movq %r15, %rdi
callq 0xa886e
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x23b65
callq 0x23b2e
// File: /workspace/github_c_makefile_star2_O1/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 0xa8883
movq %rdi, %rbx
movl 0x60(%rdi), %eax
testl %eax, %eax
je 0xa8885
decl %eax
movl %eax, 0x60(%rbx)
popq %rbx
retq
movq (%rbx), %rdi
callq 0x3d573
movq 0x8(%rbx), %rdi
callq 0x3d1eb
movq 0x10(%rbx), %rdi
callq 0x3d1eb
movq 0x20(%rbx), %rdi
callq 0x4905a
movq 0x28(%rbx), %rdi
callq 0xbac08
movq 0x30(%rbx), %rdi
callq 0xc1690
movq 0x38(%rbx), %rdi
callq 0xd7a53
movq 0x40(%rbx), %rdi
callq 0xa9e28
leaq 0x5305b(%rip), %rsi     # 0xfb92e
movq %rbx, %rdi
movl $0x247, %edx            # imm = 0x247
popq %rbx
jmp 0x362a0
// File: /workspace/github_c_makefile_star2_O1/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 0xa8940
movl %edx, %ebx
movl %esi, %ebp
movl %ebp, %eax
andb %bl, %al
cmpb $0x1, %al
je 0xa8945
movq %rdi, %r14
leaq 0x5302b(%rip), %rdx     # 0xfb92e
movl $0x1, %edi
movl $0x68, %esi
movl $0x50, %ecx
callq 0x3601f
movq %rax, %r15
movq %r14, %rdi
callq 0x3d26f
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
callq 0x23bd3
callq 0x23b9c
// File: /workspace/github_c_makefile_star2_O1/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 0xa89aa
movl %edx, %ebx
movl %esi, %ebp
movl %ebp, %eax
andb %bl, %al
cmpb $0x1, %al
je 0xa89af
movq %rdi, %r14
leaq 0x52fc2(%rip), %rdx     # 0xfb92e
movl $0x1, %edi
movl $0x68, %esi
movl $0x5e, %ecx
callq 0x3601f
movq %rax, %r15
movq %r14, %rdi
callq 0xc1cd3
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
callq 0x23c41
callq 0x23c0a
// File: /workspace/github_c_makefile_star2_O1/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 0xa8a0a
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x52f50(%rip), %rdx     # 0xfb92e
movl $0x1, %edi
movl $0x68, %esi
movl $0x74, %ecx
callq 0x3601f
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
callq 0x23c78
// File: /workspace/github_c_makefile_star2_O1/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 0xa997a
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0xa99b4
testq %r14, %r14
je 0xa99af
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0xa9998
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x490a4
movq (%r15), %rdi
xorl %esi, %esi
callq 0x3d41d
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3c561
callq 0x24478
callq 0x2443f
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0xa99de
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0xa9a41
testq %r14, %r14
je 0xa9a3c
leaq (%r14,%r15), %r12
decq %r12
cmpq %r14, %r12
jb 0xa9a2e
leaq 0x7(%rsp), %r15
movsbl (%r14), %esi
movq %r15, %rdi
movq %rbx, %rdx
callq 0xbe154
testl %eax, %eax
jne 0xa9a17
movsbl (%r12), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xbe154
testl %eax, %eax
jne 0xa9a30
movb 0x7(%rsp), %al
movb %al, (%r12)
incq %r14
decq %r12
cmpq %r12, %r14
jbe 0xa99f4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x244e8
callq 0x244b1
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xa9a68
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0xa9aec
testq %r14, %r14
je 0xa9ae7
leaq 0x524db(%rip), %rsi     # 0xfbf4f
movl $0x38, %edi
movl $0xc4, %edx
callq 0x35ee2
movq %rax, %r15
movq %r14, %rdi
callq 0xbb2c6
movq %rax, %rdi
callq 0x722dc
movq %rax, (%r15)
leaq -0x73741(%rip), %rsi    # 0x3635f
leaq 0x4a(%rip), %rdx        # 0xa9af1
movl $0x1, %edi
callq 0x76f28
movq %rax, 0x8(%r15)
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xa9afb
testl %eax, %eax
je 0xa9ad6
movq %r15, %rdi
callq 0xa9e28
xorl %r15d, %r15d
jmp 0xa9ade
movq $0x0, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x24558
callq 0x2451f
// File: /workspace/github_c_makefile_star2_O1/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 0xa9e6b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x77675
movq (%rbx), %rdi
leaq 0x52108(%rip), %r14     # 0xfbf4f
movq %r14, %rsi
movl $0xe6, %edx
callq 0x362a0
movq %rbx, %rdi
movq %r14, %rsi
movl $0xe7, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa9e88
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0xa9f00
testq %r14, %r14
je 0xa9efb
leaq 0x520bb(%rip), %rsi     # 0xfbf4f
movl $0x38, %edi
movl $0xd6, %edx
callq 0x35ee2
movq %rax, %r15
movq $0x0, (%rax)
leaq -0x73b55(%rip), %rsi    # 0x3635f
leaq -0x3ca(%rip), %rdx      # 0xa9af1
movl $0x1, %edi
callq 0x76f28
movq %rax, 0x8(%r15)
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xa9afb
testl %eax, %eax
je 0xa9eea
movq %r15, %rdi
callq 0xa9e28
xorl %r15d, %r15d
jmp 0xa9ef2
movq $0x0, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x246e7
callq 0x246ae
// File: /workspace/github_c_makefile_star2_O1/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, %r15
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
testq %r9, %r9
je 0xaa143
movq %r15, %rdi
callq 0x3566a
testb %al, %al
jne 0xaa1b2
testq %r12, %r12
je 0xaa1ad
movq %r14, %rdi
callq 0x6ea17
cmpq $-0x1, 0x8(%r12)
je 0xaa185
cmpq $-0x1, 0x18(%rax)
je 0xaa185
leaq 0x8(%rsp), %rsi
movq %rbp, (%rsi)
movq %r13, 0x8(%rsi)
movups (%r12), %xmm0
movups %xmm0, 0x10(%rsi)
movl $0x20, %edx
movq %r14, %rdi
callq 0x6ec0e
xorl %eax, %eax
jmp 0xaa19e
leaq 0x51eef(%rip), %rsi     # 0xfc07b
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x24839
callq 0x24802
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x51f9c(%rip), %rdx     # 0xfc174
movl $0x1, %edi
movl $0xd0, %esi
movl $0xef, %ecx
callq 0x3601f
movq %rax, %rbx
movq %r13, %rdi
callq 0x49954
movq %rax, (%rbx)
movq %r12, %rdi
callq 0x49954
movq %rax, 0x8(%rbx)
movb %r15b, 0x10(%rbx)
movb %bpl, 0x11(%rbx)
movq %r14, 0x18(%rbx)
leaq -0x73eba(%rip), %rsi    # 0x3635f
leaq 0x71(%rip), %rdx        # 0xaa291
movl $0x1, %edi
callq 0x76f28
movq %rax, 0x20(%rbx)
callq 0xdaa5c
movq %rax, 0x28(%rbx)
callq 0xdaa5c
movq %rax, 0x30(%rbx)
callq 0xdaa5c
movq %rax, 0x38(%rbx)
callq 0xdaa5c
movq %rax, 0x40(%rbx)
callq 0xdaa5c
movq %rax, 0x48(%rbx)
callq 0xad460
movq %rax, 0x50(%rbx)
callq 0xad460
movq %rax, 0x58(%rbx)
callq 0xad460
movq %rax, 0x60(%rbx)
callq 0xad460
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_O1/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 0xab9a2
movq %rcx, %rdi
callq 0x3566a
testb %al, %al
jne 0xaba96
testq %r15, %r15
je 0xaba91
testq %r14, %r14
je 0xaba91
testq %rbx, %rbx
je 0xaba91
movq 0x120(%r14), %rdi
testq %rdi, %rdi
je 0xab9e4
callq 0x70bd9
movq %rax, %r15
movq 0x120(%r14), %rdi
callq 0x70ca1
subq %rax, %r15
addq %r15, 0x70(%rbx)
movq 0x128(%r14), %rdi
testq %rdi, %rdi
je 0xaba0b
callq 0x70bd9
movq %rax, %r15
movq 0x128(%r14), %rdi
callq 0x70ca1
subq %rax, %r15
addq %r15, 0x70(%rbx)
movq 0x130(%r14), %rdi
testq %rdi, %rdi
je 0xaba35
callq 0x70bd9
movq %rax, %r15
movq 0x130(%r14), %rdi
callq 0x70ca1
subq %rax, %r15
addq %r15, 0x80(%rbx)
movq 0x138(%r14), %rdi
testq %rdi, %rdi
je 0xaba5f
callq 0x70bd9
movq %rax, %r15
movq 0x138(%r14), %rdi
callq 0x70ca1
subq %rax, %r15
addq %r15, 0x80(%rbx)
movq 0x140(%r14), %rdi
testq %rdi, %rdi
je 0xaba89
callq 0x70bd9
movq %rax, %r15
movq 0x140(%r14), %rdi
callq 0x70ca1
subq %rax, %r15
addq %r15, 0x90(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x24f68
callq 0x24f2f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/stream_evaluator.c
// Function: compute_nucleotides_values
static int compute_nucleotides_values(GT_UNUSED void *key, void *value,
                                      void *data, GT_UNUSED GtError *err)
{
  GtStreamEvaluator *se = (GtStreamEvaluator*) data;
  Slot *slot = (Slot*) value;
  GtBittab *tmp;
  gt_error_check(err);
  gt_assert(key && value && data);
  /* add ``out of range'' FPs */
  se->mRNA_nucleotides.FP += slot->FP_mRNA_nucleotides_forward;
  se->mRNA_nucleotides.FP += slot->FP_mRNA_nucleotides_reverse;
  se->CDS_nucleotides.FP  += slot->FP_CDS_nucleotides_forward;
  se->CDS_nucleotides.FP  += slot->FP_CDS_nucleotides_reverse;
  /* add other values */
  tmp = gt_bittab_new(gt_range_length(&slot->real_range));
  add_nucleotide_values(&se->mRNA_nucleotides,
                        slot->real_mRNA_nucleotides_forward,
                        slot->pred_mRNA_nucleotides_forward, tmp,
                        "mRNA forward");
  add_nucleotide_values(&se->mRNA_nucleotides,
                        slot->real_mRNA_nucleotides_reverse,
                        slot->pred_mRNA_nucleotides_reverse, tmp,
                        "mRNA reverse");
  add_nucleotide_values(&se->CDS_nucleotides,
                        slot->real_CDS_nucleotides_forward,
                        slot->pred_CDS_nucleotides_forward, tmp,
                        "CDS forward");
  add_nucleotide_values(&se->CDS_nucleotides,
                        slot->real_CDS_nucleotides_reverse,
                        slot->pred_CDS_nucleotides_reverse, tmp,
                        "CDS reverse");
  gt_bittab_delete(tmp);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rcx, %rcx
je 0xabac1
movq %rcx, %rdi
callq 0x3566a
testb %al, %al
jne 0xabbdc
testq %r14, %r14
je 0xabbd7
testq %rbx, %rbx
je 0xabbd7
testq %r15, %r15
je 0xabbd7
leaq 0xa0(%r15), %r12
movq 0xa8(%r15), %rax
movq 0xc0(%r15), %rcx
addq 0x78(%rbx), %rax
movq %rax, 0xa8(%r15)
addq 0x80(%rbx), %rax
movq %rax, 0xa8(%r15)
leaq 0xb8(%r15), %r14
addq 0x88(%rbx), %rcx
movq %rcx, 0xc0(%r15)
addq 0x90(%rbx), %rcx
movq %rcx, 0xc0(%r15)
leaq 0x68(%rbx), %rdi
callq 0x7e05b
movq %rax, %rdi
callq 0x70724
movq %rax, %r15
movq 0x98(%rbx), %rsi
movq 0xa0(%rbx), %rdx
leaq 0x50eaf(%rip), %r8      # 0xfca05
movq %r12, %rdi
movq %rax, %rcx
callq 0xad0ea
movq 0xa8(%rbx), %rsi
movq 0xb0(%rbx), %rdx
leaq 0x50e9c(%rip), %r8      # 0xfca12
movq %r12, %rdi
movq %r15, %rcx
callq 0xad0ea
movq 0xb8(%rbx), %rsi
movq 0xc0(%rbx), %rdx
leaq 0x50e89(%rip), %r8      # 0xfca1f
movq %r14, %rdi
movq %r15, %rcx
callq 0xad0ea
movq 0xc8(%rbx), %rsi
movq 0xd0(%rbx), %rdx
leaq 0x50e75(%rip), %r8      # 0xfca2b
movq %r14, %rdi
movq %r15, %rcx
callq 0xad0ea
movq %r15, %rdi
callq 0x70e34
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x24fda
callq 0x24fa1