#include <fstream>
#include <array>
#include <queue>

std::ifstream f("radixsort.in");
std::ofstream g("radixsort.out");

using num_t = uint64_t;

num_t N, A, B, C;
num_t digits, max;
constexpr num_t base = 10;

std::array<num_t, 10000005> nums;

num_t GetNumOfDigits(num_t n)
{
	num_t cnt = 0;

	while (n) {
		n /= 10ui64;
		++cnt;
	}

	return cnt;
}

void Generate()
{
	nums[0] = B;
	max = nums[0];

	for (num_t i = 1; i < N; ++i) {
		nums[i] = (A * nums[i - 1] + B) % C;
		
		if (nums[i] > max) {
			max = nums[i];
		}
	}

	digits = GetNumOfDigits(max);
}

//void CountSort(num_t digit)
//{
//	auto factor = [](num_t i) { 
//								num_t res = 1; 
//								for (num_t j = 1; j <= i; ++j) 
//									res *= 10; 
//
//								return res;
//							};
//
//	num_t i;
//	num_t count[11] = { 0 };
//	const num_t exp = factor(digit);
//
//	for (i = 0; i < N; ++i) {
//		++count[(nums[i] / exp) % base];
//	}
//
//	for (i = 1; i < base; ++i) {
//		count[i] += count[i - 1];
//	}
//
//	for (i = N - 1; i >= 0; --i) {
//		nums[count[(nums[i] / exp) % base] - 1] = nums[i];
//		
//	}
//}

void Sort()
{
	num_t i, j, factor;
	
	std::queue<num_t> q[base];
	
	for (i = 0, factor = 1; i < digits; ++i, factor *= base) {
		for (j = 0; j < N; ++j) {
			q[(nums[j] / factor) % base].emplace(nums[j]);
		}
		
		num_t k = 0;
	
		for (num_t l = 0; l < base; ++l) 
			while (!q[l].empty()) {
				nums[k] = q[l].front();
				q[l].pop();
				++k;
			}
	}

	//for (num_t i = 1; i <= digits; ++i) {
	//	CountSort(i);
	//}
}

void Prnum_t()
{
	for (num_t i = 0; i < N; i = i + 10) {
		g << nums[i] << ' ';
	}
}

int main(num_t, char *[])
{
	f >> N >> A >> B >> C;
	
	Generate();
	Sort();
	Prnum_t();

	return 0;
}