#include <bits/stdc++.h>
// #include "../Kody/simple-console-debug/debug.h"

#define ll long long
#define str string
#define pii pair<int, int>
#define pll pair<ll, ll>
#define fi first
#define se second

#define vc vector<char>
#define vvc vector<vc>
#define vi vector<int>
#define vvi vector<vi>
#define vvvi vector<vvi>
#define vvvvi vector<vvvi>
#define vll vector<ll>
#define vvll vector<vll>
#define vvvll vector<vvll>
#define vvvvll vector<vvvll>
#define vs vector<str>
#define vvs vector<vs>
#define vpii vector<pii>
#define vvpii vector<vpii>
#define vpll vector<pll>
#define vvpll vector<vpll>
#define vb vector<bool>
#define vvb vector<vb>
#define rep(i, a, b) for (int i = (a); i < int(b); i++)
#define repi(i, a, b) for (int i = (a); i <= int(b); i++)

using namespace std;
ll INF = LONG_LONG_MAX / 2;
int inf = INT_MAX / 2;
int mod = 167772161;

template <typename T, typename L>
void read(vector<T> & _data, L _size, L _shift) {
    _data.resize(_size + _shift);
    for (ll i = _shift; i < _size + _shift; i++)
        cin >> _data[i];
}

template <typename T, typename L>
void read(vector<vector<T>> & _data, L _rows, L _cols, L _shiftRows, L _shiftCols) {
    _data.resize(_rows + _shiftRows);
    for (ll i = 0; i < _rows + _shiftRows; i++)
        _data[i].resize(_cols + _shiftCols);
    for (ll i = _shiftRows; i < _rows + _shiftRows; i++)
        for (ll j = _shiftCols; j < _cols + _shiftCols; j++)
            cin >> _data[i][j];
}

template <typename T>
void write(vector<T> & _data, ll _shift) {
    for (ll i = _shift; i < _data.size(); i++)
        cout << _data[i] << " ";
    cout << endl;
}

#define vcd vector<complex<double>>

vcd fft(vcd W, double mul) {
    ll n = W.size();

    if (n == 1)
        return W;

    vcd P(n / 2), Q(n / 2);
    for (int i = 0; i < n; i ++) {
        if (i&1)
            Q[i/2] = W[i];
        else
            P[i/2] = W[i];
    }

    vcd tp = fft(P, mul);
    vcd tq = fft(Q, mul);

    vcd tw(n);

    auto wn = polar(1.0, mul * 2.0 * M_PI / (double) n);
    auto w = polar(1.0, 0.0);

    for (int i = 0; i < n; i++) {
        tw[i] = tp[i % (n / 2)] + w * tq[i % (n / 2)];
        w *= wn;
    }

    return tw;
}


//TODO: SOLUTION
int N, K;
vi w;
vvvi p, l;
int N2;


void initialize_equal(vvvi & x) {
    x = vvvi(N + 2, vvi(N + 2, vi(K + 2, 0)));
    repi(i, 0, N + 1) {
        repi(k, 0, K + 1) {
            x[i][0][k] = 0; // empty set
        }
        x[i][0][0] = 1;
    }
}

void initialize_greater_equal(vvvi & x) {
    x = vvvi(N + 2, vvi(N + 2, vi(K + 2, 0)));
    repi(i, 0, N + 1) {
        repi(k, 0, K + 1) {
            x[i][0][k] = 1; // empty set
        }
    }
}



typedef complex<double> cpx;
vector<cpx> fft(const vector<cpx> &V, cpx omega){
    // deb::Indent ind;
    // cerr << ind.head << "FFT (" << deb::Container(V) << " , " << omega << ")" << endl;
    int n = V.size();
    if(n==1)
        return V;
    
    vector<cpx>P(n/2),Q(n/2);
    for(int i=0;i<n/2;i++){
        P[i] = V[2*i];
        Q[i] = V[2*i+1];
    }
    vector<cpx>PP = fft(P, omega*omega);
    vector<cpx>QQ = fft(Q, omega*omega);

    vector<cpx>R(n);
    cpx omega_acc = 1;
    for(int i=0;i<n/2;i++){
        R[i] = PP[i] + omega_acc*QQ[i];
        R[i+n/2] = PP[i] - omega_acc*QQ[i];
        omega_acc *= omega;
    }
    // cerr << ind << deb::Container(R) << endl;

    return R;
} 
vector<cpx> ifft(const vector<cpx> &V, cpx omega){
    vector<cpx> R = fft(V, conj(omega));
    for(cpx &x : R)
        x /= V.size();
    return R;
}
vector<cpx> poly_mult(const vector<cpx> &A, const vector<cpx> &B){
    //copy
    vector<cpx>AA = A;
    vector<cpx>BB = B;

    //align
    int siz=1;
    while(siz<(int)AA.size()+(int)BB.size()-1)
        siz *= 2;
    AA.resize(siz, 0);
    BB.resize(siz, 0);

    // cerr << deb::Container(AA) << "   " << deb::Container(BB) << endl;

    //transorm
    cpx omega = exp(cpx(0, 2*M_PI/siz));
    // cerr << omega << endl;
    vector<cpx> AAA = fft(AA, omega);
    vector<cpx> BBB = fft(BB, omega);

    // cerr << deb::Container(AAA) << endl;

    //mult
    vector<cpx> CCC(siz);
    for(int i=0;i<siz;i++)
        CCC[i] = AAA[i]*BBB[i];

    //transform
    return ifft(CCC, omega);
}



