use std::io::{ stdin, stdout, BufRead, Write };
use std::ops::{ Add, Sub, Mul };

const SP   : u8 = b' ';
const LF   : u8 = b'\n';
const ZERO : u8 = b'0';

const DIGITS1 : [&'static[u8; 1]; 10] = [
  b"0", b"1", b"2", b"3", b"4", b"5", b"6", b"7", b"8", b"9"];
const DIGITS2 : [&'static[u8; 2]; 100] = [
  b"00", b"01", b"02", b"03", b"04", b"05", b"06", b"07", b"08", b"09",
  b"10", b"11", b"12", b"13", b"14", b"15", b"16", b"17", b"18", b"19",
  b"20", b"21", b"22", b"23", b"24", b"25", b"26", b"27", b"28", b"29",
  b"30", b"31", b"32", b"33", b"34", b"35", b"36", b"37", b"38", b"39",
  b"40", b"41", b"42", b"43", b"44", b"45", b"46", b"47", b"48", b"49",
  b"50", b"51", b"52", b"53", b"54", b"55", b"56", b"57", b"58", b"59",
  b"60", b"61", b"62", b"63", b"64", b"65", b"66", b"67", b"68", b"69",
  b"70", b"71", b"72", b"73", b"74", b"75", b"76", b"77", b"78", b"79",
  b"80", b"81", b"82", b"83", b"84", b"85", b"86", b"87", b"88", b"89",
  b"90", b"91", b"92", b"93", b"94", b"95", b"96", b"97", b"98", b"99"];

#[inline(always)]
fn uitoa(mut n: usize, buf: &mut Vec<u8>) {
  buf.clear();

  if n <= 9 {
    buf.extend_from_slice(DIGITS1[n]);
    return;
  }

  if n <= 99 {
    buf.extend_from_slice(DIGITS2[n]);
    return;
  }

  if n <= 9_99 {
    buf.extend_from_slice(DIGITS1[n / 1_00]);
    buf.extend_from_slice(DIGITS2[n % 1_00]);
    return;
  }

  if n <= 99_99 {
    buf.extend_from_slice(DIGITS2[n / 1_00]);
    buf.extend_from_slice(DIGITS2[n % 1_00]);
    return;
  }

  if n <= 9_99_99 {
    buf.extend_from_slice(DIGITS1[n / 1_00_00]);
    n %= 1_00_00;
    buf.extend_from_slice(DIGITS2[n / 1_00]);
    buf.extend_from_slice(DIGITS2[n % 1_00]);
    return;
  }

  if n <= 99_99_99 {
    buf.extend_from_slice(DIGITS2[n / 1_00_00]);
    n %= 1_00_00;
    buf.extend_from_slice(DIGITS2[n / 1_00]);
    buf.extend_from_slice(DIGITS2[n % 1_00]);
    return;
  }

  if n <= 9_99_99_99 {
    buf.extend_from_slice(DIGITS1[n / 1_00_00_00]);
    n %= 1_00_00_00;
    buf.extend_from_slice(DIGITS2[n / 1_00_00]);
    n %= 1_00_00;
    buf.extend_from_slice(DIGITS2[n / 1_00]);
    buf.extend_from_slice(DIGITS2[n % 1_00]);
    return;
  }

  if n <= 99_99_99_99 {
    buf.extend_from_slice(DIGITS2[n / 1_00_00_00]);
    n %= 1_00_00_00;
    buf.extend_from_slice(DIGITS2[n / 1_00_00]);
    n %= 1_00_00;
    buf.extend_from_slice(DIGITS2[n / 1_00]);
    buf.extend_from_slice(DIGITS2[n % 1_00]);
    return;
  }

  if n <= 9_99_99_99_99 {
    buf.extend_from_slice(DIGITS1[n / 1_00_00_00_00]);
    n %= 1_00_00_00_00;
    buf.extend_from_slice(DIGITS2[n / 1_00_00_00]);
    n %= 1_00_00_00;
    buf.extend_from_slice(DIGITS2[n / 1_00_00]);
    n %= 1_00_00;
    buf.extend_from_slice(DIGITS2[n / 1_00]);
    buf.extend_from_slice(DIGITS2[n % 1_00]);
    return;
  }

  // 32-bit usize::max_value() 42_94_96_72_96
  buf.extend_from_slice(DIGITS2[n / 1_00_00_00_00]);
  n %= 1_00_00_00_00;
  buf.extend_from_slice(DIGITS2[n / 1_00_00_00]);
  n %= 1_00_00_00;
  buf.extend_from_slice(DIGITS2[n / 1_00_00]);
  n %= 1_00_00;
  buf.extend_from_slice(DIGITS2[n / 1_00]);
  buf.extend_from_slice(DIGITS2[n % 1_00]);
}

#[inline(always)]
fn atoui<T>(s: &[u8]) -> T
  where T: Add<Output=T> +
           Sub<Output=T> +
           Mul<Output=T> +
           Default +
           From<u8>
{
  let mut n = T::default();
  if s.len() == 0 {
    return n;
  }

  let mut i = 0;
  if s[i] == b'+' {
    i += 1;
  }

  for b in &s[i..] {
    n = (n * T::from(10)) + T::from(b - ZERO);
  }

  n
}

fn main() {
  let stdin = stdin();
  let mut stdin = stdin.lock();

  let mut buf = Vec::with_capacity(500 * 2);
  let len = stdin.read_until(SP, &mut buf).unwrap();
  buf.truncate(len - 1);
  let h = atoui::<usize>(&buf);

  buf.clear();
  let len = stdin.read_until(LF, &mut buf).unwrap();
  buf.truncate(len - 1);
  let w = atoui::<usize>(&buf);

  let mut num = Vec::with_capacity(3);
  let mut ans = Vec::new();
  let mut n   = 0;

  let mut odd = 0;
  let mut x   = 0;
  let mut y   = 0;

  for i in 0..h {
    buf.clear();
    stdin.read_until(LF, &mut buf).unwrap();

    if i % 2 == 0 {
      for j in 0..w {
        if odd != 0 {
          uitoa(y + 1, &mut num);
          num.push(SP);
          ans.write(&num).unwrap();

          uitoa(x + 1, &mut num);
          num.push(SP);
          ans.write(&num).unwrap();

          uitoa(i + 1, &mut num);
          num.push(SP);
          ans.write(&num).unwrap();

          uitoa(j + 1, &mut num);
          num.push(LF);
          ans.write(&num).unwrap();

          n += 1;
        }
        odd ^= buf[j * 2] & 1;
        y = i;
        x = j;
      }
    } else {
      for mut j in 0..w {
        j = w - 1 - j;

        if odd != 0 {
          uitoa(y + 1, &mut num);
          num.push(SP);
          ans.write(&num).unwrap();

          uitoa(x + 1, &mut num);
          num.push(SP);
          ans.write(&num).unwrap();

          uitoa(i + 1, &mut num);
          num.push(SP);
          ans.write(&num).unwrap();

          uitoa(j + 1, &mut num);
          num.push(LF);
          ans.write(&num).unwrap();

          n += 1;
        }
        odd ^= buf[j * 2] & 1;
        y = i;
        x = j;
      }
    }
  }

  let stdout = stdout();
  let mut stdout = stdout.lock();

  uitoa(n, &mut buf);
  buf.push(LF);
  stdout.write(&buf).unwrap();

  stdout.write(&ans).unwrap();
  stdout.flush().unwrap();
}


Measured memory_bytes: 8188