#include <iostream>
#include <boost/unordered_set.hpp>
#include <unordered_set>
#include <map>
#include <functional>
#include <algorithm>
#include <iterator>

volatile size_t c;

int main()
{
    std::cout << "size_t is " << std::numeric_limits<size_t>::digits << " bit\n";
    std::unordered_set<int> v;
    //boost::unordered_set<int> v;
    for (int i = 2000 ; i < 3000 ; i++ )
    {
        v.emplace(i);
    }
    
    for (int times = 0 ; times < 50000 ; times++)
    {
        for (int i = 1000 ; i < 3000 ; i++ )
        {
            c = v.count(i);
        }    
    }


    std::map<int, int, std::greater<int> > collisions;

    for (int bucket = 0, count = v.bucket_count(); bucket < count ; bucket++)
    {
        size_t size = v.bucket_size(bucket);
        if ( size > 1 )
            collisions[size]++;
    }
    
    if ( collisions.empty() )
    {
        std::cout << "No collisions\n";
    }
    else
    {
        for ( auto& it : collisions )
        {
            std::cout << it.first << ":" << it.second << "\n";
        }
    }
    
}