template <typename I, typename Lambda>
void CoLoop(I begin, I end, const Lambda& lambda)
{
	size_t chunk = max(size_t((end - begin) / CPU_Cores()), (size_t)1);
	CoWork co;
	while(begin < end) {
		co & [=] {
			lambda(begin, begin + min(chunk, size_t(end - begin)));
		};
		begin += chunk;
	}
}

template <class I, class Better>
I CoBest(I begin, I end, const Better& better)
{
	I best = begin++;
	CoLoop(begin, end,
		[=, &best](I i, I e) {
			I b = i++;
			while(i < e) {
				if(better(*i, *b))
					b = i;
				i++;
			}
			CoWork::FinLock(); // better is shared across threads, needs a lock!
			if(better(*b, *best))
				best = b;
		}
	);
	return best;
}

static double pi_device() {
	double x, y;
	long count = 0, i;
	
	// Parallel loop with reduction for calculating PI  
	#pragma omp parallel for private(i, x, y) shared (samples) reduction(+:count) 
	for (i = 0; i < samples; ++i) {
		x = Random(1000000)/1000000.;
		y = Random(1000000)/1000000.;
		if (sqrt(x*x + y*y) < 1)
			count++;
	}
	return 4.0 * count / samples;
}

	int samples = 100000000;
	int count = 0;
	CoLoop(0, samples,
		[=, &count](int a, int b) {
			int lcount = 0;
			while(a < b) {
				double x = Randomf();
				double y = Randomf();
				if(sqrt(x*x + y*y) < 1)
					lcount++;
				a++;
			}
			CoWork::FinLock();
			count += lcount;
		}
	);