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 JAVA):

Solution:
import java.util.* ;
import java.lang.* ;
import java.io.*;

public class javaTemplate {
	
	static FastReader sc = new FastReader();
	//	static Scanner sc = new Scanner(System.in) ;
	
	public static void main(String[] args) {
		
		
        int m = sc.nextInt() ;
		int n = sc.nextInt() ;
		
		int arr[][] = new int[m][n] ;
		int ans[][] = new int[m][n] ;
		for(int i = 0 ; i< m ; i++) {
			for(int j = 0 ; j< n ; j++) {
				arr[i][j] = sc.nextInt() ;
				ans[i][j] = 1 ;
			}
		}
		
		for(int i = 0 ; i< m ; i++) {
			for(int j = 0 ; j< n ; j++) {
				if(arr[i][j] == 0) {
					for(int x = 0 ; x< n ; x ++) {
						ans[i][x] = 0 ;
					}
					for(int x = 0 ; x< m ; x ++) {
						ans[x][j] = 0 ;
					}
				}
			}
		}
		
//		for(int i = 0 ; i< m ; i++) {
//			for(int j = 0 ; j< n ; j++) {
//				System.out.print(ans[i][j] + " ");
//			}
//			System.out.println();
//		}
		boolean val = true ;
		for(int i = 0 ; i< m ; i++) {
			for(int j = 0 ; j< n ; j++) {
				int res = 0 ;
				for(int x = 0 ; x< n ; x ++) {
					res |= ans[i][x] ;
				}
				for(int k = 0 ; k< m ; k ++) {
					res |= ans[k][j] ;
				}
				if(res != arr[i][j]) {
//					System.out.println(res + " " + arr[i][j] + " " + i + " " + j);
					val = false ;
					break ;
				}
			}
			if(!val) {
				break ;
			}
		}
		
		
		if(val) {
			System.out.println("YES");
			for(int i = 0 ; i< m ; i++) {
				for(int j = 0 ; j< n ; j++) {
					System.out.print(ans[i][j] + " ");
				}
				System.out.println();
			}
		} else {
			System.out.println("NO");
		}
		
	
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
	}
	

	
	

	

	
	
	

	
	
	
	
	
	
	 
	
	


	
	
//_________________________//Template//_____________________________________________________________________
	
	
		//		FAST I/O
		static class FastReader {
	        BufferedReader br;
	        StringTokenizer st;
	        
	        public FastReader()
	        {
	            br = new BufferedReader(
	                new InputStreamReader(System.in));
	        }
	 
	        String next()
	        {
	            while (st == null || !st.hasMoreElements()) {
	                try {
	                    st = new StringTokenizer(br.readLine());
	                }
	                catch (IOException e) {
	                    e.printStackTrace();
	                }
	            }
	            return st.nextToken();
	        }
	 
	        int nextInt() { return Integer.parseInt(next()); }
	 
	        long nextLong() { return Long.parseLong(next()); }
	 
	        double nextDouble()
	        {
	            return Double.parseDouble(next());
	        }
	 
	        String nextLine()
	        {
	            String str = "";
	            try {
	                str = br.readLine();
	            }
	            catch (IOException e) {
	                e.printStackTrace();
	            }
	            return str;
	        }
		}
	
	
		
		
		
		
		
		
		
		// Modulo
		static int mod(int a, int m)
		{
		    return (a%m + m) % m;
		}
		
		
		
		
		
		//		LPS Array
		static void LPSArray(String pat, int M, int lps[]) {
			int i = 1 ;
			int length = 0 ;
			lps[0] = 0 ;
			
			while(i < M) {
				if(pat.charAt(i) == pat.charAt(length)) {
					length ++ ;
					lps[i] = length ;
					i ++ ;
				} else if(length != 0) {
					length = lps[length-1] ;
				} else {
					lps[i] = length ;
					i ++ ;
				}
			}
		}
		
		
		
		//		KMP Search
		static boolean kmpSearch(String pat, String txt) {
			boolean val = false ;
			int M = pat.length() ;
			int N = txt.length() ;
			
			int lps[] = new int[M] ;
			
			int j = 0 ;
			int i = 0 ;
			
			LPSArray(pat,M,lps) ;
			
			while(i < N) {
				if(pat.charAt(j) == txt.charAt(i)) {
					i ++ ;
					j ++ ;
				} else if(j != 0) {
					j = lps[j-1] ;
				} else {
					i ++ ;
				}
				
				if(j == M) {
					 val = true ;
					 j = lps[j-1] ;
				}
			}
			
			return val ;
		}
	
	
		
			
			
		
		
		
		//		Palindrom or Not
		static boolean isPalindrome(StringBuilder str, int low, int high) {
					
					while (low < high) {
						if (str.charAt(low) != str.charAt(high)) return false;
					 	low++;
					 	high--;
					}
					return true;
				}
	
	
		// Euler Tortient fx
	static int Phi(int n) {
		
		int count = 0 ;
		for(int i = 1 ; i< n ; i++) {
			if(GCD(i,n) == 1) count ++ ;
		}
		return count ;
	}
	
	
	
		// Integer Sort
		static void sort(int[] a) 
		   {
				ArrayList<Integer> l=new ArrayList<>();
				for (int i:a) l.add(i);
				Collections.sort(l);
				for (int i=0; i<a.length; i++) a[i]=l.get(i);
			}
	
		
		
		
		// Long Sort
		static void sort(long[] a) 
		   {
				ArrayList<Long> l=new ArrayList<>();
				for (long i:a) l.add(i);
				Collections.sort(l);
				for (int i=0; i<a.length; i++) a[i]=l.get(i);
			}
	
	
		
		// boolean Value
		static void val(boolean val)
	    {
	       System.out.println(val ? "YES" : "NO");
	       System.out.flush();
	    }
	
	
		
	
		// GCD
		public static int GCD(int a , int b) {
				if(b == 0) return a ;
				
				return GCD(b, a%b) ;
			}
	
		
		
		
		
		
		// sieve
		public static boolean [] sieveofEratosthenes(int n) {
			
			boolean isPrime[] = new boolean[n+1] ;
			Arrays.fill(isPrime, true);
			isPrime[0] = false ;
			isPrime[1] = false ;
			
			for(int i = 2 ; i * i <= n ; i++) {
				
				for(int j = 2 * i ; j<= n ; j+= i) {
					isPrime[j] = false ;
				}
			}
			
			return isPrime ;
		}
		
		
		
		
		// fastPower
		public static long fastPowerModulo(long a, long b, long n) {
			
			long res = 1 ;
			
			while(b > 0) {
			if((b&1) != 0) {
				res = (res * a % n) % n ;
			}
			
			a = (a % n * a % n) % n ;
			b = b >> 1 ;
			}
			
			return res ;
		}
	

}