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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.io.*;
import java.util.*;
import java.text.DecimalFormat;
import java.math.*;

public class Main {

static int  mod = 1000000007;
/*****************code By Priyanshu *******************************************/ 

    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;
        }
    }
    // this > other return +ve
    // this < other return -ve
    // this == other return 0
     public static class Pair implements Comparable<Pair> {
      int st;
      int et;

      public Pair(int st, int et) {
         this.st = st;
         this.et = et;
      }

      public int compareTo(Pair other) {
         if (this.st != other.st) {
            return this.st - other.st;
         } else {
            return this.et - other.et;
         }
      }
   }

    static long fastPower(long a, long b, int 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;
            
        }

     // function to find
    // the rightmost set bit
    static int PositionRightmostSetbit(int n)
    {
        // Position variable initialize
        // with 1 m variable is used to
        // check the set bit
        int position = 1;
        int m = 1;
 
        while ((n & m) == 0) {
 
            // left shift
            m = m << 1;
            position++;
        }
        return position;
    }
    
         // used for swapping ith and jth elements of array
      // public static void swap(int[] arr, int i, int j) {
      //   int temp = arr[i];
      //   arr[i] = arr[j];
      //   arr[j] = temp;
      // }
        public static void swap(long i, long j) {
        long temp = i;
        i = j;
        j = temp;
      }


    static boolean palindrome(String s) {
        return new StringBuilder(s).reverse().toString().equals(s);
    }


    static int countDigit(long n)
    {
        return (int)Math.floor(Math.log10(n) + 1);
    }
  static boolean isPerfectSquare(double x)
    {
            double sr = Math.sqrt(x);
            return ((sr * sr) == x);     
    }


 public static int gcd(int a, int b)
    {
      if (b == 0)
        return a;
      return gcd(b, a % b);
    }
    
   

   static int nod(long l) {
       if(l>=1000000000000000000l) return 19;
       if(l>=100000000000000000l) return 18;
       if(l>=10000000000000000l) return 17;
       if(l>=1000000000000000l) return 16;
       if(l>=100000000000000l) return 15;
       if(l>=10000000000000l) return 14;
       if(l>=1000000000000l) return 13;
       if(l>=100000000000l) return 12;
       if(l>=10000000000l) return 11;
       if(l>=1000000000) return 10;
       if(l>=100000000) return 9;
       if(l>=10000000) return 8;
       if(l>=1000000) return 7;
       if(l>=100000) return 6;
       if(l>=10000) return 5;
       if(l>=1000) return 4;
       if(l>=100) return 3;
       if(l>=10) return 2;
       return 1;
    }
      //Arrays.sort(a,(c,d) -> Integer.compare(c[0],d[0]));

    
    public static boolean areAllBitsSet(int n )
    {
        // all bits are not set
        if (n == 0)
            return false;
     
        // if true, then all bits are set
        if (((n + 1) & n) == 0)
            return true;
     
        // else all bits are not set
        return false;
    }
   
 

        public static int[] radixSort2(int[] a)
    {
        int n = a.length;
        int[] c0 = new int[0x101];
        int[] c1 = new int[0x101];
        int[] c2 = new int[0x101];
        int[] c3 = new int[0x101];
        for(int v : a) {
            c0[(v&0xff)+1]++;
            c1[(v>>>8&0xff)+1]++;
            c2[(v>>>16&0xff)+1]++;
            c3[(v>>>24^0x80)+1]++;
        }
        for(int i = 0;i < 0xff;i++) {
            c0[i+1] += c0[i];
            c1[i+1] += c1[i];
            c2[i+1] += c2[i];
            c3[i+1] += c3[i];
        }
        int[] t = new int[n];
        for(int v : a)t[c0[v&0xff]++] = v;
        for(int v : t)a[c1[v>>>8&0xff]++] = v;
        for(int v : a)t[c2[v>>>16&0xff]++] = v;
        for(int v : t)a[c3[v>>>24^0x80]++] = v;
        return a;
    }



   


  // static FastReader sc = new FastReader();

// public static int[] readArray(int n) {
//     int A[] = new int[n];
//     for (int i = 0; i < n; i++) {
//       A[i] = sc.nextInt();
//     }
//     return A;
//   }

//   public static long[] readArray(long n) {
//     long A[] = new long[(int) n];
//     for (int i = 0; i < n; i++) {
//       A[i] = sc.nextLong();
//     }
//     return A;
//   }
    public static boolean check(long num){
        long temp = num;

        while(temp!=0){
            if( temp%10!=0 && num%(temp%10)!=0) {
                return false;
            }
            temp/=10;
        }
        return true;
    }




    public static void main(
        String[] args)
    {
        try {
            System.setIn(new FileInputStream("input.txt"));
            System.setOut(new PrintStream(new FileOutputStream("output.txt")));
        } catch (Exception e) {
            System.err.println("Error");
        }
         
       FastReader sc = new FastReader();
       // int t = Integer.parseInt(sc.next());
       int t = 1;
 
        
     while(t-->0){

        int n = sc.nextInt();
        int m = sc.nextInt();

        int A[][]= new int[n][m];
        int X[][]=new int[n][m];
        for(int a[]:X)
            Arrays.fill(a, -1);
        
        int f=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++) 
            {
                A[i][j]= sc.nextInt();
                if(A[i][j]==0)
                {
                    Arrays.fill(X[i],0);
                    for(int k=0;k<n;k++)
                        X[k][j]=0;
                    
                }
                
            }
        }
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(X[i][j]==-1)
                {
                    X[i][j]=A[i][j];
                }
            }
        }
    
        int xor[][]=new int[n][m];
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                int x=0;
                for(int k=0;k<m;k++)
                x=x|X[i][k];
                for(int k=0;k<n;k++)
                    x=x|X[k][j];
                    xor[i][j]=x;
                
            }
        }
        
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            if(A[i][j]!=xor[i][j])
                f=-1;
        }
    }
        
        
    //for(int a[]:X)
        //System.out.println(Arrays.toString(a));
//  for(int a[]:xor)
    //  System.out.println(Arrays.toString(a));
        
        
        
        
        if(f==0)
        {
            System.out.println("YES");
            for(int i=0;i<n;i++)
            {
                for(int j=0;j<m;j++)
                {
                    System.out.print(X[i][j]+" ");
                }
                System.out.println(); 
            }
                
            
        }else
            System.out.println("NO");
        
        
    
       


     

     


       
        
          
       
        

       
        

        
        
       





    }    
  }
}
//code By Priyanshu