LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/maxcoordvalue.c
// Function: gt_maxcoordvalue_coord_update
void gt_maxcoordvalue_coord_update(GtMaxcoordvalue *max,
                                   GtWord value,
                                   GtUwordPair start,
                                   GtUword enda, GtUword endb)
{
  gt_assert(max != NULL);

  gt_maxcoordvalue_set_value(max, value);
  gt_maxcoordvalue_set_start_with_pair(max, start);
  gt_maxcoordvalue_set_end(max, enda, endb);
}

// Assembly:
testq %rdi, %rdi
je 0x16840f
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movq %r8, 0x18(%rdi)
movq %r9, 0x20(%rdi)
retq
pushq %rax
callq 0x4da57
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/maxcoordvalue.c
// Function: gt_maxcoordvalue_get_row_length
GtUword gt_maxcoordvalue_get_row_length(const GtMaxcoordvalue *max)
{
  gt_assert(max != NULL);

  GtUword end = (gt_maxcoordvalue_get_end(max)).a;
  GtUword start = (gt_maxcoordvalue_get_start(max)).a;

  gt_assert(end >= start);
  return end-start;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x16843e
movq 0x18(%rdi), %rax
subq 0x8(%rdi), %rax
jb 0x168443
popq %rcx
retq
callq 0x4dafe
callq 0x4dac5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/maxcoordvalue.c
// Function: gt_maxcoordvalue_get_col_length
GtUword gt_maxcoordvalue_get_col_length(const GtMaxcoordvalue *max)
{
  gt_assert(max != NULL);

  GtUword end = (gt_maxcoordvalue_get_end(max)).b;
  GtUword start = (gt_maxcoordvalue_get_start(max)).b;

  gt_assert(end >= start);
  return end-start;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x16845a
movq 0x20(%rdi), %rax
subq 0x10(%rdi), %rax
jb 0x16845f
popq %rcx
retq
callq 0x4db70
callq 0x4db37
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/maxcoordvalue.c
// Function: gt_maxcoordvalue_get_length_safe
bool gt_maxcoordvalue_get_length_safe(const GtMaxcoordvalue *max)
{
  if (gt_maxcoordvalue_get_end(max).a == gt_maxcoordvalue_get_start(max).a &&
      gt_maxcoordvalue_get_end(max).b == gt_maxcoordvalue_get_start(max).b  )
    return false;
  return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1683e2
movq %rax, %r14
movq %rbx, %rdi
callq 0x1683ba
cmpq %rax, %r14
jne 0x16849c
movq %rbx, %rdi
callq 0x1683e2
movq %rdx, %r14
movq %rbx, %rdi
callq 0x1683ba
cmpq %rdx, %r14
jne 0x16849c
xorl %eax, %eax
jmp 0x16849e
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/md5_to_id_visitor.c
// Function: gt_md5_to_id_visitor_class
const GtNodeVisitorClass* gt_md5_to_id_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtMD5ToSeqidsVisitor),
                                    md5_to_id_visitor_free,
                                    NULL,
                                    md5_to_id_visitor_feature_node,
                                    md5_to_id_visitor_region_node,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x3612da(%rip)    # 0x4c97d0
jne 0x16852b
movq $0x0, (%rsp)
leaq 0x32(%rip), %rsi        # 0x168539
leaq 0x53(%rip), %rcx        # 0x168561
leaq 0x97(%rip), %r8         # 0x1685ac
movl $0x18, %edi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0x16ae80
movq %rax, 0x3612a5(%rip)    # 0x4c97d0
callq 0xe6a19
movq 0x361299(%rip), %rax    # 0x4c97d0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/md5_to_id_visitor.c
// Function: md5_to_id_visitor_free
static void md5_to_id_visitor_free(GtNodeVisitor *nv)
{
  GtMD5ToSeqidsVisitor *md5_to_id_visitor =
    md5_to_id_visitor_cast(nv);
  gt_assert(md5_to_id_visitor);
  gt_region_mapping_delete(md5_to_id_visitor->region_mapping);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1684e8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
testq %rax, %rax
je 0x16855c
movq 0x10(%rax), %rdi
popq %rbx
jmp 0x1758da
callq 0x4dc19
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/md5_to_id_visitor.c
// Function: gt_md5_to_id_visitor_new
GtNodeVisitor* gt_md5_to_id_visitor_new(GtRegionMapping *region_mapping)
{
  GtNodeVisitor *nv;
  GtMD5ToSeqidsVisitor *md5_to_id_visitor;
  nv = gt_node_visitor_create(gt_md5_to_id_visitor_class());
  md5_to_id_visitor = md5_to_id_visitor_cast(nv);
  md5_to_id_visitor->region_mapping = region_mapping;
  return nv;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1684e8
movq %rax, %rdi
callq 0x16aef0
movq %rax, %r14
callq 0x1684e8
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq %rbx, 0x10(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/md5_to_id_visitor.c
// Function: md5_to_seqid
static int md5_to_seqid(GtGenomeNode *gn, GtRegionMapping *region_mapping,
                        GtError *err)
{
  GtStr *seqid;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(gn);
  seqid = gt_genome_node_get_seqid(gn);
  if (gt_md5_seqid_has_prefix(gt_str_get(seqid))) {
    GtStr *new_seqid = gt_str_new();
    /* seqid is a MD5 seqid -> change id */
    if (gt_str_length(seqid) > GT_MD5_SEQID_TOTAL_LEN)
      gt_str_append_cstr(new_seqid, gt_str_get(seqid) + GT_MD5_SEQID_TOTAL_LEN);
    else {
      /* for backward compatibility */
      GtStr *desc = gt_str_new();
      if (!region_mapping) {
        gt_error_set(err, "no region mapping defined");
        had_err = -1;
      }
      if (!had_err) {
        had_err = gt_region_mapping_get_description(region_mapping, desc, seqid,
                                                    err);
      }
      if (!had_err)
        gt_regular_seqid_save(new_seqid, desc);
      gt_str_delete(desc);
    }
    if (!had_err) {
      if (gt_feature_node_try_cast(gn)) {
        M2IChangeSeqidInfo info;
        info.new_seqid = new_seqid;
        info.region_mapping = region_mapping;
        had_err = gt_feature_node_traverse_children((GtFeatureNode*) gn, &info,
                                                    m2i_change_seqid, true,
                                                    err);
      }
      else
        gt_genome_node_change_seqid(gn, new_seqid);
    }
    gt_str_delete(new_seqid);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdx, %rdx
je 0x168656
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x16876c
testq %r14, %r14
je 0x168767
movq %r14, %rdi
callq 0x14b89b
movq %rax, %r13
movq %rax, %rdi
callq 0x120d23
movq %rax, %rdi
callq 0x10ba1c
xorl %ebp, %ebp
testb %al, %al
je 0x168756
callq 0x1208f8
movq %rax, %r12
movq %r13, %rdi
callq 0x120d4c
cmpq $0x26, %rax
jb 0x1686b2
movq %r13, %rdi
callq 0x120d23
leaq 0x25(%rax), %rsi
movq %r12, %rdi
callq 0x12097f
xorl %ebp, %ebp
jmp 0x168709
callq 0x1208f8
movq %r15, %rdi
movq %rax, %r15
testq %rdi, %rdi
movq %rdi, (%rsp)
je 0x1686d8
movq %r15, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x176433
movl %eax, %ebp
jmp 0x1686ee
leaq 0x2286e2(%rip), %rsi    # 0x390dc1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %ebp, %ebp
jne 0x1686fd
movq %r12, %rdi
movq %r15, %rsi
callq 0x177174
movq %r15, %rdi
callq 0x121b03
movq (%rsp), %r15
testl %ebp, %ebp
jne 0x16874e
movq %r14, %rdi
callq 0x14aefc
testq %rax, %rax
je 0x168741
leaq 0x8(%rsp), %rsi
movq %r12, (%rsi)
movq %r15, 0x8(%rsi)
leaq 0x44(%rip), %rdx        # 0x168771
movq %r14, %rdi
movl $0x1, %ecx
movq %rbx, %r8
callq 0x149fca
movl %eax, %ebp
jmp 0x16874e
movq %r14, %rdi
movq %r12, %rsi
callq 0x14b96f
xorl %ebp, %ebp
movq %r12, %rdi
callq 0x121b03
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4dcf9
callq 0x4dcc2
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/md5set.c
// Function: gt_md5set_new
GtMD5Set *gt_md5set_new(GtUword nof_elements)
{
  GtMD5Set *md5set;
  md5set = gt_malloc(sizeof (GtMD5Set));
  md5set->fill = 0;
  md5set->alloc = 0;
  md5set->table = NULL;
  md5set_alloc_table(md5set,
                     md5set_get_size(nof_elements + (nof_elements >> 2)));
  gt_assert(nof_elements < md5set->maxfill);
  md5set->buffer = NULL;
  md5set->bufsize = 0;
  return md5set;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x228441(%rip), %rsi    # 0x390e23
movl $0x30, %edi
movl $0xc7, %edx
callq 0x1092b2
movq %rax, %rbx
movq %r14, %rdi
shrq $0x2, %rdi
addq %r14, %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
callq 0x168b3e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x168a39
cmpq %r14, 0x18(%rbx)
jbe 0x168a34
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x4ddd7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/md5set.c
// Function: md5set_alloc_table
static void md5set_alloc_table(GtMD5Set *set, GtUword newsize)
{
  md5_t *oldtable;
  GtUword oldsize;

  oldsize = set->alloc;
  oldtable = set->table;
  set->alloc = newsize;
  set->maxfill =
    (GtUword)((double)newsize * MD5SET_MAX_LOAD_FACTOR);
  set->table = gt_calloc((size_t)newsize, sizeof (md5_t));
  if (oldtable != NULL) {
    gt_log_log("rehashing " GT_WU " elements; old size: " GT_WU ", new size: "
               GT_WU "\n", set->fill, oldsize, newsize);
    md5set_rehash(set, oldtable, oldsize);
    gt_free(oldtable);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rbx
movq %rsi, %xmm0
punpckldq 0x1e7e89(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
movq 0x8(%rdi), %r15
subpd 0x1e7e8d(%rip), %xmm0   # 0x3508f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x1ee781(%rip), %xmm1   # 0x3571f8
movq %rsi, 0x8(%rdi)
cvttsd2si %xmm1, %rax
movq %rax, %rcx
subsd 0x1e8295(%rip), %xmm1   # 0x350d20
cvttsd2si %xmm1, %rdx
sarq $0x3f, %rcx
andq %rcx, %rdx
orq %rax, %rdx
movq %rdx, 0x18(%rdi)
leaq 0x22837e(%rip), %rdx    # 0x390e23
movl $0x10, %esi
movq %r12, %rdi
movl $0xbb, %ecx
callq 0x1093ef
movq %rax, (%r14)
testq %rbx, %rbx
je 0x168b32
movq 0x10(%r14), %rsi
leaq 0x2283d1(%rip), %rdi    # 0x390e9b
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x108e02
movq $0x0, 0x10(%r14)
testq %r15, %r15
je 0x168b13
leaq 0x8(%rbx), %r12
movq -0x8(%r12), %rsi
testq %rsi, %rsi
jne 0x168af9
cmpq $0x0, (%r12)
je 0x168b0a
movq (%r12), %rdx
movq %r14, %rdi
movl $0x1, %ecx
callq 0x168dab
addq $0x10, %r12
decq %r15
jne 0x168ae8
leaq 0x228309(%rip), %rsi    # 0x390e23
movq %rbx, %rdi
movl $0xc0, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x109670
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/md5set.c
// Function: md5set_get_size
static GtUword md5set_get_size(GtUword n)
{
  GtUint64 u, l, i, k, k_i;

  k = (GtUint64)n;
  if (k > GT_MD5SET_LARGEST_PRIME) {
    fprintf(stderr, MD5SET_TOO_LARGE, k);
    exit(1);
  }
  if (k < gt_md5set_primes[0])
    return (GtUword)gt_md5set_primes[0];
  l = 0;
  u = GT_MD5SET_NOFPRIMES - 1;
  do {
    i = (l + u) >> 1;
    gt_assert(u >= l);
    if (u - l == 1) {
      return (gt_md5set_primes[l] == k)
          ? (GtUword)k
          : (GtUword)gt_md5set_primes[u];
    }
    k_i = gt_md5set_primes[i];
    if (k < k_i) {
      u = i;
    }
    else if (k > k_i) {
      l = i;
    }
    else {
      return (GtUword)k_i;
    }
  } while (1);
  return 0;
}

// Assembly:
pushq %rax
movabsq $0x7fc0002764, %rax     # imm = 0x7FC0002764
cmpq %rax, %rdi
jae 0x168baf
movl $0x100007, %eax         # imm = 0x100007
cmpq $0x100007, %rdi         # imm = 0x100007
jb 0x168bad
movl $0x97f, %ecx            # imm = 0x97F
movl $0x4bf, %r8d            # imm = 0x4BF
xorl %esi, %esi
leaq 0x228450(%rip), %rdx    # 0x390fc0
movq %rcx, %rax
subq %rsi, %rax
cmpq $0x1, %rax
je 0x168ba0
movq (%rdx,%r8,8), %rax
cmpq %rdi, %rax
jbe 0x168b8a
movq %r8, %rcx
jmp 0x168b8f
movq %r8, %rsi
jae 0x168bad
leaq (%rcx,%rsi), %r8
shrq %r8
cmpq %rsi, %rcx
jae 0x168b70
callq 0x4de10
movq %rdi, %rax
cmpq %rdi, (%rdx,%rsi,8)
je 0x168bad
movq (%rdx,%rcx,8), %rax
popq %rcx
retq
callq 0x4de47
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/md5set.c
// Function: gt_md5set_delete
void gt_md5set_delete(GtMD5Set *set)
{
  if (set != NULL) {
    gt_free(set->table);
    gt_free(set->buffer);
    gt_free(set);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x168bff
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x228259(%rip), %r14    # 0x390e23
movq %r14, %rsi
movl $0xd6, %edx
callq 0x109670
movq 0x20(%rbx), %rdi
movq %r14, %rsi
movl $0xd7, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0xd8, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/md5set.c
// Function: md5set_search
static bool md5set_search(GtMD5Set *set, md5_t k, bool insert_if_not_found)
{
  GtUword i, c;
#ifndef NDEBUG
  GtUword first_i;
#endif
  enum MD5SetSearchResult retval;

  i = (GtUword) MD5SET_H1(k, set->alloc);
  retval = md5set_search_pos(set, k, insert_if_not_found, i);
  if (retval != GT_MD5SET_COLLISION)
    return retval == GT_MD5SET_EMPTY ? false : true;

  /* open addressing by double hashing */
  c = (GtUword) MD5SET_H2(k, set->alloc);
  gt_assert(c > 0);
#ifndef NDEBUG
  first_i = i;
#endif
  while (1) {
    i = (i + c) % set->alloc;
    gt_assert(i != first_i);
    retval = md5set_search_pos(set, k, insert_if_not_found, i);
    if (retval != GT_MD5SET_COLLISION)
      return retval == GT_MD5SET_EMPTY ? false : true;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r8
movq %rsi, %r9
movq %rdi, %r12
movq (%rdi), %rsi
movq 0x8(%rdi), %rdi
movq %r9, %rax
xorl %edx, %edx
divq %rdi
movq %rdx, %rbx
movq %rdx, %r13
shlq $0x4, %r13
movq (%rsi,%r13), %rax
addq %r13, %rsi
testq %rax, %rax
jne 0x168df2
cmpq $0x0, 0x8(%rsi)
je 0x168f0d
movl $0x2, %r14d
cmpq %r9, %rax
jne 0x168e0b
xorl %r14d, %r14d
cmpq %r8, 0x8(%rsi)
setne %r14b
incl %r14d
cmpl $0x2, %r14d
jne 0x168ef8
movq 0x8(%r12), %rsi
decq %rsi
movq %r8, %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %rbp
incq %rbp
je 0x168f7b
movq %rbx, %r13
movl %ecx, 0x4(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
addq %rbp, %r13
movq 0x8(%r12), %rdi
movq %r13, %rax
xorl %edx, %edx
divq %rdi
cmpq %rbx, %rdx
je 0x168f71
movq %rdx, %r13
movq (%r12), %rax
movq %rdx, %r15
shlq $0x4, %r15
movq (%rax,%r15), %rdx
addq %r15, %rax
testq %rdx, %rdx
jne 0x168e7c
cmpq $0x0, 0x8(%rax)
je 0x168e9d
movl $0x2, %r14d
cmpq %r9, %rdx
jne 0x168e95
xorl %r14d, %r14d
cmpq %r8, 0x8(%rax)
setne %r14b
incl %r14d
cmpl $0x2, %r14d
je 0x168e42
jmp 0x168ef8
xorl %r14d, %r14d
testb %cl, %cl
je 0x168e95
movq 0x10(%r12), %rax
incq %rax
movq %rax, 0x10(%r12)
cmpq 0x18(%r12), %rax
jbe 0x168ed9
incq %rdi
callq 0x168b3e
movq %r12, %rdi
movq %rax, %rsi
callq 0x168a39
movq 0x8(%rsp), %r9
movq 0x10(%rsp), %r8
movl 0x4(%rsp), %ecx
movq 0x10(%r12), %rax
cmpq 0x18(%r12), %rax
ja 0x168f76
movq (%r12), %rax
movq %r9, (%rax,%r15)
movq %r8, 0x8(%rax,%r15)
jmp 0x168e95
testl %r14d, %r14d
setne %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
testb %cl, %cl
je 0x168e0b
movq 0x10(%r12), %rax
incq %rax
movq %rax, 0x10(%r12)
cmpq 0x18(%r12), %rax
jbe 0x168f53
incq %rdi
movl %ecx, 0x4(%rsp)
movq %r8, %r15
movq %r9, %rbp
callq 0x168b3e
movq %r12, %rdi
movq %rax, %rsi
callq 0x168a39
movq %rbp, %r9
movq %r15, %r8
movl 0x4(%rsp), %ecx
movq 0x10(%r12), %rax
cmpq 0x18(%r12), %rax
ja 0x168f80
movq (%r12), %rax
movq %r9, (%rax,%r13)
movq %r8, 0x8(%rax,%r13)
jmp 0x168e0b
callq 0x4df4d
callq 0x4df16
callq 0x4df86
callq 0x4dfbf
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0xe6a03
cmpq $0x0, 0x36082a(%rip)    # 0x4c97d8
jne 0x168fdf
movq $0x0, (%rsp)
leaq 0x2e(%rip), %rsi        # 0x168fed
leaq 0x5b(%rip), %rcx        # 0x169021
movl $0x28, %edi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x16ae80
movq %rax, 0x3607f9(%rip)    # 0x4c97d8
callq 0xe6a19
movq 0x3607ed(%rip), %rax    # 0x4c97d8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x168fa0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
testq %rax, %rax
je 0x16901c
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0x105f7d
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0xd4ef4
callq 0x4dff6
// File: /workspace/github_c_makefile_star2_O1/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 0x169042
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0x1690c1
callq 0x168fa0
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq %rax, %r14
movq 0x20(%rax), %rdi
callq 0xd4ad3
leaq 0xb3(%rip), %rdx        # 0x169118
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
movq %r15, %r8
callq 0x149fca
movl %eax, %ebp
testl %eax, %eax
jne 0x1690b4
movq 0x20(%r14), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x1690b4
xorl %r15d, %r15d
movq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0xd47ba
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x14ac1c
incq %r15
movq 0x20(%r14), %rdi
callq 0xd4a9a
cmpq %rax, %r15
jb 0x16908c
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x4e02d
// File: /workspace/github_c_makefile_star2_O1/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 0x168fa0
movq %rax, %rdi
callq 0x16aef0
movq %rax, %rbx
callq 0x168fa0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
movq %rax, %r14
movl $0x1, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x105830
movq %rax, 0x18(%r14)
movl $0x8, %edi
callq 0xd46fc
movq %rax, 0x20(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x169137
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x169168
testq %r15, %r15
je 0x169163
movq %r15, 0x10(%r14)
movq 0x18(%r14), %rdi
callq 0x105b51
leaq 0x1d(%rip), %rdx        # 0x16916d
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x14aaf6
callq 0x4e09b
callq 0x4e064
// File: /workspace/github_c_makefile_star2_O1/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 0xe6a03
cmpq $0x0, 0x36050e(%rip)    # 0x4c97e0
jne 0x1692f3
leaq 0x26(%rip), %rsi        # 0x169301
leaq 0xb5(%rip), %rdx        # 0x169397
movl $0x40, %edi
callq 0x16abb4
movq %rax, 0x3604ed(%rip)    # 0x4c97e0
callq 0xe6a19
movq 0x3604e1(%rip), %rax    # 0x4c97e0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1692c4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movq %rax, %rbx
movq 0x10(%rax), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x16936b
xorl %r15d, %r15d
xorl %r14d, %r14d
movq 0x28(%rbx), %rax
movq (%rax,%r15), %rdi
testq %rdi, %rdi
je 0x169342
callq 0x14c43a
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %rdi
callq 0x16ac6e
incq %r14
movq 0x10(%rbx), %rdi
callq 0xd4a9a
addq $0x10, %r15
cmpq %rax, %r14
jb 0x169330
movq 0x10(%rbx), %rdi
callq 0xd4ef4
movq 0x28(%rbx), %rdi
leaq 0x22c9a6(%rip), %rsi    # 0x395d25
movl $0xbb, %edx
callq 0x109670
movq 0x30(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x16cfc9
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x1693c0
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x1694ba
callq 0x1692c4
movq %rax, %rdi
movq %r15, %rsi
callq 0x16ae64
cmpq $0x0, 0x20(%rax)
jne 0x1694b5
movq %rax, %r12
leaq 0x18(%rax), %r13
cmpq $0x0, 0x18(%rax)
je 0x169458
cmpq $0x0, (%r13)
je 0x169453
addq $0x20, %r12
cmpq $0x0, (%r12)
jne 0x169453
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x169633
testl %eax, %eax
jne 0x16947b
movq (%r12), %rsi
xorl %ebp, %ebp
testq %rsi, %rsi
je 0x16947d
movq (%r13), %rdi
testq %rdi, %rdi
je 0x1694b0
callq 0x14bc04
testb %al, %al
je 0x16947d
movq (%r13), %rdi
movq (%r12), %rsi
callq 0x176c2b
movq (%r12), %rdi
callq 0x14c43a
movq $0x0, (%r12)
cmpq $0x0, (%r13)
jne 0x1693f4
callq 0x4e290
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x169633
movl %eax, %ebp
testl %eax, %eax
jne 0x16949f
cmpq $0x0, (%r13)
jne 0x1693e9
xorl %ebp, %ebp
jmp 0x169498
movl %eax, %ebp
testl %ebp, %ebp
jne 0x16949f
movq (%r13), %rax
testq %rax, %rax
je 0x1694bf
movq %rax, (%rbx)
movq (%r12), %rax
movq %rax, (%r13)
movq %r12, %rbx
movq $0x0, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4e220
callq 0x4e1e7
callq 0x4e1ae
callq 0x4e257
// File: /workspace/github_c_makefile_star2_O1/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 0x1692c4
movq %rax, %rdi
movl $0x1, %esi
callq 0x16abec
movq %rax, %rbx
callq 0x1692c4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movq %rax, %r15
movq %r14, %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x169607
movq %r14, %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x169548
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0xd47ba
movq (%rax), %rdi
callq 0x16ae51
testb %al, %al
je 0x169602
incq %r12
movq %r14, %rdi
callq 0xd4a9a
cmpq %rax, %r12
jb 0x16951d
movq %r14, %rdi
callq 0xd4a9a
leaq 0x22c7ce(%rip), %rdx    # 0x395d25
movl $0x10, %esi
movq %rax, %rdi
movl $0xdb, %ecx
callq 0x1093ef
movq %rax, 0x28(%r15)
movl $0x8, %edi
callq 0xd46fc
movq %rax, 0x10(%r15)
movq %r14, %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x1695c9
xorl %r12d, %r12d
leaq 0x8(%rsp), %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0xd47ba
movq (%rax), %rdi
callq 0x16ac58
movq %rax, 0x8(%rsp)
movq 0x10(%r15), %rdi
movl $0x8, %edx
movq %r13, %rsi
callq 0xd49ce
incq %r12
movq %r14, %rdi
callq 0xd4a9a
cmpq %rax, %r12
jb 0x169590
movq %r14, %rdi
callq 0xd4a9a
leaq 0x34(%rip), %rdi        # 0x16960c
movq %rax, %rsi
callq 0x16cd48
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 0x4e2c9
callq 0x4e302
// File: /workspace/github_c_makefile_star2_O1/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 0x16962e
testq %rsi, %rsi
je 0x16962e
cmpq $0x0, (%rdi)
je 0x169629
cmpq $0x0, (%rsi)
je 0x169629
popq %rax
jmp 0x14b9e6
callq 0x4e372
callq 0x4e33b
// File: /workspace/github_c_makefile_star2_O1/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 0x22c382(%rip), %r14    # 0x395f48
movl $0x20, %edi
movq %r14, %rsi
movl $0x33, %edx
callq 0x1092b2
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 0x1093ef
movq %rax, 0x8(%r15)
movq %rbx, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x169ca9
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x169c46
leaq 0x22c31e(%rip), %rsi    # 0x395f48
movl $0x20, %edi
movl $0x2a, %edx
callq 0x1092b2
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq 0x18(%rbx), %rsi
cmpq %rsi, 0x10(%r14)
jae 0x169c71
movq 0x8(%r14), %rdi
leaq 0x22c2ed(%rip), %rdx    # 0x395f48
movl $0x46, %ecx
callq 0x1094e6
movq %rax, 0x8(%r14)
movq 0x18(%rbx), %rax
movq %rax, 0x10(%r14)
movq $0x0, (%r14)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r14)
testq %rax, %rax
je 0x169c9e
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 0x169c87
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x4e5cf
// File: /workspace/github_c_makefile_star2_O1/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 0x169ccf
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x169cd7
decq %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x169d04
leaq 0x8(%rbx), %r14
leaq 0x22c25d(%rip), %rsi    # 0x395f48
movl $0x5e, %edx
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x22c23d(%rip), %rsi    # 0x395f48
movq %rbx, %rdi
movl $0x5f, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x169e15
movq %rdx, %r14
movq %rdi, %rbx
movslq %esi, %rax
leaq 0x22c979(%rip), %rcx    # 0x3966c8
movl (%rcx,%rax,4), %ebp
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x169d8d
testq %r14, %r14
je 0x169d8d
movq 0x8(%rbx), %rcx
movzbl -0x1(%rcx,%rax), %edx
shrl $0x6, %edx
cmpl %edx, %ebp
jne 0x169d8d
movb -0x1(%rcx,%rax), %dl
movl %edx, %esi
notb %sil
testb $0x3f, %sil
je 0x169d8d
incb %dl
movb %dl, -0x1(%rcx,%rax)
decq %r14
jne 0x169d74
xorl %r14d, %r14d
testq %r14, %r14
je 0x169e01
shlb $0x6, %bpl
xorl %r12d, %r12d
movq %r14, %r13
subq $0x3f, %r13
movl $0x3f, %r15d
cmovbq %r14, %r15
cmovbq %r12, %r13
movq 0x10(%rbx), %rsi
cmpq %rsi, 0x18(%rbx)
jb 0x169ddc
addq $0x100, %rsi            # imm = 0x100
movq %rsi, 0x10(%rbx)
movq 0x8(%rbx), %rdi
leaq 0x22c17a(%rip), %rdx    # 0x395f48
movl $0x99, %ecx
callq 0x1094e6
movq %rax, 0x8(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x169e10
orb %bpl, %r15b
movq 0x18(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%rbx)
movb %r15b, (%rax,%rcx)
cmpq $0x3f, %r14
movq %r13, %r14
ja 0x169d9c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4e606
callq 0x4e63f
// File: /workspace/github_c_makefile_star2_O1/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 0x169ea5
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x169ea5
movq 0x8(%rdi), %rcx
movb -0x1(%rcx,%rax), %dl
movl %edx, %esi
andb $0x3f, %sil
cmpb $0x1, %sil
jne 0x169e9e
decq %rax
movq %rax, 0x18(%rdi)
retq
decb %dl
movb %dl, -0x1(%rcx,%rax)
retq
pushq %rax
callq 0x4e6af
// File: /workspace/github_c_makefile_star2_O1/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 0x169eee
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x169eea
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 0x169ec2
jmp 0x169eec
xorl %eax, %eax
popq %rcx
retq
callq 0x4e6e8
// File: /workspace/github_c_makefile_star2_O1/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 0x169f38
movq 0x18(%rdi), %rcx
xorl %edx, %edx
testq %rcx, %rcx
je 0x169f34
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 0x169f0c
jmp 0x169f36
xorl %eax, %eax
popq %rcx
retq
callq 0x4e721
// File: /workspace/github_c_makefile_star2_O1/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 0x169f6c
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x169f68
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 0x169f54
jmp 0x169f6a
xorl %eax, %eax
popq %rcx
retq
callq 0x4e75a
// File: /workspace/github_c_makefile_star2_O1/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 0x16a0aa
testq %rdi, %rdi
je 0x16a0c7
movq 0x8(%rdi), %r12
movl $0x5b, %edi
movq %rbx, %rsi
callq 0x1255d6
leaq (%r12,%r14), %r13
decq %r13
leaq (%r12,%r14), %rax
addq $-0x2, %rax
movzbl 0x1(%rax), %r14d
andl $0x3f, %r14d
leaq 0x22c6e3(%rip), %rbp    # 0x3966ec
leaq 0x22c0dd(%rip), %r15    # 0x3960ed
cmpq %r12, %rax
jb 0x16a074
movzbl (%r13), %edx
shrl $0x6, %edx
movzbl (%rax), %ecx
movl %ecx, %esi
shrl $0x6, %esi
cmpl %edx, %esi
jne 0x16a037
andl $0x3f, %ecx
addq %rcx, %r14
decq %r13
decq %rax
jmp 0x16a066
movl (%rbp,%rdx,4), %edi
movq %rbx, %rsi
callq 0x1255d6
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
xorl %eax, %eax
callq 0x17ab0
movzbl -0x1(%r13), %r14d
movq %r13, %rax
decq %r13
andl $0x3f, %r14d
addq $-0x2, %rax
leaq 0x1(%rax), %rcx
cmpq %r13, %rcx
je 0x16a010
callq 0x4e83e
cmpq %r12, %r13
jne 0x16a0cc
movzbl (%r13), %eax
shrl $0x6, %eax
movl (%rbp,%rax,4), %edi
movq %rbx, %rsi
callq 0x1255d6
leaq 0x21bbbf(%rip), %rsi    # 0x385c53
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x17ab0
leaq 0x21a5f7(%rip), %rdi    # 0x38469f
jmp 0x16a0b1
leaq 0x22c023(%rip), %rdi    # 0x3960d4
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1255e8
callq 0x4e8b0
callq 0x4e877
// File: /workspace/github_c_makefile_star2_O1/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 0x16a129
movq %rsi, %r14
testq %rsi, %rsi
je 0x16a129
movq 0x18(%r14), %r12
testq %r12, %r12
je 0x16a11f
movl %edx, %ebx
movq %rdi, %r15
decq %r12
xorl %r13d, %r13d
testb %bl, %bl
movq %r12, %rsi
cmovneq %r13, %rsi
movq %r14, %rdi
callq 0x169f76
movq %r15, %rdi
movl %eax, %esi
callq 0x169d2b
incq %r13
addq $-0x1, %r12
jb 0x16a0fb
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x4e8e9
// File: /workspace/github_c_makefile_star2_O1/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 0x16a1af
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
movl $0x8, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x15e878
testl %eax, %eax
jne 0x16a192
movq (%r12), %rdi
testq %rdi, %rdi
je 0x16a25c
cmpq $0x0, 0x8(%rbx)
jne 0x16a192
movq %rdi, 0x10(%rbx)
leaq 0x22bdc4(%rip), %rsi    # 0x395f48
movl $0x181, %edx            # imm = 0x181
callq 0x1092b2
movq %rax, 0x8(%rbx)
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rdx
movl $0x1, %esi
movq %r15, %rcx
movq %r14, %r8
callq 0x15e878
jmp 0x16a241
leaq 0x22bd92(%rip), %rdx    # 0x395f48
movl $0x1, %edi
movl $0x20, %esi
movl $0x193, %ecx            # imm = 0x193
callq 0x1093ef
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 0x15e8b7
testl %eax, %eax
jne 0x16a229
movq (%r12), %rdi
testq %rdi, %rdi
je 0x16a261
cmpq $0x0, (%r13)
jne 0x16a229
movq %rdi, 0x10(%rbx)
leaq 0x22bd2d(%rip), %rsi    # 0x395f48
movl $0x181, %edx            # imm = 0x181
callq 0x1092b2
movq %rax, 0x8(%rbx)
movq (%r13), %rdi
movq (%r12), %rdx
movl $0x1, %esi
movq %r15, %rcx
movq %r14, %r8
callq 0x15e8b7
testl %eax, %eax
je 0x16a24f
movq %rbx, %rdi
callq 0x169cb5
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x4e922
callq 0x4e95b
// File: /workspace/github_c_makefile_star2_O1/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 0x22bcd4(%rip), %rsi    # 0x395f48
movl $0x20, %edi
movl $0x2a, %edx
callq 0x1092b2
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 0x169d2b
decl %ebp
jne 0x16a295
movl $0x1, %edx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x169d2b
movl $0x18, %ebp
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x169d2b
decl %ebp
jne 0x16a2bf
movq %rbx, %rdi
callq 0x169f3d
xorl %ebp, %ebp
cmpq $0x1d, %rax
je 0x16a313
leaq 0x1fd251(%rip), %rsi    # 0x36753a
leaq 0x22be74(%rip), %rdx    # 0x396164
leaq 0x22be94(%rip), %rcx    # 0x39618b
leaq 0x22bc4a(%rip), %r8     # 0x395f48
movq %r14, %rdi
movl $0x1ab, %r9d            # imm = 0x1AB
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x169f3d
leaq 0x24f772(%rip), %rdi    # 0x3b9a94
movq %rax, %rsi
xorl %eax, %eax
callq 0x108e02
movq %rbx, %rdi
callq 0x169cb5
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd3713
leal -0x1(%rax), %edi
callq 0x10ae3c
movzbl %al, %esi
movq %rbx, %rdi
callq 0xd3da7
movl %eax, %ebx
testl %ebp, %ebp
je 0x16ab9c
callq 0x170d0
jmp 0x16aba1
callq 0x17110
movsbq %bl, %rcx
movq (%rax), %rax
movb (%rax,%rcx,4), %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop