/**
radix sort: O( baza * n * log(baza, maximum) )
(maximum = c)

ne avantajeaza mai mult sa scadem din baza direct
decat sa marim baza ca sa scadem logaritmul
pentru ca logaritmul creste logaritmic
si baza creste linear
linear > logaritmic

hai sa setam baza la 2
ar trebui sa obtinem
O( 2*n*lb(maximum) )
adica O(64*n)

ceea ce ar trebui sa fie accentuat
de comfortul calculului cu 2 pe care il au procesoarele


optimizez codul pentru baza 2
**/

#define fisier "radixsort"

#ifdef consola

    #include <iostream>
    #define in std::cin
    #define out std::cout

#else

    #include <fstream>

    #ifndef fisier
        #define fisier "HYPER"
    #endif

    std::ifstream in(fisier ".in");
    std::ofstream out(fisier ".out");

#endif



const int
MAX_N = 10000000; // 10 000 000



inline int getCif(int x, int z) {

    return (x >> z) & 1;

}



void cifSort(int* v, int n, int z) {

    static int aux[MAX_N];

    int zero_total = 0, zero_puse = 0, unu_puse = 0;



    for (int i = 0; i < n; i++) {

        if (!getCif(v[i], z))
            zero_total++;

    }



    for (int i = 0; i < n; i++) { /// un fel de interclasare inversa

        if (getCif(v[i], z)) {

            aux[zero_total + unu_puse++] = v[i];

        } else {

            aux[zero_puse++] = v[i];

        }

    }



    for (int i = 0; i < n; i++) {

        v[i] = aux[i];

    }

}



void radixSort(int* v, int n) {

    for (int z = 0; z < 32; z++) {

        cifSort(v, n, z);

    }

}



int v[MAX_N];

int main() {

    int n, a, b, c;

    in >> n >> a >> b >> c;

    *v = b;

    for (int i = 1; i < n; i++) {

        v[i] = (a * v[i - 1] + b) % c;

    }



    radixSort(v, n);



    for (int i = 0; i < n; i += 10) {

        out << v[i] << ' ';

    }

}






















//