#include <iostream>
#include <random>
#include <ctime>
#include <map>
 
struct Range
{
    int min;
    int max;
};
 
template <typename... T>
struct and_
    : std::true_type
{};
 
template <typename First, typename... Other>
struct and_<First, Other...>
    : std::integral_constant<bool, First::value && and_<Other...>::value>
{};
 
template < typename ...RangeT
         , typename = typename std::enable_if<
                    and_<
                        std::is_same<RangeT, Range>...
                    >::value
                >::type
>
int random(RangeT const &...args)
{
    static std::mt19937 mt(static_cast<unsigned>(time(nullptr)));
    auto gen = [](Range const & x, std::mt19937 & g)
    {
        return std::uniform_int_distribution<int>(x.min, x.max)(g);
    };
    int const values[] = { gen(args, mt)... };
    std::discrete_distribution<int> idx({ std::fabs(args.min - args.max)... });
    return values[idx(mt)];
}
 
int main()
{
    std::map<int, int> m;
    for(size_t n = 0; n < 10000; ++n)
    {
        ++m[random(Range{ 0, 2 }, Range{ 50, 100 })];
    }
    for(auto p : m)
    {
        std::cout << p.first << " generated " << p.second << " times\n";
    }
}

I2luY2x1ZGUgPGlvc3RyZWFtPgojaW5jbHVkZSA8cmFuZG9tPgojaW5jbHVkZSA8Y3RpbWU+CiNpbmNsdWRlIDxtYXA+CgpzdHJ1Y3QgUmFuZ2UKewogICAgaW50IG1pbjsKICAgIGludCBtYXg7Cn07Cgp0ZW1wbGF0ZSA8dHlwZW5hbWUuLi4gVD4Kc3RydWN0IGFuZF8KICAgIDogc3RkOjp0cnVlX3R5cGUKe307Cgp0ZW1wbGF0ZSA8dHlwZW5hbWUgRmlyc3QsIHR5cGVuYW1lLi4uIE90aGVyPgpzdHJ1Y3QgYW5kXzxGaXJzdCwgT3RoZXIuLi4+CiAgICA6IHN0ZDo6aW50ZWdyYWxfY29uc3RhbnQ8Ym9vbCwgRmlyc3Q6OnZhbHVlICYmIGFuZF88T3RoZXIuLi4+Ojp2YWx1ZT4Ke307Cgp0ZW1wbGF0ZSA8IHR5cGVuYW1lIC4uLlJhbmdlVAogICAgICAgICAsIHR5cGVuYW1lID0gdHlwZW5hbWUgc3RkOjplbmFibGVfaWY8CiAgICAgICAgICAgICAgICAgICAgYW5kXzwKICAgICAgICAgICAgICAgICAgICAgICAgc3RkOjppc19zYW1lPFJhbmdlVCwgUmFuZ2U+Li4uCiAgICAgICAgICAgICAgICAgICAgPjo6dmFsdWUKICAgICAgICAgICAgICAgID46OnR5cGUKPgppbnQgcmFuZG9tKFJhbmdlVCBjb25zdCAmLi4uYXJncykKewogICAgc3RhdGljIHN0ZDo6bXQxOTkzNyBtdChzdGF0aWNfY2FzdDx1bnNpZ25lZD4odGltZShudWxscHRyKSkpOwogICAgYXV0byBnZW4gPSBbXShSYW5nZSBjb25zdCAmIHgsIHN0ZDo6bXQxOTkzNyAmIGcpCiAgICB7CiAgICAgICAgcmV0dXJuIHN0ZDo6dW5pZm9ybV9pbnRfZGlzdHJpYnV0aW9uPGludD4oeC5taW4sIHgubWF4KShnKTsKICAgIH07CiAgICBpbnQgY29uc3QgdmFsdWVzW10gPSB7IGdlbihhcmdzLCBtdCkuLi4gfTsKICAgIHN0ZDo6ZGlzY3JldGVfZGlzdHJpYnV0aW9uPGludD4gaWR4KHsgc3RkOjpmYWJzKGFyZ3MubWluIC0gYXJncy5tYXgpLi4uIH0pOwogICAgcmV0dXJuIHZhbHVlc1tpZHgobXQpXTsKfQoKaW50IG1haW4oKQp7CiAgICBzdGQ6Om1hcDxpbnQsIGludD4gbTsKICAgIGZvcihzaXplX3QgbiA9IDA7IG4gPCAxMDAwMDsgKytuKQogICAgewogICAgICAgICsrbVtyYW5kb20oUmFuZ2V7IDAsIDIgfSwgUmFuZ2V7IDUwLCAxMDAgfSldOwogICAgfQogICAgZm9yKGF1dG8gcCA6IG0pCiAgICB7CiAgICAgICAgc3RkOjpjb3V0IDw8IHAuZmlyc3QgPDwgIiBnZW5lcmF0ZWQgIiA8PCBwLnNlY29uZCA8PCAiIHRpbWVzXG4iOwogICAgfQp9