Problem:
Score : 800 points

Problem 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.

Constraints

1 ≤ N ≤ 300

1 ≤ D_1 ≤ 2×10^5

1 ≤ D_2 ≤ 2×10^5

All values in the input are integers.

Input

Input is given from Standard Input in the following format:

N D_1 D_2

Output

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.

Sample Input 1

2 1 2

Sample Output 1

0 0
0 2
2 0
2 2

Among these points, the distance between 2 points is either 2 or 2\sqrt{2}, thus it satisfies the condition.

Sample Input 2

3 1 5

Sample Output 2

0 0
0 2
0 4
1 1
1 3
1 5
2 0
2 2
2 4

Solution in PyPy3 (2.4.0) (judge verdict: Runtime Error)

import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 998244353

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)


def main():
    n,d1,d2 = LI()
    nn = n**2
    n2 = n*2
    r = []
    t = []
    for i in range(n*2):
        ii = i**2
        for j in range(i, n*2):
            jj = j**2
            if ii+jj == d1 or ii+jj == d2:
                t.append((i,j))
                t.append((i,-j))
                t.append((-i,j))
                t.append((-i,-j))
                if i != j:
                    t.append((j,i))
                    t.append((j,-i))
                    t.append((-j,i))
                    t.append((-j,-i))
    t = list(set(t))

    def tf(c):
        f = [[None] * (n*2) for _ in range(n*2)]
        r = []
        tt = []
        ttt = [[] for _ in range(c)]
        for i in range(n*2 // c + 1):
            for ii in range(i*c,(i+1)+c):
                ttt[ii%c].append(i)
        for ti in ttt:
            tt += ti
        for i in tt:
            for j in range(n*2):
                if not f[i][j] is None:
                    continue
                f[i][j] = 1
                r.append((i,j))
                if len(r) == nn:
                    break
                for di,dj in t:
                    ni = i + di
                    nj = j + dj
                    if 0 <= ni < n2 and 0 <= nj < n2:
                        f[ni][nj] = 1
            if len(r) == nn:
                break
        return r

    rc = 1
    r = tf(rc)
    while len(r) != nn:
        rc += 1
        r = tf(rc)

    return '\n'.join(map(lambda x: '{} {}'.format(x[0],x[1]), r))


print(main())