output_description: For each query, print the number of the connected components consisting of
  blue squares in the region.
  
  * * *
input_description: The input is given from Standard Input in the following format:
  
      
      
      N M Q
      S_{1,1}..S_{1,M}
      :
      S_{N,1}..S_{N,M}
      x_{1,1} y_{i,1} x_{i,2} y_{i,2}
      :
      x_{Q,1} y_{Q,1} x_{Q,2} y_{Q,2}
attempt: N, M, Q = map(int, input().split())
  G = [input() for i in range(N)]
  node = [[0] * (M + 1)]
  edge_x = [[0] * M]
  edge_y = [[0] * (M + 1)]
  for i in range(1, N + 1):
      n, e_x, e_y = [0], [0], [0]
      for j in range(1, M + 1):
          if G[i - 1][j - 1] == "1":
              n.append(n[-1] + node[i - 1][j] - node[i - 1][j - 1] + 1)
          else:
              n.append(n[-1] + node[i - 1][j] - node[i - 1][j - 1])
          if j < M:
              if G[i - 1][j - 1] == "1" and G[i - 1][j] == "1":
                  e_x.append(e_x[-1] + edge_x[i - 1][j] - edge_x[i - 1][j - 1] + 1)
              else:
                  e_x.append(e_x[-1] + edge_x[i - 1][j] - edge_x[i - 1][j - 1])
          if i < N:
              if G[i - 1][j - 1] == "1" and G[i][j - 1] == "1":
                  e_y.append(e_y[-1] + edge_y[i - 1][j] - edge_y[i - 1][j - 1] + 1)
              else:
                  e_y.append(e_y[-1] + edge_y[i - 1][j] - edge_y[i - 1][j - 1])
  
      node.append(n)
      edge_x.append(e_x)
      if i < N:
          edge_y.append(e_y)
  
  for q in range(Q):
      x1, y1, x2, y2 = map(int, input().split())
      n = node[x2][y2] - node[x1 - 1][y2] - node[x2][y1 - 1] + node[x1 - 1][y1 - 1]
      e_y = (
          edge_y[x2 - 1][y2]
          - edge_y[x1 - 1][y2]
          - edge_y[x2 - 1][y1 - 1]
          + edge_y[x1 - 1][y1 - 1]
      )
      e_x = (
          edge_x[x2][y2 - 1]
          - edge_x[x1 - 1][y2 - 1]
          - edge_x[x2][y1 - 1]
          + edge_x[x1 - 1][y1 - 1]
      )
      e = e_x + e_y
      print(n - e)
  
problem_description: Statement
  
  Nuske has a grid with N rows and M columns of squares. The rows are numbered 1
  through N from top to bottom, and the columns are numbered 1 through M from
  left to right. Each square in the grid is painted in either blue or white. If
  S_{i,j} is 1, the square at the i-th row and j-th column is blue; if S_{i,j}
  is 0, the square is white. For every pair of two blue square a and b, there is
  at most one path that starts from a, repeatedly proceeds to an adjacent (side
  by side) blue square and finally reaches b, without traversing the same square
  more than once.
  
  Phantom Thnook, Nuske's eternal rival, gives Q queries to Nuske. The i-th
  query consists of four integers x_{i,1}, y_{i,1}, x_{i,2} and y_{i,2} and asks
  him the following: when the rectangular region of the grid bounded by (and
  including) the x_{i,1}-th row, x_{i,2}-th row, y_{i,1}-th column and
  y_{i,2}-th column is cut out, how many connected components consisting of blue
  squares there are in the region?
  
  Process all the queries.
samples: [{"input": "3 4 4\n    1101\n    0110\n    1101\n    1 1 3 4\n    1 1 3 1\n    2 2 3 4\n    1 2 2 4", "output": "3\n    2\n    2\n    2\n    \n\n![](https://atcoder.jp/img/agc015/7aa4a2252f50a19fc18e0cec01368a2a.png)\n\nIn the first query, the whole grid is specified. There are three components\nconsisting of blue squares, and thus 3 should be printed.\n\nIn the second query, the region within the red frame is specified. There are\ntwo components consisting of blue squares, and thus 2 should be printed. Note\nthat squares that belong to the same component in the original grid may belong\nto different components.\n\n* * *"}, {"input": "5 5 6\n    11010\n    01110\n    10101\n    11101\n    01010\n    1 1 5 5\n    1 2 4 5\n    2 3 3 4\n    3 3 3 3\n    3 1 3 5\n    1 1 3 4", "output": "3\n    2\n    1\n    1\n    3\n    2"}]