LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/grep.c
// Function: gt_grep_nt
int gt_grep_nt(GT_UNUSED bool *match, GT_UNUSED const char *pattern,
               GT_UNUSED const char *line, size_t len, GtError *err)
{
  regex_t matcher;
  int rval, had_err = 0;
  gt_error_check(err);
  gt_assert(pattern && line);
  if ((rval = tre_regcomp(&matcher, pattern, REG_EXTENDED | REG_NOSUB))) {
    grep_error(rval, &matcher, err);
    had_err = -1;
  }
  if (!had_err) {
    rval = tre_regnexec(&matcher, line, len, 0, NULL, 0);
    if (rval && rval != REG_NOMATCH) {
      grep_error(rval, &matcher, err);
      had_err = -1;
    }
  }
  tre_regfree(&matcher);
  if (!had_err) {
    if (rval)
      *match = false;
    else
      *match = true;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
testq %r8, %r8
je 0x763b1
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0x7644a
testq %r15, %r15
je 0x76445
testq %r13, %r13
je 0x76445
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movl $0x9, %edx
callq 0x8fa01
movl %eax, %ebp
testl %eax, %eax
jne 0x76400
xorl %r15d, %r15d
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8fc5f
movl %eax, %ebp
movb $0x1, %r12b
cmpl $0x2, %eax
jb 0x7641d
leaq 0x8(%rsp), %rsi
movl %ebp, %edi
movq %r14, %rdx
callq 0x7644f
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl $0x1, %ebp
xorl %r12d, %r12d
leaq 0x8(%rsp), %rdi
callq 0x8fa34
testb %r12b, %r12b
je 0x76433
xorb $0x1, %bpl
movb %bpl, (%rbx)
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1c348
callq 0x1c311
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/grep.c
// Function: grep_error
static void grep_error(int errcode, regex_t *matcher, GtError *err)
{
  char sbuf[BUFSIZ], *buf;
  size_t bufsize;
  gt_error_check(err);
  bufsize = tre_regerror(errcode, matcher, NULL, 0);
  buf = gt_malloc(bufsize);
  (void) tre_regerror(errcode, matcher, buf ? buf : sbuf,
                      buf ? bufsize : BUFSIZ);
  gt_error_set(err, "grep(): %s", buf ? buf : sbuf);
  gt_free(buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
testq %rdx, %rdx
je 0x7647d
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x764ff
movl %ebp, %edi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x8fa3c
movq %rax, %r12
leaq 0x7add0(%rip), %rsi     # 0xf1265
movq %rax, %rdi
movl $0x22, %edx
callq 0x35ee2
movq %rax, %r13
testq %rax, %rax
movq %rsp, %r15
cmovneq %rax, %r15
movl $0x2000, %ecx           # imm = 0x2000
cmovneq %r12, %rcx
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x8fa3c
leaq 0x7ae9d(%rip), %rsi     # 0xf1369
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3559f
movq %r13, %rdi
leaq 0x7ad82(%rip), %rsi     # 0xf1265
movl $0x26, %edx
callq 0x362a0
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1c37f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashmap.c
// Function: gt_hashmap_new_g
static GtHashmap* gt_hashmap_new_g(GtHashType keyhashtype, GtFree keyfree,
                                   GtFree valuefree, void* (*alloc)(size_t))
{
  struct hm_freefuncs *ff = alloc(sizeof (*ff));
  ff->keyfree = keyfree;
  ff->valuefree = valuefree;
  switch (keyhashtype) {
    case GT_HASH_DIRECT:
      {
        HashElemInfo hm_directkey_eleminfo = {
          gt_ht_ptr_elem_hash, { .free_elem_with_data = hm_elem_free },
          sizeof (struct map_entry), gt_ht_ptr_elem_cmp, ff, gt_free_func
        };
        if (alloc != gt_hashmap_malloc)
          return (GtHashmap*) gt_hashtable_new_no_ma(hm_directkey_eleminfo);
        else
          return (GtHashmap*) gt_hashtable_new(hm_directkey_eleminfo);
      }
    case GT_HASH_STRING:
      {
        HashElemInfo hm_strkey_eleminfo = {
          gt_ht_cstr_elem_hash, { .free_elem_with_data = hm_elem_free },
          sizeof (struct map_entry), gt_ht_cstr_elem_cmp, ff, gt_free_func
        };
        if (alloc != gt_hashmap_malloc)
          return (GtHashmap*) gt_hashtable_new_no_ma(hm_strkey_eleminfo);
        else
          return (GtHashmap*) gt_hashtable_new(hm_strkey_eleminfo);
      }
    default: gt_assert(0);
  }
  return NULL; /* for stupid compilers nagging too much */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
movl $0x10, %edi
callq *%rcx
movq %r15, (%rax)
movq %r14, 0x8(%rax)
cmpl $0x1, %ebp
je 0x76f8b
testl %ebp, %ebp
jne 0x77026
leaq 0x1610(%rip), %rcx      # 0x78578
movq %rcx, 0x38(%rsp)
leaq 0x706(%rip), %rcx       # 0x7767a
movq %rcx, 0x40(%rsp)
movq $0x10, 0x48(%rsp)
leaq 0x1878(%rip), %rcx      # 0x78801
jmp 0x76fb3
leaq 0x183b(%rip), %rcx      # 0x787cd
movq %rcx, 0x38(%rsp)
leaq 0x6dc(%rip), %rcx       # 0x7767a
movq %rcx, 0x40(%rsp)
movq $0x10, 0x48(%rsp)
leaq 0x186c(%rip), %rcx      # 0x7881f
movq %rcx, 0x50(%rsp)
movq %rax, 0x58(%rsp)
leaq -0x40c65(%rip), %rax    # 0x3635f
movq %rax, 0x60(%rsp)
leaq 0x5b(%rip), %rax        # 0x7702b
cmpq %rax, %rbx
je 0x76ff9
movups 0x38(%rsp), %xmm0
movups 0x48(%rsp), %xmm1
movups 0x58(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x77829
jmp 0x7701b
movups 0x38(%rsp), %xmm0
movups 0x48(%rsp), %xmm1
movups 0x58(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x777ac
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1c3ed
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashmap.c
// Function: gt_hashmap_add
void gt_hashmap_add(GtHashmap *hm, void *key, void *value)
{
  struct map_entry keyvalpair = { key, value };
  if (!gt_hashtable_add((GtHashtable*) hm, &keyvalpair)) {
    ((struct map_entry *)gt_hashtable_get((GtHashtable*) hm, &keyvalpair))
      ->value = value;
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
movq %rax, %rsi
callq 0x7799a
testl %eax, %eax
jne 0x7717a
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x77906
movq %rbx, 0x8(%rax)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashmap.c
// Function: gt_hashmap_unit_test
int
gt_hashmap_unit_test(GtError *err)
{
  int had_err;
  gt_error_check(err);

  /* direct hash */
  had_err = gt_hashmap_test(GT_HASH_DIRECT);

  /* string hash */
  if (!had_err)
    had_err = gt_hashmap_test(GT_HASH_STRING);

  if (had_err)
  {
    gt_error_set(err, "hashmap operation created inconsistent state.");
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x77265
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x7729c
xorl %edi, %edi
callq 0x772a1
movl %eax, %ebp
testl %eax, %eax
jne 0x7727e
movl $0x1, %edi
callq 0x772a1
movl %eax, %ebp
testl %ebp, %ebp
je 0x77293
leaq 0x7a113(%rip), %rsi     # 0xf139c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3559f
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1c45b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashmap.c
// Function: hm_elem_free
static void
hm_elem_free(void *elem, void *table_data)
{
  struct hm_freefuncs *ff = table_data;
  gt_assert(elem && ff);
  if (ff->keyfree)
    ff->keyfree(((struct map_entry *)elem)->key);
  if (ff->valuefree)
    ff->valuefree(((struct map_entry *)elem)->value);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x776b9
movq %rsi, %r14
testq %rsi, %rsi
je 0x776b9
movq %rdi, %rbx
movq (%r14), %rax
testq %rax, %rax
je 0x7769b
movq (%rbx), %rdi
callq *%rax
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x776b1
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1c494
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashtable.c
// Function: gt_hashtable_new_with_start_size_g
GtHashtable* gt_hashtable_new_with_start_size_g(HashElemInfo table_info,
                                                unsigned short size_log,
                                                void* (*alloc)(size_t))
{
  GtHashtable *ht;
  ht = alloc(sizeof (*ht));
  ht->lock = gt_rwlock_new();
  if (alloc == gt_hashtable_malloc)
    ht->no_ma = false;
  else
    ht->no_ma = true;
  gt_ht_init(ht, table_info, size_log, DEFAULT_HIGH_MUL, DEFAULT_LOW_MUL);
  return ht;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movl $0x80, %edi
callq *%rsi
movq %rax, %r14
callq 0x3d8a7
movq %rax, 0x68(%r14)
leaq 0x45(%rip), %rax        # 0x7776c
cmpq %rax, %rbx
setne 0x78(%r14)
movaps 0x50(%rsp), %xmm0
movaps 0x60(%rsp), %xmm1
movaps 0x70(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movl $0xc0, %edx
movl $0x20, %ecx
callq 0x7777d
movq %r14, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashtable.c
// Function: gt_ht_init
static void
gt_ht_init(GtHashtable *ht, HashElemInfo table_info, unsigned short size_log,
           unsigned short high_mul, unsigned short low_mul)
{
  gt_assert(size_log < sizeof (htsize_t) * CHAR_BIT);
  ht->current_fill = 0;
  ht->reference_count = 0;
  ht->table = ht->links.table = NULL;
  gt_ht_reinit(ht, table_info, size_log, high_mul, low_mul);
}

// Assembly:
cmpw $0x20, %si
jae 0x777a6
movl $0x0, 0x54(%rdi)
xorl %eax, %eax
movq %rax, 0x70(%rdi)
movq %rax, 0x58(%rdi)
movq %rax, 0x30(%rdi)
movzwl %si, %esi
movzwl %dx, %edx
movzwl %cx, %ecx
jmp 0x782aa
pushq %rax
callq 0x1c4cb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashtable.c
// Function: gt_hashtable_get
void* gt_hashtable_get(GtHashtable *ht, const void *elem)
{
  gt_assert(ht);
  gt_rwlock_wrlock(ht->lock);
#if TJ_DEBUG > 1
  gt_ht_traverse_list_of_key_debug(ht, elem);
#endif
  gt_ht_traverse_list_of_key(ht, elem, ,
                          if (link != free_mark
                              && !ht->table_info.cmp(elem,
                                                     gt_ht_elem_ptr(ht, idx))) {
                            gt_rwlock_unlock(ht->lock);
                            return gt_ht_elem_ptr(ht, idx); },);
  gt_rwlock_unlock(ht->lock);
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7798b
movq %rsi, %r15
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
callq 0x3d934
movq %r15, %rdi
callq *(%rbx)
movl %eax, %ebp
andl 0x48(%rbx), %ebp
movq 0x58(%rbx), %rax
movl %ebp, %r14d
movl (%rax,%r14,4), %ebp
cmpl $-0x1, %ebp
je 0x77951
movq 0x10(%rbx), %rsi
imulq %r14, %rsi
addq 0x30(%rbx), %rsi
movq %r15, %rdi
callq *0x18(%rbx)
testl %eax, %eax
je 0x77959
testl %ebp, %ebp
jns 0x7792b
movb $0x1, %al
jmp 0x7796d
movq 0x68(%rbx), %rdi
callq 0x3d94f
imulq 0x10(%rbx), %r14
addq 0x30(%rbx), %r14
xorl %eax, %eax
testb %al, %al
je 0x7797d
movq 0x68(%rbx), %rdi
callq 0x3d94f
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1c504
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashtable.c
// Function: gt_hashtable_add
int gt_hashtable_add(GtHashtable *ht, const void *elem)
{
  int insert_count;
  gt_assert(ht && elem);
  gt_rwlock_wrlock(ht->lock);
  if (ht->current_fill + 1 > ht->high_fill)
    gt_ht_resize(ht, ht->table_size_log + 1);
  insert_count = gt_ht_insert(ht, elem, NULL);
  gt_rwlock_unlock(ht->lock);
  return insert_count;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x779f0
movq %rsi, %r14
testq %rsi, %rsi
je 0x779f0
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
callq 0x3d934
movl 0x54(%rbx), %eax
incl %eax
cmpl 0x4c(%rbx), %eax
jbe 0x779d1
movl 0x60(%rbx), %eax
incl %eax
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x779f5
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x77aa7
movl %eax, %ebp
movq 0x68(%rbx), %rdi
callq 0x3d94f
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1c53d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashtable.c
// Function: gt_ht_resize
static void
gt_ht_resize(GtHashtable *ht, unsigned short new_size_log)
{
  GtHashtable new_ht;
#ifndef NDEBUG
  htsize_t new_size = 1 << new_size_log;
#endif
  gt_assert(ht);
  if (new_size_log != ht->table_size_log)
  {
    /* save lock from old table */
    GtRWLock *l = ht->lock;
    new_ht.no_ma = ht->no_ma;
    gt_ht_init(&new_ht, ht->table_info, new_size_log, ht->high_fill_mul,
               ht->low_fill_mul);
    gt_assert(ht->current_fill < new_size);
    gt_hashtable_foreach_g(ht, gt_ht_insert_wrapper, &new_ht, NULL, false);
    gt_ht_destruct(ht);
    memcpy(ht, &new_ht, sizeof (*ht));
    /* restore lock */
    ht->lock = l;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
testq %rdi, %rdi
je 0x77a9d
movl %esi, %ebp
movq %rdi, %rbx
cmpw %bp, 0x60(%rdi)
je 0x77a8f
movq 0x68(%rbx), %r15
movb 0x78(%rbx), %al
leaq 0x38(%rsp), %rdi
movb %al, 0x78(%rdi)
movzwl 0x62(%rbx), %edx
movzwl 0x64(%rbx), %ecx
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movzwl %bp, %esi
callq 0x7777d
movl 0x54(%rbx), %eax
movl %ebp, %ecx
shrl %cl, %eax
testl %eax, %eax
jne 0x77aa2
leaq 0x133c(%rip), %rsi      # 0x78d9c
leaq 0x38(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x77f92
movq %rbx, %rdi
callq 0x78526
movl $0x10, %ecx
movq %rbx, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r15, 0x68(%rbx)
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1c5af
callq 0x1c576
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashtable.c
// Function: gt_hashtable_add_with_storage_ptr
int gt_hashtable_add_with_storage_ptr(GtHashtable *ht, const void *elem,
                                      void **stor_ptr)
{
  int insert_count;
  gt_assert(ht && elem);
  gt_rwlock_wrlock(ht->lock);
  if (ht->current_fill + 1 > ht->high_fill)
    gt_ht_resize(ht, ht->table_size_log + 1);
  insert_count = gt_ht_insert(ht, elem, stor_ptr);
  gt_rwlock_unlock(ht->lock);
  return insert_count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x77c91
movq %rsi, %r15
testq %rsi, %rsi
je 0x77c91
movq %rdx, %r14
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
callq 0x3d934
movl 0x54(%rbx), %eax
incl %eax
cmpl 0x4c(%rbx), %eax
jbe 0x77c6b
movl 0x60(%rbx), %eax
incl %eax
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x779f5
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x77aa7
movl %eax, %ebp
movq 0x68(%rbx), %rdi
callq 0x3d94f
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1c5e8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashtable.c
// Function: gt_hashtable_remove
int gt_hashtable_remove(GtHashtable *ht, const void *elem)
{
  htsize_t remove_pos;
  int rval = 0;
  gt_assert(ht && elem);
  gt_rwlock_wrlock(ht->lock);
  remove_pos = gt_ht_remove(ht, elem);
  if (remove_pos != free_mark)
  {
    gt_ht_shrink(ht);
    rval = 1;
  }
  gt_rwlock_unlock(ht->lock);
  return rval;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x77d09
movq %rsi, %r14
testq %rsi, %rsi
je 0x77d09
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
callq 0x3d934
movq %rbx, %rdi
movq %r14, %rsi
callq 0x77d0e
cmpl $-0x1, %eax
je 0x77cf7
movl 0x50(%rbx), %eax
movl 0x54(%rbx), %ecx
movl $0x1, %ebp
cmpl %eax, %ecx
jae 0x77cf9
movzwl 0x60(%rbx), %edx
cmpw $0x5, %dx
jb 0x77cf9
decl %edx
cmpl %eax, %ecx
jae 0x77cea
shrl %eax
cmpw $0x4, %dx
ja 0x77cdc
movzwl %dx, %esi
movq %rbx, %rdi
callq 0x779f5
jmp 0x77cf9
xorl %ebp, %ebp
movq 0x68(%rbx), %rdi
callq 0x3d94f
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1c621
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashtable.c
// Function: gt_hashtable_foreach_ordered
int gt_hashtable_foreach_ordered(GtHashtable *ht, Elemvisitfunc iter,
                                 void *data, GtCompare cmp, GtError *err)
{
  GtArray *hash_entries;
  void *elem;
  GtUword i;
  int had_err;
  gt_error_check(err);
  gt_assert(ht && iter && cmp);
  gt_rwlock_wrlock(ht->lock);
  hash_entries = gt_array_new(ht->table_info.elem_size);
  {
    struct hash_to_array_data visitor_data = { ht->table_info.elem_size,
                                               hash_entries };

    had_err = gt_hashtable_foreach_g(ht, gt_ht_save_entry_to_array,
                                     &visitor_data, err, false);
  }
  gt_rwlock_unlock(ht->lock);
  if (!had_err) {
    size_t hash_size;
    gt_qsort_r(gt_array_get_space(hash_entries), gt_array_size(hash_entries),
               gt_array_elem_size(hash_entries), data, (GtCompareWithData)cmp);
    hash_size = gt_array_size(hash_entries);
    gt_assert(hash_size == gt_hashtable_fill(ht));
    for (i = 0; !had_err && i < hash_size; i++) {
      elem = gt_array_get(hash_entries, i);
      had_err = iter(elem, data, err);
    }
  }
  gt_array_delete(hash_entries);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %rbp
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %r13
testq %r8, %r8
je 0x77e76
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x77f88
testq %r13, %r13
je 0x77f83
testq %r15, %r15
je 0x77f83
testq %rbp, %rbp
je 0x77f83
movq 0x68(%r13), %rdi
callq 0x3d934
movq 0x10(%r13), %rdi
callq 0x6e93c
movq %rax, %r12
movq 0x10(%r13), %rax
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
movq %r12, 0x8(%rdx)
leaq 0x2e2(%rip), %rsi       # 0x7819f
movq %r13, %rdi
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x77f92
movl %eax, %r14d
movq 0x68(%r13), %rdi
callq 0x3d94f
testl %r14d, %r14d
je 0x77ef6
movq %r12, %rdi
callq 0x6f134
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x6ebe9
movq %rax, 0x10(%rsp)
movq %r12, %rdi
callq 0x6ecda
movq %rax, %r14
movq %r12, %rdi
callq 0x6ece7
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
movq 0x8(%rsp), %rcx
movq %rbp, %r8
callq 0x7b734
movq %r12, %rdi
callq 0x6ecda
movq %rax, %rbp
movl 0x54(%r13), %eax
cmpq %rax, %rbp
jne 0x77f8d
testq %rbp, %rbp
je 0x77f7b
xorl %r13d, %r13d
movq %r12, %rdi
movq %r13, %rsi
callq 0x6e9fa
movq %rax, %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq *%r15
movl %eax, %r14d
testl %eax, %eax
jne 0x77edc
incq %r13
cmpq %rbp, %r13
jb 0x77f4a
jmp 0x77edc
xorl %r14d, %r14d
jmp 0x77edc
callq 0x1c693
callq 0x1c65a
callq 0x1c6cc
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashtable.c
// Function: gt_ht_save_entry_to_array
static enum iterator_op
gt_ht_save_entry_to_array(void *elem, void *data, GT_UNUSED GtError *err)
{
  GtArray *hash_entries;
  gt_assert(elem && data);
  hash_entries = ((struct hash_to_array_data *)data)->hash_entries;
  gt_array_add_elem(hash_entries, elem,
                 ((struct hash_to_array_data *)data)->elem_size);
  return CONTINUE_ITERATION;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x781c0
testq %rsi, %rsi
je 0x781c0
movq %rdi, %rax
movq (%rsi), %rdx
movq 0x8(%rsi), %rdi
movq %rax, %rsi
callq 0x6ec0e
xorl %eax, %eax
popq %rcx
retq
callq 0x1c72f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashtable.c
// Function: gt_hashtable_fill
size_t gt_hashtable_fill(GtHashtable *ht)
{
  size_t rval;
  gt_assert(ht);
  rval = ht->current_fill;
  return rval;
}

// Assembly:
testq %rdi, %rdi
je 0x781ce
movl 0x54(%rdi), %eax
retq
pushq %rax
callq 0x1c768
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashtable.c
// Function: gt_hashtable_reset
void gt_hashtable_reset(GtHashtable *ht)
{
  gt_assert(ht);
  FreeFuncWData free_elem_with_data;
  gt_rwlock_wrlock(ht->lock);
  free_elem_with_data = ht->table_info.free_op.free_elem_with_data;
  if (free_elem_with_data)
    gt_ht_internal_foreach(ht, free_elem_with_data(elem, table_data));
  ht->current_fill = 0;
  gt_ht_reinit(ht, ht->table_info, MIN_SIZE_LOG, DEFAULT_HIGH_MUL,
            DEFAULT_LOW_MUL);
  gt_rwlock_unlock(ht->lock);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
testq %rdi, %rdi
je 0x782a5
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
callq 0x3d934
movq 0x8(%rbx), %rax
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0x78257
movl 0x48(%rbx), %eax
incl %eax
sete %cl
cmpl $0x0, 0x54(%rbx)
sete %dl
orb %cl, %dl
testb $0x1, %dl
jne 0x78257
movq 0x10(%rbx), %r13
movq 0x20(%rbx), %r14
movq 0x30(%rbx), %r15
movl %eax, %ebp
xorl %r12d, %r12d
movq 0x58(%rbx), %rax
cmpl $-0x1, (%rax,%r12,4)
je 0x7824c
movq %r15, %rdi
movq %r14, %rsi
callq *0x30(%rsp)
addq %r13, %r15
incq %r12
cmpq %r12, %rbp
jne 0x78237
movl $0x0, 0x54(%rbx)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x4, %esi
movl $0xc0, %edx
movl $0x20, %ecx
callq 0x782aa
movq 0x68(%rbx), %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3d94f
callq 0x1c7a1
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashtable.c
// Function: gt_ht_reinit
static void
gt_ht_reinit(GtHashtable *ht, HashElemInfo table_info, unsigned short size_log,
             unsigned short high_mul, unsigned short low_mul)
{
  htsize_t table_size;
  gt_assert(high_mul > low_mul);
  gt_assert(low_mul > 0 && high_mul < FILL_DIVISOR);
  ht->table_info = table_info;
  ht->table_size_log = size_log;
  ht->table_mask = (table_size = 1 << size_log) - 1;
  if (ht->no_ma)
    ht->table = realloc(ht->table, table_info.elem_size * table_size);
  else
    ht->table = gt_realloc(ht->table, table_info.elem_size * table_size);
  ht->high_fill_mul = high_mul;
  ht->high_fill
    = (GtUint64)ht->high_fill_mul * table_size / FILL_DIVISOR;
  ht->low_fill_mul = low_mul;
  ht->low_fill
    = (GtUint64)ht->low_fill_mul * table_size / FILL_DIVISOR;
  {
    uint32_t i;
    if (ht->no_ma)
      ht->links.table = realloc(ht->links.table,
                                sizeof (*(ht->links.table)) * table_size);
    else
      ht->links.table = gt_realloc(ht->links.table,
                                   sizeof (*(ht->links.table)) * table_size);
    for (i = 0; i < table_size; ++i)
      ht->links.table[i] = free_mark;
    ht->get_link = gt_ht_get_table_link;
    ht->set_link = gt_ht_set_table_link;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r15d
cmpw %bp, %r15w
jbe 0x783d6
movzwl %r15w, %r12d
cmpl $0xff, %r12d
ja 0x783db
testw %bp, %bp
je 0x783db
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x40(%rsp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm2, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movl $0x1, %r13d
movl %r14d, %ecx
shll %cl, %r13d
movw %r14w, 0x60(%rdi)
leal -0x1(%r13), %ecx
movl %ecx, 0x48(%rdi)
movq 0x10(%rax), %rsi
movl %r14d, %ecx
shlq %cl, %rsi
movq 0x30(%rdi), %rdi
cmpb $0x1, 0x78(%rbx)
jne 0x78332
callq 0xba70
jmp 0x78343
leaq 0x79110(%rip), %rdx     # 0xf1449
movl $0x6a, %ecx
callq 0x36116
movq %rax, 0x30(%rbx)
movl %r14d, %ecx
shlq %cl, %r12
movw %r15w, 0x62(%rbx)
movl %r13d, %r15d
shrq $0x8, %r12
movzwl %bp, %eax
shlq %cl, %rax
movl %r12d, 0x4c(%rbx)
movw %bp, 0x64(%rbx)
shrq $0x8, %rax
movl %eax, 0x50(%rbx)
movq 0x58(%rbx), %rdi
leaq (,%r15,4), %rsi
cmpb $0x1, 0x78(%rbx)
jne 0x78387
callq 0xba70
jmp 0x78398
leaq 0x790bb(%rip), %rdx     # 0xf1449
movl $0x78, %ecx
callq 0x36116
movq %rax, 0x58(%rbx)
xorl %eax, %eax
movq 0x58(%rbx), %rcx
movl $0xffffffff, (%rcx,%rax,4) # imm = 0xFFFFFFFF
incq %rax
cmpq %rax, %r15
jne 0x7839e
leaq -0xa28(%rip), %rax      # 0x77990
movq %rax, 0x38(%rbx)
leaq 0xa1a(%rip), %rax       # 0x78ddd
movq %rax, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1c7da
callq 0x1c811
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashtable.c
// Function: gt_hashtable_ref
GtHashtable* gt_hashtable_ref(GtHashtable *ht)
{
  if (!ht) return NULL;
  gt_rwlock_wrlock(ht->lock);
  ht->reference_count++;
  gt_rwlock_unlock(ht->lock);
  return ht;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x78401
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
callq 0x3d934
incq 0x70(%rbx)
movq 0x68(%rbx), %rdi
callq 0x3d94f
jmp 0x78403
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashtable.c
// Function: gt_hashtable_delete
void gt_hashtable_delete(GtHashtable *ht)
{
  FreeFuncWData free_elem_with_data;
  if (!ht) return;
  gt_rwlock_rdlock(ht->lock);
  if (ht->reference_count) {
    ht->reference_count--;
    gt_rwlock_unlock(ht->lock);
    return;
  }
  gt_rwlock_unlock(ht->lock);
  gt_rwlock_wrlock(ht->lock);
  free_elem_with_data = ht->table_info.free_op.free_elem_with_data;
  if (free_elem_with_data)
    gt_ht_internal_foreach(ht, free_elem_with_data(elem, table_data));
  gt_ht_destruct(ht);
  if (ht->table_info.table_data_free)
    ht->table_info.table_data_free(ht->table_info.table_data);
  gt_rwlock_unlock(ht->lock);
  gt_rwlock_delete(ht->lock);
  if (ht->no_ma)
    free(ht);
  else
    gt_free(ht);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7844b
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
callq 0x3d919
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x7845a
decq %rax
movq %rax, 0x70(%rbx)
movq 0x68(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3d94f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x68(%rbx), %rdi
callq 0x3d94f
movq 0x68(%rbx), %rdi
callq 0x3d934
movq 0x8(%rbx), %rax
movq %rax, (%rsp)
testq %rax, %rax
je 0x784bf
movl 0x48(%rbx), %eax
incl %eax
sete %cl
cmpl $0x0, 0x54(%rbx)
sete %dl
orb %cl, %dl
testb $0x1, %dl
jne 0x784bf
movq 0x10(%rbx), %r13
movq 0x20(%rbx), %r14
movq 0x30(%rbx), %r15
movl %eax, %ebp
xorl %r12d, %r12d
movq 0x58(%rbx), %rax
cmpl $-0x1, (%rax,%r12,4)
je 0x784b4
movq %r15, %rdi
movq %r14, %rsi
callq *(%rsp)
addq %r13, %r15
incq %r12
cmpq %r12, %rbp
jne 0x784a0
movq %rbx, %rdi
callq 0x78526
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x784d6
movq 0x20(%rbx), %rdi
callq *%rax
movq 0x68(%rbx), %rdi
callq 0x3d94f
movq 0x68(%rbx), %rdi
callq 0x3d8f7
cmpb $0x1, 0x78(%rbx)
jne 0x78504
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb790
leaq 0x78f3e(%rip), %rsi     # 0xf1449
movq %rbx, %rdi
movl $0x2a1, %edx            # imm = 0x2A1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x362a0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashtable.c
// Function: gt_ht_destruct
static void
gt_ht_destruct(GtHashtable *ht)
{
  if (ht->no_ma) {
    free(ht->table);
    free(ht->links.table);
  } else {
    gt_free(ht->table);
    gt_free(ht->links.table);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
cmpb $0x1, 0x78(%rbx)
jne 0x7854c
callq 0xb790
movq 0x58(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb790
leaq 0x78ef6(%rip), %r14     # 0xf1449
movq %r14, %rsi
movl $0x92, %edx
callq 0x362a0
movq 0x58(%rbx), %rdi
movq %r14, %rsi
movl $0x93, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashtable.c
// Function: gt_ht_ptr_elem_hash
uint32_t gt_ht_ptr_elem_hash(const void *elem)
{
  /* rotate right by 3 because memory addresses are to often aligned
   * at oct addresses. */
#if CHAR_BIT == 8
  if (sizeof (void *) == 4) {
    return gt_uint32_key_mul_hash(gt_ht_rotate_riggt_ht_u32(*(uint32_t *)elem,
                                                            3));
  }
  else if (sizeof (void *) == 8) {
    return gt_uint64_key_mul_hash(gt_ht_rotate_riggt_ht_u64(*(uint64_t *)elem,
                                                            3));
  }
#else
#error "pointer size is not a multiple of 8, I'd like to hear of your platform"
#endif
}

// Assembly:
movq (%rdi), %rax
rolq $0x3d, %rax
movq %rax, %rcx
shrq $0x20, %rcx
imull $0x9e3779b1, %ecx, %ecx # imm = 0x9E3779B1
movl %ecx, %esi
roll $0xe, %esi
imull $0x9e3779b1, %eax, %edx # imm = 0x9E3779B1
movl %ecx, %eax
subl %esi, %eax
xorl %eax, %edx
movl %eax, %esi
roll $0xb, %esi
subl %esi, %edx
xorl %edx, %ecx
movl %edx, %esi
roll $0x19, %esi
subl %esi, %ecx
movl %ecx, %esi
roll $0x10, %esi
xorl %ecx, %eax
subl %esi, %eax
xorl %eax, %edx
movl %eax, %esi
roll $0x4, %esi
subl %esi, %edx
xorl %edx, %ecx
roll $0xe, %edx
subl %edx, %ecx
xorl %ecx, %eax
roll $0x18, %ecx
subl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashtable.c
// Function: gt_ht_2ptr_elem_free
void gt_ht_2ptr_elem_free(void *elem)
{
  struct gt_ht_elem_2cstr *p = elem;
  gt_assert(elem);
  gt_free(p->key);
  gt_free(p->value);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x78865
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x78c09(%rip), %r14     # 0xf1449
movq %r14, %rsi
movl $0x32f, %edx            # imm = 0x32F
callq 0x362a0
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x330, %edx            # imm = 0x330
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
callq 0x1c848
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashtable.c
// Function: gt_hashtable_unit_test
int gt_hashtable_unit_test(GT_UNUSED GtError *err)
{
  int had_err;
  gt_error_check(err);
  static const HashElemInfo
    hash_ptr = { gt_ht_ptr_elem_hash, { NULL },
                 sizeof (struct gt_ht_elem_2cstr),
                 gt_ht_ptr_elem_cmp, NULL, NULL },
    hash_str = { gt_ht_cstr_elem_hash, { NULL },
                 sizeof (struct gt_ht_elem_2cstr),
                 gt_ht_cstr_elem_cmp, NULL, NULL };
  /* hash key as string */
  had_err = gt_hashtable_test(hash_str);

  /* hash key by pointer value */
  if (!had_err)
    had_err = gt_hashtable_test(hash_ptr);

  return had_err;
}

// Assembly:
subq $0x38, %rsp
testq %rdi, %rdi
je 0x7887c
callq 0x3566a
testb %al, %al
jne 0x788d5
movups 0xd6f55(%rip), %xmm0    # 0x14f7d8
movups %xmm0, 0x20(%rsp)
movups 0xd6f39(%rip), %xmm0    # 0x14f7c8
movups %xmm0, 0x10(%rsp)
movups 0xd6f1d(%rip), %xmm0    # 0x14f7b8
movups %xmm0, (%rsp)
callq 0x788da
testl %eax, %eax
jne 0x788d0
movups 0xd6ef9(%rip), %xmm0    # 0x14f7a8
movups %xmm0, 0x20(%rsp)
movups 0xd6edd(%rip), %xmm0    # 0x14f798
movups %xmm0, 0x10(%rsp)
movups 0xd6ec1(%rip), %xmm0    # 0x14f788
movups %xmm0, (%rsp)
callq 0x788da
addq $0x38, %rsp
retq
callq 0x1c881
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/hashtable.c
// Function: gt_ht_find_free_idx
static htsize_t
gt_ht_find_free_idx(GtHashtable *ht, htsize_t start_idx, int search_dir)
{
  htsize_t new_idx = start_idx;
  gt_assert(ht->current_fill < ht->table_mask + 1);
  do {
    new_idx = (new_idx + search_dir) & ht->table_mask;
  } while (HT_GET_LINK(ht, new_idx) != free_mark);
  return new_idx;
}

// Assembly:
pushq %rax
movl 0x48(%rdi), %eax
leal 0x1(%rax), %ecx
cmpl %ecx, 0x54(%rdi)
jae 0x78dd8
movq 0x58(%rdi), %rcx
addl %edx, %esi
andl %eax, %esi
cmpl $-0x1, (%rcx,%rsi,4)
jne 0x78dca
movl %esi, %eax
popq %rcx
retq
callq 0x1c8d6
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/interval_tree.c
// Function: gt_interval_tree_node_new
GtIntervalTreeNode* gt_interval_tree_node_new(void *data,
                                         GtUword low,
                                         GtUword high)
{
  GtIntervalTreeNode* n;
  n = gt_calloc(1, sizeof (GtIntervalTreeNode));
  n->low = low;
  n->high = high;
  n->data = data;
  return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x788c0(%rip), %rdx     # 0xf16bd
movl $0x1, %edi
movl $0x40, %esi
movl $0x34, %ecx
callq 0x3601f
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
movq %r15, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/interval_tree.c
// Function: gt_interval_tree_new
GtIntervalTree* gt_interval_tree_new(GtFree func)
{
  GtIntervalTree *it;
  it = gt_calloc(1, sizeof (GtIntervalTree));
  it->free_func = func;
  it->nil = &it->sentinel;
  it->root = it->nil;
  return it;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x7888f(%rip), %rdx     # 0xf16bd
movl $0x1, %edi
movl $0x60, %esi
movl $0x3e, %ecx
callq 0x3601f
movq %rbx, 0x58(%rax)
leaq 0x8(%rax), %rcx
movq %rcx, 0x48(%rax)
movq %rcx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/interval_tree.c
// Function: gt_interval_tree_node_delete
void gt_interval_tree_node_delete(GtIntervalTree *it, GtIntervalTreeNode *n)
{
  if (n == it->nil) return;
  if (n->data && it->free_func)
    it->free_func(n->data);
  gt_free(n);
}

// Assembly:
cmpq %rsi, 0x48(%rdi)
je 0x78ea9
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rax
movq 0x18(%rsi), %rdi
testq %rdi, %rdi
je 0x78e94
movq 0x58(%rax), %rax
testq %rax, %rax
je 0x78e94
callq *%rax
leaq 0x78822(%rip), %rsi     # 0xf16bd
movq %rbx, %rdi
movl $0x56, %edx
popq %rbx
jmp 0x362a0
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/interval_tree.c
// Function: gt_interval_tree_find_first_overlapping
GtIntervalTreeNode* gt_interval_tree_find_first_overlapping(GtIntervalTree *it,
                                                            GtUword low,
                                                            GtUword high)
{
  gt_assert(it);
  if (it->root == it->nil)
    return NULL;
  return interval_tree_search_internal(it, it->root, low, high);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x78ee7
movq (%rdi), %rax
movq 0x48(%rdi), %rcx
cmpq %rcx, %rax
je 0x78ee3
cmpq %rsi, 0x30(%rax)
jb 0x78ec8
cmpq %rdx, 0x28(%rax)
jbe 0x78ee5
movq 0x8(%rax), %rdi
cmpq %rcx, %rdi
je 0x78ed7
cmpq %rsi, 0x38(%rdi)
jae 0x78edb
movq 0x10(%rax), %rdi
movq %rdi, %rax
cmpq %rcx, %rdi
jne 0x78ebc
xorl %eax, %eax
popq %rcx
retq
callq 0x1c97d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/interval_tree.c
// Function: interval_tree_traverse_internal
static int interval_tree_traverse_internal(GtIntervalTree *it,
                                           GtIntervalTreeNode *node,
                                           GtIntervalTreeIteratorFunc func,
                                           void *data)
{
  int had_err = 0;
  if (node == it->nil) return 0;
  if (!had_err)
    had_err = interval_tree_traverse_internal(it, node->left, func, data);
  if (!had_err)
    had_err = interval_tree_traverse_internal(it, node->right, func, data);
  if (!had_err)
    had_err = func(node, data);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq %rsi, 0x48(%rdi)
je 0x78f51
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rsi), %rsi
movq %rdx, %r12
callq 0x78efe
testl %eax, %eax
jne 0x78f37
movq 0x10(%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x78efe
testl %eax, %eax
jne 0x78f53
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/interval_tree.c
// Function: gt_interval_tree_find_all_overlapping
void gt_interval_tree_find_all_overlapping(GtIntervalTree *it,
                                           GtUword start,
                                           GtUword end, GtArray* a)
{
  gt_assert(it && a && start <= end);
  if (it->root == it->nil) return;
  interval_tree_find_all_internal(it, it->root, store_interval_node_in_array,
                                  start, end, a);
}

// Assembly:
cmpq %rdx, %rsi
ja 0x78f8a
testq %rdi, %rdi
je 0x78f8a
movq %rcx, %r9
testq %rcx, %rcx
je 0x78f8a
movq %rsi, %rcx
movq (%rdi), %rsi
cmpq 0x48(%rdi), %rsi
je 0x78f89
movq %rdx, %r8
leaq 0x84(%rip), %rdx        # 0x7900b
jmp 0x78f90
retq
pushq %rax
callq 0x1c9b4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/interval_tree.c
// Function: interval_tree_find_all_internal
static void interval_tree_find_all_internal(GtIntervalTree *it,
                                            GtIntervalTreeNode *node,
                                            GtIntervalTreeIteratorFunc func,
                                            GtUword low,
                                            GtUword high,
                                            void *data)
{
  GtIntervalTreeNode* x;
  if (node == it->nil) return;
  x = node;
  if (low <= x->high && x->low <= high)
    func(node, data);
  /* recursively search left and right subtrees */
  if (x->left != it->nil && low <= x->left->max)
    interval_tree_find_all_internal(it, x->left, func, low, high, data);
  if (x->right != it->nil && low <= x->right->max)
    interval_tree_find_all_internal(it, x->right, func, low, high, data);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
cmpq %r13, 0x48(%rbp)
je 0x78ffc
cmpq %r15, 0x30(%r13)
jb 0x78fc8
cmpq %r14, 0x28(%r13)
ja 0x78fc8
movq %r13, %rdi
movq %rbx, %rsi
callq *%r12
movq 0x8(%r13), %rsi
cmpq 0x48(%rbp), %rsi
je 0x78fec
cmpq %r15, 0x38(%rsi)
jb 0x78fec
movq %rbp, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x78f90
movq 0x10(%r13), %r13
cmpq 0x48(%rbp), %r13
je 0x78ffc
cmpq %r15, 0x38(%r13)
jae 0x78fad
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/interval_tree.c
// Function: gt_interval_tree_insert
void gt_interval_tree_insert(GtIntervalTree *it, GtIntervalTreeNode *n)
{
  gt_assert(it && n);
  n->parent = it->nil;
  n->left = it->nil;
  n->right = it->nil;
  if (it->root == it->nil)
  {
    it->root = n;
  } else interval_tree_insert_internal(it, &(it->root), n);
  it->size++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x791e0
movq %rsi, %r14
testq %rsi, %rsi
je 0x791e0
movq %rdi, %rbx
movq 0x48(%rdi), %rcx
movq %rcx, (%r14)
movq %rcx, 0x8(%r14)
movq %rcx, 0x10(%r14)
movq (%rdi), %rsi
cmpq %rcx, %rsi
je 0x790cf
movq 0x28(%r14), %rdx
movq 0x30(%r14), %rax
movq %rax, 0x38(%r14)
movq %rsi, %rax
movq 0x38(%r14), %rsi
cmpq %rsi, 0x38(%rax)
jae 0x790a0
movq %rsi, 0x38(%rax)
xorl %esi, %esi
cmpq 0x28(%rax), %rdx
setae %sil
movq 0x8(%rax,%rsi,8), %rsi
cmpq %rcx, %rsi
jne 0x7908f
movq %rax, (%r14)
movq %rbx, %rdx
cmpq %rcx, %rax
je 0x790de
movq 0x28(%r14), %rcx
cmpq 0x28(%rax), %rcx
jae 0x790d7
addq $0x8, %rax
jmp 0x790db
movq %r14, (%rbx)
jmp 0x791d1
addq $0x10, %rax
movq %rax, %rdx
movq %r14, (%rdx)
movl $0x1, 0x20(%r14)
movq (%rbx), %rcx
cmpq %r14, %rcx
je 0x791ca
movq (%r14), %r15
cmpl $0x1, 0x20(%r15)
jne 0x791ca
leaq 0x20(%r15), %rax
xorl %ebp, %ebp
movq (%r15), %rcx
movq 0x8(%rcx), %rdx
cmpq %rdx, %r15
je 0x79159
cmpq 0x48(%rbx), %rdx
je 0x79121
cmpl $0x1, 0x20(%rdx)
je 0x79169
cmpq 0x8(%r15), %r14
jne 0x79138
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x79e40
movq %r15, %r14
movq (%r14), %rax
movl $0x0, 0x20(%rax)
movq (%rax), %rdx
movl $0x1, 0x20(%rdx)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x79d95
jmp 0x791b0
movq 0x10(%rcx), %rdx
cmpq 0x48(%rbx), %rdx
je 0x7917a
cmpl $0x1, 0x20(%rdx)
jne 0x7917a
movl %ebp, (%rax)
movl %ebp, 0x20(%rdx)
movl $0x1, 0x20(%rcx)
movq %rcx, %r14
jmp 0x791b0
cmpq 0x10(%r15), %r14
jne 0x79191
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x79d95
movq %r15, %r14
movq (%r14), %rax
movl $0x0, 0x20(%rax)
movq (%rax), %rdx
movl $0x1, 0x20(%rdx)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x79e40
movq (%rbx), %rcx
cmpq %rcx, %r14
je 0x791ca
movq (%r14), %r15
leaq 0x20(%r15), %rax
cmpl $0x1, 0x20(%r15)
je 0x79109
movl $0x0, 0x20(%rcx)
incq 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1ca26
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/interval_tree.c
// Function: interval_tree_node_rec_delete
static void interval_tree_node_rec_delete(GtIntervalTree *it,
                                          GtIntervalTreeNode *n)
{
  if (n == it->nil) return;
  interval_tree_node_rec_delete(it, n->left);
  interval_tree_node_rec_delete(it, n->right);
  gt_interval_tree_node_delete(it, n);
}

// Assembly:
cmpq %rsi, 0x48(%rdi)
je 0x79243
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
callq 0x7920c
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x7920c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x78e73
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/interval_tree.c
// Function: gt_interval_tree_print_rec
static void gt_interval_tree_print_rec(GtIntervalTree *it,
                                       GtIntervalTreeNode *n)
{
  if (n == it->nil) return;
  printf("(");
  gt_interval_tree_print_rec(it, n->left);
  printf("["GT_WU","GT_WU"]", n->low, n->high);
  gt_interval_tree_print_rec(it, n->right);
  printf(")");
}

// Assembly:
cmpq %rsi, 0x48(%rdi)
je 0x795a1
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x28, %edi
callq 0xb870
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x79548
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
leaq 0x783c7(%rip), %rdi     # 0xf1944
xorl %eax, %eax
callq 0xb070
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x79548
movl $0x29, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb870
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/interval_tree.c
// Function: range_ptr_compare
static int range_ptr_compare(const void *r1p, const void *r2p)
{
  int ret;
  gt_assert(r1p && r2p);
  ret = gt_range_compare(*(GtRange**) r1p, *(GtRange**) r2p);
  /* It could be that two identical ranges with different pointers are
     present. If so, compare pointers instead to get a canonical ordering. */
  if (ret == 0 && *(GtRange**) r1p != *(GtRange**) r2p)
  {
    if (*(GtRange**) r1p < *(GtRange**) r2p)
      ret = -1;
    else
      ret = 1;
  }
  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x79d75
movq %rsi, %rbx
testq %rsi, %rsi
je 0x79d75
movq %rdi, %r14
movq (%rdi), %rdi
movq (%rbx), %rsi
callq 0x7df58
testl %eax, %eax
jne 0x79d6d
movq (%r14), %rcx
movq (%rbx), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x79d6d
cmpq %rdx, %rcx
sbbl %eax, %eax
orl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1cb0a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/interval_tree.c
// Function: interval_tree_left_rotate
static void interval_tree_left_rotate(GtIntervalTree *it,
                                      GtIntervalTreeNode **root,
                                      GtIntervalTreeNode *x)
{
  GtIntervalTreeNode *y;
  y = x->right;
  x->right = y->left;
  if (y->left != it->nil)
    y->left->parent = x;
  y->parent = x->parent;
  if (x->parent == it->nil)
    *root = y;
  else {
    if (x == x->parent->left)
      x->parent->left = y;
    else
      x->parent->right = y;
  }
  y->left = x;
  x->parent = y;
  /* interval tree augmentation */
  x->max = x->high;
  if (x->left != it->nil && x->left->max > x->max)
    x->max = x->left->max;
  if (x->right != it->nil && x->right->max > x->max)
    x->max = x->right->max;
  y->max = y->high;
  if (y->left != it->nil && y->left->max > y->max)
    y->max = y->left->max;
  if (y->right != it->nil && y->right->max > y->max)
    y->max = y->right->max;
}

// Assembly:
movq 0x10(%rdx), %rax
movq 0x8(%rax), %r8
movq %r8, 0x10(%rdx)
movq 0x48(%rdi), %rcx
cmpq %rcx, %r8
je 0x79dad
movq %rdx, (%r8)
movq (%rdx), %r8
movq %r8, (%rax)
movq (%rdx), %r8
cmpq %rcx, %r8
je 0x79dcb
leaq 0x8(%r8), %rcx
leaq 0x10(%r8), %rsi
cmpq %rdx, 0x8(%r8)
cmoveq %rcx, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rax)
movq %rax, (%rdx)
movq 0x8(%rdx), %r8
movq 0x30(%rdx), %rsi
movq %rsi, 0x38(%rdx)
movq 0x48(%rdi), %rcx
cmpq %rcx, %r8
je 0x79df7
movq 0x38(%r8), %rdi
cmpq %rsi, %rdi
jbe 0x79df7
movq %rdi, 0x38(%rdx)
movq 0x10(%rdx), %rsi
cmpq %rcx, %rsi
je 0x79e0e
movq 0x38(%rsi), %rsi
cmpq 0x38(%rdx), %rsi
jbe 0x79e0e
movq %rsi, 0x38(%rdx)
movq 0x30(%rax), %rsi
movq %rsi, 0x38(%rax)
cmpq %rdx, %rcx
je 0x79e28
movq 0x38(%rdx), %rdx
cmpq %rsi, %rdx
jbe 0x79e28
movq %rdx, 0x38(%rax)
movq 0x10(%rax), %rdx
cmpq %rcx, %rdx
je 0x79e3f
movq 0x38(%rdx), %rcx
cmpq 0x38(%rax), %rcx
jbe 0x79e3f
movq %rcx, 0x38(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/interval_tree.c
// Function: interval_tree_right_rotate
static void interval_tree_right_rotate(GtIntervalTree *it,
                                       GtIntervalTreeNode **root,
                                       GtIntervalTreeNode *y)
{
  GtIntervalTreeNode *x;
  x = y->left;
  y->left = x->right;
  if (x->right != it->nil)
    x->right->parent = y;
  x->parent = y->parent;
  if (y->parent == it->nil)
    *root = x;
  else {
    if (y == y->parent->left)
      y->parent->left = x;
    else
      y->parent->right = x;
  }
  x->right = y;
  y->parent = x;
  /* interval tree augmentation */
  x->max = x->high;
  if (x->left != it->nil && x->left->max > x->max)
    x->max = x->left->max;
  if (x->right != it->nil && x->right->max > x->max)
    x->max = x->right->max;
  y->max = y->high;
  if (y->left != it->nil && y->left->max > y->max)
    y->max = y->left->max;
  if (y->right != it->nil && y->right->max > y->max)
    y->max = y->right->max;
}

// Assembly:
movq 0x8(%rdx), %rax
movq 0x10(%rax), %r8
movq %r8, 0x8(%rdx)
movq 0x48(%rdi), %rcx
cmpq %rcx, %r8
je 0x79e58
movq %rdx, (%r8)
movq (%rdx), %r8
movq %r8, (%rax)
movq (%rdx), %r8
cmpq %rcx, %r8
je 0x79e76
leaq 0x8(%r8), %rcx
leaq 0x10(%r8), %rsi
cmpq %rdx, 0x8(%r8)
cmoveq %rcx, %rsi
movq %rax, (%rsi)
movq %rdx, 0x10(%rax)
movq %rax, (%rdx)
movq 0x8(%rax), %r8
movq 0x30(%rax), %rsi
movq %rsi, 0x38(%rax)
movq 0x48(%rdi), %rcx
cmpq %rcx, %r8
je 0x79ea2
movq 0x38(%r8), %rdi
cmpq %rsi, %rdi
jbe 0x79ea2
movq %rdi, 0x38(%rax)
cmpq %rdx, %rcx
je 0x79eb5
movq 0x38(%rdx), %rsi
cmpq 0x38(%rax), %rsi
jbe 0x79eb5
movq %rsi, 0x38(%rax)
movq 0x8(%rdx), %rsi
movq 0x30(%rdx), %rax
movq %rax, 0x38(%rdx)
cmpq %rcx, %rsi
je 0x79ed3
movq 0x38(%rsi), %rsi
cmpq %rax, %rsi
jbe 0x79ed3
movq %rsi, 0x38(%rdx)
movq 0x10(%rdx), %rax
cmpq %rcx, %rax
je 0x79eea
movq 0x38(%rax), %rax
cmpq 0x38(%rdx), %rax
jbe 0x79eea
movq %rax, 0x38(%rdx)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_double_compare
static inline bool gt_double_relative_equal(double d1, double d2)
{
  double relerr;
  if (fabs(d1 - d2) < GT_DBL_MAX_ABS_ERROR)
    return true;
  if (fabs(d2) > fabs(d1))
    relerr = fabs((d1 - d2) / d2);
  else
    relerr = fabs((d1 - d2) / d1);
  if (relerr <= GT_DBL_MAX_REL_ERROR)
    return true;
  return false;
}

// Assembly:
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
movapd 0x73940(%rip), %xmm3    # 0xed970
andpd %xmm2, %xmm3
movb $0x1, %cl
movsd 0x7793a(%rip), %xmm4    # 0xf1978
ucomisd %xmm3, %xmm4
ja 0x7a088
movapd 0x73924(%rip), %xmm3    # 0xed970
movapd %xmm1, %xmm4
andpd %xmm3, %xmm4
movapd %xmm0, %xmm5
andpd %xmm3, %xmm5
cmpltsd %xmm4, %xmm5
movapd %xmm5, %xmm4
andpd %xmm1, %xmm4
andnpd %xmm0, %xmm5
orpd %xmm4, %xmm5
divsd %xmm5, %xmm2
andpd %xmm3, %xmm2
movsd 0x778ff(%rip), %xmm3    # 0xf1980
ucomisd %xmm2, %xmm3
setae %cl
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
leal -0x1(,%rax,2), %edx
xorl %eax, %eax
testb %cl, %cl
cmovel %edx, %eax
retq