import sys
from collections import deque

sys.stdin = open("input.txt", "r")

dirs = ([-1,0], [0,-1],[1,0],[0,1])


if __name__=="__main__":

    N = int(input())

    board = [[0]*N for _ in range(N)]

    K = int(input())

    for _ in range(K):
        r, c = map(int, input().split())
        board[r-1][c-1] =1

    L = int(input())

    comm =[]
    for _ in range(L):
        a, b = map(str, input().split())
        print("a,b",a,b)
        comm.append([int(a),b ])

    print(comm)

    # snake = [0,0]
    # sDir = 3

    q = deque([[0,0]])
    sDir = 3
    board[0][0]=2

    # print(q)

    cnt=0
    flag =0
    ptr =0
    c = comm[ptr]
    while True:
        while True:
            cnt+=1

            snake = q[len(q)-1]
            # print(snake)
            nPos = [snake[0]+dirs[sDir][0], snake[1]+dirs[sDir][1]]

            if 0<=nPos[0]<N and 0<=nPos[1]<N and board[nPos[0]][nPos[1]]!=2:
                if board[nPos[0]][nPos[1]]==0:
                    tail = q.popleft()
                    board[tail[0]][tail[1]]=0
                q.append([nPos[0],nPos[1]])
                board[nPos[0]][nPos[1]]=2

                # if board[nPos[0]][nPos[1]]==1:
                #     q.append([nPos[0],nPos[1]])
                #     board[nPos[0]][nPos[1]]=2
                # elif board[nPos[0]][nPos[1]]==0:
                #     q.append([nPos[0],nPos[1]])
                #     board[nPos[0]][nPos[1]]=2
                #     tail = q.popleft()
                #     board[tail[0]][tail[1]]=0
            else:
                flag=1
                break
            if cnt == c[0]:
                if c[1]=='D':
                    sDir = (sDir+3)%4
                elif c[1]=='L':
                    sDir = (sDir+5)%4
                if ptr<len(comm)-1:
                    ptr+=1
                    c = comm[ptr]
                break
        if flag==1:
            break

    print(cnt)


____________________________________________________________________________________________________________________________________________

            
import sys

sys.stdin = open("input.txt", "r")

dirs = ([-1,0], [0,-1],[1,0],[0,1])

def plus_fish():
    global N

    num = min(board[N-1])

    for i in range(N):
        if board[N-1][i] == num:
            board[N-1][i]+=1
    


def aqua_top():
    global N
    l,h,cnt, start_l =1,1,1,0

    while True:
        if not (start_l+l+h-1<N):
            break

        tmp = [[0]*l for _ in range(h)]

        for i in range(h):
            for j in range(l):
                tmp[i][j] = board[N-h+i][start_l+j]
                board[N-h+i][start_l+j]=0

        tmp = [list(x) for x in zip(*tmp[::-1])]

        start_l+=l

        for i in range(l):
            for j in range(h):
                board[N-1-l+i][start_l+j] = tmp[i][j]

        if cnt%2==0:
            l+=1
        elif cnt%2==1:
            h+=1

        cnt+=1


def spread_aqua():
    global N

    tmp = [[0]*N for _ in range(N)]

    for j in range(N):
        for i in range(N-1, -1, -1):
            if board[i][j]:
                for d in dirs:
                    nPos = [i+d[0], j+d[1]]
                    if 0<=nPos[0]<N and 0<=nPos[1]<N and board[nPos[0]][nPos[1]]:
                        if board[i][j]>board[nPos[0]][nPos[1]]:
                            tmp[i][j] -= (board[i][j]-board[nPos[0]][nPos[1]])//5
                        else:
                            tmp[i][j] += (board[nPos[0]][nPos[1]]-board[i][j])//5
            else:
                break
    for j in range(N):
        for i in range(N-1, -1, -1):
            if board[i][j]:
                board[i][j]+=tmp[i][j]
            else:
                break


def quad_aqua():
    global N

    num = N//4

    for n in range(num):
        board[N-2][num*3+n]=board[N-1][num*1-1-n]
        board[N-1][num*1-1-n]=0

        board[N-3][num*3+n]=board[N-1][num*1+n]
        board[N-1][num*1+n] =0
        
        board[N-4][num*3+n]= board[N-1][num*3-1-n]
        board[N-1][num*3-1-n]=0



def aqua_line():
    global N

    A=[]

    for j in range(N):
        for i in range(N-1,-1,-1):
            if board[i][j]:
                A.append(board[i][j])
                board[i][j]=0
            else:
                break

    board[N-1]=A


