Problem:
Score : 400 points

Problem Statement

We have a grid with H rows and W columns. The square at the i-th row and the j-th column will be called Square (i,j).

The integers from 1 through H×W are written throughout the grid, and the integer written in Square (i,j) is A_{i,j}.

You, a magical girl, can teleport a piece placed on Square (i,j) to Square (x,y) by consuming |x-i|+|y-j| magic points.

You now have to take Q practical tests of your ability as a magical girl.

The i-th test will be conducted as follows:

Initially, a piece is placed on the square where the integer L_i is written.

Let x be the integer written in the square occupied by the piece. Repeatedly move the piece to the square where the integer x+D is written, as long as x is not R_i. The test ends when x=R_i.

Here, it is guaranteed that R_i-L_i is a multiple of D.

For each test, find the sum of magic points consumed during that test.

Constraints

1 \leq H,W \leq 300

1 \leq D \leq H×W

1 \leq A_{i,j} \leq H×W

A_{i,j} \neq A_{x,y} ((i,j) \neq (x,y))

1 \leq Q \leq 10^5

1 \leq L_i \leq R_i \leq H×W

(R_i-L_i) is a multiple of D.

Input

Input is given from Standard Input in the following format:

H W D
A_{1,1} A_{1,2} ... A_{1,W}
:
A_{H,1} A_{H,2} ... A_{H,W}
Q
L_1 R_1
:
L_Q R_Q

Output

For each test, print the sum of magic points consumed during that test.

Output should be in the order the tests are conducted.

Sample Input 1

3 3 2
1 4 3
2 5 7
8 9 6
1
4 8

Sample Output 1

5

4 is written in Square (1,2).

6 is written in Square (3,3).

8 is written in Square (3,1).

Thus, the sum of magic points consumed during the first test is (|3-1|+|3-2|)+(|3-3|+|1-3|)=5.

Sample Input 2

4 2 3
3 7
1 4
5 2
6 8
2
2 2
2 2

Sample Output 2

0
0

Note that there may be a test where the piece is not moved at all, and there may be multiple identical tests.

Sample Input 3

5 5 4
13 25 7 15 17
16 22 20 2 9
14 11 12 1 19
10 6 23 8 18
3 21 5 24 4
3
13 13
2 10
13 13

Sample Output 3

0
5
0

Solution in Rust (1.15.1) (judge verdict: Time Limit Exceeded)

#[allow(unused_macros)]
macro_rules! parse_line {
    ( $t:ty ) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            iter.next().unwrap().parse::<$t>().unwrap()
        }
    );

    ( $( $t:ty), +) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            ( $(iter.next().unwrap().parse::<$t>().unwrap()),* )
        }
    );
}

#[allow(unused_macros)]
macro_rules! read_line {
    () => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            line.pop();
            line
        }
    )
}

#[allow(unused_macros)]
macro_rules! parse_vec {
    ( $t:ty ) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let iter = line.split_whitespace();
            iter.map(|v| v.parse::<$t>().unwrap()).collect::<Vec<_>>()
        }
    )
}

#[allow(dead_code)]
fn parse_table_ws<T>(n: usize) -> Vec<Vec<T>>
where T: std::str::FromStr, <T as std::str::FromStr>::Err: std::fmt::Debug
{
    (0..n).map(|_| read_line!().split_whitespace().map(|s| s.parse().unwrap()).collect::<Vec<_>>())
        .collect::<Vec<Vec<_>>>()
}

fn solve(d: i32, aa: Vec<Vec<i32>>, lrs: Vec<(i32, i32)>) -> Vec<i32> {

    let mut m = std::collections::HashMap::new();

    for (r, v) in aa.iter().enumerate() {
        for (c, a) in v.iter().enumerate() {
            m.insert(a, (r as i32,c as i32));
        }
    }

    let mut ans = Vec::new();

    let mut memo = std::collections::HashMap::new();

    for (mut l, r) in lrs {
        if let Some(dis) = memo.get(&(l,r)) {
            ans.push(*dis);
            continue;
        }

        let mut memo_vec = Vec::new();
        let ls = l;
        let mut dis = 0;
        let &(mut lx, mut ly) = m.get(&l).unwrap();
        while l < r {
            l += d;
            let &(x, y) = m.get(&l).unwrap();
            dis += (x-lx).abs() + (y-ly).abs();
            lx = x; ly = y;
            memo_vec.push((l, dis))
        }
        ans.push(dis);

        for (l,d) in memo_vec {
            memo.insert((l,r), dis - d);
            memo.insert((ls, l), d);
        }
    }

    ans
}

fn main() {
    let (h, _w, d) = parse_line!(usize, usize, i32);
    let aa = parse_table_ws(h);
    let q = parse_line!(usize);
    let lrs = (0..q).map(|_| parse_line!(i32, i32)).collect::<Vec<_>>();

    for v in solve(d, aa, lrs) {
        println!("{}", v);
    }
}

#[test]
fn solve_test() {
    assert_eq!(solve(2, vec![vec![1,4,3],
                             vec![2,5,7],
                             vec![8,9,6]],
                     vec![(4,8)]), vec![5]);

    assert_eq!(solve(3, vec![vec![4,7],
                             vec![1,4],
                             vec![5,2],
                             vec![6,8]],
                     vec![(2,2), (2,2)]), vec![0,0]);

    assert_eq!(solve(4, vec![vec![13,25,7,15,17],
                             vec![16,22,20,2,9],
                             vec![14,11,12,1,19],
                             vec![10,6,23,8,18],
                             vec![3,21,5,24,4]],
                     vec![(13,13), (2,10), (13,13)]), vec![0,5,0]);

    assert_eq!(solve(1,
                     (0..300).map(|i| ((i*300+1)..((i+1)*300+1)).collect::<Vec<_>>()).collect::<Vec<Vec<_>>>(),
                     vec![(1,90000)]), vec![(299+300)*299 + 299]);
}