LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sampling.c
// Function: gt_sampling_read
GtSampling *gt_sampling_read(FILE *fp)
{
  GtSampling *sampling;

  gt_assert(fp);

  sampling = gt_malloc(sizeof (*sampling));
  sampling->samplingtab = NULL;
  sampling->page_sampling = NULL;
  sampling->current_sample_num =
    sampling->current_sample_elementnum = 0;
  sampling->pagesize = gt_pagesize();

  gt_sampling_io_header_samplingtab(sampling, fp, gt_sampling_xfread);
  if (sampling->method == GT_SAMPLING_PAGES)
    gt_sampling_io_page_sampling(sampling, fp, gt_sampling_xfread);
  gt_assert(sampling->arraysize == sampling->numofsamples);

  return sampling;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x170fdb
movq %rdi, %rbx
leaq 0x220e16(%rip), %rsi    # 0x391c96
movl $0x48, %edi
movl $0xbc, %edx
callq 0x104226
movq %rax, %r14
xorl %eax, %eax
movq %rax, (%r14)
movq %rax, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
callq 0xe3e95
movq %rax, 0x28(%r14)
leaq 0x20(%r14), %r15
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x17b40
cmpq $0x1, %rax
jne 0x170fe0
cmpq $0x0, (%r15)
je 0x170ff1
leaq 0x40(%r14), %r12
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x17b40
cmpq $0x1, %rax
jne 0x170ff6
leaq 0x30(%r14), %r13
movl $0x8, %esi
movl $0x1, %edx
movq %r13, %rdi
movq %rbx, %rcx
callq 0x17b40
cmpq $0x1, %rax
jne 0x171007
cmpq $0x0, (%r13)
je 0x171018
cmpl $0x2, (%r12)
jae 0x17101d
movq (%r14), %rdi
testq %rdi, %rdi
jne 0x170f60
movq 0x20(%r14), %rdi
movq %rdi, 0x8(%r14)
shlq $0x3, %rdi
leaq 0x220d46(%rip), %rsi    # 0x391c96
movl $0xa7, %edx
callq 0x104226
movq %rax, %rdi
movq %rax, (%r14)
movq (%r15), %r13
movl $0x8, %esi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x17b40
cmpq %r13, %rax
jne 0x171022
cmpl $0x1, (%r12)
jne 0x170fc4
movq 0x38(%r14), %rdi
testq %rdi, %rdi
jne 0x170fac
movq 0x8(%r14), %rdi
shlq $0x3, %rdi
leaq 0x220cfb(%rip), %rsi    # 0x391c96
movl $0x7e, %edx
callq 0x104226
movq %rax, %rdi
movq %rax, 0x38(%r14)
movq (%r15), %r15
movl $0x8, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x17b40
cmpq %r15, %rax
jne 0x171038
movq 0x8(%r14), %rax
cmpq 0x20(%r14), %rax
jne 0x171033
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x5317c
movq %rbx, %rdi
callq 0x17be0
testl %eax, %eax
je 0x171044
callq 0x52f85
callq 0x53143
movq %rbx, %rdi
callq 0x17be0
testl %eax, %eax
je 0x171044
callq 0x52fbc
movq %rbx, %rdi
callq 0x17be0
testl %eax, %eax
je 0x171044
callq 0x52ff3
callq 0x5310a
callq 0x5302a
movq %rbx, %rdi
callq 0x17be0
testl %eax, %eax
je 0x171044
callq 0x53063
callq 0x530d1
movq %rbx, %rdi
callq 0x17be0
testl %eax, %eax
jne 0x171066
movq %rbx, %rdi
callq 0x17f00
testl %eax, %eax
je 0x17105c
leaq 0x220f78(%rip), %rdi    # 0x391fcf
callq 0x17690
movl $0x1, %edi
callq 0x17940
callq 0x5309a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sampling.c
// Function: gt_sampling_get_page
void gt_sampling_get_page(GtSampling *sampling,
                          GtUword element_num,
                          GtUword *sampled_element,
                          size_t *position)
{
  gt_assert(sampling != NULL);
  gt_assert(sampled_element != NULL);
  gt_assert(position != NULL);

  switch (sampling->method) {
    case GT_SAMPLING_REGULAR:
      get_regular_page(sampling, element_num, sampled_element, position);
      break;

    case GT_SAMPLING_PAGES:
      get_pagewise_page(sampling, element_num, sampled_element, position);
      break;
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x171129
movq %rdx, %r8
testq %rdx, %rdx
je 0x17112e
testq %rcx, %rcx
je 0x171133
movl 0x40(%rdi), %eax
cmpl $0x1, %eax
je 0x1710bf
testl %eax, %eax
jne 0x171127
movq 0x30(%rdi), %r9
movq %rsi, %rax
xorl %edx, %edx
divq %r9
movq %rax, 0x18(%rdi)
imulq %r9, %rax
movq %rax, 0x10(%rdi)
movq %rax, (%r8)
movq 0x18(%rdi), %rax
shlq $0x3, %rax
jmp 0x17111e
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x171138
jle 0x17113d
movq %rax, %r9
shrq %r9
movq 0x38(%rdi), %rdx
movq $-0x1, %r10
cmpq %rsi, (%rdx,%r9,8)
ja 0x1710e6
movq %r9, %rax
jmp 0x1710e9
movq %r9, %r10
movq %rax, %r11
subq %r10, %r11
movq %r11, %r9
sarq %r9
addq %r10, %r9
cmpq $0x1, %r11
jg 0x1710db
xorl %esi, %esi
testq %r9, %r9
cmovgq %r9, %rsi
leaq (,%rsi,8), %rax
movq (%rdx,%rsi,8), %rdx
movq %rdx, 0x10(%rdi)
movq %rdx, (%r8)
movq %rsi, 0x18(%rdi)
addq (%rdi), %rax
movq (%rax), %rax
movq %rax, (%rcx)
popq %rax
retq
callq 0x5328d
callq 0x53254
callq 0x5321b
callq 0x531e2
callq 0x531b5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sampling.c
// Function: gt_sampling_get_next_elementnum
GtUword gt_sampling_get_next_elementnum(GtSampling *sampling)
{
  gt_assert(sampling->arraysize == sampling->numofsamples);
  gt_assert(sampling->current_sample_num < sampling->numofsamples);
  if (sampling->current_sample_num + 1 == sampling->numofsamples)
    return 0;
  gt_assert((sampling->current_sample_num + 1) < sampling->arraysize);
  switch (sampling->method) {
    case GT_SAMPLING_REGULAR:
      return sampling->current_sample_elementnum + sampling->sampling_rate;
    case GT_SAMPLING_PAGES:
      return sampling->page_sampling[sampling->current_sample_num + 1];
    default:
      return GT_UNDEF_UWORD;
  }
}

// Assembly:
pushq %rax
movq 0x8(%rdi), %rcx
cmpq 0x20(%rdi), %rcx
jne 0x171192
movq 0x18(%rdi), %rax
cmpq %rcx, %rax
jae 0x171197
leaq 0x1(%rax), %rdx
cmpq %rcx, %rdx
jne 0x171168
xorl %eax, %eax
jmp 0x171190
jae 0x17119c
movl 0x40(%rdi), %ecx
cmpl $0x1, %ecx
je 0x171187
movq $-0x1, %rax
testl %ecx, %ecx
jne 0x171190
movq 0x30(%rdi), %rax
addq 0x10(%rdi), %rax
jmp 0x171190
movq 0x38(%rdi), %rcx
movq 0x8(%rcx,%rax,8), %rax
popq %rcx
retq
callq 0x532c6
callq 0x532ff
callq 0x53338
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sampling.c
// Function: gt_sampling_add_sample
void gt_sampling_add_sample(GtSampling *sampling,
                            size_t position,
                            GtUword element_num)
{
  gt_assert(sampling);
  gt_assert(sampling->samplingtab);

  sampling->numofsamples++;

  if (sampling->numofsamples == sampling->arraysize) {
    sampling->arraysize += sampling->arraysize/100 + 10;
    sampling->samplingtab = gt_realloc(sampling->samplingtab,
                                       (size_t) sampling->arraysize *
                                         sizeof (*sampling->samplingtab));
    if (sampling->method == GT_SAMPLING_PAGES) {
      gt_assert(sampling->page_sampling);
      sampling->page_sampling = gt_realloc(sampling->page_sampling,
                                           (size_t) sampling->arraysize *
                                             sizeof (*sampling->page_sampling));
    }
  }
  if (sampling->method == GT_SAMPLING_PAGES)
    sampling->page_sampling[sampling->numofsamples -1] = element_num;
  else
    gt_assert(element_num % sampling->sampling_rate == 0);
  sampling->samplingtab[sampling->numofsamples -1] = position;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1712fa
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1712ff
movq %rdx, %r15
movq %rsi, %rbx
movq 0x20(%r14), %rcx
leaq 0x1(%rcx), %rax
movq %rax, 0x20(%r14)
cmpq 0x8(%r14), %rax
jne 0x1712c4
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %rdx # imm = 0x28F5C28F5C28F5C3
mulq %rdx
shrq $0x2, %rdx
leaq (%rcx,%rdx), %rax
addq %rdx, %rcx
addq $0xb, %rcx
movq %rcx, 0x8(%r14)
leaq 0x58(,%rax,8), %rsi
leaq 0x220a0c(%rip), %rdx    # 0x391c96
movl $0x162, %ecx            # imm = 0x162
callq 0x104461
movq %rax, (%r14)
cmpl $0x1, 0x40(%r14)
jne 0x1712c4
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x171309
movq 0x8(%r14), %rsi
shlq $0x3, %rsi
leaq 0x2209e0(%rip), %rdx    # 0x391c96
movl $0x167, %ecx            # imm = 0x167
callq 0x104461
movq %rax, 0x38(%r14)
cmpl $0x1, 0x40(%r14)
jne 0x1712da
movq 0x20(%r14), %rax
movq 0x38(%r14), %rcx
movq %r15, -0x8(%rcx,%rax,8)
jmp 0x1712e8
movq %r15, %rax
xorl %edx, %edx
divq 0x30(%r14)
testq %rdx, %rdx
jne 0x171304
movq (%r14), %rax
movq 0x20(%r14), %rcx
movq %rbx, -0x8(%rax,%rcx,8)
popq %rbx
popq %r14
popq %r15
retq
callq 0x5348e
callq 0x53455
callq 0x533e3
callq 0x5341c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sampling.c
// Function: gt_sampling_delete
void gt_sampling_delete(GtSampling *sampling)
{
  if (!sampling) return;
  gt_free(sampling->samplingtab);
  gt_free(sampling->page_sampling);
  gt_free(sampling);
}

// Assembly:
testq %rdi, %rdi
je 0x171379
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x220952(%rip), %r14    # 0x391c96
movq %r14, %rsi
movl $0x184, %edx            # imm = 0x184
callq 0x1045eb
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x185, %edx            # imm = 0x185
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x186, %edx            # imm = 0x186
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/scorehandler.c
// Function: gt_scorehandler_new
GtScoreHandler* gt_scorehandler_new(GtWord matchscore,
                                    GtWord mismatchscore,
                                    GtWord gap_opening,
                                    GtWord gap_extension)
{
  GtScoreHandler *scorehandler = gt_malloc(sizeof *scorehandler);

  scorehandler->scorematrix = NULL;
  scorehandler->mappedsequence = true;
  scorehandler->matchscore = matchscore;
  scorehandler->mismatchscore = mismatchscore;
  scorehandler->gap_opening = gap_opening;
  scorehandler->gap_extension = gap_extension;
  scorehandler->downcase = false;
  return scorehandler;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x220c76(%rip), %rsi    # 0x39200d
movl $0x30, %edi
movl $0x29, %edx
callq 0x104226
movq $0x0, 0x20(%rax)
movw $0x1, 0x28(%rax)
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/scorehandler.c
// Function: gt_scorehandler_get_replacement
GtWord gt_scorehandler_get_replacement(const GtScoreHandler *scorehandler,
                                       GtUchar a, GtUchar b)
{
  gt_assert(scorehandler != NULL);
  if (scorehandler->scorematrix == NULL)
  {
    if (scorehandler->mappedsequence)
    {
      return GT_ISSPECIAL(a) || GT_ISSPECIAL(b) || a != b
               ? scorehandler->mismatchscore
               : scorehandler->matchscore;
    }
    if (scorehandler->downcase)
    {
      a = tolower((int) a);
      b = tolower((int) b);
    }
    return a != b ? scorehandler->mismatchscore
                  : scorehandler->matchscore;
  }
  gt_assert(scorehandler->mappedsequence);
  return gt_score_matrix_get_score(scorehandler->scorematrix,a,b);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1714f4
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movb 0x28(%rbx), %al
testq %rdi, %rdi
je 0x17149c
testb %al, %al
je 0x1714f9
movzbl %r14b, %esi
movzbl %bpl, %edx
callq 0x113add
cltq
jmp 0x1714ef
testb %al, %al
je 0x1714c6
xorl %eax, %eax
cmpb $-0x2, %bpl
setae %al
shll $0x3, %eax
cmpb $-0x2, %r14b
movl $0x8, %ecx
cmovaeq %rcx, %rax
cmpb %bpl, %r14b
cmovneq %rcx, %rax
movq (%rbx,%rax), %rax
jmp 0x1714ef
cmpb $0x1, 0x29(%rbx)
jne 0x1714e3
movzbl %r14b, %edi
callq 0x17ae0
movl %eax, %r14d
movzbl %bpl, %edi
callq 0x17ae0
movl %eax, %ebp
xorl %eax, %eax
cmpb %bpl, %r14b
setne %al
movq (%rbx,%rax,8), %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x5367f
callq 0x53648
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/scorehandler.c
// Function: gt_scorehandler_eval_alignmentscore
GtWord gt_scorehandler_eval_alignmentscore(const GtScoreHandler *scorehandler,
                                           const GtAlignment *alignment,
                                           const GtUchar *characters)
{
  gt_assert(scorehandler && alignment && characters);
  if (scorehandler->scorematrix != NULL)
  {
    return gt_alignment_eval_with_affine_scorematrix(characters, alignment,
                                                   scorehandler->scorematrix,
                                                   scorehandler->gap_opening,
                                                   scorehandler->gap_extension);
  } else
  {
    return gt_alignment_eval_with_mapped_affine_score(characters, alignment,
                                                   scorehandler->matchscore,
                                                   scorehandler->mismatchscore,
                                                   scorehandler->gap_opening,
                                                   scorehandler->gap_extension);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x171715
testq %rsi, %rsi
je 0x171715
testq %rdx, %rdx
je 0x171715
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x1716fb
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %r8
movq %rdx, %rdi
movq %rax, %rdx
jmp 0x12163b
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %r8
movq 0x18(%rdi), %r9
movq %rdx, %rdi
movq %rax, %rdx
jmp 0x12160a
pushq %rax
callq 0x536ef
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/script_filter.c
// Function: gt_script_filter_new_generic
static GtScriptFilter* gt_script_filter_new_generic(const char *file,
                                                    bool unsafe,
                                                    GtError *err)
{
  GtScriptFilter *script_filter;
  gt_assert(file);
  script_filter = gt_malloc(sizeof (GtScriptFilter));
  script_filter->filename = gt_str_new_cstr(file);
  script_filter->L = luaL_newstate();
  script_filter->reference_count = 0;
  if (!script_filter->L) {
    gt_error_set(err, "out of memory (cannot create new Lua state)");
    gt_free(script_filter);
    return NULL;
  }
  script_filter_luaL_opencustomlibs(script_filter->L,
                                     script_filter_luasecurelibs);
  if (unsafe)
    script_filter_luaL_opencustomlibs(script_filter->L,
                                      script_filter_luainsecurelibs);
  if (luaL_loadfile(script_filter->L, file) ||
                               lua_pcall(script_filter->L, 0, 0, 0)) {
    gt_error_set(err, "cannot run file: %s",
                 lua_tostring(script_filter->L, -1));
    lua_pop(script_filter->L, 1);
    lua_close(script_filter->L);
    gt_str_delete(script_filter->filename);
    gt_free(script_filter);
    return NULL;
  }
  return script_filter;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x17183d
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
leaq 0x220a9a(%rip), %rsi    # 0x3921df
movl $0x18, %edi
movl $0x46, %edx
callq 0x104226
movq %rax, %rbx
movq %r15, %rdi
callq 0x11acc9
movq %rax, 0x8(%rbx)
callq 0x22810a
movq %rax, (%rbx)
movq $0x0, 0x10(%rbx)
testq %rax, %rax
je 0x171808
leaq 0x34268d(%rip), %rsi    # 0x4b3e10
movq %rax, %rdi
callq 0x17193e
testb %bpl, %bpl
je 0x17179f
movq (%rbx), %rdi
leaq 0x3426d6(%rip), %rsi    # 0x4b3e70
callq 0x17193e
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x227ca2
testl %eax, %eax
jne 0x1717c0
movq (%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x22537b
testl %eax, %eax
je 0x17182f
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x223ea8
leaq 0x215165(%rip), %rsi    # 0x38693b
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfcb67
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x2235b9
movq (%rbx), %rdi
callq 0x226b39
movq 0x8(%rbx), %rdi
callq 0x11bdbf
movl $0x5b, %edx
jmp 0x17181e
leaq 0x210755(%rip), %rsi    # 0x381f64
movq %r14, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0x4c, %edx
leaq 0x2209ba(%rip), %rsi    # 0x3921df
movq %rbx, %rdi
callq 0x1045eb
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x53728
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/script_filter.c
// Function: gt_script_filter_new_from_string
GtScriptFilter *gt_script_filter_new_from_string(const char *script_string,
                                                 GtError *err)
{
  GtScriptFilter *script_filter;
  gt_assert(script_string);
  script_filter = gt_malloc(sizeof (GtScriptFilter));
  script_filter->filename = NULL;
  script_filter->L = luaL_newstate();
  script_filter->reference_count = 0;
  if (!script_filter->L) {
    gt_error_set(err, "out of memory (cannot create new Lua state)");
    gt_free(script_filter);
    return NULL;
  }
  script_filter_luaL_opencustomlibs(script_filter->L,
                                     script_filter_luasecurelibs);
  if (luaL_loadstring(script_filter->L, script_string) ||
                               lua_pcall(script_filter->L, 0, 0, 0)) {
    gt_error_set(err, "cannot run file: %s",
                 lua_tostring(script_filter->L, -1));
    lua_pop(script_filter->L, 1);
    lua_close(script_filter->L);
    gt_free(script_filter);
    return NULL;
  }
  return script_filter;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x171939
movq %rsi, %r14
movq %rdi, %r15
leaq 0x220975(%rip), %rsi    # 0x3921df
movl $0x18, %edi
movl $0x70, %edx
callq 0x104226
movq %rax, %rbx
xorl %r12d, %r12d
movq %r12, 0x8(%rax)
callq 0x22810a
movq %rax, (%rbx)
movq %r12, 0x10(%rbx)
testq %rax, %rax
je 0x171903
leaq 0x342575(%rip), %rsi    # 0x4b3e10
movq %rax, %rdi
callq 0x17193e
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x2280cf
testl %eax, %eax
jne 0x1718c4
movq (%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x22537b
testl %eax, %eax
je 0x17192a
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x223ea8
leaq 0x215061(%rip), %rsi    # 0x38693b
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfcb67
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x2235b9
movq (%rbx), %rdi
callq 0x226b39
movl $0x81, %edx
jmp 0x171919
leaq 0x21065a(%rip), %rsi    # 0x381f64
movq %r14, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0x76, %edx
leaq 0x2208bf(%rip), %rsi    # 0x3921df
movq %rbx, %rdi
callq 0x1045eb
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x5375f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/script_filter.c
// Function: script_filter_luaL_opencustomlibs
static void script_filter_luaL_opencustomlibs(lua_State *L,
                                              const luaL_Reg *lib)
{
  for (; lib->func; lib++) {
    lua_pushcfunction(L, lib->func);
    lua_pushstring(L, lib->name);
    lua_call(L, 1, 0);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0x171982
movq %rdi, %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x2247b8
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2243ba
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2252cf
movq 0x18(%rbx), %rsi
addq $0x10, %rbx
testq %rsi, %rsi
jne 0x171951
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/script_filter.c
// Function: gt_script_filter_run
int gt_script_filter_run(GtScriptFilter *sf, GtFeatureNode *gf,
                         bool *select_node, GtError *err)
{
  int had_err = 0;
#ifndef NDEBUG
  int stack_size;
#endif
  GtGenomeNode *gn_lua;

#ifndef NDEBUG
  stack_size = lua_gettop(sf->L);
#endif

  if (!had_err) {
    lua_getglobal(sf->L, "filter");
    if (lua_isnil(sf->L, -1)) {
      gt_error_set(err, "function 'filter' is not defined");
      had_err = -1;
      lua_pop(sf->L, 1);
    }
  }

  if (!had_err) {
    gn_lua = gt_genome_node_ref((GtGenomeNode*) gf);
    gt_lua_genome_node_push(sf->L, gn_lua);

    if (lua_pcall(sf->L, 1, 1, 0) != 0) {
      gt_error_set(err, "error running function 'filter': %s",
                   lua_tostring(sf->L, -1));
      lua_pop(sf->L, 1);
      had_err = -1;
    }
  }

  if (!had_err && !lua_isboolean(sf->L, -1)) {
    gt_error_set(err, "function 'filter' must return boolean");
    lua_pop(sf->L, 1);
    had_err = -1;
  }

  if (!had_err) {
    *select_node = lua_toboolean(sf->L, -1);
    lua_pop(sf->L, 1);
  }
  gt_assert(lua_gettop(sf->L) == stack_size);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2235ac
movl %eax, %ebp
movq (%rbx), %rdi
leaq 0x1e69e5(%rip), %rdx    # 0x358755
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x224a06
movq (%rbx), %rdi
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x223a4b
testl %eax, %eax
je 0x171de7
movq %r13, %rdi
callq 0x1443a0
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x186e7d
movq (%rbx), %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x22537b
movq (%rbx), %rdi
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x171df0
xorl %edx, %edx
callq 0x223ea8
leaq 0x220536(%rip), %rsi    # 0x39230e
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfcb67
jmp 0x171e24
leaq 0x2204ff(%rip), %rsi    # 0x3922ed
jmp 0x171e1a
callq 0x223a4b
cmpl $0x1, %eax
jne 0x171e13
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x223e82
testl %eax, %eax
setne (%r12)
xorl %r15d, %r15d
jmp 0x171e24
leaq 0x220518(%rip), %rsi    # 0x392332
movq %r14, %rdi
xorl %eax, %eax
callq 0xfcb67
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x2235b9
movq (%rbx), %rdi
callq 0x2235ac
cmpl %ebp, %eax
jne 0x171e4f
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x538ec
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/script_filter.c
// Function: gt_script_filter_delete
void gt_script_filter_delete(GtScriptFilter *script_filter)
{
  if (!script_filter) return;
  if (script_filter->reference_count) {
    script_filter->reference_count--;
    return;
  }
  gt_str_delete(script_filter->filename);
  lua_close(script_filter->L);
  gt_free(script_filter);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x171e7a
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x171e7c
decq %rax
movq %rax, 0x10(%rbx)
popq %rbx
retq
movq 0x8(%rbx), %rdi
callq 0x11bdbf
movq (%rbx), %rdi
callq 0x226b39
leaq 0x22034b(%rip), %rsi    # 0x3921df
movq %rbx, %rdi
movl $0x14f, %edx            # imm = 0x14F
popq %rbx
jmp 0x1045eb
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/select_stream.c
// Function: gt_select_stream_class
const GtNodeStreamClass* gt_select_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtSelectStream),
                                   select_stream_free,
                                   select_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x34c9a6(%rip)    # 0x4be858
jne 0x171ed3
leaq 0x26(%rip), %rsi        # 0x171ee1
leaq 0x49(%rip), %rdx        # 0x171f0b
movl $0x20, %edi
callq 0x162d34
movq %rax, 0x34c985(%rip)    # 0x4be858
callq 0xe2545
movq 0x34c979(%rip), %rax    # 0x4be858
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/select_stream.c
// Function: select_stream_next
static int select_stream_next(GtNodeStream *ns, GtGenomeNode **gn, GtError *err)
{
  GtSelectStream *fs;
  int had_err;
  gt_error_check(err);
  fs = gt_select_stream_cast(ns);

  /* we still have nodes in the buffer */
  if (gt_select_visitor_node_buffer_size(fs->select_visitor)) {
    /* return one of them */
    *gn = gt_select_visitor_get_node(fs->select_visitor);
    return 0;
  }

  /* no nodes in the buffer -> get new nodes */
  while (!(had_err = gt_node_stream_next(fs->in_stream, gn, err)) && *gn) {
    gt_assert(*gn && !had_err);
    had_err = gt_genome_node_accept(*gn, fs->select_visitor, err);
    if (had_err) {
      /* we own the node -> delete it */
      gt_genome_node_delete(*gn);
      *gn = NULL;
      break;
    }
    if (gt_select_visitor_node_buffer_size(fs->select_visitor)) {
      *gn = gt_select_visitor_get_node(fs->select_visitor);
      return 0;
    }
  }

  /* either we have an error or no new node */
  gt_assert(had_err || !*gn);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x171f30
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x171fb3
callq 0x171ea4
movq %rax, %rdi
movq %r15, %rsi
callq 0x162ff7
movq %rax, %r15
movq 0x18(%rax), %rdi
callq 0x172be4
testq %rax, %rax
jne 0x171f82
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x162e68
testl %eax, %eax
jne 0x171f9d
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x171fa1
movq 0x18(%r15), %rsi
movq %r14, %rdx
callq 0x14472c
testl %eax, %eax
jne 0x171fa5
movq 0x18(%r15), %rdi
jmp 0x171f47
movq 0x18(%r15), %rdi
callq 0x172c02
xorl %ebp, %ebp
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebp
jmp 0x171f90
xorl %ebp, %ebp
jmp 0x171f90
movl %eax, %ebp
movq (%rbx), %rdi
callq 0x1451a0
xorl %eax, %eax
jmp 0x171f8d
callq 0x53925
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/select_stream.c
// Function: gt_select_stream_new
GtNodeStream* gt_select_stream_new(GtNodeStream *in_stream, GtStr *seqid,
                                   GtStr *source, const GtRange *contain_range,
                                   const GtRange *overlap_range,
                                   GtStrand strand, GtStrand targetstrand,
                                   bool has_CDS, GtUword max_gene_length,
                                   GtUword max_gene_num,
                                   double min_gene_score, double max_gene_score,
                                   double min_average_splice_site_prob,
                                   GtUword feature_num,
                                   GtStrArray *select_files,
                                   GtStr *select_logic, GtError *err)
{
  GtNodeStream *ns = gt_node_stream_create(gt_select_stream_class(),
                                          gt_node_stream_is_sorted(in_stream));
  GtSelectStream *select_stream = gt_select_stream_cast(ns);
  gt_assert(in_stream);
  select_stream->in_stream = gt_node_stream_ref(in_stream);
  select_stream->select_visitor =
    gt_select_visitor_new(seqid, source, contain_range, overlap_range, strand,
                          targetstrand, has_CDS, max_gene_length, max_gene_num,
                          min_gene_score, max_gene_score,
                          min_average_splice_site_prob, feature_num,
                          select_files, select_logic, err);
  if  (!select_stream->select_visitor) {
    gt_node_stream_delete(ns);
    return NULL;
  }
  return ns;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm2, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movl %r9d, 0xc(%rsp)
movq %r8, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
callq 0x171ea4
movq %rax, %rbx
movq %r14, %rdi
callq 0x162fe4
movzbl %al, %esi
movq %rbx, %rdi
callq 0x162d6c
movq %rax, %rbx
callq 0x171ea4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162ff7
testq %r14, %r14
je 0x1720c8
movq %rax, %rbp
movb 0x78(%rsp), %r15b
movq %r14, %rdi
callq 0x162dd8
movq %rax, 0x10(%rbp)
subq $0x8, %rsp
movzbl %r15b, %eax
movq %r13, %rdi
movq %r12, %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl 0x14(%rsp), %r8d
movl 0x78(%rsp), %r9d
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movsd 0x38(%rsp), %xmm2
pushq 0xb0(%rsp)
pushq 0xb0(%rsp)
pushq 0xb0(%rsp)
pushq 0xb0(%rsp)
pushq 0xb0(%rsp)
pushq 0xb0(%rsp)
pushq %rax
callq 0x17296e
addq $0x40, %rsp
movq %rax, 0x18(%rbp)
testq %rax, %rax
jne 0x1720b6
movq %rbx, %rdi
callq 0x162dee
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5395c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/select_stream.c
// Function: gt_select_stream_set_drophandler
void gt_select_stream_set_drophandler(GtSelectStream *fs,
                                      GtSelectNodeFunc fp,
                                      void *data)
{
  gt_assert(fs && fp != NULL);
  GtSelectVisitor *fv;
  fv = gt_node_visitor_cast(gt_select_visitor_class(), fs->select_visitor);
  gt_select_visitor_set_drophandler(fv, fp, data);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x17213b
movq %rsi, %r14
testq %rsi, %rsi
je 0x17213b
movq %rdx, %rbx
movq %rdi, %r15
callq 0x172140
movq 0x18(%r15), %rsi
movq %rax, %rdi
callq 0x1630b1
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x172c20
callq 0x53993
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/select_visitor.c
// Function: gt_select_visitor_class
const GtNodeVisitorClass* gt_select_visitor_class()
{
  static GtNodeVisitorClass *nvc = NULL;
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtSelectVisitor),
                                    select_visitor_free,
                                    select_visitor_comment_node,
                                    select_visitor_feature_node,
                                    select_visitor_region_node,
                                    select_visitor_sequence_node,
                                    select_visitor_eof_node);
    gt_node_visitor_class_set_meta_node_func(nvc, select_visitor_meta_node);
  }
  return nvc;
}

// Assembly:
movq 0x34c719(%rip), %rax    # 0x4be860
testq %rax, %rax
je 0x17214d
retq
pushq %rax
leaq 0x78d(%rip), %rax       # 0x1728e2
movq %rax, (%rsp)
leaq 0x48(%rip), %rsi        # 0x1721a8
leaq 0xd9(%rip), %rdx        # 0x172240
leaq 0x118(%rip), %rcx       # 0x172286
leaq 0x5d1(%rip), %r8        # 0x172746
leaq 0x6cb(%rip), %r9        # 0x172847
movl $0xc8, %edi
callq 0x163010
movq %rax, 0x34c6d3(%rip)    # 0x4be860
leaq 0x794(%rip), %rsi       # 0x172928
movq %rax, %rdi
callq 0x163070
movq 0x34c6bd(%rip), %rax    # 0x4be860
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/select_visitor.c
// Function: select_visitor_free
static void select_visitor_free(GtNodeVisitor *nv)
{
  int i;
  GtSelectVisitor *select_visitor = select_visitor_cast(nv);
  gt_str_delete(select_visitor->source);
  gt_str_delete(select_visitor->seqid);
  if (gt_array_size(select_visitor->script_filters) > 0) {
    for (i = 0; i < gt_array_size(select_visitor->script_filters); i++) {
      GtScriptFilter *todelete =
            *(GtScriptFilter**) gt_array_get(select_visitor->script_filters, i);
      gt_script_filter_delete(todelete);
    }
  }
  gt_array_delete(select_visitor->script_filters);
  gt_queue_delete(select_visitor->node_buffer);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x172140
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1630b1
movq %rax, %rbx
movq 0x20(%rax), %rdi
callq 0x11bdbf
movq 0x18(%rbx), %rdi
callq 0x11bdbf
movq 0xb0(%rbx), %rdi
callq 0xd24e0
testq %rax, %rax
je 0x172224
movq 0xb0(%rbx), %rdi
callq 0xd24e0
testq %rax, %rax
je 0x172224
xorl %r14d, %r14d
movq 0xb0(%rbx), %rdi
movq %r14, %rsi
callq 0xd2207
movq (%rax), %rdi
callq 0x171e61
incq %r14
movq 0xb0(%rbx), %rdi
callq 0xd24e0
cmpq %r14, %rax
ja 0x1721f9
movq 0xb0(%rbx), %rdi
callq 0xd2938
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10dc23
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/select_visitor.c
// Function: select_visitor_comment_node
static int select_visitor_comment_node(GtNodeVisitor *nv, GtCommentNode *c,
                                       GT_UNUSED GtError *err)
{
  GtSelectVisitor *select_visitor;
  gt_error_check(err);
  select_visitor = select_visitor_cast(nv);
  gt_queue_add(select_visitor->node_buffer, c);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x17225b
movq %rdx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x172281
callq 0x172140
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x10d65b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x539cc
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/select_visitor.c
// Function: select_visitor_region_node
static int select_visitor_region_node(GtNodeVisitor *nv, GtRegionNode *rn,
                                      GT_UNUSED GtError *err)
{
  GtSelectVisitor *select_visitor;
  gt_error_check(err);
  select_visitor = select_visitor_cast(nv);
  if (!gt_str_length(select_visitor->seqid) || /* no seqid was specified */
      !gt_str_cmp(select_visitor->seqid,       /* or seqids are equal */
               gt_genome_node_get_seqid((GtGenomeNode*) rn))) {
    if (select_visitor->contain_range.start != GT_UNDEF_UWORD) {
      GtRange range = gt_genome_node_get_range((GtGenomeNode*) rn);
      if (gt_range_overlap(&range, &select_visitor->contain_range)) {
        /* an overlapping contain range was defined -> update range  */
        range.start = GT_MAX(range.start, select_visitor->contain_range.start);
        range.end = GT_MIN(range.end, select_visitor->contain_range.end);
        gt_genome_node_set_range((GtGenomeNode*) rn, &range);
        gt_queue_add(select_visitor->node_buffer, rn);
      }
      else {
        /* contain range does not overlap with <rn> range -> handle <rn> */
        select_visitor->drophandler((GtGenomeNode*) rn, select_visitor->data,
                                    err);
        gt_genome_node_delete((GtGenomeNode*) rn);
      }
    }
    else
      gt_queue_add(select_visitor->node_buffer, rn);
  }
  else {
    select_visitor->drophandler((GtGenomeNode*) rn, select_visitor->data, err);
    gt_genome_node_delete((GtGenomeNode*) rn);
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x17276f
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x172842
callq 0x172140
movq %rax, %rdi
movq %r15, %rsi
callq 0x1630b1
movq %rax, %r15
movq 0x18(%rax), %rdi
callq 0x11b0ca
testq %rax, %rax
je 0x1727ab
movq 0x18(%r15), %r12
movq %rbx, %rdi
callq 0x144635
movq %r12, %rdi
movq %rax, %rsi
callq 0x11b146
testl %eax, %eax
jne 0x172818
cmpq $-0x1, 0x28(%r15)
je 0x17280a
movq %r15, %r12
addq $0x28, %r12
movq %rbx, %rdi
callq 0x144679
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
movq %r12, %rsi
callq 0x112246
testb %al, %al
je 0x172818
movq 0x28(%r15), %rax
leaq 0x8(%rsp), %rsi
movq (%rsi), %rcx
cmpq %rax, %rcx
cmovaq %rcx, %rax
movq 0x8(%rsi), %rcx
movq %rax, (%rsi)
movq 0x30(%r15), %rax
cmpq %rax, %rcx
cmovbq %rcx, %rax
movq %rax, 0x8(%rsi)
movq %rbx, %rdi
callq 0x1446da
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0x10d65b
jmp 0x172834
movq 0xc0(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq *0xb8(%r15)
movq %rbx, %rdi
callq 0x1451a0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x53ae7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/select_visitor.c
// Function: select_visitor_sequence_node
static int select_visitor_sequence_node(GtNodeVisitor *nv, GtSequenceNode *sn,
                                        GT_UNUSED GtError *err)
{
  GtSelectVisitor *select_visitor;
  gt_error_check(err);
  select_visitor = select_visitor_cast(nv);
  if (!gt_str_length(select_visitor->seqid) || /* no seqid was specified */
      !gt_str_cmp(select_visitor->seqid,       /* or seqids are equal */
                  gt_genome_node_get_seqid((GtGenomeNode*) sn))) {
    gt_queue_add(select_visitor->node_buffer, sn);
  }
  else {
    select_visitor->drophandler((GtGenomeNode*) sn, select_visitor->data, err);
    gt_genome_node_delete((GtGenomeNode*) sn);
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x172869
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1728dd
callq 0x172140
movq %rax, %rdi
movq %r15, %rsi
callq 0x1630b1
movq %rax, %r15
movq 0x18(%rax), %rdi
callq 0x11b0ca
testq %rax, %rax
je 0x1728c3
movq 0x18(%r15), %r12
movq %rbx, %rdi
callq 0x144635
movq %r12, %rdi
movq %rax, %rsi
callq 0x11b146
testl %eax, %eax
je 0x1728c3
movq 0xc0(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq *0xb8(%r15)
movq %rbx, %rdi
callq 0x1451a0
jmp 0x1728cf
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0x10d65b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x53b20
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/select_visitor.c
// Function: select_visitor_eof_node
static int select_visitor_eof_node(GtNodeVisitor *nv, GtEOFNode *eofn,
                                   GT_UNUSED GtError *err)
{
  GtSelectVisitor *select_visitor;
  gt_error_check(err);
  select_visitor = select_visitor_cast(nv);
  gt_queue_add(select_visitor->node_buffer, eofn);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x1728fd
movq %rdx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x172923
callq 0x172140
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x10d65b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x53b59
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/select_visitor.c
// Function: select_visitor_meta_node
static int select_visitor_meta_node(GtNodeVisitor *nv, GtMetaNode *mn,
                                    GT_UNUSED GtError *err)
{
  GtSelectVisitor *select_visitor;
  gt_error_check(err);
  select_visitor = select_visitor_cast(nv);
  gt_queue_add(select_visitor->node_buffer, mn);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x172943
movq %rdx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x172969
callq 0x172140
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x10d65b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x53b92
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/seqid2file.c
// Function: gt_seqid2file_info_new
GtSeqid2FileInfo* gt_seqid2file_info_new(void)
{
  GtSeqid2FileInfo *s2fi = gt_calloc(1, sizeof *s2fi);
  s2fi->seqfiles = gt_str_array_new();
  s2fi->seqfile = gt_str_new();
  s2fi->encseq = gt_str_new();
  s2fi->region_mapping = gt_str_new();
  return s2fi;
}

// Assembly:
pushq %rbx
leaq 0x21f9e0(%rip), %rdx    # 0x392628
movl $0x1, %edi
movl $0x28, %esi
movl $0x23, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11be10
movq %rax, (%rbx)
callq 0x11ac6c
movq %rax, 0x10(%rbx)
callq 0x11ac6c
movq %rax, 0x18(%rbx)
callq 0x11ac6c
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/seqid2file.c
// Function: gt_seqid2file_info_delete
void gt_seqid2file_info_delete(GtSeqid2FileInfo *s2fi)
{
  if (!s2fi) return;
  gt_str_delete(s2fi->region_mapping);
  gt_str_delete(s2fi->seqfile);
  gt_str_delete(s2fi->encseq);
  gt_str_array_delete(s2fi->seqfiles);
  gt_free(s2fi);
}

// Assembly:
testq %rdi, %rdi
je 0x172cc8
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x11bdbf
movq 0x10(%rbx), %rdi
callq 0x11bdbf
movq 0x18(%rbx), %rdi
callq 0x11bdbf
movq (%rbx), %rdi
callq 0x11c144
leaq 0x21f96e(%rip), %rsi    # 0x392628
movq %rbx, %rdi
movl $0x32, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/seqid2file.c
// Function: seqid2file_check
static int seqid2file_check(void *data, GT_UNUSED GtError *err)
{
  GtSeqid2FileInfo *info = (GtSeqid2FileInfo*) data;
  gt_error_check(err);
  gt_assert(info);
  if (gt_str_length(info->seqfile)) {
    gt_assert(!gt_str_array_size(info->seqfiles));
    gt_str_array_add(info->seqfiles, info->seqfile);
  }
  return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x172f47
movq %rsi, %rdi
callq 0xfcc32
testb %al, %al
jne 0x172f7c
testq %rbx, %rbx
je 0x172f77
movq 0x10(%rbx), %rdi
callq 0x11b0ca
testq %rax, %rax
je 0x172f73
movq (%rbx), %rdi
callq 0x11c131
testq %rax, %rax
jne 0x172f81
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x11bf79
xorl %eax, %eax
popq %rbx
retq
callq 0x53ce0
callq 0x53c72
callq 0x53ca9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/seqid2file.c
// Function: gt_seqid2file_region_mapping_new
GtRegionMapping* gt_seqid2file_region_mapping_new(GtSeqid2FileInfo *s2fi,
                                                  GtError *err)
{
  GtRegionMapping *rm = NULL;
  gt_error_check(err);
  gt_assert(s2fi);

  s2fi->matchdesc = s2fi->matchdesc || s2fi->matchdescstart;
  /* create region mapping */
  if (gt_str_array_size(s2fi->seqfiles)) {
    rm = gt_region_mapping_new_seqfiles(s2fi->seqfiles, s2fi->matchdesc,
                                        s2fi->usedesc);
  } else if (gt_str_length(s2fi->encseq)) {
    GtEncseqLoader *el;
    GtEncseq *encseq;
    el = gt_encseq_loader_new();
    gt_encseq_loader_disable_autosupport(el);
    gt_encseq_loader_require_md5_support(el);
    gt_encseq_loader_require_lossless_support(el);
    gt_encseq_loader_require_description_support(el);
    encseq = gt_encseq_loader_load(el, gt_str_get(s2fi->encseq), err);
    gt_encseq_loader_delete(el);
    if (!encseq)
      rm = NULL;
    else {
      rm = gt_region_mapping_new_encseq(encseq, s2fi->matchdesc,
                                        s2fi->usedesc);
      gt_encseq_delete(encseq);
    }
  } else {
    rm = gt_region_mapping_new_mapping(s2fi->region_mapping, err);
  }
  if (rm && s2fi->matchdescstart)
    gt_region_mapping_enable_match_desc_start(rm);
  gt_assert(rm || gt_error_is_set(err));
  return rm;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x173000
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x173114
testq %r14, %r14
je 0x17310f
movb $0x1, %al
cmpb $0x0, 0x8(%r14)
jne 0x173016
movb 0xa(%r14), %al
movb %al, 0x8(%r14)
movq (%r14), %rdi
callq 0x11c131
testq %rax, %rax
je 0x17305d
movq (%r14), %rdi
movzbl 0x8(%r14), %esi
movzbl 0x9(%r14), %edx
callq 0x16d6c5
movq %rax, %r15
testq %r15, %r15
je 0x1730e0
cmpb $0x1, 0xa(%r14)
jne 0x1730ef
movq %r15, %rdi
callq 0x16d7f3
jmp 0x1730ef
movq 0x18(%r14), %rdi
callq 0x11b0ca
testq %rax, %rax
je 0x1730fe
callq 0xef0cd
movq %rax, %r15
movq %rax, %rdi
callq 0xf238b
movq %r15, %rdi
callq 0xf2376
movq %r15, %rdi
callq 0xf2371
movq %r15, %rdi
callq 0xf2485
movq 0x18(%r14), %rdi
callq 0x11b0a1
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0xef129
movq %rax, %r12
movq %r15, %rdi
callq 0xefbe3
testq %r12, %r12
je 0x1730e0
movzbl 0x8(%r14), %esi
movzbl 0x9(%r14), %edx
movq %r12, %rdi
callq 0x16d72e
movq %rax, %r15
movq %r12, %rdi
callq 0xea375
jmp 0x17303c
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
je 0x173119
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x16d5d8
jmp 0x173039
callq 0x53d89
callq 0x53d17
callq 0x53d50
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/seqpos_classifier.c
// Function: gt_seqpos_classifier_new
GtSeqposClassifier *gt_seqpos_classifier_new(const char *filename,
    const char *feature_type)
{
  GtSeqposClassifier *seqpos_classifier;
  seqpos_classifier = gt_malloc(sizeof (GtSeqposClassifier));
  seqpos_classifier->annotation_stream = gt_gff3_in_stream_new_sorted(filename);
  seqpos_classifier->fn = NULL;
  seqpos_classifier->fni = NULL;
  seqpos_classifier->gn = NULL;
  seqpos_classifier->nof_specified_ft_found = 0;
  seqpos_classifier->specified_ft = feature_type;
  return seqpos_classifier;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x21f38a(%rip), %rsi    # 0x392c14
movl $0x40, %edi
movl $0x2c, %edx
callq 0x104226
movq %rax, %r15
movq %r14, %rdi
callq 0x145d7c
movq %rax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movups %xmm0, 0x18(%r15)
movq %rbx, 0x38(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/seqpos_classifier.c
// Function: gt_seqpos_classifier_next_specified_ft
static int gt_seqpos_classifier_next_specified_ft(
    GtSeqposClassifier *seqpos_classifier, GtRange *range,
    bool *end_of_annotation, GtError *err)
{
  int had_err = 0;
  GtFeatureNode *cfn;
  bool fni_exhausted = (seqpos_classifier->fni == NULL) ? true : false;
  gt_assert(seqpos_classifier != NULL);
  gt_assert(range != NULL);
  while (true)
  {
    if (fni_exhausted)
    {
      had_err = gt_seqpos_classifier_next_fn(seqpos_classifier, err);
      if (had_err != 0 || seqpos_classifier->fn == NULL)
      {
        *end_of_annotation = true;
        return had_err;
      }
      fni_exhausted = false;
    }
    gt_assert(seqpos_classifier->fni != NULL);
    cfn = gt_feature_node_iterator_next(seqpos_classifier->fni);
    if (cfn == NULL)
    {
      fni_exhausted = true;
    }
    else if (strcmp(gt_feature_node_get_type(cfn),
          seqpos_classifier->specified_ft) == 0)
    {
      seqpos_classifier->nof_specified_ft_found++;
      *range = gt_genome_node_get_range((GtGenomeNode*)cfn);
      gt_assert(range->start > 0);
      gt_assert(range->end > 0);
      range->start--;
      range->end--;
      *end_of_annotation = false;
      return had_err;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x173b44
movq %rsi, %r14
movq %rdx, (%rsp)
testq %rsi, %rsi
je 0x173b49
movq %rcx, %r15
movq %rdi, %r12
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
sete %bl
leaq 0x8(%r12), %r13
testb $0x1, %bl
je 0x173aa3
testq %rdi, %rdi
je 0x173a50
callq 0x14417c
movq $0x0, 0x18(%r12)
movq (%r13), %rdi
testq %rdi, %rdi
je 0x173a5e
callq 0x1451a0
movq (%r12), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x162e68
testl %eax, %eax
jne 0x173adf
movq (%r13), %rdi
testq %rdi, %rdi
je 0x173ae9
callq 0x143cab
movq %rax, 0x10(%r12)
testq %rax, %rax
je 0x173a50
movq %rax, %rdi
callq 0x143f54
movq %rax, 0x18(%r12)
cmpq $0x0, 0x10(%r12)
je 0x173af1
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0x173b3f
callq 0x1440ea
testq %rax, %rax
sete %bl
je 0x173ad5
movq %rax, %rbp
movq %rax, %rdi
callq 0x142988
movq 0x38(%r12), %rsi
movq %rax, %rdi
callq 0x17a40
testl %eax, %eax
je 0x173b0a
movq 0x18(%r12), %rdi
jmp 0x173a38
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
jmp 0x173af3
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
xorl %eax, %eax
movb $0x1, %cl
movq (%rsp), %rsi
movb %cl, (%rsi)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incq 0x20(%r12)
movq %rbp, %rdi
callq 0x144679
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
testq %rax, %rax
je 0x173b4e
testq %rdx, %rdx
movq (%rsp), %rsi
je 0x173b53
decq %rax
movq %rax, (%r14)
decq %rdx
movq %rdx, 0x8(%r14)
xorl %ecx, %ecx
xorl %eax, %eax
jmp 0x173af9
callq 0x5422c
callq 0x5429a
callq 0x54263
callq 0x541f5
callq 0x541be
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/seqpos_classifier.c
// Function: gt_seqpos_classifier_delete
void gt_seqpos_classifier_delete(GtSeqposClassifier *seqpos_classifier)
{
  if (seqpos_classifier != NULL)
  {
    if (seqpos_classifier->fni != NULL)
    {
      gt_feature_node_iterator_delete(seqpos_classifier->fni);
    }
    if (seqpos_classifier->gn != NULL)
    {
      gt_genome_node_delete(seqpos_classifier->gn);
    }
    gt_node_stream_delete(seqpos_classifier->annotation_stream);
    gt_free(seqpos_classifier);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x173baa
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x173b7f
callq 0x14417c
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x173b8d
callq 0x1451a0
movq (%rbx), %rdi
callq 0x162dee
leaq 0x21f078(%rip), %rsi    # 0x392c14
movq %rbx, %rdi
movl $0xea, %edx
popq %rbx
jmp 0x1045eb
retq
nop