#include <fstream>
#include <vector>



class RadixSort{
public:
    static void sort(std::vector<int>& input)
    {
        temp.assign(input.size(), 0);
        for (auto bucket = 0; bucket < 4; bucket++)
        {
            computeFrequencies(input, bucket);
            computePositions();
            moveElements(input, bucket);
        }
    }
private:
    static constexpr int countsize = 256;
    static constexpr int bucketsize = 8;
    static constexpr int mask = (1 << bucketsize) - 1;
    static std::vector<int> temp;
    static std::vector<int> frequence;
    static std::vector<int> index;

    static int computeIndex(int val, int bucket)
    {
        return val >> (bucket * bucketsize) & mask;
    }

    static void computeFrequencies(const std::vector<int>& input, int bucket)
    {
        frequence.assign(countsize, 0);

        for (auto it = input.cbegin(); it != input.cend(); ++it)
        {
            auto c = computeIndex(*it, bucket);
            frequence[c]++;
        }
    }

    static void computePositions()
    {
        index.assign(countsize, 0);
        int i, count = frequence[0];

        for (i = 1; i < countsize; i++)
        {
            if (frequence[i])
            {
                index[i] = count;
                count += frequence[i];
            }
        }
    }

    static void moveElements(std::vector<int>& input, int bucket)
    {
        for (auto it = input.cbegin(); it != input.cend(); ++it)
        {
            auto pos = computeIndex(*it, bucket);
            frequence[pos] --;
            temp[index[pos]] = *it;
            index[pos]++;
        }

        input.assign(temp.begin(), temp.end());
    }
};

std::vector<int> RadixSort::temp;
std::vector<int> RadixSort::frequence;
std::vector<int> RadixSort::index;

std::vector<int> generateInput(int N, int A, int B, int C)
{
    std::vector<int> input(N, 0);
    input[0] = B;
	for (int i = 1; i < N; i++)
	{
		input[i] = (int)((((long int)A) * ((long int)input[i - 1]) + ((long int)B)) % ((long int)C));
	}

	return input;
}

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

    auto N=0, A=0, B=0, C=0;
	f >> N >> A >> B >> C;
    auto input = generateInput(N, A, B, C);

	RadixSort::sort(input);

    for (size_t i = 0; i < input.size(); i += 10)
	{
		g << input[i] << ' ';
	}

	return 0;
}