LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/seq_iterator_fastq.c
// Function: parse_fastq_seqname
static inline int parse_fastq_seqname(GtSeqIteratorFastQ *seqit,
                                      GtStr *buffer,
                                      char startchar,
                                      GtError *err)
{
  char currentchar;
  bool firstsymbol = true;
  gt_error_check(err);
  gt_assert(seqit && buffer);
  gt_assert(gt_str_length(buffer) == 0);
  if ((currentchar = fastq_buf_getchar(seqit)) == EOF)
    return EOF;
  seqit->currentread++;
  if (currentchar != startchar) {
    gt_error_set(err, "'%c' expected, '%c' encountered instead in line "GT_WU"",
                      startchar,
                      currentchar,
                      seqit->curline);
    return -2;
  }
  while (currentchar != GT_FASTQ_NEWLINESYMBOL) {
    if (!firstsymbol)
      gt_str_append_char(buffer, currentchar);
    else
      firstsymbol = false;
    if ((currentchar = fastq_buf_getchar(seqit)) == EOF)
      return EOF;
    seqit->currentread++;
  }
  seqit->curline++;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
testq %rcx, %rcx
je 0xa5cca
movq %r12, %rdi
callq 0x34fea
testb %al, %al
jne 0xa5e26
testq %r14, %r14
je 0xa5e1c
movq %r14, %rdi
callq 0x3bb86
testq %rax, %rax
jne 0xa5e21
cmpb $0x1, 0x21(%rbx)
jne 0xa5cf6
movb $0x0, 0x21(%rbx)
movb 0x98(%rbx), %al
jmp 0xa5d3a
movq 0x60(%rbx), %rax
cmpq 0x58(%rbx), %rax
jb 0xa5d25
movq 0x48(%rbx), %rdi
leaq 0x99(%rbx), %rsi
movl $0x2000, %edx           # imm = 0x2000
callq 0x75fcd
cltq
movq %rax, 0x58(%rbx)
testl %eax, %eax
je 0xa5e0a
xorl %eax, %eax
leaq 0x1(%rax), %rcx
movq %rcx, 0x60(%rbx)
movb 0x99(%rbx,%rax), %al
movb %al, 0x98(%rbx)
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpb $-0x1, %al
je 0xa5e10
incq 0x88(%rbx)
cmpb %bpl, %al
jne 0xa5de6
cmpb $0xa, %bpl
je 0xa5ddd
leaq 0x99(%rbx), %r12
movb $0x1, %al
testb $0x1, %al
jne 0xa5d77
movsbl %bpl, %esi
movq %r14, %rdi
callq 0x3b9df
cmpb $0x1, 0x21(%rbx)
jne 0xa5d8a
movb $0x0, 0x21(%rbx)
movb 0x98(%rbx), %bpl
jmp 0xa5dc8
movq 0x60(%rbx), %rax
cmpq 0x58(%rbx), %rax
jb 0xa5db1
movq 0x48(%rbx), %rdi
movl $0x2000, %edx           # imm = 0x2000
movq %r12, %rsi
callq 0x75fcd
cltq
movq %rax, 0x58(%rbx)
testl %eax, %eax
je 0xa5e10
xorl %eax, %eax
leaq 0x1(%rax), %rcx
movq %rcx, 0x60(%rbx)
movb 0x99(%rbx,%rax), %bpl
movb %bpl, 0x98(%rbx)
cmpb $-0x1, %bpl
je 0xa5e10
incq 0x88(%rbx)
xorl %eax, %eax
cmpb $0xa, %bpl
jne 0xa5d67
incq 0x68(%rbx)
xorl %r15d, %r15d
jmp 0xa5e10
movsbl %al, %ecx
movzbl %bpl, %edx
movq 0x68(%rbx), %r8
leaq 0x54ed9(%rip), %rsi     # 0xfacd1
movq %r12, %rdi
xorl %eax, %eax
callq 0x34f1f
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
jmp 0xa5e10
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2301d
callq 0x22fe6
callq 0x22faf
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/tokenizer.c
// Function: gt_tokenizer_new
GtTokenizer* gt_tokenizer_new(GtIO *io)
{
  GtTokenizer *t;
  gt_assert(io);
  t = gt_calloc(1, sizeof *t);
  t->io = io;
  return t;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xa5e55
movq %rdi, %rbx
leaq 0x55098(%rip), %rdx     # 0xfaed4
movl $0x1, %edi
movl $0x18, %esi
movl $0x23, %ecx
callq 0x359a6
movq %rbx, (%rax)
popq %rbx
retq
callq 0x23054
// File: /workspace/github_c_makefile_star2_O3/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 0xa5fe1
callq 0xa5e6a
movq %rax, %rbx
testq %rax, %rax
je 0xa5fd9
movq %rbx, %rdi
callq 0x3c87b
testq %rbx, %rbx
setne %al
popq %rbx
retq
callq 0x23167
// File: /workspace/github_c_makefile_star2_O3/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 0xa646b
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xa45aa
movq 0x10(%rbx), %rdi
callq 0x3c87b
leaq 0x54a77(%rip), %rsi     # 0xfaed4
movq %rbx, %rdi
movl $0xd1, %edx
popq %rbx
jmp 0x35c27
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa64ae
movq %rsi, %rbx
testq %rsi, %rsi
je 0xa64ae
movq %rdi, %r14
leaq 0x54c60(%rip), %rdx     # 0xfb0e7
movl $0x1, %edi
movl $0x18, %esi
movl $0x26, %ecx
callq 0x359a6
movq %r14, (%rax)
movq %rbx, 0x10(%rax)
movb $0x0, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x232b9
// File: /workspace/github_c_makefile_star2_O3/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 0xa64d4
movq %rdi, %rbx
xorl %edi, %edi
callq 0xd9100
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa646c
movb $0x1, 0x8(%rax)
popq %rbx
retq
callq 0x232f0
// File: /workspace/github_c_makefile_star2_O3/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 0xa6535
movq %rsi, %rbx
testq %rsi, %rsi
je 0xa6535
movq %rdi, %r14
cmpb $0x1, 0x8(%rdi)
jne 0xa652a
movq (%r14), %rdi
callq 0xd93e0
movb $0x0, 0x8(%r14)
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x23395
// File: /workspace/github_c_makefile_star2_O3/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 0xa65f6
testq %rsi, %rsi
je 0xa65f6
movq %rdx, %r14
movq %rdi, %r15
movq %rsi, 0x8(%rsp)
testq %rdx, %rdx
je 0xa657a
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0xa65fb
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 0xa372b
testl %eax, %eax
jne 0xa65dd
movq (%r15), %rdi
movsbl 0x7(%rsp), %esi
movsbl 0x6(%rsp), %edx
movsbl 0x5(%rsp), %ecx
callq 0xd935f
testb %al, %al
je 0xa658e
movq 0x10(%r15), %rdi
callq 0xa36cb
decq %rax
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
xorl %eax, %eax
jmp 0xa65e7
cmpl $-0x1, %eax
je 0xa65e7
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x233cc
callq 0x23403
// File: /workspace/github_c_makefile_star2_O3/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 0xa66bc
testq %rsi, %rsi
je 0xa66bc
movq %rdx, %r14
movq %rdi, %r15
movq %rsi, 0x8(%rsp)
testq %rdx, %rdx
je 0xa6640
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0xa66c1
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 0xa372b
testl %eax, %eax
jne 0xa66a3
movq (%r15), %rdi
movsbl 0x7(%rsp), %esi
movsbl 0x6(%rsp), %edx
movsbl 0x5(%rsp), %ecx
callq 0xd93b2
testb %al, %al
je 0xa6654
movq 0x10(%r15), %rdi
callq 0xa36cb
decq %rax
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
xorl %eax, %eax
jmp 0xa66ad
cmpl $-0x1, %eax
je 0xa66ad
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2343a
callq 0x23471
// File: /workspace/github_c_makefile_star2_O3/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 0xa6808
movq %rsi, %r15
testq %rsi, %rsi
je 0xa6808
movq %rdx, %r14
testq %rdx, %rdx
je 0xa6808
movq %rcx, %rbx
movq %rdi, %r12
testq %rcx, %rcx
je 0xa670d
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0xa680d
movq %r15, %rdi
callq 0x3cbed
testq %rax, %rax
je 0xa6793
xorl %r13d, %r13d
movq %r15, %rdi
movq %r13, %rsi
callq 0x3ca6f
movq %rax, %rdi
callq 0xb260
movq %rax, %rbp
cmpl $0x3, %ebp
jne 0xa67d3
incq %r13
movq %r15, %rdi
callq 0x3cbed
cmpq %rax, %r13
jb 0xa671d
jmp 0xa6793
movq %r15, %rdi
callq 0x3cbed
testq %rax, %rax
je 0xa6793
xorl %r13d, %r13d
movq %r15, %rdi
movq %r13, %rsi
callq 0x3ca6f
movb 0x3(%rsp), %cl
cmpb (%rax), %cl
jne 0xa6783
movb 0x2(%rsp), %cl
cmpb 0x1(%rax), %cl
jne 0xa6783
movb 0x1(%rsp), %cl
cmpb 0x2(%rax), %cl
je 0xa67bf
incq %r13
movq %r15, %rdi
callq 0x3cbed
cmpq %rax, %r13
jb 0xa675e
movq 0x10(%r12), %rdi
leaq 0x3(%rsp), %rsi
leaq 0x2(%rsp), %rdx
leaq 0x1(%rsp), %rcx
leaq 0x4(%rsp), %r8
movq %rbx, %r9
callq 0xa372b
testl %eax, %eax
je 0xa674e
cmpl $-0x1, %eax
jne 0xa67f4
jmp 0xa67f9
movq 0x10(%r12), %rdi
callq 0xa36cb
decq %rax
movq %rax, (%r14)
xorl %eax, %eax
jmp 0xa67f9
movq %r15, %rdi
movq %r13, %rsi
callq 0x3ca6f
leaq 0x54a27(%rip), %rsi     # 0xfb20c
movq %rbx, %rdi
movq %rax, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x34f1f
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x234a8
callq 0x234e1
// File: /workspace/github_c_makefile_star2_O3/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 0xa68e7
movq %rsi, %r13
testq %rsi, %rsi
je 0xa68e7
movq %rdx, %rbx
testq %rdx, %rdx
je 0xa68e7
movq %r8, %r12
movq %rcx, %r14
movq %rdi, %r15
testq %r8, %r8
je 0xa6868
movq %r12, %rdi
callq 0x34fea
testb %al, %al
jne 0xa68ec
movq 0x10(%r15), %rdi
leaq 0xf(%rsp), %rsi
leaq 0xe(%rsp), %rdx
leaq 0xd(%rsp), %rcx
movq %rbx, %r8
movq %r12, %r9
callq 0xa372b
cmpl $-0x3, %eax
ja 0xa68d9
movq (%r15), %rdi
movsbl 0xf(%rsp), %esi
movsbl 0xe(%rsp), %edx
movsbl 0xd(%rsp), %ecx
movq %r13, %r8
movq %r12, %r9
callq 0xd913a
movl %eax, %ecx
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
testl %ecx, %ecx
jne 0xa68d9
testq %r14, %r14
je 0xa68d2
movq (%r15), %rdi
movsbl 0xf(%rsp), %esi
movsbl 0xe(%rsp), %edx
movsbl 0xd(%rsp), %ecx
callq 0xd935f
movb %al, (%r14)
xorl %eax, %eax
cmpl $0x3, (%rbx)
jae 0xa68f1
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2351a
callq 0x23553
callq 0x2358c
// File: /workspace/github_c_makefile_star2_O3/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 0xa6922
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0xa690d
movq (%rbx), %rdi
callq 0xd93e0
leaq 0x547d3(%rip), %rsi     # 0xfb0e7
movq %rbx, %rdi
movl $0xce, %edx
popq %rbx
jmp 0x35c27
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3b728
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x762a7
movq %rbx, %rdi
callq 0x3bb86
testq %rax, %rax
jne 0xa7aa0
leaq 0x42976(%rip), %rsi     # 0xea40e
movq %rbx, %rdi
callq 0x3b7af
leaq 0x59554(%rip), %rdx     # 0x100ffb
movq %r14, %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x57f56
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f9b
cmpl $0x5, %eax
jne 0xa7b07
movq %rbx, %rdi
callq 0x3bb5d
movq %r14, %rdi
movq %rax, %rsi
callq 0x5790a
leaq 0x53caf(%rip), %rdx     # 0xfb78f
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x584c8
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3c87b
callq 0x23861
// File: /workspace/github_c_makefile_star2_O3/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 0xa7bac
movq %rsi, %r15
testq %rsi, %rsi
je 0xa7bac
movq %rdx, %r14
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x58130
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5772d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5790a
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58524
cmpq $0x0, (%r14)
je 0xa7b93
movl $0x1, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5772d
movq -0x8(%r14,%r15,8), %rsi
movq %rbx, %rdi
callq 0x5790a
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58524
cmpq $0x0, (%r14,%r15,8)
leaq 0x1(%r15), %r15
jne 0xa7b63
leaq 0x48e2c(%rip), %rdx     # 0xf09c6
movq %rbx, %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
popq %rbx
popq %r14
popq %r15
jmp 0x584c8
callq 0x23898
// File: /workspace/github_c_makefile_star2_O3/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 0xa7c0d
testq %rsi, %rsi
je 0xa7c0d
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x728c0
movq %rax, %r14
movq %rax, %rdi
movl $0x2e, %esi
callq 0xb210
testq %rax, %rax
je 0xa7c12
movb $0x5f, (%rax)
movq %rbx, %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
movq %r14, %rdx
callq 0x584c8
leaq 0x53b4b(%rip), %rsi     # 0xfb744
movq %r14, %rdi
movl $0x6b, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
callq 0x238cf
callq 0x23906
// File: /workspace/github_c_makefile_star2_O3/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 0xa7c96
movq %rsi, %rbx
testq %rsi, %rsi
je 0xa7c96
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x58130
movq %rbx, %rdi
callq 0x3cbed
testq %rax, %rax
je 0xa7c8a
xorl %r15d, %r15d
leaq 0x1(%r15), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x5772d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3ca6f
movq %r14, %rdi
movq %rax, %rsi
callq 0x5790a
movq %r14, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58524
movq %rbx, %rdi
callq 0x3cbed
movq %r12, %r15
cmpq %rax, %r12
jb 0xa7c48
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2393d
// File: /workspace/github_c_makefile_star2_O3/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 0x56f9b
cmpl $0x5, %eax
jne 0xa7d45
movq %r15, %rdi
callq 0x57704
movq %r15, %rdi
movl %ebp, %esi
callq 0x58df3
testl %eax, %eax
je 0xa7d1d
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5706f
testl %eax, %eax
je 0xa7d22
xorl %r12d, %r12d
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x573f8
movq %r14, %rdi
movq %rax, %rsi
callq 0x3c9a5
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq %r15, %rdi
movl %ebp, %esi
callq 0x58df3
testl %eax, %eax
jne 0xa7cd2
jmp 0xa7d39
xorl %r12d, %r12d
jmp 0xa7d39
leaq 0x53aff(%rip), %rsi     # 0xfb828
movq %rbx, %rdi
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x23974
// File: /workspace/github_c_makefile_star2_O3/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 0xa7dae
movq %rsi, %r14
testq %rsi, %rsi
je 0xa7dae
movq %rdi, %rbx
movq %r14, %rdi
callq 0x34fea
testb %al, %al
je 0xa7db3
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a49a
movq %r14, %rdi
callq 0x35012
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5790a
movq %r14, %rdi
callq 0x35085
movq %rbx, %rdi
movl $0x2, %esi
callq 0x58f9f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x58d50
callq 0x239ab
callq 0x239e4
// File: /workspace/github_c_makefile_star2_O3/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 0xa7e31
movq %rdx, %r15
testq %rdx, %rdx
je 0xa7e31
movl %esi, %ebp
movq %rdi, %r14
callq 0x57668
testq %rax, %rax
je 0xa7e21
movq %rax, %rbx
movq %r14, %rdi
movl %ebp, %esi
callq 0x58207
testl %eax, %eax
je 0xa7e21
movq %r14, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
movq %r15, %rdx
callq 0x57f56
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
callq 0x570ae
testl %eax, %eax
je 0xa7e21
movq %r14, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x56b09
jmp 0xa7e23
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x23a1d
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xa7e54
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0xa7ead
testq %r14, %r14
je 0xa7ea8
leaq 0x53a3e(%rip), %rdx     # 0xfb89e
movl $0x1, %edi
movl $0x68, %esi
movl $0x40, %ecx
callq 0x359a6
movq %rax, %r15
leaq 0x611a7(%rip), %rsi     # 0x109025
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x481d8
movq %rax, 0x20(%r15)
testq %rax, %rax
jne 0xa7e9f
movq %r15, %rdi
callq 0xa7eb2
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x23a8d
callq 0x23a56
// File: /workspace/github_c_makefile_star2_O3/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 0xa7ec7
movq %rdi, %rbx
movl 0x60(%rdi), %eax
testl %eax, %eax
je 0xa7ec9
decl %eax
movl %eax, 0x60(%rbx)
popq %rbx
retq
movq (%rbx), %rdi
callq 0x3cc00
movq 0x8(%rbx), %rdi
callq 0x3c87b
movq 0x10(%rbx), %rdi
callq 0x3c87b
movq 0x20(%rbx), %rdi
callq 0x483d5
movq 0x28(%rbx), %rdi
callq 0xbbcc5
movq 0x30(%rbx), %rdi
callq 0xc273d
movq 0x38(%rbx), %rdi
callq 0xd815b
movq 0x40(%rbx), %rdi
callq 0xa936d
leaq 0x53987(%rip), %rsi     # 0xfb89e
movq %rbx, %rdi
movl $0x247, %edx            # imm = 0x247
popq %rbx
jmp 0x35c27
// File: /workspace/github_c_makefile_star2_O3/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 0xa7f84
movl %edx, %ebx
movl %esi, %ebp
movl %ebp, %eax
andb %bl, %al
cmpb $0x1, %al
je 0xa7f89
movq %rdi, %r14
leaq 0x53957(%rip), %rdx     # 0xfb89e
movl $0x1, %edi
movl $0x68, %esi
movl $0x50, %ecx
callq 0x359a6
movq %rax, %r15
movq %r14, %rdi
callq 0x3c8ff
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 0x23afb
callq 0x23ac4
// File: /workspace/github_c_makefile_star2_O3/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 0xa7fee
movl %edx, %ebx
movl %esi, %ebp
movl %ebp, %eax
andb %bl, %al
cmpb $0x1, %al
je 0xa7ff3
movq %rdi, %r14
leaq 0x538ee(%rip), %rdx     # 0xfb89e
movl $0x1, %edi
movl $0x68, %esi
movl $0x5e, %ecx
callq 0x359a6
movq %rax, %r15
movq %r14, %rdi
callq 0xc2d86
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 0x23b69
callq 0x23b32
// File: /workspace/github_c_makefile_star2_O3/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 0xa804e
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x5387c(%rip), %rdx     # 0xfb89e
movl $0x1, %edi
movl $0x68, %esi
movl $0x74, %ecx
callq 0x359a6
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 0x23ba0
// File: /workspace/github_c_makefile_star2_O3/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 0xa8eba
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0xa8ef4
testq %r14, %r14
je 0xa8eef
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0xa8ed8
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x4841f
movq (%r15), %rdi
xorl %esi, %esi
callq 0x3caaa
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3bcaf
callq 0x243a0
callq 0x24367
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdx, %rdx
je 0xa8f22
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0xa8f8c
testq %r14, %r14
je 0xa8f87
leaq (%r14,%r15), %r12
decq %r12
xorl %ebp, %ebp
cmpq %r14, %r12
jb 0xa8f78
leaq 0xf(%rsp), %r15
movsbl (%r14), %esi
movq %r15, %rdi
movq %rbx, %rdx
callq 0xbf1e4
testl %eax, %eax
jne 0xa8f76
movsbl (%r12), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xbf1e4
testl %eax, %eax
jne 0xa8f76
movb 0xf(%rsp), %al
movb %al, (%r12)
incq %r14
decq %r12
cmpq %r12, %r14
jbe 0xa8f3a
jmp 0xa8f78
movl %eax, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x24410
callq 0x243d9
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0xa8fb4
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0xa9038
testq %r14, %r14
je 0xa9033
leaq 0x52eff(%rip), %rsi     # 0xfbebf
movl $0x38, %edi
movl $0xc4, %edx
callq 0x35862
movq %rax, %r15
movq %r14, %rdi
callq 0xbc384
movq %rax, %rdi
callq 0x728c0
movq %rax, (%r15)
leaq -0x73306(%rip), %rsi    # 0x35ce6
leaq 0x4a(%rip), %rdx        # 0xa903d
movl $0x1, %edi
callq 0x7740c
movq %rax, 0x8(%r15)
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xa9047
testl %eax, %eax
je 0xa9022
movq %r15, %rdi
callq 0xa936d
xorl %r15d, %r15d
jmp 0xa902a
movq $0x0, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x24480
callq 0x24447
// File: /workspace/github_c_makefile_star2_O3/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 0xa93b0
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x77bab
movq (%rbx), %rdi
leaq 0x52b33(%rip), %r14     # 0xfbebf
movq %r14, %rsi
movl $0xe6, %edx
callq 0x35c27
movq %rbx, %rdi
movq %r14, %rsi
movl $0xe7, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa93cd
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0xa9445
testq %r14, %r14
je 0xa9440
leaq 0x52ae6(%rip), %rsi     # 0xfbebf
movl $0x38, %edi
movl $0xd6, %edx
callq 0x35862
movq %rax, %r15
movq $0x0, (%rax)
leaq -0x73713(%rip), %rsi    # 0x35ce6
leaq -0x3c3(%rip), %rdx      # 0xa903d
movl $0x1, %edi
callq 0x7740c
movq %rax, 0x8(%r15)
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xa9047
testl %eax, %eax
je 0xa942f
movq %r15, %rdi
callq 0xa936d
xorl %r15d, %r15d
jmp 0xa9437
movq $0x0, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x2460f
callq 0x245d6
// File: /workspace/github_c_makefile_star2_O3/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 0xa9675
movq %r15, %rdi
callq 0x34fea
testb %al, %al
jne 0xa96e4
testq %r12, %r12
je 0xa96df
movq %r14, %rdi
callq 0x6f054
cmpq $-0x1, 0x8(%r12)
je 0xa96b7
cmpq $-0x1, 0x18(%rax)
je 0xa96b7
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 0x6f240
xorl %eax, %eax
jmp 0xa96d0
leaq 0x5292d(%rip), %rsi     # 0xfbfeb
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x24761
callq 0x2472a
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x529d8(%rip), %rdx     # 0xfc0e4
movl $0x1, %edi
movl $0xd0, %esi
movl $0xef, %ecx
callq 0x359a6
movq %rax, %rbx
movq %r13, %rdi
callq 0x48cec
movq %rax, (%rbx)
movq %r12, %rdi
callq 0x48cec
movq %rax, 0x8(%rbx)
movb %r15b, 0x10(%rbx)
movb %bpl, 0x11(%rbx)
movq %r14, 0x18(%rbx)
leaq -0x73a67(%rip), %rsi    # 0x35ce6
leaq 0x71(%rip), %rdx        # 0xa97c5
movl $0x1, %edi
callq 0x7740c
movq %rax, 0x20(%rbx)
callq 0xdb118
movq %rax, 0x28(%rbx)
callq 0xdb118
movq %rax, 0x30(%rbx)
callq 0xdb118
movq %rax, 0x38(%rbx)
callq 0xdb118
movq %rax, 0x40(%rbx)
callq 0xdb118
movq %rax, 0x48(%rbx)
callq 0xac914
movq %rax, 0x50(%rbx)
callq 0xac914
movq %rax, 0x58(%rbx)
callq 0xac914
movq %rax, 0x60(%rbx)
callq 0xac914
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_O3/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 0xaaeb7
movq %rcx, %rdi
callq 0x34fea
testb %al, %al
jne 0xaafab
testq %r15, %r15
je 0xaafa6
testq %r14, %r14
je 0xaafa6
testq %rbx, %rbx
je 0xaafa6
movq 0x120(%r14), %rdi
testq %rdi, %rdi
je 0xaaef9
callq 0x71194
movq %rax, %r15
movq 0x120(%r14), %rdi
callq 0x71242
subq %rax, %r15
addq %r15, 0x70(%rbx)
movq 0x128(%r14), %rdi
testq %rdi, %rdi
je 0xaaf20
callq 0x71194
movq %rax, %r15
movq 0x128(%r14), %rdi
callq 0x71242
subq %rax, %r15
addq %r15, 0x70(%rbx)
movq 0x130(%r14), %rdi
testq %rdi, %rdi
je 0xaaf4a
callq 0x71194
movq %rax, %r15
movq 0x130(%r14), %rdi
callq 0x71242
subq %rax, %r15
addq %r15, 0x80(%rbx)
movq 0x138(%r14), %rdi
testq %rdi, %rdi
je 0xaaf74
callq 0x71194
movq %rax, %r15
movq 0x138(%r14), %rdi
callq 0x71242
subq %rax, %r15
addq %r15, 0x80(%rbx)
movq 0x140(%r14), %rdi
testq %rdi, %rdi
je 0xaaf9e
callq 0x71194
movq %rax, %r15
movq 0x140(%r14), %rdi
callq 0x71242
subq %rax, %r15
addq %r15, 0x90(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x24e51
callq 0x24e18
// File: /workspace/github_c_makefile_star2_O3/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, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rcx, %rcx
je 0xaafd6
movq %rcx, %rdi
callq 0x34fea
testb %al, %al
jne 0xab0e3
testq %r15, %r15
je 0xab0de
testq %r14, %r14
je 0xab0de
testq %rbx, %rbx
je 0xab0de
movq 0xa8(%rbx), %rax
addq 0x78(%r14), %rax
movq 0xc0(%rbx), %rcx
addq 0x80(%r14), %rax
movq %rax, 0xa8(%rbx)
addq 0x88(%r14), %rcx
addq 0x90(%r14), %rcx
leaq 0xa0(%rbx), %r12
movq %rcx, 0xc0(%rbx)
addq $0xb8, %rbx
leaq 0x68(%r14), %rdi
callq 0x7e19f
movq %rax, %rdi
callq 0x70cd4
movq %rax, %r15
movq 0x98(%r14), %rsi
movq 0xa0(%r14), %rdx
leaq 0x51918(%rip), %r8      # 0xfc975
movq %r12, %rdi
movq %rax, %rcx
callq 0xac59d
movq 0xa8(%r14), %rsi
movq 0xb0(%r14), %rdx
leaq 0x51905(%rip), %r8      # 0xfc982
movq %r12, %rdi
movq %r15, %rcx
callq 0xac59d
movq 0xb8(%r14), %rsi
movq 0xc0(%r14), %rdx
leaq 0x518f2(%rip), %r8      # 0xfc98f
movq %rbx, %rdi
movq %r15, %rcx
callq 0xac59d
movq 0xc8(%r14), %rsi
movq 0xd0(%r14), %rdx
leaq 0x518de(%rip), %r8      # 0xfc99b
movq %rbx, %rdi
movq %r15, %rcx
callq 0xac59d
movq %r15, %rdi
callq 0x713d5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x24ec3
callq 0x24e8a