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: # ■標準入力ショートカット
  
  
  def get_next_int():
      return int(float(input()))
  
  
  def get_next_ints(delim=" "):
      return tuple([int(float(x)) for x in input().split(delim)])
  
  
  def get_next_str():
      return input()
  
  
  def get_next_strs(delim=" "):
      return tuple(input().split(delim))
  
  
  def get_next_by_types(*value_types, delim=" "):
      return tuple([t(x) for t, x in zip(value_types, input().split(delim))])
  
  
  class PracticalSkillTest:
  
      def __init__(self):
          self.H, self.W, self.D = get_next_ints()
          self.field = []
          for _ in range(self.H):
              self.field.append(get_next_ints())
          self.Q = get_next_int()
          self.places = []
          for _ in range(self.Q):
              self.places.append(get_next_ints())
          self.mapping()
          self.dp = [[-1] * (self.H * self.W) for i in range(self.H * self.W)]
  
      def mapping(self):
          self.mapping_dic = {}
          for y in range(self.H):
              for x in range(self.W):
                  self.mapping_dic[self.field[y][x]] = (x, y)
  
      def get_consumption(self, num):
          start = self.places[num][0]
          end = self.places[num][1]
          if self.dp[start][end] != -1:
              return self.dp[start][end]
          pos = self.mapping_dic[start]
          cost = 0
          for i in range(start + self.D, end + 1, self.D):
              next_pos = self.mapping_dic[i]
              cost += abs(pos[0] - next_pos[0]) + abs(pos[1] - next_pos[1])
              pos = next_pos
          self.dp[start][end] = cost
          return cost
  
      def practice_solve(self):
          for i in range(self.Q):
              cost = self.get_consumption(i)
              print(cost)
  
  
  def solve():
      p = PracticalSkillTest()
      p.practice_solve()
  
  
  solve()
  
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"}]