## https://yukicoder.me/problems/no/3285

# 数論変換パートは
# https://qiita.com/AngrySadEight/items/0dfde26060daaf6a2fda
# と
# https://qiita.com/izu_nori/items/1c5cdef0500ffa0276f5
# を参考にしました

MOD = 998244353

def main():
    N, M = map(int, input().split())
    A = []
    for _ in range(N):
        A.append(list(map(int, input().split())))


    # 取りうる値のチェック
    a_map = {}
    for i in range(N):
        a = A[i][0]
        if a not in a_map:
            a_map[a] = []
        a_map[a].append(i)
    
    answer = 0
    for a, index_list in a_map.items():
        if M <= 15:
            # 各種計算
            enables = [[False] * (2 ** M) for _ in range(len(index_list))]
            for index, i in enumerate(index_list):
                for bit in range(2 ** M):
                    steped = False
                    is_ok = True
                    for j in range(M):
                        if bit & (1 << j) > 0:
                            if not steped:
                                if j < M - 1 and A[i][j + 1] == a:
                                    continue
                                else:
                                    steped = True
                            else:
                                is_ok = False
                                break
                    if is_ok:
                        enables[index][bit] = True
            
            # dp
            dp = [0] * (2 ** M)
            for bit in range(2 ** M):
                if enables[0][bit]:
                    dp[bit] = 1
            for index in range(1, len(index_list)):
                en = enables[index]
                new_dp = [0] * (2 ** M)
                for base_bit in range(2 ** M):
                    bit = base_bit
                    while bit > 0:
                        b = base_bit - bit
                        if en[b]:
                            new_dp[base_bit] += dp[bit]
                            new_dp[base_bit] %= MOD
                        
                        bit = (bit - 1) & base_bit
                    if en[base_bit]:
                        new_dp[base_bit] += dp[0]
                        new_dp[base_bit] %= MOD
                dp = new_dp
            ans = dp[2 ** M - 1]
            answer += ans
            answer %= MOD
        else:
            dp = {0: 1}
            for m in range(M - 1):
                new_dp = {}
                for key_bit, value in dp.items():
                    for j in range(len(index_list)):
                        if key_bit & (1 << j) == 0:
                            if A[index_list[j]][m + 1] == a:
                                new_key_bit = key_bit
                            else:
                                new_key_bit = key_bit | (1 << j)
                            
                            if new_key_bit not in new_dp:
                                new_dp[new_key_bit] = 0
                            new_dp[new_key_bit] += value
                            new_dp[new_key_bit] %= MOD
                dp = new_dp
            
            ans = 0
            for key_bit, value in dp.items():
                for j in range(len(index_list)):
                    if key_bit & (1 << j) == 0:
                        ans += value
                        ans %= MOD
            answer += ans
            answer %= MOD
    print(answer)




















if __name__ == "__main__":
    main()