Nastya came to her informatics lesson, and her teacher who is, by the way, a little bit famous here gave her the following task.

Two matrices $A$ and $B$ are given, each of them has size $n \times m$. Nastya can perform the following operation to matrix $A$ unlimited number of times:   take any square square submatrix of $A$ and transpose it (i.e. the element of the submatrix which was in the $i$-th row and $j$-th column of the submatrix will be in the $j$-th row and $i$-th column after transposing, and the transposed submatrix itself will keep its place in the matrix $A$). 

Nastya's task is to check whether it is possible to transform the matrix $A$ to the matrix $B$.

 $\left. \begin{array}{|c|c|c|c|c|c|c|c|} \hline 6 & {3} & {2} & {11} \\ \hline 5 & {9} & {4} & {2} \\ \hline 3 & {3} & {3} & {3} \\ \hline 4 & {8} & {2} & {2} \\ \hline 7 & {8} & {6} & {4} \\ \hline \end{array} \right.$ Example of the operation 

As it may require a lot of operations, you are asked to answer this question for Nastya.

A square submatrix of matrix $M$ is a matrix which consist of all elements which comes from one of the rows with indeces $x, x+1, \dots, x+k-1$ of matrix $M$ and comes from one of the columns with indeces $y, y+1, \dots, y+k-1$ of matrix $M$. $k$ is the size of square submatrix. In other words, square submatrix is the set of elements of source matrix which form a solid square (i.e. without holes).


-----Input-----

The first line contains two integers $n$ and $m$ separated by space ($1 \leq n, m \leq 500$) — the numbers of rows and columns in $A$ and $B$ respectively.

Each of the next $n$ lines contains $m$ integers, the $j$-th number in the $i$-th of these lines denotes the $j$-th element of the $i$-th row of the matrix $A$ ($1 \leq A_{ij} \leq 10^{9}$).

Each of the next $n$ lines contains $m$ integers, the $j$-th number in the $i$-th of these lines denotes the $j$-th element of the $i$-th row of the matrix $B$ ($1 \leq B_{ij} \leq 10^{9}$).


-----Output-----

Print "YES" (without quotes) if it is possible to transform $A$ to $B$ and "NO" (without quotes) otherwise.

You can print each letter in any case (upper or lower).


-----Examples-----
Input
2 2
1 1
6 1
1 6
1 1

Output
YES
Input
2 2
4 4
4 5
5 4
4 4

Output
NO
Input
3 3
1 2 3
4 5 6
7 8 9
1 4 7
2 5 6
3 8 9

Output
YES


-----Note-----

Consider the third example. The matrix $A$ initially looks as follows.

$$ \begin{bmatrix} 1 & 2 & 3\\ 4 & 5 & 6\\ 7 & 8 & 9 \end{bmatrix} $$

Then we choose the whole matrix as transposed submatrix and it becomes

$$ \begin{bmatrix} 1 & 4 & 7\\ 2 & 5 & 8\\ 3 & 6 & 9 \end{bmatrix} $$

Then we transpose the submatrix with corners in cells $(2, 2)$ and $(3, 3)$. 

$$ \begin{bmatrix} 1 & 4 & 7\\ 2 & \textbf{5} & \textbf{8}\\ 3 & \textbf{6} & \textbf{9} \end{bmatrix} $$

So matrix becomes

$$ \begin{bmatrix} 1 & 4 & 7\\ 2 & 5 & 6\\ 3 & 8 & 9 \end{bmatrix} $$

and it is $B$.

Difficulty: MEDIUM

Solutions:
(n, m) = map(int, input().split())
pa = [{} for _ in range(n + m - 1)]
pb = [{} for _ in range(n + m - 1)]
for i in range(n):
	tmp = list(map(int, input().split()))
	for j in range(m):
		if tmp[j] in pa[i + j]:
			pa[i + j][tmp[j]] += 1
		else:
			pa[i + j][tmp[j]] = 1
for i in range(n):
	tmp = list(map(int, input().split()))
	for j in range(m):
		if tmp[j] in pb[i + j]:
			pb[i + j][tmp[j]] += 1
		else:
			pb[i + j][tmp[j]] = 1
if pa == pb:
	print('YES')
else:
	print('NO')


import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7

def ri(flag=0):
	if flag == 0:
		return [int(i) for i in sys.stdin.readline().split()]
	else:
		return int(sys.stdin.readline())
(n, m) = ri()
mat = []
mat1 = []
for i in range(n):
	mat.append(ri())
for i in range(n):
	mat1.append(ri())
one = dd(list)
for i in range(n):
	for j in range(m):
		one[i + j].append(mat[i][j])
two = dd(list)
for i in range(n):
	for j in range(m):
		two[i + j].append(mat1[i][j])
for i in one:
	one[i].sort()
for i in two:
	two[i].sort()
f = 1
for i in one:
	if one[i] != two[i]:
		f = 0
if f:
	print('YES')
else:
	print('NO')


import sys
input = sys.stdin.readline
MOD = 1000000007
MOD2 = 998244353
ii = lambda : int(input().strip('\n'))
si = lambda : input().strip('\n')
dgl = lambda : list(map(int, input().strip('\n')))
f = lambda : map(int, input().strip('\n').split())
il = lambda : list(map(int, input().strip('\n').split()))
ls = lambda : list(input().strip('\n'))
let = 'abcdefghijklmnopqrstuvwxyz'
(n, m) = f()
m1 = [[] for i in range(n + m)]
m2 = [[] for i in range(n + m)]
for i in range(n):
	l = il()
	for j in range(m):
		m1[i + j].append(l[j])
for i in range(n):
	l = il()
	for j in range(m):
		m2[i + j].append(l[j])
for i in range(n + m):
	m1[i].sort()
	m2[i].sort()
	if m1[i] != m2[i]:
		print('NO')
		exit()
print('YES')


from collections import defaultdict
from collections import Counter
import sys
(r, c) = map(int, input().split())
m1 = []
m2 = []
for i in range(r):
	a = list(map(int, input().split()))
	m1.append(a)
for i in range(r):
	a = list(map(int, input().split()))
	m2.append(a)
d1 = defaultdict(list)
d2 = defaultdict(list)
for i in range(r):
	for j in range(c):
		d1[i + j].append(m1[i][j])
		d2[i + j].append(m2[i][j])
for (i, j) in zip(d1, d2):
	if not Counter(d1[i]) == Counter(d2[j]):
		print('NO')
		sys.exit()
print('YES')


(n, m) = [int(x) for x in input().split()]
A = []
B = []
for _ in range(n):
	A.append([int(x) for x in input().split()])
for _ in range(n):
	B.append([int(x) for x in input().split()])
AD = []
BD = []
for s in range(2, m + n + 1):
	at = []
	bt = []
	for r in range(1, n + 1):
		c = s - r
		if 1 <= c and c <= m:
			at.append(A[r - 1][c - 1])
			bt.append(B[r - 1][c - 1])
	at.sort()
	bt.sort()
	AD.append(at)
	BD.append(bt)
if AD == BD:
	print('YES')
else:
	print('NO')


(n, m) = map(int, input().strip().split())

def transpose(matrix):
	to_return = [[] for i in range(m)]
	for i in range(m):
		for j in range(n):
			to_return[i].append(matrix[j][i])
	return to_return
(A, B) = ([], [])
for i in range(n):
	A.append([int(i) for i in input().strip().split()])
for i in range(n):
	B.append([int(i) for i in input().strip().split()])
yes = True
pivot = 0
not_exceed = 0
if m < n:
	A = transpose(A)
	B = transpose(B)
	(m, n) = (n, m)
index = 0
while index < m:
	col_index = index
	row_index = 0
	numbers = dict()
	while row_index < n and col_index >= 0:
		if A[row_index][col_index] not in numbers:
			numbers[A[row_index][col_index]] = 1
		else:
			numbers[A[row_index][col_index]] += 1
		row_index += 1
		col_index -= 1
	col_index = index
	row_index = 0
	while row_index < n and col_index >= 0:
		if B[row_index][col_index] in numbers and numbers[B[row_index][col_index]] > 0:
			numbers[B[row_index][col_index]] -= 1
		else:
			yes = False
			break
		row_index += 1
		col_index -= 1
	index += 1
	if not yes:
		break
index = 1
while index < n:
	col_index = m - 1
	row_index = index
	numbers = dict()
	while row_index < n and col_index >= 0:
		if A[row_index][col_index] not in numbers:
			numbers[A[row_index][col_index]] = 1
		else:
			numbers[A[row_index][col_index]] += 1
		row_index += 1
		col_index -= 1
	col_index = m - 1
	row_index = index
	while row_index < n and col_index >= 0:
		if B[row_index][col_index] in numbers and numbers[B[row_index][col_index]] > 0:
			numbers[B[row_index][col_index]] -= 1
		else:
			yes = False
			break
		row_index += 1
		col_index -= 1
	index += 1
	if not yes:
		break
print('YES' if yes else 'NO')


import sys
input = sys.stdin.readline
(n, m) = map(int, input().split())
grid1 = [list(input().split()) for _ in range(n)]
grid2 = [list(input().split()) for _ in range(n)]
for i in range(n + m - 1):
	(s1, s2) = ([], [])
	for j in range(n):
		(x, y) = (j, i - j)
		if 0 <= x < n and 0 <= y < m:
			s1.append(grid1[x][y])
			s2.append(grid2[x][y])
	if sorted(s1) != sorted(s2):
		print('NO')
		sys.exit()
print('YES')


import sys
input = iter(sys.stdin)
(n, m) = map(int, next(input).split())

def read_matrix():
	mat = []
	for _ in range(n):
		mat.append(tuple(map(int, next(input).split())))
	return build_diags(mat)

def build_diags(mat):
	import collections
	diags = collections.defaultdict(list)
	for i in range(n):
		for j in range(m):
			diags[i + j].append(mat[i][j])
	diags = sorted(((k, sorted(v)) for (k, v) in diags.items()))
	return diags
d1 = read_matrix()
d2 = read_matrix()
print(['NO', 'YES'][d1 == d2])


(n, m) = map(int, input().split())
a = []
b = []
for i in range(n):
	a.append(list(map(int, input().split())))
for i in range(n):
	b.append(list(map(int, input().split())))
dla = [list() for _ in range(n + m)]
dlb = [list() for _ in range(n + m)]
for i in range(n):
	for j in range(m):
		dla[i + j].append(a[i][j])
		dlb[i + j].append(b[i][j])
for i in range(n + m):
	if sorted(dla[i]) != sorted(dlb[i]):
		print('NO')
		exit()
print('YES')


import sys

def rint():
	return map(int, sys.stdin.readline().split())
(n, m) = rint()
a = [[] for j in range(n)]
b = [[] for j in range(n)]
for i in range(n):
	a[i] = list(rint())
for i in range(n):
	b[i] = list(rint())
for s in range(n + m - 1):
	adict = dict()
	bdict = dict()
	for r in range(s + 1):
		if r >= n:
			break
		c = s - r
		if c < 0:
			break
		if c >= m:
			continue
		if a[r][c] in adict:
			adict[a[r][c]] += 1
		else:
			adict[a[r][c]] = 1
		if b[r][c] in bdict:
			bdict[b[r][c]] += 1
		else:
			bdict[b[r][c]] = 1
	if adict != bdict:
		print('NO')
		exit()
print('YES')


(n, m) = map(int, input().split())
a = []
for i in range(n):
	a.append(list(map(int, input().split())))
b = []
for i in range(n):
	b.append(list(map(int, input().split())))
diasA = [[] for i in range(m + n)]
diasB = [[] for i in range(m + n)]
for i in range(n):
	for j in range(m):
		diasA[i + j].append(a[i][j])
		diasB[i + j].append(b[i][j])
result = all((sorted(da) == sorted(db) for (da, db) in zip(diasA, diasB)))
if result:
	print('YES')
else:
	print('NO')


(n, m) = [int(item) for item in input().split()]
a = [[] for _ in range(n)]
b = [[] for _ in range(n)]
for i in range(n):
	a[i] = [int(item) for item in input().split()]
for i in range(n):
	b[i] = [int(item) for item in input().split()]
ok = True
for i in range(n):
	for l in range(m):
		if a[i][l] == b[i][l]:
			continue
		flag = False
		for col in range(max(0, l - n + i + 1), min(l, m)):
			if b[i][l] == a[i + l - col][col]:
				flag = True
				(a[i][l], a[i + l - col][col]) = (a[i + l - col][col], a[i][l])
		if not flag:
			ok = False
			break
	if ok == False:
		break
print('YES' if ok else 'NO')


import collections as z
k = lambda : map(int, input().split())
l = lambda : list(k())
(n, m) = k()
(p, q, d) = ([l() for _ in range(n)], [l() for _ in range(n)], [z.defaultdict(int) for i in range(n + m)])
for i in range(n):
	for j in range(m):
		d[i + j][p[i][j]] += 1
		d[i + j][q[i][j]] -= 1
print('YES' if all((all((i[j] == 0 for j in i)) for i in d)) else 'NO')


(N, M) = map(int, input().split())
A = [list(map(int, input().split())) for i in range(N)]
B = [list(map(int, input().split())) for i in range(N)]
ans = 'YES'
for i in range(N):
	t1 = sorted([A[i - j][j] for j in range(min(N, M)) if i - j >= 0])
	t2 = sorted([B[i - j][j] for j in range(min(N, M)) if i - j >= 0])
	if t1 != t2:
		ans = 'NO'
		break
for j in range(M):
	t1 = sorted([A[N - i - 1][j + i] for i in range(min(N, M)) if j + i < M])
	t2 = sorted([B[N - i - 1][j + i] for i in range(min(N, M)) if j + i < M])
	if t1 != t2:
		ans = 'NO'
		break
print(ans)


import collections
(n, m) = map(int, input().split())
A = [[0 for i in range(m)] for j in range(n)]
B = [[0 for i in range(m)] for j in range(n)]
for i in range(n):
	X = input().split()
	for j in range(m):
		A[i][j] = int(X[j])
for i in range(n):
	X = input().split()
	for j in range(m):
		B[i][j] = int(X[j])
