#include <fstream>
#define file "radixsort"
#define N 10000003
#define bucket 8
#define TYPE 32
#define lim (1<<8) - 1 // va fi numarul (11111111) = 255
using namespace std;

ifstream fin(file".in");
ofstream fout(file".out");

int n,A,B,C;
int v[N],aux[N];
int f[lim+3];

void input()
{
    fin>>n>>A>>B>>C;
    v[1] = B;
    for(int i=1; i<=n; ++i)
        v[i] = ((long long)A * v[i-1] + B) % C;
}

inline void reset(int vec[])
{
    for(int i=0; i < sizeof(vec)/sizeof((vec)[0]); ++i)
        vec[i] = 0;
}

inline int get_bucket(const int &val, const int &k)
{
    return (val>>(k*bucket)) & lim;
    //returneaza valoarea buchetului k. Se ignora primele k-1 buchete, si se ia al k-lea
}

void RadixSort(int k)
{
    reset(f);

    for(int i=1; i<=n; ++i)
        ++f[get_bucket(v[i],k)];

    for(int i=1; i<=lim; ++i)
        f[i] += f[i-1];

    //f[i] = j, sunt j elemente mai mari sau egale cu i.

    for(int i=n; i>=1; --i)
    {
        aux[f[get_bucket(v[i],k)]] = v[i];
        --f[get_bucket(v[i],k)]; // in cazul in care sunt 2 numere egale,
        //se vor pune pe pozitii diferite.
        //k numere sunt >= 38 , k-1 numere sunt >= decat urmatorul numar 38
    }

    for(int i=1; i<=n; ++i)
        v[i] = aux[i];

}

inline void output()
{
    for(int i=1; i<=n; i+=10)
        fout<<v[i]<<" ";
}

int main()
{
    input();

    /*
    In cazul nostru numerele au maxim 32 biti si se pot imparti in "buchete" de cate 8 biti.
    Astfel vom lua de la cel mai nesemnificativ buchet la cel mai semnificativ,
    si le vom sorta folosind Counting Sort in timp liniar deoarece avem numere naturale
    iar buchetul luat pastreaza un interval relativ mic de numere. 8 biti (11111111) = 255
    */

    for(int i=0; i < TYPE/bucket; ++i)
        RadixSort(i);
    // i de pe 0 deoarece initial eliminam 0 biti pentru obtine urmatorul buchet.

    output();

    fin.close(); fout.close();
    return 0;
}