// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/sparsehashtable.h
// Function: google::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::sparse_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::sparse_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 (table.num_nonempty() >=
        (std::numeric_limits<size_type>::max)() - delta) {
      throw std::length_error("resize overflow");
    }
    if ( bucket_count() >= HT_MIN_BUCKETS &&
         (table.num_nonempty() + 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.
    const size_type needed_size =
        settings.min_buckets(table.num_nonempty() + delta, 0);
    if ( needed_size <= bucket_count() )      // we have enough buckets
      return did_resize;

    size_type resize_to =
        settings.min_buckets(table.num_nonempty() - num_deleted + delta,
                             bucket_count());
    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 (table.num_nonempty() - num_deleted + delta >= target) {
        // Good, we won't be below the shrink threshhold even if we double.
        resize_to *= 2;
      }
    }

    sparse_hashtable tmp(MoveDontCopy, *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 0x2bec
movq %rbx, %rdi
callq 0x30ce
movl %eax, %ebp
jmp 0x2bee
xorl %ebp, %ebp
movq 0x50(%rbx), %rsi
movq %r14, %rax
notq %rax
cmpq %rax, %rsi
jae 0x2ce6
addq %r14, %rsi
cmpq $0x4, 0x48(%rbx)
jb 0x2c14
cmpq (%rbx), %rsi
jbe 0x2cd9
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1736
movq 0x48(%rbx), %rdx
cmpq %rdx, %rax
jbe 0x2cd9
movq %rax, %r15
movq 0x50(%rbx), %rsi
addq %r14, %rsi
subq 0x28(%rbx), %rsi
movq %rbx, %rdi
callq 0x1736
cmpq %r15, %rax
setae %cl
movabsq $0x7ffffffffffffffe, %rdx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rdx, %rax
seta %dl
orb %cl, %dl
jne 0x2cae
movq %rax, %rcx
addq %rax, %rcx
js 0x2c6a
cvtsi2ss %rcx, %xmm0
jmp 0x2c7b
movq %rax, %rdx
btrq $0x3f, %rdx
cvtsi2ss %rdx, %xmm0
addss %xmm0, %xmm0
mulss 0x14(%rbx), %xmm0
cvttss2si %xmm0, %rdx
movq %rdx, %rsi
subss 0x13a0(%rip), %xmm0     # 0x4030
sarq $0x3f, %rsi
cvttss2si %xmm0, %rdi
andq %rsi, %rdi
addq 0x50(%rbx), %r14
subq 0x28(%rbx), %r14
orq %rdx, %rdi
cmpq %rdi, %r14
cmovaeq %rcx, %rax
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x1f04
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f84
leaq 0x30(%rsp), %rdi
callq 0x1636
movb $0x1, %bpl
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x1070
movq %rax, %rbx
leaq 0x13b3(%rip), %rsi      # 0x40ab
movq %rax, %rdi
callq 0x10c0
movq 0x72d9(%rip), %rsi      # 0x9fe0
movq 0x72c2(%rip), %rdx      # 0x9fd0
movq %rbx, %rdi
callq 0x1160
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x1636
jmp 0x2d30
movq %rax, %r14
movq %rbx, %rdi
callq 0x10b0
movq %r14, %rdi
callq 0x1170