for nn in range(m + n - 1):
	AA = collections.Counter()
	BB = collections.Counter()
	for j in range(nn + 1):
		x = nn - j
		y = j
		if x < n and y < m:
			AA[A[x][y]] += 1
			BB[B[x][y]] += 1
	for i in AA.keys():
		if AA[i] != BB[i]:
			print('NO')
			exit()
print('YES')


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
(n, m) = map(int, input().split())
a = []
b = []
for i in range(n):
	a.append(list(map(int, input().split())))
for j in range(n):
	b.append(list(map(int, input().split())))
f = 0
for i in range(m):
	t = i
	r = []
	d = 0
	r1 = []
	for j in range(t + 1):
		r.append(a[d][i - j])
		r1.append(b[d][i - j])
		d += 1
		if d == n:
			break
	r.sort()
	r1.sort()
	if r != r1:
		f = 1
		break
for i in range(1, n):
	t = m - 1
	r = []
	d = i
	r1 = []
	for j in range(t + 1):
		r.append(a[d][t - j])
		r1.append(b[d][t - j])
		d += 1
		if d == n:
			break
	r.sort()
	r1.sort()
	if r != r1:
		f = 1
		break
if f == 1:
	print('NO')
else:
	print('YES')


import sys
import math, bisect
sys.setrecursionlimit(10 ** 5)
from collections import defaultdict
from itertools import groupby, accumulate
from heapq import heapify, heappop, heappush
from collections import deque, Counter, OrderedDict

def I():
	return int(sys.stdin.readline())

def neo():
	return map(int, sys.stdin.readline().split())

def Neo():
	return list(map(int, sys.stdin.readline().split()))
(n, m) = neo()
f = 0
(A, B) = ([Neo() for i in range(n)], [Neo() for i in range(n)])
(A1, B1) = ([[] for i in range(n + m)], [[] for i in range(n + m)])
for i in range(n):
	for j in range(m):
		A1[i + j].append(A[i][j])
		B1[i + j].append(B[i][j])
for (i, j) in zip(A1, B1):
	if sorted(i) != sorted(j):
		f = 1
		break
if f == 1:
	print('NO')
else:
	print('YES')


inp = lambda : map(int, input().split())

def ans():
	global n, m
	a = [[] for _ in [0] * (n + m)]
	for i in range(n):
		for j in inp():
			a[i].append(j)
			i += 1
	return [*map(sorted, a)]
(n, m) = inp()
if ans() != ans():
	print('NO')
else:
	print('YES')


def problem_1136c():
	gi = lambda : list(map(int, input().strip().split()))
	(n, m) = gi()
	a_list = [gi() for _ in range(n)]
	b_list = [gi() for _ in range(n)]
	for k in range(m):
		a = sorted([a_list[j][k - j] for j in range(min(n, k + 1))])
		b = sorted([b_list[j][k - j] for j in range(min(n, k + 1))])
		if a != b:
			print('NO')
			return
	for k in range(m):
		a = sorted([a_list[-j - 1][j - 1 - k] for j in range(min(n, k + 1))])
		b = sorted([b_list[-j - 1][-k + j - 1] for j in range(min(n, k + 1))])
		if a != b:
			print('NO')
			return
	if n <= m:
		print('YES')
		return
	for k in range(n):
		a = sorted([a_list[k - j][j] for j in range(min(m, k + 1))])
		b = sorted([b_list[k - j][j] for j in range(min(m, k + 1))])
		if a != b:
			print('NO')
			return
	for k in range(n):
		a = sorted([a_list[-k - 1 + j][-j - 1] for j in range(min(m, k + 1))])
		b = sorted([b_list[-k - 1 + j][-j - 1] for j in range(min(m, k + 1))])
		if a != b:
			print('NO')
			return
	print('YES')
	return
problem_1136c()


import sys
import math
from collections import defaultdict as dd
(n, m) = [int(i) for i in input().split(' ')]
a = []
b = []
for i in range(n):
	a.append([int(i) for i in input().split(' ')])
for i in range(n):
	b.append([int(i) for i in input().split(' ')])
d1 = dd(list)
d2 = dd(list)
for i in range(n):
	for j in range(m):
		d1[i + j].append(a[i][j])
		d2[i + j].append(b[i][j])
for i in d1.keys():
	if sorted(d1[i]) != sorted(d2[i]):
		print('NO')
		sys.exit(0)
print('YES')


MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
(n, m) = I()
a = [[] for i in range(n + m - 1)]
b = [[] for i in range(n + m - 1)]
for i in range(n):
	l = I()
	for j in range(m):
		a[i + j].append(l[j])
for i in range(n):
	l = I()
	for j in range(m):
		b[i + j].append(l[j])
ans = 'YES'
for i in range(n + m - 1):
	if sorted(a[i]) != sorted(b[i]):
		ans = 'NO'
		break
print(ans)


[r, c] = list(map(int, input().split()))
mat1 = []
mat2 = []
flag = True
for i in range(r):
	mat1.append(list(map(int, input().split())))
for i in range(r):
	mat2.append(list(map(int, input().split())))

def diag(matrix):
	diagmat = []
	for line in range(1, r + c):
		start_col = max(0, line - r)
		count = min(line, c - start_col, r)
		arr = []
		for j in range(0, count):
			arr.append(matrix[min(r, line) - j - 1][start_col + j])
		diagmat.append(arr)
	return diagmat
diag1 = diag(mat1)
diag2 = diag(mat2)
for i in range(len(diag1)):
	diag1[i].sort()
	diag2[i].sort()
	if diag1[i] != diag2[i]:
		flag = False
		break
if flag:
	print('YES')
else:
	print('NO')


(n, m) = map(int, input().strip().split())
A = []
B = []
for _ in range(n):
	a = list(map(int, input().strip().split()))
	A.append(a)
for _ in range(n):
	b = list(map(int, input().strip().split()))
	B.append(b)
flag = True
for i in range(n - 1):
	if i == 0:
		if A[0][0] != B[0][0]:
			flag = False
	else:
		a = i
		b = 0
		temp = {}
		temp2 = {}
		while a >= 0 and b < m:
			try:
				temp[B[a][b]] += 1
			except:
				temp[B[a][b]] = 1
			try:
				temp2[A[a][b]] += 1
			except:
				temp2[A[a][b]] = 1
			a -= 1
			b += 1
		for k in temp2.keys():
			try:
				if temp2[k] == temp[k]:
					nothing = 1
				else:
					flag = False
					break
			except:
				flag = False
				break
for j in range(m):
	a = n - 1
	b = j
	temp = {}
	temp2 = {}
	while a >= 0 and b < m:
		try:
			temp[B[a][b]] += 1
		except:
			temp[B[a][b]] = 1
		try:
			temp2[A[a][b]] += 1
		except:
			temp2[A[a][b]] = 1
		a -= 1
		b += 1
	for k in temp2.keys():
		try:
			if temp2[k] == temp[k]:
				nothing = 1
			else:
				flag = False
				break
		except:
			flag = False
			break
if flag:
	print('YES')
else:
	print('NO')


(n, m) = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(n)]
B = [list(map(int, input().split())) for _ in range(n)]
ans = True
for dig in range(n):
	i = dig
	j = 0
	d1 = dict()
	d2 = dict()
	while i >= 0 and j < m:
		d1[A[i][j]] = d1.get(A[i][j], 0) + 1
		d2[B[i][j]] = d2.get(B[i][j], 0) + 1
		i -= 1
		j += 1
	if d1 != d2:
		ans = False
		break
for dig in range(1, m):
	i = n - 1
	j = dig
	d1 = dict()
	d2 = dict()
	while i >= 0 and j < m:
		d1[A[i][j]] = d1.get(A[i][j], 0) + 1
		d2[B[i][j]] = d2.get(B[i][j], 0) + 1
		i -= 1
		j += 1
	if d1 != d2:
		ans = False
		break
print('YES' if ans else 'NO')


R = lambda : map(int, input().split())
(n, m) = R()

def f():
	a = [[] for _ in [0] * (n + m)]
	for i in range(n):
		j = 0
		for x in R():
			a[i + j] += (x,)
			j += 1
	return a
print('YNEOS'[any((sorted(x) != sorted(y) for (x, y) in zip(f(), f())))::2])


def diagonal(a):
	global n, m
	max_col = n
	max_row = m
	fdiag = [[] for i in range(max_col + max_row - 1)]
	for y in range(max_col):
		for x in range(max_row):
			fdiag[x + y].append(a[y][x])
	return fdiag
(n, m) = map(int, input().split())
a = []
b = []
for i in range(n):
	temp = list(map(int, input().split()))
	a.append(temp)
for i in range(n):
	temp = list(map(int, input().split()))
	b.append(temp)
ans_a = diagonal(a)
ans_b = diagonal(b)
for i in range(n + m - 1):
	if sorted(ans_a[i]) != sorted(ans_b[i]):
		print('NO')
		exit()
print('YES')


(n, m) = map(int, input().split())
A = [[] for i in range(n)]
B = [[] for i in range(n)]
for i in range(n):
	a = list(map(int, input().split()))
	A[i] = a
for i in range(n):
	a = list(map(int, input().split()))
	B[i] = a
A1 = [[] for i in range(n + m - 1)]
B1 = [[] for i in range(n + m - 1)]
for k in range(n + m - 1):
	for i in range(n):
		for j in range(m):
			if i + j == k:
				A1[k].append(A[i][j])
				B1[k].append(B[i][j])
	A1[k] = sorted(A1[k])
	B1[k] = sorted(B1[k])
	for l in range(len(A1[k])):
		if A1[k][l] != B1[k][l]:
			print('NO')
			exit()
print('YES')


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from collections import *
from operator import itemgetter, attrgetter
from decimal import *
import bisect
import math
import heapq as hq
(n, m) = map(int, input().split())
a = []
b = []
for i in range(n):
	a.append(list(map(int, input().split())))
for j in range(n):
	b.append(list(map(int, input().split())))
f = 0
first = [[] for i in range(n + m)]
second = [[] for i in range(n + m)]
for i in range(n):
	for j in range(m):
		first[i + j].append(a[i][j])
		second[i + j].append(b[i][j])
for i in range(n + m):
	first[i].sort()
	second[i].sort()
	if first[i] != second[i]:
		f = 1
		print('NO')
		break
else:
	print('YES')


(n, m) = map(int, input().split())
l1 = [[] for i in range(2 * max(n, m))]
mat1 = []
f = 1
mat2 = []
l2 = [[] for i in range(2 * max(m, n))]
for i in range(n):
	mat1.append([int(i) for i in input().split()])
for i in range(n):
	mat2.append([int(i) for i in input().split()])
for i in range(n):
	for j in range(m):
		l1[i + j].append(mat1[i][j])
for i in range(n):
	for j in range(m):
		l2[i + j].append(mat2[i][j])
from collections import Counter
for i in range(len(l1)):
	if Counter(l1[i]) != Counter(l2[i]):
		f = 0
if f:
	print('YES')
else:
	print('NO')


(n, m) = list(map(int, input().split()))
a = []
for i in range(n):
	a.append(list(map(int, input().split())))
b = []
for i in range(n):
	b.append(list(map(int, input().split())))
for i in range(m + n - 1):
	d1 = {}
	d2 = {}
	for j in range(n):
		l = j
		r = i - j
		if l >= 0 and l < n and (r >= 0) and (r < m):
			e = a[l][r]
			if e not in d1:
				d1[e] = 0
			d1[e] += 1
	for j in range(n):
		l = j
		r = i - j
		if l >= 0 and l < n and (r >= 0) and (r < m):
			e = b[l][r]
			if e not in d2:
				d2[e] = 0
			d2[e] += 1
	for k in d1:
		if k not in d2:
			print('NO')
			return
		if d1[k] != d2[k]:
			print('NO')
			return
print('YES')


import sys
import math as mt
input = sys.stdin.buffer.readline
t = 1
for _ in range(t):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	b = []
	for i in range(n):
		b.append(list(map(int, input().split())))
	d1 = {}
	d2 = {}
	for i in range(n):
		for j in range(m):
			if d1.get(i + j, -1) == -1:
				d1[i + j] = []
			if d2.get(i + j, -1) == -1:
				d2[i + j] = []
			d1[i + j].append(a[i][j])
			d2[i + j].append(b[i][j])
	ans = 1
	for i in d1:
		d1[i].sort()
		d2[i].sort()
	if d1 == d2:
		print('YES')
	else:
		print('NO')


(n, m) = [int(x) for x in input().split()]
A = [[int(x) for x in input().split()] for _ in range(n)]
B = [[int(x) for x in input().split()] for _ in range(n)]

def valid(i, j):
	return i >= 0 and j >= 0 and (i < n) and (j < m)
can = True
for i in range(n):
	(i1, j1) = (i, 0)
	a = []
	b = []
	while valid(i1, j1):
		a.append(A[i1][j1])
		b.append(B[i1][j1])
		i1 -= 1
		j1 += 1
	if sorted(a) != sorted(b):
		can = False
		break
if not can:
	print('NO')
	exit(0)
for j in range(m):
	(i1, j1) = (n - 1, j)
	a = []
	b = []
	while valid(i1, j1):
		a.append(A[i1][j1])
		b.append(B[i1][j1])
		i1 -= 1
		j1 += 1
	if sorted(a) != sorted(b):
		can = False
		break
if can:
	print('YES')
else:
	print('NO')


(n, m) = [int(s) for s in input().split()]
a = []
b = []
c = []
d = []
for i in range(n):
	a.append([int(s) for s in input().split()])
for i in range(n):
	b.append([int(s) for s in input().split()])
for i in range(0, n + m - 1):
	c.append([])
	d.append([])
for i in range(n):
	for j in range(m):
		c[i + j].append(a[i][j])
		d[i + j].append(b[i][j])
for i in range(0, n + m - 1):
	c[i].sort()
	d[i].sort()
if c == d:
	print('YES')
else:
	print('NO')


(n, m) = map(int, input().split())
a = [[] for i in range(n + m)]
b = [[] for i in range(n + m)]
for i in range(n):
	j = 0
	for el in map(int, input().split()):
		a[i + j].append(el)
		j += 1
for i in range(n):
	j = 0
	for el in map(int, input().split()):
		b[i + j].append(el)
		j += 1
for i in range(n + m):
	a[i].sort()
	b[i].sort()
	if a[i] != b[i]:
		print('NO')
		exit(0)
print('YES')


