Jumbo Takahashi will play golf on an infinite two-dimensional grid.
The ball is initially at the origin (0, 0), and the goal is a grid point (a point with integer coordinates) (X, Y). In one stroke, Jumbo Takahashi can perform the following operation:
 - Choose a grid point whose Manhattan distance from the current position of the ball is K, and send the ball to that point.
The game is finished when the ball reaches the goal, and the score will be the number of strokes so far. Jumbo Takahashi wants to finish the game with the lowest score possible.
Determine if the game can be finished. If the answer is yes, find one way to bring the ball to the goal with the lowest score possible.
What is Manhattan distance?
The Manhattan distance between two points (x_1, y_1) and (x_2, y_2) is defined as |x_1-x_2|+|y_1-y_2|.

-----Constraints-----
 - All values in input are integers.
 - 1 \leq K \leq 10^9
 - -10^5 \leq X, Y \leq 10^5
 - (X, Y) \neq (0, 0)

-----Input-----
Input is given from Standard Input in the following format:
K
X Y

-----Output-----
If the game cannot be finished, print -1.
If the game can be finished, print one way to bring the ball to the destination with the lowest score possible, in the following format:
s
x_1 y_1
x_2 y_2
.
.
.
x_s y_s

Here, s is the lowest score possible, and (x_i, y_i) is the position of the ball just after the i-th stroke.

-----Sample Input-----
11
-1 2

-----Sample Output-----
3
7 4
2 10
-1 2

 - The Manhattan distance between (0, 0) and (7, 4) is |0-7|+|0-4|=11.
 - The Manhattan distance between (7, 4) and (2, 10) is |7-2|+|4-10|=11.
 - The Manhattan distance between (2, 10) and (-1, 2) is |2-(-1)|+|10-2|=11.
Thus, this play is valid.
Also, there is no way to finish the game with less than three strokes.

Difficulty: interview

Starter code:

Solutions:
k = int(input())
x, y = list(map(int, input().split()))
ans = []
if k % 2 == 0:
    if (x + y) % 2 == 1:
        print((-1))
        return
x_reverse = False
y_reverse = False
if x < 0:
    x *= -1
    x_reverse = True
if y < 0:
    y *= -1
    y_reverse = True


def app(a, b):
    nonlocal ans
    if x_reverse:
        a *= -1
    if y_reverse:
        b *= -1

    ans.append((a, b))


nowx = 0
nowy = 0

while abs(x - nowx) + abs(y - nowy) >= 2 * k:
    if abs(x - nowx) > k:
        nowx += k
    else:
        nowy += k
    app(nowx, nowy)


def ok():
    app(x, y)
    print((len(ans)))
    for a, b in ans:
        print((a, b))
    return


rest = abs(x - nowx) + abs(y - nowy)
if rest == k:
    ok()

if rest % 2 == 0:
    delta = 2 * k - rest
    assert delta % 2 == 0
    if abs(x - nowx) < abs(y - nowy):
        temp = abs(x - nowx) + delta // 2
        nowx += temp
        nowy += k - temp
    else:
        temp = abs(y - nowy) + delta // 2
        nowy += temp
        nowx += k - temp
    app(nowx, nowy)
    ok()

# 残りが奇数のときは、条件から一旦ゴールをすぎる方向に移動すれば、
# 残りの距離の偶奇が変わる。

if abs(x - nowx) < abs(y - nowy):
    nowx += k
    app(nowx, nowy)
else:
    nowy += k
    app(nowx, nowy)

x_delta = x - nowx
x_pm = x_delta // abs(x_delta)
y_delta = y - nowy
y_pm = y_delta // abs(y_delta)
if abs(x_delta) < abs(y_delta):
    delta = 2 * k - (abs(x_delta) + abs(y_delta))
    temp = abs(x - nowx) + delta // 2
    nowx += x_pm * temp
    nowy += y_pm * (k - temp)
    app(nowx, nowy)
    ok()
else:
    delta = 2 * k - (abs(x_delta) + abs(y_delta))
    temp = abs(y - nowy) + delta // 2
    nowy += y_pm * temp
    nowx += x_pm * (k - temp)
    app(nowx, nowy)
    ok()



import sys

K = int(input())
X, Y = list(map(int, input().split()))

mx = 1 if X >= 0 else -1
my = 1 if Y >= 0 else -1
X, Y = abs(X), abs(Y)
isSwaped = False
if X < Y:
    X, Y = Y, X
    isSwaped = True

dist = X+Y
if dist%K == 0:
    rx, ry = 0, 0
