import sys
import math
import collections
import itertools
import array
import inspect

# Set max recursion limit
sys.setrecursionlimit(1000000)


# Debug output
def chkprint(*args):
    names = {
        id(v): k
        for k, v in inspect.currentframe().f_back.f_locals.items()
    }
    print(', '.join(
        names.get(id(arg), '???') + ' = ' + repr(arg) for arg in args))


# Binary converter
def to_bin(x):
    return bin(x)[2:]


def li_input():
    return [int(_) for _ in input().split()]


def gcd(n, m):
    if n % m == 0:
        return m
    else:
        return gcd(m, n % m)


def gcd_list(L):
    v = L[0]

    for i in range(1, len(L)):
        v = gcd(v, L[i])

    return v


def lcm(n, m):
    return (n * m) // gcd(n, m)


def lcm_list(L):
    v = L[0]

    for i in range(1, len(L)):
        v = lcm(v, L[i])

    return v


# Width First Search (+ Distance)
def wfs_d(D, N, K):
    """
    D: 隣接行列(距離付き)
    N: ノード数
    K: 始点ノード
    """

    dfk = [-1] * (N + 1)
    dfk[K] = 0

    cps = [(K, 0)]
    r = [False] * (N + 1)
    r[K] = True
    while len(cps) != 0:
        n_cps = []
        for cp, cd in cps:
            for i, dfcp in enumerate(D[cp]):
                if dfcp != -1 and not r[i]:
                    dfk[i] = cd + dfcp
                    n_cps.append((i, cd + dfcp))
                    r[i] = True

        cps = n_cps[:]

    return dfk


# Depth First Search (+Distance)
def dfs_d(v, pre, dist):
    """
    v:  現在のノード
    pre: １つ前のノード
    dist: 現在の距離

    以下は別途用意する
    D: 隣接リスト(行列ではない)
    D_dfs_d: dfs_d関数で用いる，始点ノードから見た距離リスト
    """

    global D
    global D_dfs_d

    D_dfs_d[v] = dist

    for next_v, d in D[v]:
        if next_v != pre:
            dfs_d(next_v, v, dist + d)

    return


def sigma(N):
    ans = 0
    for i in range(1, N + 1):
        ans += i
    return ans


def comb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2, r + 1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p - 1, r, p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result


# --------------------------------------------

H, W = None, None

def wfs(y, x, desty, destx, R):
    R[y][x] = 1
    
    nextL = [[y, x]]
        
    t = 2
    while len(nextL) != 0:
        for nl in nextL:
            cy, cx = nl
            new_nextL = []
            for dy, dx in zip([-1, 0, 0, 1], [0, 1, -1, 0]):
                    if 0 <= cy + dy < H and 0 <= cx + dx < W and R[cy + dy][cx + dx] == 0:
                        new_nextL.append([cy + dy, cx + dx])
                        R[cy + dy][cx + dx] = t

                        if cy + dy == desty and cx + dx == destx:
                            return R
        
        t += 1
        
        nextL = new_nextL


def main():
    global H
    global W

    H, W = li_input()
    A = [li_input() for _ in range(H)]

    ansL = []

    for i in range(H):
        if i % 2 == 0:
            rng_obj = range(0, W-1)
            is_right = True
        else:
            rng_obj = range(W - 1, 0, -1)
            is_right = False
        
        for j in rng_obj:
            if A[i][j] % 2 == 1:
                if is_right:
                    A[i][j] -= 1
                    A[i][j+1] += 1
                    ansL.append([i, j, i, j + 1])
                else:
                    A[i][j] -= 1
                    A[i][j-1] += 1
                    ansL.append([i, j, i, j - 1])
        
        if i != H - 1:
            if is_right:
                if A[i][-1] % 2 == 1:
                    A[i][-1] -= 1
                    A[i + 1][-1] += 1
                    ansL.append([i, W - 1, i + 1, W - 1])
            else:
                if A[i][0] % 2 == 1:
                    A[i][0] -= 1
                    A[i + 1][0] += 1
                    ansL.append([i, 0, i + 1, 0])
    
    print(len(ansL))

    for l in ansL:
        a, b, c, d = l
        print(a+1, b+1, c+1, d+1)
                
    
                

main()


Measured memory_bytes: 27900