#ifndef Yamada
#define Yamada
#include Yamada __FILE__ Yamada

const int mod = 998244353;
int n, k;

pii operator*(const pii &a, const pii &b) {
    int F = a.X * b.X % (mod-1) * n % (mod-1);
    F = (F + a.X * b.Y % (mod-1)) % (mod-1);
    F = (F + a.Y * b.X % (mod-1)) % (mod-1);
    int tmp = a.Y * b.Y;
    F = (F + tmp / n) % (mod-1);
    return pii(F, tmp % n);
}

pii piifpow(pii base, pii ans, int exp) {
    while (exp) {
        if (exp & 1) ans = ans * base;
        exp >>= 1, base = base * base;
    }
    return ans;
}

int fpow(int base, int exp = mod-2, int ans = 1) {
    while (exp) {
        if (exp & 1) ans = ans * base % mod;
        exp >>= 1, base = base * base % mod;
    }
    return ans;
}

void solve() {

    cin >> n >> k;
    vector<int> a(n+1), prod(n+1), inv(n+1);
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
        if (i) {
            prod[i] = prod[i-1] * a[i] % mod;
            inv[i] = fpow(prod[i]);
        }
        else {
            prod[i] = a[i];
            inv[i] = fpow(prod[i]);
        }
    }
    // debug(a);
    // debug(prod);
    
    pii base = pii(2 / n, 2 % n);
    pii ans = pii(1 / n, 1 % n);
    pii K = piifpow(base, ans, k);
    for (int i = 0; i < n; ++i) {
        int R = (i + fpow(2, k) - 1 + n) % n;
        int b = fpow(prod[n-1], K.X);
        
        if (i > 0 && R == i-1) {
            cout << b << " \n"[i==n-1];
            continue;
        }
        if (i == 0 && R == n-1) {
            cout << b << " \n"[i==n-1];
            continue;
        }
        
        if (i <= R) {
            b = b * prod[R] % mod;
            if (i) b = b * inv[i-1] % mod;
        }
        else {
            b = b * prod[R] % mod;
            b = b * prod[n-1] % mod;
            b = b * inv[i-1] % mod;
        }
        
        // debug(K.X, K.Y, R, b);
        cout << b;
        cout << " \n"[i==n-1];
    }
}

signed main() {
    IOS();
    int t = 1; // cin >> t;
    for (int i = 1; i <= t; ++i) solve();
    return 0;
}

#else

#ifdef local
#define _GLIBCXX_DEBUG 1
#endif
#pragma GCC optimize("Ofast", "unroll-loops")
#include <bits/stdc++.h>
using namespace std;

#define int int64_t
using pii = pair<int, int>;
template <typename T> using MaxHeap = std::priority_queue<T>;
template <typename T> using MinHeap = std::priority_queue<T, vector<T>, greater<T>>;

#define SZ(a) ((int)(a).size())
#define ALL(a) begin(a), end(a)
#define RALL(a) rbegin(a), rend(a)
#define ee emplace
#define eb emplace_back
#define ef emplace_front
#define pb pop_back
#define pf pop_front
#define X first
#define Y second

template <typename T>
ostream & operator << (ostream &os, const vector<T> &vec) {
    os << "[";
    for (int i = 0; i < SZ(vec); ++i) {
        if (i) os << ", ";
        os << vec[i];
    }
    os << "]";
    return os;
}

#ifdef local
#define IOS() void()
#define debug(...) \
    fprintf(stderr, "%sAt [%s], line %d: (%s) = ", "\u001b[33m", __FUNCTION__, __LINE__, #__VA_ARGS__), \
    _do(__VA_ARGS__), fprintf(stderr, "%s", "\u001b[0m")
template <typename T> void _do(T &&_t) {cerr << _t << "\n";}
template <typename T, typename ...U> void _do(T &&_t, U &&..._u) {cerr << _t << ", ", _do(_u...);}
#else
#define IOS() ios_base::sync_with_stdio(0); cin.tie(0)
#define debug(...) void()
#define endl '\n'
#endif

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

template <typename T, typename U> bool chmin(T &lhs, U rhs) {return lhs > rhs ? lhs = rhs, 1 : 0;}
template <typename T, typename U> bool chmax(T &lhs, U rhs) {return lhs < rhs ? lhs = rhs, 1 : 0;}

#endif