void do_magic(vector<vector<int>>&Results){
    for(int i=1;i<=N;i++){
        vector<int>Jsums(N+1);

        for(int k=0;k<=K;k++){
            // cerr << "i=" << i << " k=" << k << endl;
            vector<cpx>W1,W2;
            for(int m=0;m<=N;m++){
                W1.push_back(p[i-1][m][k]);
                W2.push_back(l[i+1][m][K-k]);
            }

            auto prod = poly_mult(W1, W2);
            for(cpx &x : prod)
                x = round(fmod(x.real(), mod));
            
            // cerr << "W1=" << deb::Container(W1) << endl;
            // cerr << "W1=" << deb::Container(W2) << endl;
            // cerr << "W1=" << deb::Container(prod) << endl;

            for(int j=1;j<N;j++)
                Jsums[j] += prod[j].real();
        }

        for(int j=1;j<N;j++)
            Results[i][j] = (Results[i][j] + Jsums[j])%mod;
    }
}

void do_magic2(vector<vector<int>>&Results){
    for(int i=1;i<=N;i++){
        int KK = K-w[i];
        vector<int>Jsums(N+1);

        for(int k=0;k<=KK;k++){
            // cerr << "i=" << i << " k=" << k << " KK=" << KK << endl;
            vector<cpx>W1,W2;
            for(int m=0;m<=N;m++){
                W1.push_back(p[i-1][m][k]);
                W2.push_back(l[i+1][m][KK-k]);
            }

            auto prod = poly_mult(W1, W2);
            for(cpx &x : prod)
                x = round(fmod(x.real(), mod));

            // cerr << "W1=" << deb::Container(W1) << endl;
            // cerr << "W1=" << deb::Container(W2) << endl;
            // cerr << "W1=" << deb::Container(prod) << endl;

            for(int j=1;j<N;j++)
                Jsums[j] += prod[j].real();
        }

        for(int j=1;j<N;j++)
            Results[i][j] = (Results[i][j] - Jsums[j])%mod;
    }
}



void solve() {
    cin >> N >> K;
    read(w, N, 1);
    w.push_back(0);

    initialize_equal(p);
    initialize_greater_equal(l);

    repi(i, 1, N) {
        repi(j, 1, N) {
            repi(k, 0, K) {
                p[i][j][k] = p[i - 1][j][k];
                if (w[i] <= k) {
                    p[i][j][k] = (p[i][j][k] + p[i - 1][j - 1][k - w[i]]) % mod;
                }
            }
        }
    }

    for (int i = N; i > 0; i--) {
        repi(j, 1, N) {
            repi(k, 0, K) {
                l[i][j][k] = l[i + 1][j][k];
                if (w[i] <= k) {
                    l[i][j][k] = (l[i][j][k] + l[i + 1][j - 1][k - w[i]]) % mod;
                }
            }
        }
    }

    vector<vector<int>>Results(N+1, vector<int>(N+1));
    do_magic(Results);
    do_magic2(Results);

    for(int i=1;i<=N;i++){
        for(int j=1;j<N;j++){
            int val = Results[i][j];
            if(val<0)
                val += mod;
            cout << val << " ";
        }
        cout << "\n";
    }
}


int main() {

    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    // TODO: Set value of this variable manually
    bool _multipleTestCases = false;

    if (_multipleTestCases) {
        ll t; cin >> t;
        while (t--)
            solve();
    }
    else {
        solve();
    }

    return 0;
}