LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sam_alignment.c
// Function: gt_sam_alignment_sequence_external_buffer
void gt_sam_alignment_sequence_external_buffer(GtSamAlignment *sam_alignment,
    GtUchar **seq_buffer, GtUword *bufsize)
{
  GtUword query_len, idx;
  uint8_t *bam_seq;

  query_len = (GtUword) sam_alignment->s_alignment->core.l_qseq;
  if ((*bufsize) < query_len) {
    (*seq_buffer) = gt_realloc(*seq_buffer, sizeof (**seq_buffer) *
                                   (query_len + 1UL));
    (*bufsize) = query_len;
  }
  gt_assert((*seq_buffer) != NULL);

  bam_seq = bam1_seq(sam_alignment->s_alignment);

  for (idx = 0UL; idx < query_len; idx++) {
    (*seq_buffer)[idx] = bambase2gtbase((uint8_t) bam1_seqi(bam_seq, idx),
                                      sam_alignment->alphabet);
  }
  (*seq_buffer)[query_len] = (GtUchar)'\0';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, (%rsp)
movq (%rdi), %rax
movslq 0x10(%rax), %r12
cmpq %r12, (%rdx)
jae 0x17863e
movq %rdx, %r15
movq (%rbx), %rdi
leaq 0x1(%r12), %rsi
leaq 0x222361(%rip), %rdx    # 0x39a98f
movl $0x8e, %ecx
callq 0x1094e6
movq %rax, (%rbx)
movq %r12, (%r15)
cmpq $0x0, (%rbx)
je 0x1786fb
testl %r12d, %r12d
je 0x1786e4
movq (%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %r13
movq %r13, %rcx
shrq $0x30, %rcx
shlq $0x2, %rcx
addq 0x30(%rax), %rcx
shrl $0x18, %r13d
addq %rcx, %r13
xorl %ebp, %ebp
xorl %r14d, %r14d
movq %r14, %rax
shrq %rax
movb (%r13,%rax), %dl
movl %ebp, %ecx
notb %cl
andb $0x4, %cl
shrb %cl, %dl
andb $0xf, %dl
movq (%rsp), %rax
movq 0x8(%rax), %r15
decb %dl
cmpb $0x8, %dl
jae 0x1786be
movzbl %dl, %eax
movl $0x8b, %ecx
btl %eax, %ecx
jae 0x1786be
shlb $0x3, %dl
movabsq $0x5441414147414341, %rax # imm = 0x5441414147414341
movl %edx, %ecx
shrq %cl, %rax
jmp 0x1786c6
movq %r15, %rdi
callq 0xd3746
movsbl %al, %esi
movq %r15, %rdi
callq 0xd3d89
movq (%rbx), %rcx
movb %al, (%rcx,%r14)
incq %r14
addb $0x4, %bpl
cmpq %r14, %r12
jne 0x178677
movq (%rbx), %rax
movb $0x0, (%rax,%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5362d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sam_alignment.c
// Function: gt_sam_alignment_qualitystring_external_buffer
void gt_sam_alignment_qualitystring_external_buffer(
    GtSamAlignment *sam_alignment, GtUchar **qual_buffer,
    GtUword *bufsize)
{
  GtUword query_len, idx;
  uint8_t *qual;

  gt_assert(qual_buffer != NULL);
  gt_assert(bufsize != NULL);
  query_len = (GtUword) sam_alignment->s_alignment->core.l_qseq;
  if ((*bufsize) < query_len) {
    (*qual_buffer) = gt_realloc((*qual_buffer), sizeof (**qual_buffer) *
        (query_len + 1UL));
    (*bufsize) = query_len;
  }
  gt_assert((*qual_buffer) != NULL);
  qual = bam1_qual(sam_alignment->s_alignment);
  for (idx = 0UL; idx < query_len; idx++) {
    (*qual_buffer)[idx] = (GtUchar)(qual[idx] + PHREDOFFSET);
  }
  (*qual_buffer)[query_len] = (GtUchar)'\0';
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1787c2
movq %rdx, %r15
testq %rdx, %rdx
je 0x1787c7
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movslq 0x10(%rax), %r12
cmpq %r12, (%r15)
jae 0x178765
movq (%rbx), %rdi
leaq 0x1(%r12), %rsi
leaq 0x22223a(%rip), %rdx    # 0x39a98f
movl $0xaf, %ecx
callq 0x1094e6
movq %rax, (%rbx)
movq %r12, (%r15)
cmpq $0x0, (%rbx)
je 0x1787cc
testl %r12d, %r12d
je 0x1787ae
movq (%r14), %rax
movq 0x8(%rax), %rcx
movq %rcx, %rdx
shrq $0x30, %rdx
shlq $0x2, %rdx
addq 0x30(%rax), %rdx
shrl $0x18, %ecx
movl 0x10(%rax), %eax
incl %eax
sarl %eax
cltq
addq %rcx, %rax
addq %rdx, %rax
xorl %ecx, %ecx
movb (%rax,%rcx), %dl
addb $0x21, %dl
movq (%rbx), %rsi
movb %dl, (%rsi,%rcx)
incq %rcx
cmpq %rcx, %r12
jne 0x17879a
movq (%rbx), %rax
movb $0x0, (%rax,%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x536d8
callq 0x5369f
callq 0x53666
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sam_query_name_iterator.c
// Function: gt_sam_query_name_iterator_class
const GtCstrIteratorClass* gt_sam_query_name_iterator_class(void)
{
  static const GtCstrIteratorClass *sic = NULL;
  gt_class_alloc_lock_enter();
  if (!sic) {
    sic = gt_cstr_iterator_class_new(sizeof (GtSamQueryNameIterator),
                                     gt_sam_query_name_iterator_next,
                                     gt_sam_query_name_iterator_reset,
                                     gt_sam_query_name_iterator_delete);
  }
  gt_class_alloc_lock_leave();
  return sic;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x350ee6(%rip)    # 0x4c9850
jne 0x178992
leaq 0x2d(%rip), %rsi        # 0x1789a0
leaq 0x93(%rip), %rdx        # 0x178a0d
leaq 0xd2(%rip), %rcx        # 0x178a53
movl $0x20, %edi
callq 0x3071b5
movq %rax, 0x350ebe(%rip)    # 0x4c9850
callq 0xe6a19
movq 0x350eb2(%rip), %rax    # 0x4c9850
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sam_query_name_iterator.c
// Function: gt_sam_query_name_iterator_next
static int gt_sam_query_name_iterator_next(GtCstrIterator *cstr_iterator,
                                      const char **query_name,
                                      GT_UNUSED GtError *err)
{
  int read = 0;
  GtSamQueryNameIterator *sqi = gt_sam_query_name_iterator_cast(cstr_iterator);
  read = gt_samfile_iterator_next(sqi->s_iter, &sqi->alignment);
  while (read > 0 && gt_sam_alignment_is_unmapped(sqi->alignment)) {
    read = gt_samfile_iterator_next(sqi->s_iter, &sqi->alignment);
  }
  if (read > 0) {
    *query_name = gt_sam_alignment_identifier(sqi->alignment);
    return read;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x17895c
movq %rax, %rdi
movq %r14, %rsi
callq 0x30722a
movq %rax, %r15
movq 0x18(%rax), %rdi
leaq 0x10(%rax), %r14
movq %r14, %rsi
callq 0x178ebe
xorl %ebp, %ebp
testl %eax, %eax
jle 0x178a02
movl %eax, %r12d
movq (%r14), %rdi
callq 0x178892
testb %al, %al
je 0x1789f4
movq 0x18(%r15), %rdi
movq %r14, %rsi
callq 0x178ebe
jmp 0x1789d3
movl %r12d, %ebp
movq (%r14), %rdi
callq 0x1785da
movq %rax, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sam_query_name_iterator.c
// Function: gt_sam_query_name_iterator_new
GtCstrIterator* gt_sam_query_name_iterator_new(GtSamfileIterator *s_iter,
                                        GtError *err)
{
  GtCstrIterator *cstr_iterator =
    gt_cstr_iterator_create(gt_sam_query_name_iterator_class());
  GtSamQueryNameIterator *sqi = gt_sam_query_name_iterator_cast(cstr_iterator);
  sqi->s_iter = s_iter;
  if (gt_sam_query_name_iterator_reset(cstr_iterator, err) != 0)
    return NULL;
  return cstr_iterator;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x17895c
movq %rax, %rdi
callq 0x3071f8
movq %rax, %r15
callq 0x17895c
movq %rax, %rdi
movq %r15, %rsi
callq 0x30722a
movq %r14, 0x18(%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x178a0d
xorl %ecx, %ecx
testl %eax, %eax
cmoveq %r15, %rcx
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/samfile_encseq_mapping.c
// Function: gt_samfile_encseq_mapping_seqpos
GtUword gt_samfile_encseq_mapping_seqpos(
    GtSamfileEncseqMapping *samfile_encseq_mapping, int32_t reference_num,
    GtUword reference_seqpos)
{
  GtUword seqnum, seqstartpos;
  gt_assert(samfile_encseq_mapping != NULL);
  seqnum = gt_samfile_encseq_mapping_seqnum(samfile_encseq_mapping,
      reference_num);
  seqstartpos = gt_encseq_seqstartpos(samfile_encseq_mapping->encseq, seqnum);
  return seqstartpos + reference_seqpos;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x178d61
cmpl %esi, 0x10(%rdi)
jle 0x178d66
movq %rdx, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movslq %esi, %rdx
movq (%rcx,%rdx,8), %rsi
movq %rax, %rdi
callq 0xefce0
addq %rbx, %rax
popq %rbx
retq
callq 0x53b7b
callq 0x53b44
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/samfile_iterator.c
// Function: gt_samfile_iterator_new
GtSamfileIterator* gt_samfile_iterator_new(const char *filename,
                                           const char *mode,
                                           void *aux,
                                           GtAlphabet *alphabet,
                                           GtError *err)
{
  GtSamfileIterator *s_iter;
  s_iter = gt_malloc(sizeof (GtSamfileIterator));
  s_iter->ref_count = 0;
  s_iter->filename = gt_cstr_dup(filename);
  s_iter->mode = gt_cstr_dup(mode);
  s_iter->aux = aux;
  s_iter->current_alignment = NULL;
  s_iter->alphabet = gt_alphabet_ref(alphabet);
  s_iter->samfile = samopen(filename, mode, aux);
  if (s_iter->samfile == NULL) {
    gt_error_set(err, "could not open sam/bam file: %s", filename);
    gt_samfile_iterator_delete(s_iter);
    return NULL;
  }
  return s_iter;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
movq %rcx, %rbp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
leaq 0x22221a(%rip), %rsi    # 0x39afa8
movl $0x38, %edi
movl $0x2e, %edx
callq 0x1092b2
movq %rax, %rbx
xorl %r14d, %r14d
movq %r14, 0x30(%rax)
movq %r15, %rdi
callq 0xe8760
movq %rax, 0x10(%rbx)
movq %r13, %rdi
callq 0xe8760
movq %rax, 0x18(%rbx)
movq %r12, 0x28(%rbx)
movq %r14, 0x8(%rbx)
movq %rbp, %rdi
callq 0xd3007
movq %rax, (%rbx)
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x24eeef
movq %rax, 0x20(%rbx)
testq %rax, %rax
jne 0x178e08
leaq 0x2221d8(%rip), %rsi    # 0x39afc8
movq (%rsp), %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1019cf
movq %rbx, %rdi
callq 0x178e1a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/samfile_iterator.c
// Function: gt_samfile_iterator_delete
void gt_samfile_iterator_delete(GtSamfileIterator *s_iter)
{
  if (s_iter != NULL) {
    if (s_iter->ref_count != 0)
      s_iter->ref_count--;
    else {
      samclose(s_iter->samfile);
      gt_free(s_iter->filename);
      gt_free(s_iter->mode);
      gt_alphabet_delete(s_iter->alphabet);
      gt_sam_alignment_delete(s_iter->current_alignment);
      gt_free(s_iter);
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x178e36
movq %rdi, %rbx
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x178e3e
decq %rax
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x20(%rbx), %rdi
callq 0x24f355
movq 0x10(%rbx), %rdi
leaq 0x222156(%rip), %r14    # 0x39afa8
movq %r14, %rsi
movl $0x5c, %edx
callq 0x109670
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movl $0x5d, %edx
callq 0x109670
movq (%rbx), %rdi
callq 0xd335d
movq 0x8(%rbx), %rdi
callq 0x178501
movq %rbx, %rdi
movq %r14, %rsi
movl $0x60, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/samfile_iterator.c
// Function: gt_samfile_iterator_next
int gt_samfile_iterator_next(GtSamfileIterator *s_iter,
                             GtSamAlignment **s_alignment)
{
  int read;
  if (s_iter->current_alignment == NULL)
    s_iter->current_alignment = gt_sam_alignment_new(s_iter->alphabet);
  s_iter->current_alignment->rightmost = GT_UNDEF_UWORD;
  read = samread(s_iter->samfile, s_iter->current_alignment->s_alignment);
  if (read > 0) {
    *s_alignment = s_iter->current_alignment;
  }
  else {
    *s_alignment = NULL;
  }
  return read;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
jne 0x178edb
movq (%r14), %rdi
callq 0x1783a4
movq %rax, 0x8(%r14)
movq 0x8(%r14), %rax
movq $-0x1, 0x30(%rax)
movq 0x20(%r14), %rdi
movq (%rax), %rsi
callq 0x24f39b
testl %eax, %eax
jle 0x178efd
movq 0x8(%r14), %rcx
jmp 0x178eff
xorl %ecx, %ecx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/samfile_iterator.c
// Function: gt_samfile_iterator_reset
int gt_samfile_iterator_reset(GtSamfileIterator *s_iter,
                              GtError *err)
{
  gt_assert(s_iter != NULL);
  samclose(s_iter->samfile);
  s_iter->samfile = samopen(s_iter->filename, s_iter->mode, s_iter->aux);
  if (s_iter->samfile == NULL) {
    gt_error_set(err, "could not reopen sam/bam file: %s", s_iter->filename);
    return -1;
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x178f63
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0x24f355
movq 0x10(%r14), %rdi
movq 0x18(%r14), %rsi
movq 0x28(%r14), %rdx
callq 0x24eeef
movq %rax, %rcx
movq %rax, 0x20(%r14)
xorl %eax, %eax
testq %rcx, %rcx
jne 0x178f5b
movq 0x10(%r14), %rdx
leaq 0x2220b6(%rip), %rsi    # 0x39b002
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x53bb4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sampling.c
// Function: gt_sampling_new_regular
GtSampling *gt_sampling_new_regular(GtUword rate, off_t first_offset)
{
  GtSampling *sampling = gt_malloc(sizeof (*sampling));
  sampling->method = GT_SAMPLING_REGULAR;
  gt_assert(rate != 0);

  gt_sampling_init_sampling(sampling, rate);

  gt_assert(first_offset % sampling->pagesize == 0);

  sampling->page_sampling = NULL;
  sampling->samplingtab = gt_malloc((size_t) sampling->arraysize *
                                    sizeof (*sampling->samplingtab));
  gt_safe_assign(sampling->samplingtab[0], first_offset);
  return sampling;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x2220f4(%rip), %rsi    # 0x39b0b6
movl $0x48, %edi
movl $0x3d, %edx
callq 0x1092b2
movl $0x0, 0x40(%rax)
testq %r15, %r15
je 0x179049
movq %rax, %r14
movq $0x1, 0x20(%rax)
movq $0xa, 0x8(%rax)
movq %r15, 0x30(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
callq 0xe837d
movq %rax, %rcx
movq %rax, 0x28(%r14)
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
jne 0x17904e
movq $0x0, 0x38(%r14)
movq 0x8(%r14), %rdi
shlq $0x3, %rdi
leaq 0x22208b(%rip), %rsi    # 0x39b0b6
movl $0x47, %edx
callq 0x1092b2
movq %rax, (%r14)
testq %rbx, %rbx
js 0x179053
movq %rbx, (%rax)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x53cf8
callq 0x53c96
callq 0x53ccd
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sampling.c
// Function: gt_sampling_new_page
GtSampling *gt_sampling_new_page(GtUword rate, off_t first_offset)
{
  GtSampling *sampling = gt_sampling_new_regular(rate, first_offset);
  sampling->method = GT_SAMPLING_PAGES;
  gt_assert(rate != 0);

  sampling->page_sampling = gt_malloc((size_t) sampling->arraysize *
                                      sizeof (*sampling->page_sampling));
  sampling->page_sampling[0] = 0;
  return sampling;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x178fb0
movl $0x1, 0x40(%rax)
testq %r14, %r14
je 0x1790a2
movq %rax, %rbx
movq 0x8(%rax), %rdi
shlq $0x3, %rdi
leaq 0x222034(%rip), %rsi    # 0x39b0b6
movl $0x53, %edx
callq 0x1092b2
movq %rax, 0x38(%rbx)
movq $0x0, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x53d2f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sampling.c
// Function: gt_sampling_write
void gt_sampling_write(GtSampling *sampling, FILE *fp)
{
  gt_assert(sampling);
  gt_assert(fp);

  gt_sampling_io_header_samplingtab(sampling, fp, gt_sampling_xfwrite);
  if (sampling->method == GT_SAMPLING_PAGES)
    gt_sampling_io_page_sampling(sampling, fp, gt_sampling_xfwrite);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1791e4
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1791e9
movq %rdi, %r14
leaq 0x20(%rdi), %r15
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x17fa0
cmpq $0x1, %rax
jne 0x1791ee
cmpq $0x0, (%r15)
je 0x1791f3
leaq 0x40(%r14), %r15
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x17fa0
cmpq $0x1, %rax
jne 0x1791f8
leaq 0x30(%r14), %r12
movl $0x8, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x17fa0
cmpq $0x1, %rax
jne 0x1791fd
cmpq $0x0, (%r12)
je 0x179202
cmpl $0x2, (%r15)
jae 0x179207
cmpq $0x0, (%r14)
jne 0x179175
movq 0x20(%r14), %rdi
movq %rdi, 0x8(%r14)
shlq $0x3, %rdi
leaq 0x221f4e(%rip), %rsi    # 0x39b0b6
movl $0xa7, %edx
callq 0x1092b2
movq %rax, (%r14)
movq (%r14), %rdi
movq 0x20(%r14), %r12
movl $0x8, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x17fa0
cmpq %r12, %rax
jne 0x17920c
cmpl $0x1, (%r15)
jne 0x1791d8
cmpq $0x0, 0x38(%r14)
jne 0x1791bb
movq 0x8(%r14), %rdi
shlq $0x3, %rdi
leaq 0x221f09(%rip), %rsi    # 0x39b0b6
movl $0x7e, %edx
callq 0x1092b2
movq %rax, 0x38(%r14)
movq 0x20(%r14), %r15
movq 0x38(%r14), %rdi
movl $0x8, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x17fa0
cmpq %r15, %rax
jne 0x179211
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x53eb3
callq 0x53e7a
callq 0x53d66
callq 0x53e41
callq 0x53d7b
callq 0x53d90
callq 0x53e08
callq 0x53da5
callq 0x53dde
callq 0x53df3
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x17938b
movq %rdi, %rbx
leaq 0x221e85(%rip), %rsi    # 0x39b0b6
movl $0x48, %edi
movl $0xbc, %edx
callq 0x1092b2
movq %rax, %r14
xorl %eax, %eax
movq %rax, (%r14)
movq %rax, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
callq 0xe837d
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 0x179390
cmpq $0x0, (%r15)
je 0x1793a1
leaq 0x40(%r14), %r15
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x17b40
cmpq $0x1, %rax
jne 0x1793a6
leaq 0x30(%r14), %r12
movl $0x8, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x17b40
cmpq $0x1, %rax
jne 0x1793b7
cmpq $0x0, (%r12)
je 0x1793c8
cmpl $0x2, (%r15)
jae 0x1793cd
cmpq $0x0, (%r14)
jne 0x17930b
movq 0x20(%r14), %rdi
movq %rdi, 0x8(%r14)
shlq $0x3, %rdi
leaq 0x221db8(%rip), %rsi    # 0x39b0b6
movl $0xa7, %edx
callq 0x1092b2
movq %rax, (%r14)
movq (%r14), %rdi
movq 0x20(%r14), %r12
movl $0x8, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x17b40
cmpq %r12, %rax
jne 0x1793d2
cmpl $0x1, (%r15)
jne 0x179372
cmpq $0x0, 0x38(%r14)
jne 0x179355
movq 0x8(%r14), %rdi
shlq $0x3, %rdi
leaq 0x221d6f(%rip), %rsi    # 0x39b0b6
movl $0x7e, %edx
callq 0x1092b2
movq %rax, 0x38(%r14)
movq 0x20(%r14), %r15
movq 0x38(%r14), %rdi
movl $0x8, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x17b40
cmpq %r15, %rax
jne 0x1793e8
movq 0x8(%r14), %rax
cmpq 0x20(%r14), %rax
jne 0x1793e3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x540e3
movq %rbx, %rdi
callq 0x17be0
testl %eax, %eax
je 0x1793f4
callq 0x53eec
callq 0x540aa
movq %rbx, %rdi
callq 0x17be0
testl %eax, %eax
je 0x1793f4
callq 0x53f23
movq %rbx, %rdi
callq 0x17be0
testl %eax, %eax
je 0x1793f4
callq 0x53f5a
callq 0x54071
callq 0x53f91
movq %rbx, %rdi
callq 0x17be0
testl %eax, %eax
je 0x1793f4
callq 0x53fca
callq 0x54038
movq %rbx, %rdi
callq 0x17be0
testl %eax, %eax
jne 0x179416
movq %rbx, %rdi
callq 0x17f00
testl %eax, %eax
je 0x17940c
leaq 0x221fe8(%rip), %rdi    # 0x39b3ef
callq 0x17690
movl $0x1, %edi
callq 0x17940
callq 0x54001
// File: /workspace/github_c_makefile_star2_O1/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 0x1794d9
movq %rdx, %r8
testq %rdx, %rdx
je 0x1794de
testq %rcx, %rcx
je 0x1794e3
movl 0x40(%rdi), %eax
cmpl $0x1, %eax
je 0x17946f
testl %eax, %eax
jne 0x1794d7
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 0x1794ce
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x1794e8
jle 0x1794ed
movq %rax, %r9
shrq %r9
movq 0x38(%rdi), %rdx
movq $-0x1, %r10
cmpq %rsi, (%rdx,%r9,8)
ja 0x179496
movq %r9, %rax
jmp 0x179499
movq %r9, %r10
movq %rax, %r11
subq %r10, %r11
movq %r11, %r9
sarq %r9
addq %r10, %r9
cmpq $0x1, %r11
jg 0x17948b
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 0x541f4
callq 0x541bb
callq 0x54182
callq 0x54149
callq 0x5411c
// File: /workspace/github_c_makefile_star2_O1/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
movq 0x20(%rdi), %rdx
cmpq %rdx, %rcx
jne 0x179548
movq 0x18(%rdi), %rax
cmpq %rdx, %rax
jae 0x17954d
leaq 0x1(%rax), %rsi
cmpq %rdx, %rsi
jne 0x17951b
xorl %eax, %eax
jmp 0x179546
cmpq %rcx, %rsi
jae 0x179552
movl 0x40(%rdi), %ecx
cmpl $0x1, %ecx
je 0x17953d
movq $-0x1, %rax
testl %ecx, %ecx
jne 0x179546
movq 0x30(%rdi), %rax
addq 0x10(%rdi), %rax
jmp 0x179546
movq 0x38(%rdi), %rcx
movq 0x8(%rcx,%rax,8), %rax
popq %rcx
retq
callq 0x5422d
callq 0x54266
callq 0x5429f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sampling.c
// Function: gt_sampling_get_next_sample
int gt_sampling_get_next_sample(GtSampling *sampling,
                                GtUword *sampled_element,
                                size_t *position)
{
  enum state {
    ERROR = -1,
    END,
    SUCCESS
  };
  enum state status = END;

  if (sampling->current_sample_num + 1 == sampling->numofsamples) {
    sampling->current_sample_num = 0;
    *sampled_element = sampling->current_sample_elementnum = 0;
  }
  else {
    status = SUCCESS;
    sampling->current_sample_num++;
    switch (sampling->method) {
      case GT_SAMPLING_REGULAR:
        *sampled_element =
          sampling->current_sample_elementnum += sampling->sampling_rate;
        break;
      case GT_SAMPLING_PAGES:
        *sampled_element = sampling->current_sample_elementnum =
          sampling->page_sampling[sampling->current_sample_num];
        break;
      default:
        status = ERROR;
    }
  }
  if (status != ERROR)
    *position = sampling->samplingtab[sampling->current_sample_num];
  return (int) status;
}

// Assembly:
movq 0x18(%rdi), %rax
leaq 0x1(%rax), %rcx
cmpq 0x20(%rdi), %rcx
jne 0x179572
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
xorl %ecx, %ecx
xorl %eax, %eax
jmp 0x17959e
movq %rcx, 0x18(%rdi)
movl 0x40(%rdi), %ecx
cmpl $0x1, %ecx
je 0x17958c
testl %ecx, %ecx
jne 0x1795b6
movq 0x10(%rdi), %rcx
addq 0x30(%rdi), %rcx
jmp 0x179595
movq 0x38(%rdi), %rcx
movq 0x8(%rcx,%rax,8), %rcx
movq %rcx, 0x10(%rdi)
movl $0x1, %eax
movq %rcx, (%rsi)
xorl %ecx, %ecx
testb %cl, %cl
jne 0x1795b5
movq (%rdi), %rcx
movq 0x18(%rdi), %rsi
movq (%rcx,%rsi,8), %rcx
movq %rcx, (%rdx)
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movb $0x1, %cl
jmp 0x1795a3
// File: /workspace/github_c_makefile_star2_O1/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 0x1796bf
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1796c4
movq %rdx, %r15
movq %rsi, %rbx
movq 0x8(%r14), %rcx
movq 0x20(%r14), %rax
incq %rax
movq %rax, 0x20(%r14)
cmpq %rcx, %rax
jne 0x179689
movq %rcx, %rax
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %rdx # imm = 0x28F5C28F5C28F5C3
mulq %rdx
shrq $0x2, %rdx
leaq (%rcx,%rdx), %rax
addq %rdx, %rcx
addq $0xa, %rcx
movq %rcx, 0x8(%r14)
leaq 0x50(,%rax,8), %rsi
leaq 0x221a67(%rip), %rdx    # 0x39b0b6
movl $0x162, %ecx            # imm = 0x162
callq 0x1094e6
movq %rax, (%r14)
cmpl $0x1, 0x40(%r14)
jne 0x179689
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x1796ce
movq 0x8(%r14), %rsi
shlq $0x3, %rsi
leaq 0x221a3b(%rip), %rdx    # 0x39b0b6
movl $0x167, %ecx            # imm = 0x167
callq 0x1094e6
movq %rax, 0x38(%r14)
cmpl $0x1, 0x40(%r14)
jne 0x17969f
movq 0x20(%r14), %rax
movq 0x38(%r14), %rcx
movq %r15, -0x8(%rcx,%rax,8)
jmp 0x1796ad
movq %r15, %rax
xorl %edx, %edx
divq 0x30(%r14)
testq %rdx, %rdx
jne 0x1796c9
movq (%r14), %rax
movq 0x20(%r14), %rcx
movq %rbx, -0x8(%rax,%rcx,8)
popq %rbx
popq %r14
popq %r15
retq
callq 0x543f5
callq 0x543bc
callq 0x5434a
callq 0x54383
// File: /workspace/github_c_makefile_star2_O1/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 0x17973e
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x2219ad(%rip), %r14    # 0x39b0b6
movq %r14, %rsi
movl $0x184, %edx            # imm = 0x184
callq 0x109670
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x185, %edx            # imm = 0x185
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x186, %edx            # imm = 0x186
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x221cd2(%rip), %rsi    # 0x39b42d
movl $0x30, %edi
movl $0x29, %edx
callq 0x1092b2
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_O1/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 0x1798b8
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movb 0x28(%rbx), %al
testq %rdi, %rdi
je 0x179860
testb %al, %al
je 0x1798bd
movzbl %r14b, %esi
movzbl %bpl, %edx
callq 0x1191b4
cltq
jmp 0x1798b3
testb %al, %al
je 0x17988a
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 0x1798b3
cmpb $0x1, 0x29(%rbx)
jne 0x1798a7
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 0x545e6
callq 0x545af
// File: /workspace/github_c_makefile_star2_O1/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 0x179ada
testq %rsi, %rsi
je 0x179ada
testq %rdx, %rdx
je 0x179ada
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x179ac0
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %r8
movq %rdx, %rdi
movq %rax, %rdx
jmp 0x127433
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %r8
movq 0x18(%rdi), %r9
movq %rdx, %rdi
movq %rax, %rdx
jmp 0x127402
pushq %rax
callq 0x54656
// File: /workspace/github_c_makefile_star2_O1/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 0x179c01
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
leaq 0x221af6(%rip), %rsi    # 0x39b5ff
movl $0x18, %edi
movl $0x46, %edx
callq 0x1092b2
movq %rax, %rbx
movq %r15, %rdi
callq 0x120955
movq %rax, 0x8(%rbx)
callq 0x231b44
movq %rax, (%rbx)
movq $0x0, 0x10(%rbx)
testq %rax, %rax
je 0x179bcc
leaq 0x3452d9(%rip), %rsi    # 0x4bee20
movq %rax, %rdi
callq 0x179d02
testb %bpl, %bpl
je 0x179b63
movq (%rbx), %rdi
leaq 0x345322(%rip), %rsi    # 0x4bee80
callq 0x179d02
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x23180b
testl %eax, %eax
jne 0x179b84
movq (%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x22f092
testl %eax, %eax
je 0x179bf3
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x22db9e
leaq 0x216181(%rip), %rsi    # 0x38fd1b
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1019cf
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x22d42e
movq (%rbx), %rdi
callq 0x2307b5
movq 0x8(%rbx), %rdi
callq 0x121b03
movl $0x5b, %edx
jmp 0x179be2
leaq 0x211744(%rip), %rsi    # 0x38b317
movq %r14, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0x4c, %edx
leaq 0x221a16(%rip), %rsi    # 0x39b5ff
movq %rbx, %rdi
callq 0x109670
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x5468f
// File: /workspace/github_c_makefile_star2_O1/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 0x179cfd
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2219d1(%rip), %rsi    # 0x39b5ff
movl $0x18, %edi
movl $0x70, %edx
callq 0x1092b2
movq %rax, %rbx
xorl %r12d, %r12d
movq %r12, 0x8(%rax)
callq 0x231b44
movq %rax, (%rbx)
movq %r12, 0x10(%rbx)
testq %rax, %rax
je 0x179cc7
leaq 0x3451c1(%rip), %rsi    # 0x4bee20
movq %rax, %rdi
callq 0x179d02
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x231b09
testl %eax, %eax
jne 0x179c88
movq (%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x22f092
testl %eax, %eax
je 0x179cee
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x22db9e
leaq 0x21607d(%rip), %rsi    # 0x38fd1b
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1019cf
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x22d42e
movq (%rbx), %rdi
callq 0x2307b5
movl $0x81, %edx
jmp 0x179cdd
leaq 0x211649(%rip), %rsi    # 0x38b317
movq %r14, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0x76, %edx
leaq 0x22191b(%rip), %rsi    # 0x39b5ff
movq %rbx, %rdi
callq 0x109670
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x546c6
// File: /workspace/github_c_makefile_star2_O1/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 0x179d46
movq %rdi, %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x22e48c
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x22e0c4
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x22efe6
movq 0x18(%rbx), %rsi
addq $0x10, %rbx
testq %rsi, %rsi
jne 0x179d15
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x22d421
movl %eax, %ebp
movq (%rbx), %rdi
leaq 0x1e768d(%rip), %rdx    # 0x3617a8
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x22e6f4
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22d7b8
testl %eax, %eax
je 0x17a189
movq %r12, %rdi
callq 0x14b5fc
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x18f4ad
movq (%rbx), %rdi
xorl %r12d, %r12d
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x22f092
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x17a192
xorl %edx, %edx
callq 0x22db9e
leaq 0x2215b4(%rip), %rsi    # 0x39b72e
movq %r15, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1019cf
jmp 0x17a1af
leaq 0x22157d(%rip), %rsi    # 0x39b70d
jmp 0x17a1a5
callq 0x22d7b8
movb $0x1, %cl
cmpl $0x1, %eax
je 0x17a1c4
leaq 0x2215ad(%rip), %rsi    # 0x39b752
movq %r15, %rdi
xorl %eax, %eax
callq 0x1019cf
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x22d42e
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
xorl %ecx, %ecx
testb %cl, %cl
je 0x17a1e8
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22db78
testl %eax, %eax
setne (%r14)
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x22d42e
movq (%rbx), %rdi
callq 0x22d421
cmpl %ebp, %eax
jne 0x17a200
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x54853
// File: /workspace/github_c_makefile_star2_O1/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 0x17a22e
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x17a230
decq %rax
movq %rax, 0x10(%rbx)
popq %rbx
retq
movq 0x8(%rbx), %rdi
callq 0x121b03
movq (%rbx), %rdi
callq 0x2307b5
leaq 0x2213b7(%rip), %rsi    # 0x39b5ff
movq %rbx, %rdi
movl $0x14f, %edx            # imm = 0x14F
popq %rbx
jmp 0x109670
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xe6a03
cmpq $0x0, 0x34f5f2(%rip)    # 0x4c9858
jne 0x17a287
leaq 0x26(%rip), %rsi        # 0x17a295
leaq 0x49(%rip), %rdx        # 0x17a2bf
movl $0x20, %edi
callq 0x16abb4
movq %rax, 0x34f5d1(%rip)    # 0x4c9858
callq 0xe6a19
movq 0x34f5c5(%rip), %rax    # 0x4c9858
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x17a2e4
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17a379
callq 0x17a258
movq %rax, %rdi
movq %r15, %rsi
callq 0x16ae64
movq %rax, %r15
movq 0x18(%rax), %rdi
callq 0x17afc2
testq %rax, %rax
jne 0x17a336
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x16ace8
testl %eax, %eax
jne 0x17a351
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x17a355
movq 0x18(%r15), %rsi
movq %r14, %rdx
callq 0x14b992
testl %eax, %eax
jne 0x17a359
movq 0x18(%r15), %rdi
jmp 0x17a2fb
movq 0x18(%r15), %rdi
callq 0x17afe0
movq %rax, (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebp
jmp 0x17a36a
xorl %ebp, %ebp
jmp 0x17a36a
movl %eax, %ebp
movq (%rbx), %rdi
callq 0x14c43a
movq $0x0, (%rbx)
testl %ebp, %ebp
jne 0x17a344
cmpq $0x0, (%rbx)
je 0x17a344
callq 0x548c3
callq 0x5488c
// File: /workspace/github_c_makefile_star2_O1/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 0x17a258
movq %rax, %rbx
movq %r14, %rdi
callq 0x16ae51
movzbl %al, %esi
movq %rbx, %rdi
callq 0x16abec
movq %rax, %rbx
callq 0x17a258
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
testq %r14, %r14
je 0x17a48e
movq %rax, %rbp
movb 0x78(%rsp), %r15b
movq %r14, %rdi
callq 0x16ac58
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 0x17ad5a
addq $0x40, %rsp
movq %rax, 0x18(%rbp)
testq %rax, %rax
jne 0x17a47c
movq %rbx, %rdi
callq 0x16ac6e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x548fa
// File: /workspace/github_c_makefile_star2_O1/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 0x17a501
movq %rsi, %r14
testq %rsi, %rsi
je 0x17a501
movq %rdx, %rbx
movq %rdi, %r15
callq 0x17a508
movq 0x18(%r15), %rsi
movq %rax, %rdi
callq 0x16af21
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x17affe
callq 0x54931
nop