gi = lambda : list(map(int, input().strip().split()))
(n, m) = gi()
A = [gi() for e in range(n)]
B = [gi() for e in range(n)]
for k in range(m):
	a = sorted([A[j][k - j] for j in range(min(n, k + 1))])
	b = sorted([B[j][k - j] for j in range(min(n, k + 1))])
	if a != b:
		print('NO')
		exit()
for k in range(m):
	a = sorted([A[-j - 1][j - 1 - k] for j in range(min(n, k + 1))])
	b = sorted([B[-j - 1][-k + j - 1] for j in range(min(n, k + 1))])
	if a != b:
		print('NO')
		exit()
if n <= m:
	print('YES')
	exit()
for k in range(n):
	a = sorted([A[k - j][j] for j in range(min(m, k + 1))])
	b = sorted([B[k - j][j] for j in range(min(m, k + 1))])
	if a != b:
		print('NO')
		exit()
for k in range(n):
	a = sorted([A[-k - 1 + j][-j - 1] for j in range(min(m, k + 1))])
	b = sorted([B[-k - 1 + j][-j - 1] for j in range(min(m, k + 1))])
	if a != b:
		print('NO')
		exit()
print('YES')


from collections import defaultdict
(n, m) = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
b = [list(map(int, input().split())) for _ in range(n)]
flag = True
for i in range(n):
	d = defaultdict(int)
	for j in range(min(i + 1, m)):
		d[a[i - j][j]] += 1
		d[b[i - j][j]] -= 1
	for k in d.values():
		if k != 0:
			flag = False
for i in range(m):
	d = defaultdict(int)
	for j in range(min(m - i, n)):
		d[a[n - j - 1][i + j]] += 1
		d[b[n - j - 1][i + j]] -= 1
	for k in d.values():
		if k != 0:
			flag = False
if flag:
	print('YES')
else:
	print('NO')


from sys import stdin
from collections import Counter
input = stdin.readline
(n, m) = [int(x) for x in input().split()]
a = [[int(x) for x in input().split()] for _ in range(n)]
b = [[int(x) for x in input().split()] for _ in range(n)]
ans = 'YES'
counter_a = Counter()
counter_b = Counter()
i = 0
r = 0
c = 0
while r < n and ans == 'YES':
	counter_a.clear()
	counter_b.clear()
	while r >= 0 and c < m:
		counter_a[a[r][c]] += 1
		counter_b[b[r][c]] += 1
		r -= 1
		c += 1
	for (k, v) in counter_a.items():
		if v != counter_b[k]:
			ans = 'NO'
			break
	i += 1
	c = 0
	r = i
i = 0
r = n - 1
c = 0
while c < m and ans == 'YES':
	counter_a.clear()
	counter_b.clear()
	while r >= 0 and c < m:
		counter_a[a[r][c]] += 1
		counter_b[b[r][c]] += 1
		r -= 1
		c += 1
	for (k, v) in counter_a.items():
		if v != counter_b[k]:
			ans = 'NO'
			break
	i += 1
	c = i
	r = n - 1
print(ans)


(n, m) = map(int, input().split())
mat1 = []
mat2 = []
for i in range(n):
	mat1.append(list(map(int, input().split())))
for i in range(n):
	mat2.append(list(map(int, input().split())))
i = 0
temp1 = []
temp2 = []
while i < m:
	k = i
	j = 0
	while k >= 0 and j < n:
		temp1.append(mat1[j][k])
		temp2.append(mat2[j][k])
		k -= 1
		j += 1
	temp1.sort()
	temp2.sort()
	if temp1 == temp2:
		temp1.clear()
		temp2.clear()
	else:
		print('NO')
		exit()
	i += 1
i = 1
while i < n:
	k = m - 1
	j = i
	while j < n and k >= 0:
		temp1.append(mat1[j][k])
		temp2.append(mat2[j][k])
		k -= 1
		j += 1
	temp1.sort()
	temp2.sort()
	if temp1 == temp2:
		temp1.clear()
		temp2.clear()
	else:
		print('NO')
		exit()
	i += 1
print('YES')


(n, m) = map(int, input().split())
M1 = [list(map(int, input().split())) for i in range(n)]
M2 = [list(map(int, input().split())) for i in range(n)]
h = [0] * n
for i in range(n):
	M1[i].extend(h)
for i in range(n):
	M2[i].extend(h)
fl = 0
for i in range(1, m + n - 1):
	s1 = dict()
	s2 = dict()
	x = i
	y = i
	while m + n > x >= 0 and n > i - x >= 0:
		if M1[i - x][x] not in s1:
			s1[M1[i - x][x]] = 0
		s1[M1[i - x][x]] += 1
		x -= 1
	while m + n > y >= 0 and n > i - y >= 0:
		if M2[i - y][y] not in s2:
			s2[M2[i - y][y]] = 0
		s2[M2[i - y][y]] += 1
		y -= 1
	if s1 != s2:
		fl = 1
if M1[0][0] != M2[0][0] or M1[-1][-1] != M2[-1][-1]:
	fl = 1
if fl:
	print('NO')
else:
	print('YES')


(n, m) = [int(x) for x in input().split()]
A = []
B = []
for i in range(n):
	a = [int(x) for x in input().split()]
	A.append(a)
for i in range(n):
	a = [int(x) for x in input().split()]
	B.append(a)
a_list = []
for i in range(n):
	a = []
	j = 0
	a.append(A[i][j])
	while 1:
		if i - 1 >= 0 and j + 1 <= m - 1:
			i -= 1
			j += 1
			a.append(A[i][j])
		else:
			break
	a_list.append(a)
i = n - 1
for j in range(1, m):
	i = n - 1
	a = []
	a.append(A[i][j])
	while 1:
		if i - 1 >= 0 and j + 1 <= m - 1:
			i -= 1
			j += 1
			a.append(A[i][j])
		else:
			break
	a_list.append(a)
b_list = []
for i in range(n):
	a = []
	j = 0
	a.append(B[i][j])
	while 1:
		if i - 1 >= 0 and j + 1 <= m - 1:
			i -= 1
			j += 1
			a.append(B[i][j])
		else:
			break
	b_list.append(a)
i = n - 1
for j in range(1, m):
	a = []
	i = n - 1
	a.append(B[i][j])
	while 1:
		if i - 1 >= 0 and j + 1 <= m - 1:
			i -= 1
			j += 1
			a.append(B[i][j])
		else:
			break
	b_list.append(a)
for i in range(len(a_list)):
	a = sorted(a_list[i])
	b = sorted(b_list[i])
	if a != b:
		print('NO')
		break
else:
	print('YES')


(n, m, *_) = list(map(int, input().split()))
b1 = []
for i in range(n):
	b1.append(input().split())
b2 = []
for i in range(n):
	b2.append(input().split())

def works(n, m, b1, b2):
	for diag in range(n + m - 1):
		l1 = []
		l2 = []
		for col in range(diag + 1):
			point = [col, diag - col]
			if 0 <= point[0] < n and 0 <= point[1] < m:
				l1.append(b1[point[0]][point[1]])
				l2.append(b2[point[0]][point[1]])
		if sorted(l1) != sorted(l2):
			return False
	return True
if works(n, m, b1, b2):
	print('YES')
else:
	print('NO')


(n, m) = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
b = [list(map(int, input().split())) for _ in range(n)]
newa = [list() for _ in range(m + n)]
newb = [list() for _ in range(m + n)]
for row in range(n):
	for col in range(m):
		newa[row + col].append(a[row][col])
		newb[row + col].append(b[row][col])
for i in newa:
	i.sort()
for i in newb:
	i.sort()
print('YES' if newb == newa else 'NO')


from collections import deque, Counter, OrderedDict
from heapq import nsmallest, nlargest, heapify, heappop, heappush, heapreplace
from math import ceil, floor, log, log2, sqrt, gcd, factorial, pow, pi
from bisect import bisect_left, bisect_right

def binNumber(n, size=4):
	return bin(n)[2:].zfill(size)

def iar():
	return list(map(int, input().split()))

def ini():
	return int(input())

def isp():
	return map(int, input().split())

def sti():
	return str(input())

def par(a):
	print(' '.join(list(map(str, a))))

def tdl(outerListSize, innerListSize, defaultValue=0):
	return [[defaultValue] * innerListSize for i in range(outerListSize)]

def sts(s):
	s = list(s)
	s.sort()
	return ''.join(s)

def bis(a, x):
	i = bisect_left(a, x)
	if i != len(a) and a[i] == x:
		return [i, True]
	else:
		return [-1, False]

class pair:

	def __init__(self, f, s):
		self.fi = f
		self.se = s

	def __lt__(self, other):
		return (self.fi, self.se) < (other.fi, other.se)
(n, m) = isp()
a = []
b = []
c1 = Counter()
c2 = Counter()
for i in range(n):
	a.append(iar())
	c1.update(a[i])
for i in range(n):
	b.append(iar())
	c2.update(b[i])
for i in range(n):
	for j in range(m):
		if c1[a[i][j]] != c2[a[i][j]]:
			print('NO')
			quit()
p1 = tdl(n + m, 1)
p2 = tdl(n + m, 1)
for i in range(n):
	for j in range(m):
		p1[i + j].append(a[i][j])
		p2[i + j].append(b[i][j])
for i in range(n + m):
	p1[i].sort()
	p2[i].sort()
for i in range(n + m):
	if p1[i] != p2[i]:
		print('NO')
		quit()
print('YES')


from collections import defaultdict
(n, m) = [int(r) for r in input().split()]
first_matrix = [[int(z) for z in input().split()] for _ in range(n)]
second_matrix = [[int(z) for z in input().split()] for _ in range(n)]
elements_1 = defaultdict(list)
elements_2 = defaultdict(list)
for i in range(n):
	for j in range(m):
		elements_1[i + j].append(first_matrix[i][j])
		elements_2[i + j].append(second_matrix[i][j])
printed = False
for i in range(n + m - 1):
	if sorted(elements_1[i]) != sorted(elements_2[i]):
		print('NO')
		printed = True
		break
if not printed:
	print('YES')


def readLine():
	a = input()
	return [int(i) for i in a.split(' ')]
nm = readLine()
(n, m) = (nm[0], nm[1])
a = [readLine() for _ in range(n)]
b = [readLine() for _ in range(n)]
ok = True
for i in range(n):
	(k, j) = (i, 0)
	(l1, l2) = ([], [])
	while k >= 0 and j < m:
		l1.append(a[k][j])
		l2.append(b[k][j])
		k = k - 1
		j = j + 1
	l1.sort()
	l2.sort()
	for (i, _) in enumerate(l1):
		if l1[i] != l2[i]:
			ok = False
for i in range(m):
	(k, j) = (n - 1, i)
	(l1, l2) = ([], [])
	while k >= 0 and j < m:
		l1.append(a[k][j])
		l2.append(b[k][j])
		k = k - 1
		j = j + 1
	l1.sort()
	l2.sort()
	for (i, _) in enumerate(l1):
		if l1[i] != l2[i]:
			ok = False
if ok:
	print('YES')
else:
	print('NO')


(n, m) = map(int, input().split())
A = []
B = []
for a in range(n):
	A.append(list(map(int, input().split())))
for _ in range(n):
	B.append(list(map(int, input().split())))
for c in range(n + m):
	rinda = 0 if c < m else c - m
	kolona = c if c < m else m - 1
	Ad = []
	Bd = []
	while kolona >= 0 and rinda < n:
		Ad.append(A[rinda][kolona])
		Bd.append(B[rinda][kolona])
		rinda += 1
		kolona -= 1
	Ad.sort()
	Bd.sort()
	if Ad != Bd:
		print('NO')
		exit(0)
print('YES')


from sys import stdin
(n, m) = map(int, stdin.readline().strip().split())
mt1 = []
for i in range(n):
	mt1.append(list(map(int, stdin.readline().strip().split())))
mt2 = []
for i in range(n):
	mt2.append(list(map(int, stdin.readline().strip().split())))
t = True
for i in range(n):
	x = i
	y = 0
	s = []
	s1 = []
	while x >= 0 and y < m:
		s.append(mt1[x][y])
		s1.append(mt2[x][y])
		x -= 1
		y += 1
	s.sort()
	s1.sort()
	if s != s1:
		t = False
for i in range(1, m):
	y = i
	x = n - 1
	s = []
	s1 = []
	while y < m and x >= 0:
		s.append(mt1[x][y])
		s1.append(mt2[x][y])
		x -= 1
		y += 1
	s.sort()
	s1.sort()
	if s != s1:
		t = False
if t:
	print('YES')
else:
	print('NO')


import sys
from math import *

def minp():
	return sys.stdin.readline().strip()

def mint():
	return int(minp())

def mints():
	return list(map(int, minp().split()))
(n, m) = mints()
z = [None, None]
for k in range(2):
	x = [[] for i in range(n + m)]
	for i in range(n):
		a = list(mints())
		for j in range(m):
			x[i + j].append(a[j])
	z[k] = x
for i in range(n + m):
	a = z[0][i]
	b = z[1][i]
	a.sort()
	b.sort()
	if a != b:
		print('NO')
		return
print('YES')


(a, b) = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(a)]
B = [list(map(int, input().split())) for _ in range(a)]
for i in range(a):
	A[i] += [0] * (b + a)
	B[i] += [0] * (b + a)
for i in range(a - 1):
	a1 = {}
	b1 = {}
	for j in range(i + 1):
		a1[A[j][i - j]] = a1.get(A[j][i - j], 0) + 1
		b1[B[j][i - j]] = b1.get(B[j][i - j], 0) + 1
	if a1 != b1:
		print('NO')
		exit(0)
for i in range(b):
	a1 = {}
	b1 = {}
	for j in range(a):
		a1[A[j][a + i - j - 1]] = a1.get(A[j][a + i - j - 1], 0) + 1
		b1[B[j][a + i - j - 1]] = b1.get(B[j][a + i - j - 1], 0) + 1
	if a1 != b1:
		print('NO')
		exit(0)
print('YES')


import bisect
import os
from collections import Counter
import bisect
from collections import defaultdict
import math
import random
import heapq as hq
from math import sqrt
import sys
from functools import reduce, cmp_to_key
from collections import deque
import threading
from itertools import combinations
from io import BytesIO, IOBase
from itertools import accumulate

def primeFactors(n):
	prime = set()
	while n % 2 == 0:
		prime.add(2)
		n = n // 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			prime.add(i)
			n = n // i
	if n > 2:
		prime.add(n)
	return list(prime)

def getFactors(n):
	factors = []
	i = 1
	while i <= math.sqrt(n):
		if n % i == 0:
			if n // i == i:
				factors.append(i)
			else:
				factors.append(i)
				factors.append(n // i)
		i = i + 1
	return factors

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	num = []
	for p in range(2, n + 1):
		if prime[p]:
			num.append(p)
	return num

def lcm(a, b):
	return a * b // math.gcd(a, b)

def sort_dict(key_value):
	return sorted(key_value.items(), key=lambda kv: (kv[1], kv[0]))

def list_input():
	return list(map(int, input().split()))

def num_input():
	return map(int, input().split())

def string_list():
	return list(input())

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def binaryToDecimal(n):
	return int(n, 2)

def solve():
	(n, m) = num_input()
	a = []
	for i in range(n):
		a.append(list_input())
	b = []
	for i in range(n):
		b.append(list_input())
	for I in range(n):
		temp_a = []
		temp_b = []
		j = 0
		i = I
		while j != m and i >= 0:
			temp_a.append(a[i][j])
			temp_b.append(b[i][j])
			j += 1
			i -= 1
		temp_b.sort()
		temp_a.sort()
		if temp_a != temp_b:
			print('NO')
			return
	for J in range(1, m):
		i = n - 1
		j = J
		temp_a = []
		temp_b = []
		while j != m and i >= 0:
			temp_a.append(a[i][j])
			temp_b.append(b[i][j])
			j += 1
			i -= 1
		temp_b.sort()
		temp_a.sort()
		if temp_a != temp_b:
			print('NO')
			return
	print('YES')
t = 1
for _ in range(t):
	solve()


def ria():
	return [int(i) for i in input().split()]
(h, w) = ria()
mt1 = []
mt2 = []
for y in range(h):
	mt1.append(ria())
for y in range(h):
	mt2.append(ria())
for x in range(w):
	st1 = []
	st2 = []
	y = 0
	while w > x >= 0 and h > y >= 0:
		st1.append(mt1[y][x])
		st2.append(mt2[y][x])
		x -= 1
		y += 1
	st1.sort()
	st2.sort()
	if st1 != st2:
		print('NO')
		exit(0)
for y in range(h):
	st1 = []
	st2 = []
	x = w - 1
	while w > x >= 0 and h > y >= 0:
		st1.append(mt1[y][x])
		st2.append(mt2[y][x])
		x -= 1
		y += 1
	st1.sort()
	st2.sort()
	if st1 != st2:
		print('NO')
		exit(0)
print('YES')


(n, m) = list(map(int, input().split()))
m1 = [list(map(int, input().split())) for i in range(n)]
m2 = [list(map(int, input().split())) for i in range(n)]
import sys
for j in range(m + n - 1):
	x1 = {}
	x2 = {}
	for i in range(j + 1):
		if j - i < n and i < m:
			x1[m1[j - i][i]] = 0
			x2[m2[j - i][i]] = 0
	for i in range(j + 1):
		if j - i < n and i < m:
			x1[m1[j - i][i]] += 1
			x2[m2[j - i][i]] += 1
	if x1 != x2:
		print('NO')
		return
print('YES')


(n, m) = map(int, input().split(' '))
ma = []
mb = []
for i in range(n):
	li = list(map(int, input().split(' ', m)[:m]))
	ma.append(li)
for i in range(n):
	li = list(map(int, input().split(' ', m)[:m]))
	mb.append(li)
lia = []
lib = []
(i, j) = (0, 0)
kl = 0
ad = 0
for l in range(n + m - 1):
	li = []
	while i >= 0 and j < m:
		li.append(ma[i][j])
		i -= 1
		j += 1
	lia.append(li)
	if kl == n - 1:
		i = n - 1
		ad += 1
		j = ad
	else:
		kl += 1
		i = kl
		j = 0
(i, j) = (0, 0)
kl = 0
ad = 0
for l in range(n + m - 1):
	li = []
	while i >= 0 and j < m:
		li.append(mb[i][j])
		i -= 1
		j += 1
	lib.append(li)
	if kl == n - 1:
		i = n - 1
		ad += 1
		j = ad
	else:
		kl += 1
		i = kl
		j = 0
fl = 0
for i in range(len(lia)):
	lia[i].sort()
	lib[i].sort()
	if lia[i] != lib[i]:
		fl = 1
		break
if fl == 0:
	print('YES')
else:
	print('NO')


(n, m) = list(map(int, input().split()))
A = []
B = []
for i in range(n):
	A.append(list(map(int, input().split())))
for i in range(n):
	B.append(list(map(int, input().split())))
dA = []
dB = []
for d in range(m):
	for i in range(d, -1, -1):
		if d - i >= n:
			break
		dA.append(A[d - i][i])
		dB.append(B[d - i][i])
	if sorted(dA) != sorted(dB):
		print('NO')
		exit()
	(dA, dB) = ([], [])
for d in range(1, n):
	for i in range(d, n):
		if i - d >= m:
			break
		dA.append(A[i][m - (i - d) - 1])
		dB.append(B[i][m - (i - d) - 1])
	if sorted(dA) != sorted(dB):
		print('NO')
		exit()
	(dA, dB) = ([], [])
print('YES')


(N, M) = list(map(int, input().split()))
A = [[int(a) for a in input().split()] for _ in range(N)]
B = [[int(a) for a in input().split()] for _ in range(N)]
AA = [[] for _ in range(N + M - 1)]
BB = [[] for _ in range(N + M - 1)]
for n in range(N):
	for m in range(M):
		AA[n + m].append(A[n][m])
		BB[n + m].append(B[n][m])
for i in range(N + M - 1):
	AA[i] = sorted(AA[i])
	BB[i] = sorted(BB[i])
	if AA[i] != BB[i]:
		print('NO')
		break
else:
	print('YES')


(n, m) = list(map(int, input().split()))
a = []
for i in range(n):
	a.append(list(map(int, input().split())))
b = []
for i in range(n):
	b.append(list(map(int, input().split())))
ok = 'YES'
for i in range(m - 1 + n - 1 + 1):
	d = dict()
	for x in range(min(i + 1, m)):
		if i - x < n:
			if a[i - x][x] in d:
				d[a[i - x][x]] += 1
			else:
				d[a[i - x][x]] = 1
	for x in range(min(i + 1, m)):
		if i - x < n:
			if b[i - x][x] in d:
				d[b[i - x][x]] -= 1
				if d[b[i - x][x]] == 0:
					d.__delitem__(b[i - x][x])
			else:
				print('NO')
				return
print('YES')


from collections import defaultdict

def rli():
	return list(map(int, input().split()))

def main():
	(n, m) = rli()
	cnt = [defaultdict(int) for i in range(n + m + 10)]
	for i in range(n):
		nums = rli()
		for j in range(m):
			cnt[i + j][nums[j]] += 1
	for i in range(n):
		nums = rli()
		for j in range(m):
			cnt[i + j][nums[j]] -= 1
	for i in range(n + m + 10):
		for v in cnt[i].values():
			if v != 0:
				print('NO')
				return
	print('YES')
main()


import heapq
import sys
from collections import defaultdict, Counter
from functools import reduce
(n, m) = list(map(int, input().split()))
A = []
B = []
for i in range(n):
	A.append(list(map(int, input().split())))
for i in range(n):
	B.append(list(map(int, input().split())))
answer = True
for r in range(n + m):
	s1 = Counter()
	s2 = Counter()
	for i in range(min(r + 1, n)):
		j = r - i
		if j < m:
			s1[A[i][j]] += 1
			s2[B[i][j]] += 1
	answer &= s1 == s2
if answer:
	print('YES')
else:
	print('NO')


(n, m) = map(int, input().split())
i = 0
k = []
while i < n:
	s = list(map(int, input().split()))
	i += 1
	k += [s]
i = 0
x = []
while i < n:
	g = []
	j = 0
	p = i
	while p > -1 and j > -1 and (p < n) and (j < m):
		g += [k[p][j]]
		j += 1
		p -= 1
	g.sort()
	x += [g]
	i += 1
i = n - 1
j = 1
while j < m:
	p = i
	q = j
	g = []
	while p >= 0 and p < n and (q >= 0) and (q < m):
		g += [k[p][q]]
		q += 1
		p -= 1
	g.sort()
	x += [g]
	j += 1
y = []
i = 0
k = []
while i < n:
	s = list(map(int, input().split()))
	i += 1
	k += [s]
i = 0
while i < n:
	g = []
	j = 0
	p = i
	while p > -1 and j > -1 and (p < n) and (j < m):
		g += [k[p][j]]
		j += 1
		p -= 1
	g.sort()
	y += [g]
	i += 1
i = n - 1
j = 1
while j < m:
	p = i
	q = j
	g = []
	while p >= 0 and p < n and (q >= 0) and (q < m):
		g += [k[p][q]]
		q += 1
		p -= 1
	g.sort()
	y += [g]
	j += 1
if x == y:
	print('YES')
else:
	print('NO')


(n, m) = map(int, input().split())
mat1 = [0] * n
mat2 = [0] * n
for i in range(n):
	mat1[i] = input().split()
for i in range(n):
	mat2[i] = input().split()
ans = 'YES'
for i in range(n + m - 1):
	if i < min(n - 1, m - 1):
		lst1 = [0] * (i + 1)
		lst2 = [0] * (i + 1)
		for (j, k) in enumerate(range(i + 1)):
			lst1[j] = mat1[min(i, n - 1) - k][i - min(i, n - 1) + k]
			lst2[j] = mat2[min(i, n - 1) - k][i - min(i, n - 1) + k]
	elif min(n - 1, m - 1) <= i <= max(n - 1, m - 1):
		lst1 = [0] * min(n, m)
		lst2 = [0] * min(n, m)
		for (j, k) in enumerate(range(min(n, m))):
			lst1[j] = mat1[min(i, n - 1) - k][i - min(i, n - 1) + k]
			lst2[j] = mat2[min(i, n - 1) - k][i - min(i, n - 1) + k]
	elif max(n - 1, m - 1) < i:
		lst1 = [0] * (min(n, m) - (i - max(n, m) + 1))
		lst2 = [0] * (min(n, m) - (i - max(n, m) + 1))
		for (j, k) in enumerate(range(min(n, m) - (i - max(n, m) + 1))):
			lst1[j] = mat1[min(i, n - 1) - k][i - min(i, n - 1) + k]
			lst2[j] = mat2[min(i, n - 1) - k][i - min(i, n - 1) + k]
	lst1.sort()
	lst2.sort()
	if lst1 != lst2:
		ans = 'NO'
		break
print(ans)


cnt = lambda s, x: s.count(x)
ii = lambda : int(input())
si = lambda : input()
f = lambda : map(int, input().split())
dgl = lambda : list(map(int, input()))
il = lambda : list(map(int, input().split()))
(n, m) = f()
(m1, m2) = ([], [])
(lm1, lm2) = ([[] for _ in range(n + m)], [[] for _ in range(n + m)])
for _ in range(n):
	m1.append(il())
for _ in range(n):
	m2.append(il())
for i in range(n):
	for j in range(m):
		lm1[i + j].append(m1[i][j])
		lm2[i + j].append(m2[i][j])
for i in range(n + m):
	if sorted(lm1[i]) != sorted(lm2[i]):
		exit(print('NO'))
print('YES')


(n, m) = map(int, input().split())
a = []
b = []
test = []
test_ = []
for i in range(n + m):
	test.append([0])
	test_.append([0])
for i in range(n):
	cache = list(map(int, input().split()))
	a.append(cache)
for i in range(n):
	cache = list(map(int, input().split()))
	b.append(cache)
for i in range(n):
	for j in range(m):
		test[i + j].append(a[i][j])
		test_[i + j].append(b[i][j])
k = 0
for i in range(n + m - 1):
	test[i].sort()
	test_[i].sort()
for i in range(n + m - 1):
	if test[i] == test_[i]:
		k += 1
if k == n + m - 1:
	print('YES')
else:
	print('NO')


import sys
ss = sys.stdin.readline
(n, m) = map(int, ss().split())
a = [[i for i in map(int, ss().split())] for i in range(n)]
b = [[i for i in map(int, ss().split())] for i in range(n)]
ans = 1
op = 1
for j in range(m):
	da = {}
	db = {}
	i = 0
	while j >= 0 and i < n:
		da[a[i][j]] = da.get(a[i][j], 0) + 1
		db[b[i][j]] = db.get(b[i][j], 0) + 1
		j -= 1
		i += 1
	if da != db:
		ans = 0
	if not ans:
		break
for i in range(1, n):
	da = {}
	db = {}
	j = m - 1
	while j >= 0 and i < n:
		da[a[i][j]] = da.get(a[i][j], 0) + 1
		db[b[i][j]] = db.get(b[i][j], 0) + 1
		j -= 1
		i += 1
	if da != db:
		ans = 0
	if not ans:
		break
if ans:
	print('YES')
else:
	print('NO')


EMPTY = 0
WHITE = 1
BLACK = 8
BOARDWIDTH = 7
BOARDHEIGHT = 6

def isWinner(board, tile):
	for x in range(BOARDWIDTH - 3):
		for y in range(3, BOARDHEIGHT):
			if board[x][y] == tile and board[x + 1][y - 1] == tile and (board[x + 2][y - 2] == tile) and (board[x + 3][y - 3] == tile):
				return True

def printDiagonal(num):
	aret = []
	bret = []
	y = d if d < M else M - 1
	x = 0 if d < M else d - M
	while x < N and y >= 0:
		aret.append(A[x][y])
		bret.append(B[x][y])
		y -= 1
		x += 1
	aret.sort()
	bret.sort()
	if aret == bret:
		return True
	else:
		return False
(N, M) = map(int, input().split())
A = []
for n in range(N):
	A.append(list(map(int, input().split())))
B = []
for n in range(N):
	B.append(list(map(int, input().split())))
for d in range(N + M):
	if not printDiagonal(d):
		print('NO')
		exit(0)
print('YES')


import sys
input = sys.stdin.readline
(n, m) = list(map(int, input().split()))
a = []
b = []
for i in range(n):
	a.append(list(map(int, input().split())))
for i in range(n):
	b.append(list(map(int, input().split())))
d = []
for i in range(m + n - 1):
	c = []
	for j in range(n):
		if 0 <= i - j < m:
			c.append(a[j][i - j])
	c.sort()
	d.append(c)
e = []
for i in range(m + n - 1):
	c = []
	for j in range(n):
		if 0 <= i - j < m:
			c.append(b[j][i - j])
	c.sort()
	e.append(c)
f = 0
for i in range(len(d)):
	if d[i] != e[i]:
		f = 1
		break
if f == 1:
	print('NO')
else:
	print('YES')


(n, m) = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(n)]
b = [list(map(int, input().split())) for _ in range(n)]
(l1, l2) = ([[] for i in range(n + m)], [[] for i in range(n + m)])
for i in range(n):
	for j in range(m):
		l1[i + j].append(a[i][j])
		l2[i + j].append(b[i][j])
