output_description: For each test, print the sum of magic points consumed during that test.
  
  Output should be in the order the tests are conducted.
  
  * * *
input_description: 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
attempt: # import numpy as np
  # import math
  def getInt():
      return int(input())
  
  
  def getIntList():
      return [int(x) for x in input().split()]
  
  
  def zeros(n):
      return [0] * n
  
  
  def zeros2(n, m):
      return [zeros(m)] * n  # obsoleted zeros((n, m))で代替
  
  
  def getIntLines(n):
      return [int(input()) for i in range(n)]
  
  
  def getIntMat(n, m):  # n行に渡って、1行にm個の整数
      mat = zeros2(n, m)
      for i in range(n):
          mat[i] = getIntList()
      return mat
  
  
  ALPHABET = [chr(i + ord("a")) for i in range(26)]
  DIGIT = [chr(i + ord("0")) for i in range(10)]
  N1097 = 10**9 + 7
  INF = 10**18
  
  
  class Debug:
      def __init__(self):
          self.debug = True
  
      def off(self):
          self.debug = False
  
      def dmp(self, x, cmt=""):
          if self.debug:
              if cmt != "":
                  print(cmt, ":  ", end="")
              print(x)
          return x
  
  
  def prob():
      d = Debug()
      d.off()
      H, W, D = getIntList()
      d.dmp((H, W, D), "H, W, D")
      A = getIntMat(H, W)
      d.dmp(A)
      p = zeros(H * W + 1)
      for i in range(H):
          for j in range(W):
              p[A[i][j]] = [i, j]
      d.dmp(p)
      Q = getInt()
      d.dmp(Q)
      for i in range(Q):
          mp = 0
          L, R = getIntList()
          intX = A[p[L][0]][p[L][1]]
          while intX is not R:
              x = p[intX][0]
              y = p[intX][1]
              d.dmp((intX, x, y, mp), "intX, x, y, mp")
              intX += D
              nx = p[intX][0]
              ny = p[intX][1]
              mp += abs(x - nx) + abs(y - ny)
              d.dmp((intX, nx, ny, mp), "intX, nx, ny, mp")
          d.dmp((L, R, mp), "L, R, mp")
          print(mp)
      return None
  
  
  ans = prob()
  if ans is None:
      pass
  elif type(ans) == list and ans[0] == "col":
      for elm in ans[1]:
          print(elm)
  else:
      print(ans)
  
problem_description: 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.
samples: [{"input": "3 3 2\n    1 4 3\n    2 5 7\n    8 9 6\n    1\n    4 8", "output": "5\n    \n\n  * 4 is written in Square (1,2).\n\n  * 6 is written in Square (3,3).\n\n  * 8 is written in Square (3,1).\n\nThus, the sum of magic points consumed during the first test is\n(|3-1|+|3-2|)+(|3-3|+|1-3|)=5.\n\n* * *"}, {"input": "4 2 3\n    3 7\n    1 4\n    5 2\n    6 8\n    2\n    2 2\n    2 2", "output": "0\n    0\n    \n\nNote that there may be a test where the piece is not moved at all, and there\nmay be multiple identical tests.\n\n* * *"}, {"input": "5 5 4\n    13 25 7 15 17\n    16 22 20 2 9\n    14 11 12 1 19\n    10 6 23 8 18\n    3 21 5 24 4\n    3\n    13 13\n    2 10\n    13 13", "output": "0\n    5\n    0"}]