#include <algorithm>
#include <fstream>
#include <iterator>

using namespace std;

typedef unsigned long int uint_t;
const uint_t BASE = 128;

inline uint_t number_of_digits(uint_t n) {
    uint_t i;
    for (i = 0; n; ++i, n /= BASE);
    return i;
}

inline uint_t get_digit(uint_t n, uint_t d) {
    for (; d > 0; --d, n /= BASE);
    return n % BASE;
}

void counting_sort(
            vector<uint_t>& v,
            const uint_t digit,
            vector<uint_t>& counter,
            vector<uint_t>& storage) {
    
    fill(counter.begin(), counter.end(), 0);
    
    for_each(v.begin(), v.end(), [&counter, digit] (const uint_t& x) {
        ++counter[ get_digit(x, digit) ];
    });
    
    partial_sum(counter.begin(), counter.end(), counter.begin());
    
    for_each(v.rbegin(), v.rend(), [&counter, &storage, digit] (const uint_t& x) {
        storage[ --counter[ get_digit(x, digit) ] ] = x;
    });
    
    copy(storage.begin(), storage.end(), v.begin());
}

int main() {
    ifstream fin("radixsort.in");
    ofstream fout("radixsort.out");

    uint_t n, a, b, c;    
    fin >> n >> a >> b >> c;
    
    vector<uint_t> v;
    generate_n( back_inserter(v), n, [&a, &b, &c] () {
                    static uint_t r = b;
                    uint_t t = r;
                    r = (a * r + b) % c;
                    return t;
                });
    
    vector<uint_t> counter(BASE);
    vector<uint_t> temp_storage(v.size());
 
    for (uint_t digit = 0; digit < number_of_digits(c); ++digit)
        counting_sort(v, digit, counter, temp_storage);
   
    for (uint_t i = 0; i < v.size(); i += 10)
        fout << v[i] << ' ';
    fout << endl;
       
    return 0;
}