You are given two matrices A and B. Each matrix contains exactly n rows and m columns. Each element of A is either 0 or 1; each element of B is initially 0.

You may perform some operations with matrix B. During each operation, you choose any submatrix of B having size 2 × 2, and replace every element in the chosen submatrix with 1. In other words, you choose two integers x and y such that 1 ≤ x < n and 1 ≤ y < m, and then set B_{x, y}, B_{x, y + 1}, B_{x + 1, y} and B_{x + 1, y + 1} to 1.

Your goal is to make matrix B equal to matrix A. Two matrices A and B are equal if and only if every element of matrix A is equal to the corresponding element of matrix B.

Is it possible to make these matrices equal? If it is, you have to come up with a sequence of operations that makes B equal to A. Note that you don't have to minimize the number of operations.

Input

The first line contains two integers n and m (2 ≤ n, m ≤ 50).

Then n lines follow, each containing m integers. The j-th integer in the i-th line is A_{i, j}. Each integer is either 0 or 1.

Output

If it is impossible to make B equal to A, print one integer -1.

Otherwise, print any sequence of operations that transforms B into A in the following format: the first line should contain one integer k — the number of operations, and then k lines should follow, each line containing two integers x and y for the corresponding operation (set B_{x, y}, B_{x, y + 1}, B_{x + 1, y} and B_{x + 1, y + 1} to 1). The condition 0 ≤ k ≤ 2500 should hold.

Examples

Input


3 3
1 1 1
1 1 1
0 1 1


Output


3
1 1
1 2
2 2


Input


3 3
1 0 1
1 0 1
0 0 0


Output


-1


Input


3 2
0 0
0 0
0 0


Output


0

Note

The sequence of operations in the first example:

