LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/merge_stream.c
// Function: merge_stream_free
static void merge_stream_free(GtNodeStream *ns)
{
  GtMergeStream *ms = gt_merge_stream_cast(ns);
  GtUword i;
  for (i = 0; i < gt_array_size(ms->node_streams); i++) {
    if (ms->items[i].gn)
      gt_genome_node_delete(ms->items[i].gn);
    gt_node_stream_delete(*(GtNodeStream**) gt_array_get(ms->node_streams, i));
  }
  gt_array_delete(ms->node_streams);
  gt_free(ms->items);
  gt_priority_queue_delete(ms->pq);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x100a94
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102c81
movq %rax, %rbx
xorl %r15d, %r15d
xorl %r14d, %r14d
movq 0x10(%rbx), %rdi
callq 0x586a4
cmpq %rax, %r14
jae 0x100b2d
movq 0x28(%rbx), %rax
movq (%rax,%r15), %rdi
testq %rdi, %rdi
je 0x100b10
callq 0xde013
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x581aa
movq (%rax), %rdi
callq 0x10297b
incq %r14
addq $0x10, %r15
jmp 0x100af0
movq 0x10(%rbx), %rdi
callq 0x58eb9
movq 0x28(%rbx), %rdi
leaq 0x22c1f4(%rip), %rsi    # 0x32cd35
movl $0xbb, %edx
callq 0x936f9
movq 0x30(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x105708
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/merge_stream.c
// Function: gt_merge_stream_new
GtNodeStream* gt_merge_stream_new(const GtArray *node_streams)
{
  GtNodeStream *in_stream,
               *ns = gt_node_stream_create(gt_merge_stream_class(), true);
  GtMergeStream *ms = gt_merge_stream_cast(ns);
  GtUword i;
#ifndef NDEBUG
  gt_assert(gt_array_size(node_streams)); /* at least one input stream given */
  /* each input stream is sorted */
  for (i = 0; i < gt_array_size(node_streams); i++) {
    gt_assert(gt_node_stream_is_sorted(*(GtNodeStream**)
                                       gt_array_get(node_streams, i)));
  }
#endif
  ms->items = gt_calloc(gt_array_size(node_streams),
                        sizeof (GtMergeStreamItem));
  ms->node_streams = gt_array_new(sizeof (GtNodeStream*));
  for (i = 0; i < gt_array_size(node_streams); i++) {
    in_stream = gt_node_stream_ref(*(GtNodeStream**)
                                   gt_array_get(node_streams, i));
    gt_array_add(ms->node_streams, in_stream);
  }
  ms->pq = gt_priority_queue_new(gt_merge_stream_item_compare,
                                 gt_array_size(node_streams));
  ms->filled = false;
  ms->first_node = ms->second_node = NULL;
  return ns;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x100a94
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x10289f
movq %rax, %rbx
callq 0x100a94
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102c81
movq %rax, %r15
movq %r14, %rdi
callq 0x586a4
testq %rax, %rax
je 0x100ea8
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x586a4
movq %r14, %rdi
cmpq %rax, %r12
jae 0x100e00
movq %r12, %rsi
callq 0x581aa
movq (%rax), %rdi
callq 0x102c3d
incq %r12
testb %al, %al
jne 0x100da1
movq 0x337199(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e423a(%rip), %rsi    # 0x2e5013
leaq 0x22bf71(%rip), %rdx    # 0x32cd51
leaq 0x22bf3a(%rip), %rcx    # 0x32cd21
leaq 0x22bf47(%rip), %r8     # 0x32cd35
movl $0xd7, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
callq 0x586a4
leaq 0x22bf29(%rip), %rdx    # 0x32cd35
pushq $0x10
popq %rsi
movq %rax, %rdi
movl $0xdb, %ecx
callq 0x9334a
movq %rax, 0x28(%r15)
pushq $0x8
popq %r12
movq %r12, %rdi
callq 0x5809c
movq %rax, 0x10(%r15)
xorl %r13d, %r13d
movq %rsp, %rbp
movq %r14, %rdi
callq 0x586a4
cmpq %rax, %r13
jae 0x100e6e
movq %r14, %rdi
movq %r13, %rsi
callq 0x581aa
movq (%rax), %rdi
callq 0x102934
movq %rax, (%rsp)
movq 0x10(%r15), %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x5851d
incq %r13
jmp 0x100e36
movq %r14, %rdi
callq 0x586a4
leaq 0x5c(%rip), %rdi        # 0x100ed9
movq %rax, %rsi
callq 0x10537c
movq %rax, 0x30(%r15)
movb $0x0, 0x38(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3370b9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e415a(%rip), %rsi    # 0x2e5013
leaq 0x22be45(%rip), %rdx    # 0x32cd05
leaq 0x22be5a(%rip), %rcx    # 0x32cd21
leaq 0x22be67(%rip), %r8     # 0x32cd35
movl $0xd3, %r9d
jmp 0x100df4
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/merge_stream.c
// Function: gt_merge_stream_item_compare
static int gt_merge_stream_item_compare(const void *a, const void *b)
{
  GtMergeStreamItem *item1, *item2;
  gt_assert(a && b);
  item1 = (GtMergeStreamItem*) a;
  item2 = (GtMergeStreamItem*) b;
  gt_assert(item1->gn && item2->gn);
  return gt_genome_node_compare(&item1->gn, &item2->gn);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x100f20
testq %rsi, %rsi
je 0x100f20
cmpq $0x0, (%rdi)
je 0x100ef6
cmpq $0x0, (%rsi)
je 0x100ef6
popq %rax
jmp 0xdd44c
movq 0x33706b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e410c(%rip), %rsi    # 0x2e5013
leaq 0x22bf57(%rip), %rdx    # 0x32ce65
leaq 0x22bf33(%rip), %rcx    # 0x32ce48
leaq 0x22be19(%rip), %r8     # 0x32cd35
pushq $0x37
jmp 0x100f48
movq 0x337041(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e40e2(%rip), %rsi    # 0x2e5013
leaq 0x1fd0c6(%rip), %rdx    # 0x2fdffe
leaq 0x22bf09(%rip), %rcx    # 0x32ce48
leaq 0x22bdef(%rip), %r8     # 0x32cd35
pushq $0x34
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/multieoplist.c
// Function: gt_multieoplist_new_with_size
GtMultieoplist *gt_multieoplist_new_with_size(GtUword size)
{
  GtMultieoplist *multieops;
  multieops = gt_malloc(sizeof (GtMultieoplist));
  multieops->refcount = 0;
  GT_INITARRAY(&multieops->meoplist, Eop);
  multieops->meoplist.spaceEop =
    gt_calloc((size_t) size, sizeof (*(multieops->meoplist.spaceEop)));
  multieops->meoplist.allocatedEop = size;
  return multieops;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x22b8e2(%rip), %r14    # 0x32cf58
pushq $0x20
popq %rdi
pushq $0x33
popq %rdx
movq %r14, %rsi
callq 0x93160
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
pushq $0x1
popq %rsi
pushq $0x37
popq %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9334a
movq %rax, 0x8(%r15)
movq %rbx, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/multieoplist.c
// Function: gt_multieoplist_clone
GtMultieoplist *gt_multieoplist_clone(GtMultieoplist *copy,
                                      const GtMultieoplist *source)
{
  GtUword i;
  gt_assert(source != NULL);
  if (copy == NULL) {
    copy = gt_multieoplist_new();
  }
  if (copy->meoplist.allocatedEop < source->meoplist.nextfreeEop) {
    copy->meoplist.spaceEop = gt_realloc(copy->meoplist.spaceEop,
                                         (size_t) source->meoplist.nextfreeEop);
    copy->meoplist.allocatedEop = source->meoplist.nextfreeEop;
  }
  copy->refcount = 0;
  copy->meoplist.nextfreeEop = source->meoplist.nextfreeEop;
  for (i = 0; i < copy->meoplist.nextfreeEop; i++) {
    copy->meoplist.spaceEop[i] = source->meoplist.spaceEop[i];
  }
  return copy;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x101729
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x1016cf
callq 0x101648
movq %rax, %r14
movq 0x18(%rbx), %rsi
cmpq %rsi, 0x10(%r14)
jae 0x1016f8
movq 0x8(%r14), %rdi
leaq 0x22b874(%rip), %rdx    # 0x32cf58
pushq $0x46
popq %rcx
callq 0x93472
movq %rax, 0x8(%r14)
movq 0x18(%rbx), %rsi
movq %rsi, 0x10(%r14)
andq $0x0, (%r14)
movq %rsi, 0x18(%r14)
xorl %eax, %eax
cmpq %rsi, %rax
jae 0x10171e
movq 0x8(%rbx), %rcx
movb (%rcx,%rax), %cl
movq 0x8(%r14), %rdx
movb %cl, (%rdx,%rax)
incq %rax
movq 0x18(%r14), %rsi
jmp 0x101702
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x336838(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e38d9(%rip), %rsi    # 0x2e5013
leaq 0x22b833(%rip), %rdx    # 0x32cf74
leaq 0x22b83b(%rip), %rcx    # 0x32cf83
leaq 0x22b809(%rip), %r8     # 0x32cf58
pushq $0x40
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/multieoplist.c
// Function: gt_multieoplist_delete
void gt_multieoplist_delete(GtMultieoplist *multieops)
{
  if (multieops != NULL) {
    if (multieops->refcount != 0) {
      multieops->refcount--;
    }
    else {
      GT_FREEARRAY(&multieops->meoplist, Eop);
      gt_free(multieops);
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x101780
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x101788
decq %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1017b0
leaq 0x8(%rbx), %r14
leaq 0x22b7bc(%rip), %rsi    # 0x32cf58
pushq $0x5e
popq %rdx
callq 0x936f9
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq 0x22b7a1(%rip), %rsi    # 0x32cf58
pushq $0x5f
popq %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/multieoplist.c
// Function: gt_multieoplist_remove_last
void gt_multieoplist_remove_last(GtMultieoplist *multieops)
{
  Eop *space;
  GtUword current;
  gt_assert(multieops != NULL && multieops->meoplist.nextfreeEop > 0);
  space = multieops->meoplist.spaceEop;
  current = multieops->meoplist.nextfreeEop - 1;
  if ((space[current] & GT_MEOPS_STEPS_MASK) == (Eop) 1) {
    multieops->meoplist.nextfreeEop--;
  }
  else {
    space[current]--;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1019c3
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x1019c3
movq 0x8(%rdi), %rcx
movb -0x1(%rcx,%rax), %dl
movl %edx, %esi
andb $0x3f, %sil
cmpb $0x1, %sil
jne 0x1019bc
decq %rax
movq %rax, 0x18(%rdi)
retq
decb %dl
movb %dl, -0x1(%rcx,%rax)
retq
pushq %rax
movq 0x33659d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e363e(%rip), %rsi    # 0x2e5013
leaq 0x22b5e3(%rip), %rdx    # 0x32cfbf
leaq 0x22b615(%rip), %rcx    # 0x32cff8
leaq 0x22b56e(%rip), %r8     # 0x32cf58
movl $0xc7, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/multieoplist.c
// Function: gt_multieoplist_get_repdel_length
GtUword gt_multieoplist_get_repdel_length(const GtMultieoplist *multieops)
{
  GtUword len = 0, i;
  Eop *space;
  gt_assert(multieops);
  space = multieops->meoplist.spaceEop;
  for (i = 0; i < multieops->meoplist.nextfreeEop ; i++) {
    switch (space[i] >> GT_MEOPS_STEPS_BITS) {
      case GT_MEOPS_INS:
        break;
      default:
        len += space[i] & GT_MEOPS_STEPS_MASK;
    }
  }
  return len;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x101a38
movq 0x8(%rdi), %rcx
movq 0x18(%rdi), %rdx
xorl %esi, %esi
xorl %eax, %eax
cmpq %rsi, %rdx
je 0x101a36
movzbl (%rcx,%rsi), %edi
movl %edi, %r8d
notl %r8d
andl $0xc0, %r8d
andl $0x3f, %edi
testl %r8d, %r8d
cmovel %r8d, %edi
addq %rdi, %rax
incq %rsi
jmp 0x101a0e
popq %rcx
retq
movq 0x336529(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e35ca(%rip), %rsi    # 0x2e5013
leaq 0x22b5c4(%rip), %rdx    # 0x32d014
leaq 0x22b5c7(%rip), %rcx    # 0x32d01e
leaq 0x22b4fa(%rip), %r8     # 0x32cf58
movl $0xd6, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/multieoplist.c
// Function: gt_multieoplist_get_repins_length
GtUword gt_multieoplist_get_repins_length(const GtMultieoplist *multieops)
{
  GtUword len = 0, i;
  Eop *space;
  gt_assert(multieops);
  space = multieops->meoplist.spaceEop;
  for (i = 0; i < multieops->meoplist.nextfreeEop ; i++) {
    switch (space[i] >> GT_MEOPS_STEPS_BITS) {
      case GT_MEOPS_DEL:
        break;
      default:
        len += space[i] & GT_MEOPS_STEPS_MASK;
    }
  }
  return len;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x101aae
movq 0x8(%rdi), %rcx
movq 0x18(%rdi), %rdx
xorl %esi, %esi
xorl %edi, %edi
xorl %eax, %eax
cmpq %rdi, %rdx
je 0x101aac
movzbl (%rcx,%rdi), %r8d
movl %r8d, %r9d
andl $-0x40, %r9d
andl $0x3f, %r8d
cmpl $0x80, %r9d
cmovel %esi, %r8d
addq %r8, %rax
incq %rdi
jmp 0x101a84
popq %rcx
retq
movq 0x3364b3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e3554(%rip), %rsi    # 0x2e5013
leaq 0x22b54e(%rip), %rdx    # 0x32d014
leaq 0x22b573(%rip), %rcx    # 0x32d040
leaq 0x22b484(%rip), %r8     # 0x32cf58
movl $0xe7, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/multieoplist.c
// Function: gt_multieoplist_get_length
GtUword gt_multieoplist_get_length(const GtMultieoplist *multieops)
{
  GtUword len = 0, i;
  Eop *space;
  gt_assert(multieops);
  space = multieops->meoplist.spaceEop;
  for (i = 0; i < multieops->meoplist.nextfreeEop ; i++) {
    len += space[i] & GT_MEOPS_STEPS_MASK;
  }
  return len;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x101b0e
movq 0x8(%rdi), %rcx
movq 0x18(%rdi), %rdx
xorl %esi, %esi
xorl %eax, %eax
cmpq %rsi, %rdx
je 0x101b0c
movzbl (%rcx,%rsi), %edi
andl $0x3f, %edi
addq %rdi, %rax
incq %rsi
jmp 0x101af8
popq %rcx
retq
movq 0x336453(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e34f4(%rip), %rsi    # 0x2e5013
leaq 0x22b4ee(%rip), %rdx    # 0x32d014
leaq 0x22b535(%rip), %rcx    # 0x32d062
leaq 0x22b424(%rip), %r8     # 0x32cf58
movl $0xf8, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/multieoplist.c
// Function: gt_multieoplist_get_entry
GtMultieop gt_multieoplist_get_entry(const GtMultieoplist *multieops,
                                     GtUword index)
{
  GtMultieop eop = { (AlignmentEoptype) 0, (GtUword) 0};
  Eop *space;
  gt_assert(multieops);
  space = multieops->meoplist.spaceEop;
  gt_assert(multieops->meoplist.nextfreeEop != 0);
  gt_assert(multieops->meoplist.nextfreeEop > index);
  eop.steps = (GtUword) space[index] & (GtUword) GT_MEOPS_STEPS_MASK;
  switch (space[index] >> GT_MEOPS_STEPS_BITS) {
    case GT_MEOPS_MATCH:
      eop.type = Match;
      break;
    case GT_MEOPS_MIS:
      eop.type = Mismatch;
      break;
    case GT_MEOPS_DEL:
      eop.type = Deletion;
      break;
    case GT_MEOPS_INS:
      eop.type = Insertion;
  }
  return eop;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x101b7b
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x101ba9
cmpq %rsi, %rax
jbe 0x101bd7
movq 0x8(%rdi), %rax
movzbl (%rax,%rsi), %edx
movl %edx, %eax
shrl $0x6, %eax
leaq 0x22bb79(%rip), %rcx    # 0x32d6ec
movl (%rcx,%rax,4), %eax
andl $0x3f, %edx
popq %rcx
retq
movq 0x3363e6(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e3487(%rip), %rsi    # 0x2e5013
leaq 0x22b481(%rip), %rdx    # 0x32d014
leaq 0x22b4e3(%rip), %rcx    # 0x32d07d
leaq 0x22b3b7(%rip), %r8     # 0x32cf58
movl $0x10a, %r9d            # imm = 0x10A
jmp 0x101c03
movq 0x3363b8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e3459(%rip), %rsi    # 0x2e5013
leaq 0x22b4d6(%rip), %rdx    # 0x32d097
leaq 0x22b4b5(%rip), %rcx    # 0x32d07d
leaq 0x22b389(%rip), %r8     # 0x32cf58
movl $0x10c, %r9d            # imm = 0x10C
jmp 0x101c03
movq 0x33638a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e342b(%rip), %rsi    # 0x2e5013
leaq 0x22b4cd(%rip), %rdx    # 0x32d0bc
leaq 0x22b487(%rip), %rcx    # 0x32d07d
leaq 0x22b35b(%rip), %r8     # 0x32cf58
movl $0x10d, %r9d            # imm = 0x10D
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/multieoplist.c
// Function: gt_multieoplist_combine
void gt_multieoplist_combine(GtMultieoplist *multieops,
                             const GtMultieoplist *multieops_to_add,
                             bool forward) {
  GtUword idx,
          nelems = 0;
  GtMultieop mop;
  gt_assert(multieops_to_add != NULL && multieops != NULL);

  nelems = multieops_to_add->meoplist.nextfreeEop;
  for (idx = 0; idx < nelems; ++idx) {
    mop = gt_multieoplist_get_entry(multieops_to_add,
                                    forward ?
                                    idx :
                                    nelems - idx - 1);
    gt_multieoplist_add_eops(multieops, mop.type, mop.steps);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x101dd7
movq %rsi, %r14
testq %rsi, %rsi
je 0x101dd7
movl %edx, %ebx
movq %rdi, %r15
movq 0x18(%r14), %r12
decq %r12
xorl %r13d, %r13d
cmpq $-0x1, %r12
je 0x101dcd
testb %bl, %bl
movq %r12, %rsi
cmovneq %r13, %rsi
movq %r14, %rdi
callq 0x101b4b
movq %r15, %rdi
movl %eax, %esi
callq 0x1017d1
incq %r13
decq %r12
jmp 0x101da4
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x33618a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e322b(%rip), %rsi    # 0x2e5013
leaq 0x22b33f(%rip), %rdx    # 0x32d12e
leaq 0x22b366(%rip), %rcx    # 0x32d15c
leaq 0x22b15b(%rip), %r8     # 0x32cf58
movl $0x167, %r9d            # imm = 0x167
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/multieoplist.c
// Function: gt_multieoplist_io
GtMultieoplist *gt_multieoplist_io(GtMultieoplist *multieops, FILE *fp,
                                   GtError *err)
{
  if (multieops == NULL) {
    multieops = gt_calloc((size_t) 1, sizeof (GtMultieoplist));
    GT_INITARRAY(&multieops->meoplist, Eop);
    multieops = gt_multieoplist_io_fp(multieops, fp, gt_io_error_fread, err);
  }
  else
    multieops = gt_multieoplist_io_fp(multieops, fp, gt_io_error_fwrite, err);
  return multieops;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0x101e27
leaq -0xdf75(%rip), %rdx     # 0xf3eb0
jmp 0x101e54
leaq 0x22b12a(%rip), %rdx    # 0x32cf58
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
movl $0x193, %ecx            # imm = 0x193
callq 0x9334a
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
andq $0x0, 0x18(%rax)
leaq -0xdf64(%rip), %rdx     # 0xf3eed
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x101e63
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/multieoplist.c
// Function: gt_multieoplist_io_fp
static GtMultieoplist *gt_multieoplist_io_fp(GtMultieoplist *multieops,
                                             FILE *fp, GtIOFunc io_func,
                                             GtError *err)
{
  int had_err = 0;
  had_err = io_func(&multieops->meoplist.nextfreeEop,
                    sizeof (multieops->meoplist.nextfreeEop),
                    (size_t) 1, fp, err);
  if (!had_err) {
    gt_assert(multieops->meoplist.nextfreeEop != 0);
    if (multieops->meoplist.spaceEop == NULL) {
      multieops->meoplist.allocatedEop = multieops->meoplist.nextfreeEop;
      multieops->meoplist.spaceEop =
        gt_malloc((size_t) multieops->meoplist.nextfreeEop *
                  sizeof (*(multieops->meoplist.spaceEop)));
    }
  }
  had_err = io_func(multieops->meoplist.spaceEop,
                    sizeof (*(multieops->meoplist.spaceEop)),
                    (size_t) multieops->meoplist.nextfreeEop,
                    fp, err);
  if (had_err) {
    gt_multieoplist_delete(multieops);
    multieops = NULL;
  }
  return(multieops);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x18(%rdi), %r13
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %r13, %rdi
movq %r12, %rcx
movq %r15, %r8
callq *%r14
testl %eax, %eax
je 0x101e98
movq 0x8(%rbx), %rdi
jmp 0x101ec9
movq (%r13), %rax
testq %rax, %rax
je 0x101ef4
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
jne 0x101ec9
movq %rax, 0x10(%rbx)
leaq 0x22b0a3(%rip), %rsi    # 0x32cf58
movq %rax, %rdi
movl $0x181, %edx            # imm = 0x181
callq 0x93160
movq %rax, %rdi
movq %rax, 0x8(%rbx)
movq (%r13), %rdx
pushq $0x1
popq %rsi
movq %r12, %rcx
movq %r15, %r8
callq *%r14
testl %eax, %eax
je 0x101ee7
movq %rbx, %rdi
callq 0x101766
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x33606d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e310e(%rip), %rsi    # 0x2e5013
leaq 0x22b18b(%rip), %rdx    # 0x32d097
leaq 0x22b7ad(%rip), %rcx    # 0x32d6c0
leaq 0x22b03e(%rip), %r8     # 0x32cf58
movl $0x17c, %r9d            # imm = 0x17C
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/multieoplist.c
// Function: gt_multieoplist_unit_test_2
int gt_multieoplist_unit_test_2(GtError *err)
{
  /* char *u = "attttgatatcgtctctctatgctgtcac", */
       /* *v = "atttngatatcgtctctctatgctgtcac"; */
  GtMultieoplist *meop = gt_multieoplist_new();
  unsigned int i;
  int had_err = 0;

  for (i = 0; i < 4; ++i) {
    gt_multieoplist_add_match(meop);
  }
  gt_multieoplist_add_mismatch(meop);
  for (i = 0; i < 24; ++i) {
    gt_multieoplist_add_match(meop);
  }
  gt_ensure(gt_multieoplist_get_length(meop) == 29);
  gt_log_log("length: " GT_WU, gt_multieoplist_get_length(meop));

  gt_multieoplist_delete(meop);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x4
popq %rbp
callq 0x101648
movq %rax, %rbx
movq %rbx, %rdi
subl $0x1, %ebp
jb 0x101f4d
callq 0x101982
jmp 0x101f3e
callq 0x101977
pushq $0x18
popq %rbp
movq %rbx, %rdi
subl $0x1, %ebp
jb 0x101f64
callq 0x101982
jmp 0x101f55
callq 0x101ae6
xorl %ebp, %ebp
cmpq $0x1d, %rax
je 0x101fa0
leaq 0x1fc47a(%rip), %rsi    # 0x2fe3f2
leaq 0x22b1f5(%rip), %rdx    # 0x32d174
leaq 0x22b215(%rip), %rcx    # 0x32d19b
leaq 0x22afcb(%rip), %r8     # 0x32cf58
movq %r14, %rdi
movl $0x1ab, %r9d            # imm = 0x1AB
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rbp
movq %rbx, %rdi
callq 0x101ae6
leaq 0x24e92d(%rip), %rdi    # 0x3508dc
movq %rax, %rsi
xorl %eax, %eax
callq 0x92a82
movq %rbx, %rdi
callq 0x101766
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/mutate.c
// Function: random_character
static char random_character(GtAlphabet *alphabet, bool upper_case)
{
  /* we do not want to get wildcard characters */
  char random_char = gt_alphabet_decode(alphabet,
                           gt_rand_max(gt_alphabet_num_of_chars(alphabet) - 1));
  if (upper_case)
    return toupper(random_char);
  return tolower(random_char);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x56c8e
leal -0x1(%rax), %edi
callq 0x955fa
movzbl %al, %esi
movq %rbx, %rdi
callq 0x575cc
movl %eax, %ebx
testl %ebp, %ebp
je 0x10281f
callq 0x170c0
jmp 0x102824
callq 0x17100
movsbq %bl, %rcx
movq (%rax), %rax
movb (%rax,%rcx,4), %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/orf_finder_stream.c
// Function: gt_orf_finder_stream_class
const GtNodeStreamClass* gt_orf_finder_stream_class(void)
{
  static const GtNodeStreamClass *gsc;
  gt_class_alloc_lock_enter();
  if (!gsc) {
    gsc = gt_node_stream_class_new(sizeof (GtORFFinderStream),
                                   gt_orf_finder_stream_free,
                                   gt_orf_finder_stream_next);
  }
  gt_class_alloc_lock_leave();
  return gsc;
}

// Assembly:
pushq %rax
callq 0x69e97
cmpq $0x0, 0x33a4b2(%rip)    # 0x43d7a8
jne 0x103315
leaq 0x24(%rip), %rsi        # 0x103323
leaq 0x47(%rip), %rdx        # 0x10334d
pushq $0x20
popq %rdi
callq 0x102838
movq %rax, 0x33a493(%rip)    # 0x43d7a8
callq 0x69ede
movq 0x33a487(%rip), %rax    # 0x43d7a8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/orf_finder_stream.c
// Function: gt_orf_finder_stream_next
static int gt_orf_finder_stream_next(GtNodeStream *gs, GtGenomeNode **gn,
                                    GtError *err)
{
  GtORFFinderStream *ls;
  int had_err;

  gt_error_check(err);
  ls = gt_orf_finder_stream_cast(gs);

  had_err = gt_node_stream_next(ls->in_stream, gn, err);
  if (!had_err && *gn) {
    had_err = gt_genome_node_accept(*gn, (GtNodeVisitor*) ls->lv, err);
  }
  if (had_err) {
    gt_genome_node_delete(*gn);
    *gn = NULL;
  }
  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 0x10336e
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x1033cb
callq 0x1032e8
movq %rax, %rdi
movq %r15, %rsi
callq 0x102c81
movq %rax, %r15
movq 0x10(%rax), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x102a22
testl %eax, %eax
je 0x1033af
movl %eax, %ebp
movq (%rbx), %rdi
callq 0xde013
andq $0x0, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x1033a2
movq 0x18(%r15), %rsi
movq %r14, %rdx
callq 0xdd39c
testl %eax, %eax
jne 0x103394
jmp 0x1033a2
movq 0x334b96(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e1c37(%rip), %rsi    # 0x2e5013
leaq 0x1e1ddc(%rip), %rdx    # 0x2e51bf
leaq 0x22a7fe(%rip), %rcx    # 0x32dbe8
leaq 0x22a811(%rip), %r8     # 0x32dc02
pushq $0x31
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/orf_finder_stream.c
// Function: gt_orf_finder_stream_new
GtNodeStream* gt_orf_finder_stream_new(GtNodeStream *in_stream,
                                       GtRegionMapping *rmap,
                                       GtHashmap *types,
                                       unsigned int min,
                                       unsigned int max,
                                       bool all,
                                       GtError *err)
{
  GtNodeStream *gs;
  GtORFFinderStream *ls;
  gs = gt_node_stream_create(gt_orf_finder_stream_class(), false);
  ls = gt_orf_finder_stream_cast(gs);
  ls->in_stream = gt_node_stream_ref(in_stream);
  ls->lv = (GtORFFinderVisitor*) gt_orf_finder_visitor_new(rmap,types,
                                                           min, max, all, err);
  return gs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movl %r8d, (%rsp)
movl %ecx, %r14d
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
callq 0x1032e8
movq %rax, %rdi
xorl %esi, %esi
callq 0x10289f
movq %rax, %rbx
callq 0x1032e8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102c81
movq %rax, %rbp
movq %r15, %rdi
callq 0x102934
movq %rax, 0x10(%rbp)
movq %r13, %rdi
movq %r12, %rsi
movl %r14d, %edx
movl (%rsp), %ecx
movl 0x4(%rsp), %r8d
movq 0x40(%rsp), %r9
callq 0x103bb0
movq %rax, 0x18(%rbp)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/orf_finder_visitor.c
// Function: gt_orf_finder_visitor_class
const GtNodeVisitorClass* gt_orf_finder_visitor_class(void)
{
  static const GtNodeVisitorClass *gvc = NULL;
  gt_class_alloc_lock_enter();
  if (!gvc) {
    gvc = gt_node_visitor_class_new(sizeof (GtORFFinderVisitor),
                                    NULL,
                                    NULL,
                                    gt_orf_finder_visitor_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return gvc;
}

// Assembly:
pushq %rax
callq 0x69e97
cmpq $0x0, 0x33a31e(%rip)    # 0x43d7b0
jne 0x1034b9
andq $0x0, (%rsp)
leaq 0x27(%rip), %rcx        # 0x1034c7
pushq $0x30
popq %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x102cd0
movq %rax, 0x33a2f7(%rip)    # 0x43d7b0
callq 0x69ede
movq 0x33a2eb(%rip), %rax    # 0x43d7b0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/orf_finder_visitor.c
// Function: gt_orf_finder_visitor_new
GtNodeVisitor* gt_orf_finder_visitor_new(GtRegionMapping *rmap,
                                         GtHashmap *types,
                                         unsigned int min,
                                         unsigned int max,
                                         bool all,
                                         GT_UNUSED GtError *err)
{
  GtNodeVisitor *gv;
  GtORFFinderVisitor *lv;
  gv = gt_node_visitor_create(gt_orf_finder_visitor_class());
  lv = gt_orf_finder_visitor_cast(gv);
  gt_assert(lv);
  lv->rmap = rmap;
  lv->types=types;
  lv->min = min;
  lv->max = max;
  lv->all = all;
  return gv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
callq 0x103484
movq %rax, %rdi
callq 0x102da0
movq %rax, %r13
callq 0x103484
movq %rax, %rdi
movq %r13, %rsi
callq 0x102dfe
testq %rax, %rax
je 0x103c12
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
movl %r14d, 0x20(%rax)
movl %ebp, 0x24(%rax)
movb %bl, 0x28(%rax)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x33434f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e13f0(%rip), %rsi    # 0x2e5013
leaq 0x25c717(%rip), %rdx    # 0x360341
leaq 0x229ff2(%rip), %rcx    # 0x32dc23
leaq 0x22a005(%rip), %r8     # 0x32dc3d
movl $0x15c, %r9d            # imm = 0x15C
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/orf_finder_visitor.c
// Function: process_orf
static void process_orf(GtRange orf_rng, unsigned int orf_frame,
                        GtStrand strand, GtFeatureNode *gf,
                        GtUword offset, unsigned int min,
                        unsigned int max, GT_UNUSED GtError *err)
{

  gt_assert(gf);
  GtUword tmp;

  if ((gt_range_length(&orf_rng) >= min) &&
      (gt_range_length(&orf_rng) <= max)) {
    switch (strand) {
      case GT_STRAND_FORWARD:
        orf_rng.start = orf_rng.start + offset;
        orf_rng.end = orf_rng.end + offset;
        break;
      case GT_STRAND_REVERSE:
        tmp = orf_rng.start;
        orf_rng.start = offset - orf_rng.end;
        orf_rng.end = offset - tmp;
        break;
      default:
        exit(GT_EXIT_PROGRAMMING_ERROR);
        break;
    }
    orf_attach_results_to_gff3(gf, orf_rng, orf_frame, strand, err);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r12
movq %r8, %r14
movl %ecx, %ebx
movl %edx, %ebp
movl 0x80(%rsp), %r15d
leaq 0x10(%rsp), %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
movq %rax, %rdi
callq 0xa31ee
cmpq %r15, %rax
jb 0x103dee
movl 0x88(%rsp), %r15d
leaq 0x10(%rsp), %rdi
callq 0xa31ee
movl %r15d, %ecx
cmpq %rcx, %rax
ja 0x103dee
movq 0x10(%rsp), %r15
testl %ebx, %ebx
je 0x103cbe
movq %r12, %rax
subq 0x18(%rsp), %rax
subq %r15, %r12
movq %rax, %r15
jmp 0x103cc6
addq %r12, %r15
addq 0x18(%rsp), %r12
movq %r15, 0x10(%rsp)
movq %r12, 0x18(%rsp)
leaq 0x229fcc(%rip), %rdi    # 0x32dca3
callq 0xacbd1
movq %rax, 0x20(%rsp)
movq %r14, %rdi
callq 0xd9d99
cmpl $0x1, %eax
jne 0x103cf7
movl %ebx, %edi
callq 0xae6f3
movl %eax, %ebx
incq %r15
leaq 0x28(%rsp), %rax
movq %r15, (%rax)
incq %r12
movq %r12, 0x8(%rax)
leaq 0x26667a(%rip), %rsi    # 0x36a38a
xorl %r12d, %r12d
leaq 0xd(%rsp), %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x17120
movq %r14, %rdi
callq 0xdc6f0
movq %rax, %r13
leaq 0x229f4f(%rip), %rbp    # 0x32dc82
movq %r13, %rdi
callq 0xdc92e
testq %rax, %rax
je 0x103d83
movq %rax, %r15
movq %rax, %rdi
callq 0xda338
movq %rax, %rdi
movq %rbp, %rsi
callq 0x179e0
testl %eax, %eax
je 0x103d33
movq %r15, %rdi
callq 0xdd1f4
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xa3345
testb %al, %al
cmovneq %r15, %r12
jmp 0x103d33
testq %r12, %r12
movq 0x20(%rsp), %r15
je 0x103dde
movq %r14, %rdi
callq 0xdd14a
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
leaq 0x229edc(%rip), %rsi    # 0x32dc82
movq %rax, %rdi
movl %ebx, %r8d
callq 0xd9acb
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0xd96be
leaq 0x278605(%rip), %rsi    # 0x37c3cb
leaq 0xd(%rsp), %rdx
movq %rbx, %rdi
callq 0xda48b
movq %r12, %rdi
movq %rbx, %rsi
callq 0xda055
movq %r15, %rdi
callq 0xae103
movq %r13, %rdi
callq 0xdc9f1
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/orf_iterator.c
// Function: gt_orf_iterator_new
GtORFIterator* gt_orf_iterator_new(GtCodonIterator *ci,
                                   GtTranslator *translator)
{
  gt_assert(ci && translator);
  GtORFIterator *orfi = gt_malloc(sizeof (GtORFIterator));
  int i;

  orfi->ci = ci;
  orfi->translator = translator;

  for (i = 0; i < 3; i++) {
    orfi->orf_start[i] = GT_UNDEF_UWORD;
    orfi->found_start[i] = false;
  }
  return orfi;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x103e4d
movq %rsi, %rbx
testq %rsi, %rsi
je 0x103e4d
movq %rdi, %r14
leaq 0x229eb9(%rip), %rsi    # 0x32dcd4
pushq $0x30
popq %rdi
pushq $0x27
popq %rdx
callq 0x93160
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
pushq $-0x3
popq %rcx
testq %rcx, %rcx
je 0x103e45
orq $-0x1, 0x28(%rax,%rcx,8)
movb $0x0, 0x2b(%rax,%rcx)
incq %rcx
jmp 0x103e30
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x334114(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e11b5(%rip), %rsi    # 0x2e5013
leaq 0x229e4a(%rip), %rdx    # 0x32dcaf
leaq 0x229e54(%rip), %rcx    # 0x32dcc0
leaq 0x229e61(%rip), %r8     # 0x32dcd4
pushq $0x26
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/orf_iterator.c
// Function: gt_orf_iterator_next
GtORFIteratorStatus gt_orf_iterator_next(
                        GtORFIterator *orfi, GtRange *orf_rng,
                        unsigned int *orf_frame, GtError *err)
{
  gt_assert(orfi);
  unsigned int frame;
  char translated;
  GtTranslatorStatus state;

  while ((state = gt_translator_next(orfi->translator,
                            &translated, &frame, err)) != GT_TRANSLATOR_END) {
    if (state == GT_TRANSLATOR_ERROR)
      return GT_ORF_ITERATOR_ERROR;
    if (translated == GT_START_AMINO && !orfi->found_start[frame]) {
      orfi->orf_start[frame] = gt_codon_iterator_current_position(orfi->ci) - 1;
      orfi->found_start[frame] = true;
    }
    else if ((translated == GT_STOP_AMINO) &&
             (orfi->found_start[frame] == true)) {
      orf_rng->start = orfi->orf_start[frame];
      /* ORF ends before GT_STOP_AMINO */
      orf_rng->end = gt_codon_iterator_current_position(orfi->ci) - 2;
      *orf_frame = frame;
      orfi->found_start[frame] = false;
      return GT_ORF_ITERATOR_OK;
    }
  }
  return GT_ORF_ITERATOR_END;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x103f3c
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x3(%rsp), %r13
leaq 0x4(%rsp), %rbp
movq 0x8(%r14), %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r12, %rcx
callq 0xb2013
cmpl $-0x3, %eax
ja 0x103f2d
movzbl 0x3(%rsp), %eax
cmpl $0x2a, %eax
je 0x103efb
cmpl $0x4d, %eax
jne 0x103ead
movl 0x4(%rsp), %eax
cmpb $0x0, 0x28(%r14,%rax)
jne 0x103ead
movq (%r14), %rdi
callq 0x6a0d5
decq %rax
movl 0x4(%rsp), %ecx
movq %rax, 0x10(%r14,%rcx,8)
movb $0x1, 0x28(%r14,%rcx)
jmp 0x103ead
movl 0x4(%rsp), %eax
cmpb $0x1, 0x28(%r14,%rax)
jne 0x103ead
movq 0x10(%r14,%rax,8), %rax
movq %rax, (%r15)
movq (%r14), %rdi
callq 0x6a0d5
addq $-0x2, %rax
movq %rax, 0x8(%r15)
movl 0x4(%rsp), %eax
movl %eax, (%rbx)
movb $0x0, 0x28(%r14,%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x334025(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e10c6(%rip), %rsi    # 0x2e5013
leaq 0x229d4a(%rip), %rdx    # 0x32dc9e
leaq 0x229d95(%rip), %rcx    # 0x32dcf0
leaq 0x229d72(%rip), %r8     # 0x32dcd4
pushq $0x38
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_delete
void gt_popcount_tab_delete(GtPopcountTab *popcount_tab)
{
  if (popcount_tab != NULL) {
    gt_compact_ulong_store_delete(popcount_tab->blocks);
    gt_compact_ulong_store_delete(popcount_tab->offsets);
    gt_compact_ulong_store_delete(popcount_tab->rev_blocks);
    gt_free(popcount_tab->bit_sizes);
    gt_free(popcount_tab);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x104560
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x6bb56
movq 0x10(%rbx), %rdi
callq 0x6bb56
movq 0x18(%rbx), %rdi
callq 0x6bb56
movq (%rbx), %rdi
leaq 0x229910(%rip), %r14    # 0x32de4c
movq %r14, %rsi
movl $0x99, %edx
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x9a, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_get
GtUword gt_popcount_tab_get(GtPopcountTab *popcount_tab,
                                  unsigned int popcount_c,
                                  GtUword i)
{
  gt_assert(popcount_c <= popcount_tab->blocksize);
  if (popcount_c == 0) {
    gt_assert(i == 0);
    return 0;
  }
  if (popcount_c < popcount_tab->blocksize)
    gt_assert(i <
              gt_compact_ulong_store_get(popcount_tab->offsets,
                                         (GtUword) popcount_c + 1) -
              gt_compact_ulong_store_get(popcount_tab->offsets,
                                         (GtUword) popcount_c));
  else
    gt_assert(i == 0);
  return gt_compact_ulong_store_get(
                    popcount_tab->blocks,
                    gt_compact_ulong_store_get(popcount_tab->offsets,
                                               (GtUword) popcount_c) + i);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x28(%rdi), %eax
cmpl %esi, %eax
jb 0x104622
movq %rdx, %rbx
testl %esi, %esi
je 0x1045da
movq %rdi, %r14
cmpl %esi, %eax
jbe 0x1045ed
movq 0x10(%r14), %rdi
movl %esi, %r15d
leaq 0x1(%r15), %rsi
callq 0x6bb8d
movq %rax, %r12
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x6bb8d
subq %rax, %r12
cmpq %rbx, %r12
ja 0x1045f9
movq 0x3339b8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e0a59(%rip), %rsi    # 0x2e5013
leaq 0x229911(%rip), %rdx    # 0x32ded2
leaq 0x2298ef(%rip), %rcx    # 0x32deb7
leaq 0x22987d(%rip), %r8     # 0x32de4c
movl $0xac, %r9d
jmp 0x1046aa
testq %rbx, %rbx
jne 0x104650
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testq %rbx, %rbx
jne 0x10467e
movl %esi, %r15d
movq 0x8(%r14), %r12
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x6bb8d
addq %rax, %rbx
movq %r12, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6bb8d
movq 0x33393f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e09e0(%rip), %rsi    # 0x2e5013
leaq 0x229857(%rip), %rdx    # 0x32de91
leaq 0x229876(%rip), %rcx    # 0x32deb7
leaq 0x229804(%rip), %r8     # 0x32de4c
movl $0xa2, %r9d
jmp 0x1046aa
movq 0x333911(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e09b2(%rip), %rsi    # 0x2e5013
leaq 0x229863(%rip), %rdx    # 0x32decb
leaq 0x229848(%rip), %rcx    # 0x32deb7
leaq 0x2297d6(%rip), %r8     # 0x32de4c
movl $0xa4, %r9d
jmp 0x1046aa
movq 0x3338e3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e0984(%rip), %rsi    # 0x2e5013
leaq 0x229835(%rip), %rdx    # 0x32decb
leaq 0x22981a(%rip), %rcx    # 0x32deb7
leaq 0x2297a8(%rip), %r8     # 0x32de4c
movl $0xae, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_calculate_size
size_t gt_popcount_tab_calculate_size(unsigned int blocksize)
{
  GtUword num_of_blocks = 1UL << blocksize;
  size_t size = gt_compact_ulong_store_size(num_of_blocks, blocksize);
  size += sizeof (GtPopcountTab);
  size += sizeof (GtUword) * blocksize;
  return size;
}

// Assembly:
pushq %rbx
movl %edi, %ecx
movl %edi, %ebx
pushq $0x1
popq %rdi
shlq %cl, %rdi
movl %ecx, %esi
callq 0x6baf6
leaq (%rax,%rbx,8), %rax
addq $0x30, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_offset_bits
unsigned int gt_popcount_tab_offset_bits(GtPopcountTab *popcount_tab,
                                         unsigned int class)
{
  gt_assert(popcount_tab != NULL);
  gt_assert(class <= popcount_tab->blocksize);
  if (popcount_tab->bit_sizes == NULL) {
    popcount_tab->bit_sizes = gt_calloc((size_t) popcount_tab->blocksize + 1,
                                        sizeof (*(popcount_tab->bit_sizes)));
    gt_popcount_tab_init_bit_sizes(popcount_tab->bit_sizes,
                                   popcount_tab->blocksize);
  }
  return popcount_tab->bit_sizes[class];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x104830
movl %esi, %ebx
movq %rdi, %r14
movl 0x28(%rdi), %edi
cmpl %esi, %edi
jb 0x10485e
movq (%r14), %rax
testq %rax, %rax
jne 0x10481c
incq %rdi
leaq 0x22966f(%rip), %rdx    # 0x32de4c
pushq $0x4
popq %rsi
movl $0xf9, %ecx
callq 0x9334a
movq %rax, %r15
movq %rax, (%r14)
movl 0x28(%r14), %r12d
xorl %ebp, %ebp
cmpl %r12d, %ebp
ja 0x104819
movl %ebp, %r13d
movq %r12, %rdi
movq %r13, %rsi
callq 0x6b72d
movq %rax, %rdi
callq 0x9580f
movl %eax, (%r15,%r13,4)
incl %ebp
jmp 0x1047f6
movq (%r14), %rax
movl %ebx, %ecx
movl (%rax,%rcx,4), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x333731(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e07d2(%rip), %rsi    # 0x2e5013
leaq 0x229724(%rip), %rdx    # 0x32df6c
leaq 0x22976e(%rip), %rcx    # 0x32dfbd
leaq 0x2295f6(%rip), %r8     # 0x32de4c
movl $0xf5, %r9d
jmp 0x10488a
movq 0x333703(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e07a4(%rip), %rsi    # 0x2e5013
leaq 0x229763(%rip), %rdx    # 0x32dfd9
leaq 0x229740(%rip), %rcx    # 0x32dfbd
leaq 0x2295c8(%rip), %r8     # 0x32de4c
movl $0xf6, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_block_to_str
void gt_popcount_tab_block_to_str(GtPopcountTab *popcount_tab,
                                  GtUword block,
                                  char *buffer)
{
  unsigned int idx;
  buffer[popcount_tab->blocksize] = 0;
  for (idx = 0; idx < popcount_tab->blocksize; ++idx) {
    buffer[idx] =
      ((block >> (GtUword) (popcount_tab->blocksize - idx - 1)) &
       (GtUword) 1) ==
      (GtUword) 1 ?
      '1' : '0';
  }
}

// Assembly:
movl 0x28(%rdi), %eax
movb $0x0, (%rdx,%rax)
pushq $-0x1
popq %rax
xorl %ecx, %ecx
movl 0x28(%rdi), %r8d
cmpq %r8, %rcx
jae 0x104a9c
addl %eax, %r8d
btq %r8, %rsi
setae %r8b
xorb $0x31, %r8b
movb %r8b, (%rdx,%rcx)
incq %rcx
decl %eax
jmp 0x104a79
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_get_offset_for_block
GtUword gt_popcount_tab_get_offset_for_block(GtPopcountTab *popcount_tab,
                                                   GtUword block)
{
  gt_assert(popcount_tab != NULL);
  if (popcount_tab->rev_blocks == NULL)
    gt_popcount_tab_init_rev_offset(popcount_tab);
  return gt_compact_ulong_store_get(popcount_tab->rev_blocks, block);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x104b62
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
jne 0x104b4c
movl 0x28(%r14), %esi
shrl %esi
movq %r14, %rdi
callq 0x1047ab
movq 0x20(%r14), %rdi
movl %eax, %esi
callq 0x6ba08
movq %rax, 0x18(%r14)
xorl %r12d, %r12d
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpq 0x20(%r14), %r15
jae 0x104b48
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x6bb8d
movq %rax, %r13
cmpl 0x28(%r14), %ebp
jae 0x104b1b
movq 0x10(%r14), %rdi
movl %ebp, %esi
incq %rsi
callq 0x6bb8d
cmpq %rax, %r15
jne 0x104b1b
incl %ebp
jmp 0x104b1f
testl %ebp, %ebp
je 0x104b32
movq 0x10(%r14), %rdi
movl %ebp, %esi
callq 0x6bb8d
movq %r15, %r12
subq %rax, %r12
jmp 0x104b34
xorl %ebp, %ebp
movq 0x18(%r14), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x6bc0a
incq %r15
jmp 0x104ae9
movq 0x18(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6bb8d
movq 0x3333ff(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e04a0(%rip), %rsi    # 0x2e5013
leaq 0x2293f2(%rip), %rdx    # 0x32df6c
leaq 0x2294ae(%rip), %rcx    # 0x32e02f
leaq 0x2292c4(%rip), %r8     # 0x32de4c
movl $0x153, %r9d            # imm = 0x153
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_next_perm
static GtUword gt_popcount_tab_next_perm(GtUword v)
{
  GtUword head, tail;

  head = (v | (v - 1)) + 1;
  tail = v & (((head & -head) >> 1) -1);
  if (tail != 0) {
#ifdef __SSE__
    int zero_trail = __builtin_ctzl(tail);
    tail >>= zero_trail;
#else
    while (( tail & 1 ) == 0)
      tail = tail >> 1;
#endif
  }
  return head | tail;
}

// Assembly:
leaq -0x1(%rdi), %rdx
orq %rdi, %rdx
leaq 0x1(%rdx), %rsi
notq %rdx
andq %rsi, %rdx
shrq %rdx
decq %rdx
andq %rdi, %rdx
bsfq %rdx, %rcx
movq %rdx, %rax
shrq %cl, %rax
testq %rdx, %rdx
cmoveq %rdx, %rax
orq %rsi, %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/priority_queue.c
// Function: gt_priority_queue_new
GtPriorityQueue *gt_priority_queue_new(GtCompare cmpfun,
                                       GtUword maxnumofelements)
{
  GtPriorityQueue *pq = gt_malloc(sizeof *pq);
  pq->elements = gt_calloc((maxnumofelements + 1), sizeof (*pq->elements));
  pq->minelement = NULL;
  pq->cmpfun = cmpfun;
  pq->capacity = maxnumofelements;
  pq->numofelements = 0;
  return pq;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x229193(%rip), %r15    # 0x32e524
pushq $0x28
popq %rdi
pushq $0x2b
popq %rdx
movq %r15, %rsi
callq 0x93160
movq %rax, %r12
leaq 0x1(%rbx), %rdi
pushq $0x8
popq %rsi
pushq $0x2c
popq %rcx
movq %r15, %rdx
callq 0x9334a
movq %rax, 0x20(%r12)
movq %r14, (%r12)
movq %rbx, 0x8(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq