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} 
'''input
3 3
1 1 1
1 1 1
0 1 1

'''
import sys
from collections import defaultdict as dd
from itertools import  permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
from  heapq import heappush as hpush
from heapq import heappop as hpop
mod=10**9+7

def ri(flag=0):
	if flag==0:
		return [int(i) for i in sys.stdin.readline().split()]
	else:
		return int(sys.stdin.readline())


n , m =ri()

b = []
a = [[0 for i in range(m)] for j in range(n)]

for i in range(n):
	b.append(ri())

ans =[]

for i in range(n-1):
	for j in range(m-1):
		#if (a[i][j+1]==0 and b[i][j+1]==1) or (a[i+1][j]==0 and b[i+1][j]==1) or (a[i][j]==0 and b[i][j]==1) or (a[i+1][j+1]==0 and b[i+1][j+1]==1):
		if b[i][j] + b[i+1][j] + b[i][j+1] +b[i+1][j+1] ==4:
			a[i][j]=1
			a[i+1][j]=1
			a[i][j+1]=1
			a[i+1][j+1]=1
			ans.append((i,j))


status =1

for i in range(n):
	for j in range(m):
		status = status &(a[i][j]==b[i][j])

if status:
	print(len(ans))
	for i, j in ans:
		print(i+1,j+1)
else:
	print(-1)