for i in l1:
	i.sort()
for i in l2:
	i.sort()
print('YES' if l1 == l2 else 'NO')


from collections import defaultdict
(n, m) = (int(t) for t in input().split(' '))
m1 = [[int(t) for t in input().split(' ')] for _ in range(n)]
m2 = [[int(t) for t in input().split(' ')] for _ in range(n)]

def get_csum(mx):
	csum = [defaultdict(int) for _ in range(n + m + 1)]
	for i in range(n):
		for j in range(m):
			csum[i + j][mx[i][j]] += 1
	return csum
csum1 = get_csum(m1)
csum2 = get_csum(m2)
print('YES' if csum1 == csum2 else 'NO')


import sys
input = sys.stdin.readline
(n, m) = list(map(int, input().split()))
a = [None] * n
for i in range(n):
	a[i] = input().split()
b = [None] * n
for i in range(n):
	b[i] = input().split()
flag = True
mi = min(m, n)
ma = max(m, n)
for i in range(mi):
	da = {}
	db = {}
	ax = [a[j][i - j] for j in range(i + 1)]
	bx = [b[j][i - j] for j in range(i + 1)]
	for x in ax:
		if x in da:
			da[x] += 1
		else:
			da[x] = 1
	for x in bx:
		if x in db:
			db[x] += 1
		else:
			db[x] = 1
	if da != db:
		flag = False
		break
if flag:
	for i in range(mi, mi + ma - 1):
		da = {}
		db = {}
		if m > n:
			ax = [a[j][i - j] for j in range(max(i + 1 - ma, 0), mi)]
			bx = [b[j][i - j] for j in range(max(i + 1 - ma, 0), mi)]
		else:
			ax = [a[i - j][j] for j in range(max(i + 1 - ma, 0), mi)]
			bx = [b[i - j][j] for j in range(max(i + 1 - ma, 0), mi)]
		for x in ax:
			if x in da:
				da[x] += 1
			else:
				da[x] = 1
		for x in bx:
			if x in db:
				db[x] += 1
			else:
				db[x] = 1
		if da != db:
			flag = False
			break
if flag:
	print('YES')
else:
	print('NO')


(N, M) = map(int, input().split())
(A, B) = ([[] for _ in range(1000)], [[] for _ in range(1000)])
for i in range(N):
	L = list(map(int, input().split()))
	for j in range(M):
		A[i + j].append(L[j])
for i in range(N):
	L = list(map(int, input().split()))
	for j in range(M):
		B[i + j].append(L[j])
for i in range(N + M):
	A[i].sort()
	B[i].sort()
	if A[i] != B[i]:
		print('NO')
		exit()
print('YES')


(n, m) = map(int, input().split())
d1 = [[] for t in range(n + m)]
d2 = [[] for t in range(m + n)]
for t in range(n):
	a = list(map(int, input().split()))
	for i in range(m):
		d1[t + i].append(a[i])
for t in range(n):
	a = list(map(int, input().split()))
	for i in range(m):
		d2[t + i].append(a[i])
flag = True
for t in range(n + m - 1):
	d1[t].sort()
	d2[t].sort()
	if d1[t] != d2[t]:
		print('NO')
		flag = False
		break
if flag:
	print('YES')


(n, m) = list(map(int, input().split()))
a = [0] * n
b = [0] * n
ok = 1
for i in range(n):
	a[i] = list(map(int, input().split()))
for i in range(n):
	b[i] = list(map(int, input().split()))
for i in range(m):
	tmp1 = []
	tmp2 = []
	deph = 0
	it = i
	while deph < n and it >= 0:
		tmp1.append(a[deph][it])
		tmp2.append(b[deph][it])
		deph += 1
		it -= 1
	tmp1.sort()
	tmp2.sort()
	if tmp1 != tmp2:
		ok = 0
for i in range(1, n):
	tmp1 = []
	tmp2 = []
	deph = i
	it = m - 1
	while deph < n and it >= 0:
		tmp1.append(a[deph][it])
		tmp2.append(b[deph][it])
		deph += 1
		it -= 1
	tmp1.sort()
	tmp2.sort()
	if tmp1 != tmp2:
		ok = 0
if ok:
	print('YES')
else:
	print('NO')


[n, m] = input().split(' ')
n = int(n)
m = int(m)
matrixA = []
matrixB = []
for i in range(n):
	matrixA.append(list(map(int, input().split(' '))))
for i in range(n):
	matrixB.append(list(map(int, input().split(' '))))

def buildDiagonals(matrix):
	r = [None] * (n + m - 1)
	for i in range(m):
		for j in range(n):
			if not r[i + j]:
				r[i + j] = []
			r[i + j].append(matrix[j][i])
	for x in range(len(r)):
		r[x].sort()
	return r
diagonalsA = buildDiagonals(matrixA)
diagonalsB = buildDiagonals(matrixB)
if str(diagonalsA) == str(diagonalsB):
	print('YES')
else:
	print('NO')


(n, m) = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
b = [list(map(int, input().split())) for _ in range(n)]
s = max(m, n)
if n < s:
	for i in range(s - n):
		a.append([0] * s)
		b.append([0] * s)
if m < s:
	for i in range(s):
		a[i] += [0] * (s - m)
		b[i] += [0] * (s - m)
for i in range(s):
	al = []
	bl = []
	c = 0
	while c <= i:
		al.append(a[c][i - c])
		bl.append(b[c][i - c])
		c += 1
	if sorted(al) != sorted(bl):
		print('NO')
		break
	c = 0
	ar = []
	br = []
	while c < s - i:
		ar.append(a[s - 1 - c][i + c])
		br.append(b[s - 1 - c][i + c])
		c += 1
	if sorted(ar) != sorted(br):
		print('NO')
		break
else:
	print('YES')


(n, m) = map(int, input().split())
a_sets = {}
b_sets = {}
for i in range(n):
	ll = map(int, input().split())
	for (j, x) in enumerate(ll):
		a_sets.setdefault(i + j, []).append(x)
for i in range(n):
	ll = map(int, input().split())
	for (j, x) in enumerate(ll):
		b_sets.setdefault(i + j, []).append(x)
for k in a_sets:
	a_k_line = sorted(a_sets[k])
	b_k_line = sorted(b_sets[k])
	if a_k_line != b_k_line:
		print('NO')
		exit(0)
print('YES')


from collections import defaultdict
d1 = defaultdict(list)
d2 = defaultdict(list)
(n, m) = map(int, input().split())
for i in range(n):
	l = list(map(int, input().split()))
	for j in range(m):
		d1[i + j].append(l[j])
for i in range(n):
	l = list(map(int, input().split()))
	for j in range(m):
		d2[i + j].append(l[j])
f = 0
for i in range(1010):
	d1[i].sort()
	d2[i].sort()
	if d1[i] != d2[i]:
		f = 1
		break
if f == 1:
	print('NO')
else:
	print('YES')


from collections import defaultdict

def main():
	(n, m) = list(map(int, input().split()))
	a = [list(map(int, input().split())) for _ in range(n)]
	b = [list(map(int, input().split())) for _ in range(n)]
	dict1 = defaultdict(list)
	for i in range(n):
		for j in range(m):
			dict1[i + j].append(a[i][j])
	dict2 = defaultdict(list)
	for i in range(n):
		for j in range(m):
			dict2[i + j].append(b[i][j])
	for i in range(n + m - 1):
		if sorted(dict1[i]) != sorted(dict2[i]):
			print('NO')
			return
	print('YES')

def __starting_point():
	main()
__starting_point()


from sys import stdin
from collections import Counter
(n, m) = map(int, stdin.readline().split())
A = []
for i in range(n):
	a = list(map(int, stdin.readline().split()))
	A.append(a)
B = []
for i in range(n):
	b = list(map(int, stdin.readline().split()))
	B.append(b)
ROW = n
COL = m

def diagonalOrder(matrix):
	final = []
	for line in range(1, ROW + COL):
		ans = []
		start_col = max(0, line - ROW)
		count = min(line, COL - start_col, ROW)
		for j in range(0, count):
			ans.append(matrix[min(ROW, line) - j - 1][start_col + j])
		final.append(ans)
	return final
x = diagonalOrder(A)
y = diagonalOrder(B)
cond = True
for i in range(len(x)):
	if Counter(x[i]) == Counter(y[i]):
		pass
	else:
		cond = False
		break
if cond == True:
	print('YES')
else:
	print('NO')


(n, m) = map(int, input().split())
arr1 = []
for i in range(n):
	temp = list(map(int, input().split()))
	arr1.append(temp)
arr2 = []
for i in range(n):
	temp = list(map(int, input().split()))
	arr2.append(temp)
flag = 0
for i in range(n):
	temparr1 = []
	temparr2 = []
	indexi = i
	indexj = 0
	while indexi >= 0 and indexj < m:
		temparr1.append(arr1[indexi][indexj])
		temparr2.append(arr2[indexi][indexj])
		indexi -= 1
		indexj += 1
	temparr1.sort()
	temparr2.sort()
	for j in range(len(temparr1)):
		if temparr1[j] != temparr2[j]:
			flag = 1
			break
if flag == 1:
	print('NO')
else:
	for i in range(1, m):
		temparr1 = []
		temparr2 = []
		indexi = n - 1
		indexj = i
		while indexi >= 0 and indexj < m:
			temparr1.append(arr1[indexi][indexj])
			temparr2.append(arr2[indexi][indexj])
			indexi -= 1
			indexj += 1
		temparr1.sort()
		temparr2.sort()
		for j in range(len(temparr1)):
			if temparr1[j] != temparr2[j]:
				flag = 1
				break
	if flag == 0:
		print('YES')
	else:
		print('NO')


import sys
import collections
from math import floor, ceil, log2
inp = lambda : sys.stdin.readline().strip()
(n, m) = map(int, inp().split())
a = [[0] * m for i in range(n)]
b = [[0] * m for i in range(n)]
for i in range(n):
	s = list(map(int, inp().split()))
	for j in range(m):
		a[i][j] = s[j]
for i in range(n):
	s = list(map(int, inp().split()))
	for j in range(m):
		b[i][j] = s[j]
(x, y) = (0, 0)
for k in range(n + m - 1):
	(i, j) = (x, y)
	(t1, t2) = ([], [])
	while i + j == k:
		if i < 0 or j >= m:
			break
		t1.append(a[i][j])
		t2.append(b[i][j])
		i -= 1
		j += 1
	t1.sort()
	t2.sort()
	ok = False
	for i in range(len(t1)):
		if t1[i] != t2[i]:
			ok = True
			print('NO')
			sys.exit(0)
	if x < n - 1:
		x += 1
	else:
		y += 1
print('YES')


tokens = input().split()
rows = int(tokens[0])
columns = int(tokens[1])
A = []
B = []
for i in range(rows):
	tokens = input().split()
	tokens = [int(w) for w in tokens]
	A.append(tokens)
for i in range(rows):
	tokens = input().split()
	tokens = [int(w) for w in tokens]
	B.append(tokens)
status = True
for count in range(rows):
	i = count
	j = 0
	a = []
	b = []
	while i >= 0 and j < columns:
		a.append(A[i][j])
		b.append(B[i][j])
		i -= 1
		j += 1
	a.sort()
	b.sort()
	for i in range(len(a)):
		if a[i] != b[i]:
			status = False
			break
for count in range(columns):
	i = rows - 1
	j = count
	a = []
	b = []
	while i >= 0 and j < columns:
		a.append(A[i][j])
		b.append(B[i][j])
		i -= 1
		j += 1
	a.sort()
	b.sort()
	for i in range(len(a)):
		if a[i] != b[i]:
			status = False
			break
if status:
	print('YES')
else:
	print('NO')


(n, m) = map(int, input().split())
a = []
b = []
for i in range(n):
	a1 = [int(x) for x in input().split()]
	a.append(a1)
for i in range(n):
	a1 = [int(x) for x in input().split()]
	b.append(a1)
ad = [[] for x in range(n * m)]
bd = [[] for x in range(n * m)]
for i in range(n):
	for j in range(m):
		ad[i + j].append(a[i][j])
for i in range(n):
	for j in range(m):
		bd[i + j].append(b[i][j])
for i in range(len(ad)):
	x = sorted(ad[i])
	y = sorted(bd[i])
	if x != y:
		print('NO')
		exit()
print('YES')


import sys
input = sys.stdin.readline
I = lambda : list(map(int, input().split()))
(n, m) = I()
a = [I() for i in range(n)]
b = [I() for i in range(n)]
x = [[] for i in range(n + m - 1)]
y = [[] for i in range(n + m - 1)]
for i in range(n):
	for j in range(m):
		x[i + j].append(a[i][j])
		y[i + j].append(b[i][j])
for i in range(n + m - 1):
	if sorted(x[i]) != sorted(y[i]):
		print('NO')
		sys.exit()
print('YES')


from collections import Counter
(n, m) = (int(x) for x in input().split())
M1 = [[int(x) for x in input().split()] for _ in range(n)]
M2 = [[int(x) for x in input().split()] for _ in range(n)]
m1_diag___nums = [[] for x in range(n + m - 1)]
m2_diag___nums = [[] for x in range(n + m - 1)]
for r in range(n):
	for c in range(m):
		m1_diag___nums[r + c].append(M1[r][c])
		m2_diag___nums[r + c].append(M2[r][c])
