#![allow(unused_imports)]
use proconio::{input, marker::*};
use itertools::*;

const N: usize = 20;

struct Input {
    T: usize,
    A: Vec<Vec<i32>>,
}

fn solve(input: &Input) -> Vec<(usize, usize)> {
    let mut dp = vec![vec![vec![vec![(0, 0, 0, 0, 0); 3]; N]; N]; input.T];
    for (i, j) in iproduct!(0..N, 0..N) {
        dp[0][i][j][0] = (input.A[i][j], 0, 0, 0, 0);
    }

    const D: usize = 0;
    const R: usize = 1;
    const L: usize = 2;

    for t in 0..input.T - 1 {
        for (i, j) in iproduct!(0..N, 0..N) {
            for d in 0..3 {
                let s = dp[t][i][j][d].0;

                // down
                if i + 1 < N {
                    let s1 = s + input.A[i + 1][j];
                    if dp[t + 1][i + 1][j][D].0 < s1 {
                        dp[t + 1][i + 1][j][D] = (s1, t, i, j, d);
                    }
                }

                // left
                if d != R && j > 0 {
                    let s1 = s + input.A[i][j - 1];
                    if dp[t + 1][i][j - 1][L].0 < s1 {
                        dp[t + 1][i][j - 1][L] = (s1, t, i, j, d);
                    }
                }

                // right
                if d != L && j + 1 < N {
                    let s1 = s + input.A[i][j + 1];
                    if dp[t + 1][i][j + 1][R].0 < s1 {
                        dp[t + 1][i][j + 1][R] = (s1, t, i, j, d);
                    }
                }
            }
        }
    }

    let (mut i, mut j, mut d) = iproduct!(0..N, 0..N, 0..3)
        .max_by_key(|&(i, j, d)| dp[input.T - 1][i][j][d].0)
        .unwrap();

    let mut rev_ans = vec![(i, j)];
    eprintln!("{i} {j} {d} {:?}", dp[input.T - 1][i][j][d]);
    for t in (1..input.T).rev() {
        let (_, _, i1, j1, d1) = dp[t][i][j][d];
        rev_ans.push((i1, j1));
        i = i1;
        j = j1;
        d = d1;
    }

    rev_ans.reverse();
    rev_ans
}

fn main() {
    input!{
        _N: usize,
        T: usize,
        A: [[i32; N]; N],
    }

    let input = Input{T, A};

    let ans = solve(&input);
    println!("{}", ans.len());
    for (i, j) in ans { println!("{i} {j}"); }
}