LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: attractivechaos[P]udb2/libcuckoo/./libcuckoo_bucket_container.hh
// Function: libcuckoo_bucket_container<unsigned int, unsigned int, std::allocator<std::pair<unsigned int const, unsigned int>>, unsigned char, 4ul>::destroy_buckets()
void destroy_buckets() noexcept {
    if (buckets_ == nullptr) {
      return;
    }
    // The bucket default constructor is nothrow, so we don't have to
    // worry about dealing with exceptions when constructing all the
    // elements.
    static_assert(std::is_nothrow_destructible<bucket>::value,
                  "libcuckoo_bucket_container requires bucket to be nothrow "
                  "destructible");
    clear();
    for (size_type i = 0; i < size(); ++i) {
      traits_::destroy(allocator_, &buckets_[i]);
    }
    bucket_allocator_.deallocate(buckets_, size());
    buckets_ = nullptr;
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x10(%rax)
jne 0x335f
jmp 0x340b
movq 0x30(%rsp), %rdi
callq 0x3430
movq $0x0, 0x38(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x3510
movq %rax, 0x28(%rsp)
jmp 0x338d
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq %rcx, %rax
jae 0x33c3
movq 0x30(%rsp), %rdi
movq 0x10(%rdi), %rsi
imulq $0x28, 0x38(%rsp), %rax
addq %rax, %rsi
callq 0x3530
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x3372
movq 0x30(%rsp), %rdi
movq %rdi, %rax
incq %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
callq 0x3510
movq %rax, 0x18(%rsp)
jmp 0x33e8
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x3560
jmp 0x33fe
movq 0x30(%rsp), %rax
movq $0x0, 0x10(%rax)
addq $0x48, %rsp
retq
movq %rax, %rdi
callq 0x3020
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/libcuckoo/./libcuckoo_bucket_container.hh
// Function: libcuckoo_bucket_container<unsigned int, unsigned int, std::allocator<std::pair<unsigned int const, unsigned int>>, unsigned char, 4ul>::clear()
void clear() noexcept {
    static_assert(
        std::is_nothrow_destructible<key_type>::value &&
            std::is_nothrow_destructible<mapped_type>::value,
        "libcuckoo_bucket_container requires key and value to be nothrow "
        "destructible");
    for (size_type i = 0; i < size(); ++i) {
      bucket &b = buckets_[i];
      for (size_type j = 0; j < SLOT_PER_BUCKET; ++j) {
        if (b.occupied(j)) {
          eraseKV(i, j);
        }
      }
    }
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x3510
movq %rax, 0x18(%rsp)
jmp 0x3467
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq %rcx, %rax
jae 0x3501
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
imulq $0x28, 0x38(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
cmpq $0x4, 0x28(%rsp)
jae 0x34ec
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x3590
movq %rax, 0x8(%rsp)
jmp 0x34b8
movq 0x8(%rsp), %rax
testb $0x1, (%rax)
je 0x34da
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x35c0
jmp 0x34d8
jmp 0x34da
jmp 0x34dc
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x349a
jmp 0x34ee
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x344c
addq $0x48, %rsp
retq
movq %rax, %rdi
callq 0x3020
nop
// File: attractivechaos[P]udb2/libcuckoo/./libcuckoo_bucket_container.hh
// Function: libcuckoo_bucket_container<unsigned int, unsigned int, std::allocator<std::pair<unsigned int const, unsigned int>>, unsigned char, 4ul>::eraseKV(unsigned long, unsigned long)
void eraseKV(size_type ind, size_type slot) {
    bucket &b = buckets_[ind];
    assert(b.occupied(slot));
    b.occupied(slot) = false;
    traits_::destroy(allocator_, std::addressof(b.storage_kvpair(slot)));
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rax), %rax
imulq $0x28, 0x18(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3590
testb $0x1, (%rax)
je 0x3604
jmp 0x3623
leaq 0xbc92(%rip), %rdi      # 0xf29d
leaq 0xaaf5(%rip), %rsi      # 0xe107
movl $0xd6, %edx
leaq 0xab09(%rip), %rcx      # 0xe127
callq 0x2110
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3590
movb $0x0, (%rax)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x36e0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x36b0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::reserve_calc(unsigned long)
static size_type reserve_calc(const size_type n) {
    const size_type buckets = (n + slot_per_bucket() - 1) / slot_per_bucket();
    size_type blog2;
    for (blog2 = 0; (size_type(1) << blog2) < buckets; ++blog2)
      ;
    assert(n <= buckets * slot_per_bucket() && buckets <= hashsize(blog2));
    return blog2;
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x3ce0
movq %rax, %rcx
movq 0x20(%rsp), %rax
addq %rcx, %rax
subq $0x1, %rax
movq %rax, 0x28(%rsp)
callq 0x3ce0
movq %rax, %rcx
movq 0x28(%rsp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rcx
movl $0x1, %eax
shlq %cl, %rax
cmpq 0x38(%rsp), %rax
jae 0x38e2
jmp 0x38d2
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x38bc
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x3ce0
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
imulq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0x1f(%rsp)
ja 0x3938
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x3cf0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
setbe %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x3942
jmp 0x3944
jmp 0x3963
leaq 0xa924(%rip), %rdi      # 0xe26f
leaq 0xa95c(%rip), %rsi      # 0xe2ae
movl $0x71f, %edx            # imm = 0x71F
leaq 0xa964(%rip), %rcx      # 0xe2c2
callq 0x2110
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/libcuckoo/./libcuckoo_bucket_container.hh
// Function: libcuckoo_bucket_container<unsigned int, unsigned int, std::allocator<std::pair<unsigned int const, unsigned int>>, unsigned char, 4ul>::libcuckoo_bucket_container(unsigned long, std::allocator<std::pair<unsigned int const, unsigned int>> const&)
libcuckoo_bucket_container(size_type hp, const allocator_type &allocator)
      : allocator_(allocator), bucket_allocator_(allocator), hashpower_(hp),
        buckets_(bucket_allocator_.allocate(size())) {
    // The bucket default constructor is nothrow, so we don't have to
    // worry about dealing with exceptions when constructing all the
    // elements.
    static_assert(std::is_nothrow_constructible<bucket>::value,
                  "libcuckoo_bucket_container requires bucket to be nothrow "
                  "constructible");
    for (size_type i = 0; i < size(); ++i) {
      traits_::construct(allocator_, &buckets_[i]);
    }
  }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movq 0x60(%rsp), %rsi
callq 0x3d10
movq 0x30(%rsp), %rdi
incq %rdi
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rsi
callq 0x3d40
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
movq 0x68(%rsp), %rsi
callq 0x3b80
movq 0x30(%rsp), %rdi
movq %rdi, %rax
addq $0x10, %rax
movq %rax, 0x38(%rsp)
callq 0x3510
movq %rax, 0x40(%rsp)
jmp 0x39e6
movq 0x40(%rsp), %rsi
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x3d60
movq %rax, 0x18(%rsp)
jmp 0x3a00
movq 0x38(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movq $0x0, 0x48(%rsp)
movq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x3510
movq %rax, 0x10(%rsp)
jmp 0x3a31
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq %rcx, %rax
jae 0x3a8b
movq 0x30(%rsp), %rdi
movq 0x10(%rdi), %rsi
imulq $0x28, 0x48(%rsp), %rax
addq %rax, %rsi
callq 0x3dc0
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x3a16
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
callq 0x3420
movq 0x30(%rsp), %rdi
callq 0x2da0
jmp 0x3a90
addq $0x78, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x2240
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::TwoBuckets cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::snapshot_and_lock_two<std::integral_constant<bool, false>>(cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::hash_value const&) const
TwoBuckets snapshot_and_lock_two(const hash_value &hv) const {
    while (true) {
      // Keep the current hashpower and locks we're using to compute the buckets
      const size_type hp = hashpower();
      const size_type i1 = index_hash(hp, hv.hash);
      const size_type i2 = alt_index(hp, hv.partial, i1);
      try {
        return lock_two(hp, i1, i2, TABLE_MODE());
      } catch (hashpower_changed &) {
        // The hashpower changed while taking the locks. Try again.
        continue;
      }
    }
  }

// Assembly:
subq $0x68, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x4f30
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rax
movq (%rax), %rsi
callq 0x4f50
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rax
movzbl 0x8(%rax), %esi
movq 0x40(%rsp), %rdx
callq 0x4f80
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %r8
callq 0x4fe0
jmp 0x4b4b
movq 0x8(%rsp), %rax
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x4b89
movq 0x28(%rsp), %rdi
callq 0x2090
movq %rax, 0x18(%rsp)
callq 0x2210
jmp 0x4ae9
movq 0x28(%rsp), %rdi
callq 0x2240
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::table_position cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::cuckoo_insert_loop<std::integral_constant<bool, false>, unsigned int>(cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::hash_value, cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::TwoBuckets&, unsigned int&)
table_position cuckoo_insert_loop(hash_value hv, TwoBuckets &b, K &key) {
    table_position pos;
    while (true) {
      const size_type hp = hashpower();
      pos = cuckoo_insert<TABLE_MODE>(hv, b, key);
      switch (pos.status) {
      case ok:
      case failure_key_duplicated:
        return pos;
      case failure_table_full:
        // Expand the table and try again, re-grabbing the locks
        cuckoo_fast_double<TABLE_MODE, automatic_resize>(hp);
        b = snapshot_and_lock_two<TABLE_MODE>(hv);
        break;
      case failure_under_expansion:
        // The table was under expansion while we were cuckooing. Re-grab the
        // locks and try again.
        b = snapshot_and_lock_two<TABLE_MODE>(hv);
        break;
      default:
        assert(false);
      }
    }
  }

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0x8(%rsp)
movb %cl, %al
movq %rdi, 0x10(%rsp)
movq %rdx, 0xa8(%rsp)
movb %al, 0xb0(%rsp)
movq %rsi, 0xa0(%rsp)
movq %r8, 0x98(%rsp)
movq %r9, 0x90(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4f30
movq 0x18(%rsp), %rsi
movq %rax, 0x88(%rsp)
movups 0xa8(%rsp), %xmm0
movaps %xmm0, 0x60(%rsp)
movq 0x98(%rsp), %r8
movq 0x90(%rsp), %r9
movq 0x60(%rsp), %rdx
movl 0x68(%rsp), %ecx
leaq 0x70(%rsp), %rdi
callq 0x5610
movq 0x8(%rsp), %rax
movq 0x80(%rsp), %rcx
movq %rcx, 0x10(%rax)
movups 0x70(%rsp), %xmm0
movups %xmm0, (%rax)
movl 0x10(%rax), %eax
movq %rax, (%rsp)
subq $0x5, %rax
ja 0x4cf5
movq (%rsp), %rax
leaq 0x93c5(%rip), %rcx      # 0xe028
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x18(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x5ae0
movq 0x18(%rsp), %rsi
leaq 0x40(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
callq 0x4ac0
movq 0x98(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x5d00
leaq 0x40(%rsp), %rdi
callq 0x4e70
jmp 0x4d14
movq 0x18(%rsp), %rsi
leaq 0x20(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
callq 0x4ac0
movq 0x98(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x5d00
leaq 0x20(%rsp), %rdi
callq 0x4e70
jmp 0x4d14
leaq 0x9716(%rip), %rdi      # 0xe412
leaq 0x95ab(%rip), %rsi      # 0xe2ae
movl $0x447, %edx            # imm = 0x447
leaq 0x9709(%rip), %rcx      # 0xe418
callq 0x2110
jmp 0x4be7
nopl (%rax)
// File: attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::partial_key(unsigned long)
static partial_t partial_key(const size_type hash) {
    const uint64_t hash_64bit = hash;
    const uint32_t hash_32bit = (static_cast<uint32_t>(hash_64bit) ^
                                 static_cast<uint32_t>(hash_64bit >> 32));
    const uint16_t hash_16bit = (static_cast<uint16_t>(hash_32bit) ^
                                 static_cast<uint16_t>(hash_32bit >> 16));
    const uint8_t hash_8bit = (static_cast<uint8_t>(hash_16bit) ^
                               static_cast<uint8_t>(hash_16bit >> 8));
    return hash_8bit;
  }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x10(%rsp), %rcx
shrq $0x20, %rcx
xorl %ecx, %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
movzwl %ax, %eax
movl -0x14(%rsp), %ecx
shrl $0x10, %ecx
movzwl %cx, %ecx
xorl %ecx, %eax
movw %ax, -0x16(%rsp)
movw -0x16(%rsp), %ax
movzbl %al, %eax
movzwl -0x16(%rsp), %ecx
sarl $0x8, %ecx
movzbl %cl, %ecx
xorl %ecx, %eax
movb %al, -0x17(%rsp)
movb -0x17(%rsp), %al
retq
nopl (%rax)
// File: attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::lock_two(unsigned long, unsigned long, unsigned long, std::integral_constant<bool, false>) const
TwoBuckets lock_two(size_type hp, size_type i1, size_type i2,
                      normal_mode) const {
    size_type l1 = lock_ind(i1);
    size_type l2 = lock_ind(i2);
    if (l2 < l1) {
      std::swap(l1, l2);
    }
    locks_t &locks = get_current_locks();
    locks[l1].lock();
    check_hashpower(hp, locks[l1]);
    if (l2 != l1) {
      locks[l2].lock();
    }
    return TwoBuckets(locks, i1, i2, normal_mode());
  }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
callq 0x5110
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x5110
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0x504d
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5130
movq 0x20(%rsp), %rdi
callq 0x5170
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x5190
movq %rax, %rdi
callq 0x51b0
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x5190
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x5260
movq 0x38(%rsp), %rax
cmpq 0x40(%rsp), %rax
je 0x50c1
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x5190
movq %rax, %rdi
callq 0x51b0
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
callq 0x52b0
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::check_hashpower(unsigned long, cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::spinlock&) const
inline void check_hashpower(size_type hp, spinlock &lock) const {
    if (hashpower() != hp) {
      lock.unlock();
      LIBCUCKOO_DBG("%s", "hashpower changed\n");
      throw hashpower_changed();
    }
  }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x4f30
cmpq 0x8(%rsp), %rax
je 0x52ab
movq (%rsp), %rdi
callq 0x5420
jmp 0x528e
movl $0x1, %edi
callq 0x20b0
movq %rax, %rdi
leaq 0x10a2e(%rip), %rsi     # 0x15cd0
xorl %eax, %eax
movl %eax, %edx
callq 0x2230
addq $0x18, %rsp
retq
// File: attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: bool cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::try_find_insert_bucket<unsigned int>(libcuckoo_bucket_container<unsigned int, unsigned int, std::allocator<std::pair<unsigned int const, unsigned int>>, unsigned char, 4ul>::bucket const&, int&, unsigned char, unsigned int const&) const
bool try_find_insert_bucket(const bucket &b, int &slot,
                              const partial_t partial, const K &key) const {
    // Silence a warning from MSVC about partial being unused if is_simple.
    (void)partial;
    slot = -1;
    for (int i = 0; i < static_cast<int>(slot_per_bucket()); ++i) {
      if (b.occupied(i)) {
        if (!is_simple && partial != b.partial(i)) {
          continue;
        }
        if (key_eq()(b.key(i), key)) {
          slot = i;
          return false;
        }
      } else {
        slot = i;
      }
    }
    return true;
  }

// Assembly:
subq $0x48, %rsp
movb %cl, %al
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movb %al, 0x27(%rsp)
movq %r8, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x3ce0
movq %rax, %rcx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x5e2a
movq 0x30(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x6300
testb $0x1, %al
jne 0x5dc8
jmp 0x5e0d
movq 0x8(%rsp), %rdi
callq 0x6330
movq 0x30(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x6370
movq %rax, %rsi
movq 0x18(%rsp), %rdx
leaq 0x13(%rsp), %rdi
callq 0x6340
testb $0x1, %al
jne 0x5df9
jmp 0x5e0b
movl 0x14(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
movb $0x0, 0x47(%rsp)
jmp 0x5e2f
jmp 0x5e18
movl 0x14(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
jmp 0x5e1a
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x5d9b
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::table_position cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::cuckoo_find<unsigned int>(unsigned int const&, unsigned char, unsigned long, unsigned long) const
table_position cuckoo_find(const K &key, const partial_t partial,
                             const size_type i1, const size_type i2) const {
    int slot = try_read_from_bucket(buckets_[i1], partial, key);
    if (slot != -1) {
      return table_position{i1, static_cast<size_type>(slot), ok};
    }
    slot = try_read_from_bucket(buckets_[i2], partial, key);
    if (slot != -1) {
      return table_position{i2, static_cast<size_type>(slot), ok};
    }
    return table_position{0, 0, failure_key_not_found};
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, (%rsp)
movb %cl, %al
movq %rdi, 0x8(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movb %al, 0x37(%rsp)
movq %r8, 0x28(%rsp)
movq %r9, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x8, %rdi
movq 0x28(%rsp), %rsi
callq 0x8840
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movb 0x37(%rsp), %al
movq 0x38(%rsp), %rcx
movzbl %al, %edx
callq 0x8780
movl %eax, 0x1c(%rsp)
cmpl $-0x1, 0x1c(%rsp)
je 0x6281
movq (%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movslq 0x1c(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, 0x10(%rax)
jmp 0x62f1
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movq 0x20(%rsp), %rsi
callq 0x8840
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movb 0x37(%rsp), %al
movq 0x38(%rsp), %rcx
movzbl %al, %edx
callq 0x8780
movl %eax, 0x1c(%rsp)
cmpl $-0x1, 0x1c(%rsp)
je 0x62d6
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movslq 0x1c(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, 0x10(%rax)
jmp 0x62f1
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20d0
movq (%rsp), %rax
movl $0x2, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::lock_one(unsigned long, unsigned long, std::integral_constant<bool, false>) const
LockManager lock_one(size_type hp, size_type i, normal_mode) const {
    locks_t &locks = get_current_locks();
    spinlock &lock = locks[lock_ind(i)];
    lock.lock();
    check_hashpower(hp, lock);
    return LockManager(&lock);
  }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5170
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x5110
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x5190
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x51b0
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x5260
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x5490
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::b_queue::dequeue()
b_slot dequeue() {
      assert(!empty());
      assert(first_ < last_);
      b_slot &x = slots_[first_++];
      return x;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7760
xorb $-0x1, %al
testb $0x1, %al
jne 0x77a0
jmp 0x77a2
jmp 0x77c1
leaq 0x783e(%rip), %rdi      # 0xefe7
leaq 0x6afe(%rip), %rsi      # 0xe2ae
movl $0x5c1, %edx            # imm = 0x5C1
leaq 0x7834(%rip), %rcx      # 0xeff0
callq 0x2110
movq 0x8(%rsp), %rcx
movq 0x2aa0(%rcx), %rax
cmpq 0x2aa8(%rcx), %rax
jae 0x77d8
jmp 0x77f7
leaq 0x791b(%rip), %rdi      # 0xf0fa
leaq 0x6ac8(%rip), %rsi      # 0xe2ae
movl $0x5c2, %edx            # imm = 0x5C2
leaq 0x77fe(%rip), %rcx      # 0xeff0
callq 0x2110
movq 0x8(%rsp), %rax
movq 0x2aa0(%rax), %rcx
movq %rcx, %rdx
incq %rdx
movq %rdx, 0x2aa0(%rax)
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rdx
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/libcuckoo/./libcuckoo_bucket_container.hh
// Function: void libcuckoo_bucket_container<unsigned int, unsigned int, std::allocator<std::pair<unsigned int const, unsigned int>>, unsigned char, 4ul>::setKV<unsigned int, unsigned int>(unsigned long, unsigned long, unsigned char, unsigned int&&, unsigned int&&)
void setKV(size_type ind, size_type slot, partial_t p, K &&k,
             Args &&... args) {
    bucket &b = buckets_[ind];
    assert(!b.occupied(slot));
    b.partial(slot) = p;
    traits_::construct(allocator_, std::addressof(b.storage_kvpair(slot)),
                       std::piecewise_construct,
                       std::forward_as_tuple(std::forward<K>(k)),
                       std::forward_as_tuple(std::forward<Args>(args)...));
    // This must occur last, to enforce a strong exception guarantee
    b.occupied(slot) = true;
  }

// Assembly:
subq $0x68, %rsp
movb %cl, %al
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movb %al, 0x4f(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rax), %rax
imulq $0x28, 0x58(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x3590
movb (%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x7f78
jmp 0x7f7a
jmp 0x7f99
leaq 0x731b(%rip), %rdi      # 0xf29c
leaq 0x617f(%rip), %rsi      # 0xe107
movl $0xc9, %edx
leaq 0x731a(%rip), %rcx      # 0xf2ae
callq 0x2110
movb 0x4f(%rsp), %al
movb %al, 0xf(%rsp)
movq 0x30(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x7840
movb 0xf(%rsp), %cl
movb %cl, (%rax)
movq 0x30(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x36e0
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x8540
movq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x8540
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x7bda(%rip), %rdx      # 0xfbd3
leaq 0x28(%rsp), %rcx
leaq 0x20(%rsp), %r8
callq 0x8500
movq 0x30(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x3590
movb $0x1, (%rax)
addq $0x68, %rsp
retq
nop
// File: attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: int cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::try_read_from_bucket<unsigned int>(libcuckoo_bucket_container<unsigned int, unsigned int, std::allocator<std::pair<unsigned int const, unsigned int>>, unsigned char, 4ul>::bucket const&, unsigned char, unsigned int const&) const
int try_read_from_bucket(const bucket &b, const partial_t partial,
                           const K &key) const {
    // Silence a warning from MSVC about partial being unused if is_simple.
    (void)partial;
    for (int i = 0; i < static_cast<int>(slot_per_bucket()); ++i) {
      if (!b.occupied(i) || (!is_simple && partial != b.partial(i))) {
        continue;
      } else if (key_eq()(b.key(i), key)) {
        return i;
      }
    }
    return -1;
  }

// Assembly:
subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x3ce0
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x8824
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x6300
testb $0x1, %al
jne 0x87d8
jmp 0x8817
movq 0x10(%rsp), %rdi
callq 0x6330
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x6370
movq %rax, %rsi
movq 0x20(%rsp), %rdx
leaq 0x1b(%rsp), %rdi
callq 0x6340
testb $0x1, %al
jne 0x8809
jmp 0x8813
movl 0x1c(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x882c
jmp 0x8815
jmp 0x8817
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x87ab
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::snapshot_and_lock_all(std::integral_constant<bool, false>)
AllLocksManager snapshot_and_lock_all(normal_mode) {
    // all_locks_ should never decrease in size, so if it is non-empty now, it
    // will remain non-empty
    assert(!all_locks_.empty());
    auto first_locked = all_locks_.end();
    --first_locked;
    auto current_locks = first_locked;
    while (current_locks != all_locks_.end()) {
      locks_t &locks = *current_locks;
      for (spinlock &lock : locks) {
        lock.lock();
      }
      ++current_locks;
    }
    // Once we have taken all the locks of the "current" container, nobody
    // else can do locking operations on the table.
    return AllLocksManager(this, AllUnlocker{first_locked});
  }

// Assembly:
subq $0x78, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x20, %rdi
callq 0x9400
xorb $-0x1, %al
testb $0x1, %al
jne 0x8895
jmp 0x8897
jmp 0x88b6
leaq 0x6b9c(%rip), %rdi      # 0xf43a
leaq 0x5a09(%rip), %rsi      # 0xe2ae
movl $0x3d2, %edx            # imm = 0x3D2
leaq 0x6b9d(%rip), %rcx      # 0xf44e
callq 0x2110
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x4050
movq %rax, 0x58(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x53e0
movq 0x58(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x4050
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x9420
testb $0x1, %al
jne 0x8908
jmp 0x8988
leaq 0x50(%rsp), %rdi
callq 0x5400
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x9440
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x9470
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x94a0
testb $0x1, %al
jne 0x8954
jmp 0x8979
leaq 0x30(%rsp), %rdi
callq 0x94e0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x51b0
leaq 0x30(%rsp), %rdi
callq 0x94f0
jmp 0x893f
leaq 0x50(%rsp), %rdi
callq 0x9510
jmp 0x88dd
movq 0x10(%rsp), %rsi
movq (%rsp), %rdi
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdx
callq 0x9530
movq 0x8(%rsp), %rax
addq $0x78, %rsp
retq
nop
// File: attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::cuckoo_status cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::check_resize_validity<std::integral_constant<bool, true>>(unsigned long, unsigned long)
cuckoo_status check_resize_validity(const size_type orig_hp,
                                      const size_type new_hp) {
    const size_type mhp = maximum_hashpower();
    if (mhp != LIBCUCKOO_NO_MAXIMUM_HASHPOWER && new_hp > mhp) {
      throw libcuckoo_maximum_hashpower_exceeded(new_hp);
    }
    if (AUTO_RESIZE::value && load_factor() < minimum_load_factor()) {
      throw libcuckoo_load_factor_too_low(minimum_load_factor());
    }
    if (hashpower() != orig_hp) {
      // Most likely another expansion ran before this one could grab the
      // locks
      LIBCUCKOO_DBG("%s", "another expansion is on-going\n");
      return failure_under_expansion;
    }
    return ok;
  }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x96f0
movq %rax, 0x40(%rsp)
cmpq $-0x1, 0x40(%rsp)
je 0x8a41
movq 0x48(%rsp), %rax
cmpq 0x40(%rsp), %rax
jbe 0x8a41
movl $0x10, %edi
callq 0x20b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rsi
callq 0x9790
jmp 0x8a0c
movq 0x20(%rsp), %rdi
leaq 0xd2c8(%rip), %rsi      # 0x15ce0
leaq 0xdb1(%rip), %rdx       # 0x97d0
callq 0x2230
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x2120
jmp 0x8afc
movq 0x28(%rsp), %rdi
callq 0x97e0
movq 0x28(%rsp), %rdi
movsd %xmm0, 0x18(%rsp)
callq 0x9870
movsd 0x18(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x8acc
movl $0x10, %edi
callq 0x20b0
movq 0x28(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x9870
movsd %xmm0, 0x10(%rsp)
jmp 0x8a88
movsd 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rdi
callq 0x9890
jmp 0x8a9a
movq 0x8(%rsp), %rdi
leaq 0xd252(%rip), %rsi      # 0x15cf8
leaq 0xe23(%rip), %rdx       # 0x98d0
callq 0x2230
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x2120
jmp 0x8afc
movq 0x28(%rsp), %rdi
callq 0x4f30
cmpq 0x50(%rsp), %rax
je 0x8aeb
jmp 0x8adf
jmp 0x8ae1
movl $0x5, 0x64(%rsp)
jmp 0x8af3
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x2240
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/libcuckoo/./libcuckoo_bucket_container.hh
// Function: libcuckoo_bucket_container<unsigned int, unsigned int, std::allocator<std::pair<unsigned int const, unsigned int>>, unsigned char, 4ul>::swap(libcuckoo_bucket_container<unsigned int, unsigned int, std::allocator<std::pair<unsigned int const, unsigned int>>, unsigned char, 4ul>&)
void swap(libcuckoo_bucket_container &bc) noexcept {
    swap_allocator(allocator_, bc.allocator_,
                   typename traits_::propagate_on_container_swap());
    bucket_allocator_ = allocator_;
    // Regardless of whether we actually swapped the allocators or not, it will
    // always be okay to do the remainder of the swap. This is because if the
    // allocators were swapped, then the subsequent operations are okay. If the
    // allocators weren't swapped but compare equal, then we're okay. If they
    // weren't swapped and compare unequal, then behavior is undefined, so
    // we're okay.
    size_t bc_hashpower = bc.hashpower();
    bc.hashpower(hashpower());
    hashpower(bc_hashpower);
    std::swap(buckets_, bc.buckets_);
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rsi
movq %rsi, 0x10(%rsp)
movq 0x28(%rsp), %rdx
movq %rsi, %rdi
callq 0xd080
jmp 0x9307
movq 0x10(%rsp), %rsi
leaq 0x26(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x3d40
movq (%rsp), %rdi
callq 0x3420
movq 0x28(%rsp), %rdi
callq 0x3770
movq 0x10(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x3770
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xd090
jmp 0x9355
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xd090
jmp 0x9366
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movq 0x28(%rsp), %rsi
addq $0x10, %rsi
callq 0xd130
addq $0x38, %rsp
retq
movq %rax, %rdi
callq 0x3020
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::AllUnlocker::operator()(cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>*) const
void operator()(cuckoohash_map *map) const {
      for (auto it = first_locked; it != map->all_locks_.end(); ++it) {
        locks_t &locks = *it;
        for (spinlock &lock : locks) {
          lock.unlock();
        }
      }
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
addq $0x20, %rdi
callq 0x4050
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x9420
testb $0x1, %al
jne 0xd1f6
jmp 0xd276
leaq 0x30(%rsp), %rdi
callq 0x5400
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x9440
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x9470
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x94a0
testb $0x1, %al
jne 0xd242
jmp 0xd265
leaq 0x10(%rsp), %rdi
callq 0x94e0
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x5420
leaq 0x10(%rsp), %rdi
callq 0x94f0
jmp 0xd22d
jmp 0xd267
leaq 0x30(%rsp), %rdi
callq 0x9510
jmp 0xd1cb
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/map/test.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	std::map<uint32_t, uint32_t> h;
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
		z += ++h[get_key(n, x)];
	}
	fprintf(stderr, "# unique keys: %ld; checksum: %u\n", h.size(), z);
	return h.size();
}

// Assembly:
subq $0x78, %rsp
movl %edi, 0x74(%rsp)
movl %esi, 0x70(%rsp)
movl $0x0, 0x64(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1740
movl $0x0, 0x6c(%rsp)
movl 0x70(%rsp), %eax
movl %eax, 0x68(%rsp)
movl 0x6c(%rsp), %eax
cmpl 0x74(%rsp), %eax
jae 0x16df
movl 0x68(%rsp), %edi
callq 0x12c0
movl %eax, 0x1c(%rsp)
jmp 0x166b
movl 0x1c(%rsp), %eax
movl %eax, 0x68(%rsp)
movl 0x74(%rsp), %edi
movl 0x68(%rsp), %esi
callq 0x1330
movl %eax, 0x18(%rsp)
jmp 0x1686
movl 0x18(%rsp), %eax
movl %eax, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1750
movq %rax, 0x10(%rsp)
jmp 0x16a4
movq 0x10(%rsp), %rcx
movl (%rcx), %eax
addl $0x1, %eax
movl %eax, (%rcx)
addl 0x64(%rsp), %eax
movl %eax, 0x64(%rsp)
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x164e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1850
jmp 0x1731
movq 0x38fa(%rip), %rax      # 0x4fe0
movq (%rax), %rax
movq %rax, (%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1840
movq (%rsp), %rdi
movq %rax, %rdx
movl 0x64(%rsp), %ecx
leaq 0x196c(%rip), %rsi      # 0x3075
movb $0x0, %al
callq 0x1100
leaq 0x30(%rsp), %rdi
callq 0x1840
movl %eax, 0xc(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1850
movl 0xc(%rsp), %eax
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x1140
nopl (%rax,%rax)
// File: conp-solutions[P]cnfmiter/AtLeastTwoSolutions.cc
// Function: print_formula(CNFMITER::Formula&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void print_formula(Formula &f, std::string s)
{
    std::cout << "c AtLeastTwoSolutions, Norbert Manthey, 2021" << std::endl;
    if (!s.empty()) std::cout << "c " << s << std::endl;
    std::cout << "c " << std::endl;
    std::cout << "p cnf " << f.nVars() << " " << f.clauses.size() << std::endl;
    for (const auto &c : f.clauses) {
        std::stringstream s;
        s << c;
        printf("%s 0\n", s.str().c_str());
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rsi, -0x1f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x8947(%rip), %rdi      # 0xafb8
leaq 0x498c(%rip), %rsi      # 0x7004
callq 0x2150
movq %rax, %rdi
movq 0x8911(%rip), %rsi      # 0xaf98
callq 0x2170
movq -0x1f0(%rbp), %rdi
callq 0x2230
testb $0x1, %al
jne 0x26cd
movq 0x8915(%rip), %rdi      # 0xafb8
leaq 0x4987(%rip), %rsi      # 0x7031
callq 0x2150
movq -0x1f0(%rbp), %rsi
movq %rax, %rdi
callq 0x2120
movq %rax, %rdi
movq 0x88d0(%rip), %rsi      # 0xaf98
callq 0x2170
movq 0x88e4(%rip), %rdi      # 0xafb8
leaq 0x4956(%rip), %rsi      # 0x7031
callq 0x2150
movq %rax, %rdi
movq 0x88ae(%rip), %rsi      # 0xaf98
callq 0x2170
movq 0x88c2(%rip), %rdi      # 0xafb8
leaq 0x4937(%rip), %rsi      # 0x7034
callq 0x2150
movq %rax, -0x200(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4250
movq -0x200(%rbp), %rdi
movl %eax, %esi
callq 0x2250
movq %rax, %rdi
leaq 0x4938(%rip), %rsi      # 0x7062
callq 0x2150
movq %rax, -0x1f8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x4260
movq -0x1f8(%rbp), %rdi
movq %rax, %rsi
callq 0x2050
movq %rax, %rdi
movq 0x883c(%rip), %rsi      # 0xaf98
callq 0x2170
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4290
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x42c0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x42f0
testb $0x1, %al
jne 0x279d
jmp 0x2862
leaq -0x20(%rbp), %rdi
callq 0x4330
movq %rax, -0x30(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x20e0
leaq -0x1a8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4350
jmp 0x27c8
leaq -0x1e8(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x2140
jmp 0x27dd
leaq -0x1e8(%rbp), %rdi
callq 0x2090
movq %rax, %rsi
leaq 0x4848(%rip), %rdi      # 0x703b
xorl %eax, %eax
callq 0x2030
jmp 0x27fc
leaq -0x1e8(%rbp), %rdi
callq 0x20b0
leaq -0x1b8(%rbp), %rdi
callq 0x20f0
leaq -0x20(%rbp), %rdi
callq 0x43d0
jmp 0x2787
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x2854
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x20b0
leaq -0x1b8(%rbp), %rdi
callq 0x20f0
jmp 0x286b
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1c0(%rbp), %rdi
callq 0x2260
nopw (%rax,%rax)
// File: conp-solutions[P]cnfmiter/./ParseUtils.h
// Function: int CNFMITER::parseInt<CNFMITER::StreamBuffer>(CNFMITER::StreamBuffer&)
static int parseInt(B &in)
{
    int val = 0;
    bool neg = false;
    skipWhitespace(in);
    if (*in == '-')
        neg = true, ++in;
    else if (*in == '+')
        ++in;
    if (*in < '0' || *in > '9') fprintf(stderr, "PARSE ERROR! Unexpected char: %c\n", *in), exit(3);
    while (*in >= '0' && *in <= '9') val = val * 10 + (*in - '0'), ++in;
    return neg ? -val : val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3d90
movq -0x8(%rbp), %rdi
callq 0x5d80
cmpl $0x2d, %eax
jne 0x3e9d
movb $0x1, -0xd(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5dc0
jmp 0x3eb6
movq -0x8(%rbp), %rdi
callq 0x5d80
cmpl $0x2b, %eax
jne 0x3eb4
movq -0x8(%rbp), %rdi
callq 0x5dc0
jmp 0x3eb6
movq -0x8(%rbp), %rdi
callq 0x5d80
cmpl $0x30, %eax
jl 0x3ed2
movq -0x8(%rbp), %rdi
callq 0x5d80
cmpl $0x39, %eax
jle 0x3f07
movq 0x70ef(%rip), %rax      # 0xafc8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d80
movq -0x18(%rbp), %rdi
movl %eax, %edx
leaq 0x351f(%rip), %rsi      # 0x7415
movb $0x0, %al
callq 0x21c0
movl $0x3, %edi
callq 0x21a0
jmp 0x3f09
movq -0x8(%rbp), %rdi
callq 0x5d80
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x19(%rbp)
jl 0x3f30
movq -0x8(%rbp), %rdi
callq 0x5d80
cmpl $0x39, %eax
setle %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x3f39
jmp 0x3f61
imull $0xa, -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d80
movl %eax, %ecx
movl -0x20(%rbp), %eax
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5dc0
jmp 0x3f09
testb $0x1, -0xd(%rbp)
je 0x3f71
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x3f77
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: conp-solutions[P]cnfmiter/./ParseUtils.h
// Function: void CNFMITER::skipLine<CNFMITER::StreamBuffer>(CNFMITER::StreamBuffer&)
static void skipLine(B &in)
{
    for (;;) {
        if (isEof(in)) return;
        if (*in == '\n') {
            ++in;
            return;
        }
        ++in;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4090
testb $0x1, %al
jne 0x3f9b
jmp 0x3f9d
jmp 0x3fc1
movq -0x8(%rbp), %rdi
callq 0x5d80
cmpl $0xa, %eax
jne 0x3fb6
movq -0x8(%rbp), %rdi
callq 0x5dc0
jmp 0x3fc1
movq -0x8(%rbp), %rdi
callq 0x5dc0
jmp 0x3f8c
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: conp-solutions[P]cnfmiter/./Dimacs.h
// Function: void CNFMITER::readClause<CNFMITER::StreamBuffer, CNFMITER::Formula>(CNFMITER::StreamBuffer&, CNFMITER::Formula&, std::vector<CNFMITER::Lit, std::allocator<CNFMITER::Lit>>&)
static void readClause(B &in, Solver &S, std::vector<Lit> &lits)
{
    int parsed_lit, var;
    lits.clear();
    for (;;) {
        parsed_lit = parseInt(in);
        if (parsed_lit == 0) break;
        var = abs(parsed_lit) - 1;
        while (var >= S.nVars()) S.newVar();
        lits.push_back((parsed_lit > 0) ? mkLit(var) : ~mkLit(var));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4610
movq -0x8(%rbp), %rdi
callq 0x3e60
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x4001
jmp 0x407b
movl -0x1c(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4250
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jl 0x4034
movq -0x10(%rbp), %rdi
callq 0x45b0
jmp 0x4011
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x4051
movl -0x20(%rbp), %edi
xorl %esi, %esi
callq 0x4690
movl %eax, -0x24(%rbp)
jmp 0x4069
movl -0x20(%rbp), %edi
xorl %esi, %esi
callq 0x4690
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edi
callq 0x4230
movl %eax, -0x24(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x4660
jmp 0x3fed
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: m1c0l[P]http-client-server/HttpMessage.cpp
// Function: HttpMessage::decodeHeaderLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int HttpMessage::decodeHeaderLine(string line)
{
	string key, value;
	size_t i = 0;
	i = line.find(":");

	if (i == string::npos || i == 0 || i == line.size() - 1) {
		return 400;
	}

	key = line.substr(0, i);
	i++;
	while(line[i] == ' ')
		i++;
	value = line.substr(i, line.size());
	setHeader(key, value);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rsi, -0x100(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x108(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x55c0
leaq -0x58(%rbp), %rdi
callq 0x55c0
movq -0x100(%rbp), %rdi
movq $0x0, -0x60(%rbp)
leaq 0xd5e7(%rip), %rsi      # 0x13004
xorl %eax, %eax
movl %eax, %edx
callq 0x5720
movq %rax, -0x60(%rbp)
cmpq $-0x1, -0x60(%rbp)
je 0x5a62
cmpq $0x0, -0x60(%rbp)
je 0x5a62
movq -0x100(%rbp), %rdi
movq -0x60(%rbp), %rax
movq %rax, -0x110(%rbp)
callq 0x52c0
movq %rax, %rcx
movq -0x110(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x5a75
movl $0x190, -0x4(%rbp)      # imm = 0x190
movl $0x1, -0x64(%rbp)
jmp 0x5c08
movq -0x100(%rbp), %rsi
movq -0x60(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x88(%rbp), %rdi
callq 0x5440
jmp 0x5a92
leaq -0x38(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x5500
leaq -0x88(%rbp), %rdi
callq 0x5280
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
movq -0x100(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x5730
movq %rax, -0x118(%rbp)
jmp 0x5ad3
movq -0x118(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x5b07
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x5aba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x5c26
movq -0x100(%rbp), %rdi
movq -0x60(%rbp), %rax
movq %rax, -0x120(%rbp)
callq 0x52c0
movq -0x100(%rbp), %rsi
movq -0x120(%rbp), %rdx
movq %rax, %rcx
leaq -0xb8(%rbp), %rdi
callq 0x5440
jmp 0x5b3d
leaq -0x58(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
movq %rsi, -0x128(%rbp)
callq 0x5500
movq -0x128(%rbp), %rdi
callq 0x5280
leaq -0xd8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x51a0
jmp 0x5b72
leaq -0xf8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x51a0
jmp 0x5b84
movq -0x108(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
leaq -0xf8(%rbp), %rdx
callq 0x5940
jmp 0x5ba0
leaq -0xf8(%rbp), %rdi
callq 0x5280
leaq -0xd8(%rbp), %rdi
callq 0x5280
movl $0x0, -0x4(%rbp)
movl $0x1, -0x64(%rbp)
jmp 0x5c08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x5bfa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x5280
leaq -0xd8(%rbp), %rdi
callq 0x5280
jmp 0x5c26
leaq -0x58(%rbp), %rdi
callq 0x5280
leaq -0x38(%rbp), %rdi
callq 0x5280
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x5280
leaq -0x38(%rbp), %rdi
callq 0x5280
movq -0x90(%rbp), %rdi
callq 0x5680
nopw %cs:(%rax,%rax)