LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_do_not_overlap
bool gt_ranges_do_not_overlap(const GtArray *ranges)
{
  GtUword i;

  gt_assert(ranges && gt_array_size(ranges));

  for (i = 1; i < gt_array_size(ranges); i++) {
    if (gt_range_overlap(gt_array_get(ranges, i-1), gt_array_get(ranges, i)))
      return false;
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7eb88
movq %rdi, %rbx
callq 0x6f310
testq %rax, %rax
je 0x7eb88
movq %rbx, %rdi
callq 0x6f310
movb $0x1, %bpl
cmpq $0x2, %rax
jb 0x7eb7b
movl $0x1, %r14d
leaq -0x1(%r14), %rsi
movq %rbx, %rdi
callq 0x6f037
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6f037
movq %r15, %rdi
movq %rax, %rsi
callq 0x7e1b2
movl %eax, %ebp
testb %al, %al
jne 0x7eb77
incq %r14
movq %rbx, %rdi
callq 0x6f310
cmpq %rax, %r14
jb 0x7eb3c
xorb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1d6de
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_are_equal
bool gt_ranges_are_equal(const GtArray *ranges_1, const GtArray *ranges_2)
{
  GtUword i;

  gt_assert(gt_ranges_are_sorted(ranges_1) && gt_ranges_are_sorted(ranges_2));

  if (gt_array_size(ranges_1) != gt_array_size(ranges_2))
    return false;

  for (i = 0; i < gt_array_size(ranges_1); i++) {
    if (gt_range_compare(gt_array_get(ranges_1, i), gt_array_get(ranges_2, i)))
      return false;
  }

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x7ea99
testb %al, %al
je 0x7ec46
movq %rbx, %rdi
callq 0x7ea99
testb %al, %al
je 0x7ec46
movq %r14, %rdi
callq 0x6f310
movq %rax, %r15
movq %rbx, %rdi
callq 0x6f310
cmpq %rax, %r15
jne 0x7ec34
movq %r14, %rdi
callq 0x6f310
testq %rax, %rax
je 0x7ec38
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x6f037
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6f037
movq %r12, %rdi
movq %rax, %rsi
callq 0x7e09c
testl %eax, %eax
sete %bpl
jne 0x7ec3b
incq %r15
movq %r14, %rdi
callq 0x6f310
cmpq %rax, %r15
jb 0x7ebf6
jmp 0x7ec3b
xorl %ebp, %ebp
jmp 0x7ec3b
movb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1d717
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/range.c
// Function: generic_ranges_uniq
static GtArray* generic_ranges_uniq(GtArray *out_ranges,
                                    const GtArray *in_ranges, bool count)
{
  GtUword i, *ctr_ptr, ctr = 1;
  GtArray *count_array = NULL;
  GtRange cur  = { GT_UNDEF_UWORD, GT_UNDEF_UWORD },
        prev = { GT_UNDEF_UWORD, GT_UNDEF_UWORD };
  gt_assert(out_ranges && in_ranges);
  gt_assert(gt_ranges_are_sorted(in_ranges));
  if (count)
    count_array = gt_array_new(sizeof (GtUword));
  for (i = 0; i < gt_array_size(in_ranges); i++) {
    cur = *(GtRange*) gt_array_get(in_ranges, i);
    if (!i) {
      gt_array_add(out_ranges, cur);
      if (count)
        gt_array_add(count_array, ctr);
    }
    else {
      if (prev.start == cur.start && prev.end == cur.end) {
        if (count) {
          ctr_ptr = gt_array_get_last(count_array);
          (*ctr_ptr)++;
        }
      }
      else {
        gt_array_add(out_ranges, cur);
        if (count)
          gt_array_add(count_array, ctr);
      }
    }
    prev = cur;
  }
  return count_array;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq $0x1, 0x20(%rsp)
pcmpeqd %xmm0, %xmm0
movdqa %xmm0, 0x10(%rsp)
testq %rdi, %rdi
je 0x7ed60
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x7ea99
testb %al, %al
je 0x7ed65
testb %bl, %bl
je 0x7eca2
movl $0x8, %edi
callq 0x6ef7c
movq %rax, 0x8(%rsp)
jmp 0x7ecab
movq $0x0, 0x8(%rsp)
movq %r14, %rdi
callq 0x6f310
testq %rax, %rax
je 0x7ed4c
movq $-0x1, %rbp
xorl %r13d, %r13d
movq $-0x1, %r12
movq %r14, %rdi
movq %r13, %rsi
callq 0x6f037
movdqu (%rax), %xmm0
movdqa %xmm0, 0x10(%rsp)
testq %r13, %r13
je 0x7ed08
cmpq 0x10(%rsp), %rbp
jne 0x7ed08
cmpq 0x18(%rsp), %r12
jne 0x7ed08
testb %bl, %bl
je 0x7ed32
movq 0x8(%rsp), %rdi
callq 0x6f05b
incq (%rax)
jmp 0x7ed32
movl $0x10, %edx
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
callq 0x6f240
testb %bl, %bl
je 0x7ed32
movl $0x8, %edx
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6f240
movq 0x10(%rsp), %rbp
movq 0x18(%rsp), %r12
incq %r13
movq %r14, %rdi
callq 0x6f310
cmpq %rax, %r13
jb 0x7eccd
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1d789
callq 0x1d750
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/range.c
// Function: generic_ranges_uniq_in_place
static GtArray* generic_ranges_uniq_in_place(GtArray *ranges, bool count)
{
  GtArray *out_ranges, *count_array;
  gt_assert(ranges);
  out_ranges = gt_array_new(sizeof (GtRange));
  count_array = generic_ranges_uniq(out_ranges, ranges, count);
  gt_array_reset(ranges);
  gt_array_add_array(ranges, out_ranges); /* XXX: could be more efficient
                                               with something like
                                               gt_array_replace(ranges,
                                                             out_ranges) */
  gt_array_delete(out_ranges);
  return count_array;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl $0x10, %edi
callq 0x6ef7c
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x7ec4b
movq %rax, %rbx
movq %r14, %rdi
callq 0x6f349
movq %r14, %rdi
movq %r15, %rsi
callq 0x6f2b9
movq %r15, %rdi
callq 0x6f768
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_are_consecutive
bool gt_ranges_are_consecutive(const GtArray *ranges)
{
  GtUword i;
  for (i = 0; i < gt_array_size(ranges); i++) {
    gt_assert(((GtRange*) gt_array_get(ranges, i))->start <=
              ((GtRange*) gt_array_get(ranges, i))->end);
    if (i) {
      /* check if ranges are consecutive */
      if (((GtRange*) gt_array_get(ranges, i-1))->end >=
          ((GtRange*) gt_array_get(ranges, i))->start) {
        return false;
      }
    }
  }
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x6f310
movb $0x1, %bl
testq %rax, %rax
je 0x7ee27
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x6f037
movq (%rax), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x6f037
cmpq 0x8(%rax), %r12
ja 0x7ee35
testq %r15, %r15
je 0x7ee13
leaq -0x1(%r15), %rsi
movq %r14, %rdi
callq 0x6f037
movq 0x8(%rax), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x6f037
cmpq (%rax), %r12
jae 0x7ee25
incq %r15
movq %r14, %rdi
callq 0x6f310
cmpq %rax, %r15
jb 0x7edcf
jmp 0x7ee27
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1d7c2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_total_length
GtUword gt_ranges_total_length(const GtArray *ranges)
{
  GtUword i, totallen = 0;
  GtRange *range;
  gt_assert(ranges);
  for (i = 0; i < gt_array_size(ranges); i++) {
    range = gt_array_get(ranges, i);
    totallen += range->end - range->start + 1;
  }
  return totallen;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x7ee8a
movq %rdi, %rbx
callq 0x6f310
testq %rax, %rax
je 0x7ee7e
xorl %r15d, %r15d
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6f037
addq 0x8(%rax), %r14
subq (%rax), %r14
incq %r14
incq %r15
movq %rbx, %rdi
callq 0x6f310
cmpq %rax, %r15
jb 0x7ee57
jmp 0x7ee81
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1d7fb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_spanned_length
GtUword gt_ranges_spanned_length(const GtArray *ranges)
{
  GtRange spanned_range;
  gt_assert(ranges);
  spanned_range.start = ((GtRange*) gt_array_get_first(ranges))->start;
  spanned_range.end   = ((GtRange*) gt_array_get_last(ranges))->end;
  return gt_range_length(&spanned_range);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x7eece
movq %rdi, %rbx
callq 0x6f054
movq (%rax), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x6f05b
movq 0x8(%rax), %rax
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x7e19f
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x1d834
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_copy_to_opposite_strand
void gt_ranges_copy_to_opposite_strand(GtArray *outranges,
                                       const GtArray *inranges,
                                       GtUword gen_total_length,
                                       GtUword gen_offset)
{
  GtRange range;
  GtUword i;

  /* outranges are empty */
  gt_assert(!gt_array_size(outranges));
  /* inranges are not empty */
  gt_assert(gt_array_size(inranges));

  for (i = gt_array_size(inranges); i > 0; i--) {
    /* genomic offset is defined */
    gt_assert(gen_offset != GT_UNDEF_UWORD);
    range.start  = gen_total_length - 1
                  - (((GtRange*) gt_array_get(inranges, i-1))->end -
                     gen_offset)
                  + gen_offset;
    range.end = gen_total_length - 1
                  - (((GtRange*) gt_array_get(inranges, i-1))->start -
                     gen_offset)
                  + gen_offset;
    gt_array_add(outranges, range);
  }

  /* outranges has the same number of elements as inranges */
  gt_assert(gt_array_size(inranges) == gt_array_size(outranges));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
callq 0x6f310
testq %rax, %rax
jne 0x7ef98
movq %r14, %rdi
callq 0x6f310
testq %rax, %rax
je 0x7ef9d
movq %r14, %rdi
callq 0x6f310
testq %rax, %rax
je 0x7ef72
cmpq $-0x1, %r12
je 0x7efa7
movq %rax, %r15
leaq -0x1(%r13,%r12,2), %r13
decq %r15
movq %rsp, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x6f037
movq %r13, %rcx
subq 0x8(%rax), %rcx
movq %rcx, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6f037
movq %r13, %rcx
subq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movl $0x10, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6f240
addq $-0x1, %r15
jb 0x7ef30
movq %r14, %rdi
callq 0x6f310
movq %rax, %r14
movq %rbx, %rdi
callq 0x6f310
cmpq %rax, %r14
jne 0x7efa2
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1d86d
callq 0x1d918
callq 0x1d8df
callq 0x1d8a6
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_borders_are_in_region
bool gt_ranges_borders_are_in_region(GtArray *ranges, const GtRange *region)
{
  gt_assert(ranges && region);

  /* check region start */
  if (((GtRange*) gt_array_get_first(ranges))->start < region->start)
    return false;

  /* check region end */
  if (((GtRange*) gt_array_get_last(ranges))->end > region->end)
    return false;

  return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7efec
movq %rsi, %rbx
testq %rsi, %rsi
je 0x7efec
movq %rdi, %r14
callq 0x6f054
movq (%rax), %rax
cmpq (%rbx), %rax
jae 0x7efd1
xorl %eax, %eax
jmp 0x7efe4
movq %r14, %rdi
callq 0x6f05b
movq 0x8(%rax), %rax
cmpq 0x8(%rbx), %rax
setbe %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1d951
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_show
void gt_ranges_show(GtArray *ranges, GtFile *outfp)
{
  GtRange *range;
  GtUword i;
  gt_assert(ranges);
  for (i = 0; i < gt_array_size(ranges); i++) {
    range = gt_array_get(ranges, i);
    gt_file_xprintf(outfp, "("GT_WU","GT_WU")", range->start, range->end);
  }
  gt_file_xfputc('\n', outfp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7f05f
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6f310
testq %rax, %rax
je 0x7f047
leaq 0x73a52(%rip), %r15     # 0xf2a67
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0x6f037
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x75ce5
incq %r12
movq %r14, %rdi
callq 0x6f310
cmpq %rax, %r12
jb 0x7f018
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x75f43
callq 0x1d98a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/safearith.c
// Function: gt_safe_mult_u32_check_func
uint32_t gt_safe_mult_u32_check_func(uint32_t a, uint32_t b,
                                     const char *src_file, int src_line,
                                     GtOverflowHandlerFunc handler_func,
                                     void *data)
{
  GtUint64 x = (GtUint64) a * b;
  if (x > 0xffffffff) { /* overflow */
    handler_func(src_file, src_line, data);
  }
  return x;
}

// Assembly:
pushq %rbx
movq %rdx, %r10
movl %edi, %eax
mull %esi
movl %eax, %ebx
jno 0x7f0c1
movq %r10, %rdi
movl %ecx, %esi
movq %r9, %rdx
callq *%r8
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/sequence_buffer.c
// Function: gt_sequence_buffer_create
GtSequenceBuffer*
gt_sequence_buffer_create(const GtSequenceBufferClass *sic)
{
  GtSequenceBuffer *si;
  gt_assert(sic && sic->size);
  si = gt_calloc(1, sic->size);
  si->c_class = sic;
  si->pvt = gt_calloc(1, sizeof (GtSequenceBufferMembers));
  return si;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x7f214
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x7f214
leaq 0x73b5d(%rip), %r14     # 0xf2d35
movl $0x1, %edi
movq %r14, %rdx
movl $0x25, %ecx
callq 0x359a6
movq %rax, %r15
movq %rbx, (%rax)
movl $0x1, %edi
movl $0x6088, %esi           # imm = 0x6088
movq %r14, %rdx
movl $0x27, %ecx
callq 0x359a6
movq %rax, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1da35
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/sequence_buffer.c
// Function: gt_sequence_buffer_delete
void gt_sequence_buffer_delete(GtSequenceBuffer *si)
{
  if (!si) return;
  if (si->pvt->reference_count) {
    si->pvt->reference_count--;
    return;
  }
  gt_assert(si->c_class && si->c_class->free);
  si->c_class->free(si);
  gt_free(si->pvt);
  gt_free(si);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7f239
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x30(%rax), %rcx
testq %rcx, %rcx
je 0x7f241
decq %rcx
movq %rcx, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rax
testq %rax, %rax
je 0x7f286
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x7f286
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
leaq 0x73ad3(%rip), %r14     # 0xf2d35
movq %r14, %rsi
movl $0x34, %edx
callq 0x35c27
movq %rbx, %rdi
movq %r14, %rsi
movl $0x35, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
callq 0x1da6c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/sequence_buffer.c
// Function: gt_sequence_buffer_next
int gt_sequence_buffer_next(GtSequenceBuffer *sb, GtUchar *val,
                            GtError *err)
{
  GtSequenceBufferMembers *pvt;
  pvt = sb->pvt;
  if (pvt->nextread >= pvt->nextfree) {
    if (pvt->complete) {
      return 0;
    }
    if (pvt->descptr && pvt->nextread > 0)
      gt_desc_buffer_reset(pvt->descptr);
    if (gt_sequence_buffer_advance(sb, err) != 0) {
      return -1;
    }
    pvt->nextread = 0;
    if (pvt->nextfree == 0) {
      return 0;
    }
  }
  *val = pvt->outbuf[pvt->nextread++];
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rdi), %r12
movq 0x50(%r12), %rcx
cmpq 0x58(%r12), %rcx
jae 0x7f50f
leaq 0x1(%rcx), %rax
movq %rax, 0x50(%r12)
movb 0x2079(%r12,%rcx), %al
movb %al, (%rbx)
movl $0x1, %eax
jmp 0x7f54f
xorl %eax, %eax
cmpb $0x0, 0x18(%r12)
jne 0x7f54f
movq %rdx, %r14
movq %rdi, %r15
movq 0x20(%r12), %rdi
testq %rdi, %rdi
sete %al
testq %rcx, %rcx
sete %cl
orb %al, %cl
jne 0x7f539
callq 0xa3d14
movq %r15, %rdi
movq %r14, %rsi
callq 0x7f4bc
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
je 0x7f55b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq $0x0, 0x50(%r12)
xorl %eax, %eax
cmpq $0x0, 0x58(%r12)
je 0x7f54f
xorl %ecx, %ecx
jmp 0x7f4f5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/sequence_buffer.c
// Function: gt_sequence_buffer_next_with_original_raw
int gt_sequence_buffer_next_with_original_raw(GtSequenceBuffer *sb,
                                              GtUchar *val, char *orig,
                                              GtError *err)
{
  GtSequenceBufferMembers *pvt;
  pvt = sb->pvt;
  if (pvt->nextread >= pvt->nextfree) {
    if (pvt->complete) {
      return 0;
    }
    if (pvt->descptr && pvt->nextread > 0)
      gt_desc_buffer_reset(pvt->descptr);
    if (gt_sequence_buffer_advance(sb, err) != 0) {
      return -1;
    }
    pvt->nextread = 0;
    if (pvt->nextfree == 0) {
      return 0;
    }
  }
  *val = pvt->outbuf[pvt->nextread];
  *orig = pvt->outbuforig[pvt->nextread];
  pvt->nextread++;
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rdi), %r13
movq 0x50(%r13), %rcx
cmpq 0x58(%r13), %rcx
jae 0x7f5b6
movb 0x2079(%r13,%rcx), %al
movb %al, (%r14)
movq 0x50(%r13), %rax
movb 0x4079(%r13,%rax), %al
movb %al, (%rbx)
incq 0x50(%r13)
movl $0x1, %eax
jmp 0x7f5f1
xorl %eax, %eax
cmpb $0x0, 0x18(%r13)
jne 0x7f5f1
movq %rdi, %r12
movq 0x20(%r13), %rdi
testq %rdi, %rdi
sete %al
testq %rcx, %rcx
sete %cl
orb %al, %cl
jne 0x7f5db
callq 0xa3d14
movq %r12, %rdi
movq %r15, %rsi
callq 0x7f4bc
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
je 0x7f5fb
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq $0x0, 0x50(%r13)
xorl %eax, %eax
cmpq $0x0, 0x58(%r13)
je 0x7f5f1
xorl %ecx, %ecx
jmp 0x7f592
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/sequence_buffer_dust.c
// Function: gt_dust_masker_new
GtDustMasker* gt_dust_masker_new(bool echo, GtUword windowsize,
                                 double threshold,
                                 GtUword linker)
{
  GtDustMasker *dust_masker = gt_calloc(1, sizeof *dust_masker);
  dust_masker->echo = echo;
  dust_masker->windowsize = windowsize;
  dust_masker->threshold = threshold;
  dust_masker->linker = linker;

  dust_masker->buf_size = windowsize + linker;
  dust_masker->buf = gt_calloc(dust_masker->buf_size,
                               sizeof *(dust_masker->buf));
  dust_masker->buf_initialized = false;
  dust_masker->buf_readpos = 0;
  dust_masker->buf_insertpos = 0;
  dust_masker->buf_remaining = 0;

  dust_masker->nuc_val1 = 0;
  dust_masker->nuc_val2 = 0;

  dust_masker->rv = 0;
  dust_masker->rw = 0;
  dust_masker->L_param = 0;
  dust_masker->w_queue = gt_inl_queue_new(windowsize);

  dust_masker->total_length = 0;
  dust_masker->current_length = 0;
  dust_masker->current_pos_total = 0;
  dust_masker->current_pos_local = 0;

  dust_masker->last_seq_start = 0;

  GT_INITARRAY(&dust_masker->masked_regions,GtDustRange);
  dust_masker->mask_length = 0;
  dust_masker->next_mask = 0;
  dust_masker->current_is_masked = false;
  dust_masker->current_region_index = 0;

  dust_masker->masking_done = false;

  return dust_masker;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x73781(%rip), %r12     # 0xf308a
movl $0x1, %edi
movl $0x3d8, %esi            # imm = 0x3D8
movq %r12, %rdx
movl $0x5f, %ecx
callq 0x359a6
movq %rax, %r14
movb %bpl, 0x3b8(%rax)
movq %rbx, 0x3c0(%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x3d0(%rax)
movq %r15, 0x3c8(%rax)
addq %rbx, %r15
movq %r15, 0x28(%rax)
movl $0x20, %esi
movq %r15, %rdi
movq %r12, %rdx
movl $0x67, %ecx
callq 0x359a6
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movw $0x0, 0x30(%r14)
xorl %eax, %eax
movq %rax, 0x34(%r14)
movq %rax, 0x340(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %rax, 0x20(%r14)
leaq 0x73774(%rip), %rsi     # 0xf3105
movl $0x28, %edi
movl $0x33, %edx
callq 0x35862
testq %rbx, %rbx
je 0x7fa24
movq %rax, %r15
leaq 0x73756(%rip), %rsi     # 0xf3105
movq %rbx, %rdi
movl $0x35, %edx
callq 0x35862
movq %rax, (%r15)
xorl %eax, %eax
movq %rax, 0x20(%r15)
movq %rbx, 0x18(%r15)
decq %rbx
movq %rbx, 0x8(%r15)
movq %rbx, 0x10(%r15)
movq %r15, 0x348(%r14)
movq %rax, 0x3b0(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x37a(%r14)
movups %xmm0, 0x370(%r14)
movups %xmm0, 0x360(%r14)
movups %xmm0, 0x350(%r14)
movq %rax, 0x3a0(%r14)
movups %xmm0, 0x390(%r14)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1dd41
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/sequence_buffer_dust.c
// Function: gt_dust_masker_delete
void gt_dust_masker_delete(GtDustMasker *dust_masker)
{
  if (dust_masker) {
    gt_free(dust_masker->buf);
    gt_inl_queue_delete(dust_masker->w_queue);
    GT_FREEARRAY(&dust_masker->masked_regions,GtDustRange);
    gt_free(dust_masker);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x7facd
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x73646(%rip), %rsi     # 0xf308a
movl $0x8a, %edx
callq 0x35c27
movq 0x348(%rbx), %r14
testq %r14, %r14
je 0x7fa81
movq (%r14), %rdi
leaq 0x736a1(%rip), %r15     # 0xf3105
movq %r15, %rsi
movl $0x44, %edx
callq 0x35c27
movq %r14, %rdi
movq %r15, %rsi
movl $0x45, %edx
callq 0x35c27
movq 0x390(%rbx), %rdi
testq %rdi, %rdi
je 0x7fab4
leaq 0x390(%rbx), %r14
leaq 0x735ef(%rip), %rsi     # 0xf308a
movl $0x8c, %edx
callq 0x35c27
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x735cf(%rip), %rsi     # 0xf308a
movq %rbx, %rdi
movl $0x8d, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x35c27
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/sequence_buffer_embl.c
// Function: gt_sequence_buffer_embl_free
static void gt_sequence_buffer_embl_free(GtSequenceBuffer *sb)
{
  GtSequenceBufferEMBL *sbe = gt_sequence_buffer_embl_cast(sb);
  if (sb->pvt->inputstream)
    gt_file_delete(sb->pvt->inputstream);
  gt_str_delete(sbe->headerbuffer);
  gt_str_delete(sbe->overflowbuffer);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xce8ea(%rip), %rdi     # 0x14f7e8
movq %r14, %rsi
callq 0x7f41e
movq %rax, %rbx
movq 0x8(%r14), %rax
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x80f1b
callq 0x760c0
movq 0x10(%rbx), %rdi
callq 0x3c87b
movq 0x18(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3c87b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/sequence_buffer_embl.c
// Function: gt_sequence_buffer_embl_new
GtSequenceBuffer* gt_sequence_buffer_embl_new(const GtStrArray *sequences)
{
  GtSequenceBuffer *sb;
  GtSequenceBufferEMBL *sbe;
  sb = gt_sequence_buffer_create(gt_sequence_buffer_embl_class());
  sbe = gt_sequence_buffer_embl_cast(sb);
  sb->pvt->filenametab = sequences;
  sbe->headerbuffer = gt_str_new();
  sbe->overflowbuffer = gt_str_new();
  sb->pvt->filenum = 0;
  sb->pvt->linenum = 0;
  sbe->firstoverallentry = true;
  sbe->firstentryinfile = true;
  sbe->desc_spacer_was_set = false;
  sbe->nextfile = true;
  sb->pvt->nextread = sb->pvt->nextfree = 0;
  sb->pvt->lastspeciallength = 0;
  return sb;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xce895(%rip), %r14     # 0x14f7e8
movq %r14, %rdi
callq 0x7f1bc
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x7f41e
movq %rax, %r14
movq 0x8(%r15), %rax
movq %rbx, 0x70(%rax)
callq 0x3b728
movq %rax, 0x10(%r14)
callq 0x3b728
movq %rax, 0x18(%r14)
movq 0x8(%r15), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movw $0x101, 0x21(%r14)      # imm = 0x101
movb $0x1, 0x20(%r14)
movb $0x0, 0x24(%r14)
movq %rcx, 0x60(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/sequence_buffer_fasta.c
// Function: gt_sequence_buffer_fasta_new
GtSequenceBuffer* gt_sequence_buffer_fasta_new(const GtStrArray *sequences)
{
  GtSequenceBuffer *sb;
  GtSequenceBufferFasta *sbf;
  sb = gt_sequence_buffer_create(gt_sequence_buffer_fasta_class());
  sbf = gt_sequence_buffer_fasta_cast(sb);
  sb->pvt->filenametab = sequences;
  sbf->headerbuffer = gt_str_new();
  sb->pvt->filenum = 0;
  sbf->firstoverallseq = true;
  sbf->firstseqinfile = true;
  sbf->nextfile = true;
  sb->pvt->nextread = sb->pvt->nextfree = 0;
  sb->pvt->complete = false;
  sb->pvt->lastspeciallength = 0;
  return sb;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xce4aa(%rip), %r14     # 0x14f808
movq %r14, %rdi
callq 0x7f1bc
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x7f41e
movq %rax, %r14
movq 0x8(%r15), %rax
movq %rbx, 0x70(%rax)
callq 0x3b728
movq %rax, 0x10(%r14)
movq 0x8(%r15), %rax
movl $0x0, (%rax)
movw $0x101, 0x19(%r14)      # imm = 0x101
movb $0x1, 0x1b(%r14)
movb $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rax)
movq $0x0, 0x60(%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/sequence_buffer_fastq.c
// Function: gt_sequence_buffer_fastq_get_file_index
static GtUword
gt_sequence_buffer_fastq_get_file_index(GtSequenceBuffer *sb)
{
  GtSequenceBufferFastQ *sbfq;
  gt_assert(sb);
  sbfq = gt_sequence_buffer_fastq_cast(sb);
  return gt_seq_iterator_fastq_get_file_index((GtSeqIteratorFastQ*)
                                              sbfq->seqit);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x81889
movq %rdi, %rsi
leaq 0xcdfae(%rip), %rdi     # 0x14f828
callq 0x7f41e
movq 0x10(%rax), %rdi
popq %rax
jmp 0xa52d8
callq 0x1e0fa
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/sequence_buffer_fastq.c
// Function: gt_sequence_buffer_fastq_new
GtSequenceBuffer* gt_sequence_buffer_fastq_new(const GtStrArray *sequences)
{
  GtSequenceBuffer *sb;
  GtSequenceBufferFastQ *sbfq;
  sb = gt_sequence_buffer_create(gt_sequence_buffer_fastq_class());
  sbfq = gt_sequence_buffer_fastq_cast(sb);
  sbfq->seqit = NULL;
  sbfq->sequences = sequences;
  sb->pvt->filenametab = sequences;
  sbfq->overflowbuffer = gt_str_new();
  sb->pvt->filenum = 0;
  sb->pvt->nextread = sb->pvt->nextfree = 0;
  sb->pvt->lastspeciallength = 0;
  return sb;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xcdf5b(%rip), %r14     # 0x14f828
movq %r14, %rdi
callq 0x7f1bc
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x7f41e
movq %rax, %r14
xorl %r12d, %r12d
movq %r12, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq 0x8(%r15), %rax
movq %rbx, 0x70(%rax)
callq 0x3b728
movq %rax, 0x28(%r14)
movq 0x8(%r15), %rax
movl $0x0, (%rax)
movq %r12, 0x60(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rax)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/sequence_buffer_gb.c
// Function: gt_sequence_buffer_gb_free
static void gt_sequence_buffer_gb_free(GtSequenceBuffer *sb)
{
  GtSequenceBufferGB *sbe = gt_sequence_buffer_gb_cast(sb);
  if (sb->pvt->inputstream)
    gt_file_delete(sb->pvt->inputstream);
  gt_str_delete(sbe->headerbuffer);
  gt_str_delete(sbe->overflowbuffer);
  gt_str_delete(sbe->keywordbuffer);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xcce04(%rip), %rdi     # 0x14f848
movq %r14, %rsi
callq 0x7f41e
movq %rax, %rbx
movq 0x8(%r14), %rax
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x82a61
callq 0x760c0
movq 0x10(%rbx), %rdi
callq 0x3c87b
movq 0x18(%rbx), %rdi
callq 0x3c87b
movq 0x20(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3c87b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/sequence_buffer_gb.c
// Function: gt_sequence_buffer_gb_new
GtSequenceBuffer* gt_sequence_buffer_gb_new(const GtStrArray *sequences)
{
  GtSequenceBuffer *sb;
  GtSequenceBufferGB *sbe;
  sb = gt_sequence_buffer_create(gt_sequence_buffer_gb_class());
  sb->pvt->filenametab = sequences;
  sb->pvt->filenum = 0;
  sb->pvt->linenum = 0;
  sb->pvt->nextread = sb->pvt->nextfree = 0;
  sb->pvt->lastspeciallength = 0;
  sbe = gt_sequence_buffer_gb_cast(sb);
  sbe->headerbuffer = gt_str_new();
  sbe->overflowbuffer = gt_str_new();
  sbe->keywordbuffer = gt_str_new();
  return sb;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0xccd8b(%rip), %r15     # 0x14f848
movq %r15, %rdi
callq 0x7f1bc
movq %rax, %rbx
movq 0x8(%rax), %rax
movq %r14, 0x70(%rax)
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rcx, 0x60(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7f41e
movq %rax, %r14
callq 0x3b728
movq %rax, 0x10(%r14)
callq 0x3b728
movq %rax, 0x18(%r14)
callq 0x3b728
movq %rax, 0x20(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/sequence_buffer_gb.c
// Function: get_keyword
static inline int get_keyword(GtSequenceBuffer *sb, GtStr *kwbuf,
                              GtUword *currentfileread)
{
  int currentchar;
  currentchar = inlinebuf_getchar(sb, sb->pvt->inputstream);
  if (currentchar == EOF)
      return EOF;
  (*currentfileread)++;
  while (currentchar != NEWLINESYMBOL && !isspace(currentchar)) {
    gt_str_append_char(kwbuf, currentchar);
    currentchar = inlinebuf_getchar(sb, sb->pvt->inputstream);
    if (currentchar == EOF)
      return EOF;
    (*currentfileread)++;
  }
  inlinebuf_ungetchar(sb);
  (*currentfileread)--;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %r12
cmpb $0x1, 0x19(%r12)
jne 0x82b46
movb $0x0, 0x19(%r12)
movb 0x78(%r12), %bpl
jmp 0x82b8a
movq 0x48(%r12), %rax
cmpq 0x40(%r12), %rax
jb 0x82b77
movq 0x28(%r12), %rdi
leaq 0x79(%r12), %rsi
movl $0x2000, %edx           # imm = 0x2000
callq 0x75fcd
cltq
movq %rax, 0x40(%r12)
testl %eax, %eax
je 0x82c4b
xorl %eax, %eax
leaq 0x1(%rax), %rcx
movq %rcx, 0x48(%r12)
movb 0x79(%r12,%rax), %bpl
movb %bpl, 0x78(%r12)
movq (%rbx), %r13
leaq 0x1(%r13), %rax
movq %rax, (%rbx)
cmpb $0xa, %bpl
jne 0x82bc0
movq 0x8(%r14), %rax
cmpb $0x1, 0x19(%rax)
je 0x82c55
movb $0x1, 0x19(%rax)
movq %r13, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xb6e0
movq %rax, %r12
movq (%rax), %rax
movzbl %bpl, %ecx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x82b9a
movsbl %bpl, %esi
movq %r15, %rdi
callq 0x3b9df
movq 0x8(%r14), %r13
cmpb $0x1, 0x19(%r13)
jne 0x82bf8
movb $0x0, 0x19(%r13)
movb 0x78(%r13), %bpl
jmp 0x82c31
movq 0x48(%r13), %rax
cmpq 0x40(%r13), %rax
jb 0x82c20
movq 0x28(%r13), %rdi
leaq 0x79(%r13), %rsi
movl $0x2000, %edx           # imm = 0x2000
callq 0x75fcd
cltq
movq %rax, 0x40(%r13)
testl %eax, %eax
je 0x82c4b
xorl %eax, %eax
leaq 0x1(%rax), %rcx
movq %rcx, 0x48(%r13)
movb 0x79(%r13,%rax), %bpl
movb %bpl, 0x78(%r13)
movq (%rbx), %r13
leaq 0x1(%r13), %rax
movq %rax, (%rbx)
cmpb $0xa, %bpl
je 0x82b9a
movq (%r12), %rax
jmp 0x82bcb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x82bb1
callq 0x1e517
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/sequence_buffer_gb.c
// Function: get_description
static inline int get_description(GtSequenceBuffer *sb,
                                  GtUword *currentfileread)
{
  int currentchar;
  currentchar = inlinebuf_getchar(sb, sb->pvt->inputstream);
  if (currentchar == EOF)
      return EOF;
  (*currentfileread)++;
  while (currentchar != NEWLINESYMBOL) {
    if (sb->pvt->descptr)
      gt_desc_buffer_append_char(sb->pvt->descptr, currentchar);
    currentchar = inlinebuf_getchar(sb, sb->pvt->inputstream);
    if (currentchar == EOF)
      return EOF;
    (*currentfileread)++;
  }
  inlinebuf_ungetchar(sb);
  (*currentfileread)--;
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
cmpb $0x1, 0x19(%r15)
jne 0x82c7b
movb $0x0, 0x19(%r15)
movb 0x78(%r15), %al
jmp 0x82cb4
movq 0x48(%r15), %rax
cmpq 0x40(%r15), %rax
jb 0x82ca3
movq 0x28(%r15), %rdi
leaq 0x79(%r15), %rsi
movl $0x2000, %edx           # imm = 0x2000
callq 0x75fcd
cltq
movq %rax, 0x40(%r15)
testl %eax, %eax
je 0x82cf6
xorl %eax, %eax
leaq 0x1(%rax), %rcx
movq %rcx, 0x48(%r15)
movb 0x79(%r15,%rax), %al
movb %al, 0x78(%r15)
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
cmpb $0xa, %al
je 0x82cdd
movq 0x8(%r14), %r15
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x82c69
movsbl %al, %esi
callq 0xa3c20
movq 0x8(%r14), %r15
jmp 0x82c69
movq 0x8(%r14), %rax
cmpb $0x1, 0x19(%rax)
je 0x82cfd
movb $0x1, 0x19(%rax)
movq %rcx, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x82cf0
callq 0x1e54e
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/string_distri.c
// Function: gt_string_distri_add
void gt_string_distri_add(GtStringDistri *sd, const char *key)
{
  GtUword *valueptr;
  gt_assert(sd && key);
  valueptr = cstr_ul_gt_hashmap_get(sd->hashdist, key);
  if (!valueptr) {
    cstr_ul_gt_hashmap_add(sd->hashdist, gt_cstr_dup(key), 1);
  }
  else
    (*valueptr)++;
  sd->num_of_occurrences++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0x82e11
movq %rsi, %r14
testq %rsi, %rsi
je 0x82e11
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x10(%rsp), %rsi
movq %r14, (%rsi)
callq 0x77dfe
testq %rax, %rax
je 0x82dca
incq 0x8(%rax)
jmp 0x82e03
movq (%rbx), %r15
movq %r14, %rdi
callq 0x728c0
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq $0x1, 0x8(%rsi)
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x780fe
testl %eax, %eax
jne 0x82e03
movq 0x8(%rsp), %rax
movq $0x1, 0x8(%rax)
incq 0x8(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x1e5f3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/string_distri.c
// Function: gt_string_distri_sub
void gt_string_distri_sub(GtStringDistri *sd, const char *key)
{
  GtUword *valueptr;
  gt_assert(sd && key && gt_string_distri_get(sd, key) &&
            sd->num_of_occurrences);
  valueptr = cstr_ul_gt_hashmap_get(sd->hashdist, key);
  (*valueptr)--;
  if (!(*valueptr))
    cstr_ul_gt_hashmap_remove(sd->hashdist, key);
  sd->num_of_occurrences--;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x82e83
movq %rsi, %r14
testq %rsi, %rsi
je 0x82e83
movq %rdi, %rbx
movq (%rdi), %rdi
movq %rsp, %rsi
movq %r14, (%rsi)
callq 0x77dfe
testq %rax, %rax
je 0x82e83
cmpq $0x0, 0x8(%rax)
je 0x82e83
cmpq $0x0, 0x8(%rbx)
je 0x82e83
movq (%rbx), %rdi
movq %rsp, %rsi
movq %r14, (%rsi)
callq 0x77dfe
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
decq (%rcx)
jne 0x82e77
movq (%rbx), %rdi
movq %rsp, %rsi
movq %r14, (%rsi)
callq 0x78166
decq 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1e62a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/string_distri.c
// Function: gt_string_distri_get
GtUword gt_string_distri_get(const GtStringDistri *sd, const char *key)
{
  GtUword *valueptr;
  gt_assert(sd && key);
  if ((valueptr = cstr_ul_gt_hashmap_get(sd->hashdist, key)))
    return *valueptr;
  else
    return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x82eb3
testq %rsi, %rsi
je 0x82eb3
movq (%rdi), %rdi
movq %rsp, %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x77dfe
testq %rax, %rax
je 0x82eaf
movq 0x8(%rax), %rax
jmp 0x82eb1
xorl %eax, %eax
popq %rcx
retq
callq 0x1e661
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/string_distri.c
// Function: gt_string_distri_get_prob
double gt_string_distri_get_prob(const GtStringDistri *sd, const char *key)
{
  GtUword occ;
  gt_assert(sd && key);
  if ((occ = gt_string_distri_get(sd, key)))
    return (double) occ / sd->num_of_occurrences;
  return 0.0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x82f3b
testq %rsi, %rsi
je 0x82f3b
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x77dfe
xorpd %xmm0, %xmm0
testq %rax, %rax
je 0x82f35
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x82f35
movq %rax, %xmm1
movq 0x5e584(%rip), %xmm2    # 0xe1480
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x5e588(%rip), %xmm3    # 0xe1490
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq 0x8(%rbx), %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
addq $0x10, %rsp
popq %rbx
retq
callq 0x1e698
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/string_distri.c
// Function: gt_string_distri_foreach
void gt_string_distri_foreach(const GtStringDistri *sd,
                              GtStringDistriIterFunc func, void *data)
{
  StringDistriForeachInfo info;
  GT_UNUSED int rval;
  gt_assert(sd);
  if (sd->hashdist) {
    info.func = func;
    info.data = data;
    info.num_of_occurrences = sd->num_of_occurrences;
    rval = cstr_ul_gt_hashmap_foreach_in_default_order(
      sd->hashdist, string_distri_foreach_iterfunc, &info, NULL);
    gt_assert(!rval); /* string_distri_foreach_iterfunc() is sane */
  }
}

// Assembly:
subq $0x38, %rsp
testq %rdi, %rdi
je 0x82f9a
movq %rdi, %rax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x82f95
leaq 0x8(%rsp), %rcx
movq %rsi, (%rcx)
movq %rdx, 0x8(%rcx)
movq 0x8(%rax), %rax
movq %rax, 0x10(%rcx)
leaq 0x20(%rsp), %rdx
movq %rcx, (%rdx)
leaq 0x2d(%rip), %rax        # 0x82fa4
movq %rax, 0x8(%rdx)
movq $0x0, 0x10(%rdx)
leaq 0xe2(%rip), %rsi        # 0x8306c
xorl %ecx, %ecx
callq 0x78316
testl %eax, %eax
jne 0x82f9f
addq $0x38, %rsp
retq
callq 0x1e706
callq 0x1e6cf
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/string_distri.c
// Function: string_distri_foreach_iterfunc
static enum iterator_op
string_distri_foreach_iterfunc(char *key, GtUword occurrences, void *data,
                               GT_UNUSED GtError *err)
{
  StringDistriForeachInfo *info;
  gt_error_check(err);
  gt_assert(key && data);
  info = (StringDistriForeachInfo*) data;
  info->func(key, occurrences, (double) occurrences / info->num_of_occurrences,
             info->data);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rcx, %rcx
je 0x82fc3
movq %rcx, %rdi
callq 0x34fea
testb %al, %al
jne 0x8302c
testq %r15, %r15
je 0x83027
testq %rbx, %rbx
je 0x83027
movq %r14, %xmm1
movq 0x5e4a6(%rip), %xmm2    # 0xe1480
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x5e4aa(%rip), %xmm3    # 0xe1490
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq 0x10(%rbx), %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
movq 0x8(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq *(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1e774
callq 0x1e73d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/xbsd.c
// Function: gt_xflock_with_op
static void gt_xflock_with_op(int fd, short l_type)
{
  struct flock f;
  if (!getenv("GT_NO_FLOCK")) {
    memset(&f, 0, sizeof (f));
    f.l_type = l_type;
    if (fcntl(fd, F_SETLKW, &f)) {
      perror("cannot flock");
      exit(EXIT_FAILURE);
    }
  }
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movl %edi, %ebx
leaq 0x70848(%rip), %rdi     # 0xf38e1
callq 0xb7c0
testq %rax, %rax
jne 0x830c5
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movw %bp, (%rdx)
movl %ebx, %edi
movl $0x7, %esi
xorl %eax, %eax
callq 0xba30
testl %eax, %eax
jne 0x830cc
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
callq 0x1e7ab
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/xbzlib.c
// Function: gt_xbzwrite
void gt_xbzwrite(BZFILE *file, void *buf, unsigned len)
{
  gt_assert(buf);
  if (BZ2_bzwrite(file, buf, len) != len) {
    fprintf(stderr, "cannot write it compressed file\n");
    exit(EXIT_FAILURE);
  }
}

// Assembly:
pushq %rbx
testq %rsi, %rsi
je 0x831a8
movl %edx, %ebx
callq 0x9968c
cmpl %ebx, %eax
jne 0x831ad
popq %rbx
retq
callq 0x1e890
callq 0x1e86b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/xposix.c
// Function: gt_xwrite
void gt_xwrite(int d, const void *buf, size_t nbytes)
{
  size_t pos = 0;
  ssize_t rval;
  int error = 0;
  while (nbytes > pos) {
    rval = write(d, (char*) buf + pos, nbytes - pos);
    switch (rval) {
      case -1:
        if (errno == EINTR || errno == EAGAIN)
          continue;
        error = 1;
        break;
      case 0:
        errno = EPIPE;
        error = 1;
        break;
      default:
        pos += rval;
    }
    if (error)
      break;
  }
  if (error) {
    perror("cannot write to file descriptor");
    exit(EXIT_FAILURE);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x83392
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
xorl %r13d, %r13d
leaq (%r14,%r13), %r15
movq %rbx, %r12
subq %r13, %r12
movl %ebp, %edi
movq %r15, %rsi
movq %r12, %rdx
callq 0xb200
cmpq $-0x1, %rax
jne 0x83385
callq 0xb060
movl (%rax), %eax
cmpl $0x4, %eax
je 0x8335f
cmpl $0xb, %eax
je 0x8335f
jmp 0x833ac
testq %rax, %rax
je 0x833a1
addq %rax, %r13
cmpq %rbx, %r13
jb 0x83355
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xb060
movl $0x20, (%rax)
callq 0x1eb1a
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/xzlib.c
// Function: gt_xgzwrite
void gt_xgzwrite(gzFile file, void *buf, unsigned len)
{
  int errnum;
  gt_assert(buf);
  if (gzwrite(file, buf, len) != len) {
    fprintf(stderr, "cannot write to compressed file: %s\n",
            gzerror(file, &errnum));
    exit(EXIT_FAILURE);
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x8348e
movl %edx, %ebp
movq %rdi, %rbx
callq 0x9aaac
cmpl %ebp, %eax
jne 0x83493
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1ec1b
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x1ebef
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/xzlib.c
// Function: gt_xgzclose
void gt_xgzclose(gzFile file)
{
  const char *msg;
  int errnum;
  if (gzclose(file)) {
    msg = gzerror(file, &errnum);
    if (errnum == Z_ERRNO) { /* error in file system */
      perror("cannot close compressed file");
      exit(EXIT_FAILURE);
    }
    else { /* error in zlib */
      fprintf(stderr, "cannot close compressed file: %s\n", msg);
      exit(EXIT_FAILURE);
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x99890
testl %eax, %eax
jne 0x834ca
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x99fd1
cmpl $-0x1, (%r14)
jne 0x834e5
callq 0x1ec9b
movq %rax, %rdi
callq 0x1ec77
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/add_ids_stream.c
// Function: gt_add_ids_stream_class
const GtNodeStreamClass* gt_add_ids_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtAddIDsStream),
                                   add_ids_stream_free,
                                   add_ids_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x72367
cmpq $0x0, 0xcf722(%rip)     # 0x152c20
jne 0x8351f
leaq 0x26(%rip), %rsi        # 0x8352d
leaq 0x49(%rip), %rdx        # 0x83557
movl $0x28, %edi
callq 0x48c48
movq %rax, 0xcf701(%rip)     # 0x152c20
callq 0x7237d
movq 0xcf6f5(%rip), %rax     # 0x152c20
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/add_ids_stream.c
// Function: add_ids_stream_next
static int add_ids_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                               GtError *err)
{
  GtAddIDsStream *ais;
  int had_err;
  gt_error_check(err);
  ais = gt_add_ids_stream_cast(ns);

  /* we still have nodes in the buffer */
  if (gt_add_ids_visitor_node_buffer_size(ais->add_ids_visitor)) {
    /* return one of them */
    *gn = gt_add_ids_visitor_get_node(ais->add_ids_visitor);
    return 0;
  }

  /* handle disabled stream */
  if (!ais->add_ids)
    return gt_node_stream_next(ais->in_stream, gn, err);

  /* no nodes in the buffer -> get new nodes */
  for (;;) {
    had_err = gt_node_stream_next(ais->in_stream, gn, err);
    /* end of the stream */
    if (!*gn)
      break;
    if (had_err)
      break;
    else {
      had_err = gt_genome_node_accept(*gn, ais->add_ids_visitor, err);
      if (had_err) {
        /* we own the node -> delete it */
        gt_genome_node_delete(*gn);
        *gn = NULL;
        break;
      }
      else {
        /* the node is now in the buffer -> reset to avoid double free */
        *gn = NULL;
      }
      if (gt_add_ids_visitor_node_buffer_size(ais->add_ids_visitor)) {
        *gn = gt_add_ids_visitor_get_node(ais->add_ids_visitor);
        return 0;
      }
    }
  }

  if (!had_err) {
    gt_add_ids_visitor_finalize(ais->add_ids_visitor);
    if (gt_add_ids_visitor_node_buffer_size(ais->add_ids_visitor)) {
      *gn = gt_add_ids_visitor_get_node(ais->add_ids_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 0x8357c
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x83662
callq 0x834f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x48f0b
movq %rax, %r15
movq 0x18(%rax), %rdi
callq 0x83cd5
testq %rax, %rax
je 0x835b8
movq 0x18(%r15), %rdi
callq 0x83cf3
movq %rax, (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x1, 0x20(%r15)
jne 0x83603
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x48d7c
movl %eax, %ebp
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8361c
testl %ebp, %ebp
jne 0x8361c
movq 0x18(%r15), %rsi
movq %r14, %rdx
callq 0x41698
testl %eax, %eax
jne 0x8364c
movq $0x0, (%rbx)
movq 0x18(%r15), %rdi
callq 0x83cd5
testq %rax, %rax
je 0x835bf
jmp 0x8359d
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x48d7c
testl %ebp, %ebp
jne 0x835ab
movq 0x18(%r15), %rdi
callq 0x83d11
movq 0x18(%r15), %rdi
callq 0x83cd5
testq %rax, %rax
jne 0x8359d
xorl %ebp, %ebp
cmpq $0x0, (%rbx)
je 0x835ab
callq 0x1ece7
movl %eax, %ebp
movq (%rbx), %rdi
callq 0x4210c
movq $0x0, (%rbx)
jmp 0x835ab
callq 0x1ecb0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/add_ids_stream.c
// Function: gt_add_ids_stream_new
GtNodeStream* gt_add_ids_stream_new(GtNodeStream *in_stream)
{
  GtAddIDsStream *add_ids_stream;
  GtNodeStream *ns;
  gt_assert(in_stream);
  ns = gt_node_stream_create(gt_add_ids_stream_class(), false);
  add_ids_stream = gt_add_ids_stream_cast(ns);
  add_ids_stream->in_stream = gt_node_stream_ref(in_stream);
  add_ids_stream->add_ids_visitor =
    gt_add_ids_visitor_new(gt_node_stream_is_sorted(in_stream));
  add_ids_stream->add_ids = true;
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x836c7
movq %rdi, %rbx
callq 0x834f0
movq %rax, %rdi
xorl %esi, %esi
callq 0x48c80
movq %rax, %r14
callq 0x834f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x48f0b
movq %rax, %r15
movq %rbx, %rdi
callq 0x48cec
movq %rax, 0x10(%r15)
movq %rbx, %rdi
callq 0x48ef8
movzbl %al, %edi
callq 0x83c06
movq %rax, 0x18(%r15)
movb $0x1, 0x20(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1ed1e