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: from math import sqrt
  from itertools import product
  
  import numpy as np
  
  
  def helper(N, D):
      banned = list()
      for x in range(0, int(sqrt(D / 2)) + 2):
          if D > x * x:
              y = sqrt(D - x * x)
              if y == int(y):
                  y = int(y)
  
                  for a, b in {(x, y), (y, x)}:
                      for s, t in product((1, -1), repeat=2):
                          banned.append((s * a, t * b))
  
      M = N * 2
  
      grid = np.zeros((M, M), dtype=int)
  
      p0 = (0, 0)
      while p0:
          stack = [p0]
          grid[stack[0]] = 1
          while stack:
              x, y = stack.pop()
              t = grid[x, y]
              for dx, dy in banned:
                  xx, yy = x + dx, y + dy
                  if 0 <= xx < M and 0 <= yy < M and grid[xx, yy] == 0:
                      grid[xx, yy] = -t
                      stack.append((xx, yy))
  
          l = np.transpose(np.nonzero(grid == 0))
          if l.size > 0:
              p0 = tuple(l[0])
          else:
              p0 = None
  
      print("A")
      return grid
  
  
  N, D1, D2 = map(int, input().split())
  M = N * 2
  g1 = helper(N, D1)
  g2 = helper(N, D2)
  
  if np.count_nonzero(g1 == 1) * 2 > M * M:
      g1 = g1 == 1
  else:
      g1 = g1 == -1
  
  if np.sum(g1 * g2) > 0:
      ans = g1 & (g2 == 1)
  else:
      ans = g1 & (g2 == -1)
  
  
  # for x,y in np.transpose(np.nonzero(ans))[:N*N]:
  #   print(x,y)
  
  print(ans.astype(int))
  print(np.sum(ans), N * N)
  
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"}]