#include <fstream>
#include <iostream>
#include <iterator>
#include <algorithm>
#include <vector>
#include <cstring>

using namespace std;

#define MAXRAD (0xffff + 1)

struct ValGen
{
    ValGen(uint32_t a_, uint32_t b_, uint32_t c_, uint32_t prev_) :
        _a(a_),
        _b(b_),
        _c(c_),
        _prev(prev_)
    {}
    
    uint32_t operator () ()
    {
        uint32_t val = (_a * _prev + _b) % _c;
        _prev = val;
        
        return val;
    }

private:
    uint32_t _a;
    uint32_t _b;
    uint32_t _c;
    uint32_t _prev;
};

void radix_pass(uint32_t in_[], uint32_t out_[], int n_, int pass_)
{
    static int count[MAXRAD];
    memset(count, 0, MAXRAD * sizeof(int));
    
    for (int i=0; i<n_; ++i)
    {
        count[(in_[i] >> (pass_ * 16)) & 0xffff]++;
    }
    
    int prev = count[0];
    count[0] = 0;
    for (int i=1; i<MAXRAD; ++i)
    {
        int aux = count[i];
        count[i] = count[i - 1] + prev;
        prev = aux;
    }
    
    for (int i=0; i<n_; ++i)
    {
        out_[count[(in_[i] >> (pass_ * 16)) & 0xffff]++] = in_[i];
    }
}

int main()
{
    fstream fin("radixsort.in", fstream::in);
    fstream fout("radixsort.out", fstream::out);
    
    int n;
    uint32_t a, b, c;
    fin >> n >> a >> b >> c;
    //cout << n << " " << a << " " << b << " " << c << endl;
    
    uint32_t *v = static_cast<uint32_t*>(malloc((n + 1) * sizeof(uint32_t)));
    uint32_t *buffer = static_cast<uint32_t*>(malloc((n + 1) * sizeof(uint32_t)));
    
    v[0] = b;
    generate_n(v + 1, n - 1, ValGen(a, b, c, v[0]));
    
    ostream_iterator<uint32_t> itOut(cout, " ");
    //copy(v, v + n, itOut);
    //cout << endl;
    
    //sort(v, v + n);
    radix_pass(v, buffer, n, 0);
    radix_pass(buffer, v, n, 1);
    
    for (int i=0; i<n; i+=10)
    {
        fout << v[i] << " ";
    }
    fout << "\n";
    
    free(buffer);
    free(v);
    
    return 0;
}