def check_num():
    global N
    A = sorted(board[N-1])

    return A[N-1]-A[0]


if __name__=="__main__":
    
    T = int(input())

    for tc in range(1,T+1):
        ans =0
        N, K = map(int, input().split())

        A= list(map(int, input().split()))
        board = [[0]*N for _ in range(N-1)]
        board+=[A]

        # print(*board, sep='\n')
        while True:
            plus_fish()
            # print()
            # print(*board, sep='\n')
            aqua_top()
            # print()
            # print(*board, sep='\n')
            spread_aqua()
            # print()
            # print(*board, sep='\n')
            aqua_line()

            quad_aqua()
            # print("quad")
            # print(*board, sep='\n')

            spread_aqua()
            aqua_line()
            ans+=1
            if check_num()<=K:
                break
        # print()
        # print(*board, sep='\n')

        print(f'#{tc} {ans}')


___________________________________________________________________________________________________________________
import sys

sys.stdin=open("input.txt", "r")


dirs = ([-1,0],[0,-1],[1,0],[0,1])

def deepcopy(arr):
    return [[cols for cols in rows] for rows in arr]

def dfs(dep, cBoard):
    global ans, N
    if dep==5:
        for r in range(N):
            ans = max(ans, max(cBoard[r]))
        return 
    # print("test", dep)
    for d in range(4):
        mBoard = [[0]*N for _ in range(N)]
        visited = [[0]*N for _ in range(N)]
        
        if d ==0:
            for j in range(N):
                for i in range(N):
                    if cBoard[i][j]:
                        row = i
                        tmp = cBoard[i][j]
                        # cBoard[i][j]=0

                        while 0<=row+dirs[d][0]<N and mBoard[row+dirs[d][0]][j]==0:
                            row+=dirs[d][0]

                        if 0<=row+dirs[d][0]<N and mBoard[row+dirs[d][0]][j]==tmp and visited[row+dirs[d][0]][j]==0:
                            mBoard[row+dirs[d][0]][j]+=tmp
                            visited[row+dirs[d][0]][j]=1
                        else:
                            mBoard[row][j]=tmp
            dfs(dep+1, deepcopy(mBoard))

        elif d==1:
            for i in range(N):
                for j in range(N):
                    if cBoard[i][j]:
                        col = j
                        tmp = cBoard[i][j]
                        # cBoard[i][j]=0

                        while 0<=col+dirs[d][1]<N and mBoard[i][col+dirs[d][1]]==0:
                            col+=dirs[d][1]

                        if 0<=col+dirs[d][1]<N and mBoard[i][col+dirs[d][1]]==tmp and visited[i][col+dirs[d][1]]==0:
                            mBoard[i][col+dirs[d][1]]+=tmp
                            visited[i][col+dirs[d][1]]=1
                        else:
                            mBoard[i][col]=tmp
            dfs(dep+1, deepcopy(mBoard))
        elif d==2:
            for j in range(N):
                for i in range(N-1,-1,-1):
                    if cBoard[i][j]:
                        row = i
                        tmp = cBoard[i][j]
                        # cBoard[i][j]=0

                        while 0<=row+dirs[d][0]<N and mBoard[row+dirs[d][0]][j]==0:
                            row+=dirs[d][0]

                        if 0<=row+dirs[d][0]<N and mBoard[row+dirs[d][0]][j]==tmp and visited[row+dirs[d][0]][j]==0:
                            mBoard[row+dirs[d][0]][j]+=tmp
                            visited[row+dirs[d][0]][j]=1
                        else:
                            mBoard[row][j]=tmp
            dfs(dep+1, deepcopy(mBoard))
        elif d==3:
            for i in range(N):
                for j in range(N-1,-1,-1):
                    if cBoard[i][j]:
                        col = j
                        tmp = cBoard[i][j]
                        # cBoard[i][j]=0

                        while 0<=col+dirs[d][1]<N and mBoard[i][col+dirs[d][1]]==0:
                            col+=dirs[d][1]

                        if 0<=col+dirs[d][1]<N and mBoard[i][col+dirs[d][1]]==tmp and visited[i][col+dirs[d][1]]==0:
                            mBoard[i][col+dirs[d][1]]+=tmp
                            visited[i][col+dirs[d][1]]=1
                        else:
                            mBoard[i][col]=tmp
            dfs(dep+1, deepcopy(mBoard))



if __name__=="__main__":

    N = int(input())

    board= [list(map(int, input().split())) for _ in range(N)]
    ans=0
    dfs(0, deepcopy(board))

    print(ans)