for diag in range(n + m - 1):
	if Counter(m1_diag___nums[diag]) != Counter(m2_diag___nums[diag]):
		print('NO')
		quit()
print('YES')


(n, m) = map(int, input().split())

def mtr(r):
	for _ in range(r):
		temp = map(int, input().split())
		yield list(temp)

def diag(x, t):
	temp = [[] for _ in range(1, m + n)]
	for (i, j) in list(zip(*[[i for i in range(t)], [i for i in range(t)]])):
		for k in x[j]:
			temp[i].append(k)
			i += 1
	for i in range(0, m + n - 1):
		temp[i].sort()
	return temp
a = diag(list(mtr(n)), n)
b = diag(list(mtr(n)), n)
print('YES' if a == b else 'NO')


(n, m) = map(int, input().split())
a = [[] for i in range(n)]
b = [[] for i in range(n)]
va = [[] for i in range(n + m)]
vb = [[] for i in range(n + m)]
for i in range(n):
	a[i] = list(map(int, input().split()))
	for j in range(m):
		va[i + j].append(a[i][j])
for i in range(n):
	b[i] = list(map(int, input().split()))
	for j in range(m):
		vb[i + j].append(b[i][j])
for i in range(n + m - 1):
	va[i].sort()
	vb[i].sort()
	for j in range(len(va[i])):
		if va[i][j] != vb[i][j]:
			print('NO')
			exit()
print('YES')


(n, m) = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(n)]
B = [list(map(int, input().split())) for i in range(n)]
C = [sorted([A[j][i - j] for j in range(i + 1) if 0 <= j < n and i - j < m]) for i in range(n + m - 1)]
D = [sorted([B[j][i - j] for j in range(i + 1) if 0 <= j < n and i - j < m]) for i in range(n + m - 1)]
if C == D:
	print('YES')
else:
	print('NO')


(n, m) = map(int, input().split())
from collections import defaultdict
diag_a = defaultdict(list)
diag_b = defaultdict(list)
for x in range(n):
	for (i, val) in enumerate(list(map(int, input().split()))):
		diag_a[x + i].append(val)
for x in range(n):
	for (i, val) in enumerate(list(map(int, input().split()))):
		diag_b[x + i].append(val)
diag_a = {k: sorted(v) for (k, v) in diag_a.items()}
diag_b = {k: sorted(v) for (k, v) in diag_b.items()}
for k in diag_a.keys():
	if diag_a[k] != diag_b[k]:
		print('NO')
		return
print('YES')


(n, m) = map(int, input().split())
a = []
b = []
c = []
d = []
for i in range(n):
	c = list(map(int, input().split()))
	a.append(c)
for i in range(n):
	d = list(map(int, input().split()))
	b.append(d)
ans = 0
if ans == 0:
	for i in range(m):
		c = []
		d = []
		j = i
		k = 0
		while k < n and j >= 0:
			c.append(a[k][j])
			d.append(b[k][j])
			k += 1
			j -= 1
		c.sort()
		d.sort()
		if c == d:
			continue
		else:
			ans = 1
			break
if ans == 0:
	for i in range(1, n):
		c = []
		d = []
		j = i
		k = m - 1
		while j <= n - 1 and k >= 0:
			c.append(a[j][k])
			d.append(b[j][k])
			k -= 1
			j += 1
		c.sort()
		d.sort()
		if c == d:
			continue
		else:
			ans = 1
			break
if ans == 0:
	print('YES')
else:
	print('NO')


import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
from collections import defaultdict
(n, m) = map(int, input().split())
grid = [list(map(int, input().split())) for i in range(n)]
target = [list(map(int, input().split())) for i in range(n)]
d1 = defaultdict(list)
d2 = defaultdict(list)
ok = True
for i in range(n):
	for j in range(m):
		d1[i + j].append(grid[i][j])
		d2[i + j].append(target[i][j])
for i in range(n + m - 1):
	if sorted(d1[i]) != sorted(d2[i]):
		ok = False
print('YES' if ok else 'NO')


(n, m) = map(int, input().split())
(a, b) = ([], [])
for i in range(n):
	a.append(list(map(int, input().split())))
for i in range(n):
	b.append(list(map(int, input().split())))
p = [[] for _ in range(n + m)]
q = [[] for _ in range(n + m)]
for i in range(n):
	for j in range(m):
		p[i + j].append(a[i][j])
		q[i + j].append(b[i][j])
print('YES' if all((sorted(x) == sorted(y) for (x, y) in zip(p, q))) else 'NO')


(n, m) = map(int, input().split())
lst = []
lst2 = []
for c in range(n):
	lst.append(list(map(int, input().split())))
for c in range(n):
	lst2.append(list(map(int, input().split())))
for c in range(n):
	for r in range(len(lst[c])):
		p = 0
		if lst[c][r] != lst2[c][r]:
			a = c
			b = r
			while a != n and b != -1:
				if lst2[a][b] == lst[c][r]:
					p = 1
					break
				a += 1
				b -= 1
			if p == 1:
				if True:
					(lst2[a][b], lst2[c][r]) = (lst2[c][r], lst2[a][b])
			else:
				print('NO')
				exit(0)
print('YES')


import itertools
import bisect
import math
from collections import *
import os
import sys
from io import BytesIO, IOBase
ii = lambda : int(input())
lmii = lambda : list(map(int, input().split()))
li = lambda : list(input())
mii = lambda : map(int, input().split())
msi = lambda : map(str, input().split())

def main():
	(n, m) = mii()
	mat1 = []
	mat2 = []
	for i in range(n):
		mat1.append(lmii())
	for i in range(n):
		mat2.append(lmii())
	d = defaultdict(list)
	dd = defaultdict(list)
	for i in range(n):
		for j in range(m):
			d[i + j].append(mat1[i][j])
	for i in range(n):
		for j in range(m):
			dd[i + j].append(mat2[i][j])
	lst = []
	lst1 = []
	for i in d:
		lst.append(sorted(d[i]))
	for i in dd:
		lst1.append(sorted(dd[i]))
	if lst == lst1:
		print('YES')
	else:
		print('NO')
	pass
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


(n, m) = map(int, input().split())
a = []
b = []
for i in range(n):
	c = list(map(int, input().split()))
	a.append(c)
for i in range(n):
	c = list(map(int, input().split()))
	b.append(c)
for i in range(n):
	for j in range(m):
		if a[i][j] == b[i][j]:
			continue
		else:
			k = i + 1
			l = j - 1
			flag = 0
			while k < n and 0 <= l:
				if a[k][l] == b[i][j]:
					flag = 1
					(a[i][j], a[k][l]) = (a[k][l], a[i][j])
					break
				l -= 1
				k += 1
			if flag == 0:
				print('NO')
				exit()
print('YES')


import sys

def equal(arr, arr_1):
	for i in range(len(arr)):
		if arr[i] != arr_1[i]:
			return False
	return True
(n, m) = [int(s) for s in input().split()]
array = []
array_2 = []
for i in range(n):
	array.append([int(s) for s in input().split()])
for i in range(n):
	array_2.append([int(s) for s in input().split()])
diags = []
diags_2 = []
for i in range(n):
	tmp = []
	tmp_2 = []
	j = 0
	while i - j > -1 and j < m:
		tmp.append(array[i - j][j])
		tmp_2.append(array_2[i - j][j])
		j += 1
	diags.append(tmp)
	diags_2.append(tmp_2)
for i in range(1, m):
	tmp = []
	tmp_2 = []
	j = 0
	while i + j < m and n - j - 1 > -1:
		tmp.append(array[n - j - 1][i + j])
		tmp_2.append(array_2[n - j - 1][i + j])
		j += 1
	diags.append(tmp)
	diags_2.append(tmp_2)
for i in range(len(diags)):
	diags[i] = sorted(diags[i])
	diags_2[i] = sorted(diags_2[i])
for i in range(len(diags)):
	if not equal(diags[i], diags_2[i]):
		print('NO')
		sys.exit(0)
print('YES')


(n, m) = [int(k) for k in input().split()]
a = [[int(k) for k in input().split()] for _ in range(n)]
b = [[int(k) for k in input().split()] for _ in range(n)]
x = [[] for _ in range(n + m - 1)]
y = [[] for _ in range(n + m - 1)]
for i in range(n):
	for j in range(m):
		x[i + j].append(a[i][j])
		y[i + j].append(b[i][j])
bl = []
for i in range(n + m - 1):
	bl.append(sorted(x[i]) == sorted(y[i]))
if all(bl):
	print('YES')
else:
	print('NO')


(n, m) = map(int, input().strip().split())
matrix1 = []
matrix2 = []
ans = 'YES'
for _ in range(n):
	matrix1.append(list(map(int, input().strip().split())))
for _ in range(n):
	matrix2.append(list(map(int, input().strip().split())))
for idx_sum in range(n + m - 1):
	line1 = []
	line2 = []
	for raw_id in range(idx_sum + 1):
		if raw_id < n and idx_sum - raw_id < m:
			line1.append(matrix1[raw_id][idx_sum - raw_id])
			line2.append(matrix2[raw_id][idx_sum - raw_id])
	line1 = sorted(line1)
	line2 = sorted(line2)
	if line1 != line2:
		ans = 'NO'
print(ans)


import sys
import heapq
import math
from enum import Enum
lines = sys.stdin.read().splitlines()
(n, m) = map(int, lines[0].split(' '))
matA = []
matB = []
for i in range(0, n):
	row = list(map(int, lines[i + 1].split(' ')))
	matA.append(row)
for i in range(0, n):
	row = list(map(int, lines[i + n + 1].split(' ')))
	matB.append(row)
allElemsA = [[] for i in range(0, n + m - 1)]
for i in range(0, n):
	for j in range(0, m):
		allElemsA[i + j].append(matA[i][j])
allElemsB = [[] for i in range(0, n + m - 1)]
for i in range(0, n):
	for j in range(0, m):
		allElemsB[i + j].append(matB[i][j])
can = True
for i in range(0, len(allElemsA)):
	can = can and sorted(allElemsA[i]) == sorted(allElemsB[i])
	if not can:
		break
if can:
	print('YES')
else:
	print('NO')


from sys import stdin, stdout
(n, m) = map(int, stdin.readline().split())
mata = [None] * n
matb = [None] * n
for i in range(n):
	mata[i] = list(map(int, stdin.readline().split()))
for i in range(n):
	matb[i] = list(map(int, stdin.readline().split()))
la = [None] * (n + m - 1)
lb = [None] * (n + m - 1)
for i in range(n + m - 1):
	la[i] = []
	lb[i] = []
for i in range(n):
	for j in range(m):
		la[i + j].append(mata[i][j])
		lb[i + j].append(matb[i][j])
flag = True
for i in range(n + m - 1):
	la[i].sort()
	lb[i].sort()
	if la[i] != lb[i]:
		flag = False
if flag:
	stdout.write('YES')
else:
	stdout.write('NO')


def main():
	(n, m) = map(int, input().split())
	a = [[] for i in range(n)]
	b = [[] for i in range(n)]
	aDicts = [dict() for i in range(n + m - 1)]
	bDicts = [dict() for i in range(n + m - 1)]
	for i in range(n):
		a[i] = list(map(int, input().split()))
	for i in range(n):
		b[i] = list(map(int, input().split()))
	for i in range(n):
		for j in range(m):
			if a[i][j] in aDicts[i + j].keys():
				aDicts[i + j][a[i][j]] += 1
			else:
				aDicts[i + j][a[i][j]] = 1
			if b[i][j] in bDicts[i + j].keys():
				bDicts[i + j][b[i][j]] += 1
			else:
				bDicts[i + j][b[i][j]] = 1
	for i in range(n + m - 1):
		if aDicts[i] != bDicts[i]:
			print('NO')
			return 0
	print('YES')
	return 0
main()


(n, m) = map(int, input().split())
a = []
b = []
lol = 0
la = [[] for i in range(n * m)]
lb = [[] for i in range(n * m)]
for i in range(n):
	a.append(list(map(int, input().split())))
for i in range(n):
	b.append(list(map(int, input().split())))
for i in range(n):
	for j in range(m):
		la[i + j].append(a[i][j])
		lb[i + j].append(b[i][j])
for i in range(n * m):
	la[i].sort()
	lb[i].sort()
	if la[i] != lb[i]:
		lol = 1
		break
if lol == 0:
	print('YES')
else:
	print('NO')


(n, m) = map(int, input().split())
a = [None] * n
b = [None] * n
f = [None] * (n + m)
g = [None] * (n + m)
for i in range(n + m):
	f[i] = []
	g[i] = []
for i in range(n):
	a[i] = [int(o) for o in input().split()]
	for j in range(m):
		f[i + j].append(a[i][j])
for i in range(n):
	b[i] = [int(o) for o in input().split()]
	for j in range(m):
		g[i + j].append(b[i][j])
flag = 0
for i in range(m + n):
	f[i] = sorted(f[i])
	g[i] = sorted(g[i])
	if f[i] != g[i]:
		flag = 1
		break
if flag == 0:
	print('YES')
else:
	print('NO')


from sys import stdin, stdout
(n, m) = map(int, stdin.readline().split())
mata = [None] * n
matb = [None] * n
for i in range(n):
	mata[i] = list(map(int, stdin.readline().split()))
for i in range(n):
	matb[i] = list(map(int, stdin.readline().split()))
la = [None] * (n + m - 1)
lb = [None] * (n + m - 1)
for i in range(n + m - 1):
	la[i] = []
	lb[i] = []
for i in range(n):
	for j in range(m):
		la[i + j].append(mata[i][j])
		lb[i + j].append(matb[i][j])
ans = 'YES'
for i in range(n + m - 1):
	la[i].sort()
	lb[i].sort()
	if la[i] != lb[i]:
		ans = 'NO'
		break
stdout.write(ans)


(n, m) = map(int, input().split())
L = [list(map(int, input().split())) for i in range(n)]
L1 = [list(map(int, input().split())) for i in range(n)]
l = [[] for i in range(n + m - 1)]
l1 = [[] for i in range(n + m - 1)]
for i in range(n):
	for j in range(m):
		l[i + j].append(L[i][j])
		l1[i + j].append(L1[i][j])
for x in range(n + m - 1):
	v = l[x]
	v1 = l1[x]
	v = sorted(v)
	v1 = sorted(v1)
	if v != v1:
		print('NO')
		exit()
