// 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>::cuckoo_fast_double<std::integral_constant<bool, false>, std::integral_constant<bool, true>>(unsigned long)
cuckoo_status cuckoo_fast_double(size_type current_hp) {
    if (!std::is_nothrow_move_constructible<key_type>::value ||
        !std::is_nothrow_move_constructible<mapped_type>::value) {
      LIBCUCKOO_DBG("%s", "cannot run cuckoo_fast_double because key-value"
                          " pair is not nothrow move constructible");
      return cuckoo_expand_simple<TABLE_MODE, AUTO_RESIZE>(current_hp + 1);
    }
    const size_type new_hp = current_hp + 1;
    auto all_locks_manager = snapshot_and_lock_all(TABLE_MODE());
    cuckoo_status st = check_resize_validity<AUTO_RESIZE>(current_hp, new_hp);
    if (st != ok) {
      return st;
    }

    // We must re-hash the table, moving items in each bucket to a different
    // one. The hash functions are carefully designed so that when doubling the
    // number of buckets, each element either stays in its existing bucket or
    // goes to exactly one new bucket. This means we can re-hash each bucket in
    // parallel. We create a new empty buckets container and move all the
    // elements from the old container to the new one.
    buckets_t new_buckets(new_hp, get_allocator());
    // For certain types, MSVC may decide that move_buckets() cannot throw and
    // so the catch block below is dead code. Since that won't always be true,
    // we just disable the warning here.
    LIBCUCKOO_SQUELCH_DEADCODE_WARNING_BEGIN;
    parallel_exec(
        0, hashsize(current_hp),
        [this, &new_buckets, current_hp, new_hp](size_type start, size_type end,
                                                 std::exception_ptr &eptr) {
          try {
            move_buckets(new_buckets, current_hp, new_hp, start, end);
          } catch (...) {
            eptr = std::current_exception();
          }
        });
    LIBCUCKOO_SQUELCH_DEADCODE_WARNING_END;

    // Resize the locks array if necessary. This is done before we update the
    // hashpower so that other threads don't grab the new hashpower and the old
    // locks
    maybe_resize_locks(size_type(1) << new_hp);
    // Swap the old and new buckets. The old bucket data will be destroyed when
    // the function exits
    buckets_.swap(new_buckets);
    return ok;
  }

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq 0xb8(%rsp), %rsi
movq %rsi, 0x30(%rsp)
movq 0xb0(%rsp), %rax
incq %rax
movq %rax, 0xa8(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x8860
movq 0x30(%rsp), %rdi
movq 0xb0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
callq 0x89b0
movl %eax, 0x3c(%rsp)
jmp 0x5b44
movl 0x3c(%rsp), %eax
movl %eax, 0x90(%rsp)
cmpl $0x0, 0x90(%rsp)
je 0x5b90
movl 0x90(%rsp), %eax
movl %eax, 0xc4(%rsp)
movl $0x1, 0x80(%rsp)
jmp 0x5cbb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x5cd7
movq 0x30(%rsp), %rsi
movq 0xa8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x67(%rsp), %rdi
callq 0x3aa0
jmp 0x5bae
movq 0x28(%rsp), %rsi
leaq 0x68(%rsp), %rdi
leaq 0x67(%rsp), %rdx
callq 0x3970
jmp 0x5bc4
leaq 0x67(%rsp), %rdi
callq 0x2da0
movq 0xb0(%rsp), %rdi
callq 0x3cf0
movq 0x30(%rsp), %rdi
movq %rax, %rdx
movq %rdi, 0x40(%rsp)
leaq 0x68(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x58(%rsp)
movups 0x40(%rsp), %xmm0
movups 0x50(%rsp), %xmm1
movq %rsp, %rax
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
xorl %eax, %eax
movl %eax, %esi
callq 0x8b10
jmp 0x5c2b
movq 0x30(%rsp), %rdi
movb 0xa8(%rsp), %cl
movl $0x1, %esi
shlq %cl, %rsi
callq 0x9010
jmp 0x5c46
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
leaq 0x68(%rsp), %rsi
callq 0x92e0
movl $0x0, 0xc4(%rsp)
movl $0x1, 0x80(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x2ee0
jmp 0x5cbb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x67(%rsp), %rdi
callq 0x2da0
jmp 0x5cd7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x2ee0
jmp 0x5cd7
leaq 0x98(%rsp), %rdi
callq 0x9390
movl 0xc4(%rsp), %eax
addq $0xc8, %rsp
retq
leaq 0x98(%rsp), %rdi
callq 0x9390
movq 0x88(%rsp), %rdi
callq 0x2240
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)