LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: kvmap_api_helper
int
kvmap_api_helper(int argc, char ** const argv, struct kvmap_api ** const out, struct kvmap_mm * const mm, const bool use_ucache)
{
  if (argc < 3 || strcmp(argv[0], "api") != 0) {
    return -1;
  }
  const u64 mb = strtoull(argv[1], NULL, 10);
  if (mb == 0) {
    // no icache
    return 2 + kvmap_api_helper_map(argc - 2, argv + 2, out, mm);
  }

  // index + icache
  struct icache * const cache = icache_create(NULL, mb);
  if (cache == NULL) {
    fprintf(stderr, "icache_create() failed\n");
    return -1;
  }
  icache_wrap_mm(cache, mm);
  struct kvmap_api * map_api = NULL;
  const int n1 = kvmap_api_helper_map(argc - 2, argv + 2, &map_api, mm);
  if (n1 < 0) {
    icache_destroy(cache);
    return -1;
  }
  struct kvmap_api * const icache_api = use_ucache ? ucache_api_create(cache) : icache_api_create(cache);
  if (icache_api == NULL) {
    kvmap_api_destroy(map_api);
    icache_destroy(cache);
    return -1;
  }
  icache_wrap_kvmap(cache, map_api);
  *out = icache_api;
  return 2 + n1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
pushq $-0x1
popq %rbx
cmpl $0x3, %edi
jl 0xae1c
movl %r8d, %r15d
movq %rcx, %r12
movq %rsi, %r13
movl %edi, %r14d
movq %rdx, -0x38(%rbp)
movq (%rsi), %rdi
leaq 0x77bd(%rip), %rsi      # 0x12518
callq 0x62f0
testl %eax, %eax
jne 0xae1c
movq 0x8(%r13), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x62c0
testq %rax, %rax
je 0xadd4
xorl %edi, %edi
movq %rax, %rsi
callq 0xafb2
testq %rax, %rax
je 0xae3f
movq %rax, %rdi
movq %rax, -0x30(%rbp)
movq %r12, %rsi
callq 0xb0ca
leaq -0x40(%rbp), %rdx
andq $0x0, (%rdx)
addl $-0x2, %r14d
addq $0x10, %r13
movl %r14d, %edi
movq %r13, %rsi
movq %r12, %rcx
callq 0xae5d
testl %eax, %eax
js 0xadf2
movl %eax, %ebx
movq -0x30(%rbp), %r14
movq %r14, %rdi
testb %r15b, %r15b
je 0xadfd
callq 0xb189
jmp 0xae02
addl $-0x2, %r14d
addq $0x10, %r13
movl %r14d, %edi
movq %r13, %rsi
movq -0x38(%rbp), %rdx
movq %r12, %rcx
callq 0xae5d
movl %eax, %ebx
jmp 0xae19
movq -0x30(%rbp), %rdi
callq 0xb136
jmp 0xae1c
callq 0xb21e
movq -0x40(%rbp), %rdi
testq %rax, %rax
je 0xae2d
movq %rdi, 0x10150(%r14)
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
addl $0x2, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xac58
movq %r14, %rdi
callq 0xb136
pushq $-0x1
popq %rbx
jmp 0xae1c
movq 0xe1b2(%rip), %rax      # 0x18ff8
movq (%rax), %rcx
leaq 0x76cc(%rip), %rdi      # 0x1251c
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
callq 0x6550
jmp 0xae1c
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: kvmap_api_helper_map
static int
kvmap_api_helper_map(int argc, char ** const argv, struct kvmap_api ** const out, struct kvmap_mm * const mm)
{
  if (argc < 1) {
    return -1;
  }
  struct kvmap_api * tmp = NULL;
  int used = 0;
  if (strcmp("kvmap2", argv[0]) == 0) {
    tmp = kvmap2_api_create(kvmap2_create(mm));
    used = 1;
  } else if (strcmp("cuckoo", argv[0]) == 0) {
    tmp = cuckoo_api_create(cuckoo_create(mm));
    used = 1;
  } else if (strcmp("skiplist", argv[0]) == 0) {
    tmp = skiplist_api_create(skiplist_create(mm));
    used = 1;
  } else if (strcmp("chainmap", argv[0]) == 0) {
    tmp = chainmap_api_create(chainmap_create(mm));
    used = 1;
  } else if (strcmp("bptree", argv[0]) == 0) {
    tmp = bptree_api_create(bptree_create(mm));
    used = 1;
  } else if (strcmp("tcpmap", argv[0]) == 0) {
    if (argc < 3) return -1;
    tmp = tcpmap_api_create(tcpmap_create(argv[1], atoi(argv[2])));
    used = 3;
  }
  if (used > 0 && tmp) {
    *out = tmp;
    return used;
  } else {
    return -1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, -0x30(%rbp)
movq %rsi, %r15
movl %edi, %r13d
movq (%rsi), %rbx
leaq 0x78b9(%rip), %rdi      # 0x1273b
movq %rbx, %rsi
callq 0x62f0
pushq $-0x1
popq %r14
testl %eax, %eax
je 0xaf36
leaq 0x78a5(%rip), %rdi      # 0x12742
movq %rbx, %rsi
callq 0x62f0
testl %eax, %eax
je 0xaf48
leaq 0x7895(%rip), %rdi      # 0x12749
movq %rbx, %rsi
callq 0x62f0
testl %eax, %eax
je 0xaf5a
leaq 0x7887(%rip), %rdi      # 0x12752
movq %rbx, %rsi
callq 0x62f0
testl %eax, %eax
je 0xaf6c
leaq 0x7879(%rip), %rdi      # 0x1275b
movq %rbx, %rsi
callq 0x62f0
testl %eax, %eax
je 0xaf7e
leaq 0x7869(%rip), %rdi      # 0x12762
movq %rbx, %rsi
callq 0x62f0
cmpl $0x3, %r13d
jl 0xafa0
testl %eax, %eax
jne 0xafa0
movq 0x8(%r15), %rbx
movq 0x10(%r15), %rdi
callq 0x64e0
movq %rbx, %rdi
movl %eax, %esi
callq 0xe9e6
movq %rax, %rdi
callq 0xec82
pushq $0x3
jmp 0xaf90
movq %r12, %rdi
callq 0xb2c0
movq %rax, %rdi
callq 0xc4db
jmp 0xaf8e
movq %r12, %rdi
callq 0xc570
movq %rax, %rdi
callq 0xd08b
jmp 0xaf8e
movq %r12, %rdi
callq 0xd1ce
movq %rax, %rdi
callq 0xd800
jmp 0xaf8e
movq %r12, %rdi
callq 0xd895
movq %rax, %rdi
callq 0xdfcb
jmp 0xaf8e
movq %r12, %rdi
callq 0xe060
movq %rax, %rdi
callq 0xe951
pushq $0x1
popq %rcx
testq %rax, %rax
je 0xafa0
movq -0x30(%rbp), %rdx
movq %rax, (%rdx)
movl %ecx, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: icache_create
struct icache *
icache_create(const struct kvmap_mm * const mm, const u64 nr_mb)
{
  debug_assert(ICACHE_ENTRY_NR == 15 || ICACHE_ENTRY_NR == 7);
  debug_assert((sizeof(struct __icache_slot) % 64) == 0);
  debug_assert((sizeof(struct __icache_hist) % 8) == 0);

  struct icache * const cache = (typeof(cache))malloc(sizeof(*cache));
  memset(cache, 0, sizeof(*cache));
  cache->mm = mm ? (*mm) : __kvmap_mm_default;
  for (u64 i = 0; i < KVMAP_HLOCK_NR; i++) {
    spinlock_init(&(cache->hlocks[i]));
  }
  const u64 table_size = nr_mb << 20;
  const u64 nr_slots = table_size / sizeof(cache->table[0]);
  struct __icache_slot * const table = pages_alloc_best(table_size, false, &(cache->slots_alloc_size));
  if (table == NULL) {
    free(cache);
    return NULL;
  }
  debug_assert(nr_slots % KVMAP_HLOCK_NR == 0);
  cache->table = table;
  cache->nr_slots = nr_slots;

  const u64 nr_hists = nr_slots * 16;
  const u64 hists_size = nr_hists * sizeof(cache->hists[0]);
  struct __icache_hist * const hists = pages_alloc_best(hists_size, false, &(cache->hists_alloc_size));
  if (hists == NULL) {
    pages_unmap(table, cache->slots_alloc_size);
    free(cache);
    return NULL;
  }

  cache->nr_hists = nr_hists;
  cache->hists = hists;
  return cache;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
movl $0x10158, %esi          # imm = 0x10158
callq 0x62d0
movq %rax, %rbx
testq %r15, %r15
je 0xaff5
vmovups (%r15), %ymm0
vmovups 0x20(%r15), %ymm1
vmovups 0x30(%r15), %ymm2
vmovups %ymm2, 0x30(%rbx)
vmovups %ymm1, 0x20(%rbx)
jmp 0xb017
vmovups 0xddbb(%rip), %ymm0     # 0x18db8
vmovups %ymm0, 0x30(%rbx)
vmovups 0xdd9e(%rip), %ymm0     # 0x18da8
vmovups %ymm0, 0x20(%rbx)
vmovups 0xdd71(%rip), %ymm0     # 0x18d88
vmovups %ymm0, (%rbx)
movl $0xe0, %r15d
cmpq $0x100e0, %r15          # imm = 0x100E0
je 0xb03c
leaq (%rbx,%r15), %rdi
vzeroupper
callq 0x6aec
addq $0x40, %r15
jmp 0xb021
movq %r14, %r15
shlq $0x14, %r15
leaq 0x10128(%rbx), %rdx
movq %r15, %rdi
xorl %esi, %esi
vzeroupper
callq 0x7c29
testq %rax, %rax
je 0xb0b4
movq %rax, %r12
movq %r15, %rax
shrq $0x6, %rax
movq %r12, 0x10130(%rbx)
movq %rax, 0x10120(%rbx)
shlq $0x16, %r14
movq %rbx, %rdx
addq $0x10140, %rdx          # imm = 0x10140
movq %r14, %rdi
xorl %esi, %esi
callq 0x7c29
testq %rax, %rax
je 0xb0a5
shrq $0x2, %r15
movq %r15, 0x10138(%rbx)
movq %rax, 0x10148(%rbx)
jmp 0xb0be
movq 0x10128(%rbx), %rsi
movq %r12, %rdi
callq 0x6410
movq %rbx, %rdi
callq 0x6060
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: icache_wrap_mm
inline void
icache_wrap_mm(struct icache * const cache, struct kvmap_mm * const mm)
{
  cache->map_mm = *mm;
  if (mm->rf) {
    mm->rf = __icache_kv_retire_cb;
    mm->rp = cache;
    mm->uf = __icache_kv_uncache_cb;
    mm->up = cache;
  }
  mm->hf = __icache_kv_hit_cb;
  mm->hp = cache;
  mm->xf = __icache_kv_refresh_cb;
  mm->xp = cache;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
vmovups (%rsi), %ymm0
vmovups 0x20(%rsi), %ymm1
vmovups 0x30(%rsi), %ymm2
vmovups %ymm2, 0x80(%rdi)
vmovups %ymm1, 0x70(%rdi)
vmovups %ymm0, 0x50(%rdi)
cmpq $0x0, 0x10(%rsi)
je 0xb113
leaq 0x43c2(%rip), %rax      # 0xf4be
movq %rax, 0x10(%rsi)
movq %rdi, 0x18(%rsi)
leaq 0x43c6(%rip), %rax      # 0xf4d1
movq %rax, 0x30(%rsi)
movq %rdi, 0x38(%rsi)
leaq 0x43ca(%rip), %rax      # 0xf4e4
movq %rax, 0x20(%rsi)
movq %rdi, 0x28(%rsi)
leaq 0x43ce(%rip), %rax      # 0xf4f7
movq %rax, 0x40(%rsi)
movq %rdi, 0x48(%rsi)
popq %rbp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: icache_destroy
void
icache_destroy(struct icache * const cache)
{
  icache_clean(cache);
  pages_unmap(cache->table, cache->slots_alloc_size);
  pages_unmap(cache->hists, cache->hists_alloc_size);
  if (cache->map_api) {
    kvmap_api_destroy(cache->map_api);
  }
  free(cache);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xefb3
movq 0x10128(%rbx), %rsi
movq 0x10130(%rbx), %rdi
callq 0x6410
movq 0x10140(%rbx), %rsi
movq 0x10148(%rbx), %rdi
callq 0x6410
movq 0x10150(%rbx), %rdi
testq %rdi, %rdi
je 0xb17b
callq 0xac58
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6060
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: kvmap2_create
struct kvmap2 *
kvmap2_create(const struct kvmap_mm * const mm)
{
  struct kvmap2 * const map2 = calloc(1, sizeof(*map2));
  map2->mm = mm ? (*mm) : __kvmap_mm_default;
  map2->sz_shift = 5;
  map2->maps[0] = kvmap1_create(mm, 0);
  map2->maps[1] = kvmap1_create(mm, 19);
  return map2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x68
popq %rsi
callq 0x62d0
movq %rax, %r14
testq %rbx, %rbx
je 0xb2f9
vmovups (%rbx), %ymm0
vmovups 0x20(%rbx), %ymm1
vmovups 0x30(%rbx), %ymm2
vmovups %ymm2, 0x30(%r14)
vmovups %ymm1, 0x20(%r14)
jmp 0xb31d
vmovups 0xdab7(%rip), %ymm0     # 0x18db8
vmovups %ymm0, 0x30(%r14)
vmovups 0xda99(%rip), %ymm0     # 0x18da8
vmovups %ymm0, 0x20(%r14)
vmovups 0xda6b(%rip), %ymm0     # 0x18d88
vmovups %ymm0, (%r14)
movq $0x5, 0x50(%r14)
movq %rbx, %rdi
xorl %esi, %esi
vzeroupper
callq 0xb352
movq %rax, 0x58(%r14)
pushq $0x13
popq %rsi
movq %rbx, %rdi
callq 0xb352
movq %rax, 0x60(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: kvmap1_create
static struct kvmap1 *
kvmap1_create(const struct kvmap_mm * const mm, const u64 hash_rotate)
{
  struct kvmap1 * const map = xalloc(64, sizeof(*map));
  memset(map, 0, sizeof(*map));

  map->mm = mm ? (*mm) : __kvmap_mm_default;
  map->hash_rotate = hash_rotate;

  for (u64 j = 0; j < KVMAP_HLOCK_NR; j++) {
    spinlock_init(&(map->hlocks[j]));
  }
  spinlock_init(&(map->split_lock));

  kvmap1_init(map);
  return map;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
pushq $0x40
popq %rdi
movl $0x10928, %esi          # imm = 0x10928
callq 0x7b93
movq %rax, %rbx
movl $0x10928, %edx          # imm = 0x10928
movq %rax, %rdi
xorl %esi, %esi
callq 0x6210
testq %r15, %r15
je 0xb3a3
vmovups (%r15), %ymm0
vmovups 0x20(%r15), %ymm1
vmovups 0x30(%r15), %ymm2
vmovups %ymm2, 0x30(%rbx)
vmovups %ymm1, 0x20(%rbx)
jmp 0xb3c5
vmovups 0xda0d(%rip), %ymm0     # 0x18db8
vmovups %ymm0, 0x30(%rbx)
vmovups 0xd9f0(%rip), %ymm0     # 0x18da8
vmovups %ymm0, 0x20(%rbx)
vmovups 0xd9c3(%rip), %ymm0     # 0x18d88
vmovups %ymm0, (%rbx)
movq %r14, 0x50(%rbx)
movl $0xe8, %r14d
cmpq $0x100e8, %r14          # imm = 0x100E8
je 0xb3ee
leaq (%rbx,%r14), %rdi
vzeroupper
callq 0x6aec
addq $0x40, %r14
jmp 0xb3d3
movq %rbx, %rdi
addq $0x100e8, %rdi          # imm = 0x100E8
vzeroupper
callq 0x6aec
movq %rbx, %rdi
callq 0x10700
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: kvmap2_get
struct kv *
kvmap2_get(struct kvmap2 * const map2, const struct kv * const key, struct kv * const out)
{
  u64 i = UINT64_MAX;
  u64 j = UINT64_MAX;
  u64 k = UINT64_MAX;
  kvmap1_lock_hash(map2->maps[0], key);
  for (u64 x = 0; x < 2; x++) {
    struct kvmap1 * const map = map2->maps[x];
    if (kvmap1_locate_key(map, key, &i, &j, &k)) {
      struct kv * const curr = __u64_to_ptr(map->levels[i].table[j].e[k].ptr);
      if (map2->mm.hf) map2->mm.hf(curr, map2->mm.hp);
      struct kv * const ret = kv_dup2(curr, out);
      kvmap1_unlock_hash(map2->maps[x], key);
      return ret;
    }
    if (x == 0) {
      kvmap1_lock_hash(map2->maps[1], key);
    }
    kvmap1_unlock_hash(map2->maps[x], key);
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq -0x38(%rbp), %rax
orq $-0x1, (%rax)
leaq -0x30(%rbp), %rax
orq $-0x1, (%rax)
movq %rdx, -0x40(%rbp)
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x48(%rbp), %r15
orq $-0x1, (%r15)
movq 0x58(%rdi), %rdi
callq 0xb505
xorl %r13d, %r13d
cmpq $0x2, %r13
je 0xb49d
movq 0x58(%r14,%r13,8), %r12
movq %r12, %rdi
movq %rbx, %rsi
leaq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movq %r15, %r8
callq 0xb527
testb %al, %al
jne 0xb4a1
testq %r13, %r13
jne 0xb48b
movq 0x60(%r14), %rdi
movq %rbx, %rsi
callq 0xb505
movq 0x58(%r14,%r13,8), %rdi
movq %rbx, %rsi
callq 0xb5da
incq %r13
jmp 0xb455
xorl %eax, %eax
jmp 0xb4f6
movq -0x38(%rbp), %rax
shlq $0x5, %rax
movq -0x30(%rbp), %rcx
shlq $0x6, %rcx
addq 0x10128(%r12,%rax), %rcx
movq -0x48(%rbp), %rax
movq (%rcx,%rax,8), %r15
shrq $0x10, %r15
movq 0x20(%r14), %rax
testq %rax, %rax
je 0xb4d7
movq 0x28(%r14), %rsi
movq %r15, %rdi
callq *%rax
movq %r15, %rdi
movq -0x40(%rbp), %rsi
callq 0xaa68
movq %rax, %r15
movq 0x58(%r14,%r13,8), %rdi
movq %rbx, %rsi
callq 0xb5da
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: kvmap1_locate_key
static bool
kvmap1_locate_key(const struct kvmap1 * const map, const struct kv * const key,
    u64 * const out_level, u64 * const out_index, u64 * const out_entry)
{
  const u64 hash = bits_rotl_u64(key->hash, map->hash_rotate);
  const u64 pkey = kvmap_pkey(hash);
  kvmap1_locate_level(map, hash, out_level, out_index);
  const struct __kvmap_slot * const slot = &(map->levels[*out_level].table[*out_index]);
  u64 used = 0;
  for (u64 k = 0; k < 8; k++) {
    if (slot->e[k].ptr) {
      used++;
      if (slot->e[k].pkey == pkey) {
        const struct kv * const curr = __u64_to_ptr(slot->e[k].ptr);
        if (kv_keymatch(key, curr)) {
          *out_entry = k;
          return true;
        }
      }
    }
  }
  *out_entry = used;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rsi
movb 0x50(%rdi), %cl
rolq %cl, %rsi
movq %r8, -0x30(%rbp)
movq %rdx, %r13
movq %rsi, %rax
shrq $0x20, %rax
xorq %rsi, %rax
movq %rax, %rbx
shrq $0x10, %rbx
xorq %rax, %rbx
movq %r12, %rcx
callq 0x10795
movq (%r13), %rax
shlq $0x5, %rax
movq (%r12), %r12
shlq $0x6, %r12
addq 0x10128(%r15,%rax), %r12
xorl %r15d, %r15d
xorl %r13d, %r13d
cmpq $0x8, %r13
je 0xb5bd
movq (%r12,%r13,8), %rsi
cmpq $0x10000, %rsi          # imm = 0x10000
jb 0xb5b5
incq %r15
movl %ebx, %eax
xorw %si, %ax
jne 0xb5b5
shrq $0x10, %rsi
movq %r14, %rdi
callq 0xab0c
testb %al, %al
jne 0xb5ba
incq %r13
jmp 0xb588
movq %r13, %r15
cmpq $0x8, %r13
setb %al
movq -0x30(%rbp), %rcx
movq %r15, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: kvmap2_probe
bool
kvmap2_probe(struct kvmap2 * const map2, const struct kv * const key)
{
  u64 i = UINT64_MAX;
  u64 j = UINT64_MAX;
  u64 k = UINT64_MAX;
  kvmap1_lock_hash(map2->maps[0], key);
  for (u64 x = 0; x < 2; x++) {
    struct kvmap1 * const map = map2->maps[x];
    if (kvmap1_locate_key(map, key, &i, &j, &k)) {
      struct kv * const curr = __u64_to_ptr(map->levels[i].table[j].e[k].ptr);
      if (map2->mm.hf) map2->mm.hf(curr, map2->mm.hp);
      kvmap1_unlock_hash(map2->maps[x], key);
      return true;
    }
    if (x == 0) {
      kvmap1_lock_hash(map2->maps[1], key);
    }
    kvmap1_unlock_hash(map2->maps[x], key);
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq -0x38(%rbp), %rax
orq $-0x1, (%rax)
leaq -0x30(%rbp), %rax
orq $-0x1, (%rax)
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x40(%rbp), %r13
orq $-0x1, (%r13)
movq 0x58(%rdi), %rdi
callq 0xb505
xorl %r12d, %r12d
cmpq $0x2, %r12
je 0xb6c4
movq 0x58(%r14,%r12,8), %r15
movq %r15, %rdi
movq %rbx, %rsi
leaq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movq %r13, %r8
callq 0xb527
testb %al, %al
jne 0xb684
testq %r12, %r12
jne 0xb672
movq 0x60(%r14), %rdi
movq %rbx, %rsi
callq 0xb505
movq 0x58(%r14,%r12,8), %rdi
movq %rbx, %rsi
callq 0xb5da
incq %r12
jmp 0xb638
movq 0x20(%r14), %rax
testq %rax, %rax
je 0xb6b7
movq -0x38(%rbp), %rcx
shlq $0x5, %rcx
movq -0x30(%rbp), %rdx
shlq $0x6, %rdx
addq 0x10128(%r15,%rcx), %rdx
movq -0x40(%rbp), %rcx
movq (%rdx,%rcx,8), %rdi
shrq $0x10, %rdi
movq 0x28(%r14), %rsi
callq *%rax
movq 0x58(%r14,%r12,8), %rdi
movq %rbx, %rsi
callq 0xb5da
cmpq $0x2, %r12
setb %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: kv_alloc_dup
static inline struct kv *
kv_alloc_dup(const struct kv * const kv, const struct kvmap_mm * const mm)
{
  const u64 sz = kv_size(kv);
  struct kv * const new = mm->af(sz, mm->ap);
  debug_assert(new);
  memcpy(new, kv, sz);
  return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %edx
leaq (%rcx,%rdx), %r14
addq $0x10, %r14
movq 0x8(%rsi), %rsi
movq %r14, %rdi
callq *(%rax)
movq %rax, %r15
testq %rax, %rax
jne 0xba5d
callq 0x6e43
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6340
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: kvmap1_put_entry
static inline void
kvmap1_put_entry(struct kvmap1 * const map, struct __kvmap_entry * const e, const struct kv * const kv)
{
  struct kv * const old = __u64_to_ptr(e->ptr);
  if (old && map->mm.rf) {
    map->mm.rf(old, map->mm.rp);
  }
  e->ptr = __ptr_to_u64(kv);
  e->pkey = kv ? kvmap_pkey(bits_rotl_u64(kv->hash, map->hash_rotate)) : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rdi
cmpq $0x10000, %rdi          # imm = 0x10000
jb 0xbaaa
movq 0x10(%r15), %rax
testq %rax, %rax
je 0xbaaa
shrq $0x10, %rdi
movq 0x18(%r15), %rsi
callq *%rax
movzwl (%rbx), %edi
movq %r14, %rax
shlq $0x10, %rax
movzwl %di, %ecx
orq %rax, %rcx
movq %rcx, (%rbx)
testq %r14, %r14
je 0xbade
movq (%r14), %rdx
movb 0x50(%r15), %cl
rolq %cl, %rdx
movq %rdx, %rcx
shrq $0x20, %rcx
xorl %edx, %ecx
movl %ecx, %edx
shrl $0x10, %edx
xorl %ecx, %edx
movzwl %dx, %ecx
jmp 0xbae0
xorl %ecx, %ecx
orq %rax, %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: kvmap2_del
bool
kvmap2_del(struct kvmap2 * const map2, const struct kv * const key)
{
  u64 i = UINT64_MAX;
  u64 j = UINT64_MAX;
  u64 k = UINT64_MAX;
  kvmap1_lock_hash(map2->maps[0], key);
  for (u64 x = 0; x < 2; x++) {
    struct kvmap1 * const map = map2->maps[x];
    if (kvmap1_locate_key(map, key, &i, &j, &k)) {
      struct __kvmap_entry * const e = &(map->levels[i].table[j].e[k]);
      //(void)atomic_fetch_sub(&(map->nr_kv), 1);
      (void)atomic_fetch_sub(&(map->levels[i].nr_kv), 1);
      kvmap1_put_entry(map, e, NULL);
      kvmap1_unlock_hash(map2->maps[x], key);
      return true;
    }
    if (x == 0) {
      kvmap1_lock_hash(map2->maps[1], key);
    }
    kvmap1_unlock_hash(map2->maps[x], key);
  }
  return false;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq -0x38(%rbp), %rax
orq $-0x1, (%rax)
leaq -0x30(%rbp), %rax
orq $-0x1, (%rax)
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x40(%rbp), %r13
orq $-0x1, (%r13)
movq 0x58(%rdi), %rdi
callq 0xb505
xorl %r12d, %r12d
cmpq $0x2, %r12
je 0xbef2
movq 0x58(%r14,%r12,8), %r15
movq %r15, %rdi
movq %rbx, %rsi
leaq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movq %r13, %r8
callq 0xb527
testb %al, %al
jne 0xbeb2
testq %r12, %r12
jne 0xbea0
movq 0x60(%r14), %rdi
movq %rbx, %rsi
callq 0xb505
movq 0x58(%r14,%r12,8), %rdi
movq %rbx, %rsi
callq 0xb5da
incq %r12
jmp 0xbe66
movq -0x38(%rbp), %rax
shlq $0x5, %rax
movq -0x30(%rbp), %rcx
shlq $0x6, %rcx
addq 0x10128(%r15,%rax), %rcx
movq -0x40(%rbp), %rdx
leaq (%rcx,%rdx,8), %rsi
lock
decq 0x10140(%r15,%rax)
movq %r15, %rdi
xorl %edx, %edx
callq 0xba75
movq 0x58(%r14,%r12,8), %rdi
movq %rbx, %rsi
callq 0xb5da
cmpq $0x2, %r12
setb %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: kvmap1_clean
static void
kvmap1_clean(struct kvmap1 * const map)
{
  for (u64 i = map->max_level; i >= KVMAP_MIN_LEVEL; i--) {
    struct __kvmap1_level * const level = &(map->levels[i]);
    if (level->bm == NULL) continue;
    const u64 nr_slots = KVMAP_SLOTS_OF(i);
    for (u64 j = 0; j < nr_slots; j++) {
      if (bitmap_test(level->bm, j)) {
        struct __kvmap_slot * const slot = &(level->table[j]);
        for (u64 k = 0; k < 8; k++) {
          struct __kvmap_entry * const e = &(slot->e[k]);
          if (e->ptr) {
            kvmap1_put_entry(map, e, NULL);
            //(void)atomic_fetch_sub(&(map->nr_kv), 1);
            (void)atomic_fetch_sub(&(level->nr_kv), 1);
          }
        }
      }
    }
    debug_assert(atomic_load(&(level->nr_kv)) == 0);
    if (level->table) {
      pages_unmap(level->table, level->alloc_size);
      level->table = NULL;
    }
    free(level->bm);
    level->bm = NULL;
  }
  debug_assert(atomic_load(&(map->nr_kv)) == 0);
  kvmap1_init(map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x58(%rdi), %r15
leaq 0x10128(%rdi), %rax
movq %rax, -0x38(%rbp)
cmpq $0xf, %r15
jbe 0xc01c
movq %r15, %r13
shlq $0x5, %r13
cmpq $0x0, 0x8(%rax,%r13)
je 0xc014
addq %rax, %r13
movq $0x0, -0x30(%rbp)
xorl %r14d, %r14d
movq %r15, -0x40(%rbp)
shrxq %r15, %r14, %rax
testq %rax, %rax
jne 0xbfdd
movq 0x8(%r13), %rdi
movq %r14, %rsi
callq 0x7337
testb %al, %al
je 0xbfcf
movq (%r13), %r15
addq -0x30(%rbp), %r15
xorl %r12d, %r12d
cmpq $0x40, %r12
je 0xbfcf
cmpq $0x10000, (%r15,%r12)   # imm = 0x10000
jb 0xbfc9
leaq (%r15,%r12), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xba75
lock
decq 0x18(%r13)
addq $0x8, %r12
jmp 0xbfa6
incq %r14
addq $0x40, -0x30(%rbp)
movq -0x40(%rbp), %r15
jmp 0xbf81
movq 0x18(%r13), %rax
testq %rax, %rax
je 0xbfeb
callq 0x6e43
movq (%r13), %rdi
testq %rdi, %rdi
je 0xc002
movq 0x10(%r13), %rsi
callq 0x6410
andq $0x0, (%r13)
movq 0x8(%r13), %rdi
callq 0x6060
andq $0x0, 0x8(%r13)
movq -0x38(%rbp), %rax
decq %r15
jmp 0xbf52
movq 0xa8(%rbx), %rax
testq %rax, %rax
je 0xc02d
callq 0x6e43
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10700
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: kvmap2_fprint
void
kvmap2_fprint(struct kvmap2 * const map2, FILE * const out)
{
  //u64 sum_kv = 0;
  //for (u64 x = 0; x < 2; x++) {
  //  sum_kv += atomic_load(&(map2->maps[x]->nr_kv));
  //}
  //const double sum100 = ((double)sum_kv) * 0.01;

  //fprintf(out, "KVMAP2 sz_shift %"PRIu64" nr_kv %"PRIu64"\n", map2->sz_shift, sum_kv);
  for (u64 x = 0; x < 2; x++) {
    //const u64 nr_kv = atomic_load(&(map2->maps[x]->nr_kv));
    //fprintf(out, "  KVMAP2 %"PRIu64" %.2lf%% ||| ", x, ((double)nr_kv) / sum100);
    kvmap1_fprint(map2->maps[x], out);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x48(%rbp)
xorl %edx, %edx
cmpq $0x2, %rdx
je 0xc237
movq -0x48(%rbp), %rax
movq 0x58(%rax,%rdx,8), %rsi
leaq 0x10128(%rsi), %r12
xorl %eax, %eax
xorl %r15d, %r15d
cmpq $0x800, %rax            # imm = 0x800
je 0xc103
cmpq $0x0, (%r12,%rax)
je 0xc0fd
cmpq $0x0, 0x8(%r12,%rax)
je 0xc0fd
movq 0x18(%r12,%rax), %rcx
addq %rcx, %r15
addq $0x20, %rax
jmp 0xc0de
movq %rdx, -0x50(%rbp)
movq 0x50(%rsi), %rdx
movq -0x30(%rbp), %rdi
movq %rsi, -0x38(%rbp)
leaq 0x664f(%rip), %rsi      # 0x12769
movq %r15, %rcx
xorl %eax, %eax
callq 0x6300
movq -0x38(%rbp), %rcx
vcvtusi2sd %r15, %xmm2, %xmm0
vmulsd 0x5f7a(%rip), %xmm0, %xmm0 # 0x120b0
vmovsd %xmm0, -0x58(%rbp)
xorl %r13d, %r13d
xorl %r15d, %r15d
xorl %r14d, %r14d
xorl %edx, %edx
cmpq $0x40, %r15
je 0xc209
cmpq $0x0, (%r12)
je 0xc1fa
cmpq $0x0, 0x8(%r12)
je 0xc1fa
movq %rdx, -0x40(%rbp)
movq 0x18(%r12), %rbx
movq 0x8(%r12), %rax
movq 0x8(%rax), %r8
vcvtusi2sd %r8, %xmm2, %xmm0
pushq $0x1
popq %rax
shlxq %r15, %rax, %r9
vcvtusi2sd %r9, %xmm2, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
cmpq 0x68(%rcx), %r15
vmulsd 0x5ecb(%rip), %xmm0, %xmm0 # 0x12068
pushq $0x20
popq %rdx
pushq $0x2a
popq %rax
cmovel %eax, %edx
pushq $0x8
popq %rax
shlxq %r15, %rax, %r10
vcvtusi2sd %rbx, %xmm2, %xmm1
vdivsd -0x58(%rbp), %xmm1, %xmm1
movq -0x30(%rbp), %rdi
leaq 0x65be(%rip), %rsi      # 0x12782
movq %r15, %rcx
movb $0x2, %al
pushq %r10
pushq %rbx
callq 0x6300
movq -0x38(%rbp), %rcx
addq $0x10, %rsp
movq %r15, %rax
subq 0x68(%rcx), %rax
jae 0xc1e9
movq 0x58(%rcx), %rax
addq %r13, %rax
movq -0x40(%rbp), %rdx
addq %rbx, %rdx
incq %rax
imulq %rbx, %rax
addq %rax, %r14
incq %r15
decq %r13
addq $0x20, %r12
jmp 0xc146
vcvtusi2sd %r14, %xmm2, %xmm0
vcvtusi2sd %rdx, %xmm2, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
movq -0x30(%rbp), %rdi
leaq 0x658f(%rip), %rsi      # 0x127b3
movb $0x1, %al
callq 0x6300
movq -0x50(%rbp), %rdx
incq %rdx
jmp 0xc0bf
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: kvmap2_iter_create
inline struct kvmap2_iter *
kvmap2_iter_create(struct kvmap2 * const map2)
{
  struct kvmap2_iter * const iter2 = (typeof(iter2))malloc(sizeof(*iter2));
  iter2->map2 = map2;
  iter2->map_id = 0;
  for (u64 x = 0; x < 2; x++) {
    iter2->iters[x] = kvmap1_iter_create(map2->maps[x]);
  }
  iter2->iter = iter2->iters[0];
  return iter2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0x63a0
movq %rax, %r14
movq %rbx, -0x30(%rbp)
movq %rbx, (%rax)
andq $0x0, 0x8(%rax)
xorl %r13d, %r13d
cmpq $0x2, %r13
je 0xc2db
movq -0x30(%rbp), %rax
movq 0x58(%rax,%r13,8), %r15
pushq $0x20
popq %rdi
callq 0x63a0
movq %rax, %r12
testq %rax, %rax
je 0xc2d1
movl $0xe8, %ebx
cmpq $0x100e8, %rbx          # imm = 0x100E8
je 0xc2ad
leaq (%r15,%rbx), %rdi
callq 0x6afb
addq $0x40, %rbx
jmp 0xc295
leaq 0x100e8(%r15), %rdi
callq 0x6afb
movq %r15, (%r12)
movq 0x58(%r15), %rax
movq %rax, 0x8(%r12)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x10(%r12)
movq %r12, 0x18(%r14,%r13,8)
incq %r13
jmp 0xc271
movq 0x18(%r14), %rax
movq %rax, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: kvmap2_iter_next
struct kv *
kvmap2_iter_next(struct kvmap2_iter * const iter2, struct kv * const out)
{
  struct kv * const ret = kvmap1_iter_next(iter2->iter, out);
  if (ret == NULL) {
    iter2->iter = NULL;
    iter2->map_id++;
    if (iter2->map_id < 2) {
      iter2->iter = iter2->iters[iter2->map_id];
      return kvmap1_iter_next(iter2->iter, out);
    }
  }
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0xc340
testq %rax, %rax
jne 0xc33b
andq $0x0, 0x10(%r14)
movq 0x8(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%r14)
cmpq $0x1, %rcx
ja 0xc339
movq 0x20(%r14,%rax,8), %rdi
movq %rdi, 0x10(%r14)
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xc340
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: kvmap1_iter_next
static struct kv *
kvmap1_iter_next(struct kvmap1_iter * const iter, struct kv * const out)
{
  u64 i = iter->i;
  u64 j = iter->j;
  u64 k = iter->k;
  struct kv * ret = NULL;
  while (i >= KVMAP_MIN_LEVEL) {
    if (iter->map->levels[i].table == NULL) {
      i--;
      continue;
    }
    struct __kvmap1_level * const level = &(iter->map->levels[i]);
    if (k == 0) { // try skip empty slots at every new j
      while ((j < (1lu << i)) && (bitmap_test(level->bm, j) == false)) j++;
      if (j >= (1lu << i)) {
        j = 0;
        i--;
        continue;
      }
    }
    if (level->table[j].e[k].ptr) {
      struct kv * const kv = __u64_to_ptr(level->table[j].e[k].ptr);
      ret = kv_dup2(kv, out);
    }
    // shift next
    k++;
    if (k >= 8) {
      k = 0;
      j++;
      if (j >= (1lu << i)) {
        j = 0;
        i--;
      }
    }
    if (ret) break;
  }
  iter->i = i;
  iter->j = j;
  iter->k = k;
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x40(%rbp)
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rbx
movq %rdi, -0x38(%rbp)
movq 0x18(%rdi), %r14
movq %r14, -0x30(%rbp)
movq %rcx, %r15
shlq $0x5, %r15
addq $0x10130, %r15          # imm = 0x10130
movq %rcx, %r13
movq -0x38(%rbp), %rax
cmpq $0x10, %r13
jb 0xc436
movq (%rax), %r14
movq -0x8(%r14,%r15), %r12
testq %r12, %r12
jne 0xc39e
decq %r13
addq $-0x20, %r15
jmp 0xc37e
cmpq $0x0, -0x30(%rbp)
jne 0xc3c4
jmp 0xc3aa
incq %rbx
shrxq %r13, %rbx, %rax
testq %rax, %rax
jne 0xc426
movq (%r14,%r15), %rdi
movq %rbx, %rsi
callq 0x7337
testb %al, %al
je 0xc3a7
movq %rbx, %rax
shlq $0x6, %rax
addq %rax, %r12
movq -0x30(%rbp), %r14
movq (%r12,%r14,8), %rdi
cmpq $0x10000, %rdi          # imm = 0x10000
jae 0xc3e3
xorl %eax, %eax
jmp 0xc3f0
shrq $0x10, %rdi
movq -0x40(%rbp), %rsi
callq 0xaa68
incq %r14
cmpq $0x8, %r14
jb 0xc418
incq %rbx
shrxq %r13, %rbx, %rcx
xorl %edx, %edx
testq %rcx, %rcx
setne %dl
movl $0x0, %ecx
cmovneq %rcx, %rbx
subq %rdx, %r13
xorl %r14d, %r14d
movq %r13, %rcx
testq %rax, %rax
je 0xc365
jmp 0xc448
decq %r13
xorl %r14d, %r14d
xorl %ebx, %ebx
movq %r13, %rcx
jmp 0xc365
cmpq $0xf, %rcx
pushq $0xf
popq %r13
cmovbq %rcx, %r13
xorl %eax, %eax
movq -0x30(%rbp), %r14
movq -0x38(%rbp), %rcx
movq %r13, 0x8(%rcx)
movq %rbx, 0x10(%rcx)
movq %r14, 0x18(%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: cuckoo_create
struct cuckoo *
cuckoo_create(const struct kvmap_mm * const mm)
{
  struct cuckoo * const map = xalloc(64, sizeof(*map));
  memset(map, 0, sizeof(*map));

  map->mm = mm ? (*mm) : __kvmap_mm_default;
  for (u64 j = 0; j < KVMAP_HLOCK_NR; j++) {
    spinlock_init(&(map->hlocks[j]));
  }
  mutexlock_init(&(map->expand_lock));

  map->fixed_power = 0;
  if (map->fixed_power == 0) {
    map->bm = bitmap_create(KVMAP_HLOCK_NR);
  }

  cuckoo_init(map);
  return map;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x40
popq %rdi
movl $0x10148, %esi          # imm = 0x10148
callq 0x7b93
movq %rax, %rbx
movl $0x10148, %edx          # imm = 0x10148
movq %rax, %rdi
xorl %esi, %esi
callq 0x6210
testq %r14, %r14
je 0xc5bb
vmovups (%r14), %ymm0
vmovups 0x20(%r14), %ymm1
vmovups 0x30(%r14), %ymm2
vmovups %ymm2, 0x30(%rbx)
vmovups %ymm1, 0x20(%rbx)
jmp 0xc5dd
vmovups 0xc7f5(%rip), %ymm0     # 0x18db8
vmovups %ymm0, 0x30(%rbx)
vmovups 0xc7d8(%rip), %ymm0     # 0x18da8
vmovups %ymm0, 0x20(%rbx)
vmovups 0xc7ab(%rip), %ymm0     # 0x18d88
vmovups %ymm0, (%rbx)
pushq $0x50
popq %r14
cmpq $0x10050, %r14          # imm = 0x10050
je 0xc600
leaq (%rbx,%r14), %rdi
vzeroupper
callq 0x6aec
addq $0x40, %r14
jmp 0xc5e5
movq %rbx, %rdi
addq $0x10050, %rdi          # imm = 0x10050
vzeroupper
callq 0x6b3a
andq $0x0, 0x100d0(%rbx)
movl $0x400, %edi            # imm = 0x400
callq 0x7306
movq %rax, 0x100d8(%rbx)
movq %rbx, %rdi
callq 0xc63b
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: cuckoo_init
static void
cuckoo_init(struct cuckoo * const map)
{
  const u64 power = map->fixed_power > KVMAP_MIN_LEVEL ? map->fixed_power : KVMAP_MIN_LEVEL;
  map->levels[0].power = power;
  map->levels[0].table = pages_alloc_best(KVMAP_SIZE_OF_LEVEL(power), true, &(map->levels[0].alloc_size));
  if (map->fixed_power == 0) {
    bitmap_set_all0(map->bm);
  }
  debug_assert(map->levels[0].table);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x100d0(%rdi), %rax
cmpq $0x11, %rax
pushq $0x10
popq %rcx
cmovaeq %rax, %rcx
movq %rcx, 0x10128(%rdi)
addb $-0x6, %cl
movl $0x1000, %eax           # imm = 0x1000
shlxq %rcx, %rax, %rdi
leaq 0x10120(%rbx), %rdx
pushq $0x1
popq %rsi
callq 0x7c29
movq %rax, 0x10118(%rbx)
cmpq $0x0, 0x100d0(%rbx)
jne 0xc6bd
movq 0x100d8(%rbx), %r14
leaq 0x10(%r14), %rdi
movq (%r14), %rdx
addq $0x3f, %rdx
shrq $0x3, %rdx
andq $-0x8, %rdx
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x6210
xchgq %r15, 0x8(%r14)
movq 0x10118(%rbx), %rax
addq $0x8, %rsp
testq %rax, %rax
je 0xc6cd
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6e43
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: cuckoo_get
struct kv *
cuckoo_get(struct cuckoo * const map, const struct kv * const key, struct kv * const out)
{
  const u64 hash2[2] = {cuckoo_hash(key, 0), cuckoo_hash(key, 1), };
  const u64 pkey = kvmap_pkey(key->hash);

  cuckoo_lock_two(map, key);
  for (u64 x = 0; x < 2; x++) {
    struct __kvmap_slot * const slot = cuckoo_hash_slot(map, hash2[x]);
    for (u64 k = 0; k < 8; k++) {
      if (slot->e[k].pkey == pkey) {
        const struct kv * const curr = __u64_to_ptr(slot->e[k].ptr);
        if (kv_keymatch(key, curr)) {
          if (map->mm.hf) map->mm.hf(curr, map->mm.hp);
          struct kv * const ret = kv_dup2(curr, out);
          cuckoo_unlock_two(map, key);
          return ret;
        }
      }
    }
  }
  cuckoo_unlock_two(map, key);
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, -0x38(%rbp)
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rax, -0x50(%rbp)
rorxq $0x2d, %rax, %rcx
movq %rcx, -0x48(%rbp)
movq %rax, %rcx
shrq $0x20, %rcx
xorq %rax, %rcx
movq %rcx, %r15
shrq $0x10, %r15
xorq %rcx, %r15
callq 0xc7ce
xorl %eax, %eax
movq %r14, -0x30(%rbp)
cmpq $0x2, %rax
je 0xc7bf
movq %rax, -0x40(%rbp)
movq -0x50(%rbp,%rax,8), %rsi
movq %r14, %rdi
callq 0xc84c
movq %rax, %r13
xorl %r14d, %r14d
cmpq $0x8, %r14
je 0xc770
movq (%r13,%r14,8), %r12
movl %r15d, %eax
xorw %r12w, %ax
jne 0xc76b
shrq $0x10, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xab0c
testb %al, %al
jne 0xc77d
incq %r14
jmp 0xc744
movq -0x40(%rbp), %rax
incq %rax
movq -0x30(%rbp), %r14
jmp 0xc723
movq -0x30(%rbp), %r14
movq 0x20(%r14), %rax
testq %rax, %rax
je 0xc793
movq 0x28(%r14), %rsi
movq %r12, %rdi
callq *%rax
movq %r12, %rdi
movq -0x38(%rbp), %rsi
callq 0xaa68
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8c1
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8c1
xorl %eax, %eax
jmp 0xc7b0
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: cuckoo_lock_two
static void
cuckoo_lock_two(struct cuckoo * const map, const struct kv * const key)
{
  const u64 hash2[2] = {cuckoo_hash(key, 0), cuckoo_hash(key, 1), };
  const u64 i1 = kvmap_hlocks_index(hash2[0]);
  const u64 i2 = kvmap_hlocks_index(hash2[1]);
  if (i1 < i2) {
    cuckoo_lock(map, i1);
    cuckoo_lock(map, i2);
  } else if (i1 > i2) {
    cuckoo_lock(map, i2);
    cuckoo_lock(map, i1);
  } else { // equal
    cuckoo_lock(map, i1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r14
movq %r14, %r15
shrq $0x33, %r15
shrl $0x6, %r14d
andl $0x3ff, %r14d           # imm = 0x3FF
andl $0x3ff, %r15d           # imm = 0x3FF
cmpq %r15, %r14
jae 0xc81b
shll $0x6, %r14d
leaq (%rbx,%r14), %rdi
addq $0x50, %rdi
callq 0x6afb
shll $0x6, %r15d
leaq (%rbx,%r15), %r14
addq $0x50, %r14
jmp 0xc83a
addq $0x50, %rbx
cmpl %r15d, %r14d
jbe 0xc833
shll $0x6, %r15d
addq %rbx, %r15
movq %r15, %rdi
callq 0x6afb
shll $0x6, %r14d
addq %rbx, %r14
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6afb
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: cuckoo_hash_slot
static inline struct __kvmap_slot *
cuckoo_hash_slot(struct cuckoo * const map, const u64 hash)
{
  const u64 lid = map->bm ? (bitmap_test(map->bm, kvmap_hlocks_index(hash)) ? 1 : 0) : 0;
  struct __cuckoo_level * const level = &(map->levels[lid]);
  const u64 hidx = __cuckoo_hidx(hash, level->power);
  debug_assert(level->table);
  struct __kvmap_slot * const slot = &(level->table[hidx]);
  return slot;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x100d8(%rdi), %rdi
testq %rdi, %rdi
je 0xc87d
movl %ebx, %esi
shrl $0x6, %esi
andl $0x3ff, %esi            # imm = 0x3FF
callq 0x7337
movzbl %al, %eax
jmp 0xc87f
xorl %eax, %eax
imulq $0x18, %rax, %rax
movq 0x10118(%r14,%rax), %rcx
movq 0x10128(%r14,%rax), %r15
testq %rcx, %rcx
jne 0xc8aa
addq %rax, %r14
addq $0x10118, %r14          # imm = 0x10118
callq 0x6e43
movq (%r14), %rcx
bzhiq %r15, %rbx, %rax
shlq $0x6, %rax
addq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: cuckoo_unlock_two
static void
cuckoo_unlock_two(struct cuckoo * const map, const struct kv * const key)
{
  const u64 hash2[2] = {cuckoo_hash(key, 0), cuckoo_hash(key, 1), };
  const u64 i1 = kvmap_hlocks_index(hash2[0]);
  const u64 i2 = kvmap_hlocks_index(hash2[1]);
  if (i1 < i2) {
    cuckoo_unlock(map, i1);
    cuckoo_unlock(map, i2);
  } else if (i1 > i2) {
    cuckoo_unlock(map, i2);
    cuckoo_unlock(map, i1);
  } else { // equal
    cuckoo_unlock(map, i1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r14
movq %r14, %r15
shrq $0x33, %r15
shrl $0x6, %r14d
andl $0x3ff, %r14d           # imm = 0x3FF
andl $0x3ff, %r15d           # imm = 0x3FF
cmpq %r15, %r14
jae 0xc90e
shll $0x6, %r14d
leaq (%rbx,%r14), %rdi
addq $0x50, %rdi
callq 0x6320
shll $0x6, %r15d
leaq (%rbx,%r15), %r14
addq $0x50, %r14
jmp 0xc92d
addq $0x50, %rbx
cmpl %r15d, %r14d
jbe 0xc926
shll $0x6, %r15d
addq %rbx, %r15
movq %r15, %rdi
callq 0x6320
shll $0x6, %r14d
addq %rbx, %r14
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6320
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: cuckoo_probe
bool
cuckoo_probe(struct cuckoo * const map, const struct kv * const key)
{
  const u64 hash2[2] = {cuckoo_hash(key, 0), cuckoo_hash(key, 1), };
  const u64 pkey = kvmap_pkey(key->hash);

  cuckoo_lock_two(map, key);
  for (u64 x = 0; x < 2; x++) {
    struct __kvmap_slot * const slot = cuckoo_hash_slot(map, hash2[x]);
    for (u64 k = 0; k < 8; k++) {
      if (slot->e[k].pkey == pkey) {
        const struct kv * const curr = __u64_to_ptr(slot->e[k].ptr);
        if (kv_keymatch(key, curr)) {
          if (map->mm.hf) map->mm.hf(curr, map->mm.hp);
          cuckoo_unlock_two(map, key);
          return true;
        }
      }
    }
  }
  cuckoo_unlock_two(map, key);
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rax
movq %rax, -0x50(%rbp)
rorxq $0x2d, %rax, %rcx
movq %rcx, -0x48(%rbp)
movq %rax, %rcx
shrq $0x20, %rcx
xorq %rax, %rcx
movq %rcx, %r14
shrq $0x10, %r14
xorq %rcx, %r14
callq 0xc7ce
xorl %r12d, %r12d
movq %r15, -0x30(%rbp)
cmpq $0x2, %r12
je 0xca1b
movq %r12, -0x38(%rbp)
movq -0x50(%rbp,%r12,8), %rsi
movq %r15, %rdi
callq 0xc84c
movq %rax, %r15
xorl %r13d, %r13d
cmpq $0x8, %r13
je 0xc9d3
movq (%r15,%r13,8), %r12
movl %r14d, %eax
xorw %r12w, %ax
jne 0xc9ce
shrq $0x10, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xab0c
testb %al, %al
jne 0xc9e0
incq %r13
jmp 0xc9a8
movq -0x38(%rbp), %r12
incq %r12
movq -0x30(%rbp), %r15
jmp 0xc987
movq -0x30(%rbp), %r14
movq 0x20(%r14), %rax
testq %rax, %rax
je 0xc9f6
movq 0x28(%r14), %rsi
movq %r12, %rdi
callq *%rax
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8c1
movq -0x38(%rbp), %r12
cmpq $0x2, %r12
setb %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc8c1
jmp 0xca05
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: cuckoo_set
bool
cuckoo_set(struct cuckoo * const map, const struct kv * const kv)
{
  const struct kv * const new = kv_alloc_dup(kv, &(map->mm));
  if (new == NULL) return false;
  if (map->fixed_power) {
    for (u64 i = 0; i < 8; i++) {
      if (cuckoo_try_set(map, new)) return true;
    }
    return false;
  } else {
    while (cuckoo_try_set(map, new) == false);
    return true;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0xba29
testq %rax, %rax
je 0xca85
movq %rax, %r14
cmpq $0x0, 0x100d0(%rbx)
je 0xca71
pushq $0x9
popq %r12
decq %r12
setne %r15b
je 0xca88
movq %rbx, %rdi
movq %r14, %rsi
callq 0xca94
testb %al, %al
je 0xca57
jmp 0xca88
movq %rbx, %rdi
movq %r14, %rsi
callq 0xca94
testb %al, %al
je 0xca71
movb $0x1, %r15b
jmp 0xca88
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: cuckoo_try_set
static bool
cuckoo_try_set(struct cuckoo * const map, const struct kv * const kv)
{
  const u64 hash2[2] = {cuckoo_hash(kv, 0), cuckoo_hash(kv, 1), };
  const u64 pkey = kvmap_pkey(kv->hash);

  cuckoo_lock_two(map, kv);
  // try update
  for (u64 x = 0; x < 2; x++) {
    struct __kvmap_slot * const slot = cuckoo_hash_slot(map, hash2[x]);
    for (u64 k = 0; k < 8; k++) {
      if (slot->e[k].pkey == pkey) {
        const struct kv * const curr = __u64_to_ptr(slot->e[k].ptr);
        if (kv_keymatch(kv, curr)) {
          kvmap_put_entry(&(map->mm), &(slot->e[k]), kv);
          cuckoo_unlock_two(map, kv);
          return true;
        }
      }
    }
  }

  // cuckoo
  for (u64 depth = 0; depth < 3; depth++) {
    for (u64 x = 0; x < 2; x++) {
      if (cuckoo_cuckoo_depth(map, hash2[x], kv, depth)) {
        cuckoo_unlock_two(map, kv);
        return true;
      }
    }
  }
  cuckoo_unlock_two(map, kv);
  if (map->bm) cuckoo_expand(map);
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq (%rsi), %rax
movq %rax, -0x40(%rbp)
rorxq $0x2d, %rax, %rcx
movq %rcx, -0x38(%rbp)
movq %rax, %rcx
shrq $0x20, %rcx
xorq %rax, %rcx
movq %rcx, %r12
shrq $0x10, %r12
xorq %rcx, %r12
movq %rdi, -0x30(%rbp)
callq 0xc7ce
xorl %r13d, %r13d
cmpq $0x2, %r13
je 0xcb54
movq -0x40(%rbp,%r13,8), %rsi
movq -0x30(%rbp), %rdi
callq 0xc84c
movq %rax, %r15
xorl %ebx, %ebx
cmpq $0x40, %rbx
je 0xcb1a
movq (%r15,%rbx), %rsi
movl %r12d, %eax
xorw %si, %ax
jne 0xcb14
shrq $0x10, %rsi
movq %r14, %rdi
callq 0xab0c
testb %al, %al
jne 0xcb1f
addq $0x8, %rbx
jmp 0xcaf2
incq %r13
jmp 0xcad9
addq %rbx, %r15
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xccb2
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc8c1
movb $0x1, %r14b
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
movq -0x30(%rbp), %r12
cmpq $0x3, %r15
je 0xcb8f
xorl %ebx, %ebx
cmpq $0x2, %rbx
je 0xcb85
movq -0x40(%rbp,%rbx,8), %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x10833
incq %rbx
testb %al, %al
je 0xcb63
jmp 0xcb8a
incq %r15
jmp 0xcb5b
movq %r12, %rdi
jmp 0xcb37
movq %r12, %rdi
movq %r14, %rsi
callq 0xc8c1
cmpq $0x0, 0x100d8(%r12)
je 0xcbeb
leaq 0x10050(%r12), %rdi
callq 0x6b6e
testb %al, %al
je 0xcbeb
leaq 0x10090(%r12), %rdi
leaq 0x3dd0(%rip), %rdx      # 0x10995
xorl %r14d, %r14d
xorl %esi, %esi
movq %r12, %rcx
callq 0x6430
movq 0x10090(%r12), %rdi
leaq 0x5be8(%rip), %rsi      # 0x127c9
callq 0x61d0
jmp 0xcb42
xorl %r14d, %r14d
jmp 0xcb42
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: cuckoo_del
bool
cuckoo_del(struct cuckoo * const map, const struct kv * const key)
{
  const u64 hash2[2] = {cuckoo_hash(key, 0), cuckoo_hash(key, 1), };
  const u64 pkey = kvmap_pkey(key->hash);

  cuckoo_lock_two(map, key);
  for (u64 x = 0; x < 2; x++) {
    struct __kvmap_slot * const slot = cuckoo_hash_slot(map, hash2[x]);
    for (u64 k = 0; k < 8; k++) {
      if (slot->e[k].pkey == pkey) {
        const struct kv * const curr = __u64_to_ptr(slot->e[k].ptr);
        if (kv_keymatch(key, curr)) {
          kvmap_put_entry(&(map->mm), &(slot->e[k]), NULL);
          cuckoo_unlock_two(map, key);
          return true;
        }
      }
    }
  }
  cuckoo_unlock_two(map, key);
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq (%rsi), %rax
movq %rax, -0x40(%rbp)
rorxq $0x2d, %rax, %rcx
movq %rcx, -0x38(%rbp)
movq %rax, %rcx
shrq $0x20, %rcx
xorq %rax, %rcx
movq %rcx, %r13
shrq $0x10, %r13
xorq %rcx, %r13
movq %rdi, -0x30(%rbp)
callq 0xc7ce
xorl %r12d, %r12d
cmpq $0x2, %r12
je 0xcc90
movq -0x40(%rbp,%r12,8), %rsi
movq -0x30(%rbp), %rdi
callq 0xc84c
movq %rax, %r15
xorl %r14d, %r14d
cmpq $0x40, %r14
je 0xcc7a
movq (%r15,%r14), %rsi
movl %r13d, %eax
xorw %si, %ax
jne 0xcc74
shrq $0x10, %rsi
movq %rbx, %rdi
callq 0xab0c
testb %al, %al
jne 0xcc7f
addq $0x8, %r14
jmp 0xcc52
incq %r12
jmp 0xcc38
addq %r14, %r15
movq -0x30(%rbp), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xccb2
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0xc8c1
cmpq $0x2, %r12
setb %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/lib1.c
// Function: kvmap_put_entry
static inline void
kvmap_put_entry(struct kvmap_mm * const mm, struct __kvmap_entry * const e, const struct kv * const kv)
{
  struct kv * const old = __u64_to_ptr(e->ptr);
  if (old) {
    if (kv && mm->xf) {
      mm->xf(old, kv, mm->xp);
    } else if (mm->rf) {
      mm->rf(old, mm->rp);
    }
  }
  e->ptr = __ptr_to_u64(kv);
  e->pkey = kv ? kvmap_pkey(kv->hash) : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %rax
movq (%rsi), %rdi
cmpq $0x10000, %rdi          # imm = 0x10000
jb 0xccfa
shrq $0x10, %rdi
testq %r14, %r14
je 0xcceb
movq 0x40(%rax), %rcx
testq %rcx, %rcx
je 0xcceb
movq 0x48(%rax), %rdx
movq %r14, %rsi
callq *%rcx
jmp 0xccfa
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0xccfa
movq 0x18(%rax), %rsi
callq *%rcx
movzwl (%rbx), %ecx
movq %r14, %rax
shlq $0x10, %rax
orq %rax, %rcx
movq %rcx, (%rbx)
testq %r14, %r14
je 0xcd27
movq (%r14), %rcx
movq %rcx, %rdx
shrq $0x20, %rdx
xorl %ecx, %edx
movl %edx, %ecx
shrl $0x10, %ecx
xorl %edx, %ecx
movzwl %cx, %ecx
jmp 0xcd29
xorl %ecx, %ecx
orq %rax, %rcx
movq %rcx, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq