output_description: Print N^2 distinct points that satisfy the condition in the following format:
  
      
      
      x_1 y_1
      x_2 y_2
      :
      x_{N^2} y_{N^2}
      
  
  Here, (x_i,y_i) represents the i-th chosen point. 0 ≤ x_i,y_i < 2N must hold,
  and they must be integers. The chosen points may be printed in any order. In
  case there are multiple possible solutions, you can output any.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N D_1 D_2
attempt: def main():
      N, D1, D2 = map(int, input().split())
      for i in range(D1):
          if ((D1 - i**2) ** 0.5) % 1 == 0:
              a1 = i
              a2 = int((D1 - i**2) ** 0.5)
              break
      for i in range(D2):
          if ((D2 - i**2) ** 0.5) % 1 == 0:
              b1 = i
              b2 = int((D2 - i**2) ** 0.5)
              break
      A = [[0 for _ in range(2 * N)] for _ in range(2 * N)]
      X = []
      k = 0
      for i in range(2 * N):
          for j in range(2 * N):
              if A[i][j] == 0:
                  X.append([i, j])
                  k += 1
                  if i + a1 < 2 * N:
                      if j + a2 < 2 * N:
                          A[i + a1][j + a2] = 1
                      if j - a2 >= 0:
                          A[i + a1][j - a2] = 1
                  if i + a2 < 2 * N:
                      if j + a1 < 2 * N:
                          A[i + a2][j + a1] = 1
                      if j - a1 >= 0:
                          A[i + a2][j - a1] = 1
                  if i - a1 >= 0:
                      if j + a2 < 2 * N:
                          A[i - a1][j + a2] = 1
                      if j - a2 >= 0:
                          A[i - a1][j - a2] = 1
                  if i - a2 >= 0:
                      if j + a1 < 2 * N:
                          A[i - a2][j + a1] = 1
                      if j - a1 >= 0:
                          A[i - a2][j - a1] = 1
                  if i + b1 < 2 * N:
                      if j + b2 < 2 * N:
                          A[i + b1][j + b2] = 1
                      if j - b2 >= 0:
                          A[i + b1][j - b2] = 1
                  if i + b2 < 2 * N:
                      if j + b1 < 2 * N:
                          A[i + b2][j + b1] = 1
                      if j - b1 >= 0:
                          A[i + b2][j - b1] = 1
                  if i - b1 >= 0:
                      if j + b2 < 2 * N:
                          A[i - b1][j + b2] = 1
                      if j - a2 >= 0:
                          A[i - b1][j - b2] = 1
                  if i - b2 >= 0:
                      if j + b1 < 2 * N:
                          A[i - b2][j + b1] = 1
                      if j - b1 >= 0:
                          A[i - b2][j - b1] = 1
              if k == N**2:
                  break
          if k == N**2:
              break
      for i in range(N**2):
          print(str(X[i][0]) + " " + str(X[i][1]))
  
  
  if __name__ == "__main__":
      main()
  
problem_description: Statement
  
  Takahashi is doing a research on sets of points in a plane. Takahashi thinks a
  set S of points in a coordinate plane is a _good set_ when S satisfies both of
  the following conditions:
  
    * The distance between any two points in S is not \sqrt{D_1}.
    * The distance between any two points in S is not \sqrt{D_2}.
  
  Here, D_1 and D_2 are positive integer constants that Takahashi specified.
  
  Let X be a set of points (i,j) on a coordinate plane where i and j are
  integers and satisfy 0 ≤ i,j < 2N.
  
  Takahashi has proved that, for any choice of D_1 and D_2, there exists a way
  to choose N^2 points from X so that the chosen points form a good set.
  However, he does not know the specific way to choose such points to form a
  good set. Find a subset of X whose size is N^2 that forms a good set.
samples: [{"input": "2 1 2", "output": "0 0\n    0 2\n    2 0\n    2 2\n    \n\nAmong these points, the distance between 2 points is either 2 or 2\\sqrt{2},\nthus it satisfies the condition.\n\n* * *"}, {"input": "3 1 5", "output": "0 0\n    0 2\n    0 4\n    1 1\n    1 3\n    1 5\n    2 0\n    2 2\n    2 4"}]