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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader sc = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.solve(1, sc, out);
        out.close();
    }

    static class Task {
        public void solve(int testNumber, InputReader sc, PrintWriter out) {
            int n=sc.nextInt();
            int m=sc.nextInt();
            int[][] A=new int[n+2][m+2];
            
            for(int i=1;i<=n;i++) {
            	for(int j=1;j<=m;j++)
            		A[i][j]=sc.nextInt();
            }
            boolean[][] jud=new boolean[n+1][m+1];
            boolean flag=true;
            for(int i=1;i<=n;i++) {
            	for(int j=1;j<=m;j++) {
            		if(A[i][j]==1) {
            			boolean f=false;
            			if(A[i-1][j-1]==1&&A[i-1][j]==1&&A[i][j-1]==1)
            				f=true;
            			if(A[i-1][j]==1&&A[i-1][j+1]==1&&A[i][j+1]==1)
            				f=true;
            			if(A[i][j-1]==1&&A[i+1][j-1]==1&&A[i+1][j]==1)
            				f=true;
            			if(A[i][j+1]==1&&A[i+1][j+1]==1&&A[i+1][j]==1)
            				f=true;
            			if(!f)
            				flag=false;
            		}
            	}
            }
            if(!flag) {
            	out.println("-1");
            	return ;
            }
            ArrayList<Node> res=new ArrayList<Node>();
            for(int i=1;i<=n;i++) {
            	for(int j=1;j<=m;j++) {
            		if(A[i][j]==1&&!jud[i][j]) {
            			jud[i][j]=true;
            			if(A[i][j+1]==1&&A[i+1][j+1]==1&&A[i+1][j]==1) {
            				res.add(new Node(i,j));
            				jud[i][j+1]=true;
            				jud[i+1][j+1]=true;
            				jud[i+1][j]=true;
            				continue;
            			}
            			if(A[i-1][j]==1&&A[i-1][j+1]==1&&A[i][j+1]==1) {
            				res.add(new Node(i-1,j));
            				jud[i-1][j]=true;
            				jud[i-1][j+1]=true;
            				jud[i][j+1]=true;
            				continue;
            			}
            			if(A[i-1][j-1]==1&&A[i-1][j]==1&&A[i][j-1]==1) {
            				res.add(new Node(i-1,j-1));
            				jud[i-1][j-1]=true;
            				jud[i-1][j]=true;
            				jud[i][j-1]=true;
            				continue;
            			}
            			if(A[i][j-1]==1&&A[i+1][j-1]==1&&A[i+1][j]==1) {
            				res.add(new Node(i,j-1));
            				jud[i][j-1]=true;
            				jud[i+1][j-1]=true;
            				jud[i+1][j]=true;
            				continue;
            			}
            		}
            	}
            }
            out.println(res.size());
            for(Node temp:res)
            	out.println(temp.x+" "+temp.y);
        } 

    }

    static class Node implements Comparable<Node>{
    	public int x;
    	public int y;
    	
    	public Node(int x,int y) {
    		this.x=x;
    		this.y=y;
    	}

		@Override
		public int compareTo(Node o) {
			if(this.x!=o.x)
				return this.x-o.x;
			return this.x-o.y;
		}
    }
    
    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

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

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

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

    }
}
