#include <iostream>
#include <thread>
#include <functional>
#include <algorithm>
 
using namespace std;
inline void ParallelFor( const size_t startIdx, const size_t endIdx, std::function< void( size_t ) >&& fn, const size_t numThreads = std::thread::hardware_concurrency() )
{
    const size_t portion = std::max( 1u, (endIdx - startIdx) / numThreads );
    std::vector< std::thread > threads;
    for ( size_t i = startIdx; i < endIdx; i += portion )
    {
        int from    = i;
        int to      = (i + portion) <= endIdx ? (i + portion) : endIdx;
 
        threads.push_back( std::thread( [=,&fn]() 
            {
                for ( int j = from; j < to; ++j )
                    fn( j );
            } ) );
    }
    std::for_each( threads.begin(), threads.end(), []( std::thread& x ) 
        { 
            x.join();
        } );
}
int main() {
	std::vector<unsigned int> v;
    for(unsigned int i = 0; i < 64; i++)
    {
    	v.push_back(i);	
    }
    auto func = [&v](size_t j) {
    	v[j] = v[j]*v[j];
    };
    ParallelFor(0, v.size(), func, 4);
    for(unsigned int i = 0; i < v.size(); i++)
    {
    	std::cout << v[i] << "\n";
    }
    return 0;
}

I2luY2x1ZGUgPGlvc3RyZWFtPgojaW5jbHVkZSA8dGhyZWFkPgojaW5jbHVkZSA8ZnVuY3Rpb25hbD4KI2luY2x1ZGUgPGFsZ29yaXRobT4KCnVzaW5nIG5hbWVzcGFjZSBzdGQ7CmlubGluZSB2b2lkIFBhcmFsbGVsRm9yKCBjb25zdCBzaXplX3Qgc3RhcnRJZHgsIGNvbnN0IHNpemVfdCBlbmRJZHgsIHN0ZDo6ZnVuY3Rpb248IHZvaWQoIHNpemVfdCApID4mJiBmbiwgY29uc3Qgc2l6ZV90IG51bVRocmVhZHMgPSBzdGQ6OnRocmVhZDo6aGFyZHdhcmVfY29uY3VycmVuY3koKSApCnsKICAgIGNvbnN0IHNpemVfdCBwb3J0aW9uID0gc3RkOjptYXgoIDF1LCAoZW5kSWR4IC0gc3RhcnRJZHgpIC8gbnVtVGhyZWFkcyApOwogICAgc3RkOjp2ZWN0b3I8IHN0ZDo6dGhyZWFkID4gdGhyZWFkczsKICAgIGZvciAoIHNpemVfdCBpID0gc3RhcnRJZHg7IGkgPCBlbmRJZHg7IGkgKz0gcG9ydGlvbiApCiAgICB7CiAgICAgICAgaW50IGZyb20gICAgPSBpOwogICAgICAgIGludCB0byAgICAgID0gKGkgKyBwb3J0aW9uKSA8PSBlbmRJZHggPyAoaSArIHBvcnRpb24pIDogZW5kSWR4OwoKICAgICAgICB0aHJlYWRzLnB1c2hfYmFjayggc3RkOjp0aHJlYWQoIFs9LCZmbl0oKSAKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgZm9yICggaW50IGogPSBmcm9tOyBqIDwgdG87ICsraiApCiAgICAgICAgICAgICAgICAgICAgZm4oIGogKTsKICAgICAgICAgICAgfSApICk7CiAgICB9CiAgICBzdGQ6OmZvcl9lYWNoKCB0aHJlYWRzLmJlZ2luKCksIHRocmVhZHMuZW5kKCksIFtdKCBzdGQ6OnRocmVhZCYgeCApIAogICAgICAgIHsgCiAgICAgICAgICAgIHguam9pbigpOwogICAgICAgIH0gKTsKfQppbnQgbWFpbigpIHsKCXN0ZDo6dmVjdG9yPHVuc2lnbmVkIGludD4gdjsKICAgIGZvcih1bnNpZ25lZCBpbnQgaSA9IDA7IGkgPCA2NDsgaSsrKQogICAgewogICAgCXYucHVzaF9iYWNrKGkpOwkKICAgIH0KICAgIGF1dG8gZnVuYyA9IFsmdl0oc2l6ZV90IGopIHsKICAgIAl2W2pdID0gdltqXSp2W2pdOwogICAgfTsKICAgIFBhcmFsbGVsRm9yKDAsIHYuc2l6ZSgpLCBmdW5jLCA0KTsKICAgIGZvcih1bnNpZ25lZCBpbnQgaSA9IDA7IGkgPCB2LnNpemUoKTsgaSsrKQogICAgewogICAgCXN0ZDo6Y291dCA8PCB2W2ldIDw8ICJcbiI7CiAgICB9CiAgICByZXR1cm4gMDsKfQ==