Monocarp is playing a game "Assimilation IV". In this game he manages a great empire: builds cities and conquers new lands.

Monocarp's empire has n cities. In order to conquer new lands he plans to build one Monument in each city. The game is turn-based and, since Monocarp is still amateur, he builds exactly one Monument per turn.

Monocarp has m points on the map he'd like to control using the constructed Monuments. For each point he knows the distance between it and each city. Monuments work in the following way: when built in some city, a Monument controls all points at distance at most 1 to this city. Next turn, the Monument controls all points at distance at most 2, the turn after — at distance at most 3, and so on. Monocarp will build n Monuments in n turns and his empire will conquer all points that are controlled by at least one Monument.

Monocarp can't figure out any strategy, so during each turn he will choose a city for a Monument randomly among all remaining cities (cities without Monuments). Monocarp wants to know how many points (among m of them) he will conquer at the end of turn number n. Help him to calculate the expected number of conquered points!

Input

The first line contains two integers n and m (1 ≤ n ≤ 20; 1 ≤ m ≤ 5 ⋅ 10^4) — the number of cities and the number of points.

Next n lines contains m integers each: the j-th integer of the i-th line d_{i, j} (1 ≤ d_{i, j} ≤ n + 1) is the distance between the i-th city and the j-th point.

Output

It can be shown that the expected number of points Monocarp conquers at the end of the n-th turn can be represented as an irreducible fraction x/y. Print this fraction modulo 998 244 353, i. e. value x ⋅ y^{-1} mod 998244353 where y^{-1} is such number that y ⋅ y^{-1} mod 998244353 = 1.

Example

Input


3 5
1 4 4 3 4
1 4 1 4 2
1 4 4 4 3


Output


166374062

Note

Let's look at all possible orders of cities Monuments will be build in: 

  * [1, 2, 3]: 
    * the first city controls all points at distance at most 3, in other words, points 1 and 4; 
    * the second city controls all points at distance at most 2, or points 1, 3 and 5; 
    * the third city controls all points at distance at most 1, or point 1. 
In total, 4 points are controlled. 
  * [1, 3, 2]: the first city controls points 1 and 4; the second city — points 1 and 3; the third city — point 1. In total, 3 points. 
  * [2, 1, 3]: the first city controls point 1; the second city — points 1, 3 and 5; the third city — point 1. In total, 3 points. 
  * [2, 3, 1]: the first city controls point 1; the second city — points 1, 3 and 5; the third city — point 1. In total, 3 points. 
  * [3, 1, 2]: the first city controls point 1; the second city — points 1 and 3; the third city — points 1 and 5. In total, 3 points. 
  * [3, 2, 1]: the first city controls point 1; the second city — points 1, 3 and 5; the third city — points 1 and 5. In total, 3 points. 

The expected number of controlled points is (4 + 3 + 3 + 3 + 3 + 3)/(6) = 19/6 or 19 ⋅ 6^{-1} ≡ 19 ⋅ 166374059 ≡ 166374062 \pmod{998244353}
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <set>
#include <string>
#include <map>
#include <list>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <utility>
using namespace std;

typedef unsigned int uint;
typedef long long int64;
typedef unsigned long long uint64;
typedef pair<int, int> ii;
typedef pair<int64, int64> ii64;
typedef vector<int> vint;
typedef vector<int64> vint64;
typedef vector<uint64> vuint64;
typedef vector<vint> vvint;
typedef vector<vint64> vvint64;
typedef vector<vuint64> vvuint64;
typedef vector<ii> vii;
typedef vector<vector<ii>> vvii;

#define mp make_pair
#define pb push_back
#define ALL(a) a.begin(), a.end()
#define fi first
#define se second
#define fori(n) for(int i = 0; i < n; ++i)
#define forj(n) for(int j = 0; j < n; ++j)
#define fork(n) for(int k = 0; k < n; ++k)
#define INF9 (int64)(1e9)
#define INF18 (int64)(1e18)

template<typename T>
struct compF{
	bool operator()(const pair<T, T> &a, const pair<T, T> &b){
		return a.first < b.first;
	}
};

template<typename T>
struct compS{
	bool operator()(const pair<T, T> &a, const pair<T, T> &b){
		return a.second < b.second;
	}
};

