from itertools import permutations

N = int(input())
A = [list(map(int, input().split())) for _ in range(N)]

class fenwick_tree():
    n=1
    data=[0 for i in range(n)]
    def __init__(self,N):
        self.n=N
        self.data=[0 for i in range(N)]
    def add(self,p,x):
        assert 0<=p<self.n,"0<=p<n,p={0},n={1}".format(p,self.n)
        p+=1
        while(p<=self.n):
            self.data[p-1]+=x
            p+=p& -p
    def sum(self,l,r):
        assert (0<=l and l<=r and r<=self.n),"0<=l<=r<=n,l={0},r={1},n={2}".format(l,r,self.n)
        return self.sum0(r)-self.sum0(l)
    def sum0(self,r):
        s=0
        while(r>0):
            s+=self.data[r-1]
            r-=r&-r
        return s

def serialize(X):
    serialized = []
    for row in X:
        serialized.extend(row)

    return serialized


def calc_parity(X):
    for i in range(N):
        for j in range(N):
            if X[i][j] == 0:
                return (i + j) % 2


def calc_inversion(array):
    MAX = max(array)
    bit = fenwick_tree(MAX + 1)
    
    result = 0
    for a in array:
        result += bit.sum(0, MAX + 1) - bit.sum(0, a + 1)
        bit.add(a, 1)
    
    return result


def is_valid(X):
    parity = calc_parity(X)
    
    serialized = serialize(X)
    inversion = calc_inversion(serialized)
    
    return parity == inversion % 2


def fun(X):
    result = 0
    for i in range(N):
        for j in range(N):
            result += A[i][j] * X[i][j]
    
    return result


val = dict()

perm = list(range(N**2))

for perm in permutations(range(N**2)):
    X = [[perm[i * N + j] for j in range(N)] for i in range(N)]
    
    if not is_valid(X):
        continue
    
    f = fun(X)
    
    if f in val and X != val[f]:
        print("Yes")
        for row in val[f]:
            print(*row)
        
        for row in X:
            print(*row)
        
        exit()
    
    val[f] = X

print("No")