// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/densehashtable.h
// Function: google::dense_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::resize_delta(unsigned long)
bool resize_delta(size_type delta) {
    bool did_resize = false;
    if ( settings.consider_shrink() ) {  // see if lots of deletes happened
      if ( maybe_shrink() )
        did_resize = true;
    }
    if (num_elements >=
        (std::numeric_limits<size_type>::max)() - delta) {
      throw std::length_error("resize overflow");
    }
    if ( bucket_count() >= HT_MIN_BUCKETS &&
         (num_elements + delta) <= settings.enlarge_threshold() )
      return did_resize;                          // we're ok as we are

    // Sometimes, we need to resize just to get rid of all the
    // "deleted" buckets that are clogging up the hashtable.  So when
    // deciding whether to resize, count the deleted buckets (which
    // are currently taking up room).  But later, when we decide what
    // size to resize to, *don't* count deleted buckets, since they
    // get discarded during the resize.
    size_type needed_size = settings.min_buckets(num_elements + delta, 0);
    if ( needed_size <= bucket_count() )      // we have enough buckets
      return did_resize;

    size_type resize_to =
      settings.min_buckets(num_elements - num_deleted + delta, bucket_count());

    // When num_deleted is large, we may still grow but we do not want to
    // over expand.  So we reduce needed_size by a portion of num_deleted
    // (the exact portion does not matter).  This is especially helpful
    // when min_load_factor is zero (no shrink at all) to avoid doubling
    // the bucket count to infinity.  See also test ResizeWithoutShrink.
    needed_size = settings.min_buckets(num_elements - num_deleted / 4 + delta, 0);
    if (resize_to < needed_size &&    // may double resize_to
        resize_to < (std::numeric_limits<size_type>::max)() / 2) {
      // This situation means that we have enough deleted elements,
      // that once we purge them, we won't actually have needed to
      // grow.  But we may want to grow anyway: if we just purge one
      // element, say, we'll have to grow anyway next time we
      // insert.  Might as well grow now, since we're already going
      // through the trouble of copying (in order to purge the
      // deleted elements).
      const size_type target =
          static_cast<size_type>(settings.shrink_size(resize_to*2));
      if (num_elements - num_deleted + delta >= target) {
        // Good, we won't be below the shrink threshhold even if we double.
        resize_to *= 2;
      }
    }
    dense_hashtable tmp(*this, resize_to);
    swap(tmp);                             // now we are tmp
    return true;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x18(%rdi)
jne 0x2328
movq %rbx, %rdi
callq 0x26b2
movl %eax, %ebp
jmp 0x232a
xorl %ebp, %ebp
movq 0x30(%rbx), %rsi
movq %r14, %rax
notq %rax
cmpq %rax, %rsi
jae 0x2441
cmpq $0x4, 0x38(%rbx)
jb 0x2351
leaq (%rsi,%r14), %rax
cmpq (%rbx), %rax
jbe 0x2434
addq %r14, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x177a
movq 0x38(%rbx), %rdx
cmpq %rdx, %rax
jbe 0x2434
movq 0x30(%rbx), %rsi
addq %r14, %rsi
subq 0x28(%rbx), %rsi
movq %rbx, %rdi
callq 0x177a
movq %rax, %r15
movq 0x28(%rbx), %rax
shrq $0x2, %rax
movq 0x30(%rbx), %rsi
addq %r14, %rsi
subq %rax, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x177a
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rcx, %r15
ja 0x2404
cmpq %rax, %r15
jae 0x2404
movq %r15, %rax
addq %r15, %rax
js 0x23c0
cvtsi2ss %rax, %xmm0
jmp 0x23d1
movq %r15, %rcx
btrq $0x3f, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
mulss 0x14(%rbx), %xmm0
cvttss2si %xmm0, %rcx
movq %rcx, %rdx
subss 0xc6a(%rip), %xmm0      # 0x3050
sarq $0x3f, %rdx
cvttss2si %xmm0, %rsi
andq %rdx, %rsi
addq 0x30(%rbx), %r14
subq 0x28(%rbx), %r14
orq %rcx, %rsi
cmpq %rsi, %r14
cmovaeq %rax, %r15
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1a96
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1bec
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x2431
callq 0x10a0
movb $0x1, %bpl
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1050
movq %rax, %r14
leaq 0xc76(%rip), %rsi       # 0x30cb
movq %rax, %rdi
callq 0x1090
movq 0x6b7c(%rip), %rsi      # 0x8fe0
movq 0x6b65(%rip), %rdx      # 0x8fd0
movq %r14, %rdi
callq 0x1110
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x2492
callq 0x10a0
jmp 0x2492
movq %rax, %rbx
movq %r14, %rdi
callq 0x1080
movq %rbx, %rdi
callq 0x1120