template<typename T>
void printMatrix(const string &txt, vector<vector<T>> &a){
	cout << txt;
	fori(a.size()){
		forj(a[i].size())
			cout << a[i][j] << ' ';

		cout << endl;
	}
}

template<typename T>
void printVector(const string &txt, vector<T> &a){
	cout << txt;
	for (int i = 0; i < a.size(); ++i)
		cout << a[i] << ' ';
	cout << endl;
}

template<typename T>
void readVector(int n, vector<T> &a){
	if (a.size() < n)
		a.resize(n);

	fori(n) cin >> a[i];
}

template<typename T>
T lb(const set<T> &a, T x){
	auto it = a.lower_bound(x);
	if (it == a.end())
		return -1;
	return *it;
}

template<typename T>
T ub(const set<T> &a, T x){
	auto it = a.upper_bound(x);
	if (it == a.end())
		return -1;
	return *it;
}

template<typename T>
T rlb(const set<T> &a, T x){
	auto it = a.lower_bound(x);

	if (it == a.begin()){
		if (*it > x)
			return -1;
		return *it;
	}

	it = prev(it);
	return *it;
}

template<typename T>
T rub(const set<T> &a, T x){
	auto it = a.lower_bound(x);

	if (it == a.begin()){
		return -1;
	}

	it = prev(it);
	return *it;
}

template<typename T1, typename T2>
bool exist(map<T1, T2> &m, T1 x){
	if (m.find(x) == m.end())
		return false;

	return true;
}

int64 gcd(int64 a, int64 b){
	while (a != 0 && b != 0){
		if (b > a)
			b %= a;
		else
			a %= b;
	}

	return a + b;
}

int64 minFactor(int64 x){
	for (int64 i = 2; i * i <= x; ++i)
		if (x % i == 0)
			return i;

	return x;
}

int64 allFactors(int64 x, vint64 &prms, vint64 &prm_cnt){
	prms.clear();
	prm_cnt.clear();
	while (x > 1){
		int64 t = minFactor(x);
		prms.push_back(t);
		int s = prms.size() - 1;
		prm_cnt.push_back(0);
		while (x % t == 0){
			x /= t;
			++prm_cnt[s];
		}
	}

	return 0;
}

#define MOD 998244353

int64 add(int64 a, int64 b){
	if (a > MOD) a %= MOD;
	if (b > MOD) b %= MOD;

	return (a + b) % MOD;
}

int64 sub(int64 a, int64 b){
	if (a > MOD) a %= MOD;
	if (b > MOD) b %= MOD;

	int64 x = a - b;
	while (x < 0)
		x += MOD;

	return x;
}

int64 mul(int64 a, int64 b){
	if (a > MOD) a %= MOD;
	if (b > MOD) b %= MOD;

	return (a * b) % MOD;
}

int64 pow_(int64 a, int64 b){
	if (b == 0)
		return 1ll;
	if (b % 2 == 0){
		int64 k = pow_(a, b / 2);
		return mul(k, k);
	}
	else{
		int64 k = pow_(a, b - 1);
		return mul(a, k);
	}
}

int n, m;

#define N 20
#define M 50000

int d[M][N];
int64 fact[N + 1], rfact[N + 1];

int64 comb(int n, int k){
	int64 num = fact[n];
	int64 denum = mul(rfact[k], rfact[n - k]);

	return mul(num, denum);
}

int main(){

	ios_base::sync_with_stdio(0);
	cin.tie();

	fact[0] = fact[1] = rfact[0] = rfact[1] = 1;
	for (int i = 2; i <= N; ++i){
		fact[i] = mul(i, fact[i - 1]);
		rfact[i] = pow_(fact[i], MOD - 2);
	}

	cin >> n >> m;
	fori(n){
		forj(m){
			cin >> d[j][i];
		}
	}

	fori(m) sort(d[i], d[i] + n);

	int64 res = 0;

	fori(m){
		bool poss = true;
		int64 ttl = fact[n];
		int64 sum = 1;
		int taken = 0;

		forj(n){
			int x = d[i][j];
			if (x - 1 - taken <= 0){
				poss = false;
				sum = 0;
				break;
			}
			
			sum = mul(sum, x - 1 - taken);
			++taken;
		}

		//if (!poss) continue;
		res = add(res, sub(ttl, sum));
	}

	res = mul(res, rfact[n]);
	cout << res << endl;

	return 0;
}
