Problem: Let's define logical OR as an operation on two logical values (i. e. values that belong to the set {0, 1}) that is equal to 1 if either or both of the logical values is set to 1, otherwise it is 0. We can define logical OR of three or more logical values in the same manner:

<image> where <image> is equal to 1 if some ai = 1, otherwise it is equal to 0.

Nam has a matrix A consisting of m rows and n columns. The rows are numbered from 1 to m, columns are numbered from 1 to n. Element at row i (1 ≤ i ≤ m) and column j (1 ≤ j ≤ n) is denoted as Aij. All elements of A are either 0 or 1. From matrix A, Nam creates another matrix B of the same size using formula:

<image>.

(Bij is OR of all elements in row i and column j of matrix A)

Nam gives you matrix B and challenges you to guess matrix A. Although Nam is smart, he could probably make a mistake while calculating matrix B, since size of A can be large.

Input

The first line contains two integer m and n (1 ≤ m, n ≤ 100), number of rows and number of columns of matrices respectively.

The next m lines each contain n integers separated by spaces describing rows of matrix B (each element of B is either 0 or 1).

Output

In the first line, print "NO" if Nam has made a mistake when calculating B, otherwise print "YES". If the first line is "YES", then also print m rows consisting of n integers representing matrix A that can produce given matrix B. If there are several solutions print any one.

Examples

Input

2 2
1 0
0 0


Output

NO


Input

2 3
1 1 1
1 1 1


Output

YES
1 1 1
1 1 1


Input

2 3
0 1 0
1 1 1


Output

YES
0 0 0
0 1 0

Solution (in PYTHON3):

Solution:
import math, sys
from collections import defaultdict, Counter, deque
from functools import reduce

INF = float('inf')
MOD = int(1e9) + 7

def solve():
	n, m = vars()

	mat = [] 
	for i in range(n):
		mat.append(array())

	row = [1] * n 
	col = [1] * m 

	for i in range(n):
		for j in range(m):
			if not mat[i][j]:
				row[i] = 0 
				col[j] = 0

	if bool(sum(row)) ^ bool(sum(col)):
		print('NO')
		return 

	for i in range(n):
		for j in range(m):
			if mat[i][j]:
				if row[i] or col[j]:
					mat[i][j] = int(row[i] and col[j])
				else:
					print('NO')
					return
	print('YES')
	for r in mat:
		print(*r)


def main():
	t = 1 
	# t = int(input())
	for _ in range(t):
		solve()
















def gcd(a, b):
	while b:
		a, b = b, a%b
	return a
 
def isPrime(n):
	if (n <= 1): 
		return False
	i = 2
	while i ** 2 <= n:
		if n % i == 0:
			return False
		i += 1
	return True

class DSU:
	def __init__(self, n):
		self.p = [i for i in range(n + 1)]
		self.size = [1 for i in range(n + 1)]
		self.minmax = [[i, i] for i in range(n + 1)]
		self.n = n

	def find(self, node):
		if self.p[node] != node:
			self.p[node] = self.find(self.p[node])

		return self.p[node]

	def union(self, source, dest):
		source = self.find(source)
		dest = self.find(dest)

		if source != dest:
			if self.size[source] < self.size[dest]:
				source, dest = dest, source
			self.p[dest] = source
			self.size[source] += self.size[dest]
			mini = min(self.minmax[source][0], self.minmax[dest][0])
			maxi = max(self.minmax[source][1], self.minmax[dest][1])
			self.minmax[source] = [mini, maxi]



def input():
	return sys.stdin.readline().rstrip('\n')

def print(*args, sep=' ', end='\n'):
	first = True
	for arg in args:
		if not first:
			sys.stdout.write(sep)
		sys.stdout.write(str(arg))
		first = False 

	sys.stdout.write(end)

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

if __name__ == "__main__":
	main()