// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SelectKey, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, spp::libc_allocator<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_exception(std::length_error("resize overflow"));
        }

        size_type num_occupied = (size_type)(table.num_nonempty() + num_deleted);

        if (bucket_count() >= HT_MIN_BUCKETS &&
             (num_occupied + 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).
        // -------------------------------------------------------------
        const size_type needed_size =
                  settings.min_buckets((size_type)(num_occupied + delta), (size_type)0);

        if (needed_size <= bucket_count())      // we have enough buckets
            return did_resize;

        size_type resize_to = settings.min_buckets((size_type)(num_occupied + 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((size_type)(resize_to*2)));
            if (table.num_nonempty() + 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 %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x18(%rdi)
jne 0x1a0e
movq %rbx, %rdi
callq 0x1c08
movl %eax, %ebp
jmp 0x1a10
xorl %ebp, %ebp
movq 0x48(%rbx), %r15
movq %r14, %rax
notq %rax
cmpq %rax, %r15
jae 0x1b0b
addq 0x28(%rbx), %r15
cmpq $0x4, 0x40(%rbx)
jb 0x1a3b
leaq (%r15,%r14), %rax
cmpq (%rbx), %rax
jbe 0x1afc
addq %r14, %r15
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x18ae
movq 0x40(%rbx), %rdx
cmpq %rdx, %rax
jbe 0x1afc
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x18ae
cmpq %r12, %rax
setae %cl
movabsq $0x7ffffffffffffffe, %rdx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rdx, %rax
seta %dl
orb %cl, %dl
jne 0x1acf
movq %rax, %rcx
addq %rax, %rcx
js 0x1a8f
cvtsi2ss %rcx, %xmm0
jmp 0x1aa0
movq %rax, %rdx
btrq $0x3f, %rdx
cvtsi2ss %rdx, %xmm0
addss %xmm0, %xmm0
mulss 0x14(%rbx), %xmm0
cvttss2si %xmm0, %rdx
movq %rdx, %rsi
subss 0x158b(%rip), %xmm0     # 0x3040
cvttss2si %xmm0, %rdi
sarq $0x3f, %rsi
andq %rsi, %rdi
addq 0x48(%rbx), %r14
orq %rdx, %rdi
cmpq %rdi, %r14
cmovaeq %rcx, %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x1d22
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e30
leaq 0x38(%rsp), %rdi
callq 0x1766
movb $0x1, %bpl
movl %ebp, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15a9(%rip), %rsi      # 0x30bb
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x10c0
movl $0x10, %edi
callq 0x1070
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1130
movq 0x4492(%rip), %rax      # 0x5fd0
addq $0x10, %rax
movq %rax, (%r14)
movq 0x4494(%rip), %rsi      # 0x5fe0
movq 0x4475(%rip), %rdx      # 0x5fc8
movq %r14, %rdi
callq 0x1140
jmp 0x1b6c
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x1766
jmp 0x1b81
movq %rax, %rdi
callq 0x17b0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1178
movq %rbx, %rdi
callq 0x1150
nop