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

#pragma GCC optimize("O3")
#pragma GCC target("sse4")
#pragma GCC target("avx2")

#define deb(x) cout << #x << " = " << x << "\n"
#define all(x) (x).begin(), (x).end()
#define len(x) (int) x.size()
#define lsb(x) (x) & -(x)
#define l(x) (x << 1) + 1
#define r(x) (x << 1) + 2
#define v(x) (int)(x - 'a')

#define xx first
#define yy second
#define mp make_pair
#define pb push_back
#define lb lower_bound
#define ub upper_bound

using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef long double ld;
typedef pair <int, int> pii;
typedef pair <ld, ld> pld;
typedef pair <ll, ll> pll;

template <class T1, class T2 = less <T1>> using pb_heap = __gnu_pbds::priority_queue <T1, T2, binary_heap_tag>;
template <class T1, class T2 = null_type, class T3 = less <T1>> using pb_map = tree <T1, T2, T3, rb_tree_tag, tree_order_statistics_node_update>;
template <class T1, class T2 = null_type, class T3 = hash <T1>> using pb_umap = gp_hash_table <T1, T2, T3>;
template <class T1, class T2, class T3 = hash <T1>> using umap = unordered_map <T1, T2, T3>;
template <class T> using uset = unordered_set <T>;
template <class T> using vec = vector <T>;

const ll infll = numeric_limits <ll>::max() >> 1;
const int inf = numeric_limits <int>::max() >> 1;
const int mod = 5 * (1 << 25) + 1;
const int MOD = 5 * (1 << 25) + 1;
const int G = 3;
const int MAX = 1 << 25;
const int N = 404;
const int M = 802;
int n, k, w[N];
ll ans[N][N];

int pre[N][N][N];
int suf[N][N][N];

int fpow(int b, int p = mod - 2) {

    int res = 1;
    int pow = b;
    for (; p; p >>= 1) {
        if (p & 1) {
            res = 1ll * res * pow % mod;
        }
        pow = 1ll * pow * pow % mod;
    }
    return res;
}

void input() {
    cin >> n >> k;
    for (int i = 1; i <= n; ++i) {
        cin >> w[i];
    }
}

// [idx][db][súly]
void calc_pre() {
    pre[0][0][0] = 1;
    for (int i = 1; i <= n; ++i) {
        for (int j = 0; j <= n; ++j) {
            for (int l = 0; l <= k; ++l) {
                pre[i][j][l] += pre[i - 1][j][l];
                if (l - w[i] >= 0 && j - 1 >= 0) {
                    pre[i][j][l] += pre[i - 1][j - 1][l - w[i]];
                }
                pre[i][j][l] %= mod;
            }
        }
    }
}

void calc_suf() {
    suf[n + 1][0][0] = 1;
    for (int i = n; i >= 1; --i) {
        for (int j = 0; j <= n; ++j) {
            for (int l = 0; l <= k; ++l) {
                suf[i][j][l] += suf[i + 1][j][l];
                if (l - w[i] >= 0 && j + 1 <= n) {
                    suf[i][j][l] += suf[i + 1][j - 1][l - w[i]];
                }
                suf[i][j][l] %= mod;
            }
        }
    }
}

int mul(int x, int y) {
  return 1ll*x * y % MOD;
}
int modpow(int base, int exp) {
  base %= MOD;
  int result = 1;
  while (exp > 0) {
	if (exp & 1) result = (1ll*result * base) % MOD;
	base = (1ll*base * base) % MOD;
	exp >>= 1;
  }
  return result;
}
int modinv(int a) {
    return modpow(a,MOD-2);
}

void fft(vector<int>& a, int FFT, int N) {
    static int rev[MAX];
    for (int i = 0; i < N; i++) {
		rev[i] = (rev[i>>1]>>1)|((i&1)?(N>>1):0);
        if (i < rev[i]) swap(a[i], a[rev[i]]);
    }
    for (int m = 2, m2 = 1; m <= N; m <<= 1, m2 <<= 1) {
        int wm = modpow(G, (MOD-1)/m*FFT+(FFT==-1?MOD-1:0));
        for (int k = 0; k < N; k += m)
            for (int j = 0, u, t, w = 1; j < m2; j++)
                t = 1ll*w*a[k+j+m2]%MOD, u = a[k+j], w = 1ll*w*wm%MOD,
                a[k+j] = (u+t)%MOD, a[k+j+m2] = (u-t+MOD)%MOD;
    }
    if (FFT == -1)
        for (int i = 0, invN = modinv(N); i < N; i++)
            a[i] = 1ll * a[i] * invN % MOD;
}

vector<int> multiply(vector<int> a, vector<int> b) {
  int need = a.size() + b.size() - 1, nbase = 0;
  while (1 << nbase < need) {
    ++nbase;
  }
  int sz = 1 << nbase;
  a.resize(sz);
  b.resize(sz);
  bool equal = (a == b);
  fft(a, 1, sz);
  if (equal) {
    b = a;
  } else {
    fft(b, 1, sz);
  }
  for (int i = 0; i < sz; ++i) {
    a[i] = mul(a[i], b[i]);
  }
  fft(a, -1, sz);
  a.resize(need);
  return a;
}

//[idx][db][súly]

void solve() {
    calc_pre();
    calc_suf();
    for (int cur = 1; cur <= n; ++cur) {
		for(int db2=0;db2<=n-cur;++db2) {
			for(int suly2=0;suly2<=k;++suly2) {
				suf[cur+1][db2][suly2]=(suf[cur+1][db2][suly2]+(suly2?suf[cur+1][db2][suly2-1]:0))%mod;
			}
		}
		
        for(int db1=0;db1<cur;++db1) {
			for(int db2=0;db2<=n-cur;++db2) {
				for(int suly1=0;suly1<=k;++suly1) {
					int L=max(0,k+1-suly1-w[cur]), R=k-suly1;
					ans[cur][db1+db2]+=(ll)pre[cur-1][db1][suly1]*(suf[cur+1][db2][R]-(L?suf[cur+1][db2][L-1]:0))%mod;
				}
				ans[cur][db1+db2]%=mod;
			}
		}
    }
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j < n; ++j) {
            cout << (ans[i][j]+mod)%mod << " ";
        }
        cout << "\n";
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    input();
    solve();
}