LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x86819
movq 0x10(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x867e1
jmp 0x86819
movq 0x12d7f0(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd7874(%rip), %rsi     # 0x15e066
leaq 0xd7e4f(%rip), %rdx     # 0x15e648
leaq 0xe806b(%rip), %rcx     # 0x16e86b
leaq 0xe8079(%rip), %r8      # 0x16e880
movl $0x115, %r9d            # imm = 0x115
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8681b
xorl %edi, %edi
callq 0x86860
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x8683b
movl $0x1, %edi
callq 0x86860
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x86855
movq 0x10(%rsp), %rdi
leaq 0xe8045(%rip), %rsi     # 0x16e893
movb $0x0, %al
callq 0xc0d0
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x86cf6
cmpq $0x0, (%rsp)
jne 0x86d2e
movq 0x12d2db(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd735f(%rip), %rsi     # 0x15e066
leaq 0xe7bc4(%rip), %rdx     # 0x16e8d2
leaq 0xe7bc8(%rip), %rcx     # 0x16e8dd
leaq 0xe7b64(%rip), %r8      # 0x16e880
movl $0x2a, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x86d30
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x86d4b
movq (%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rdi
callq *%rax
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x86d69
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movw %di, %ax
leaq 0x60(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movw %ax, 0x56(%rsp)
movq %rsi, 0x48(%rsp)
movl $0x80, %edi
callq *0x48(%rsp)
movq %rax, 0x40(%rsp)
callq 0x1bec0
movq %rax, %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x68(%rax)
leaq 0x5f(%rip), %rax        # 0x86f10
cmpq %rax, 0x48(%rsp)
jne 0x86ec3
movq 0x40(%rsp), %rax
movb $0x0, 0x78(%rax)
jmp 0x86ecc
movq 0x40(%rsp), %rax
movb $0x1, 0x78(%rax)
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %rdi
movw 0x56(%rsp), %ax
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movq %rsp, %rcx
movups %xmm2, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
movzwl %ax, %esi
movl $0xc0, %edx
movl $0x20, %ecx
callq 0x86f30
movq 0x40(%rsp), %rax
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movw %cx, %ax
movw %dx, %cx
movw %si, %dx
leaq 0x50(%rsp), %rsi
movq %rsi, 0x30(%rsp)
movq %rdi, 0x40(%rsp)
movw %dx, 0x3e(%rsp)
movw %cx, 0x3c(%rsp)
movw %ax, 0x3a(%rsp)
movzwl 0x3e(%rsp), %eax
cmpq $0x20, %rax
jb 0x86f9e
movq 0x12d06b(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd70ef(%rip), %rsi     # 0x15e066
leaq 0xe7ad1(%rip), %rdx     # 0x16ea4f
leaq 0xe7af2(%rip), %rcx     # 0x16ea77
leaq 0xe79b9(%rip), %r8      # 0x16e945
movl $0x84, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x86fa0
movq 0x30(%rsp), %rsi
movq 0x40(%rsp), %rax
movl $0x0, 0x54(%rax)
movq 0x40(%rsp), %rax
movq $0x0, 0x70(%rax)
movq 0x40(%rsp), %rax
movq $0x0, 0x58(%rax)
movq 0x40(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x40(%rsp), %rdi
movw 0x3e(%rsp), %dx
movw 0x3c(%rsp), %cx
movw 0x3a(%rsp), %ax
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movq %rsp, %rsi
movups %xmm2, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
movzwl %dx, %esi
movzwl %cx, %edx
movzwl %ax, %ecx
callq 0x885c0
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x8715e
movq 0x12ceab(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd6f2f(%rip), %rsi     # 0x15e066
leaq 0xe14b1(%rip), %rdx     # 0x1685ef
leaq 0xe77ef(%rip), %rcx     # 0x16e934
leaq 0xe77f9(%rip), %r8      # 0x16e945
movl $0x11d, %r9d            # imm = 0x11D
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x87160
movq 0x38(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1c100
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x87250
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x87280
movl %eax, 0x1c(%rsp)
cmpl $-0x1, 0x1c(%rsp)
je 0x87211
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x872a0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x10(%rsp), %rax
callq *%rax
cmpl $0x0, %eax
jne 0x87211
movq 0x38(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1c1a0
movq 0x38(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x872a0
movq %rax, 0x40(%rsp)
jmp 0x87245
jmp 0x87213
movl 0x1c(%rsp), %eax
andl $0x80000000, %eax       # imm = 0x80000000
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x87193
jmp 0x8722e
movq 0x38(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1c1a0
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x872ee
cmpq $0x0, 0x8(%rsp)
jne 0x87326
movq 0x12cce3(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd6d67(%rip), %rsi     # 0x15e066
leaq 0xe7654(%rip), %rdx     # 0x16e95a
leaq 0xe7658(%rip), %rcx     # 0x16e965
leaq 0xe7631(%rip), %r8      # 0x16e945
movl $0x12f, %r9d            # imm = 0x12F
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x87328
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1c100
movq 0x10(%rsp), %rax
movl 0x54(%rax), %eax
addl $0x1, %eax
movq 0x10(%rsp), %rcx
cmpl 0x4c(%rcx), %eax
jbe 0x87364
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movzwl 0x60(%rax), %eax
addl $0x1, %eax
movzwl %ax, %esi
callq 0x873a0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x87550
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1c1a0
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xd8, %rsp
movw %si, %ax
movq %rdi, 0xd0(%rsp)
movw %ax, 0xce(%rsp)
movzwl 0xce(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0x44(%rsp)
cmpq $0x0, 0xd0(%rsp)
jne 0x87410
movq 0x12cbf9(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd6c7d(%rip), %rsi     # 0x15e066
leaq 0xe11ff(%rip), %rdx     # 0x1685ef
leaq 0xe768b(%rip), %rcx     # 0x16ea82
leaq 0xe7547(%rip), %r8      # 0x16e945
movl $0xe1, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x87412
movzwl 0xce(%rsp), %eax
movq 0xd0(%rsp), %rcx
movzwl 0x60(%rcx), %ecx
cmpl %ecx, %eax
je 0x87547
movq 0xd0(%rsp), %rax
movq 0x68(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0xd0(%rsp), %rax
movb 0x78(%rax), %al
andb $0x1, %al
movb %al, 0xc0(%rsp)
movq 0xd0(%rsp), %rsi
movw 0xce(%rsp), %dx
movq 0xd0(%rsp), %rax
movw 0x62(%rax), %cx
movq 0xd0(%rsp), %rax
movw 0x64(%rax), %ax
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movq %rsp, %rsi
movups %xmm2, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
movzwl %dx, %esi
movzwl %cx, %edx
movzwl %ax, %ecx
leaq 0x48(%rsp), %rdi
callq 0x86f30
movq 0xd0(%rsp), %rax
movl 0x54(%rax), %eax
cmpl 0x44(%rsp), %eax
jb 0x874f0
movq 0x12cb19(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd6b9d(%rip), %rsi     # 0x15e066
leaq 0xe75bf(%rip), %rdx     # 0x16ea8f
leaq 0xe75ab(%rip), %rcx     # 0x16ea82
leaq 0xe7467(%rip), %r8      # 0x16e945
movl $0xe9, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x874f2
movq 0xd0(%rsp), %rdi
leaq 0x233f(%rip), %rsi      # 0x89840
leaq 0x48(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x88010
movq 0xd0(%rsp), %rdi
callq 0x88a50
movq 0xd0(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movl $0x80, %edx
callq 0xb500
movq 0x38(%rsp), %rcx
movq 0xd0(%rsp), %rax
movq %rcx, 0x68(%rax)
addq $0xd8, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x878d3
cmpq $0x0, 0x18(%rsp)
jne 0x8790b
movq 0x12c6fe(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd6782(%rip), %rsi     # 0x15e066
leaq 0xe706f(%rip), %rdx     # 0x16e95a
leaq 0xe7084(%rip), %rcx     # 0x16e976
leaq 0xe704c(%rip), %r8      # 0x16e945
movl $0x13c, %r9d            # imm = 0x13C
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8790d
movq 0x20(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1c100
movq 0x20(%rsp), %rax
movl 0x54(%rax), %eax
addl $0x1, %eax
movq 0x20(%rsp), %rcx
cmpl 0x4c(%rcx), %eax
jbe 0x87949
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movzwl 0x60(%rax), %eax
addl $0x1, %eax
movzwl %ax, %esi
callq 0x873a0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x87550
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1c1a0
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, (%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x879a5
cmpq $0x0, 0x8(%rsp)
jne 0x879dd
movq 0x12c62c(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd66b0(%rip), %rsi     # 0x15e066
leaq 0xe6f9d(%rip), %rdx     # 0x16e95a
leaq 0xe6fd4(%rip), %rcx     # 0x16e998
leaq 0xe6f7a(%rip), %r8      # 0x16e945
movl $0x192, %r9d            # imm = 0x192
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x879df
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1c100
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x87a30
movl %eax, 0x4(%rsp)
cmpl $-0x1, 0x4(%rsp)
je 0x87a18
movq 0x10(%rsp), %rdi
callq 0x87c90
movl $0x1, (%rsp)
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1c1a0
movl (%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x54(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x50(%rcx), %eax
jae 0x87d31
movq 0x10(%rsp), %rax
movzwl 0x60(%rax), %eax
cmpl $0x4, %eax
jle 0x87d31
movq 0x10(%rsp), %rax
movw 0x60(%rax), %ax
movw %ax, 0xe(%rsp)
movq 0x10(%rsp), %rax
movl 0x50(%rax), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
movw 0xe(%rsp), %ax
addw $-0x1, %ax
movw %ax, 0xe(%rsp)
movl 0x8(%rsp), %eax
shrl %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x54(%rax), %ecx
xorl %eax, %eax
cmpl 0x4(%rsp), %ecx
movb %al, 0x3(%rsp)
jae 0x87d1a
movzwl 0xe(%rsp), %eax
cmpl $0x4, %eax
setg %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0x87cd7
movq 0x10(%rsp), %rdi
movzwl 0xe(%rsp), %esi
callq 0x873a0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x88333
cmpq $0x0, 0x18(%rsp)
jne 0x8836b
movq 0x12bc9e(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd5d22(%rip), %rsi     # 0x15e066
leaq 0xe6800(%rip), %rdx     # 0x16eb4b
leaq 0xe6806(%rip), %rcx     # 0x16eb58
leaq 0xe65ec(%rip), %r8      # 0x16e945
movl $0x1e0, %r9d            # imm = 0x1E0
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8836d
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rax
movq (%rax), %rdx
callq 0x76220
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
cmpq $0x0, 0x60(%rsp)
jne 0x88499
movq 0x12bb70(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd5bf4(%rip), %rsi     # 0x15e066
leaq 0xe0176(%rip), %rdx     # 0x1685ef
leaq 0xe6590(%rip), %rcx     # 0x16ea10
leaq 0xe64be(%rip), %r8      # 0x16e945
movl $0x275, %r9d            # imm = 0x275
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8849b
movq 0x60(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1c100
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x88561
jmp 0x884c5
movq 0x60(%rsp), %rax
movl 0x48(%rax), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rax
cmpl $0x0, 0x54(%rax)
je 0x8855d
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
cmpl 0x50(%rsp), %eax
jae 0x8855b
movq 0x60(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0x87280
cmpl $-0x1, %eax
je 0x8853f
movq 0x58(%rsp), %rax
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq *%rax
movq 0x40(%rsp), %rax
addq 0x38(%rsp), %rax
movq %rax, 0x40(%rsp)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x88511
jmp 0x8855d
jmp 0x8855f
jmp 0x88561
movq 0x60(%rsp), %rax
movl $0x0, 0x54(%rax)
movq 0x60(%rsp), %rdi
movq 0x60(%rsp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x4, %esi
movl $0xc0, %edx
movl $0x20, %ecx
callq 0x885c0
movq 0x60(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1c1a0
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x8886c
movq $0x0, 0x10(%rsp)
jmp 0x888a3
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1c100
movq 0x8(%rsp), %rax
movq 0x70(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x70(%rax)
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1c1a0
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x888c6
jmp 0x88a4b
movq 0x30(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1c060
movq 0x30(%rsp), %rax
cmpq $0x0, 0x70(%rax)
je 0x88904
movq 0x30(%rsp), %rax
movq 0x70(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x70(%rax)
movq 0x30(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1c1a0
jmp 0x88a4b
movq 0x30(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1c1a0
movq 0x30(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1c100
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x889d8
jmp 0x8893c
movq 0x30(%rsp), %rax
movl 0x48(%rax), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
cmpl $0x0, 0x54(%rax)
je 0x889d4
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
jae 0x889d2
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x87280
cmpl $-0x1, %eax
je 0x889b6
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq *%rax
movq 0x10(%rsp), %rax
addq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x88988
jmp 0x889d4
jmp 0x889d6
jmp 0x889d8
movq 0x30(%rsp), %rdi
callq 0x88a50
movq 0x30(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x88a02
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x30(%rsp), %rcx
movq 0x20(%rcx), %rdi
callq *%rax
movq 0x30(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1c1a0
movq 0x30(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1bfe0
movq 0x30(%rsp), %rax
testb $0x1, 0x78(%rax)
je 0x88a35
movq 0x30(%rsp), %rdi
callq 0xb760
jmp 0x88a4b
movq 0x30(%rsp), %rdi
leaq 0xe5f04(%rip), %rsi     # 0x16e945
movl $0x2a1, %edx            # imm = 0x2A1
callq 0xdab0
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
testb $0x1, 0x78(%rax)
je 0x88a7b
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0xb760
movq (%rsp), %rax
movq 0x58(%rax), %rdi
callq 0xb760
jmp 0x88aad
movq (%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0xe5ebb(%rip), %rsi     # 0x16e945
movl $0x92, %edx
callq 0xdab0
movq (%rsp), %rax
movq 0x58(%rax), %rdi
leaq 0xe5ea2(%rip), %rsi     # 0x16e945
movl $0x93, %edx
callq 0xdab0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/hashtable-siop.h
// Function: gt_uint64_key_mul_hash
static inline uint32_t
gt_uint64_key_mul_hash(uint64_t key)
{
  uint32_t low = key, hi = key >> 32;
  uint32_t x = gt_ht_finalize2_u32(gt_uint32_key_mul_hash(low),
                                gt_uint32_key_mul_hash(hi));
  return x;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
shrq $0x20, %rax
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %edi
callq 0x899d0
movl %eax, (%rsp)
movl 0x8(%rsp), %edi
callq 0x899d0
movl (%rsp), %edi
movl %eax, %esi
callq 0x899b0
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl 0x10(%rsp), %eax
xorl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %edi
movl $0xe, %esi
callq 0x88f20
movl %eax, %ecx
movl 0xc(%rsp), %eax
subl %ecx, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
xorl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0xc(%rsp), %edi
movl $0xb, %esi
callq 0x88f20
movl %eax, %ecx
movl 0x14(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
xorl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %edi
movl $0x19, %esi
callq 0x88f20
movl %eax, %ecx
movl 0x10(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
xorl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %edi
movl $0x10, %esi
callq 0x88f20
movl %eax, %ecx
movl 0xc(%rsp), %eax
subl %ecx, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
xorl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0xc(%rsp), %edi
movl $0x4, %esi
callq 0x88f20
movl %eax, %ecx
movl 0x14(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
xorl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %edi
movl $0xe, %esi
callq 0x88f20
movl %eax, %ecx
movl 0x10(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
xorl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %edi
movl $0x18, %esi
callq 0x88f20
movl %eax, %ecx
movl 0xc(%rsp), %eax
subl %ecx, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/hashtable.c
// Function: uint32_str_key_hash
static uint32_t
uint32_str_key_hash(const char *str)
{
  const uint8_t *k = (const uint8_t *)str;
  uint32_t c, h = 0xdeadbeef;
  while ((c = *k++))
    h ^= ((h << 5) + (h >> 2) + c);
  return h;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
movl $0xdeadbeef, -0x18(%rsp) # imm = 0xDEADBEEF
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movzbl (%rax), %eax
movl %eax, -0x14(%rsp)
cmpl $0x0, %eax
je 0x89102
movl -0x18(%rsp), %eax
shll $0x5, %eax
movl -0x18(%rsp), %ecx
shrl $0x2, %ecx
addl %ecx, %eax
addl -0x14(%rsp), %eax
xorl -0x18(%rsp), %eax
movl %eax, -0x18(%rsp)
jmp 0x890c7
movl -0x18(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x89273
movq 0x12ad96(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd4e1a(%rip), %rsi     # 0x15e066
leaq 0xe31e7(%rip), %rdx     # 0x16c43a
leaq 0xe57c9(%rip), %rcx     # 0x16ea23
leaq 0xe56e4(%rip), %r8      # 0x16e945
movl $0x32e, %r9d            # imm = 0x32E
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x89275
movq 0x8(%rsp), %rax
movq (%rax), %rdi
leaq 0xe56c1(%rip), %rsi     # 0x16e945
movl $0x32f, %edx            # imm = 0x32F
callq 0xdab0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0xe56a7(%rip), %rsi     # 0x16e945
movl $0x330, %edx            # imm = 0x330
callq 0xdab0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 $0x48, %rsp
movq %rdi, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x89309
movq 0x40(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x892d1
jmp 0x89309
movq 0x12ad00(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd4d84(%rip), %rsi     # 0x15e066
leaq 0xd535f(%rip), %rdx     # 0x15e648
leaq 0xe5748(%rip), %rcx     # 0x16ea38
leaq 0xe564e(%rip), %r8      # 0x16e945
movl $0x395, %r9d            # imm = 0x395
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8930b
movups 0x129906(%rip), %xmm0   # 0x1b2c18
movq %rsp, %rax
movups %xmm0, 0x20(%rax)
movups 0x1298e8(%rip), %xmm0   # 0x1b2c08
movups %xmm0, 0x10(%rax)
movups 0x1298cd(%rip), %xmm0   # 0x1b2bf8
movups %xmm0, (%rax)
callq 0x89380
movl %eax, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
jne 0x8936a
movups 0x1298a3(%rip), %xmm0   # 0x1b2be8
movq %rsp, %rax
movups %xmm0, 0x20(%rax)
movups 0x129885(%rip), %xmm0   # 0x1b2bd8
movups %xmm0, 0x10(%rax)
movups 0x12986a(%rip), %xmm0   # 0x1b2bc8
movups %xmm0, (%rax)
callq 0x89380
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movl 0x54(%rax), %eax
movq 0x10(%rsp), %rcx
movl 0x48(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jb 0x89908
movq 0x12a701(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd4785(%rip), %rsi     # 0x15e066
leaq 0xe51f6(%rip), %rdx     # 0x16eade
leaq 0xe5215(%rip), %rcx     # 0x16eb04
leaq 0xe504f(%rip), %r8      # 0x16e945
movl $0x149, %r9d            # imm = 0x149
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8990a
jmp 0x8990c
movl 0x4(%rsp), %eax
addl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
andl 0x48(%rcx), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x87280
cmpl $-0x1, %eax
jne 0x8990c
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x1, %edi
movl $0x40, %esi
leaq 0xe5145(%rip), %rdx     # 0x16ebb9
movl $0x34, %ecx
callq 0xd5b0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x1, %edi
movl $0x60, %esi
leaq 0xe50df(%rip), %rdx     # 0x16ebb9
movl $0x3e, %ecx
callq 0xd5b0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x8(%rsp), %rcx
addq $0x8, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x48(%rcx), %rax
jne 0x89bf0
jmp 0x89c32
movq 0x8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x89c1c
movq 0x10(%rsp), %rax
cmpq $0x0, 0x58(%rax)
je 0x89c1c
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rdi
callq *%rax
movq 0x8(%rsp), %rdi
leaq 0xe4f91(%rip), %rsi     # 0x16ebb9
movl $0x56, %edx
callq 0xdab0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x89c93
movq 0x12a376(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd43fa(%rip), %rsi     # 0x15e066
leaq 0xd9bba(%rip), %rdx     # 0x16382d
leaq 0xe4f8d(%rip), %rcx     # 0x16ec07
leaq 0xe4f38(%rip), %r8      # 0x16ebb9
movl $0x78, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x89c95
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x48(%rcx), %rax
jne 0x89cb3
movq $0x0, 0x20(%rsp)
jmp 0x89cd4
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x89ce0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/interval_tree.c
// Function: interval_tree_search_internal
static GtIntervalTreeNode* interval_tree_search_internal(GtIntervalTree *it,
                                                         GtIntervalTreeNode
                                                          *node,
                                                         GtUword low,
                                                         GtUword high)
{
  GtIntervalTreeNode *x;
  x = node;

  while (x != it->nil && !(low <= x->high && x->low <= high)) {
    if (x->left != it->nil && x->left->max >= low)
      x = x->left;
    else
      x = x->right;
  }
  return (x == it->nil) ? NULL : x;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rcx
movq -0x8(%rsp), %rdx
xorl %eax, %eax
cmpq 0x48(%rdx), %rcx
movb %al, -0x29(%rsp)
je 0x89d49
movq -0x18(%rsp), %rcx
movq -0x28(%rsp), %rdx
xorl %eax, %eax
cmpq 0x30(%rdx), %rcx
movb %al, -0x2a(%rsp)
ja 0x89d3f
movq -0x28(%rsp), %rax
movq 0x28(%rax), %rax
cmpq -0x20(%rsp), %rax
setbe %al
movb %al, -0x2a(%rsp)
movb -0x2a(%rsp), %al
xorb $-0x1, %al
movb %al, -0x29(%rsp)
movb -0x29(%rsp), %al
testb $0x1, %al
jne 0x89d53
jmp 0x89d9e
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rsp), %rcx
cmpq 0x48(%rcx), %rax
je 0x89d8b
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
cmpq -0x18(%rsp), %rax
jb 0x89d8b
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0x89d99
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0x89cfe
movq -0x28(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x48(%rcx), %rax
jne 0x89db7
xorl %eax, %eax
movq %rax, -0x38(%rsp)
jmp 0x89dc1
movq -0x28(%rsp), %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x48(%rcx), %rax
jne 0x89e6a
movl $0x0, 0x34(%rsp)
jmp 0x89ede
cmpl $0x0, 0xc(%rsp)
jne 0x89e92
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x89e30
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x89eba
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x89e30
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x89ed6
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq *%rax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x89f24
cmpq $0x0, 0x8(%rsp)
je 0x89f24
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jbe 0x89f5c
movq 0x12a0ad(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd4131(%rip), %rsi     # 0x15e066
leaq 0xe4cf3(%rip), %rdx     # 0x16ec2f
leaq 0xe4d04(%rip), %rcx     # 0x16ec47
leaq 0xe4c6f(%rip), %r8      # 0x16ebb9
movl $0xb4, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x89f5e
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x48(%rcx), %rax
jne 0x89f73
jmp 0x89f9b
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
leaq 0x11a(%rip), %rdx       # 0x8a0b0
callq 0x89fa0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x48(%rcx), %rax
jne 0x89fd7
jmp 0x8a0a7
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
cmpq 0x30(%rcx), %rax
ja 0x8a00f
movq (%rsp), %rax
movq 0x28(%rax), %rax
cmpq 0x10(%rsp), %rax
ja 0x8a00f
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rsp), %rcx
cmpq 0x48(%rcx), %rax
je 0x8a05b
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x38(%rcx), %rax
ja 0x8a05b
movq 0x30(%rsp), %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
callq 0x89fa0
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rcx
cmpq 0x48(%rcx), %rax
je 0x8a0a7
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movq 0x10(%rcx), %rcx
cmpq 0x38(%rcx), %rax
ja 0x8a0a7
movq 0x30(%rsp), %rdi
movq (%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
callq 0x89fa0
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x8a1ae
cmpq $0x0, 0x8(%rsp)
jne 0x8a1e6
movq 0x129e23(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd3ea7(%rip), %rsi     # 0x15e066
leaq 0xe4ae7(%rip), %rdx     # 0x16ecad
leaq 0xe4ae8(%rip), %rcx     # 0x16ecb5
leaq 0xe49e5(%rip), %r8      # 0x16ebb9
movl $0x171, %r9d            # imm = 0x171
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8a1e8
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x48(%rcx), %rax
jne 0x8a23f
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
jmp 0x8a253
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x8a270
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x50(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x48(%rcx), %rax
jne 0x8a530
jmp 0x8a565
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x8a510
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x8a510
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x89bd0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/interval_tree.c
// Function: gt_interval_tree_get_successor
GtIntervalTreeNode* gt_interval_tree_get_successor(GtIntervalTree *it,
                                                   GtIntervalTreeNode *x)
{
  GtIntervalTreeNode *y;

  if ((y = x->right)) {
    while (y->left != it->nil) {
      y = y->left;
    }
    return y;
  } else {
    y = x->parent;
    while (y != it->nil && x == y->right) {
      x = y;
      y = y->parent;
    }
    return y;
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, %rax
je 0x8a5c0
jmp 0x8a590
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x48(%rcx), %rax
je 0x8a5b4
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x8a590
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x8a625
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rcx
movq -0x10(%rsp), %rdx
xorl %eax, %eax
cmpq 0x48(%rdx), %rcx
movb %al, -0x21(%rsp)
je 0x8a5f8
movq -0x18(%rsp), %rax
movq -0x20(%rsp), %rcx
cmpq 0x10(%rcx), %rax
sete %al
movb %al, -0x21(%rsp)
movb -0x21(%rsp), %al
testb $0x1, %al
jne 0x8a602
jmp 0x8a61b
movq -0x20(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x8a5cd
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/interval_tree.c
// Function: interval_tree_max_fixup
static void interval_tree_max_fixup(GtIntervalTree *it,
                                    GtIntervalTreeNode *root,
                                    GtIntervalTreeNode *x)
{
  while (x != it->nil && x != root) {
    if (x->left == it->nil && x->right != it->nil)
      x->max = x->right->max;
    else if (x->right == it->nil && x->left != it->nil)
      x->max = x->left->max;
    else if (x->right != it->nil && x->left != it->nil)
      x->max = GT_MAX(x->left->max, x->right->max);
    x = x->parent;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rdx
xorl %eax, %eax
cmpq 0x48(%rdx), %rcx
movb %al, -0x19(%rsp)
je 0x8a8d6
movq -0x18(%rsp), %rax
cmpq -0x10(%rsp), %rax
setne %al
movb %al, -0x19(%rsp)
movb -0x19(%rsp), %al
testb $0x1, %al
jne 0x8a8e3
jmp 0x8a9f4
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rsp), %rcx
cmpq 0x48(%rcx), %rax
jne 0x8a926
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rsp), %rcx
cmpq 0x48(%rcx), %rax
je 0x8a926
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x38(%rax)
jmp 0x8a9e2
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rsp), %rcx
cmpq 0x48(%rcx), %rax
jne 0x8a966
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rsp), %rcx
cmpq 0x48(%rcx), %rax
je 0x8a966
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x38(%rax)
jmp 0x8a9e0
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rsp), %rcx
cmpq 0x48(%rcx), %rax
je 0x8a9de
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rsp), %rcx
cmpq 0x48(%rcx), %rax
je 0x8a9de
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
movq -0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
cmpq 0x38(%rcx), %rax
jbe 0x8a9be
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0x8a9d0
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x38(%rax)
jmp 0x8a9e0
jmp 0x8a9e2
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0x8a8af
retq
nopw %cs:(%rax,%rax)