print('YES')


(n, m) = map(int, input().strip().split())
arr = []
for i in range(n):
	a = list(map(int, input().strip().split()))
	arr.append(a)
brr = []
for i in range(n):
	a = list(map(int, input().strip().split()))
	brr.append(a)
flag = 0
j = 0
for i in range(n):
	a = []
	b = []
	p = i
	q = 0
	while p >= 0 and q < m:
		a.append(arr[p][q])
		b.append(brr[p][q])
		p -= 1
		q += 1
	a = sorted(a)
	b = sorted(b)
	if a != b:
		flag = 1
for j in range(m):
	a = []
	b = []
	p = n - 1
	q = j
	while p >= 0 and q < m:
		a.append(arr[p][q])
		b.append(brr[p][q])
		p -= 1
		q += 1
	a = sorted(a)
	b = sorted(b)
	if a != b:
		flag = 1
if flag == 0:
	print('YES')
else:
	print('NO')


(n, m) = map(int, input().split())
a = [[int(x) for x in input().split()] for _ in range(n)]
b = [[int(x) for x in input().split()] for _ in range(n)]
transa = [[] for _ in range(n + m)]
transb = [[] for _ in range(n + m)]
for i in range(n):
	for j in range(m):
		transa[i + j].append(a[i][j])
		transb[i + j].append(b[i][j])
for i in range(n + m):
	if sorted(transa[i]) != sorted(transb[i]):
		print('NO')
		exit()
print('YES')


num = [int(x) for x in input().split(' ')]
(n, m) = (num[0], num[1])
table1 = list()
table2 = list()
for i in range(n):
	num = [int(x) for x in input().split(' ')]
	table1.append(num)
test = table1
max_col = len(test)
max_row = len(test[0])
cols = [[] for i in range(max_col)]
rows = [[] for i in range(max_row)]
fdiag = [[] for i in range(max_col + max_row - 1)]
for y in range(max_col):
	for x in range(max_row):
		cols[y].append(test[y][x])
		rows[x].append(test[y][x])
		fdiag[x + y].append(test[y][x])
dig1 = fdiag
for i in range(n):
	num = [int(x) for x in input().split(' ')]
	table2.append(num)
test = table2
max_col = len(test)
max_row = len(test[0])
cols = [[] for i in range(max_col)]
rows = [[] for i in range(max_row)]
fdiag = [[] for i in range(max_col + max_row - 1)]
for y in range(max_col):
	for x in range(max_row):
		cols[y].append(test[y][x])
		rows[x].append(test[y][x])
		fdiag[x + y].append(test[y][x])
dig2 = fdiag
f = 0
for i in range(m + n - 1):
	if sorted(dig1[i]) != sorted(dig2[i]):
		f = 1
		break
if f == 1:
	print('NO')
else:
	print('YES')


(n, m) = map(int, input().split())
a = [list(map(int, input().split())) for i in range(n)]
b = [list(map(int, input().split())) for i in range(n)]
a1 = [[] for i in range(n + m + 100)]
b1 = [[] for i in range(n + m + 100)]
for i in range(n):
	for j in range(m):
		a1[i + j].append(a[i][j])
		b1[i + j].append(b[i][j])
for i in range(n + m + 5):
	a1[i].sort()
	b1[i].sort()
	if len(a1[i]) != len(b1[i]):
		print('NO')
		exit(0)
	for j in range(len(a1[i])):
		if a1[i][j] != b1[i][j]:
			print('NO')
			exit(0)
print('YES')


(n, m) = map(int, input().split())
m1 = []
m2 = []
for i in range(n):
	m1.append([int(j) for j in input().split()])
for i in range(n):
	m2.append([int(j) for j in input().split()])
d1 = [[] for i in range(n + m - 1)]
d2 = [[] for i in range(n + m - 1)]
for i in range(n):
	for j in range(m):
		d1[i + j].append(m1[i][j])
		d2[i + j].append(m2[i][j])
flag = True
for i in range(n + m - 1):
	d1[i].sort()
	d2[i].sort()
	if d1[i][:] != d2[i][:]:
		flag = False
if flag:
	print('YES')
else:
	print('NO')


import sys
(n, m) = map(int, input().split())
A = []
for i in range(0, n):
	A.append(input().split())
B = []
for i in range(0, n):
	B.append(input().split())
for i in range(1, n + m):
	(x, y) = (min(i - 1, n - 1), max(i - n, 0))
	(a, b) = ([], [])
	while x >= 0 and y < m:
		a.append(A[x][y])
		b.append(B[x][y])
		x -= 1
		y += 1
	a.sort()
	b.sort()
	for k in range(len(a)):
		if a[k] != b[k]:
			print('NO')
			sys.exit()
print('YES')


(n, m) = map(int, input().split())
A = []
B = []
for i in range(n):
	A.append([int(x) for x in input().split()])
for i in range(n):
	B.append([int(x) for x in input().split()])
flag = 0
for i in range(n + m - 1):
	a = []
	b = []
	if i < m:
		(r, c) = (0, i)
	else:
		(r, c) = (i - m + 1, m - 1)
	while r < n and c >= 0:
		a.append(A[r][c])
		b.append(B[r][c])
		r = r + 1
		c = c - 1
	a = sorted(a)
	b = sorted(b)
	if a != b:
		print('NO')
		flag = 1
		break
if flag == 0:
	print('YES')


def f(L):
	T = []
	j = 0
	for i in range(n):
		j = 0
		s = 0
		p = i
		while p >= 0 and j <= m - 1:
			s += L[p][j]
			p -= 1
			j += 1
		T.append(s)
	for j in range(1, m):
		i = n - 1
		s = 0
		q = j
		while q <= m - 1 and i >= 0:
			s += L[i][q]
			q += 1
			i -= 1
		T.append(s)
	return T
R = lambda : map(int, input().split())
(n, m) = R()
A = []
for i in range(n):
	A.append(list(R()))
B = []
for i in range(n):
	B.append(list(R()))
D1 = [j for i in A for j in i]
D2 = [j for i in B for j in i]
if sorted(D1) != sorted(D2):
	print('NO')
	quit()
print('YNEOS'[f(A) != f(B)::2])


from collections import Counter
(n, m) = map(int, input().split())
a = [list(map(int, input().split())) for i in range(n)]
b = [list(map(int, input().split())) for i in range(n)]
ac = [Counter() for i in range(n + m - 1)]
bc = [Counter() for i in range(n + m - 1)]
for i in range(n):
	for j in range(m):
		ac[i + j][a[i][j]] += 1
		bc[i + j][b[i][j]] += 1
if ac == bc:
	print('YES')
else:
	print('NO')


import sys
input = sys.stdin.readline
(n, m) = map(int, input().split())
A = [list(map(int, input().split())) for i in range(n)]
B = [list(map(int, input().split())) for i in range(n)]
LISTA = [[] for i in range(n + m + 1)]
LISTB = [[] for i in range(n + m + 1)]
for i in range(n):
	for j in range(m):
		LISTA[i + j].append(A[i][j])
		LISTB[i + j].append(B[i][j])
for i in range(n + m + 1):
	if sorted(LISTA[i]) != sorted(LISTB[i]):
		print('NO')
		sys.exit()
else:
	print('YES')


(n, m) = map(int, input().strip().split())

def inrange(x, y):
	return x >= 0 and y >= 0 and (x < n) and (y < m)
a = []
b = []
for _ in range(n):
	a.append(list(map(int, input().split())))
for _ in range(n):
	b.append(list(map(int, input().split())))
s = True
for i in range(n + m - 1):
	ii = i
	j = 0
	aa = {}
	bb = {}
	while ii >= 0 and j < m:
		if inrange(ii, j):
			if str(a[ii][j]) in aa.keys():
				aa[str(a[ii][j])] += 1
			else:
				aa[str(a[ii][j])] = 0
			if str(b[ii][j]) in bb.keys():
				bb[str(b[ii][j])] += 1
			else:
				bb[str(b[ii][j])] = 0
		ii -= 1
		j += 1
	if not aa == bb:
		s = False
		break
if s:
	print('YES')
else:
	print('NO')


import sys
(n, m) = tuple(map(int, input().split(' ')))
A = []
for i in range(n):
	A.append(list(map(int, input().split(' '))))
B = []
for i in range(n):
	B.append(list(map(int, input().split(' '))))
if A[0][0] != B[0][0] or A[-1][-1] != B[-1][-1]:
	print('NO')
	sys.exit(0)
for i in range(n):
	for j in range(m):
		if i == 0 and j == 0 or (i == n - 1 and j == m - 1):
			continue
		sum1 = i + j
		found = False
		for k in range(sum1 + 1):
			if k < n and sum1 - k < m and (A[i][j] == B[k][sum1 - k]):
				found = True
				B[k][sum1 - k] = -1
				break
		if not found:
			print('NO')
			sys.exit(0)
print('YES')


(n, m) = map(int, input().split())
ans = 'YES'
M = [list(map(int, input().split())) for j in range(n)]
M2 = [list(map(int, input().split())) for j in range(n)]
for hehe in range(1, n + m):
	start_m = max(0, hehe - n)
	count = min(hehe, m - start_m, n)
	(dic1, dic2) = ({}, {})
	for j in range(0, count):
		if M[min(n, hehe) - j - 1][start_m + j] in dic1:
			dic1[M[min(n, hehe) - j - 1][start_m + j]] += 1
		else:
			dic1[M[min(n, hehe) - j - 1][start_m + j]] = 1
		if M2[min(n, hehe) - j - 1][start_m + j] in dic2:
			dic2[M2[min(n, hehe) - j - 1][start_m + j]] += 1
		else:
			dic2[M2[min(n, hehe) - j - 1][start_m + j]] = 1
	if dic1 != dic2:
		ans = 'NO'
print(ans)


import sys, math, queue
sys.setrecursionlimit(1000000)
(n, m) = map(int, input().split())
a = []
b = []
for i in range(n):
	a.append(list(map(int, input().split())))
for i in range(n):
	b.append(list(map(int, input().split())))
valid = True
for i in range(n):
	d1 = {}
	d2 = {}
	(j, k) = (0, i)
	while j < m and k >= 0:
		if a[k][j] in d1:
			d1[a[k][j]] += 1
		else:
			d1[a[k][j]] = 1
		if b[k][j] in d2:
			d2[b[k][j]] += 1
		else:
			d2[b[k][j]] = 1
		j += 1
		k -= 1
	if d1 != d2:
		valid = False
		break
if not valid:
	print('NO')
	exit()
for j in range(m):
	d1 = {}
	d2 = {}
	(i, k) = (n - 1, j)
	while i >= 0 and k < m:
		if a[i][k] in d1:
			d1[a[i][k]] += 1
		else:
			d1[a[i][k]] = 1
		if b[i][k] in d2:
			d2[b[i][k]] += 1
		else:
			d2[b[i][k]] = 1
		i -= 1
		k += 1
	if d1 != d2:
		valid = False
		break
if not valid:
	print('NO')
	exit(0)
print('YES')


(n, m) = map(int, input().split())
a = [[i for i in map(int, input().split())] for i in range(n)]
b = [[i for i in map(int, input().split())] for i in range(n)]
ans = 1
op = 1
for j in range(m):
	da = {}
	db = {}
	i = 0
	while j >= 0 and i < n:
		da[a[i][j]] = da.get(a[i][j], 0) + 1
		db[b[i][j]] = db.get(b[i][j], 0) + 1
		j -= 1
		i += 1
	if da != db:
		ans = 0
	if not ans:
		break
for i in range(1, n):
	da = {}
	db = {}
	j = m - 1
	while j >= 0 and i < n:
		da[a[i][j]] = da.get(a[i][j], 0) + 1
		db[b[i][j]] = db.get(b[i][j], 0) + 1
		j -= 1
		i += 1
	if da != db:
		ans = 0
	if not ans:
		break
if ans:
	print('YES')
else:
	print('NO')


(n, m) = map(int, input().split())
diag_A = []
diag_B = []
for i in range(n + m):
	diag_A.append([])
	diag_B.append([])
A = []
for i in range(n):
	row = input().split()
	A.append(row)
B = []
for i in range(n):
	row = input().split()
	B.append(row)
for row in range(n):
	for col in range(m):
		diag_A[row + col].append(A[row][col])
		diag_B[row + col].append(B[row][col])
for i in range(n + m):
	if sorted(diag_A[i]) != sorted(diag_B[i]):
		print('NO')
		break
else:
	print('YES')


(n, m) = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
b = [list(map(int, input().split())) for _ in range(n)]
aa = [[] for _ in range(n + m)]
bb = [[] for _ in range(n + m)]
for i in range(n):
	for k in range(m):
		aa[i + k].append(a[i][k])
		bb[i + k].append(b[i][k])
print('YES' if all(map(lambda x, y: sorted(x) == sorted(y), aa, bb)) else 'NO')


from sys import stdin, stdout
stdin.readline

def mp():
	return list(map(int, stdin.readline().strip().split()))

def it():
	return int(stdin.readline().strip())
from collections import defaultdict as dd, Counter as C, deque
from math import ceil, gcd, sqrt, factorial, log2, floor
(n, m) = mp()
(a, b) = ([], [])
for _ in range(n):
	a.append(mp())
for _ in range(n):
	b.append(mp())
ans = 'YES'
d = dd(list)
for i in range(n):
	for j in range(m):
		d[i + j].append(a[i][j])
t = dd(list)
for i in range(n):
	for j in range(m):
		t[i + j].append(b[i][j])
for i in range(m + n):
	if sorted(d[i]) != sorted(t[i]):
		ans = 'NO'
		break
print(ans)


from sys import stdin, stdout
from itertools import combinations
from collections import defaultdict
import math

def listIn():
	return list(map(int, stdin.readline().strip().split()))

def stringListIn():
	return [x for x in stdin.readline().split()]

def intIn():
	return int(stdin.readline())

def stringIn():
	return stdin.readline().strip()

def diagonalOrder(matrix, ROW, COL):
	ans = []
	for line in range(1, ROW + COL):
		start_col = max(0, line - ROW)
		count = min(line, COL - start_col, ROW)
		li = []
		for j in range(0, count):
			ele = matrix[min(ROW, line) - j - 1][start_col + j]
			li.append(ele)
		ans.append(sorted(li))
	return ans
