#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 fi first
#define se second
#define mp make_pair
#define pb push_back
#define fbo find_by_order
#define ook order_of_key
 
typedef long long ll;
typedef pair<int,int> ii;
typedef vector<int> vi;
typedef long double ld; 
typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update> pbds;

struct DSU
{
	int S;
	
	struct node
	{
		int p; ll sum;
	};
	vector<node> dsu;
	
	DSU(int n)
	{
		S = n;
		for(int i = 0; i < n; i++)
		{
			node tmp;
			tmp.p = i; tmp.sum = 1;
			dsu.pb(tmp);
		}
	}
	
	void reset(int n)
	{
		dsu.clear();
		S = n;
		for(int i = 0; i < n; i++)
		{
			node tmp;
			tmp.p = i; tmp.sum = 1;
			dsu.pb(tmp);
		}
	}
	
	int rt(int u)
	{
		if(dsu[u].p == u) return u;
		dsu[u].p = rt(dsu[u].p);
		return dsu[u].p;
	}
	
	void merge(int u, int v)
	{
		u = rt(u); v = rt(v);
		if(u == v) return ;
		if(rand()&1) swap(u, v);
		dsu[v].p = u;
		dsu[u].sum += dsu[v].sum;
	}
	
	bool sameset(int u, int v)
	{
		if(rt(u) == rt(v)) return true;
		return false;
	}
	
	ll getstat(int u)
	{
		return dsu[rt(u)].sum;
	}
};

vector<int> fact;
vector<int> ifact;
vector<int> inv;
vector<int> pow2;
const int MOD =998244353;
int add(int a, int b)
{
	a+=b;
	while(a>=MOD) a-=MOD;
	return a;
}
void radd(int &a, int b)
{
	a=add(a,b); 
}
int mult(int a, int b)
{
	return (a*1LL*b)%MOD;
}
void rmult(int &a, int b)
{
	a=mult(a,b);
}
int modpow(int a, int b)
{
	int r=1;
	while(b)
	{
		if(b&1) r=mult(r,a);
		a=mult(a,a);
		b>>=1;
	}
	return r;
}
int choose(int a, int b)
{
	if(a<b) return 0;
	if(b==0) return 1;
	if(a==b) return 1;
	return mult(fact[a],mult(ifact[b],ifact[a-b]));
}
int inverse(int a)
{
	return modpow(a,MOD-2);
}
void init(int _n)
{
	fact.clear(); ifact.clear(); inv.clear(); pow2.clear();
	fact.resize(_n+1);
	ifact.resize(_n+1);
	inv.resize(_n+1);
	pow2.resize(_n+1);
	pow2[0]=1;
	ifact[0]=1;
	fact[0]=1;
	for(int i=1;i<=_n;i++)
	{
		pow2[i]=add(pow2[i-1],pow2[i-1]);
		fact[i]=mult(fact[i-1],i);
		//ifact[i]=mult(ifact[i-1],inv[i]);
	}
	ifact[_n] = inverse(fact[_n]);
	for(int i=_n-1;i>=1;i--)
	{
		ifact[i] = mult(ifact[i + 1], i + 1);
	}
	for(int i=1;i<=_n;i++)
	{
		inv[i] = mult(fact[i-1],ifact[i]);
	}
}
	
int a[155][155];

int main()
{
	init(100000);
	ios_base::sync_with_stdio(0); cin.tie(0);
	int n,k; cin>>n>>k;
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<n;j++)
		{
			cin>>a[i][j];
		}
	}
	DSU R(n); DSU C(n);
	for(int i=0;i<n;i++)
	{
		for(int j=i+1;j<n;j++)
		{
			int pos=1;
			for(int z=0;z<n;z++)
			{
				if(a[i][z]+a[j][z]>k) pos=0;
			}
			//cerr<<i<<' '<<j<<' '<<pos<<'\n';
			if(pos) R.merge(i,j);
		}
	}
	for(int i=0;i<n;i++)
	{
		for(int j=i+1;j<n;j++)
		{
			int pos=1;
			for(int z=0;z<n;z++)
			{
				if(a[z][i]+a[z][j]>k) pos=0;
			}
			//cerr<<"C: "<<i<<' '<<j<<' '<<pos<<'\n';
			if(pos) C.merge(i,j);
		}
	}
	int ans=1;
	for(int i=0;i<n;i++)
	{
		if(R.rt(i)==i)
		{
			ans=mult(ans,fact[R.getstat(i)]);
		}
		if(C.rt(i)==i)
		{
			ans=mult(ans,fact[C.getstat(i)]);
		}
	}
	cout<<ans<<'\n';
}

#define taskname "test"

#include <bits/stdc++.h>

using namespace std;

#define sz(x) (int)x.size()
#define fi first
#define se second

typedef long long lli;
typedef pair<int, int> pii;

const int maxn = 2e5 + 5;

int n, k;
vector<int> gr[maxn];

int depth[maxn], p[maxn];
int max_depth = 0;

vector<int> vertices[maxn];

int need[maxn], fire[maxn];

void read_input()
{
    cin >> n >> k;
    for(int i = 1; i < n; ++i)
    {
        int u, v;
        cin >> u >> v;
        gr[u].push_back(v);
        gr[v].push_back(u);
    }
}

void dfs_modify(int u, int par)
{
    p[u] = par;
    depth[u] = depth[par] + 1;
    vertices[depth[u]].push_back(u);
    max_depth = max(max_depth, depth[u]);
    for(auto&v: gr[u])
        if(v != par)
            dfs_modify(v, u);
}

bool check(int t)
{
    fill(need + 1, need + n + 1, t);
    fill(fire + 1, fire + n + 1, -1);
    int cnt = 0;
    for(int d = max_depth; d > 1; --d)
        for(auto&u: vertices[d])
        {
            if(need[u] == 0)
            {
                ++cnt;
                if(cnt > k) return false;
                fire[u] = t;
                fire[p[u]] = max(fire[p[u]], t - 1);
            }
            else
            {
                if(fire[u] + need[u] >= t)
                    fire[p[u]] = max(fire[p[u]], fire[u] - 1);
                else
                {
                    fire[p[u]] = max(fire[p[u]], fire[u] - 1);
                    need[p[u]] = min(need[p[u]], need[u] - 1);
                }
            }
        }
    if(need[1] + fire[1] < t)
        ++cnt;
    return cnt <= k;
}

void solve()
{
    dfs_modify(1, 0);
    int low = 1, high = max_depth;
    while(low <= high)
    {
        int mid = (low + high) / 2;
        if(check(mid)) high = mid - 1;
        else low = mid + 1;
    }
    cout << low << '\n';
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    read_input();
    solve();
}

