import sys, math
sys.setrecursionlimit(10**8)
sys.set_int_max_str_digits(0)
INF = 1e18
MOD = 998244353
from bisect import bisect_left, bisect_right
from collections import deque, defaultdict, Counter
from itertools import product, combinations, permutations, groupby, accumulate
from heapq import heapify, heappop, heappush
def I():   return sys.stdin.readline().rstrip()
def II():  return int(sys.stdin.readline().rstrip())
def IS():  return sys.stdin.readline().rstrip().split()
def MII(): return map(int, sys.stdin.readline().rstrip().split())
def LI():  return list(sys.stdin.readline().rstrip())
def TII(): return tuple(map(int, sys.stdin.readline().rstrip().split()))
def LII(): return list(map(int, sys.stdin.readline().rstrip().split()))
def LSI(): return list(map(str, sys.stdin.readline().rstrip().split()))
def GMI(): return list(map(lambda x: int(x) - 1, sys.stdin.readline().rstrip().split()))
def kiriage(a, b): return (a+b-1)//b
def chmax(DP,i,v):
    if DP[i] < v: DP[i] = v
def chmin(DP,i,v):
    if DP[i] > v: DP[i] = v

N = II()
def check(i, j):
    return 0 <= i < N and 0 <= j < N

C = [LI() for _ in range(N)]

que = deque()
DP = defaultdict(int)

for i in range(N):
    j = N - 1 - i
    num = i*N + j
    DP[(num, num)] = 1

for _ in range(N - 1):
    # 枠を作る
    nDP = defaultdict(int)

    for k, v in DP.items():
        lnum, rnum = k

        li, lj = divmod(lnum, N)
        ri, rj = divmod(rnum, N)
        
        for ii, jj in [(0, -1),(-1, 0)]:
            lni, lnj = li+ii, lj+jj
            lnexnum = lni*N + lnj
            if not check(lni, lnj):
                continue

            # この lni, lnj に対して
            for ii, jj in [(0, 1),(1, 0)]:
                rni, rnj = ri+ii, rj+jj
                rnexnum = rni*N + rnj
                if not check(rni, rnj):
                    continue

                # (lni, lnj) * (rni, rnj) のペア
                if C[lni][lnj] == C[rni][rnj]:
                    nDP[(lnexnum, rnexnum)] += v
                    nDP[(lnexnum, rnexnum)] %= MOD
    # DP にコピー
    DP = nDP#.copy()

ans = DP[(0, N*N - 1)]
print(ans)