(n, m) = listIn()
A = []
B = []
for i in range(n):
	a = listIn()
	A.append(a)
for i in range(n):
	a = listIn()
	B.append(a)
if A[0][0] == B[0][0] and A[n - 1][m - 1] == B[n - 1][m - 1]:
	res = diagonalOrder(A, n, m)
	res2 = diagonalOrder(B, n, m)
	if res == res2:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


n_m = input().split(' ')
n = int(n_m[0])
m = int(n_m[1])
A = []
for i in range(n):
	t = input().split(' ')
	A.append(t)
B = []
for i in range(n):
	t = input().split(' ')
	B.append(t)
for i in range(m + n - 1):
	text_1 = []
	text_2 = []
	for j in range(i + 1):
		if i - j < n and j < m:
			text_1.append(A[i - j][j])
			text_2.append(B[i - j][j])
		if i - j >= n and j < m:
			continue
		if i - j < n and j >= m:
			continue
		if i - j >= n and j >= m:
			continue
	text_1.sort()
	text_2.sort()
	f = True
	if text_1 == text_2:
		f == True
	else:
		f = False
		break
if f:
	print('YES')
else:
	print('NO')


R = lambda : map(int, input().split())
(n, m) = R()

def f():
	a = [()] * (n + m)
	for i in range(n):
		for x in R():
			a[i] += (x,)
			i += 1
	return [*map(sorted, a)]
print('YNEOS'[f() != f()::2])


(n, m) = map(int, input().split())
A = []
B = []
flag = 1
for i in range(n):
	A.append(list(map(int, input().split())))
for i in range(n):
	B.append(list(map(int, input().split())))
for i in range(n + m - 1):
	j = 0
	Alist = []
	Blist = []
	while i >= 0:
		try:
			Alist.append(A[i][j])
			Blist.append(B[i][j])
		except IndexError:
			pass
		j += 1
		i -= 1
	Alist.sort()
	Blist.sort()
	if Alist != Blist:
		flag = 0
if flag == 1:
	print('YES')
else:
	print('NO')


(n, m) = map(int, input().split())
A = [list(map(int, input().split())) for i in range(n)]
B = [list(map(int, input().split())) for i in range(n)]
X = [[] for i in range(n + m)]
Y = [[] for i in range(n + m)]
for i in range(n):
	for j in range(m):
		X[i + j].append(A[i][j])
for i in range(n):
	for j in range(m):
		Y[i + j].append(B[i][j])
for k in range(n + m):
	x = X[k]
	y = Y[k]
	x.sort()
	y.sort()
	if x != y:
		print('NO')
		exit()
else:
	print('YES')


from sys import stdin, stdout
from math import *
(n, m) = map(int, input().split())
m1 = []
for i in range(n):
	r = list(map(int, input().split()))
	m1.append(r)
m2 = []
for i in range(n):
	r = list(map(int, input().split()))
	m2.append(r)
d = [0] * (n - 1 + m)
for i in range(n - 1 + m):
	d[i] = {}
for i in range(n):
	for j in range(m):
		if d[i + j].get(m2[i][j]) == None:
			d[i + j][m2[i][j]] = 1
		else:
			d[i + j][m2[i][j]] += 1
ans = 'YES'
for i in range(n):
	for j in range(m):
		e = m1[i][j]
		if d[i + j].get(e) == 0 or d[i + j].get(e) == None:
			ans = 'NO'
		else:
			d[i + j][e] -= 1
print(ans)


(n, m) = [int(s) for s in input().split()]
a = []
b = []
for i in range(n):
	a.append([int(s) for s in input().split()])
for i in range(n):
	b.append([int(s) for s in input().split()])
diagsa = []
diagsb = []
for i in range(n - 1):
	k = i
	j = 0
	diagsa.append([])
	diagsb.append([])
	while j < m and k > -1:
		diagsa[i].append(a[k][j])
		diagsb[i].append(b[k][j])
		j = j + 1
		k = k - 1
	diagsa[i].sort()
	diagsb[i].sort()
for j in range(m):
	k = j
	i = n - 1
	diagsa.append([])
	diagsb.append([])
	while k < m and i > -1:
		diagsa[n - 1 + j].append(a[i][k])
		diagsb[n - 1 + j].append(b[i][k])
		i = i - 1
		k = k + 1
	diagsa[n - 1 + j].sort()
	diagsb[n - 1 + j].sort()
for i in range(len(diagsa)):
	if diagsa[i] != diagsb[i]:
		print('NO')
		break
else:
	print('YES')


(n, m) = map(int, input().split())
ma = [[] for i in range(n + m)]
mb = [[] for i in range(n + m)]
w = []
for i in range(n):
	w = list(map(int, input().split()))
	for j in range(m):
		ma[i + j].append(w[j])
w = []
for i in range(n):
	w = list(map(int, input().split()))
	for j in range(m):
		mb[i + j].append(w[j])
for i in range(n + m):
	if sorted(ma[i]) != sorted(mb[i]):
		print('NO')
		exit(0)
print('YES')


from collections import defaultdict
(n, m) = map(int, input().split())
R = n
C = m

def diagonalOrder(matrix):
	config = []
	for line in range(1, R + C):
		d = defaultdict(int)
		lineconfig = []
		start_col = max(0, line - R)
		count = min(line, C - start_col, R)
		for j in range(0, count):
			d[matrix[min(R, line) - j - 1][start_col + j]] += 1
		for (i, j) in d.items():
			lineconfig.append((i, j))
		config.append(sorted(lineconfig))
	return config
a = []
b = []
for _ in range(n):
	a.append(list(map(int, input().split())))
for _ in range(n):
	b.append(list(map(int, input().split())))
set_a = diagonalOrder(a)
set_b = diagonalOrder(b)
if set_a == set_b:
	print('YES')
else:
	print('NO')


(n, m) = map(int, input().split())
ar = [0] * 2
diag = [0] * 2
for i in range(2):
	ar[i] = [[int(t) for t in input().split()] for j in range(n)]
	diag[i] = [{} for j in range(n + m - 1)]
for num in range(2):
	for i in range(n):
		for j in range(m):
			cur = ar[num][i][j]
			it = diag[num][j + i]
			if it.get(cur) == None:
				it[cur] = 0
			it[cur] += 1
for i in range(n + m - 1):
	if diag[0][i] != diag[1][i]:
		print('NO')
		exit()
print('YES')


(n, m) = map(int, input().split())
a = []
b = []
f = 0
for i in range(n):
	a.append(list(map(int, input().split())))
for i in range(n):
	b.append(list(map(int, input().split())))
for i in range(n):
	k = 0
	ta = []
	tb = []
	while 1:
		if i - k >= 0 and k < m:
			ta.append(a[i - k][k])
			tb.append(b[i - k][k])
		else:
			break
		k += 1
	ta.sort()
	tb.sort()
	for i in range(len(ta)):
		if ta[i] != tb[i]:
			f = 1
for j in range(m):
	k = 0
	ta = []
	tb = []
	while 1:
		if j + k <= m - 1 and n - 1 - k >= 0:
			ta.append(a[n - 1 - k][j + k])
			tb.append(b[n - 1 - k][j + k])
		else:
			break
		k += 1
	ta.sort()
	tb.sort()
	for i in range(len(ta)):
		if ta[i] != tb[i]:
			f = 1
if f == 0:
	print('YES')
else:
	print('NO')


(r, c) = list(map(int, input().split()))
f = [None] * (r + c - 1)
l = [None] * (r + c - 1)
for i in range(0, r + c - 1):
	f[i] = []
	l[i] = []
for i in range(0, r):
	ip = list(map(int, input().split()))
	for j in range(0, c):
		f[i + j].append(ip[j])
for i in range(0, r):
	ip = list(map(int, input().split()))
	for j in range(0, c):
		l[i + j].append(ip[j])
for i in range(0, r + c - 1):
	f[i].sort()
	l[i].sort()
	if f[i] == l[i]:
		continue
	else:
		print('NO')
		exit(0)
print('YES')


from collections import defaultdict
(n, m) = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
b = [list(map(int, input().split())) for _ in range(n)]
cnt = [defaultdict(int) for _ in range(1000)]
for i in range(n):
	for j in range(m):
		cnt[i + j][a[i][j]] += 1
		cnt[i + j][b[i][j]] -= 1
for i in range(n + m):
	for key in cnt[i].keys():
		if cnt[i][key] != 0:
			print('NO')
			exit(0)
print('YES')


(sizeI, sizeJ) = map(int, input().split())
have = [list(map(int, input().split())) for _ in range(sizeI)]
need = [list(map(int, input().split())) for _ in range(sizeI)]

def solve():
	for k in range(sizeI + sizeJ - 1):
		(haveDict, needDict) = ({}, {})
		for j in range(k + 1):
			i = k - j
			if i < sizeI and j < sizeJ:
				(haveVal, needVal) = (have[i][j], need[i][j])
				haveDict.setdefault(haveVal, 0)
				haveDict[haveVal] += 1
				needDict.setdefault(needVal, 0)
				needDict[needVal] += 1
		if haveDict != needDict:
			return 'NO'
	return 'YES'
print(solve())


(n, m) = list(map(int, input().split()))
a = []
b = []
for i in range(n):
	a.append(list(map(int, input().split())))
for i in range(n):
	b.append(list(map(int, input().split())))
a1 = [[] for i in range(n + m - 1)]
for i in range(n):
	j = 0
	k = i
	while k >= 0 and j < m:
		a1[i].append(a[k][j])
		k -= 1
		j += 1
for i in range(1, m):
	j = n - 1
	k = i
	while k < m and j >= 0:
		a1[n + i - 1].append(a[j][k])
		k += 1
		j -= 1
b1 = [[] for i in range(n + m - 1)]
for i in range(n):
	j = 0
	k = i
	while k >= 0 and j < m:
		b1[i].append(b[k][j])
		k -= 1
		j += 1
for i in range(1, m):
	j = n - 1
	k = i
	while k < m and j >= 0:
		b1[n + i - 1].append(b[j][k])
		k += 1
		j -= 1
for i in range(n + m - 1):
	q1 = a1[i]
	q2 = b1[i]
	q1.sort()
	q2.sort()
	if q1 != q2:
		print('NO')
		exit()
print('YES')


(n, m) = map(int, input().split())
a = []
for j in range(n):
	te = [int(v) for v in input().split()]
	a.append(te)
b = []
f = 0
for j in range(n):
	te = [int(v) for v in input().split()]
	b.append(te)
j = 0
while j < m:
	k = 0
	p = j
	x = []
	y = []
	while k < n and p >= 0:
		x.append(a[k][p])
		y.append(b[k][p])
		k = k + 1
		p = p - 1
	x.sort()
	y.sort()
	j = j + 1
	if x[:] != y[:]:
		f = 1
		break
if f == 0:
	j = 1
	while j < n:
		k = j
		p = m - 1
		x = []
		y = []
		while k < n and p >= 0:
			x.append(a[k][p])
			y.append(b[k][p])
			k = k + 1
			p = p - 1
		x.sort()
		y.sort()
		j = j + 1
		if x[:] != y[:]:
			f = 1
			break
if f == 0:
	print('YES')
else:
	print('NO')


import os
import sys
from math import *
from collections import *
from bisect import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
ALPHA = 'abcdefghijklmnopqrstuvwxyz'
M = 998244353
EPS = 1e-06

def Ceil(a, b):
	return a // b + int(a % b > 0)

def value():
	return tuple(map(int, input().split()))

def array():
	return [int(i) for i in input().split()]

def Int():
	return int(input())

def Str():
	return input()

def arrayS():
	return [i for i in input().split()]
(n, m) = value()
row_a = defaultdict(list)
row_b = defaultdict(list)
for i in range(n):
	a = array()
	for j in range(m):
		row_a[i + j].append(a[j])
for i in range(n):
	a = array()
	for j in range(m):
		row_b[i + j].append(a[j])
ok = 'YES'
for i in range(m * n):
	if sorted(row_a[i]) != sorted(row_b[i]):
		ok = 'NO'
print(ok)


from sys import *
(n, m) = map(int, stdin.readline().split())
a = []
for i in range(n):
	x = list(map(int, stdin.readline().split()))
	a.append(x)
b = []
for i in range(n):
	x = list(map(int, stdin.readline().split()))
	b.append(x)
c1 = []
for i in range(n + m):
	c1.append([])
c2 = []
for i in range(n + m):
	c2.append([])
for i in range(n):
	for j in range(m):
		c1[i + j].append(a[i][j])
		c2[i + j].append(b[i][j])
f = 0
for i in range(n + m):
	c1[i].sort()
	c2[i].sort()
	if c1[i] != c2[i]:
		f = 1
		break
if f == 1:
	print('NO')
else:
	print('YES')


import sys
sys.setrecursionlimit(10 ** 5 + 1)
inf = int(10 ** 20)
max_val = inf
min_val = -inf
RW = lambda : sys.stdin.readline().strip()
RI = lambda : int(RW())
RMI = lambda : [int(x) for x in sys.stdin.readline().strip().split()]
RWI = lambda : [x for x in sys.stdin.readline().strip().split()]
(nb_rows, nb_cols) = RMI()
mat_A = [RMI() for _ in range(nb_rows)]
mat_B = [RMI() for _ in range(nb_rows)]
mat_AB = [[] for _ in range(nb_rows + nb_cols)]
mat_BA = [[] for _ in range(nb_rows + nb_cols)]
for i in range(nb_rows):
	for j in range(nb_cols):
		mat_AB[i + j].append(mat_A[i][j])
		mat_BA[i + j].append(mat_B[i][j])
mat_ABS = [sorted(x) for x in mat_AB]
mat_BAS = [sorted(x) for x in mat_BA]
print(['NO', 'YES'][mat_ABS == mat_BAS])


from sys import stdin
from collections import defaultdict
input = stdin.readline
(n, m) = map(int, input().split())
mat = [list(map(int, line.split())) for line in stdin.read().splitlines()]
a = defaultdict(list)
b = defaultdict(list)
for i in range(n):
	for j in range(m):
		a[i + j].append(mat[i][j])
		b[i + j].append(mat[i + n][j])
if all((sorted(a[i]) == sorted(b[i]) for i in a.keys())):
	print('YES')
else:
	print('NO')