#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using ll   = long long;
using ull  = unsigned long long;
using ld   = long double;
using pii  = pair<int,int>;
using pll  = pair<ll,ll>;
using vi   = vector<int>;
using vb   = vector<bool>;
using vc   = vector<char>;
using vvc  = vector<vc>;
using vvi  = vector<vi>;
using vvb  = vector<vb>;
using vpii = vector<pii>;
using vpll = vector<pll>;
using vll  = vector<ll>;
using vull = vector<ull>;
using vvll = vector<vll>;
using namespace __gnu_pbds;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define f first
#define s second
#define pb emplace_back
#define rep(i, begin, end) for(auto i = (begin); i <= (end); ++i)
#define repr(i, begin, end) for(auto i = (begin); i >= (end); --i)
#define bend(X) X.begin(), X.end()
#ifdef LOCAL
#define deb(...) cout << #__VA_ARGS__ << " = " << __VA_ARGS__ << endl
#define say(...) cout << __VA_ARGS__ << endl
#else
#define deb(x)
#define say(x)
#define endl '\n'
#endif
constexpr int INF = 1e9+1e7;
constexpr ll INFl = INF;
constexpr ll INFll = 1e18+1e16;
void print() { cout << '\n'; }
template <typename T, typename... Args> void print(T x, Args... args) { cout << x << ' '; print(args...); }
template <typename T1, typename T2> ostream& operator<<(ostream& os, pair<T1,T2> x) { os << x.f << ' ' << x.s; return os; }
template <typename T1, typename T2> istream& operator>>(istream& is, pair<T1,T2>& x) { is >> x.f >> x.s; return is; }
template <typename Ch, typename Tr, typename T> ostream& operator<<(basic_ostream<Ch,Tr>& os, T x) { for(auto i : x) os << i << ' '; return os; }
template <typename T> istream& operator>>(istream& is, vector<T>& x) { for(T& i : x) is >> i; return is; }
template <typename T1, typename T2> pair<T1,T2> operator+(const pair<T1,T2>& A, const pair<T1,T2>& B) { return {A.f+B.f, A.s+B.s}; }
template <typename T1, typename T2> pair<T1,T2> operator-(const pair<T1,T2>& A, const pair<T1,T2>& B) { return {A.f-B.f, A.s-B.s}; }
template <typename T1, typename T2> pair<T1,T2>& operator+=(pair<T1,T2>& A, const pair<T1,T2>& B) { A.f += B.f; A.s += B.s; return A; }
template <typename T1, typename T2> pair<T1,T2>& operator-=(pair<T1,T2>& A, const pair<T1,T2>& B) { A.f -= B.f; A.s -= B.s; return A; }
template <typename T1, typename T2> pair<T1,T2> operator-(const pair<T1,T2>& A) { return {-A.f, -A.s}; }
template <typename T1, typename T2> bool maxe(T1& A, const T2& B) { if(B>A) { A=B; return 1; } return 0; }
template <typename T1, typename T2> bool mine(T1& A, const T2& B) { if(B<A) { A=B; return 1; } return 0; }
class Nic{} nic;
template <typename T> Nic operator<<(Nic, T) { return nic; }
Nic operator<<(ostream&, Nic) { return nic; }

template <typename T>
T fastpow(const T& x, const unsigned long long& p) {
    if (p == 1) return x;
    return (p&1) ? fastpow(x*x, p/2)*x : fastpow(x*x, p/2);
}
template <ll mod>
class nu {
private:
    ll v;
    // constructor called when you know v will be in [0,mod), so no modulo is performed
    nu(ll val, void* _) : v{val} {};

public:
    nu(ll val = 0) : v{val} {
        if (v >= mod || v <= -mod) v %= mod;
        if (v < 0) v += mod;
    };
    operator ll() { return v; }
    nu<mod> operator+(const nu<mod>& o) const { return nu<mod>{v+o.v >= mod ? v+o.v-mod : v+o.v, nullptr}; }
    nu<mod> operator-(const nu<mod>& o) const { return nu<mod>{v-o.v < 0 ? v-o.v+mod : v-o.v, nullptr}; }
    nu<mod> operator*(const nu<mod>& o) const { return nu<mod>{(v*o.v)%mod, nullptr}; }
    nu<mod> operator+=(const nu<mod>& o) { v += o.v; if (v >= mod) v -= mod; return *this; }
    nu<mod> operator-=(const nu<mod>& o) { v -= o.v; if (v < 0) v += mod; return *this; }
    nu<mod> operator*=(const nu<mod>& o) { v *= o.v; if (v >= mod) v %= mod; return *this; }
    // assumes mod is prime
    nu<mod> inv() const { return fastpow(*this, mod-2); }
    nu<mod> operator/(const nu<mod>& o) const { return (*this) * o.inv(); }
    nu<mod> operator/=(const nu<mod>& o) { v = ((*this)/o).v; return *this; }

    static vector<nu<mod>> all_inverses(size_t n) {
        vector<nu<mod>> inv(n+1);
        inv[1] = 1;
        for (int i = 2; i <= n; i++)
            inv[i] = nu<mod>(mod - (mod/i) * inv[mod%i] % mod, nullptr);
        return inv;
    }
    static vector<nu<mod>> all_inverses() {
        return all_inverses(mod-1);
    }
};
using num=nu<167772161>;

//////////////////////////////////////////////////

constexpr int maxN = 401;
constexpr int maxK = 401;
int n, k;
vi T;
num DP[maxN][maxK], DP1[maxN][maxK], DP2[maxN][maxK];

auto solve() {
    cin >> n >> k;
    T.resize(n+1);
    rep (i, 1, n)
        cin >> T[i];
    DP[0][0] = num{1};
    rep (i, 1, n) {
        int x = T[i];
        repr (j, n, 1)
            rep (w, x, k)
                DP[j][w] += DP[j-1][w-x];
    }
    rep (z, 1, n) {
        int x = T[z];
        rep (j, 0, n)
            rep (w, 0, k)
                DP1[j][w] = DP2[j][w] = num{0};
        DP1[0][0] = num{1};
        rep (j, 1, n)
            rep (w, 0, k) {
                DP2[j][w] = w >= x ? DP1[j-1][w-x] : num{0};
                DP1[j][w] = DP[j][w] - DP2[j][w];
            }
        rep (j, 1, n-1) {
            num res{0};
            rep (w, k-x+1, k)
                res += DP1[j][w];
            cout << ll(res) << " \n"[j==n-1];
        }
    }

    return nic;
}



int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int noOfTests = 1;
    //cin >> noOfTests;

    while(noOfTests --> 0)
        cout << solve() << '\n';

    return 0;
}