// {{{ by unolight
#include <bits/stdc++.h>
#pragma GCC diagnostic ignored "-Wunused-result"
#pragma GCC diagnostic ignored "-Wunused-function"
#define SZ(x) ((int)(x).size())
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define REP1(i,a,b) for (int i = a; i <= (int)(b); i++)
#define ALL(c) (c).begin(), (c).end()
#define RALL(c) (c).rbegin(), (c).rend()
#define PB push_back
#define MP make_pair
using namespace std;
typedef long long LL;
typedef vector<int> VI;
typedef pair<int,int> PII;

namespace { namespace unolight {
    
#ifdef UNOLIGHT
#include "dump.hpp"
#else
#define dump(...)
#endif

template<class T> inline bool chmax( T &a, const T &b ) { return b>a ? a=b,true : false; }
template<class T> inline bool chmin( T &a, const T &b ) { return b<a ? a=b,true : false; }
template <class T, class F = less<T>>
void sort_uniq(vector<T> &v, F f = F()) {
    sort(begin(v), end(v), f);
    v.resize(unique(begin(v), end(v)) - begin(v));
}
// }}}

// {{{ ModInt
template<int _MOD>
struct ModInt {
	static const auto MOD = _MOD;
	template<class T> using integral_only = typename enable_if<is_integral<T>::value>::type;

    int x;   
	constexpr ModInt() : x() {}

	template<class T, integral_only<T>* = nullptr>
    ModInt(T _x=0) {
		x = _x % MOD;
		if(x<0) x+=MOD;
	}
    ModInt operator-() const { return {x == 0? 0 : MOD-x}; }
    ModInt& operator+=(const ModInt a) {
        if ((x += a.x) >= MOD) x -= MOD;
        return *this;
    }
    ModInt& operator-=(const ModInt a) {
        if ((x += MOD-a.x) >= MOD) x -= MOD;
        return *this;
    }
    ModInt& operator*=(const ModInt a) {
        x = (long long)x * a.x % MOD;
        return *this;
    }
    ModInt& operator/=(const ModInt a) {
        return (*this) *= a.inv();
    }

    ModInt operator+(const ModInt a) const { return ModInt(*this) += a; }
    ModInt operator-(const ModInt a) const { return ModInt(*this) -= a; }
    ModInt operator*(const ModInt a) const { return ModInt(*this) *= a; }
    ModInt operator/(const ModInt a) const { return ModInt(*this) /= a; }
    ModInt inv() const {
	    // for prime MOD
        return pow(MOD-2);
    }
	ModInt inv2() const {
		// work for non-prime MOD if gcd(x,MOD) = 1
		int a = x, b = MOD, u = 1, v = 0;
		while(b != 0) {
			int t = a / b;
			a -= t * b;
			u -= t * v;
			swap(a, b);
			swap(u, v);
		}
		return u;
	}
	template<class T, integral_only<T>* = nullptr>
    ModInt pow(T t) const {
		ModInt r = 1, p = *this;
		while(t) {
			if(t & 1) r *= p;
			p *= p;
			t >>= 1;
		}
        return r;
    }

    bool operator==(ModInt rhs) const { return x == rhs.x; }
    bool operator!=(ModInt rhs) const { return x != rhs.x; }
    bool operator<(ModInt rhs) const { return x < rhs.x; }
    bool operator<=(ModInt rhs) const { return x <= rhs.x; }
    bool operator>(ModInt rhs) const { return x > rhs.x; }
    bool operator>=(ModInt rhs) const { return x >= rhs.x; }

    friend string to_string(ModInt i) { return to_string(i.x); }
    friend istream& operator>>(istream&i,ModInt&a) { return i>>a.x; }
    friend ostream& operator<<(ostream&o,const ModInt&a) { return o<<a.x; }
};

const int MOD=998244353;
using mint=ModInt<MOD>;
// }}}

void main() {
    int n, k;
    cin >> n >> k;
    vector<int> a(n);
    REP(i,n) cin >> a[i];
    vector<mint> s(k+1); // sum(ai^k)
    vector<vector<mint>> c(k+1, vector<mint>(k+1));
    c[0][0]=1;
    REP(i,k) {
        REP(j,i+1) {
            c[i+1][j]+=c[i][j];
            c[i+1][j+1]+=c[i][j];
        }
    }
    REP(i,n) {
        mint x=1;
        REP(j,k+1) {
            s[j]+=x;
            x*=a[i];
        }
    }
    REP1(i,1,k) {
        mint ans=0;
        REP(j,i+1) {
            ans+=c[i][j]*s[j]*s[i-j];
            ans-=c[i][j]*s[i];
        }
        cout << ans/2 << '\n';
    }
}

// {{{ main
}}
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    unolight::main();
    return 0;
}
// }}}
#include<bits/stdc++.h>
#define fi first
#define se second
using namespace std;
const int K=1e5;
long long w[K+10];
priority_queue<pair<long long,int>> pq;
int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int k;
	long long n,m;
	cin>>k>>n>>m;
	int lft=m;
	for(int i=1;i<=k;i++)
	{
		long long a;
		cin>>a;
		w[i]=(a*m)/n;
		lft-=w[i];
		pq.push({abs(w[i]*n-a*m)-abs((w[i]+1)*n-a*m),i});
	}
	for(;lft>0;lft--)
	{
		w[pq.top().se]++;
		pq.pop();
	}
	for(int i=1;i<=k;i++)
		cout<<w[i]<<" ";
	cout<<"\n";
	return 0;
}

