Filling up a hand with random cards that are not yet drawn - Monte Carlo I would like to know if there is a more efficient way to speed up below code. This function is meant to fill in a set of poker hand with the remaining 
cards using Mersenne Twister for a Monte Carlo simulation.

void HandEvaluator::RandomFill(std::vector&lt;std::shared_ptr&lt;Card&gt;&gt;&amp; _Set, std::vector&lt;std::shared_ptr&lt;Card&gt;&gt;&amp; _Dead, unsigned int _Target){
    //Add the cards that are currently in Set as dead cards
    for (auto const&amp; CardInSet : _Set)
    {
        if (CardInSet == nullptr)
            break;

        _Dead.push_back(CardInSet);
    }

    bool IsDead;
    unsigned int RequiredAmt = _Target - _Set.size();

    unsigned int CardIndex = 0;
    std::uniform_int_distribution&lt;unsigned int&gt; CardsDistribution(0, 51);

    for (unsigned int Index = 0; Index &lt; RequiredAmt; Index++)
    {
        while (true)
        {
            IsDead = false;
            CardIndex = CardsDistribution(MTGenerator);

            for (auto const&amp; Dead : _Dead)
            {
                if (ReferenceDeck[CardIndex]-&gt;GetRank() == Dead-&gt;GetRank() &amp;&amp; ReferenceDeck[CardIndex]-&gt;GetSuit() == Dead-&gt;GetSuit())
                {
                    IsDead = true;
                    break;
                }
            }

            if (!IsDead)
            {
                _Set.push_back(ReferenceDeck[CardIndex]);
                break;
            }
        }
    }
}


The Visual Studio Profiler had identified that this line

    CardIndex = CardsDistribution(MTGenerator);


is the main culprit behind the high compute time. Is Mersenne Twister itself not meant for a Monte Carlo Simulation and another PRNG should be used instead ? Or there are some inefficient lines that I had missed out ?
In the end, I opt to replace Mersenne Twister with another PRNG, xoroshiro128+, it managed to cut the compute time by around 15%. I also did some minor optimization on the for-loop but the improvement is minuscule. Anyway, here is the same function but with new PRNG:

Seeding in HandEvaluator's constructor:

HandEvaluator::HandEvaluator()
{
    Initialize();
    MTGenerator.seed(std::chrono::high_resolution_clock::now().time_since_epoch().count());

    s[0] = std::chrono::high_resolution_clock::now().time_since_epoch().count();
    std::cout &lt;&lt; "Seed 1: " &lt;&lt; s[0] &lt;&lt; "\n";

    s[1] = std::chrono::high_resolution_clock::now().time_since_epoch().count();
    std::cout &lt;&lt; "Seed 2: " &lt;&lt; s[1] &lt;&lt; "\n";
}


HandEvaluator's RandomFill function:

void HandEvaluator::RandomFill(std::vector&lt;std::shared_ptr&lt;Card&gt;&gt;&amp; _Set, std::vector&lt;std::shared_ptr&lt;Card&gt;&gt;&amp; _Dead, unsigned int _Target)
{
    //Add the cards that are currently in Set as dead cards
    for (auto const&amp; CardInSet : _Set)
    {
        if (CardInSet == nullptr)
            break;

        _Dead.push_back(CardInSet);
    }

    bool IsDead;
    unsigned int RequiredAmt = _Target - _Set.size();

    for (unsigned int Index = 0; Index &lt; RequiredAmt; Index++)
    {
        while (true)
        {
            _Set.push_back(ReferenceDeck[next() % 52]);

            IsDead = false;

            for (auto const&amp; Dead : _Dead)
            {
                if (Dead-&gt;IsEqualTo(_Set[_Set.size() - 1]))
                {
                    IsDead = true;
                    break;
                }
            }

            if (IsDead)
                _Set.pop_back();
            else
                break;
        }
    }
}