LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/merge_feature_visitor.c
// Function: gt_merge_feature_visitor_class
const GtNodeVisitorClass* gt_merge_feature_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtMergeFeatureVisitor),
                                    merge_feature_visitor_free,
                                    NULL,
                                    merge_feature_visitor_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x35d656(%rip)    # 0x4be7d8
jne 0x1611b3
movq $0x0, (%rsp)
leaq 0x2e(%rip), %rsi        # 0x1611c1
leaq 0x5b(%rip), %rcx        # 0x1611f5
movl $0x28, %edi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x163010
movq %rax, 0x35d625(%rip)    # 0x4be7d8
callq 0xe2545
movq 0x35d619(%rip), %rax    # 0x4be7d8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/merge_feature_visitor.c
// Function: merge_feature_visitor_free
static void merge_feature_visitor_free(GtNodeVisitor *nv)
{
  GtMergeFeatureVisitor *merge_feature_visitor =
    gt_merge_feature_visitor_cast(nv);
  gt_assert(merge_feature_visitor);
  gt_hashmap_delete(merge_feature_visitor->hm);
  gt_array_delete(merge_feature_visitor->nodes_to_remove);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x161174
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1630b1
testq %rax, %rax
je 0x1611f0
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0x10109b
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0xd2938
callq 0x4d13a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/merge_feature_visitor.c
// Function: merge_feature_visitor_feature_node
static int merge_feature_visitor_feature_node(GtNodeVisitor *nv,
                                          GtFeatureNode *fn, GtError *err)
{
  GtMergeFeatureVisitor *v;
  GtFeatureNode *leaf;
  GtUword i;
  int had_err = 0;
  gt_error_check(err);
  v = gt_merge_feature_visitor_cast(nv);
  gt_array_reset(v->nodes_to_remove);
  had_err = gt_feature_node_traverse_children(fn, v, mergefeat_if_necessary,
                                              false, err);
  if (!had_err) {
    for (i = 0; i < gt_array_size(v->nodes_to_remove); i++) {
      leaf = *(GtFeatureNode**) gt_array_get(v->nodes_to_remove, i);
      gt_feature_node_remove_leaf(fn, leaf);
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x161216
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
jne 0x161295
callq 0x161174
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq %rax, %r14
movq 0x20(%rax), %rdi
callq 0xd2519
leaq 0xb3(%rip), %rdx        # 0x1612ec
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
movq %r15, %r8
callq 0x142d9d
movl %eax, %ebp
testl %eax, %eax
jne 0x161288
movq 0x20(%r14), %rdi
callq 0xd24e0
testq %rax, %rax
je 0x161288
xorl %r15d, %r15d
movq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0xd2207
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x1439cb
incq %r15
movq 0x20(%r14), %rdi
callq 0xd24e0
cmpq %rax, %r15
jb 0x161260
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x4d171
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/merge_feature_visitor.c
// Function: gt_merge_feature_visitor_new
GtNodeVisitor* gt_merge_feature_visitor_new(void)
{
  GtNodeVisitor *nv = gt_node_visitor_create(gt_merge_feature_visitor_class());
  GtMergeFeatureVisitor *mfv = gt_merge_feature_visitor_cast(nv);
  mfv->hm = gt_hashmap_new(GT_HASH_STRING, NULL, NULL);
  mfv->nodes_to_remove = gt_array_new(sizeof (GtFeatureNode*));
  return nv;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x161174
movq %rax, %rdi
callq 0x163080
movq %rax, %rbx
callq 0x161174
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1630b1
movq %rax, %r14
movl $0x1, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1008fc
movq %rax, 0x18(%r14)
movl $0x8, %edi
callq 0xd214c
movq %rax, 0x20(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/merge_feature_visitor.c
// Function: mergefeat_if_necessary
static int mergefeat_if_necessary(GtFeatureNode *fn, void *data, GtError *err)
{
  GtMergeFeatureVisitor *v = (GtMergeFeatureVisitor*) data;
  gt_error_check(err);
  gt_assert(fn);
  v->current_tree = fn;
  gt_hashmap_reset(v->hm);
  return gt_feature_node_traverse_direct_children(fn, v, mergefeat_in_children,
                                                  err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x16130b
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x16133c
testq %r15, %r15
je 0x161337
movq %r15, 0x10(%r14)
movq 0x18(%r14), %rdi
callq 0x100c1d
leaq 0x1d(%rip), %rdx        # 0x161341
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x1438a5
callq 0x4d1df
callq 0x4d1a8
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/merge_stream.c
// Function: gt_merge_stream_class
const GtNodeStreamClass* gt_merge_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtMergeStream),
                                   merge_stream_free,
                                   merge_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x35d33e(%rip)    # 0x4be7e0
jne 0x1614c3
leaq 0x26(%rip), %rsi        # 0x1614d1
leaq 0xb5(%rip), %rdx        # 0x161567
movl $0x40, %edi
callq 0x162d34
movq %rax, 0x35d31d(%rip)    # 0x4be7e0
callq 0xe2545
movq 0x35d311(%rip), %rax    # 0x4be7e0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x161494
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162ff7
movq %rax, %rbx
movq 0x10(%rax), %rdi
callq 0xd24e0
testq %rax, %rax
je 0x16153b
xorl %r15d, %r15d
xorl %r14d, %r14d
movq 0x28(%rbx), %rax
movq (%rax,%r15), %rdi
testq %rdi, %rdi
je 0x161512
callq 0x1451a0
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xd2207
movq (%rax), %rdi
callq 0x162dee
incq %r14
movq 0x10(%rbx), %rdi
callq 0xd24e0
addq $0x10, %r15
cmpq %rax, %r14
jb 0x161500
movq 0x10(%rbx), %rdi
callq 0xd2938
movq 0x28(%rbx), %rdi
leaq 0x22b3f6(%rip), %rsi    # 0x38c945
movl $0xbb, %edx
callq 0x1045eb
movq 0x30(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1650b1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/merge_stream.c
// Function: merge_stream_next
static int merge_stream_next(GtNodeStream *ns, GtGenomeNode **gn, GtError *err)
{
  GtMergeStream *ms;
  int had_err = 0;
  gt_error_check(err);
  ms = gt_merge_stream_cast(ns);

  gt_assert(!ms->second_node); /* the second buffer is always empty when this
                                  function is called */
  if (!ms->first_node) {
    /* both buffers are empty */
    had_err = merge_stream_next_in_order(ns, &ms->first_node, err);
    if (had_err)
      return had_err;
    if (!ms->first_node) {
      *gn = NULL;
      return 0;
    }
  }

  while (!had_err) {
    gt_assert(ms->first_node && !ms->second_node);
    had_err = merge_stream_next_in_order(ns, &ms->second_node, err);
    if (!had_err && ms->second_node) {
      if (!merge_stream_consolidate(&ms->first_node, &ms->second_node))
        break;
    }
    else
      break;
  }

  if (!had_err) {
    gt_assert(ms->first_node);
    *gn = ms->first_node;
    ms->first_node = ms->second_node;
    ms->second_node = NULL;
  }

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x16158e
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x161673
callq 0x161494
movq %rax, %rdi
movq %r15, %rsi
callq 0x162ff7
cmpq $0x0, 0x20(%rax)
jne 0x16166e
movq %rax, %r12
leaq 0x18(%rax), %r13
cmpq $0x0, 0x18(%rax)
je 0x16163d
addq $0x20, %r12
cmpq $0x0, (%r12)
jne 0x161618
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1617ec
testl %eax, %eax
jne 0x16164f
movq (%r12), %rsi
testq %rsi, %rsi
je 0x16161d
movq (%r13), %rdi
testq %rdi, %rdi
je 0x161669
callq 0x14499e
testb %al, %al
je 0x16161d
movq (%r13), %rdi
movq (%r12), %rsi
callq 0x16e89f
movq (%r12), %rdi
callq 0x1451a0
movq $0x0, (%r12)
cmpq $0x0, (%r13)
jne 0x1615c6
callq 0x4d364
movq (%r13), %rax
testq %rax, %rax
je 0x161678
movq %rax, (%rbx)
movq (%r12), %rax
movq %rax, (%r13)
movq $0x0, (%r12)
xorl %eax, %eax
jmp 0x16164f
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x1617ec
testl %eax, %eax
je 0x161659
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
cmpq $0x0, (%r13)
jne 0x1615bb
movq %rbx, %r12
jmp 0x161631
callq 0x4d39d
callq 0x4d32b
callq 0x4d2f2
callq 0x4d3d4
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
callq 0x161494
movq %rax, %rdi
movl $0x1, %esi
callq 0x162d6c
movq %rax, %rbx
callq 0x161494
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162ff7
movq %rax, %r15
movq %r14, %rdi
callq 0xd24e0
testq %rax, %rax
je 0x1617c0
movq %r14, %rdi
callq 0xd24e0
testq %rax, %rax
je 0x161701
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0xd2207
movq (%rax), %rdi
callq 0x162fe4
testb %al, %al
je 0x1617bb
incq %r12
movq %r14, %rdi
callq 0xd24e0
cmpq %rax, %r12
jb 0x1616d6
movq %r14, %rdi
callq 0xd24e0
leaq 0x22b235(%rip), %rdx    # 0x38c945
movl $0x10, %esi
movq %rax, %rdi
movl $0xdb, %ecx
callq 0x10436a
movq %rax, 0x28(%r15)
movl $0x8, %edi
callq 0xd214c
movq %rax, 0x10(%r15)
movq %r14, %rdi
callq 0xd24e0
testq %rax, %rax
je 0x161782
xorl %r12d, %r12d
leaq 0x8(%rsp), %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0xd2207
movq (%rax), %rdi
callq 0x162dd8
movq %rax, 0x8(%rsp)
movq 0x10(%r15), %rdi
movl $0x8, %edx
movq %r13, %rsi
callq 0xd2410
incq %r12
movq %r14, %rdi
callq 0xd24e0
cmpq %rax, %r12
jb 0x161749
movq %r14, %rdi
callq 0xd24e0
leaq 0x34(%rip), %rdi        # 0x1617c5
movq %rax, %rsi
callq 0x164e18
movq %rax, 0x30(%r15)
movb $0x0, 0x38(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x4d40d
callq 0x4d446
// File: /workspace/github_c_makefile_star2_O3/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 0x1617e7
testq %rsi, %rsi
je 0x1617e7
cmpq $0x0, (%rdi)
je 0x1617e2
cmpq $0x0, (%rsi)
je 0x1617e2
popq %rax
jmp 0x144780
callq 0x4d4b6
callq 0x4d47f
// File: /workspace/github_c_makefile_star2_O3/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 0x22adfa(%rip), %r14    # 0x38cb68
movl $0x20, %edi
movq %r14, %rsi
movl $0x33, %edx
callq 0x104226
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movl $0x1, %esi
movq %rbx, %rdi
movq %r14, %rdx
movl $0x37, %ecx
callq 0x10436a
movq %rax, 0x8(%r15)
movq %rbx, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x161e4d
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x161dee
leaq 0x22ad96(%rip), %rsi    # 0x38cb68
movl $0x20, %edi
movl $0x2a, %edx
callq 0x104226
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq 0x18(%rbx), %rsi
cmpq %rsi, 0x10(%r14)
jae 0x161e19
movq 0x8(%r14), %rdi
leaq 0x22ad65(%rip), %rdx    # 0x38cb68
movl $0x46, %ecx
callq 0x104461
movq %rax, 0x8(%r14)
movq 0x18(%rbx), %rsi
movq %rsi, 0x10(%r14)
movq $0x0, (%r14)
movq %rsi, 0x18(%r14)
testq %rsi, %rsi
je 0x161e42
xorl %eax, %eax
movq 0x8(%rbx), %rcx
movb (%rcx,%rax), %cl
movq 0x8(%r14), %rdx
movb %cl, (%rdx,%rax)
incq %rax
cmpq 0x18(%r14), %rax
jb 0x161e2b
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x4d713
// File: /workspace/github_c_makefile_star2_O3/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 0x161e73
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x161e7b
decq %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x161ea8
leaq 0x8(%rbx), %r14
leaq 0x22acd9(%rip), %rsi    # 0x38cb68
movl $0x5e, %edx
callq 0x1045eb
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x22acb9(%rip), %rsi    # 0x38cb68
movq %rbx, %rdi
movl $0x5f, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/multieoplist.c
// Function: gt_multieoplist_add_eops
static void gt_multieoplist_add_eops(GtMultieoplist *multieops,
                                     AlignmentEoptype type,
                                     GtUword steps)
{
  Eop *space, type_bits = 0;

  gt_assert(multieops != NULL);
  space = multieops->meoplist.spaceEop;
  switch (type) {
    case Deletion:
      type_bits = GT_MEOPS_DEL;
      break;
    case Insertion:
      type_bits = GT_MEOPS_INS;
      break;
    case Match:
    case Replacement:
      type_bits = GT_MEOPS_MATCH;
      break;
    case Mismatch:
      type_bits = GT_MEOPS_MIS;
      break;
    default:
      gt_assert(false);
  }
  if (multieops->meoplist.nextfreeEop != 0) {
    GtUword current = multieops->meoplist.nextfreeEop - 1;
    if (space[current] >> GT_MEOPS_STEPS_BITS == type_bits) {
      while (steps != 0 &&
             (space[current] & GT_MEOPS_STEPS_MASK) < GT_MEOPS_STEPS_MASK) {
        space[current]++;
        steps--;
      }
    }
  }
  if (steps != 0) {
    while (steps != 0) {
      Eop tmp = type_bits << GT_MEOPS_STEPS_BITS;
      if (steps < (GtUword) GT_MEOPS_STEPS_MASK) {
        tmp += steps;
        steps = 0;
      }
      else {
        tmp |= GT_MEOPS_STEPS_MASK;
        steps -= GT_MEOPS_STEPS_MASK;
      }
      GT_STOREINARRAY(&multieops->meoplist, Eop, 64<<2, tmp);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x161fad
movq %rdx, %rbx
movq %rdi, %r14
movslq %esi, %rax
leaq 0x22b3f8(%rip), %rcx    # 0x38d2e8
movl (%rcx,%rax,4), %ebp
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x161f2b
testq %rbx, %rbx
je 0x161f2b
movq 0x8(%r14), %rcx
movzbl -0x1(%rcx,%rax), %edx
movl %edx, %esi
shrl $0x6, %esi
cmpl %esi, %ebp
jne 0x161f2b
movl %edx, %esi
notb %sil
testb $0x3f, %sil
je 0x161f30
incb %dl
movb %dl, -0x1(%rcx,%rax)
decq %rbx
jne 0x161f13
jmp 0x161f9f
testq %rbx, %rbx
je 0x161f9f
shlb $0x6, %bpl
leaq 0x22ac2d(%rip), %r15    # 0x38cb68
cmpq $0x3f, %rbx
movl $0x3f, %r12d
cmovbq %rbx, %r12
movq 0x10(%r14), %rsi
cmpq %rsi, 0x18(%r14)
jae 0x161f59
movq 0x8(%r14), %rax
jmp 0x161f79
addq $0x100, %rsi            # imm = 0x100
movq %rsi, 0x10(%r14)
movq 0x8(%r14), %rdi
movq %r15, %rdx
movl $0x99, %ecx
callq 0x104461
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x161fa8
addq $-0x3f, %rbx
orb %bpl, %r12b
movq 0x18(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%r14)
movb %r12b, (%rax,%rcx)
leaq 0x3f(%rbx), %rax
cmpq $0x3f, %rax
ja 0x161f3b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x4d74a
callq 0x4d783
// File: /workspace/github_c_makefile_star2_O3/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 0x16203d
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x16203d
movq 0x8(%rdi), %rcx
movb -0x1(%rcx,%rax), %dl
movl %edx, %esi
andb $0x3f, %sil
cmpb $0x1, %sil
jne 0x162036
decq %rax
movq %rax, 0x18(%rdi)
retq
decb %dl
movb %dl, -0x1(%rcx,%rax)
retq
pushq %rax
callq 0x4d7f3
// File: /workspace/github_c_makefile_star2_O3/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 0x162086
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x162082
movq 0x8(%rdi), %rdx
xorl %eax, %eax
xorl %esi, %esi
movzbl (%rdx,%rsi), %edi
movl %edi, %r8d
notl %r8d
andl $0xc0, %r8d
andl $0x3f, %edi
testl %r8d, %r8d
cmovel %r8d, %edi
addq %rdi, %rax
incq %rsi
cmpq %rsi, %rcx
jne 0x16205a
jmp 0x162084
xorl %eax, %eax
popq %rcx
retq
callq 0x4d82c
// File: /workspace/github_c_makefile_star2_O3/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 0x1620d0
movq 0x18(%rdi), %rcx
xorl %edx, %edx
testq %rcx, %rcx
je 0x1620cc
movq 0x8(%rdi), %rsi
xorl %eax, %eax
xorl %edi, %edi
movzbl (%rsi,%rdi), %r8d
movl %r8d, %r9d
andl $-0x40, %r9d
andl $0x3f, %r8d
cmpl $0x80, %r9d
cmovel %edx, %r8d
addq %r8, %rax
incq %rdi
cmpq %rdi, %rcx
jne 0x1620a4
jmp 0x1620ce
xorl %eax, %eax
popq %rcx
retq
callq 0x4d865
// File: /workspace/github_c_makefile_star2_O3/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 0x162104
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x162100
movq 0x8(%rdi), %rdx
xorl %eax, %eax
xorl %esi, %esi
movzbl (%rdx,%rsi), %edi
andl $0x3f, %edi
addq %rdi, %rax
incq %rsi
cmpq %rsi, %rcx
jne 0x1620ec
jmp 0x162102
xorl %eax, %eax
popq %rcx
retq
callq 0x4d89e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/multieoplist.c
// Function: gt_multieoplist_show
void gt_multieoplist_show(const GtMultieoplist *multieops, FILE *fp)
{
  GtUword stepssum,
          num = multieops->meoplist.nextfreeEop;
  Eop *space, *last, *next;

  if (num == 0)
  {
    gt_xfputs("[]\n", fp);
    return;
  }
  gt_assert(multieops != NULL);
  space = multieops->meoplist.spaceEop;

  gt_xfputc('[', fp);
  last = space + num - 1;
  next = space + num - 2;
  stepssum = (GtUword) (*last & GT_MEOPS_STEPS_MASK);
  while (next >= space) {
    if (*last >> GT_MEOPS_STEPS_BITS ==
        *next >> GT_MEOPS_STEPS_BITS) {
      stepssum += *next & GT_MEOPS_STEPS_MASK;
      last--;
      next--;
    }
    else {
      switch (*last >> GT_MEOPS_STEPS_BITS) {
        case GT_MEOPS_MATCH:
          gt_xfputc('M', fp);
          break;
        case GT_MEOPS_MIS:
          gt_xfputc('R', fp);
          break;
        case GT_MEOPS_INS:
          gt_xfputc('I', fp);
          break;
        case GT_MEOPS_DEL:
          gt_xfputc('D', fp);
          break;
      }
      fprintf(fp, " %u, ", (unsigned int) stepssum);
      last--;
      stepssum = (GtUword) (*last & GT_MEOPS_STEPS_MASK);
      next = last - 1;
    }
    gt_assert(next + 1 == last);
  }
  gt_assert(num == 0 || last == space);
  switch (*last >> GT_MEOPS_STEPS_BITS) {
    case GT_MEOPS_MATCH:
      gt_xfputc('M', fp);
      break;
    case GT_MEOPS_MIS:
      gt_xfputc('R', fp);
      break;
    case GT_MEOPS_INS:
      gt_xfputc('I', fp);
      break;
    case GT_MEOPS_DEL:
      gt_xfputc('D', fp);
      break;
  }
  fprintf(fp, " %u", (unsigned int) stepssum);
  gt_xfputs("]\n", fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18(%rdi), %r14
testq %r14, %r14
je 0x16223a
movq 0x8(%rdi), %r12
movl $0x5b, %edi
movq %rbx, %rsi
callq 0x11f81a
leaq (%r12,%r14), %rbp
decq %rbp
leaq (%r12,%r14), %rax
addq $-0x2, %rax
movzbl 0x1(%rax), %r14d
andl $0x3f, %r14d
leaq 0x22b174(%rip), %r13    # 0x38d30c
leaq 0x22ab6e(%rip), %r15    # 0x38cd0d
cmpq %r12, %rax
jb 0x162203
movzbl (%rbp), %edx
shrl $0x6, %edx
movzbl (%rax), %ecx
movl %ecx, %esi
shrl $0x6, %esi
cmpl %edx, %esi
jne 0x1621c5
andl $0x3f, %ecx
addq %rcx, %r14
decq %rbp
decq %rax
jmp 0x1621f5
movl (%r13,%rdx,4), %edi
movq %rbx, %rsi
callq 0x11f81a
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
xorl %eax, %eax
callq 0x17ab0
movzbl -0x1(%rbp), %r14d
movq %rbp, %rax
decq %rbp
andl $0x3f, %r14d
addq $-0x2, %rax
leaq 0x1(%rax), %rcx
cmpq %rbp, %rcx
je 0x16219f
callq 0x4d982
cmpq %r12, %rbp
jne 0x162257
movzbl (%r12), %eax
shrl $0x6, %eax
movl (%r13,%rax,4), %edi
movq %rbx, %rsi
callq 0x11f81a
leaq 0x21a6bf(%rip), %rsi    # 0x37c8e3
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x17ab0
leaq 0x2190fe(%rip), %rdi    # 0x37b336
jmp 0x162241
leaq 0x22aab3(%rip), %rdi    # 0x38ccf4
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11f82c
callq 0x4d9bb
// File: /workspace/github_c_makefile_star2_O3/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 0x1622b4
movq %rsi, %r14
testq %rsi, %rsi
je 0x1622b4
movq 0x18(%r14), %r12
testq %r12, %r12
je 0x1622aa
movl %edx, %ebx
movq %rdi, %r15
decq %r12
xorl %r13d, %r13d
testb %bl, %bl
movq %r12, %rsi
cmovneq %r13, %rsi
movq %r14, %rdi
callq 0x16210e
movq %r15, %rdi
movl %eax, %esi
callq 0x161ecf
incq %r13
addq $-0x1, %r12
jb 0x162286
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x4d9f4
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
testq %rdi, %rdi
je 0x1622f9
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
movl $0x8, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x156cc4
testl %eax, %eax
je 0x162350
movq 0x8(%rbx), %rdi
jmp 0x162385
leaq 0x22a868(%rip), %rdx    # 0x38cb68
movl $0x1, %edi
movl $0x20, %esi
movl $0x193, %ecx            # imm = 0x193
callq 0x10436a
movq %rax, %rbx
leaq 0x8(%rax), %r13
leaq 0x18(%rax), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movl $0x8, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x156d03
testl %eax, %eax
je 0x16239b
movq (%r13), %rdi
jmp 0x1623cc
movq (%r12), %rax
testq %rax, %rax
je 0x1623fb
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
jne 0x162385
movq %rax, 0x10(%rbx)
leaq 0x22a7f7(%rip), %rsi    # 0x38cb68
movq %rax, %rdi
movl $0x181, %edx            # imm = 0x181
callq 0x104226
movq %rax, %rdi
movq %rax, 0x8(%rbx)
movq (%r12), %rdx
movl $0x1, %esi
movq %r15, %rcx
movq %r14, %r8
callq 0x156cc4
jmp 0x1623e0
movq (%r12), %rax
testq %rax, %rax
je 0x162400
movq (%r13), %rdi
testq %rdi, %rdi
jne 0x1623cc
movq %rax, 0x10(%rbx)
leaq 0x22a7b0(%rip), %rsi    # 0x38cb68
movq %rax, %rdi
movl $0x181, %edx            # imm = 0x181
callq 0x104226
movq %rax, %rdi
movq %rax, 0x8(%rbx)
movq (%r12), %rdx
movl $0x1, %esi
movq %r15, %rcx
movq %r14, %r8
callq 0x156d03
testl %eax, %eax
je 0x1623ee
movq %rbx, %rdi
callq 0x161e59
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x4da2d
callq 0x4da66
// File: /workspace/github_c_makefile_star2_O3/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
leaq 0x22a755(%rip), %rsi    # 0x38cb68
movl $0x20, %edi
movl $0x2a, %edx
callq 0x104226
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movl $0x4, %ebp
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x161ecf
decl %ebp
jne 0x162434
movl $0x1, %edx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x161ecf
movl $0x18, %ebp
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x161ecf
decl %ebp
jne 0x16245e
movq %rbx, %rdi
callq 0x1620d5
xorl %ebp, %ebp
cmpq $0x1d, %rax
je 0x1624b2
leaq 0x1fbfb6(%rip), %rsi    # 0x35e43e
leaq 0x22a8f5(%rip), %rdx    # 0x38cd84
leaq 0x22a915(%rip), %rcx    # 0x38cdab
leaq 0x22a6cb(%rip), %r8     # 0x38cb68
movq %r14, %rdi
movl $0x1ab, %r9d            # imm = 0x1AB
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x1620d5
leaq 0x24dfd3(%rip), %rdi    # 0x3b0494
movq %rax, %rsi
xorl %eax, %eax
callq 0x103d72
movq %rbx, %rdi
callq 0x161e59
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd11be
leal -0x1(%rax), %edi
callq 0x105d85
movzbl %al, %esi
movq %rbx, %rdi
callq 0xd187b
movl %eax, %ebx
testl %ebp, %ebp
je 0x162d1c
callq 0x170d0
jmp 0x162d21
callq 0x17110
movsbq %bl, %rcx
movq (%rax), %rax
movb (%rax,%rcx,4), %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xe252f
cmpq $0x0, 0x35b4ba(%rip)    # 0x4be7f8
jne 0x16335f
leaq 0x26(%rip), %rsi        # 0x16336d
leaq 0x49(%rip), %rdx        # 0x163397
movl $0x20, %edi
callq 0x162d34
movq %rax, 0x35b499(%rip)    # 0x4be7f8
callq 0xe2545
movq 0x35b48d(%rip), %rax    # 0x4be7f8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1633b8
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x163418
callq 0x163330
movq %rax, %rdi
movq %r15, %rsi
callq 0x162ff7
movq %rax, %r15
movq 0x10(%rax), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x162e68
testl %eax, %eax
je 0x1633fc
movl %eax, %ebp
movq (%rbx), %rdi
callq 0x1451a0
movq $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 0x1633ef
movq 0x18(%r15), %rsi
movq %r14, %rdx
callq 0x14472c
testl %eax, %eax
jne 0x1633de
jmp 0x1633ef
callq 0x4e189
// File: /workspace/github_c_makefile_star2_O3/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 0x163330
movq %rax, %rdi
xorl %esi, %esi
callq 0x162d6c
movq %rax, %rbx
callq 0x163330
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162ff7
movq %rax, %rbp
movq %r15, %rdi
callq 0x162dd8
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 0x163a56
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_O3/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 0xe252f
cmpq $0x0, 0x35b352(%rip)    # 0x4be800
jne 0x1634da
movq $0x0, (%rsp)
leaq 0x29(%rip), %rcx        # 0x1634e8
movl $0x30, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x163010
movq %rax, 0x35b326(%rip)    # 0x4be800
callq 0xe2545
movq 0x35b31a(%rip), %rax    # 0x4be800
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1634a0
movq %rax, %rdi
callq 0x163080
movq %rax, %r13
callq 0x1634a0
movq %rax, %rdi
movq %r13, %rsi
callq 0x1630b1
testq %rax, %rax
je 0x163ab8
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
callq 0x4e3c1
// File: /workspace/github_c_makefile_star2_O3/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, %r15d
movl %edx, %ebp
movl 0x80(%rsp), %ebx
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
movq %rax, %rdi
callq 0x112233
cmpq %rbx, %rax
jb 0x163c87
movl 0x88(%rsp), %ebx
leaq 0x8(%rsp), %rdi
callq 0x112233
movl %ebx, %ecx
cmpq %rcx, %rax
ja 0x163c87
movq 0x8(%rsp), %rbx
testl %r15d, %r15d
je 0x163b30
movq %r12, %rax
subq 0x10(%rsp), %rax
subq %rbx, %r12
movq %rax, %rbx
jmp 0x163b38
addq %r12, %rbx
addq 0x10(%rsp), %r12
movq %rbx, 0x8(%rsp)
movq %r12, 0x10(%rsp)
leaq 0x229d6a(%rip), %rdi    # 0x38d8b3
callq 0x11acc9
movq %rax, 0x18(%rsp)
movq %r14, %rdi
callq 0x1424d6
cmpl $0x1, %eax
jne 0x163b6b
movl %r15d, %edi
callq 0x11c1f0
movl %eax, %r15d
incq %rbx
movq %rbx, 0x20(%rsp)
incq %r12
movq %r12, 0x28(%rsp)
leaq 0x266408(%rip), %rsi    # 0x3c9f8a
leaq 0x1(%rsp), %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x17130
movq %r14, 0x30(%rsp)
movq %r14, %rdi
callq 0x143f54
movq %rax, %r12
movq %rax, %rdi
callq 0x1440ea
testq %rax, %rax
je 0x163c75
movq %rax, %r14
movl %r15d, 0x4(%rsp)
xorl %r13d, %r13d
leaq 0x229ccf(%rip), %rbp    # 0x38d892
leaq 0x38(%rsp), %r15
leaq 0x20(%rsp), %rbx
movq %r14, %rdi
callq 0x142988
movq %rax, %rdi
movq %rbp, %rsi
callq 0x17a40
testl %eax, %eax
je 0x163c07
movq %r14, %rdi
callq 0x144679
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1122f5
testb %al, %al
cmovneq %r14, %r13
movq %r12, %rdi
callq 0x1440ea
movq %rax, %r14
testq %rax, %rax
jne 0x163bcd
testq %r13, %r13
movl 0x4(%rsp), %ebx
je 0x163c75
movq 0x30(%rsp), %rdi
callq 0x144635
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
leaq 0x229c57(%rip), %rsi    # 0x38d892
movq %rax, %rdi
movl %ebx, %r8d
callq 0x1422f4
movq %rax, %rbx
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x141fb5
leaq 0x27839e(%rip), %rsi    # 0x3dbffb
leaq 0x1(%rsp), %rdx
movq %rbx, %rdi
callq 0x142a0f
movq %r13, %rdi
movq %rbx, %rsi
callq 0x14275f
movq 0x18(%rsp), %rdi
callq 0x11bdbf
movq %r12, %rdi
callq 0x14417c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x163cec
movq %rsi, %rbx
testq %rsi, %rsi
je 0x163cec
movq %rdi, %r14
leaq 0x229c31(%rip), %rsi    # 0x38d8e4
movl $0x30, %edi
movl $0x27, %edx
callq 0x104226
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x10(%rax)
movq $-0x1, 0x20(%rax)
movw $0x0, 0x28(%rax)
movb $0x0, 0x2a(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x4e3fa
// File: /workspace/github_c_makefile_star2_O3/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 0x163daa
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 0x11ea96
cmpl $-0x3, %eax
ja 0x163d9b
movzbl 0x3(%rsp), %eax
cmpl $0x2a, %eax
je 0x163d69
cmpl $0x4d, %eax
jne 0x163d1b
movl 0x4(%rsp), %eax
cmpb $0x0, 0x28(%r14,%rax)
jne 0x163d1b
movq (%r14), %rdi
callq 0xe2643
decq %rax
movl 0x4(%rsp), %ecx
movq %rax, 0x10(%r14,%rcx,8)
movb $0x1, 0x28(%r14,%rcx)
jmp 0x163d1b
movl 0x4(%rsp), %eax
cmpb $0x1, 0x28(%r14,%rax)
jne 0x163d1b
movq 0x10(%r14,%rax,8), %rax
movq %rax, (%r15)
movq (%r14), %rdi
callq 0xe2643
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
callq 0x4e431
// File: /workspace/github_c_makefile_star2_O3/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 0x164277
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xe3bf1
movq 0x10(%rbx), %rdi
callq 0xe3bf1
movq 0x18(%rbx), %rdi
callq 0xe3bf1
movq (%rbx), %rdi
leaq 0x229809(%rip), %r14    # 0x38da5c
movq %r14, %rsi
movl $0x99, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x9a, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x164305
movq %rdx, %rbx
testl %esi, %esi
je 0x1642c1
movq %rdi, %r14
cmpl %esi, %eax
jbe 0x1642d4
movq 0x10(%r14), %rdi
movl %esi, %r15d
leaq 0x1(%r15), %rsi
callq 0xe3c2c
movq %rax, %r12
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0xe3c2c
subq %rax, %r12
cmpq %rbx, %r12
ja 0x1642dc
callq 0x4e694
testq %rbx, %rbx
jne 0x16430a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testq %rbx, %rbx
jne 0x16430f
movl %esi, %r15d
movq 0x8(%r14), %r12
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0xe3c2c
addq %rax, %rbx
movq %r12, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe3c2c
callq 0x4e706
callq 0x4e6cd
callq 0x4e65b
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %edi
shlq %cl, %rdi
movl %ecx, %esi
callq 0xe3bc2
leaq (%rax,%rbx,8), %rax
addq $0x30, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x16442c
movl %esi, %ebx
movq %rdi, %r14
movl 0x28(%rdi), %edi
cmpl %esi, %edi
jb 0x164431
movq (%r14), %rax
testq %rax, %rax
jne 0x164418
incq %rdi
leaq 0x229683(%rip), %rdx    # 0x38da5c
movl $0x4, %esi
movl $0xf9, %ecx
callq 0x10436a
movq %rax, %r15
movq %rax, (%r14)
movl 0x28(%r14), %r12d
xorl %ebp, %ebp
movl %ebp, %r13d
movq %r12, %rdi
movq %r13, %rsi
callq 0xe38db
movq %rax, %rdi
callq 0x105e91
movl %eax, (%r15,%r13,4)
incl %ebp
cmpl %r12d, %ebp
jbe 0x1643f4
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
callq 0x4e7ea
callq 0x4e7b1