#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

#define ll long long
#define lll __int128
#define ull unsigned long long
#define fi first
#define se second
#define db double
#define ld long double
#define lld __float128

/// order_of_key, find_by_order

template<class T, class COMP>
using custom_set = tree<T, null_type, COMP, rb_tree_tag, tree_order_statistics_node_update>;

template<class T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

template<class T>
using ordered_multiset = tree<T, null_type, less_equal<T>, rb_tree_tag, tree_order_statistics_node_update>;

template<class T, class U>
using ordered_map = tree<T, U, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rnd_64(chrono::steady_clock::now().time_since_epoch().count());

const ll MOD = 167772161;

ll dp1[405][405][405], dp2[405][405][405], ans[405], sum[405];

const int max_lev = 20, mod = 167772161;

template<int mod, int max_lev>
struct NTT {
    static const int max_n = 1 << max_lev;

    int roots[2][max_lev];
    int rev[max_n], buf1[max_n], buf2[max_n], bufpw[max_n];

    NTT() {
        int root = find_root();
        int rroot = power(root, mod - 2);
        roots[0][0] = root;
        roots[1][0] = rroot;
        for (int i = 1; i < max_lev; ++i) {
            roots[0][i] = mul(roots[0][i - 1], roots[0][i - 1]);
            roots[1][i] = mul(roots[1][i - 1], roots[1][i - 1]);
        }
        for (int i = 1; i < max_n; ++i) {
            rev[i] = (rev[i / 2] / 2) + ((i & 1) << (max_lev - 1));
        }
    }

    static inline void inc(int &x, int y) {
        x += y;
        if (x >= mod) {
            x -= mod;
        }
    }

    static inline int mul(int x, int y) {
        return (1LL * x * y) % mod;
    }

    static int power(int x, int y) {
        if (y == 0) {
            return 1;
        }
        if (y % 2 == 0) {
            return power(mul(x, x), y / 2);
        }
        return mul(x, power(x, y - 1));
    }

    static int find_root() {
        for (int root = 2; ; ++root) {
            if (power(root, max_n) == 1) {
                int cur = 1;
                bool ok = true;
                for (int i = 1; i < max_n; ++i) {
                    cur = mul(cur, root);
                    if (cur == 1) {
                        ok = false;
                        break;
                    }
                }
                if (ok) {
                    return root;
                }
            }
        }
    }

    void fft(int *a, const int *roots, int lg) {
        const int n = 1 << lg;
        for (int i = 0; i < n; ++i) {
            int r = (rev[i] >> (max_lev - lg)) & (n - 1);
            if (i < r) {
                swap(a[i], a[r]);
            }
        }
        int pos = max_lev - 1;
        for (int st = 1; st < n; st *= 2) {
            int cur = 1;
            for (int i = 0; i < st; ++i) {
                bufpw[i] = cur;
                cur = mul(cur, roots[pos]);
            }
            --pos;
            for (int i = 0; i < n; i += 2 * st) {
                int *curpw = bufpw;
                for (int j = i; j < i + st; ++j) {
                    int y = mul(*curpw++, a[j + st]);
                    a[j + st] = a[j];
                    inc(a[j + st], mod - y);
                    inc(a[j], y);
                }
            }
        }
    }

    vector<int> product(const vector<int> &a, const vector<int> &b) {
        int sz = a.size() + b.size() - 1;
        int n = 1, rn = 1, lg = 0;
        while (n < sz) {
            n *= 2;
            rn = mul(rn, (mod + 1) / 2);
            ++lg;
        }
        memcpy(buf1, a.data(), 4 * a.size());
        memset(buf1 + a.size(), 0, 4 * (n - a.size()));
        memcpy(buf2, b.data(), 4 * b.size());
        memset(buf2 + b.size(), 0, 4 * (n - b.size()));
        fft(buf1, roots[0], lg);
        fft(buf2, roots[0], lg);
        for (int i = 0; i < n; ++i) {
            buf1[i] = mul(buf1[i], buf2[i]);
        }
        fft(buf1, roots[1], lg);
        vector<int> ans(sz);
        for (int i = 0; i < sz; ++i) {
            ans[i] = mul(buf1[i], rn);
        }
        return ans;
    }
};

NTT<mod, max_lev> ntt;

int main()
{
    int n, k; cin >> n >> k;
    ll dat[n];
    for(int i = 0; i < n; i++)
        cin >> dat[i];

    dp1[0][0][0] = 1;
    for(int i = 0; i < n; i++)
    {
        for(int sm = 0; sm <= k; sm++)
        {
            for(int cn = 0; cn <= i; cn++)
            {
                dp1[i][sm][cn] %= MOD;
                dp1[i+1][sm][cn] += dp1[i][sm][cn];
                if(sm+dat[i] <= k)
                {
                    dp1[i+1][sm+dat[i]][cn+1] += dp1[i][sm][cn];
                }
            }
        }
    }

    for(int i = 0; i <= n; i++)
    {
        for(int sm = 0; sm <= k; sm++)
        {
            for(int cn = 0; cn <= i; cn++)
            {
                dp1[i][sm][cn] %= MOD;
            }
        }
    }
  //  cout << "dp1\n";

    dp2[n][0][0] = 1;
    for(int i = n; i > 0; i--)
    {
        for(int sm = 0; sm <= k; sm++)
        {
            for(int cn = 0; cn <= i; cn++)
            {
                dp2[i][sm][cn] %= MOD;
                dp2[i-1][sm][cn] += dp2[i][sm][cn];
                if(sm+dat[i-1] <= k)
                {
                    dp2[i-1][sm+dat[i-1]][cn+1] += dp2[i][sm][cn];
                }
            }
        }
    }
  //  cout << "dp2\n";
    for(int i = 0; i <= n; i++)
    {
        for(int sm = 0; sm <= k; sm++)
        {
            for(int cn = 0; cn <= i; cn++)
            {
                dp2[i][sm][cn] %= MOD;
            }
        }
    }

    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j <= n; j++)
            sum[j] = 0;
        for(int j = k-dat[i]+1; j <= k; j++)
        {
            for(int x = 0; x <= n; x++)
            {
                sum[x] += dp2[i+1][j][x];
            }
        }
//        cout << i << '\n';
        for(int s = 0; s <= k; s++)
        {
            vector<int> vca, vcb;
//            cout << s << ": ";
            for(int j = 0; j <= n; j++)
            {
                vca.push_back(dp1[i][s][j]);
                vcb.push_back(sum[j]%mod);
//                cout << sum[j] << ' ';
            }
//            cout << '\n';
            vector<int> res = ntt.product(vca, vcb);
            for(int j = 1; j <= n; j++)
            {
                ans[j-1] += res[j];
            }
            for(int x = 0; x <= n; x++)
            {
                sum[x] -= dp2[i+1][k-s][x];
                if(k-dat[i]+1-s >= 0)
                sum[x] += dp2[i+1][k-dat[i]-s][x];
            }
        }
        for(int j = 0; j < n-1; j++)
            cout << ans[j]%MOD << ' ';
        for(int j = 0; j < n; j++)
            ans[j] = 0;
        cout << '\n';
    }

}






































/// shche ne vmerla Ykraina