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.*;
import java.util.*;

public class TaskC {


    public static void main(String[] args) throws Exception {

        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);

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

        int[][] mat = new int[n][m];
        int[][] ans = new int[n][m];

        for (int i = 0 ; i < n ;i++)
            Arrays.fill(ans[i],1);

        for (int i = 0 ; i < n ; i++)
            for (int j = 0 ; j < m ; j++) {
                mat[i][j] = sc.nextInt();
                if(mat[i][j] == 0)
                {
                    for (int x = 0; x < n ;x++)
                        ans[x][j] = 0;
                    for (int y = 0; y < m ;y++)
                        ans[i][y] = 0;
                }
            }
        for (int i = 0 ; i < n; i++)
            for (int j = 0; j<m ; j++)
            {
                int OR = 0;
                for (int x = 0; x < n ;x++)
                    OR |= ans[x][j];
                for (int y = 0; y < m ;y++)
                    OR |= ans[i][y];
                if(OR != mat[i][j])
                {
                    System.out.println("NO");
                    return;
                }
            }

        System.out.println("YES");
        for (int i = 0 ; i < n ;i++) {
            for (int j = 0; j < m; j++) {
                System.out.print(ans[i][j] + " ");
            }
            System.out.println();
        }
        pw.close();
    }

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

    private  static int dis(int xa , int ya , int xb , int yb)
    {
        return (xa-xb)*(xa - xb) + (ya- yb)*(ya-yb);
    }

    static class Pair implements Comparable<Pair> {
        int x,l,r;


        public Pair(int x, int y , int z) {
            this.x = x;
            this.l = y;
            r = z;
        }

        public int compareTo(Pair o) {
            if(x == o.x)
               return l - o.l;
            return  x- o.x;
        }
        public double dis(Pair a){
            return  0;
            //   return (a.x - x)*(a.x - x) + (a.y-y)*(a.y-y);
        }
        public String toString() {
            return  x+" "+ l + " " + r ;
        }
        public boolean overlap(Pair a)
        {
        //    if((this.x >= a.x && this.x <= a.y) || (a.x >= this.x && a.x <= this.y)) return true;
            return false;

        }
    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(FileReader r) {
            br = new BufferedReader(r);
        }

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        public String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return st.nextToken();
        }

        public boolean check() {
            if (!st.hasMoreTokens())
                return false;
            return true;
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public String nextLine() {
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        public double nextDouble() {
            String x = next();
            StringBuilder sb = new StringBuilder("0");
            double res = 0, f = 1;
            boolean dec = false, neg = false;
            int start = 0;
            if (x.charAt(0) == '-') {
                neg = true;
                start++;
            }
            for (int i = start; i < x.length(); i++)
                if (x.charAt(i) == '.') {
                    res = Long.parseLong(sb.toString());
                    sb = new StringBuilder("0");
                    dec = true;
                } else {
                    sb.append(x.charAt(i));
                    if (dec)
                        f *= 10;
                }
            res += Long.parseLong(sb.toString()) / f;
            return res * (neg ? -1 : 1);
        }

        public boolean ready() {
            try {
                return br.ready();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}