else:
    if dist%2 == 0:
        if K%2 == 0:
            if dist <= 2*K:
                R = 2*K
            else:
                R = -(-dist // K) * K
        else:
            R = -(-dist // (2*K)) * 2*K
    else:
        if K%2 == 0:
            print((-1))
            return
        else:
            if dist <= 3*K:
                R = 3*K
            else:
                R = -(-(dist-K) // (2*K)) * 2*K + K
    r = (R-dist) // 2

    if r < K:
        rx, ry = 0, r
    else:
        rx = r//2
        ry = r-rx

anss = []
x, y = 0, 0
if -ry < y:
    dy = y+ry
    y -= dy
    x += K-dy
    anss.append((x, y))

num = (X+rx-x) // K
for _ in range(num):
    x += K
    anss.append((x, y))

if x < X+rx:
    dx = X+rx-x
    x += dx
    y += K-dx
    anss.append((x, y))

num = (Y-y) // K
for _ in range(num):
    y += K
    anss.append((x, y))

if y < Y:
    dy = Y-y
    y += dy
    x -= K-dy
    anss.append((x, y))

print((len(anss)))
if isSwaped:
    print(('\n'.join([str(x[1]*mx)+' '+str(x[0]*my) for x in anss])))
else:
    print(('\n'.join([str(x[0]*mx)+' '+str(x[1]*my) for x in anss])))


K = int(input())
X, Y = [int(_) for _ in input().split()]
x, signx = abs(X), -1 if X < 0 else 1
y, signy = abs(Y), -1 if Y < 0 else 1
ans = [(x, y)]


def calcxy(x, y):
    dx = min(K, x)
    dy = K - dx
    x -= dx
    if y > dy:
        y -= dy
    else:
        y += dy
    return x, y


def calczw(x, y):
    #z+w=abs(z-x)+abs(w-y)=K
    if x > y:
        #z+w=x-z+w-y=K and z<=x and w>=y
        z = (x - y) // 2
        w = K - z
    else:
        #z+w=z-x+y-w=K and z>=x and w<=y
        w = (y - x) // 2
        z = K - w
    return (z, w)


if x + y != K:
    while (x + y) > 2 * K:
        x, y = calcxy(x, y)
        ans += [(x, y)]
    z, w = calczw(x, y)
    if abs(z - x) + abs(w - y) != K:
        x, y = calcxy(x, y)
        ans += [(x, y)]
        z, w = calczw(x, y)
    if abs(z - x) + abs(w - y) != K:
        print((-1))
        return
    ans += [(z, w)]
print((len(ans)))
for x, y in ans[::-1]:
    print((x * signx, y * signy))


def main():
    k=int(input())
    x,y=map(int,input().split())

    def calc(x,y,k):
        x_sign,y_sign,xy_swap=1,1,0
        if x<0:
            x_sign=-1
            x*=-1
        if y<0:
            y_sign=-1
            y*=-1
        if x<y:
            xy_swap=1
            x,y=y,x
        ans=[]
        d=x+y
        cnt=d//k
        #距離がkで割り切れるとき
        def pattern_0(x,y):
            x_now,y_now=0,0
            ans=[]
            cnt=(x+y)//k
            j=cnt
            for i in range(cnt):
                if x_now+k<x:
                    x_now+=k
                    ans.append([x_now,y_now])
                else:
                    y_now=k-x+x_now
                    x_now=x
                    ans.append([x_now,y_now])
                    j=i+1
                    break
            return ans+[[x,y_now+(i-j+1)*k] for i in range(j,cnt)]

        #cnt==0のとき
        #dが偶数のとき
        def pattern_1_even(x,y):
            return [[(x+y)//2,(x+y)//2-k],[x,y]]
        #dが奇数のとき
        def pattern_1_odd(x,y):
            if k%2==0:
                return -1
            return [[k,0]]+[[-i+k,j] for i,j in pattern_1_even(k-x,y)]

        #cnt>=1のとき
        #dが偶数のとき
        def pattern_2_even(x,y):
            cnt=(x+y)//k
            if k%2==0 or cnt%2==1:
                l=(k*(cnt+1)-(x+y))//2
            else:
                l=(k*(cnt+2)-(x+y))//2
            if cnt!=1:
                temp=[min(2*(k-l),x),max(2*(k-l)-x,0)]
                return [[k-l,-l],temp]+[[i+temp[0],j+temp[1]] for i,j in pattern_0(x-temp[0],y-temp[1])]
            else:
                return [[k-l,-l],[x,y]]
            
        #dが奇数のとき
        def pattern_2_odd(x,y):
            cnt=(x+y)//k
            if k%2==0:
                return -1
            else:
                if (x-k+y)<k:
                    if x-k<y:
                        return [[k,0]]+[[j+k,i] for i,j in pattern_1_even(y,x-k)]
                    else:
                        return [[k,0]]+[[i+k,j] for i,j in pattern_1_even(x-k,y)]
                if x-k<y:
                    return [[k,0]]+[[j+k,i] for i,j in pattern_2_even(y,x-k)]
                else:
                    return [[k,0]]+[[i+k,j] for i,j in pattern_2_even(x-k,y)]
        if d%k==0:
            temp=pattern_0(x,y)
        elif cnt==0:
            if d%2==0:
                temp=pattern_1_even(x,y)
            else:
                temp=pattern_1_odd(x,y)
        else:
            if d%2==0:
                temp=pattern_2_even(x,y)
            else:
                temp=pattern_2_odd(x,y)
        if temp==-1:
            return -1
        if xy_swap:
            temp=[[j*x_sign,i*y_sign] for i,j in temp]
        else:
            temp=[[i*x_sign,j*y_sign] for i,j in temp]
        return temp

    def out(x,y,k):
        temp=calc(x,y,k)
        if temp==-1:
            print(-1)
            return 0
        print(len(temp))
        for i in temp:
            print(*i)

    out(x,y,k)
main()

k = int(input())
x, y = [int(item) for item in input().split()]

# Think 1st quadrant
x_minus = False
if x < 0:
    x *= -1
    x_minus = True
y_minus = False
if y < 0:
    y *= -1
    y_minus = True
# Think x >= y
y_lt_x = False
if y > x:
    x, y = y, x
    y_lt_x = True

# Even step cannot go to odd point
if k % 2 == 0 and (x + y) % 2 == 1:
    print(-1)
    return

step_num = ((x + y) + (k - 1)) // k
d = (step_num * k - x - y) // 2
while d != 0 and (k > x + d or k > y + d + x):
    step_num += 1
    d = (step_num * k - x - y) // 2
if step_num * k % 2 != (x + y) % 2:
    step_num += 1
    d = (step_num * k - x - y) // 2

# print(x, y, step_num, step_num * k)

ans = []
step_len = 0
on_top = False
for i in range(step_num):
    step_len += k
    if step_len <= y + d:
        ans.append([0, step_len])
    elif step_len <= y + d + x:
        on_top = True
        ans.append([step_len - y - d, y + d])
    else:
        ans.append([x, (y + d) - (step_len - y - d - x)])
        if not on_top:
            newx, newy = ans[-1]
            prevx, prevy = ans[-2]
            if newy > prevy:
                b = abs(prevy - newy)
                a = k - abs(prevx - newx) - abs(prevy - newy)
                ans.pop() 
                ans.append([newx + b + a // 2, newy - b - a // 2])
            else:
                a = k - abs(prevx - newx) - abs(prevy - newy)
                ans.pop() 
                ans.append([newx + a // 2, newy - a // 2])
            on_top = True
print(len(ans))
for x, y in ans:
    if y_lt_x:
        x, y = y, x
    if x_minus:
        x *= -1
    if y_minus:
        y *= -1
    print(x, y)

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

K = int(input())
X,Y = map(int,input().split())

if (X+Y) % 2 != 0 and K % 2 == 0:
    print(-1)
    return

def strategy(x,y,K):
    if x < 0:
        dx, dy = strategy(-x,y,K)
        return -dx, dy
    if y < 0:
        dx, dy = strategy(x,-y,K)
        return dx,-dy
    if x > y:
        dx, dy = strategy(y,x,K)
        return dy, dx
    # 0 <= x <= y としてよい
    L = x + y
    if L > 2 * K:
        dx = min(x,K)
        dy = K - dx
        return dx,dy
    # 距離2K以下。3回以内に仕留める
    if L == K:
        return x,y
    if (x+y) % 2 == 0:
        # 2回で仕留める
        # 0 <= x < y が分かっている
        t = (y - x) // 2
        dx,dy = K-t, t
        return dx,dy
    # 3回で仕留める
    # とりあえず離れないようにすればよい
    dx = min(K,x)
    dy = K - dx
    return dx,dy


x,y = 0,0
answer = []
while x != X or y != Y:
    dx,dy = strategy(X-x, Y-y, K)
    x += dx
    y += dy
    answer.append((x,y))

print(len(answer))
for x,y in answer:
    print(x,y)

def editarr(x,y,arr):
  if abs(x)>=abs(y):
    for i in range(len(arr)):
      arr[i][0],arr[i][1]=arr[i][1],arr[i][0]
  if x<0:
    for i in range(len(arr)):
      arr[i][0]*=-1
  if y<0:
    for i in range(len(arr)):
      arr[i][1]*=-1

k=int(input())
x,y=map(int,input().split())
ans=[]
tx=abs(x)
ty=abs(y)
if tx>=ty:
  tx,ty=ty,tx
if k%2==0 and (tx+ty)%2!=0:
  print(-1)
else:
  if tx+ty<k:
    if (tx+ty)%2==0:
      m=(ty-tx)//2
      ans.append([k-m,m])
    else:
      td=k-(tx+ty)
      ans.append([tx,ty+td])
      ans.append([tx+(k-td//2),ty+td//2])
    ans.append([tx,ty])
    n=len(ans)
  elif ty-(k-tx%k)<k and (ty-(k-tx%k))%2!=0:
    if tx<k and ty<k:
      if (2*k-(tx+ty))%2==0:
        td=2*k-(tx+ty)
        ans.append([tx+td//2,k-(tx+td//2)])
        ans.append([tx,ty])
      else:
        ans.append([tx,k-tx])
        td=ty-(k-tx)
        ans.append([tx+(k-td//2),ans[-1][1]+td//2])
        ans.append([tx,ty])
      n=len(ans)
    else:
      if tx+ty<2*k:
        if (2*k-(tx+ty))%2==0:
          td=2*k-(tx+ty)
          ans.append([tx+td//2,k-(tx+td//2)])
          ans.append([tx,ty])
        else:
          ans.append([tx,k-tx])
          td=ty-(k-tx)
          ans.append([tx+(k-td//2),ans[-1][1]+td//2])
          ans.append([tx,ty])
        n=len(ans)
      else:
        ans.append([0,0])  
  else:
    ans.append([0,0])
    for i in range(tx//k):
      ans.append([ans[-1][0]+k,0])
    if ans[-1][0]!=tx:
      ans.append([tx,k-abs(tx-ans[-1][0])])
    td=ty-ans[-1][1]
    if td%k==0:
      flag=True
    else:
      flag=False
    for i in range(td//k):
      if flag==False and (ty-ans[-1][1])%2==0 and (ty-ans[-1][1])<=2*k:
          break
      ans.append([tx,ans[-1][1]+k])
    if ans[-1][1]!=ty:
      td=ty-ans[-1][1]
      ans.append([tx+(k-td//2),ans[-1][1]+td//2])
      ans.append([tx,ty])
    ans.pop(0)
    n=len(ans)
  editarr(x,y,ans)
  print(n)
  for a,b in ans:
    print(a,b)

import sys
sys.setrecursionlimit(300000)
def solve(x,y,k):
    if x==y==0: return []
    if x<0: return [(-x,y) for x,y in solve(-x,y,k)]
    if y<0: return [(x,-y) for x,y in solve(x,-y,k)]
    if x>y: return [(x,y) for y,x in solve(y,x,k)]
    if (x+y)%k==0: return [(k,0)]*(x//k)+[(0,k)]*(y//k)+([]if x%k==y%k==0 else[(x%k,y%k)])
    if x+y>=2*k:
        if x%k+y%k>=k: return [(k,0)]*(x//k)+[(0,k)]*(y//k)+solve(x%k,y%k,k)
        else: return ([(k,0)]*(x//k)+[(0,k)]*(y//k))[:-1]+solve(x%k,y%k+k,k)
    if x+y<K and (x+y)%2==1: return solve(x,y+k,k)+[(0,-k)]
    if K&1 and x+y>k and (x+y)%k%2==0: return solve(x,y-k,k)+[(0,k)]
    z=(x+y)//2
    return [(k-z+x,z-x),(z-k,z)]
K,X,Y=map(int, open(0).read().split())
if K%2==0 and (X+Y)%2==1:
    print(-1)
else:
    ans=solve(X,Y,K)
    print(len(ans))
    ax,ay=0,0
    for x,y in ans:
        ax+=x
        ay+=y
        print(ax,ay)

import sys
input = sys.stdin.readline

K=int(input())
X,Y=list(map(int,input().split()))

if K%2==0 and (X+Y)%2==1:
    print((-1))
    return

ANS=[]
NOWX=0
NOWY=0

def dis(NOWX,NOWY,X,Y):
    return abs(NOWX-X)+abs(NOWY-Y)

def app():
    ANS.append((NOWX,NOWY))

if dis(NOWX,NOWY,X,Y)<K and dis(NOWX,NOWY,X,Y)%2==1:
    if X>0:
        NOWX-=K
        app()
    elif X<0:
        NOWX+=K
        app()
    elif Y>0:
        NOWY-=K
        app()
    elif Y<0:
        NOWY+=K
        app()
        

while dis(NOWX,NOWY,X,Y)>2*K:
    if X-NOWX>K:
        NOWX+=K
        app()
    elif NOWX-X>K:
        NOWX-=K
        app()
    elif Y-NOWY>K:
        NOWY+=K
        app()
    elif NOWY-Y>K:
        NOWY-=K
        app()



if dis(NOWX,NOWY,X,Y)!=K and dis(NOWX,NOWY,X,Y)%2==1:
    if X-NOWX>0:
        NOWX+=K
        app()
    elif NOWX-X>0:
        NOWX-=K
        app()
    elif Y-NOWY>0:
        NOWY+=K
        app()
    elif NOWY-Y>0:
        NOWY-=K
        app()



if dis(NOWX,NOWY,X,Y)==K:
    ANS.append((X,Y))

else:
    t=dis(NOWX,NOWY,X,Y)
    u=(K*2-t)//2

    if abs(NOWY-Y)<=abs(NOWX-X):

        if X<NOWX and Y>=NOWY:
                ANS.append((NOWX-(K-u),NOWY-u))
                ANS.append((X,Y))
        elif X<NOWX and Y<=NOWY:
                ANS.append((NOWX-(K-u),NOWY+u))
                ANS.append((X,Y))
                
        elif X>NOWX and Y>=NOWY:
                ANS.append((NOWX+(K-u),NOWY-u))
                ANS.append((X,Y))
        elif X>NOWX and Y<=NOWY:
                ANS.append((NOWX+(K-u),NOWY+u))
                ANS.append((X,Y))

    else:
        if X<=NOWX and Y>NOWY:
                ANS.append((NOWX+u,NOWY+(K-u)))
                ANS.append((X,Y))
        elif X<=NOWX and Y<NOWY:
                ANS.append((NOWX+u,NOWY-(K-u)))
                ANS.append((X,Y))
                
        elif X>=NOWX and Y>NOWY:
                ANS.append((NOWX-u,NOWY+(K-u)))
                ANS.append((X,Y))
        elif X>=NOWX and Y<NOWY:
                ANS.append((NOWX-u,NOWY-(K-u)))
                ANS.append((X,Y))
        
            
print((len(ANS)))
for x,y in ANS:
    print((x,y))
        
        

    
    


import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]

k=II()
x,y=MI()

# Kが偶数で、ゴールまでのマンハッタン距離が奇数だと不可能
if k%2==0 and (x+y)%2:
    print(-1)
    return

# x>=0,y>=0,x<=yに修正して解き、最後に復元
cx=-1 if x<0 else 1
cy=-1 if y<0 else 1
x,y=abs(x),abs(y)
swap=False
if x>y:
    swap=True
    x,y=y,x

ans=[]
if (x+y)%2 and x+y<k:
    ans.append((x,y))
    y+=k
l=(x+y+k-1)//k*k
if (l-x-y)%2:l+=k
d=(l-x-y)//2
if d>0 and d+y<k:d+=k//2

if d:
    ans.append((x,y))
    x+=d
    y-=k-d

while y-k>=0:
    ans.append((x, y))
    y-=k

if y:
    ans.append((x,y))
    x-=k-y
    y=0

while x>0:
    ans.append((x, y))
    x-=k

print(len(ans))
for x,y in ans[::-1]:
    if swap:x,y=y,x
    print(cx*x,cy*y)


K = int(input())
X, Y = list(map(int, input().split()))

P = []
x, y = 0, 0

while (x, y) != (X, Y):
    dx = abs(X - x)
    dy = abs(Y - y)
    D = dx + dy
    if D == K:
        x, y = X, Y
    elif D % 2 != 0 and K % 2 == 0:
        print((-1))
        return
    elif D % 2 == 0 and D <= 2 * K:
        pos   = D // 2
        shift = (2 * K - D) // 2
        if pos <= dx:
            x += pos   if X > x else -pos
            y -= shift if Y > y else -shift
        else:
            x = X + (shift if X > x else -shift)
            y += pos - dx if Y > y else -(pos - dx)
    elif D < K:
        x -= K if X > x else -K
    elif dx >= K:
        x += K if X > x else -K
    else:
        x = X
        y += K - dx if Y > y else -(K - dx)
    P.append((x, y))

print((len(P)))
for x, y in P:
    print((x, y))


#55 ABC135E
k=int(input())
x,y=map(int,input().split())
def golf(a,b):
	if a<0:
		t=golf(-a,b)
		return -t[0],t[1]
	if b<0:
		t=golf(a,-b)
		return t[0],-t[1]
	if a>b:
		t=golf(b,a)
		return t[1],t[0]
	if a+b>=2*k:
		return a,b-k
	if a+b==k:
		return 0,0
	r=k-(a+b)//2
	return -r,a+b+r-k
if k%2==0 and (x+y)%2==1:
	print(-1)
else:
	res=[]
	while x or y:
		res.append([x,y])
		x,y=golf(x,y)
	print(len(res))
	for r in res[::-1]:
		print(r[0],r[1])

import itertools
K=int(input())
X,Y=list(map(int,input().split()))
Mdist=abs(X)+abs(Y)
if Mdist%2==1 and K%2==0:
    print((-1))
    return
    #K:偶数ならマンハッタン距離が偶数の点にしか行けない
    #逆にKが偶数ならマンハッタン距離が偶数の任意の点に行ける
    #K:奇数なら理論上どこでも行ける
    #よってこれ以外のパターンは全部可能
    #(0,0)->(2n+1,0)->(n+1,n+1)->(1,0)
#K:奇数のとき、移動回数と距離がmod2 で合同
def searcheven(x,y):
    if abs(x)+abs(y)>2*K:
        return None
    if (abs(x)+abs(y))%2==1:
        return None
    for ps in itertools.product([-1,1],repeat=4):
        p1,p2,p3,p4=ps
        if p1*p4==p2*p3:
            if p3*(K-p1*x-p2*y)==-p1*K:
                a,b=0,p4*K
                if abs(x-a)+abs(y-b)==K and abs(a)+abs(b)==K:
                    return (a,b)
                a,b=p3*K,0
                if abs(x-a)+abs(y-b)==K and abs(a)+abs(b)==K:
                    return (a,b)
            else:
                pass
        else:
            tmp1=K-p1*x-p2*y
            tmp2=K
            tmp3=p4*tmp1+p2*tmp2
            tmp4=-p3*tmp1-p1*tmp2
            det=-p1*p4+p2*p3
            a,b=(tmp3//det,tmp4//det)
            if abs(x-a)+abs(y-b)==K and abs(a)+abs(b)==K:
                return (a,b)
            else:
                pass
    return None

ans=[(0,0)]
while(True):
    nx,ny=ans[-1]
    if abs(nx-X)+abs(ny-Y)<=2*K:
        if (abs(nx-X)+abs(ny-Y))%2==0:
            p,q=searcheven(X-nx,Y-ny)
            ans.append((p+nx,q+ny))
            ans.append((X,Y))
            break
        else:
            if abs(nx-X)+abs(ny-Y)==K:
                ans.append((X,Y))
                break
            tmpx=K//2
            tmpy=K-tmpx
            nextkouho=[(tmpx,tmpy),(tmpx,-tmpy),(-tmpx,tmpy),(-tmpx,-tmpy),(K,0),(-K,0),(0,K),(0,-K)]
            for point in nextkouho:
                ptmp,qtmp=point
                p=ptmp+nx;q=qtmp+ny
                if abs(X-p)+abs(Y-q)<=2*K:
                    ans.append((p,q))
                    break
    elif abs(nx)+K<=abs(X):
        if X<0:
            ans.append((nx-K,ny))
            continue
        else:
            ans.append((nx+K,ny))
            continue
    elif abs(ny)+K<=abs(Y):
        if Y<0:
            ans.append((nx,ny-K))
            continue
        else:
            ans.append((nx,ny+K))
            continue


#print(ans)
s=len(ans)-1
flag=1
for i in range(s):
    ax,ay=ans[i]
    bx,by=ans[i+1]
    if abs(ax-bx)+abs(ay-by)==K:
        pass
    else:
        flag=0
        break
if flag==0:
    print("NG")
print(s)
for i in range(1,s+1):
    print((ans[i][0],ans[i][1]))


k = int(input())
x,y = list(map(int,input().split()))
if abs(x)+abs(y) == k:
    print((1))
    print((x,y))
    return
cx = cy = cxy = False
if x < 0:
    x = -x
    cx = True
if y < 0:
    y = -y
    cy = True
if x < y:
    x,y =y,x
    cxy = True

if k %2 == 0 and (x+y)%2 == 1:
    print((-1))
    return

ans = []
n = max((x+y+k-1)//k,2)

if (x+y)%2 != (n*k)%2:
    n += 1

if x < k and n==3:
    mid = (k+x-y)//2
    ans.append([x,x-k])
    ans.append([x+mid,y-k+mid])
    ans.append([x,y])

else:
    over = (n*k-x-y)//2
    for i in range(1,n+1):
        d = i*k
        if d <= y+over:
            ans.append([0,d])
        elif d <= y+over+x:
            ans.append([d-over-y,y+over])
        else:
            ans.append([x,y+(n-i)*k])

if cxy:
    ans = [[i,j] for j,i in ans]
if cx:
    ans = [[-i,j] for i,j in ans]
if cy:
    ans = [[i,-j] for i,j in ans]


print(n)
for i,j in ans:
    print((i,j))


def e_golf(K, X, Y):
    # 参考: https://babcs2035.hateblo.jp/entry/2019/07/29/AtCoder_Beginner_Contest_135：E_-_Golf
    # 参考: https://atcoder.jp/contests/abc135/submissions/6607612

    # x >= y >= 0 となるようにどのような座標変換を行ったか
    is_xpos_negative = is_ypos_negative = is_swap = False
    x, y = X, Y
    if x < 0:
        x *= -1
        is_xpos_negative = True
    if y < 0:
        y *= -1
        is_ypos_negative = True
    if x < y:
        x, y = y, x
        is_swap = True

    if (x + y) % 2 == 1 and K % 2 == 0:
        return -1  # ゴールできない

    ans = []
    shot_min = max((x + y + K - 1) // K, 2)
    if (x + y) % 2 != (shot_min * K) % 2:
        shot_min += 1
    if x + y == K:
        ans.append((x, y))
    elif shot_min == 3 and x < K:
        mid = (K + x - y) // 2
        ans.extend(((x, x - K), (x + mid, y - K + mid), (x, y)))
    else:
        over = (shot_min * K - x - y) // 2
        for i in range(1, shot_min + 1):
            d = i * K
            if d <= y + over:
                ans.append((0, d))
            elif d <= y + over + x:
                ans.append((d - y - over, y + over))
            else:
                ans.append((x, y + (shot_min - i) * K))

    # 座標変換をしていた場合、元に戻す
    if is_swap:
        ans = [(second, first) for first, second in ans]
    if is_xpos_negative:
        ans = [(-first, second) for first, second in ans]
    if is_ypos_negative:
        ans = [(first, -second) for first, second in ans]
    return '\n'.join([str(len(ans))] + ['{} {}'.format(f, s) for f, s in ans])

K = int(input())
X, Y = [int(i) for i in input().split()]
print(e_golf(K, X, Y))

K=int(input())
X,Y=map(int,input().split())

sgn_X,sgn_Y=1,1
if X<0:
  X=-X
  sgn_X=-1
if Y<0:
  Y=-Y
  sgn_Y=-1

if K%2==0 and (X+Y)%2==1:
  print(-1)
else:
  xx,yy=0,0
  vec_list=[]
  while((X-xx)+(Y-yy)>2*K):
    if X-xx>K:
      xx+=K
      vec_list.append((K,0))
    elif Y-yy>K:
      yy+=K
      vec_list.append((0,K))
  #print(xx,yy,vec_list)
  diff_x=X-xx
  diff_y=Y-yy
  
  if K%2==0:
    if diff_x+diff_y==K:
      vec_list.append((diff_x,diff_y))
    else:
      buf=2*K-(diff_x+diff_y)
      if diff_x+buf//2<=K:
        vec_list.append((diff_x+buf//2,K-(diff_x+buf//2)))
        vec_list.append((-buf//2,K-buf//2))
      elif diff_y+buf//2<=K:
        vec_list.append((K-(diff_y+buf//2),diff_y+buf//2))
        vec_list.append((K-buf//2,-buf//2))
      else:
        raise("Error")    
          
  else:
    if diff_x+diff_y==K:
      vec_list.append((diff_x,diff_y))
    else:
      if (diff_x+diff_y)%2==1:
        if diff_x<=K:
          xx+=diff_x
          if K-diff_x<diff_y:
            yy+=K-diff_x
            vec_list.append((diff_x,K-diff_x))
          else:
            yy-=K-diff_x
            vec_list.append((diff_x,-K+diff_x))
        elif diff_y<=K:
          yy+=diff_y
          if K-diff_y<diff_x:
            xx+=K-diff_y
            vec_list.append((K-diff_y,diff_y))
          else:
            xx-=K-diff_y
            vec_list.append((-K+diff_y,diff_y))

      diff_x=X-xx
      diff_y=Y-yy
      buf=2*K-(diff_x+diff_y)  
      if diff_x+buf//2<=K:
        vec_list.append((diff_x+buf//2,K-(diff_x+buf//2)))
        vec_list.append((-buf//2,K-buf//2))
      elif diff_y+buf//2<=K:
        vec_list.append((K-(diff_y+buf//2),diff_y+buf//2))
        vec_list.append((K-buf//2,-buf//2))
      else:
        raise("Error")    

  #print(vec_list)
  print(len(vec_list))
  pos_x,pos_y=0,0
  for x,y in vec_list:
    pos_x+=sgn_X*x
    pos_y+=sgn_Y*y
      
    print(pos_x,pos_y)

i=input;k = int(i());x, y = list(map(int, i().split()));x,y=x-y,x+y
def cc(x, xs):
    if abs(x-xs)<=2*k and abs(x-xs)%2==0:
        return 1,x+(k if abs(x+k-xs) <= abs(x-k-xs) else -k)
    return 0,xs+(k if x-xs>0 else -k)
if (k%2,x%2)==(0,1):
    print((-1))
else:
    rs = []
    xs, ys = 0, 0
    while True:
        if abs(x-xs) == k or abs(y-ys) == k:
            if abs(x-xs) <= k and abs(y-ys) <= k:
                rs+=["{} {}".format((x+y)//2,(y-x)//2)]
                break
        mm,ys=cc(y,ys)
        if mm:
            xs = xs+(k if x > xs else -k)
        else:
            mm, xs = cc(x, xs)
        rs+=["{} {}".format((xs+ys)//2,(ys-xs)//2)]
    print((len(rs)))
    print(("\n".join(rs)))


K = int(input())
X,Y = map(int,input().split())

ans = [(X,Y)]
x,y = ans[-1]
while abs(x)>=3*K//2:
    x,y = ans[-1]
    if x>=K:
        x -= K
    elif x<=-K:
        x += K
    ans.append((x,y))
dx = abs(x)

while abs(y)>2*K-dx:
    x,y = ans[-1]
    if y>0:
        y -= K
    else:
        y += K
    ans.append((x,y))

x,y = ans[-1]
if abs(y)+abs(x)!=K:
    if (x+y)%2==0 and K%2==0:
        d2 = (abs(x)+abs(y))//2
        if abs(x)>abs(y):
            x -= d2 * (1 if x>0 else -1)
            y += (K-d2) * (1 if y>0 else -1)
        else:
            x += (K-d2) * (1 if x>0 else -1)
            y -= d2 * (1 if y>0 else -1)
        ans.append((x,y))
    else:
        if (x+y+K)%2 == 0:
            y -= K if y>0 else (-K)
            ans.append((x,y))
        d = abs(x)+abs(y)
        if abs(x)>abs(y):
            x -= d//2 * (1 if x>0 else -1)
            y += (K-d//2) * (1 if y>0 else -1)
        else:
            x += (K-d//2) * (1 if x>0 else -1)
            y -= d//2 * (1 if y>0 else -1)
        ans.append((x,y))
x,y = ans[-1]

if abs(x)+abs(y)!=K:
    print(-1)
else:
    ans = ans[::-1]
    print(len(ans))
    for out in ans:
        print(*out)

k = int(input())
x, y = map(int, input().split())

def sign(x):
    return 1 if x > 0 else -1

if (abs(x) + abs(y)) % 2 == 1 and k % 2 == 0:
    print(-1)
else:
    cx, cy = 0, 0
    ret = []
    while x != cx or y != cy:
        if abs(x - cx) + abs(y - cy) == k:
            cx, cy = x, y
        elif abs(x - cx) + abs(y - cy) <= 2 * k:
            dx = abs(x - cx)
            dy = abs(y - cy)
            rem = 2 * k - dx - dy
            if dx > dy:
                cy += (dy + rem // 2) * sign(y - cy)
                cx += (k - dy - rem // 2) * sign(x - cx)
            else:
                cx += (dx + rem // 2) * sign(x - cx)
                cy += (k - dx - rem // 2) * sign(y - cy)
        else:
            if abs(x - cx) > abs(y - cy):
                cx += sign(x - cx) * k
            else:
                cy += sign(y - cy) * k
        ret.append((cx, cy))

    print(len(ret))
    for cx, cy in ret:
        print(cx, cy)

'''
分かりやすい図解ページ
https://blog.bobuhiro11.net/2019/08-03-abc135ef.html
https://betrue12.hateblo.jp/entry/2019/07/28/215024
'''
import math

def swap(X,Y):
  temp=X
  X=Y
  Y=temp
  return X,Y

def keiro(count,X,Y,K):
  keirolist=[]
  oneway_surplus=int(((count*K)-X-Y)/2)
  move=0
  turncount=0
  prevX=0
  prevY=0
  while(move<count):
    if turncount==0:
      if K-prevY>=oneway_surplus:
        prevX=K-oneway_surplus
        prevY-=oneway_surplus
        turncount+=1
      else:
        prevX=0
        prevY-=K
    elif turncount==1:
      if K+prevX>X:
        prevY+=(K-(X-prevX))
        prevX=X
        turncount+=1
      else:
        prevX+=K
    else:
      prevY+=K
    keirolist.append([prevX,prevY])
    #print(keirolist)
    move+=1
  return keirolist

def ans(K,X,Y):
  anslist=[]
  count=0
  Xminus=0
  Yminus=0
  swapflag=0
  if X<0:
    Xminus=1
    X=abs(X)
  if Y<0:
    Yminus=1
    Y=abs(Y)
  if (X+Y)==K:
    count=1
    anslist.append([X,Y])
  else:
    if X<Y:
      X,Y=swap(X,Y)
      swapflag=1
    if X+Y>K:
      count=math.ceil((X+Y)/K)
      lastflag=0
      if (count*K-X-Y)%2==1:
        count+=1
        lastflag=1
      anslist=keiro(count,X,Y,K)
      
    else:
      if (X+Y)%2==0:
        count=2
        anslist=keiro(count,X,Y,K)
      else:
        count=3
        anslist.append([X,-K+X])
        Xsurplus=int((X+K-Y)/2)
        anslist.append([X+Xsurplus,X-Xsurplus])
        anslist.append([X,Y])
  for ans in anslist:
    if swapflag==1:
      ans[0],ans[1]=swap(ans[0],ans[1])
    if Xminus==1:
      ans[0]=-ans[0]
    if Yminus==1:
      ans[1]=-ans[1]
  return count,anslist



K=int(input())
X,Y=map(int,input().split())

if K%2==0 and (X+Y)%2==1:
  print(-1)
  return

count,anslist=ans(K,X,Y)
print(count)
for ans in anslist:
  print(ans[0],ans[1])

#!/usr/bin/env python3
import random

def copysign(x, y):
    return abs(x) * (1 if y >= 0 else - 1)

def dist(k, x, y):
    if not (abs(x) + abs(y) < 2 * k):
        return None
    if x == y == 0:
        return 0
    elif abs(x) + abs(y) == k:
        return 1
    elif (abs(x) + abs(y)) % 2 == 0:
        return 2
    else:
        return 3

def iterate_neighbors(k, x, y):
    assert abs(x) + abs(y) < 2 * k
    dz = (2 * k - abs(x) - abs(y)) // 2
    for dx in (dz, k - dz):
        dy = k - dx
        yield (dx, dy)
        yield (dx, - dy)
        yield (- dx, dy)
        yield (- dx, - dy)

def solve(k, x, y):
    while True:
        d = dist(k, x, y)
        if d == 0:
            return
        elif d == 1:
            dx = x
            dy = y
        elif d == 2:
            for dx, dy in iterate_neighbors(k, x, y):
                if dist(k, x - dx, y - dy) == 1:
                    break
            else:
                assert False
        elif d == 3:
            while True:
                dx = random.randint(0, k) * random.choice([-1, 1])
                dy = (k - abs(dx)) * random.choice([-1, 1])
                if dist(k, x - dx, y - dy) == 2:
                    break
        else:
            dx = copysign(min(k, abs(x)), x)
            dy = copysign(k - abs(dx), y)
        yield (dx, dy)
        x -= dx
        y -= dy

def main():
    k = int(input())
    x, y = list(map(int, input().split()))
    if k % 2 == 0 and (abs(x) + abs(y)) % 2 != 0:
        print((-1))
        return
    ops = list(solve(k, x, y))
    print((len(ops)))
    x = 0
    y = 0
    for dx, dy in ops:
        x += dx
        y += dy
        print((x, y))

main()


k=int(input())
x,y=map(int,input().split())
if x<0:fx=-1
else:fx=1
if y<0:fy=-1
else:fy=1
ax,ay=abs(x),abs(y)
if ax<ay:
  x,y=y,x
  ax,ay=ay,ax
  fx,fy=fy,fx
  flag=1
else:flag=0
r=ax+ay
if k%2==0 and r%2==1:print(-1);return
if r==k:
  print(1)
  if flag:x,y=y,x
  print(x,y)
  return
if r%2==1 and r<k:
  print(3)
  anss=[]
  anss.append(((ax+(k-ay))//2,(k-(ax+(k-ay))//2)))
  anss.append((ax+(k-ay),0))
  anss.append((ax,ay))
  for i,j in anss:
    ii,jj=i*fx,j*fy
    if flag:ii,jj=jj,ii
    print(ii,jj)
  return
if r%2==0 and r<k:
  rm=(2*k-ax-ay)//2
else:
  rn=(k-(r%k))%k
  if rn%2==1:rn+=k
  rm=rn//2
ans=(r+rm*2)//k
anss=[]*ans
print(ans)
first=[0,-rm]
second=[ax,-rm]
third=[ax,ay]
xx=yy=0
while yy>first[1]:
  if yy-k<=first[1]:
    xx+=k-(yy-first[1])
    yy=first[1]
  else:
    yy-=k
  anss.append((xx*fx,yy*fy))
while xx<second[0]:
  if xx+k>=second[0]:
    yy+=k-(second[0]-xx)
    xx=second[0]
  else:
    xx+=k
  anss.append((xx*fx,yy*fy))
while yy!=third[1]:
  yy+=k
  anss.append((xx*fx,yy*fy))
for i,j in anss:
  ii,jj=i,j
  if flag:ii,jj=jj,ii
  print(ii,jj)

k = int(input())
X,Y = map(int,input().split())
x = max(abs(X),abs(Y))
y = min(abs(X),abs(Y))
c = (k-(x+y)%k)%k
if k%2 == 0 and (x+y)%2 == 1:
  print(-1)
  return
  
import math
ans = []
m = math.ceil((x+y)/k)
if (x+y)/k == int((x+y)/k):
  for i in range(m):
    ans.append((min(x,k*i+k),max(0,k*i+k-x)))
    
elif m == 1:
  if (x+y)%2 == 1:
    ans.append((x,x-k))
    ans.append((x+(k+x-y)//2,(-k+x+y)//2))
    ans.append((x,y))
  else:
    ans.append(((x+y)//2,-k+(x+y)//2))
    ans.append((x,y))
               
elif c%2 == 0 and x+y >= k:
  a = abs((k*m-x-y)//2)
  for i in range(m-1):
    l = k*i+k
    if a >= l:
      ans.append((0,-l))
    elif a < l <= x+a:
      ans.append((l-a,-a))
    elif x+a < l:
      ans.append((x,l-x-2*a))
  ans.append((x,y))
  
else:
  m += 1
  a = abs((k*m-x-y)//2)
  for i in range(m-1):
    l = k*i+k
    if a >= l:
      ans.append((0,-1))
    elif a < l <= x+a:
      ans.append((l-a,-a))
    elif x+a < l:
      ans.append((x,l-x-2*a))
  ans.append((x,y))
  
print(len(ans))
for i,j in ans:
  if abs(X) < abs(Y):
    i,j = j,i
  if X < 0:
    i *= -1
  if Y < 0:
    j *= -1
  print(i,j)

def solve(k, x, y):
    if k % 2 == 0 and (x + y) % 2 == 1:
        print((-1))
        return

    ans = []
    abx, aby = abs(x), abs(y)
    mh = abx + aby
    xx, yy = 0, 0

    if mh % k == 0:
        d = (mh - 1) // k + 1
        for _ in range(d - 1):
            dx, dy = abs(abx - xx), abs(aby - yy)
            if dx > 0:
                if dx >= k:
                    xx += k
                else:
                    xx += dx
                    yy += k - dx
            else:
                yy += k
            ans.append((xx, yy))
        ans.append((abx, aby))
        print_ans(ans, x, y)
        return

    d = (mh - 1) // k + 1

    if k % 2 == 1 and mh % 2 != max(2, d) % 2:
        if abx > aby:
            xx += min(k, abx)
            yy += k - min(k, abx)
        else:
            yy += min(k, aby)
            xx += k - min(k, aby)
        ans.append((xx, yy))

    for _ in range(d - 2):
        dx, dy = abs(abx - xx), abs(aby - yy)
        if dx > dy:
            if abx > xx:
                xx += k
            else:
                xx -= k
        else:
            if aby > yy:
                yy += k
            else:
                yy -= k
        ans.append((xx, yy))

    dx, dy = abs(abx - xx), abs(aby - yy)
    mhh = (dx + dy) // 2
    if dx > dy:
        if abx > xx:
            xx += mhh
        else:
            xx -= mhh
        if aby > yy:
            yy -= k - mhh
        else:
            yy += k - mhh
    else:
        if aby > yy:
            yy += mhh
        else:
            yy -= mhh
        if abx > xx:
            xx -= k - mhh
        else:
            xx += k - mhh
    ans.append((xx, yy))
    ans.append((abx, aby))

    print_ans(ans, x, y)


def print_ans(ans, x, y):
    print((len(ans)))
    for dx, dy in ans:
        if x < 0:
            dx = -dx
        if y < 0:
            dy = -dy
        print((dx, dy))


k = int(input())
x, y = list(map(int, input().split()))
solve(k, x, y)


K=int(input())
X,Y=map(int,input().split())

sgn_X,sgn_Y=1,1
if X<0:
  X=-X
  sgn_X=-1
if Y<0:
  Y=-Y
  sgn_Y=-1

if K%2==0 and (X+Y)%2==1:
  print(-1)
else:
  xx,yy=0,0
  vec_list=[]
  while((X-xx)+(Y-yy)>2*K):
    if X-xx>K:
      xx+=K
      vec_list.append((K,0))
    elif Y-yy>K:
      yy+=K
      vec_list.append((0,K))
  #print(xx,yy,vec_list)
  diff_x=X-xx
  diff_y=Y-yy
  
  if diff_x+diff_y==K:
    vec_list.append((diff_x,diff_y))
  else:
    if (diff_x+diff_y)%2==1:
      if diff_x<=K:
        xx+=diff_x
        if K-diff_x<diff_y:
          yy+=K-diff_x
          vec_list.append((diff_x,K-diff_x))
        else:
          yy-=K-diff_x
          vec_list.append((diff_x,-K+diff_x))
      elif diff_y<=K:
        yy+=diff_y
        if K-diff_y<diff_x:
          xx+=K-diff_y
          vec_list.append((K-diff_y,diff_y))
        else:
          xx-=K-diff_y
          vec_list.append((-K+diff_y,diff_y))
      diff_x=X-xx          
      diff_y=Y-yy
      
    buf=2*K-(diff_x+diff_y)  
    if diff_x+buf//2<=K:
      vec_list.append((diff_x+buf//2,K-(diff_x+buf//2)))
      vec_list.append((-buf//2,K-buf//2))
    elif diff_y+buf//2<=K:
      vec_list.append((K-(diff_y+buf//2),diff_y+buf//2))
      vec_list.append((K-buf//2,-buf//2))
    else:
      raise("Error")    

  #print(vec_list)
  print(len(vec_list))
  pos_x,pos_y=0,0
  for x,y in vec_list:
    pos_x+=sgn_X*x
    pos_y+=sgn_Y*y      
    print(pos_x,pos_y)

k = int(input())
x, y = [int(x) for x in input().strip().split(" ")]
x, y = x-y, x+y

def main():
    if k % 2 == 0:
        if x % 2 != 0:
            return -1
    return to(x,y)

def cc(x, xs):
        if abs(x-xs) <= 2*k:
            if abs(x+k-xs) % 2 == k % 2:
                if abs(x+k-xs) <= abs(x-k-xs):
                    xs = x+k
                else:
                    xs = x-k
                return (True,xs)
            else:
                if x > xs:
                    xs += k
                else:
                    xs -= k
        else:
            if x > xs:
                xs += k
            else:
                xs -= k
        return (False,xs)


def to(x, y):
    rs = []
    xs, ys = 0, 0
    while True:
        if abs(x-xs) == k or abs(y-ys) == k:
            if abs(x-xs) <= k and abs(y-ys) <= k:
                return rs + [(x, y)]
        mm, ys = cc(y, ys)
        if mm:
            if x > xs:
                xs += k
            else:
                xs -= k
        else:
            mm, xs = cc(x, xs)
        rs.append((xs, ys))

def __starting_point():
    jj = main()
    if jj == -1:
        print((-1))
    else:
        print((len(jj)))
        for r in jj:
            print(((r[0]+r[1])//2, (r[1]-r[0])//2))



__starting_point()

K = int(input())
X, Y = list(map(int,input().split()))

if K%2 == 0 and (X+Y)%2:
    print((-1))
    return

def next(x,y):
    if x < 0:
        dx, dy = next(-x, y)
        return -dx, dy
    if y < 0:
        dx, dy = next(x, -y)
        return dx, -dy
    if x < y:
        dx, dy = next(y, x)
        return dy, dx
    if x + y == K:
        return x, y
    if x + y <= K * 2 and (x + y) % 2 == 0:
        return (x + y)//2, (x + y)//2 - K
    return K, 0

x, y = 0,0
ans = list()
while x != X or y != Y:
    dx, dy = next(X - x, Y - y)
    x += dx; y += dy
    ans.append((x, y))

print((len(ans)))
for x, y in ans:
  print((x, y))


k=int(input())
x,y=map(int,input().split())

if k%2==0 and (x+y)%2!=0:
    print(-1)
    return

def f(x,y):
    if x<0:
        a,b=f(-x,y)
        return -a,b
    if y<0:
        a,b=f(x,-y)
        return a,-b
    if x<y:
        a,b=f(y,x)
        return b,a
    if x+y==k:
        return x,y
    if x+y<=k*2 and (x+y)%2==0:
        return (x+y)//2,(x+y)//2-k
    return k,0

p,q=0,0
ans=[]
while (p,q)!=(x,y):
    a,b=f(x-p,y-q)
    p+=a
    q+=b
    ans.append(str(p)+" "+str(q))

print(len(ans))
print('\n'.join(ans))

def solve(x, y):
    if x < 0:
        x, y = solve(-x, y)
        return -x, y
    if y < 0:
        x, y = solve(x, -y)
        return x, -y
    if x > y:
        x, y = solve(y, x)
        return y, x

    if x + y >= 2 * K:
        return x, y - K
    if x + y == K:
        return 0, 0

    r = K - (x + y) // 2
    return -r, (x + y + r - K)



K, X, Y = map(int, open(0).read().split())

if K % 2 == 0 and (X + Y) % 2 == 1:
    print(-1)
    return

A = []
while X or Y:
    A.append((X, Y))
    X, Y = solve(X, Y)

print(len(A))
for a in reversed(A):
    print(*a)

K = int(input())
X, Y = map(int, input().split())

def golf(a, b):
  if a < 0:
    t = golf(-a, b)
    return (-t[0], t[1])
  if b < 0:
    t = golf(a, -b)
    return (t[0], -t[1])
  if a > b:
    t = golf(b, a)
    return (t[1], t[0])
  
  if a + b >= K * 2:
    return (a, b - K)
  if a + b == K:
    return (0, 0)
  r = K - (a + b) // 2
  return (-r, a + b + r - K)

if K % 2 == 0 and (X + Y) % 2 == 1:
  print(-1)
else:
  res = []
  while X or Y:
    res.append((X, Y))
    X, Y = golf(X, Y)
  print(len(res))
  for r in res[: : -1]:
    print(r[0], r[1])

import sys
K = int(input())
X, Y = map(int, input().split())
if (X + Y) % 2 and K % 2 == 0:
    print(-1)
    return

def solve(K, X, Y):
    if (X + Y) % 2 and K % 2 == 0:
        return None
    def gen(a, b, c, d):
        ans = []
        x = y = 0
        assert c-a == Y and b-d == X
        while a >= K:
            y -= K; a -= K
            ans.append((0, y))
        if a:
            x += K - a; y -= a
            b -= K - a
            ans.append((x, y))
        while b >= K:
            x += K; b -= K
            ans.append((x, y))
        if b:
            x += b; y += K - b
            c -= K - b
            ans.append((x, y))
        while c >= K:
            y += K; c -= K
            ans.append((x, y))
        if c:
            x -= K - c; y += c
            d -= K - c
            ans.append((x, y))
        while d >= K:
            x -= K; d -= K
            ans.append((x, y))
        assert X == x and Y == y, (x, y, ans)
        assert d == 0
        return ans

    ans = []
    if X + Y < K:
        if (X + Y) % 2 == 1:
            n = 3
            ans = gen(K-X, X + (K + X - Y)//2, K - X + Y, (K + X - Y)//2)
        else:
            n = 2
            ans = gen((K*n-X-Y)//2, X, (K*n-X+Y)//2, 0)
    else:
        c = (K - (X + Y)) % K
        if c % 2 == 1:
            n = (X + Y + K-1) // K + 1
        else:
            n = (X + Y + K-1) // K
        ans = gen((K*n-X-Y)//2, X, (K*n-X+Y)//2, 0)
    assert len(ans) == n
    return ans
rx = X < 0
if rx:
    X = -X
ry = Y < 0
if ry:
    Y = -Y
r = X < Y
if r:
    X, Y = Y, X
ans = solve(K, X, Y)
if ans:
    print(len(ans))
    for x, y in ans:
        if r:
            x, y = y, x
        if rx:
            x = -x
        if ry:
            y = -y
        print(x, y)
else:
    print(-1)

#!/usr/bin/env python3
import sys

def get(K: int, X: int, Y: int):
    p = None
    if X >= K:
        X -= K
        p = [K, 0]
    elif Y >= K:
        Y -= K
        p = [0, K]
    else:
        if X + Y >= K:
            p = [X, K - X]
            Y -= K - X
            X = 0
        else:
            p = [-K, 0]
            X += K
    return p, X, Y

def jump_two(K: int, X: int, Y: int):
    assert(X + Y < 2 * K)
    if X + Y == 0:
        return []
    elif X + Y == K:
        return [(X, Y)]
    ret = []
    rev = False
    if X > Y:
        X, Y = Y, X
        rev = True
    a = K - (Y - X)//2
    b = K - (Y + X)//2
    assert(0 <= a and a <= K)
    assert(0 <= b and b <= K)
    ret.append([a, K - a])
    ret.append([-b, K - b])
    if rev:
        for i in range(len(ret)):
            ret[i][0], ret[i][1] = ret[i][1], ret[i][0]
    return ret

def calc(K: int, X: int, Y: int):
    ret = []
    if X + Y < K:
        if (X + Y) % 2 != 0:
            # 3
            p, X, Y = get(K, X, Y)
            ret.append(p)
        ret += jump_two(K, X, Y)
        return ret
    while X + Y >= K * 2:
        p, X, Y = get(K, X, Y)
        ret.append(p)
    if X + Y == K:
        # 1
        ret.append([X, Y])
    else:
        # K * 2 > X + Y > K
        if (X + Y) % 2 != 0:
            p, X, Y = get(K, X, Y)
            ret.append(p)

        ret += jump_two(K, X, Y)
    return ret


def solve(K: int, X: int, Y: int):
    if K % 2 == 0 and (X + Y) % 2 != 0:
        print((-1))
        return
    negate_X = False
    negate_Y = False
    if X < 0:
        X *= -1
        negate_X = True
    if Y < 0:
        Y *= -1
        negate_Y = True
    v = calc(K, X, Y)
    for i in range(len(v)):
        if negate_X:
            v[i][0] *= -1
        if negate_Y:
            v[i][1] *= -1
    x = 0
    y = 0
    print((len(v)))
    for dx, dy in v:
        x += dx
        y += dy
        print((x, y))
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    K = int(next(tokens))  # type: int
    X = int(next(tokens))  # type: int
    Y = int(next(tokens))  # type: int
    solve(K, X, Y)

def __starting_point():
    main()

__starting_point()

def solve(v, u, k):
    sign_v = sign_u = 1
    swap = 1
    if abs(v) < abs(u):
        v, u = u, v
        swap = -1
    if v < 0:
        v = -v
        sign_v = -1
    if u < 0:
        u = -u
        sign_u = -1
    if v % k == 0:
        n = v // k
        res = []
        cum_u = 0
        for i in range(n):
            du = min(k, max(-k, u-cum_u))
            if (k+du)%2:
                du += 1 if du < 0 else -1
            cum_u += du
            res.append([k*sign_v, du*sign_u][::swap])
        assert cum_u == u, (cum_u, u)
        return res
    elif v < k and v%2==0:
        res = [[k, u-k], [v-k, k]]
        res = [[dv * sign_v, du * sign_u][::swap] for dv, du in res]
        return res
    else:
        m = v % k
        if (k+m)%2:
            m -= 1
        res = [[m, k]] + solve(v-m, u-k, k)
        res = [[dv*sign_v, du*sign_u][::swap] for dv, du in res]
        return res

def test():
    inf = -1
    M = [[inf]*1000 for _ in range(1000)]
    K = 9
    q = [(0, 0)]
    R = 100
    ans = 1
    M[0][0] = 0
    while q:
        q_new = []
        for x, y in q:
            for i in range(-K, K+1, 2):
                ux = x+i
                uy = y+i
                if -R <= ux <= R:
                    if y + K <= R:
                        if M[ux][y+K] == inf:
                            M[ux][y+K] = ans
                            q_new.append((ux, y+K))
                    if y - K >= -R:
                        if M[ux][y-K] == inf:
                            M[ux][y-K] = ans
                            q_new.append((ux, y-K))
                if -R <= uy <= R:
                    if x + K <= R:
                        if M[x+K][uy] == inf:
                            M[x+K][uy] = ans
                            q_new.append((x+K, uy))
                    if x - K >= -R:
                        if M[x-K][uy] == inf:
                            M[x-K][uy] = ans
                            q_new.append((x-K, uy))
        q = q_new
        ans += 1
    for x in range(-R, R+1):
        for y in range(-R, R+1):
            if M[x][y] != -1:
                if len(solve(x, y, K)) != M[x][y]:
                    print(f"!! x={x} y={y} len(solve(x, y, K))={len(solve(x, y, K))} M[x][y]={M[x][y]}")
    print("test finished")

#test()

def main():
    K = int(input())
    X, Y = list(map(int, input().split()))
    if K % 2 == 0 and (X + Y) % 2:
        print((-1))
        return
    V, U = X + Y, X - Y
    Ans = solve(V, U, K)
    print((len(Ans)))
    cum_x = cum_y = 0
    for v, u in Ans:
        x, y = (v+u)//2, (v-u)//2
        assert abs(x)+abs(y) == K
        cum_x += x
        cum_y += y
        print(f"{cum_x} {cum_y}")
    assert cum_x == X and cum_y == Y

main()


k = int(input())
gx,gy = list(map(int,input().split()))
if k%2 == 0 and (gx+gy)%2:
  print((-1))
  return
flgx = 1
flgy = 1
if gx < 0:
  flgx -= 2
  gx *= -1
if gy < 0:
  flgy -= 2
  gy *= -1
px = 0
py = 0
ansls = []
while True:
  if (gx-px+gy-py) <= 2*k:
    break
  if gx-px >= k:
    px += k
  elif gy-py >= k:
    py += k
  ansls.append((px,py))
if gx-px+gy-py <= 2*k:
  if gx-px+gy-py == 2*k:
    if px+k <= gx:
      px += k
    else:
      py += k
    ansls.append((px,py))
  if gx-px+gy-py == k:
    ansls.append((gx,gy))
  else:
    if (gx-px+gy-py)%2:
      if px+k <= gx:
        px += k
      elif py+k <= gy:
        py += k
      elif px+py+k <= gx+gy:
        py += k-(gx-px)
        px = gx
      else:
        py -= gx-px
        px -= k-(gx-px)
      ansls.append((px,py))
    if gx-px <= gy-py:
      ansls.append((px+(gx-px+gy-py)//2-k,py+(gx-px+gy-py)//2))
    else:
      ansls.append((px+(gx-px+gy-py)//2,py+(gx-px+gy-py)//2-k))
    ansls.append((gx,gy))
for i in range(len(ansls)-1):
  if abs(ansls[i+1][0]-ansls[i][0])+abs(ansls[i+1][1]-ansls[i][1]) != k:
    print("error")
print((len(ansls)))
for x,y in ansls:
  print((x*flgx,y*flgy))
  


k = int(input())
X,Y = map(int,input().split())
x = max(abs(X),abs(Y))
y = min(abs(X),abs(Y))
c = (k-(x+y)%k)%k
if k%2 == 0 and (x+y)%2 == 1:
  print(-1)
  return
  
a = []
m = ((x+y-1)//k+1)
if x+y < k:
  if (x+y)%2 == 1:
    a.append((x,x-k))
    a.append((x+(k+x-y)//2,(-k+x+y)//2))
  else:
    a.append(((x+y)//2,-k+(x+y)//2))
  
if c%2 == 1 and x+y >= k:
  m += 1
A = abs((k*m-x-y)//2)
for i in range(m-1):
  l = k*i+k
  if A >= l:
    a.append((0,-1))
  elif A < l <= x+A:
    a.append((l-A,-A))
  elif x+A < l:
    a.append((x,l-x-2*A))
    
a.append((x,y))
print(len(a))
for i,j in a:
  if abs(X) < abs(Y):
    i,j = j,i
  if X < 0:
    i *= -1
  if Y < 0:
    j *= -1
  print(i,j)

K = int(input())
x, y = map(int, input().split())

nowx, nowy = 0, 0
ans = []

def ok():
    nonlocal ans, x, y
    ans.append((x, y))
    print(len(ans))
    for (x, y) in ans:
        print(x,y)
    return
        


while(abs(nowx - x) + abs(nowy - y) >= 2*K):
    if x - nowx >= K:
        nowx += K
    elif nowx - x >= K:
        nowx -= K
    elif y - nowy >= K:
        nowy += K
    else:
        nowy -= K
    ans.append((nowx, nowy))

if (abs(nowx - x) + abs(nowy - y)) % 2 == 1 and K % 2 == 0:
    print(-1)
    return

    
if (abs(nowx - x) + abs(nowy - y)) == K:ok()
    
if (abs(nowx - x) + abs(nowy - y)) % 2 == 1:
    if abs(nowx+K - x) + abs(nowy - y) < 2*K:nowx += K
    elif abs(nowx-K - x) + abs(nowy - y) < 2*K:nowx -= K
    elif abs(nowx - x) + abs(nowy+K - y) < 2*K:nowy += K
    elif abs(nowx - x) + abs(nowy-K - y) < 2*K:nowy -= K
    ans.append((nowx, nowy))
    
if (abs(nowx - x) + abs(nowy - y)) == K:ok()

rest = K*2 - (abs(nowx-x) + abs(nowy-y))
rest //= 2
xgo, ygo = 1, 1

if nowx != x:
    xgo = (x - nowx) // abs(nowx - x)
if nowy != y:
    ygo = (y - nowy) // abs(nowy - y)

if abs(nowx-x) >= abs(nowy-y):
    nowx += xgo * (K - rest)
    nowy -= ygo * rest
    ans.append((nowx, nowy))
    
else:
    nowy += ygo * (K - rest)
    nowx -= xgo * rest
    ans.append((nowx, nowy))

ok()

import math

k = int(input())
x, y = list(map(int, input().split()))

if k % 2 == 0 and (x + y) % 2 == 1:
    print((-1))
    return

a = 1
b = 1
d = 0
if x < 0:
    x *= -1
    a = -1
if y < 0:
    y *= -1
    b = -1
if x < y:
    d = 1
    x, y = y, x

def show_xy(tx, ty):
    if d == 1:
        print((ty * a, tx * b))
    else:
        print((tx * a, ty * b))

if x + y < k and (x + y) % 2 == 1:
    print((3))
    temp_x = x
    temp_y = x - k
    show_xy(temp_x, temp_y)
    temp_x = x + (k+x-y)//2
    temp_y += k - (k+x-y)//2
    show_xy(temp_x, temp_y)
    temp_x = x
    temp_y = y
    show_xy(temp_x, temp_y)
    return

c = (k - ((x + y) % k)) % k
if x + y < k:
    n = 2
else:
    n = math.ceil((x + y) / k) + (c % 2)

print(n)

ans = 0
temp_x = 0
temp_y = 0

temp = - (k * n - x - y) // 2
while 1:
    temp_y -= k
    if temp_y >=  temp:
        show_xy(temp_x, temp_y)
    else:
        temp_x = temp - temp_y
        temp_y = temp
        #print(temp_x * a, temp_y * b)
        break

while temp_x <= x:
    show_xy(temp_x, temp_y)
    temp_x += k

temp_y += temp_x - x
temp_x = x

while temp_y <= y:
    show_xy(temp_x, temp_y)
    temp_y += k


K = int(input())
X, Y = [int(_) for _ in input().split()]
x, signx = abs(X), -1 if X < 0 else 1
y, signy = abs(Y), -1 if Y < 0 else 1
ans = [(x, y)]
if x + y != K:
    while (x + y) > 2 * K:
        dx = min(K, x)
        dy = K - dx
        x -= dx
        y -= dy
        ans += [(x, y)]

    def calczw(x, y):
        #z+w=abs(z-x)+abs(w-y)=K
        if x > y:
            #z+w=x-z+w-y=K and z<=x and w>=y
            z = (x - y) // 2
            w = K - z
        else:
            #z+w=z-x+y-w=K and z>=x and w<=y
            w = (y - x) // 2
            z = K - w
        return (z, w)

    z, w = calczw(x, y)
    if abs(z - x) + abs(w - y) != K:
        dx = min(K, x)
        dy = K - dx
        x -= dx
        if y > dy:
            y -= dy
        else:
            y += dy
        ans += [(x, y)]
        z, w = calczw(x, y)
    if abs(z - x) + abs(w - y) != K:
        print((-1))
        return
    ans += [(z, w)]
print((len(ans)))
for x, y in ans[::-1]:
    print((x * signx, y * signy))


def editarr(x,y,arr):
  l=len(arr)
  if abs(x)>=abs(y):
    for i in range(l):
      arr[i][0],arr[i][1]=arr[i][1],arr[i][0]
  if x<0:
    for i in range(l):
      arr[i][0]*=-1
  if y<0:
    for i in range(l):
      arr[i][1]*=-1

k=int(input())
x,y=map(int,input().split())
ans=[]
tx=abs(x)
ty=abs(y)
if tx>=ty:
  tx,ty=ty,tx
if k%2==0 and (tx+ty)%2!=0:
  print(-1)
else:
  if tx+ty<k:
    if (tx+ty)%2==0:
      m=(ty-tx)//2
      ans.append([k-m,m])
    else:
      td=k-(tx+ty)
      ans.append([tx,ty+td])
      ans.append([tx+(k-td//2),ty+td//2])
    ans.append([tx,ty])
  elif ty-(k-tx%k)<k and (ty-(k-tx%k))%2!=0:
    if (2*k-(tx+ty))%2==0:
      td=2*k-(tx+ty)
      ans.append([tx+td//2,k-(tx+td//2)])
      ans.append([tx,ty])
    else:
      ans.append([tx,k-tx])
      td=ty-(k-tx)
      ans.append([tx+(k-td//2),ans[-1][1]+td//2])
      ans.append([tx,ty])
  else:
    ans.append([0,0])
    for i in range(tx//k):
      ans.append([ans[-1][0]+k,0])
    if ans[-1][0]!=tx:
      ans.append([tx,k-abs(tx-ans[-1][0])])
    td=ty-ans[-1][1]
    if td%k==0:
      flag=True
    else:
      flag=False
    for i in range(td//k):
      if flag==False and (ty-ans[-1][1])%2==0 and (ty-ans[-1][1])<=2*k:
          break
      ans.append([tx,ans[-1][1]+k])
    if ans[-1][1]!=ty:
      td=ty-ans[-1][1]
      ans.append([tx+(k-td//2),ans[-1][1]+td//2])
      ans.append([tx,ty])
    ans.pop(0)
  editarr(x,y,ans)
  print(len(ans))
  for a,b in ans:
    print(a,b)

# https://atcoder.jp/contests/abc135/submissions/7969271
# 写経

def main():
    K = int(input())
    X, Y = map(int, input().split())

    if K % 2 == 0 and (X + Y) % 2 != 0:
        print(-1)
        return

    def next_vec(x, y):
        # 原点からx,yを目指すとき
        if x < 0:
            dx, dy = next_vec(-x, y)
            return -dx, dy
        if y < 0:
            dx, dy = next_vec(x, -y)
            return dx, -dy
        if x < y:
            dx, dy = next_vec(y, x)
            return dy, dx
        # 1手
        if x + y == K:
            return x, y
        # 2手...(1)
        if x + y <= K + K and (x + y) % 2 == 0:
            return (x + y) // 2, (x + y) // 2 - K
        # 3手以上
        return K, 0

    x, y = 0, 0
    ans = []
    while (x, y) != (X, Y):
        dx, dy = next_vec(X - x, Y - y)
        x += dx
        y += dy
        ans.append('{} {}'.format(x, y))

    print(len(ans))
    print(*ans, sep='\n')


def __starting_point():
    main()

"""
写経して計算の意味を考えた

(1)
x+y=D<2K
2手要する
S(A,B)->M(?,?)->G(X,Y)
S->M: 距離K未満=D-K詰め
M->G: 距離K詰め

S,Gから等距離Lの点M'
M'からGから離れる方向に距離Fの点M
SM'=M'G: 距離L
MM': 距離F

S->M'->M->M'->G
(S->M'->M)->M'->G: 初手
S->M': Gに距離L近づく
M'->M: Gから距離F離れる
dD_1=L-F=D-K...1

S->M'->(M->M'->G): 次手
M->M': Gに距離F近づく
M'->G: Gに距離L近づく
dD_2=L+F=K...2

1,2の連立で
L=D/2<K
F=K-D/2...(1)と符合逆だがこれは大きさ

SからGに向かって
L=D/2近づき
F離れることは可能か？
D=x+y
x>=yとすると
2D=2(x+y)<=2(2x)
D<=2x
D/2<=x
x,y方向の離れている距離のうちより離れている方向xでは
距離D/2以上離れているので、
この方向でSからGに向かってL=D/2近づくこと(=Mに到達)はできる
その後、y方向でMからGに向かうのと逆方向に
F=K-D/2進めば
次にGに向かって最短経路を進むと
距離KでGに到達できるようなM'に到達できる
"""

__starting_point()

#コメントで解説を書いてみる

#itertoolsとはpythonで組み合わせ全探索するのに使える
import itertools

#標準入力からデータを受け取る
K=int(input())
X,Y=list(map(int,input().split()))

#Mdistとは(0,0)から(X,Y)へのマンハッタン距離
Mdist=abs(X)+abs(Y)
#ここで答えが-1になる条件を考えてみる。
#K:偶数ならマンハッタン距離が偶数の点にしか行けない
#よってKが偶数でMdistが奇数ならその点に行くことができないので答えは-1となる。
if Mdist%2==1 and K%2==0:
    print((-1))
    return

#逆にKが偶数ならマンハッタン距離が偶数の任意の点に行ける
#実際に,(0,0)->(K,0)->(1,1)とすれば点(1,1)に行けるのでこの操作を組み合わせれば良い

#また、K:奇数なら理論上どこでも行ける
#実際に以下の様にすることで(1,0)に行くことができるのでこの操作を組み合わせれば良い
#(0,0)->(2n+1,0)->(n+1,n+1)->(1,0)

#よってこれ以外のパターンは全部可能

#以降は操作を具体的に構成することを考える
#近くになるまで貪欲に進んでいって、近くなったら付近の都合の良い点を探すことを考える

#よってMdist<=2Kの状態でまず考える.
#操作を2回繰り返せばMdist<=2KかつMdist:偶数の任意の点に行ける
#Mdist<=2KでMdist:奇数の点については一回操作をしてから上記の2回の操作を適用すればよい

#よってMdist<=2Kなら3回以内で行けるはず
#Mdist:偶数なら2回、Mdist:奇数なら3回となるが、
#一回で行ける状況を始めに処理しておかないとコーナーケースでエラーになる

#コーナーケースの例:
#5
#1 4

#このケースについては
#1
#1 4
#と出力しなくてはいけないが,
#3
#5 0
#1 -1
#1 4
#と最適でない方法を出力する可能性がある.

if abs(X)+abs(Y)==K:
    print((1))
    print((X,Y))
    return
    
#searchevenとは、Mdist<=2Kの点に行くためにどの点を中継するべきかを出力する
#マンハッタン距離が一定の点の集合は正方形となることから,
#各辺の組み合わせ(4*4通り)について連立方程式を解けば良い
#ここで、2辺が平行になる可能性もあるので,行列式が0になるかならないかで場合分けして考える必要がある。
def searcheven(x,y):
    if abs(x)+abs(y)>2*K:
        return None
    if (abs(x)+abs(y))%2==1:
        return None
    #p1X+p2Y=Kとp3X+p4Y=Kの交点をそれぞれ求める。(pk in {-1,1})
    for ps in itertools.product([-1,1],repeat=4):
        p1,p2,p3,p4=ps
        if p1*p4==p2*p3:
            #並行のときは直線が重なるとき
            #両端のどちらかが条件を満たすのでそれを返す
            if p3*(K-p1*x-p2*y)==-p1*K:
                a,b=0,p4*K
                if abs(x-a)+abs(y-b)==K and abs(a)+abs(b)==K:
                    return (a,b)
                a,b=p3*K,0
                if abs(x-a)+abs(y-b)==K and abs(a)+abs(b)==K:
                    return (a,b)
            else:
                pass
        else:
            #平行でないときは単純に連立方程式を解いている
            tmp1=K-p1*x-p2*y
            tmp2=K
            tmp3=p4*tmp1+p2*tmp2
            tmp4=-p3*tmp1-p1*tmp2
            det=-p1*p4+p2*p3
            a,b=(tmp3//det,tmp4//det)
            #交点が辺の上にあるかをチェックしなければいけない
            if abs(x-a)+abs(y-b)==K and abs(a)+abs(b)==K:
                return (a,b)
            else:
                pass
    return None

#順々に点を移動していく
ans=[(0,0)]
while(True):
    #nx,nyからどこに移動するべきかを決める
    nx,ny=ans[-1]
    if abs(nx-X)+abs(ny-Y)<=2*K:
        #もし近いところに点があるならば先程のsearchevenでどこの点を経由するべきかを決める
        if (abs(nx-X)+abs(ny-Y))%2==0:
            p,q=searcheven(X-nx,Y-ny)
            ans.append((p+nx,q+ny))
            ans.append((X,Y))
            break
        #距離が奇数なら一回別の近傍の点を経由する
        else:
            tmpx=K//2
            tmpy=K-tmpx
            nextkouho=[(tmpx,tmpy),(tmpx,-tmpy),(-tmpx,tmpy),(-tmpx,-tmpy),(K,0),(-K,0),(0,K),(0,-K)]
            for point in nextkouho:
                ptmp,qtmp=point
                p=ptmp+nx;q=qtmp+ny
                if abs(X-p)+abs(Y-q)<=2*K:
                    ans.append((p,q))
                    break
    #遠い場所になるなら距離が近くなるように貪欲に移動する
    #座標がマイナスのときに逆に移動しないように注意
    elif abs(nx)+K<=abs(X):
        if X<0:
            ans.append((nx-K,ny))
            continue
        else:
            ans.append((nx+K,ny))
            continue
    elif abs(ny)+K<=abs(Y):
        if Y<0:
            ans.append((nx,ny-K))
            continue
        else:
            ans.append((nx,ny+K))
            continue


#print(ans)
#これは提出前のデバッグ用
#NGと出力される状況ならふつうにWAになる
s=len(ans)-1
flag=1
for i in range(s):
    ax,ay=ans[i]
    bx,by=ans[i+1]
    if abs(ax-bx)+abs(ay-by)==K:
        pass
    else:
        flag=0
        break
if flag==0:
    print("NG")

#解の出力
#ansには(0,0)データもあるので,それを出力しないように注意
print(s)
for i in range(1,s+1):
    print((ans[i][0],ans[i][1]))