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 Common Lisp (SBCL 1.1.14) (judge verdict: Wrong Answer)

;; -*- coding:utf-8 -*-

(eval-when (:compile-toplevel :load-toplevel :execute)
  (defparameter O3 '(optimize (speed 3) (safety 0) (debug 0)))
  (defparameter O2 '(optimize (speed 3) (safety 1))))

(defmacro print-line (obj &optional (stream '*standard-output*))
  `(prog1 (princ ,obj ,stream) (terpri ,stream)))


;; Hauptteil

(defmacro split-and-bind (arg-lst string &body body)
  (let ((pos1 (gensym "POS"))
	(pos2 (gensym "POS"))
	(str-evaled (gensym "STR")))
    (labels ((expand (arg-lst &optional (init-pos1 t))
	       (if (null arg-lst)
		   body
		   `((let* ((,pos1 ,(if init-pos1 0 `(1+ ,pos2)))
			    (,pos2 (position #\space ,str-evaled :start ,pos1 :test #'char=))
			    (,(car arg-lst) (parse-integer ,str-evaled :start ,pos1 :end ,pos2)))
		       ,@(expand (cdr arg-lst) nil))))))
      `(let ((,str-evaled ,string))
	 ,@(expand arg-lst)))))

(declaim (inline l1-norm))
(defun l1-norm (x1 y1 x2 y2)
  (+ (abs (- x1 x2)) (abs (- y1 y2))))

(deftype unum nil `(integer 0 ,(expt 10 9)))
(defun main ()
  (declare #.O3)
  (let* ((height (read))
	 (width (read))
	 (delta (read))
	 (adict-row (make-array (+ (* width height) 1)
				:initial-element -1 :element-type 'fixnum))
	 (adict-col (make-array (+ (* width height) 1)
				:initial-element -1 :element-type 'fixnum)))
    (declare (unum width height delta))
    (loop for row from 1 to height do
	 (loop for col from 1 to width do
	      (let ((a (read)))
		(setf (aref adict-row a) row)
		(setf (aref adict-col a) col))))
    (let* ((q (read))
	   (l-arr (make-array q :initial-element 0 :element-type 'fixnum))
	   (r-arr (make-array q :initial-element 0 :element-type 'fixnum))
	   (cache (make-hash-table :test #'eql)))
      (dotimes (idx q)
	(split-and-bind (l r) (the string (read-line))
	  (setf (aref l-arr idx) l
		(aref r-arr idx) r)))
      (labels ((get-mp (start left left-row left-col dest mp-consumed)
		 (declare (unum start left dest))
		 (multiple-value-bind (val exists)
		     (gethash (* left dest) cache)
		   (if exists
		       (+ mp-consumed val)
		       (multiple-value-bind (val exists)
			   (gethash (* start left) cache)
			 (unless exists
			   (setf (gethash (* start left) cache) mp-consumed))
			 (if (= left dest)
			     (progn
			       (setf (gethash (* start dest) cache) mp-consumed)
			       mp-consumed)
			     (let* ((next-left (+ left delta))
				    (next-row (aref adict-row next-left))
				    (next-col (aref adict-col next-left)))
			       (get-mp
				start
				next-left
				next-row
				next-col
				dest
				(+ mp-consumed
				   (l1-norm left-row left-col next-row next-col))))))))))
	(loop for idx from 0 below q
	   do (print-line
	       (let* ((left (aref l-arr idx))
		      (right (aref r-arr idx))
		      (left-row (aref adict-row left))
		      (left-col (aref adict-col left)))
		 (get-mp left left left-row left-col right 0))))))))
		   


#-swank(main)


;; Für Test
(defun get-clipbrd ()
  (with-output-to-string (out)
    (run-program "C:/msys64/usr/bin/cat.exe" '("/dev/clipboard") :output out)))

(defun test ()
  (with-input-from-string (*standard-input* (delete #\return (get-clipbrd)))
    (main)))


;; Für Benchmark
(defparameter *file-path* *load-pathname*)
(defparameter *dir-path* (pathname (directory-namestring *file-path*)))
(defparameter *dat-path* (merge-pathnames "test.dat" *dir-path*))

#+swank
(defun gendat ()
  (with-open-file (out *dat-path*
		       :direction :output :if-exists :supersede)
    ))

(defun bench ()
  (let ((*standard-output* (make-broadcast-stream)))
    (with-open-file (*standard-input* *dat-path*)
      (time (main)))))