\begin{matrix} 0 & 0 & 0 & & 1 & 1 & 0 & & 1 & 1 & 1 & & 1 & 1 & 1 \\\ 0 & 0 & 0 & → & 1 & 1 & 0 & → & 1 & 1 & 1 & → & 1 & 1 & 1 \\\ 0 & 0 & 0 & & 0 & 0 & 0 & & 0 & 0 & 0 & & 0 & 1 & 1 \end{matrix} 
    import java.io.*;
    import java.util.*;
    import java.lang.*;
    import static java.lang.Math.*;
     
    public class TaskB implements Runnable {
        ArrayList<Integer> prime;
        boolean is_prime[];
        InputReader c;
        PrintWriter w;
        /*Global Variables*/
     
        long m = (int)1e9+7;
        public void run() { // check scan function;
            c = new InputReader(System.in);
            w = new PrintWriter(System.out);
     
            int n=c.nextInt(),m=c.nextInt();
            int mat[][] = new int[n][m];
            for(int i=0;i<n;i++) mat[i] = scanArrayI(m);
     
     
            ArrayList<pair> arr=new ArrayList<>();
            int newmat[][] = new int[n][m];
            for(int i=0;i<n;i++){
                for(int j=0;j<m;j++){
                    if(check(mat,i,j)){
                        arr.add(new pair(i+1,j+1));
                        for(int k=i;k<i+2;k++){
                            for(int l=j;l<j+2;l++){
                                newmat[k][l] = 1;
                            }
                        }
                    }
                }
            }
     
            boolean c=true;
            for(int i=0;i<n;i++){
                for(int j=0;j<m;j++){
                    if(mat[i][j]!=newmat[i][j]){
                        c=false;
                    }
                }
            }
            if(c) {
                w.println(arr.size());
                for(pair p:arr){
                    w.println(p);
                }
            }
            else w.println("-1");
     
            w.close();
        }
     
        private boolean check(int[][] mat, int i, int j) {
     
            for(int k=i;k<i+2;k++){
                for(int l=j;l<j+2;l++){
                    if(k>=mat.length || l>=mat[0].length) return false;
                    if(mat[k][l] == 0) return false;
                }
            }
     
            return true;
     
        }
     
        /*Template Stuff*/
        class pair{
            int x;
            int y;
     
            @Override
            public String toString() {
                return  x +
                        " " + y;
            }
     
            public pair(int x, int y) {
                this.x = x;
                this.y = y;
            }
     
        }
        long powmod(long x, long n, long m) {
            if (n == 0) return 1;
            long p = powmod(x, n / 2, m) % m;
            p = (p * p) % m;
            return (n % 2 == 0) ? p : (x * p) % m;
        }
        void sieve(int n) {
            is_prime = new boolean[n+10];
            prime = new ArrayList<>();
            for(int i=2;i<=n;i++)
                is_prime[i] = true;
     
            for (int i = 2; i <= n; ++i) {
                if (is_prime[i]) prime.add(i);
                for (int j = 0; j < prime.size () && i * prime.get(j) < n; ++j) {
                    is_prime[i * prime.get(j)] = false;
                    if (i % prime.get(j) == 0) break;
                }
            }
        }
        public static void sortbyColumn(int arr[][], int col){
            Arrays.sort(arr, new Comparator<int[]>()
            {
                public int compare(int[] o1, int[] o2){
                    return(Integer.valueOf(o1[col]).compareTo(o2[col]));
                }
            });
     
        }
        static long gcd(long a, long b){
            if (b == 0)
                return a;
            return gcd(b, a % b);
        }
        public void printArray(int[] a){
            for(int i=0;i<a.length;i++)
                w.print(a[i]+" ");
            w.println();
        }
        public int[] scanArrayI(int n){
            int a[] = new int[n];
            for(int i=0;i<n;i++)
                a[i] = c.nextInt();
            return a;
        }
        public long[] scanArrayL(int n){
            long a[] = new long[n];
            for(int i=0;i<n;i++)
                a[i] = c.nextLong();
            return a;
        }
        public void printArray(long[] a){
            for(int i=0;i<a.length;i++)
                w.print(a[i]+" ");
            w.println();
        }
        static class InputReader {
            private InputStream stream;
            private byte[] buf = new byte[1024];
            private int curChar;
            private int numChars;
            private SpaceCharFilter filter;
            private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
     
            public InputReader(InputStream stream) {
                this.stream = stream;
            }
     
            public int read() {
                if (numChars==-1)
                    throw new InputMismatchException();
     
                if (curChar >= numChars) {
                    curChar = 0;
                    try {
                        numChars = stream.read(buf);
                    }
                    catch (IOException e) {
                        throw new InputMismatchException();
                    }
     
                    if(numChars <= 0)
                        return -1;
                }
                return buf[curChar++];
            }
     
            public String nextLine() {
                String str = "";
                try {
                    str = br.readLine();
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
                return str;
            }
            public int nextInt() {
                int c = read();
     
                while(isSpaceChar(c))
                    c = read();
     
                int sgn = 1;
     
                if (c == '-') {
                    sgn = -1;
                    c = read();
                }
     
                int res = 0;
                do {
                    if(c<'0'||c>'9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                }
                while (!isSpaceChar(c));
     
                return res * sgn;
            }
     
            public long nextLong() {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                int sgn = 1;
                if (c == '-') {
                    sgn = -1;
                    c = read();
                }
                long res = 0;
     
                do {
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                }
                while (!isSpaceChar(c));
                return res * sgn;
            }
     
            public double nextDouble() {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                int sgn = 1;
                if (c == '-') {
                    sgn = -1;
                    c = read();
                }
                double res = 0;
                while (!isSpaceChar(c) && c != '.') {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                }
                if (c == '.') {
                    c = read();
                    double m = 1;
                    while (!isSpaceChar(c)) {
                        if (c == 'e' || c == 'E')
                            return res * Math.pow(10, nextInt());
                        if (c < '0' || c > '9')
                            throw new InputMismatchException();
                        m /= 10;
                        res += (c - '0') * m;
                        c = read();
                    }
                }
                return res * sgn;
            }
     
            public String readString() {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                StringBuilder res = new StringBuilder();
                do {
                    res.appendCodePoint(c);
                    c = read();
                }
                while (!isSpaceChar(c));
     
                return res.toString();
            }
     
            public boolean isSpaceChar(int c) {
                if (filter != null)
                    return filter.isSpaceChar(c);
                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
            }
     
            public String next() {
                return readString();
            }
     
            public interface SpaceCharFilter {
                public boolean isSpaceChar(int ch);
            }
        }
        public static void main(String args[]) throws Exception {
            new Thread(null, new TaskB(),"TaskB",1<<26).start();
        }
    }