LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x15d09
movq %rax, 0x68(%r14)
leaq 0x43(%rip), %rax        # 0x564ca
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)
pushq $0x20
popq %rcx
movq %r14, %rdi
movl %ebp, %esi
movl $0xc0, %edx
callq 0x564db
movq %r14, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x56502
andl $0x0, 0x54(%rdi)
andq $0x0, 0x70(%rdi)
andq $0x0, 0x58(%rdi)
andq $0x0, 0x30(%rdi)
movzwl %si, %esi
movzwl %dx, %edx
movzwl %cx, %ecx
jmp 0x57106
pushq %rax
movq 0xd7aae(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x73b52(%rip), %rsi     # 0xca066
leaq 0x83f98(%rip), %rdx     # 0xda4b3
leaq 0x83fb9(%rip), %rcx     # 0xda4db
leaq 0x83e80(%rip), %r8      # 0xda3a9
movl $0x84, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5663e
movq %rsi, %r14
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
callq 0x15e99
movq %r14, %rdi
callq *(%rbx)
movl %eax, %ebp
andl 0x48(%rbx), %ebp
movq 0x58(%rbx), %rax
movl %ebp, %r15d
movl (%rax,%r15,4), %ebp
cmpl $-0x1, %ebp
je 0x56610
movq 0x10(%rbx), %rsi
imulq %r15, %rsi
addq 0x30(%rbx), %rsi
movq %r14, %rdi
callq *0x18(%rbx)
testl %eax, %eax
je 0x5661e
testl %ebp, %ebp
jns 0x565e6
movq 0x68(%rbx), %rdi
callq 0x15f0a
xorl %r15d, %r15d
jmp 0x56630
movq 0x68(%rbx), %rdi
callq 0x15f0a
imulq 0x10(%rbx), %r15
addq 0x30(%rbx), %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xd7973(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x73a17(%rip), %rsi     # 0xca066
leaq 0x7dd59(%rip), %rdx     # 0xd43af
leaq 0x83d3b(%rip), %rcx     # 0xda398
leaq 0x83d45(%rip), %r8      # 0xda3a9
movl $0x11d, %r9d            # imm = 0x11D
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x566d6
movq %rsi, %r14
testq %rsi, %rsi
je 0x566d6
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
callq 0x15e99
movl 0x54(%rbx), %eax
incl %eax
cmpl 0x4c(%rbx), %eax
jbe 0x566b7
movl 0x60(%rbx), %eax
incl %eax
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x5670e
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5681a
movl %eax, %ebp
movq 0x68(%rbx), %rdi
callq 0x15f0a
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0xd78db(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7397f(%rip), %rsi     # 0xca066
leaq 0x83cd0(%rip), %rdx     # 0xda3be
leaq 0x83cd4(%rip), %rcx     # 0xda3c9
leaq 0x83cad(%rip), %r8      # 0xda3a9
movl $0x12f, %r9d            # imm = 0x12F
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x567b4
movl %esi, %ebp
movq %rdi, %rbx
cmpw %bp, 0x60(%rdi)
je 0x567a6
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 0x564db
movl 0x54(%rbx), %eax
movl %ebp, %ecx
shrl %cl, %eax
testl %eax, %eax
jne 0x567e2
leaq 0x1387(%rip), %rsi      # 0x57b00
leaq 0x38(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x56dc9
movq %rbx, %rdi
callq 0x573b5
pushq $0x10
popq %rcx
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
movq 0xd77fd(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x738a1(%rip), %rsi     # 0xca066
leaq 0x7dbe3(%rip), %rdx     # 0xd43af
leaq 0x83d13(%rip), %rcx     # 0xda4e6
leaq 0x83bcf(%rip), %r8      # 0xda3a9
movl $0xe1, %r9d
jmp 0x5680e
movq 0xd77cf(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x73873(%rip), %rsi     # 0xca066
leaq 0x83cf9(%rip), %rdx     # 0xda4f3
leaq 0x83ce5(%rip), %rcx     # 0xda4e6
leaq 0x83ba1(%rip), %r8      # 0xda3a9
movl $0xe9, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x569de
movq %rsi, %r15
testq %rsi, %rsi
je 0x569de
movq %rdx, %r14
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
callq 0x15e99
movl 0x54(%rbx), %eax
incl %eax
cmpl 0x4c(%rbx), %eax
jbe 0x569b8
movl 0x60(%rbx), %eax
incl %eax
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x5670e
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x5681a
movl %eax, %ebp
movq 0x68(%rbx), %rdi
callq 0x15f0a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xd75d3(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x73677(%rip), %rsi     # 0xca066
leaq 0x839c8(%rip), %rdx     # 0xda3be
leaq 0x839dd(%rip), %rcx     # 0xda3da
leaq 0x839a5(%rip), %r8      # 0xda3a9
movl $0x13c, %r9d            # imm = 0x13C
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x56a62
movq %rsi, %r14
testq %rsi, %rsi
je 0x56a62
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
callq 0x15e99
movq %rbx, %rdi
movq %r14, %rsi
callq 0x56a9a
cmpl $-0x1, %eax
je 0x56a50
movq %rbx, %rdi
callq 0x56bc4
pushq $0x1
popq %rbp
jmp 0x56a52
xorl %ebp, %ebp
movq 0x68(%rbx), %rdi
callq 0x15f0a
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0xd754f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x735f3(%rip), %rsi     # 0xca066
leaq 0x83944(%rip), %rdx     # 0xda3be
leaq 0x8397b(%rip), %rcx     # 0xda3fc
leaq 0x83921(%rip), %r8      # 0xda3a9
movl $0x192, %r9d            # imm = 0x192
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/hashtable.c
// Function: gt_ht_shrink
static inline void
gt_ht_shrink(GtHashtable *ht)
{
  if (ht->current_fill < ht->low_fill
      && ht->table_size_log > MIN_SIZE_LOG)
  {
    unsigned short new_size_log = ht->table_size_log;
    htsize_t low_fill = ht->low_fill, old_low_fill;
    do {
      old_low_fill = low_fill;
      --new_size_log;
      low_fill >>= 1;
    } while (ht->current_fill < old_low_fill && new_size_log > MIN_SIZE_LOG);
    gt_ht_resize(ht, new_size_log);
  }
}

// Assembly:
movl 0x50(%rdi), %eax
movl 0x54(%rdi), %ecx
cmpl %eax, %ecx
jae 0x56bee
movzwl 0x60(%rdi), %edx
cmpw $0x5, %dx
jb 0x56bee
decl %edx
cmpl %eax, %ecx
jae 0x56be6
shrl %eax
cmpw $0x4, %dx
ja 0x56bd8
movzwl %dx, %esi
jmp 0x5670e
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x56f96
testq %rsi, %rsi
je 0x56f96
movq %rdi, %rax
movq (%rsi), %rdx
movq 0x8(%rsi), %rdi
movq %rax, %rsi
callq 0x4b801
xorl %eax, %eax
popq %rcx
retq
movq 0xd701b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x730bf(%rip), %rsi     # 0xca066
leaq 0x83601(%rip), %rdx     # 0xda5af
leaq 0x83607(%rip), %rcx     # 0xda5bc
leaq 0x833ed(%rip), %r8      # 0xda3a9
movl $0x1e0, %r9d            # imm = 0x1E0
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x56fd7
movl 0x54(%rdi), %eax
retq
pushq %rax
movq 0xd6fd9(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7307d(%rip), %rsi     # 0xca066
leaq 0x7d3bf(%rip), %rdx     # 0xd43af
leaq 0x8346b(%rip), %rcx     # 0xda462
leaq 0x833ab(%rip), %r8      # 0xda3a9
movl $0x25d, %r9d            # imm = 0x25D
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x570ce
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
callq 0x15e99
movq 0x8(%rbx), %r12
testq %r12, %r12
je 0x57087
cmpl $0x0, 0x54(%rbx)
je 0x57087
movq 0x10(%rbx), %r13
movq 0x20(%rbx), %rax
movq %rax, 0x30(%rsp)
movl 0x48(%rbx), %ebp
incl %ebp
movq 0x30(%rbx), %r15
xorl %r14d, %r14d
cmpq %r14, %rbp
je 0x57087
movq 0x58(%rbx), %rax
cmpl $-0x1, (%rax,%r14,4)
je 0x5707f
movq %r15, %rdi
movq 0x30(%rsp), %rsi
callq *%r12
addq %r13, %r15
incq %r14
jmp 0x57064
andl $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)
pushq $0x4
popq %rsi
pushq $0x20
popq %rcx
movq %rbx, %rdi
movl $0xc0, %edx
callq 0x57106
movq 0x68(%rbx), %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x15f0a
movq 0xd6ee3(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x72f87(%rip), %rsi     # 0xca066
leaq 0x7d2c9(%rip), %rdx     # 0xd43af
leaq 0x83387(%rip), %rcx     # 0xda474
leaq 0x832b5(%rip), %r8      # 0xda3a9
movl $0x275, %r9d            # imm = 0x275
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
testq %rdi, %rdi
je 0x5729c
movq 0x68(%rbx), %rdi
callq 0x15e99
incq 0x70(%rbx)
movq 0x68(%rbx), %rdi
callq 0x15f0a
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x572e4
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
callq 0x15e28
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x572f3
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 0x15f0a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x68(%rbx), %rdi
callq 0x15f0a
movq 0x68(%rbx), %rdi
callq 0x15e99
movq 0x8(%rbx), %r12
testq %r12, %r12
je 0x5734e
cmpl $0x0, 0x54(%rbx)
je 0x5734e
movq 0x10(%rbx), %r13
movq 0x20(%rbx), %rax
movq %rax, (%rsp)
movl 0x48(%rbx), %ebp
incl %ebp
movq 0x30(%rbx), %r15
xorl %r14d, %r14d
cmpq %r14, %rbp
je 0x5734e
movq 0x58(%rbx), %rax
cmpl $-0x1, (%rax,%r14,4)
je 0x57346
movq %r15, %rdi
movq (%rsp), %rsi
callq *%r12
addq %r13, %r15
incq %r14
jmp 0x5732c
movq %rbx, %rdi
callq 0x573b5
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x57365
movq 0x20(%rbx), %rdi
callq *%rax
movq 0x68(%rbx), %rdi
callq 0x15f0a
movq 0x68(%rbx), %rdi
callq 0x15dd5
cmpb $0x1, 0x78(%rbx)
jne 0x57393
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb790
leaq 0x8300f(%rip), %rsi     # 0xda3a9
movq %rbx, %rdi
movl $0x2a1, %edx            # imm = 0x2A1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd249
// File: /workspace/github_c_makefile_star2_O2/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 0x573db
callq 0xb790
movq 0x58(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb790
leaq 0x82fc7(%rip), %r14     # 0xda3a9
movq %r14, %rsi
movl $0x92, %edx
callq 0xd249
movq 0x58(%rbx), %rdi
movq %r14, %rsi
movl $0x93, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/hashtable-siop.h
// Function: gt_ht_finalize3_u32
static inline uint32_t
gt_ht_finalize3_u32(uint32_t a, uint32_t b, uint32_t c)
{
  c ^= b; c -= gt_ht_rotate_left_u32(b,(unsigned short) 14);
  a ^= c; a -= gt_ht_rotate_left_u32(c,(unsigned short) 11);
  b ^= a; b -= gt_ht_rotate_left_u32(a,(unsigned short) 25);
  c ^= b; c -= gt_ht_rotate_left_u32(b,(unsigned short) 16);
  a ^= c; a -= gt_ht_rotate_left_u32(c,(unsigned short) 4);
  b ^= a; b -= gt_ht_rotate_left_u32(a,(unsigned short) 14);
  c ^= b; c -= gt_ht_rotate_left_u32(b,(unsigned short) 24);
  return c;
}

// Assembly:
movl %edx, %eax
xorl %esi, %eax
movl %esi, %ecx
roll $0xe, %ecx
subl %ecx, %eax
xorl %eax, %edi
movl %eax, %ecx
roll $0xb, %ecx
subl %ecx, %edi
xorl %edi, %esi
movl %edi, %ecx
roll $0x19, %ecx
subl %ecx, %esi
movl %esi, %ecx
roll $0x10, %ecx
xorl %esi, %eax
subl %ecx, %eax
xorl %eax, %edi
movl %eax, %ecx
roll $0x4, %ecx
subl %ecx, %edi
xorl %edi, %esi
roll $0xe, %edi
subl %edi, %esi
xorl %esi, %eax
roll $0x18, %esi
subl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x57667
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x82d67(%rip), %r14     # 0xda3a9
movq %r14, %rsi
movl $0x32f, %edx            # imm = 0x32F
callq 0xd249
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x330, %edx            # imm = 0x330
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
movq 0xd694a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x729ee(%rip), %rsi     # 0xca066
leaq 0x809b4(%rip), %rdx     # 0xd8033
leaq 0x82e01(%rip), %rcx     # 0xda487
leaq 0x82d1c(%rip), %r8      # 0xda3a9
movl $0x32e, %r9d            # imm = 0x32E
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x576b1
callq 0xc103
testb %al, %al
jne 0x5770f
movups 0xd5100(%rip), %xmm0    # 0x12c7b8
movups %xmm0, 0x20(%rsp)
movups 0xd50e4(%rip), %xmm0    # 0x12c7a8
movups %xmm0, 0x10(%rsp)
movups 0xd50c8(%rip), %xmm0    # 0x12c798
movups %xmm0, (%rsp)
callq 0x57747
testl %eax, %eax
je 0x576e2
pushq $-0x1
popq %rax
jmp 0x5770a
movups 0xd509f(%rip), %xmm0    # 0x12c788
movups %xmm0, 0x20(%rsp)
movups 0xd5083(%rip), %xmm0    # 0x12c778
movups %xmm0, 0x10(%rsp)
movups 0xd5067(%rip), %xmm0    # 0x12c768
movups %xmm0, (%rsp)
callq 0x57747
addq $0x38, %rsp
retq
movq 0xd68a2(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x72946(%rip), %rsi     # 0xca066
leaq 0x72f32(%rip), %rdx     # 0xca659
leaq 0x82d6e(%rip), %rcx     # 0xda49c
leaq 0x82c74(%rip), %r8      # 0xda3a9
movl $0x395, %r9d            # imm = 0x395
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x57b52
movq 0x58(%rdi), %rcx
addl %edx, %esi
andl %eax, %esi
cmpl $-0x1, (%rcx,%rsi,4)
jne 0x57b44
movl %esi, %eax
popq %rcx
retq
movq 0xd645f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x72503(%rip), %rsi     # 0xca066
leaq 0x829d8(%rip), %rdx     # 0xda542
leaq 0x829f7(%rip), %rcx     # 0xda568
leaq 0x82831(%rip), %r8      # 0xda3a9
movl $0x149, %r9d            # imm = 0x149
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x82a48(%rip), %rdx     # 0xda61d
pushq $0x1
popq %rdi
pushq $0x40
popq %rsi
pushq $0x34
popq %rcx
callq 0xce9a
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_O2/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 0x82a1d(%rip), %rdx     # 0xda61d
pushq $0x1
popq %rdi
pushq $0x60
popq %rsi
pushq $0x3e
popq %rcx
callq 0xce9a
movq %rbx, 0x58(%rax)
leaq 0x8(%rax), %rcx
movq %rcx, 0x48(%rax)
movq %rcx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x57cd5
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rax
movq 0x18(%rsi), %rdi
testq %rdi, %rdi
je 0x57cc2
movq 0x58(%rax), %rax
testq %rax, %rax
je 0x57cc2
callq *%rax
leaq 0x82954(%rip), %rsi     # 0xda61d
pushq $0x56
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x57d15
movq (%rdi), %r8
movq 0x48(%rdi), %rcx
cmpq %rcx, %r8
je 0x57d11
cmpq %rcx, %r8
je 0x57d11
movq %r8, %rax
cmpq %rsi, 0x30(%r8)
jb 0x57cfc
cmpq %rdx, 0x28(%rax)
jbe 0x57d13
movq 0x8(%rax), %r8
cmpq %rcx, %r8
je 0x57d0b
cmpq %rsi, 0x38(%r8)
jae 0x57ce8
movq 0x10(%rax), %r8
jmp 0x57ce8
xorl %eax, %eax
popq %rcx
retq
movq 0xd629c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x72340(%rip), %rsi     # 0xca066
leaq 0x779e5(%rip), %rdx     # 0xcf712
leaq 0x82937(%rip), %rcx     # 0xda66b
leaq 0x828e2(%rip), %r8      # 0xda61d
pushq $0x78
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x57db0
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rsi), %rsi
movq %rdx, %r12
callq 0x57d5d
testl %eax, %eax
jne 0x57db2
movq 0x10(%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x57d5d
testl %eax, %eax
jne 0x57db2
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_O2/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 0x57de9
testq %rdi, %rdi
je 0x57de9
movq %rcx, %r9
testq %rcx, %rcx
je 0x57de9
movq %rsi, %rcx
movq (%rdi), %rsi
cmpq 0x48(%rdi), %rsi
je 0x57de8
movq %rdx, %r8
leaq 0xc0(%rip), %rdx        # 0x57ea6
jmp 0x57e22
retq
pushq %rax
movq 0xd61c7(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7226b(%rip), %rsi     # 0xca066
leaq 0x82891(%rip), %rdx     # 0xda693
leaq 0x828a2(%rip), %rcx     # 0xda6ab
leaq 0x8280d(%rip), %r8      # 0xda61d
movl $0xb4, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
movq 0x48(%rdi), %rax
cmpq %r13, %rax
je 0x57e97
cmpq %r15, 0x30(%r13)
jb 0x57e61
cmpq %r14, 0x28(%r13)
ja 0x57e61
movq %r13, %rdi
movq %rbx, %rsi
callq *%r12
movq 0x48(%rbp), %rax
movq 0x8(%r13), %rsi
cmpq %rax, %rsi
je 0x57e88
cmpq %r15, 0x38(%rsi)
jb 0x57e88
movq %rbp, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x57e22
movq 0x48(%rbp), %rax
movq 0x10(%r13), %r13
cmpq %rax, %r13
je 0x57e97
cmpq %r15, 0x38(%r13)
jae 0x57e43
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x5809a
movq %rsi, %r14
testq %rsi, %rsi
je 0x5809a
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq %rax, (%r14)
movq %rax, 0x8(%r14)
movq %rax, 0x10(%r14)
movq (%rdi), %rsi
cmpq %rax, %rsi
je 0x57fa1
movq 0x30(%r14), %rcx
movq %rcx, 0x38(%r14)
movq %rax, %rcx
cmpq %rax, %rsi
je 0x57f86
movq %rsi, %rdx
movq 0x38(%r14), %rcx
cmpq %rcx, 0x38(%rsi)
jae 0x57f6e
movq %rcx, 0x38(%rdx)
movq 0x28(%r14), %rcx
xorl %esi, %esi
cmpq 0x28(%rdx), %rcx
setae %sil
movq 0x8(%rdx,%rsi,8), %rsi
movq %rdx, %rcx
jmp 0x57f58
movq %rcx, (%r14)
movq %rbx, %rdx
cmpq %rax, %rcx
je 0x57fb0
movq 0x28(%r14), %rax
cmpq 0x28(%rcx), %rax
jae 0x57fa9
addq $0x8, %rcx
jmp 0x57fad
movq %r14, (%rbx)
jmp 0x58090
addq $0x10, %rcx
movq %rcx, %rdx
movq %r14, (%rdx)
movl $0x1, 0x20(%r14)
movq (%rbx), %rax
cmpq %rax, %r14
je 0x5808c
movq (%r14), %r15
cmpl $0x1, 0x20(%r15)
jne 0x5808c
movq (%r15), %rdx
movq 0x8(%rdx), %rax
cmpq %rax, %r15
je 0x57ff8
cmpq 0x48(%rbx), %rax
je 0x57fed
cmpl $0x1, 0x20(%rax)
je 0x58008
cmpq 0x8(%r15), %r14
je 0x58028
movq %r15, %rax
jmp 0x5803f
movq 0x10(%rdx), %rax
cmpq 0x48(%rbx), %rax
je 0x5801d
cmpl $0x1, 0x20(%rax)
jne 0x5801d
andl $0x0, 0x20(%r15)
andl $0x0, 0x20(%rax)
movl $0x1, 0x20(%rdx)
movq %rdx, %r14
jmp 0x57fbb
cmpq 0x10(%r15), %r14
je 0x5805a
movq %r15, %rax
jmp 0x58071
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x58bf6
movq (%r15), %rax
movq (%rax), %rdx
movq %r15, %r14
andl $0x0, 0x20(%rax)
movl $0x1, 0x20(%rdx)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x58b48
jmp 0x57fbb
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x58b48
movq (%r15), %rax
movq (%rax), %rdx
movq %r15, %r14
andl $0x0, 0x20(%rax)
movl $0x1, 0x20(%rdx)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x58bf6
jmp 0x57fbb
andl $0x0, 0x20(%rax)
incq 0x50(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0xd5f17(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x71fbb(%rip), %rsi     # 0xca066
leaq 0x8265f(%rip), %rdx     # 0xda711
leaq 0x82660(%rip), %rcx     # 0xda719
leaq 0x8255d(%rip), %r8      # 0xda61d
movl $0x171, %r9d            # imm = 0x171
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x58130
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
callq 0x580f9
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x580f9
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x57ca1
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5847e
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0xb860
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x58429
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
leaq 0x82448(%rip), %rdi     # 0xda8a4
xorl %eax, %eax
callq 0xb070
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x58429
pushq $0x29
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb860
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x58af7
movq %rsi, %rbx
testq %rsi, %rsi
je 0x58af7
movq %rdi, %r14
movq (%rdi), %rdi
movq (%rbx), %rsi
callq 0x5cec8
testl %eax, %eax
jne 0x58aef
movq (%r14), %rcx
movq (%rbx), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x58aef
cmpq %rdx, %rcx
sbbl %eax, %eax
orl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xd54ba(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7155e(%rip), %rsi     # 0xca066
leaq 0x81d9f(%rip), %rdx     # 0xda8ae
leaq 0x81da3(%rip), %rcx     # 0xda8b9
leaq 0x81b00(%rip), %r8      # 0xda61d
movl $0x20c, %r9d            # imm = 0x20C
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x58b60
movq %rdx, (%r8)
movq (%rdx), %r8
movq %r8, (%rax)
cmpq %rcx, %r8
je 0x58b77
cmpq %rdx, 0x8(%r8)
je 0x58b80
movq %rax, 0x10(%r8)
jmp 0x58b84
movq %rax, (%rsi)
movq 0x48(%rdi), %rcx
jmp 0x58b84
movq %rax, 0x8(%r8)
movq %rdx, 0x8(%rax)
movq %rax, (%rdx)
movq 0x8(%rdx), %rdi
movq 0x30(%rdx), %rsi
movq %rsi, 0x38(%rdx)
cmpq %rcx, %rdi
je 0x58bac
movq 0x38(%rdi), %rdi
cmpq %rsi, %rdi
jbe 0x58bac
movq %rdi, 0x38(%rdx)
movq %rdi, %rsi
movq 0x10(%rdx), %rdi
cmpq %rcx, %rdi
je 0x58bc2
movq 0x38(%rdi), %rdi
cmpq %rsi, %rdi
jbe 0x58bc2
movq %rdi, 0x38(%rdx)
movq 0x30(%rax), %rsi
movq %rsi, 0x38(%rax)
cmpq %rdx, %rcx
je 0x58bdf
movq 0x38(%rdx), %rdx
cmpq %rsi, %rdx
jbe 0x58bdf
movq %rdx, 0x38(%rax)
movq %rdx, %rsi
movq 0x10(%rax), %rdx
cmpq %rcx, %rdx
je 0x58bf5
movq 0x38(%rdx), %rcx
cmpq %rsi, %rcx
jbe 0x58bf5
movq %rcx, 0x38(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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), %rcx
movq 0x10(%rcx), %r8
movq %r8, 0x8(%rdx)
movq 0x48(%rdi), %rax
cmpq %rax, %r8
je 0x58c0e
movq %rdx, (%r8)
movq (%rdx), %r8
movq %r8, (%rcx)
cmpq %rax, %r8
je 0x58c25
cmpq %rdx, 0x8(%r8)
je 0x58c2e
movq %rcx, 0x10(%r8)
jmp 0x58c32
movq %rcx, (%rsi)
movq 0x48(%rdi), %rax
jmp 0x58c32
movq %rcx, 0x8(%r8)
movq %rdx, 0x10(%rcx)
movq %rcx, (%rdx)
movq 0x8(%rcx), %rdi
movq 0x30(%rcx), %rsi
movq %rsi, 0x38(%rcx)
cmpq %rax, %rdi
je 0x58c5a
movq 0x38(%rdi), %rdi
cmpq %rsi, %rdi
jbe 0x58c5a
movq %rdi, 0x38(%rcx)
movq %rdi, %rsi
cmpq %rdx, %rax
je 0x58c6c
movq 0x38(%rdx), %rdi
cmpq %rsi, %rdi
jbe 0x58c6c
movq %rdi, 0x38(%rcx)
movq 0x8(%rdx), %rsi
movq 0x30(%rdx), %rcx
movq %rcx, 0x38(%rdx)
cmpq %rax, %rsi
je 0x58c8d
movq 0x38(%rsi), %rsi
cmpq %rcx, %rsi
jbe 0x58c8d
movq %rsi, 0x38(%rdx)
movq %rsi, %rcx
movq 0x10(%rdx), %rsi
cmpq %rax, %rsi
je 0x58ca3
movq 0x38(%rsi), %rax
cmpq %rcx, %rax
jbe 0x58ca3
movq %rax, 0x38(%rdx)
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_rand_max
GtUword gt_rand_max(GtUword maximal_value)
{
  GtUword r;
  gt_assert(maximal_value);
  r = ((double) random() / ((double) GT_RAND_MAX + 1) * (maximal_value + 1));
  gt_assert(r <= maximal_value);
  return r;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x58e40
movq %rdi, %rbx
callq 0x166a8
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cvtsi2sd %eax, %xmm0
mulsd 0x81af7(%rip), %xmm0    # 0xda8e8
leaq 0x1(%rbx), %rax
movq %rax, %xmm1
punpckldq 0x7167e(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x71686(%rip), %xmm1    # 0xca490
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
cvttsd2si %xmm2, %rcx
movq %rcx, %rdx
subsd 0x7a926(%rip), %xmm2    # 0xd3750
cvttsd2si %xmm2, %rax
sarq $0x3f, %rdx
andq %rdx, %rax
orq %rcx, %rax
cmpq %rbx, %rax
ja 0x58e6a
popq %rbx
retq
movq 0xd5171(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x71215(%rip), %rsi     # 0xca066
leaq 0x81b2f(%rip), %rdx     # 0xda987
leaq 0x81ae1(%rip), %rcx     # 0xda940
leaq 0x81ae6(%rip), %r8      # 0xda94c
pushq $0x58
jmp 0x58e92
movq 0xd5147(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x711eb(%rip), %rsi     # 0xca066
leaq 0x81b00(%rip), %rdx     # 0xda982
leaq 0x81ab7(%rip), %rcx     # 0xda940
leaq 0x81abc(%rip), %r8      # 0xda94c
pushq $0x5a
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_rand_max_double
double gt_rand_max_double(double maximal_value)
{
  double r;
  gt_assert(maximal_value);
  r = ((double) random() / GT_RAND_MAX) * maximal_value; /* XXX */
  gt_assert(r >= 0.0 && r <= maximal_value);
  return r;
}

// Assembly:
pushq %rax
xorpd %xmm1, %xmm1
movsd %xmm0, (%rsp)
ucomisd %xmm1, %xmm0
jne 0x58eb2
jnp 0x58ee3
callq 0x166a8
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cvtsi2sd %eax, %xmm0
divsd 0x7da28(%rip), %xmm0    # 0xd68f0
movsd (%rsp), %xmm1
mulsd %xmm1, %xmm0
ucomisd 0x81a17(%rip), %xmm0    # 0xda8f0
jb 0x58f0d
ucomisd %xmm0, %xmm1
jb 0x58f0d
popq %rax
retq
movq 0xd50ce(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x71172(%rip), %rsi     # 0xca066
leaq 0x81a8c(%rip), %rdx     # 0xda987
leaq 0x81a61(%rip), %rcx     # 0xda963
leaq 0x81a43(%rip), %r8      # 0xda94c
pushq $0x61
jmp 0x58f35
movq 0xd50a4(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x71148(%rip), %rsi     # 0xca066
leaq 0x81a51(%rip), %rdx     # 0xda976
leaq 0x81a37(%rip), %rcx     # 0xda963
leaq 0x81a19(%rip), %r8      # 0xda94c
pushq $0x63
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_rand_0_to_1
double gt_rand_0_to_1(void)
{
  double r;
  r = (double) random() / GT_RAND_MAX;
  gt_assert(r >= 0.0 && r <= 1.0);
  return r;
}

// Assembly:
pushq %rax
callq 0x166a8
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cvtsi2sd %eax, %xmm0
divsd 0x7d996(%rip), %xmm0    # 0xd68f0
movsd 0x7198e(%rip), %xmm1    # 0xca8f0
ucomisd %xmm0, %xmm1
jb 0x58f6a
popq %rax
retq
movq 0xd5047(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x710eb(%rip), %rsi     # 0xca066
leaq 0x81a13(%rip), %rdx     # 0xda995
leaq 0x81a21(%rip), %rcx     # 0xda9aa
leaq 0x819bc(%rip), %r8      # 0xda94c
pushq $0x6b
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_rand_char
char gt_rand_char(void)
{
  int offset;
  char c;
  offset = gt_rand_max(25);
  c = 97 + offset;
  gt_assert(c >= 'a' && c <= 'z');
  return c;
}

// Assembly:
pushq %rax
pushq $0x19
popq %rdi
callq 0x58dd2
cmpb $0x1a, %al
jae 0x58fb1
addb $0x61, %al
popq %rcx
retq
movq 0xd5000(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x710a4(%rip), %rsi     # 0xca066
leaq 0x819f0(%rip), %rdx     # 0xda9b9
leaq 0x819fe(%rip), %rcx     # 0xda9ce
leaq 0x81975(%rip), %r8      # 0xda94c
pushq $0x75
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_determinebitspervalue
unsigned int gt_determinebitspervalue(GtUword maxvalue)
{
  unsigned int bits = 0;
#ifndef USEbuiltin_clzl
  GtUword value, mask = (~((GtUword) 0)) << CHAR_BIT;

  for (value = maxvalue; (value & mask) != 0; value >>= CHAR_BIT) {
    bits += CHAR_BIT;
  }
  bits += CHAR_BIT - gt_byte_select[value];
#else
  {
    if (maxvalue != 0) { /*__builtin_clz only defined != 0 */
      bits = (unsigned int) (sizeof(GtUword) * CHAR_BIT) -
             __builtin_clzl(maxvalue);
    }
  }
#endif
  gt_assert(bits <= GT_MAXLOG2VALUE);
  return bits;
}

// Assembly:
pushq %rax
pushq $0x8
popq %rax
cmpq $0x100, %rdi            # imm = 0x100
jb 0x58ffd
shrq $0x8, %rdi
addl $0x8, %eax
jmp 0x58feb
leaq 0x899bc(%rip), %rcx     # 0xe29c0
movzbl (%rcx,%rdi), %ecx
subl %ecx, %eax
cmpl $0x40, %eax
jae 0x59011
popq %rcx
retq
movq 0xd4fa0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x71044(%rip), %rsi     # 0xca066
leaq 0x819b2(%rip), %rdx     # 0xda9db
leaq 0x819c3(%rip), %rcx     # 0xda9f3
leaq 0x81915(%rip), %r8      # 0xda94c
movl $0x90, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_power_for_small_exponents
GtUword gt_power_for_small_exponents(unsigned int base,
                                     unsigned int exponent)
{
  unsigned int logvalue = 0;

  if (exponent == 0) {
    return 1UL;
  }
  switch (base)
  {
    case 2UL:
      logvalue = 1U;
      break;
    case 4UL:
      logvalue = 2U;
      break;
    case 8UL:
      logvalue = 3U;
      break;
    case 16UL:
      logvalue = 4U;
      break;
    case 32UL:
      logvalue = 5U;
      break;
    case 64:
      logvalue = 6U;
      break;
    case 128:
      logvalue = 7U;
      break;
    case 256:
      logvalue = 8U;
      break;
  }
  if (logvalue > 0) {
    gt_assert(logvalue * exponent < sizeof (void *) * 8);
    return 1UL << (logvalue * exponent);
  }
  else {
    GtUword powervalue = (GtUword) base;

    while (exponent > 1U) {
      powervalue *= base;
      exponent--;
    }
    return powervalue;
  }
}

// Assembly:
testl %esi, %esi
je 0x5907f
cmpl $0x2, %edi
je 0x590ad
cmpl $0x100, %edi            # imm = 0x100
je 0x5908f
cmpl $0x8, %edi
je 0x590a9
cmpl $0x10, %edi
je 0x590a5
cmpl $0x20, %edi
je 0x59083
cmpl $0x40, %edi
je 0x5908b
cmpl $0x80, %edi
je 0x59087
cmpl $0x4, %edi
jne 0x59093
pushq $0x2
jmp 0x590af
pushq $0x1
popq %rax
retq
pushq $0x5
jmp 0x590af
pushq $0x7
jmp 0x590af
pushq $0x6
jmp 0x590af
pushq $0x8
jmp 0x590af
movl %edi, %ecx
movq %rcx, %rax
cmpl $0x2, %esi
jb 0x590be
imulq %rcx, %rax
decl %esi
jmp 0x59098
pushq $0x4
jmp 0x590af
pushq $0x3
jmp 0x590af
pushq $0x1
popq %rcx
imull %esi, %ecx
cmpl $0x40, %ecx
jae 0x590bf
pushq $0x1
popq %rax
shlq %cl, %rax
retq
pushq %rax
movq 0xd4ef1(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x70f95(%rip), %rsi     # 0xca066
leaq 0x81934(%rip), %rdx     # 0xdaa0c
leaq 0x81957(%rip), %rcx     # 0xdaa36
leaq 0x81866(%rip), %r8      # 0xda94c
movl $0xb8, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_round_to_long
GtWord gt_round_to_long(double x)
{
  int64_t intgr;
  double rounded = gt_round(x);
  intgr = (int64_t) rounded;
  /* If the fractional part is exactly 0.5, we need to check whether
  the rounded result is even. If it is not we need to add 1 to
  negative values and subtract one from positive values. */
  if ((fabs(((double) intgr) - x) == 0.5) & intgr) {
    /* 1 with the sign of result, i.e. -1 or 1. */
    intgr -= ((intgr >> 62) | ((int64_t) 1));
  }
  return (GtWord) intgr;
}

// Assembly:
pushq %rax
movsd %xmm0, (%rsp)
callq 0xb0e0
movsd (%rsp), %xmm4
xorpd %xmm2, %xmm2
subsd %xmm4, %xmm2
movapd %xmm0, %xmm3
subsd %xmm4, %xmm3
movsd 0x7a520(%rip), %xmm1    # 0xd3640
xorl %eax, %eax
xorl %ecx, %ecx
ucomisd %xmm1, %xmm3
seta %cl
setae %al
movsd 0x817a2(%rip), %xmm3    # 0xda8d8
ucomisd %xmm2, %xmm3
cmoval %ecx, %eax
testb %al, %al
je 0x59149
addsd 0x7afb7(%rip), %xmm0    # 0xd4100
cvttsd2si %xmm0, %rax
cvtsi2sd %rax, %xmm0
subsd %xmm4, %xmm0
andpd 0x7d771(%rip), %xmm0    # 0xd68d0
movl %eax, %ecx
andl $0x1, %ecx
negq %rcx
movq %rax, %rdx
sarq $0x3e, %rdx
orq $0x1, %rdx
andq %rcx, %rdx
xorl %ecx, %ecx
ucomisd %xmm1, %xmm0
cmovneq %rcx, %rdx
cmovpq %rcx, %rdx
subq %rdx, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_gcd_uint
unsigned int gt_gcd_uint(unsigned int m, unsigned int n)
{
  unsigned int r;

  if (m < n) {
    r = m;
    m = n;
    n = r;
  }
  do {
    gt_assert(m >= n);
    r = m % n;
    m = n;
    n = r;
  } while (r != 0);
  return m;
}

// Assembly:
movl %esi, %edx
cmpl %esi, %edi
movl %esi, %eax
cmoval %edi, %eax
cmovbl %edi, %edx
cmpl %edx, %eax
jb 0x591a7
movl %edx, %ecx
xorl %edx, %edx
divl %ecx
movl %ecx, %eax
testl %edx, %edx
jne 0x59194
movl %ecx, %eax
retq
pushq %rax
movq 0xd4e09(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x70ead(%rip), %rsi     # 0xca066
leaq 0x81893(%rip), %rdx     # 0xdaa53
leaq 0x81893(%rip), %rcx     # 0xdaa5a
leaq 0x8177e(%rip), %r8      # 0xda94c
movl $0xe7, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300