Harryxun/stf_run huggingface dataset:
n = int(input())
l = list(map(int, input().split()))
b = []

def gcd(a,b):
	while b:
		a, b = b, a % b
	return a
if n == 2:
	print(max(l[0],l[1]))
elif n == 3:
	print(max(gcd(l[0],l[1]),gcd(l[0],l[2]),gcd(l[2],l[1])))
else:
	for i in range(n):
		tmp = l
		tmp.pop(i)
		x = gcd(tmp[0],tmp[1])
		for j in list(range(2, n-1)):
			x = gcd(x,tmp[j])
		b.append(x)
	print(max(b))

### FIXED CODE ###

def gcd(a,b):
  while b:a,b=b,a%b
  return a
n,a,b=int(input()),list(map(int,input().split())),[]
if n==2:print(max(a[0],a[1]))
elif n==3:print(max(gcd(a[0],a[1]),gcd(a[0],a[2]),gcd(a[1],a[2])))
else:
  no,mi=a[0],a[0]
  for i in range(1,n):
    s=gcd(no,a[i])
    if s!=no:
      no=max(s,mi)
      mi=gcd(s,mi)
  print(no)
import sys

def main():

    sys.stdin = open('input155a.txt')

    a, b, c = map(int, input().split())

    answer = 'Yes' if check(a, b, c) else 'No'
    print(answer)

def check(a, b, c):

    for _ in range(3):
        a, b, c = b, c, a
        if a == b and b != c:
            return True

    return False


if __name__ == '__main__':
    main()


### FIXED CODE ###

import sys

def main():
    
    # sys.stdin = open('input155a.txt')
    
    a, b, c = map(int, input().split())

    if a == b & b == c:
        print('No')
        
    elif a != b & b != c & c != a:
        print('No')
    
    else:
        print('Yes')
     

if __name__ == '__main__':
    main()
import math
r = int(input())
print("{0:.5f} {1:.5f}".format(math.pi*r**2, 2*math.pi*r))

### FIXED CODE ###

import math
r = float(input())
print("{0:.6f} {1:.6f}".format(math.pi*r**2, 2*math.pi*r))
import sys
readline = sys.stdin.readline
class Tree:
    __slots__ = ['id', 'p', 'sibling', 'degree', 'depth', 'height', 'type', 'c']
    def __init__(self, id):
        self.id = id
        self.p = -1
        self.sibling = -1
        self.degree = 0
        self.depth = 0
        self.height = 0
        self.type = "leaf"
        self.c = []
    def __str__(self):
        return f"node {self.id}: parent = {self.p}, sibling = {self.sibling}, degree = {self.degree}, depth = {self.depth}, height = {self.height}, {self.type}"
def solve():
    n = int(input())
    tree = tuple(Tree(i) for i in range(n))
    for _ in range(n):
        id, *c = map(int, readline().replace("-1", "").split())
        if c != []:
            tree[id].type = "internal node"
            tree[id].c = c
            for j in c:
                tree[j].p = id
            len_c = len(c)
            tree[id].degree = len_c
            if len_c == 2:
                tree[c[0]].sibling = c[1]
                tree[c[1]].sibling = c[0]
    rootget = lambda x: rootget(x) if tree[x].p != -1 else x
    root = rootget(0)
    tree[root].type = "root"
    def depth_height_check(id, d):
        d += 1
        height = 0
        for i in tree[id].c:
            tree[i].depth = d
            if tree[i].type != "leaf":
                tree[i].height = depth_height_check(i, d) + 1
                height = max(height, tree[i].height)
        return height
    tree[root].height = depth_height_check(root, 0) + 1 if n > 1 else 0
    print("\n".join(map(str, tree)))
solve()



### FIXED CODE ###

import sys
readline = sys.stdin.readline
class Tree:
    __slots__ = ['id', 'p', 'sibling', 'degree', 'depth', 'height', 'type', 'c']
    def __init__(self, id):
        self.id = id
        self.p = -1
        self.sibling = -1
        self.degree = 0
        self.depth = 0
        self.height = 0
        self.type = "leaf"
        self.c = []
    def __str__(self):
        return f"node {self.id}: parent = {self.p}, sibling = {self.sibling}, degree = {self.degree}, depth = {self.depth}, height = {self.height}, {self.type}"
n = int(input())
tree = tuple(Tree(i) for i in range(n))
for _ in range(n):
    id, *c = (i for i in map(int, readline().split()) if i != -1)
    if c != []:
        tree[id].type = "internal node"
        tree[id].c = c
        for j in c:
            tree[j].p = id
        len_c = len(c)
        tree[id].degree = len_c
        if len_c == 2:
            tree[c[0]].sibling = c[1]
            tree[c[1]].sibling = c[0]
root = 0
while tree[root].p != -1:
    root = tree[root].p
tree[root].type = "root"
def depth_height_check(id, d):
    d += 1
    height = 0
    for i in tree[id].c:
        tree[i].depth = d
        if tree[i].type != "leaf":
            tree[i].height = depth_height_check(i, d)
            height = max(height, tree[i].height)
    return height + 1
tree[root].height = depth_height_check(root, 0) if n > 1 else 0
print("\n".join(map(str, tree)))
s=input()
s=string(set(s))
if (len(s) != 2):
  print("NO")
  else:
    print("YES")

### FIXED CODE ###

s=list(input())
s=set(s)
if (len(s) == 2):
  print("Yes")
else:
  print("No")
S = input()
print'A%sC' % s[0]

### FIXED CODE ###

A,S,C = input().split()
print ('A%sC' % S[0])
r1, c1, r2, c2 = map(int, input().split())

#############

mod = 10**9 + 7
max = 2 * 10**6 + 2
fac, finv, inv = [0]*max, [0]*max, [0]*max

def comInit(max):
    fac[0] = fac[1] = 1
    finv[0] = finv[1] = 1
    inv[1] = 1

    for i in range(2,max):
      fac[i] = fac[i-1]* i% mod
      inv[i] = mod - inv[mod%i] * (mod // i) % mod
      finv[i] = finv[i-1] * inv[i] % mod

comInit(max)

# 二項係数の計算
def com(n,k):
    if(n < k):
        return 0
    if( (n<0) | (k < 0)):
        return 0
    return fac[n] * (finv[k] * finv[n-k] % mod) % mod

#############
ans = (com(r2+c2+2,r2+1) - com(r2+c1+1, c1) - com(r1+c2+1, r1) + com(r1+c1, r1)) % mod

print(ans)

### FIXED CODE ###

r1, c1, r2, c2 = map(int, input().split())

#############

mod = 10**9 + 7
max = 3 * 10**6
fac, finv, inv = [0]*max, [0]*max, [0]*max

def comInit(max):
    fac[0] = fac[1] = 1
    finv[0] = finv[1] = 1
    inv[1] = 1

    for i in range(2,max):
      fac[i] = fac[i-1]* i% mod
      inv[i] = mod - inv[mod%i] * (mod // i) % mod
      finv[i] = finv[i-1] * inv[i] % mod

comInit(max)

# 二項係数の計算
def com(n,k):
    if(n < k):
        return 0
    if( (n<0) | (k < 0)):
        return 0
    return fac[n] * (finv[k] * finv[n-k] % mod) % mod

#############
ans = (com(r2+c2+2,r2+1) - com(r2+c1+1, c1) - com(r1+c2+1, r1) + com(r1+c1, r1)) % mod

print(ans)
n,q=map(int,input().split())
root=[[] for _ in range(n)]
f=lambda x:int(x)-1
 
for i in range(n-1):
  a,b=map(f,input().split())
  root[a].append(b)
  root[b].append(a)
 
score=[0]*n
for j in range(q):
  p,x=map(int,input().split())
  score[p-1]+=x
 
visit = [False]*n
def dfs(now):
  visit[now] = True
  for go in root[now]:
    if visit[go]:
      continue
    score[go] += score[now]
    dfs(go)

dfs(0)
print(*score)

### FIXED CODE ###

import sys
sys.setrecursionlimit(10**7)
n,q=map(int,input().split())
root=[[] for _ in range(n)]
f=lambda x:int(x)-1
 
for i in range(n-1):
  a,b=map(f,input().split())
  root[a].append(b)
  root[b].append(a)
 
score=[0]*n
for j in range(q):
  p,x=map(int,input().split())
  score[p-1]+=x
 
visit = [False]*n
def dfs(now):
  visit[now] = True
  for go in root[now]:
    if visit[go]:
      continue
    score[go] += score[now]
    dfs(go)

dfs(0)
print(*score)
num = int(input())
d = {"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9,"j":10,"k":11,"l":12,"m":13,"n":14,"o":15,"p":16,"q":17,"r":18,"s":19,"t":20,"u":21,"v":22,"w":23,"x":24,"y":25,"z":0}
op_d = {}
for i,j in d.items():
    op_d[j] = i
ans =""
for i in list(range(0,12))[::-1]:
    if(int(num/(26**i)) == 0 ):
        pass
    else:
        ans += op_d[int(num/(26**i))]
        num = num % 26**i;
print(ans)

### FIXED CODE ###

a =input()
if(a.islower()):
    print("a")
else:
    print("A")
n = input()
A = input().split(' ').sort()
q = input()
M = input().split(' ')

### FIXED CODE ###

n = input()
A = input().split(' ')
A.sort()
A.reverse()
q = input()
M = input().split(' ')

A = list(map(int,A))
M = list(map(int,M))
A.sort()

A_sum = [0]
for a in A:
    A_sum.append(a+A_sum[-1])
A_sum.pop(0)

A.reverse()
A_sum.reverse()


#memo = [True]*(len(A))

def search(base, m, n):
    if base == m:
        return True
    if len(A)-1 < n or m - base > A_sum[n]:
        return False
    result = False
    for i in range(len(A)-1,n-1,-1):
        if base + A[i] <= m: # and memo[i]:
#           memo[i] = False
#           print(str(A[i]) + ',' + str(base+A[i]) + ',')
            if search(base+A[i], m, i+1):
                return True
#           memo[i] = True
    return result

def print_yn(result):
    if result:
        print('yes')
    else:
        print('no')

for m in M:
#   print(str(m)+':')
    print_yn(search(0,m,0))
a,b,c=map(int,input(.split()))

if a==b:
    print(c)
elif a==c:
    print(b)
else:
    print(a)

### FIXED CODE ###

a,b,c=map(int,input().split())

if a==b:
    print(c)
elif a==c:
    print(b)
else:
    print(a)
a = list(input())
b = list(input())

k = max(len(a),len(b))

dp = [[0]*(len(b)+1) for i in range(len(a)+1)]

for i in range(len(a)):
	for j in range(len(b)):
		if a[i] == b[j]:
			dp[i+1][j+1] = dp[i][j] + 1
		else:
			dp[i+1][j+1] = max(dp[i+1][j],dp[i][j+1])

ans = ""

def rec(m,n):
	if m == 0 and n == 0:
		return ans
	if a[m-1] == b[n-1]:
		global ans
		ans += a[m-1]
		rec(m-1,n-1)
	elif dp[m-1][n] > dp[m][n-1]:
		rec(m-1,n)
	else:
		rec(m,n-1) 

rec(len(a),len(b))
print(ans[::-1])

### FIXED CODE ###

a = input()
b = input()

aa = len(a)

bb = len(b)

dp = [[0]*(bb+1) for i in range(aa+1)]

for i in range(aa):
	for j in range(bb):
		if a[i] == b[j]:
			dp[i+1][j+1] = dp[i][j] + 1
		else:
			dp[i+1][j+1] = max(dp[i][j+1],dp[i+1][j])

ans = ""

while aa > 0 and bb > 0:
	if a[aa-1] == b[bb-1]:
		aa -= 1
		bb -= 1
		ans += a[aa]
	elif dp[aa][bb-1] > dp[aa-1][bb]:
		bb -= 1
	else:
		aa -= 1
print(ans[::-1])
def cmb(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
md=10**9+7
n,k=map(int,input().split())
for i in range(k):
  a=cmb(n-k+1,i)*cmb(k-1,i-1)
  a=a%md
  print(a)

### FIXED CODE ###

import math
def cmb(n, r):
  if n < r : return 0
  else : return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
md=10**9+7
n,k=map(int,input().split())
for i in range(1,k+1):
  a=cmb(n-k+1,i)*cmb(k-1,i-1)
  a=a%md
  print(a)
A, B = map(int, input().slipt())
print((A+B)%24)

### FIXED CODE ###

A, B = map(int, input().split())
print((A+B) % 24)
# ABC167D
Town = []
C = 0
N, K = map(int, input().split())
A = list(map(int, input().split()))
def dfs(a, i, town, c):
    if i-1 in town:
        L = len(town) - len(town[:town.index(i-1)])
        c += (K-c) - ((K-c)%L)
        town = []
    else:
        town.append(i-1)
        c += 1
    if c >= K:
        return print(i)
    nx = a[i-1]
    dfs(a, nx, town, c)

dfs(A, 1, Town, C)

### FIXED CODE ###

N, K = map(int, input().split())
A = list(map(int, input().split()))
vis = [0]*N
p = 1
Town = []

while vis[p-1] == 0:
    Town.append(p)
    vis[p-1] = 1
    p = A[p-1]

l = Town.index(p)

if K < len(Town):
    print(Town[K])
else:
    print(Town[l + (K-l)%(len(Town[l:]))])
from fractions import gcd

from math import factorial as f

from math import ceil,floor,sqrt

from sys import exit

from copy import deepcopy
import numpy as np

import bisect
import re


ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))



def main():
    n,k,q = mi()
    alist = [0 for i in range(100005)]
    for i in range(q):
        a = ii()
        alist[a]+=1
   
  	for i in range(1,n+1):
        if alist[i] > q-k:
            print('Yes')
        else:
            print('No')
    


main()


### FIXED CODE ###

#gcdは3.4.3だとfractionsにある
from fractions import gcd

from math import factorial as f

from math import ceil,floor,sqrt

from sys import exit

from copy import deepcopy
import numpy as np

import bisect
import re


ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))



def main():
    n,k,q = mi()
    alist = [0 for i in range(100005)]
    for i in range(q):
        a = ii()
        alist[a]+=1
    
    for i in range(1,n+1):
        if alist[i] > q-k:
            print('Yes')
        else:
            print('No')
    


main()
N = int(input())
A = list(map(int, input().split()))

INFTY = 1000000001
cnt = [0]

def merge(left, mid, right):
    n1 = mid - left
    n2 = right - mid
    L = [0 for _ in range(n1+1)]
    R = [0 for _ in range(n2+1)]
    for i in range(n1):
        L[i] = A[left+i]
    for i in range(n2):
        R[i] = A[mid+i]
    L[n1] = INFTY
    R[n2] = INFTY
    i = 0
    j = 0
    for k in range(left, right):
        cnt[0] += 1
        if L[i] <= R[j]:
            A[k] = L[i]
            i += 1
        else:
            A[k] = R[j]
            j += 1

def merge_sort(left, right):
    if left+1 < right:
        mid = int((left+right) / 2)
        merge_sort(left, mid)
        merge_sort(mid, right)
        print("left:{}, mid:{}, right:{}".format(left, mid, right))
        merge(left, mid, right)
        print(A)

merge_sort(0, N)
print(" ".join(A))
print(cnt[0])


### FIXED CODE ###

N = int(input())
A = list(map(int, input().split()))

INFTY = 1000000001
cnt = [0]

def merge(left, mid, right):
    n1 = mid - left
    n2 = right - mid
    L = A[left:left+n1]
    R = A[mid:mid+n2]
    L.append(INFTY)
    R.append(INFTY)
    i = 0
    j = 0
    for k in range(left, right):
        cnt[0] += 1
        if L[i] <= R[j]:
            A[k] = L[i]
            i += 1
        else:
            A[k] = R[j]
            j += 1

def merge_sort(left, right):
    if left+1 < right:
        mid = int((left+right) / 2)
        merge_sort(left, mid)
        merge_sort(mid, right)
        merge(left, mid, right)

merge_sort(0, N)
print(" ".join(map(str, A)))
print(cnt[0])
n,a=map(int,input().split())
costs=[10**18]*(n+1)
costs[1]=0
times=[0]*(n+1)
for i in range(1,n+1):
  times[i]=costs[i]+(n+i-1)//i
  for j in range(2,n//i+1):
    costs[i*j]=min(costs[i*j],costs[i]+j+a)
print(min(times[1:]))

### FIXED CODE ###

n,a=map(int,input().split())
ans=10**18
for k in range(41):
  l=0
  r=n
  while r-l!=1:
    m=(r+l)//2
    if m**(k+1)>=n:
      r=m
    else:
      l=m
  for m in range(k+2):
    if (l**m)*(r**((k+1)-m))>=n:
      ans=min(ans,k*a+l*m+r*((k+1)-m))
print(ans)
#encoding utf-8

n = int(input())
v = list(int(i) for i in input().split())


v_odd = []
v_even = []
for i in range(n):
    if i%2 == 0:
        v_odd.append(v[i])
    else:
        v_even.append(v[i])

#odd part
count={}
for i in range(len(v_odd)):
    if v_odd[i] in count.keys():
        count[v_odd[i]] += 1
    else:
        count[v_odd[i]] = 1



for k, v in sorted(count.items(), key=lambda x: -x[1]):
    pass
keys = list(count.keys())
# num_odd = len(v_odd)-int(count[keys[0]])


#even part
even_count={}

for i in range(len(v_even)):
    if v_even[i] in even_count.keys():
        even_count[v_even[i]] += 1
    else:
        even_count[v_even[i]] = 1


for k, v in sorted(even_count.items(), key=lambda x: -x[1]):
    pass
even_keys = list(even_count.keys())
# num += len(v_even)-int(count[even_keys[0]])


if even_keys[0] == keys[0]:
    if len(keys) == 1 and len(even_keys) == 1:
        answer = int(len(v_odd))
    elif len(keys) == 1:
        answer = len(v_even)-int(v_even[even_keys[1]])
    elif len(even_keys) == 1:
        answer = len(v_odd)-int(v_odd[keys[1]])
    else:
        if int(v_even[even_keys[0]]) >= int(v_odd[keys[0]]):
            answer = len(v_odd)-int(count[keys[1]])
            answer += len(v_even)-int(even_count[even_keys[0]])
        else:
            answer = len(v_odd)-int(count[keys[0]])
            answer += len(v_even)-int(even_count[even_keys[1]])

else:
    answer = len(v_odd)-int(count[keys[0]])+len(v_even)-int(even_count[even_keys[0]])
print(int(answer))


### FIXED CODE ###

from collections import Counter
def main(n,v):
    # n = int(input())
    # v = list(map(int, input().split()))
    odd = Counter(v[0::2]).most_common(2) + [(0, 0)]
    even = Counter(v[1::2]).most_common(2) + [(0, 0)]

    n_half = int(n / 2)

    if (len(odd) == 1 and len(even) == 1) and odd[0][0] == even[0][0]:
        ans = n_half
    elif odd[0][0] == even[0][0]:
        ans = min(n_half - odd[0][1] + n_half - even[1][1],\
                n_half - odd[1][1] + n_half - even[0][1])
    else:
        ans = n_half - odd[0][1] + n_half - even[0][1]

    print(ans)
    return 0

if __name__ == "__main__":
    n = int(input())
    v = list(map(int, input().split()))
    main(n,v)
for line in open('s.txt').readlines():
    n = ''
    lis = []
    for c in line.rstrip():
        if c.isdigit() or c == 'X':
            n += c
        elif c == '+':
            lis.append(n)
            n = ''
        elif c == '=':
            lis.append(n)
            n = ''
    else:
        lis.append(n)
     
    c_lis = lis[:]   
    for n in range(10):
        for i, v in enumerate(lis):
            if 'X' in v:
                c_lis[i] = c_lis[i].replace('X', str(n))
        else:
            flag = False
            if n == 0:
                for v in c_lis:
                    if len(v) >= 2 and v[0] == '0':
                        flag = True
                        break
            if not flag:
                if int(c_lis[0]) + int(c_lis[1]) == int(c_lis[2]):
                    print n
                    break
            c_lis = lis[:]
    else:
        print 'NA'

### FIXED CODE ###

import sys

for line in sys.stdin:
    n = ''
    lis = []
    for c in line.rstrip():
        if c.isdigit() or c == 'X':
            n += c
        elif c == '+':
            lis.append(n)
            n = ''
        elif c == '=':
            lis.append(n)
            n = ''
    else:
        lis.append(n)
     
    c_lis = lis[:]   
    for n in range(10):
        for i, v in enumerate(lis):
            if 'X' in v:
                c_lis[i] = c_lis[i].replace('X', str(n))
        else:
            flag = False
            if n == 0:
                for v in c_lis:
                    if len(v) >= 2 and v[0] == '0':
                        flag = True
                        break
            if not flag:
                if int(c_lis[0]) + int(c_lis[1]) == int(c_lis[2]):
                    print n
                    break
            c_lis = lis[:]
    else:
        print 'NA'
a,b=input().split()
a=int(a)
b=str(b)
b.replace(".","")
b=int(b)
print(a*b//100)

### FIXED CODE ###

a,b=input().split()
a=int(a)
b=str(b)
b=b.replace('.','')

b=int(b)
print(a*b//100)
A, B, C, D = map(int, raw_input().split())
print min(A, C) + min(B, D)


### FIXED CODE ###

A = input()
B = input()
C = input()
D = input()
print min(A, B) + min(C, D)
N, K = map(int, input().split())

have_snack = [0 for i in range(N)]

for k in range(K):
    hito_len = int(input())
    have_hito = map(int, input().split())
    for hh in range(have_hito):
        have_snack[hh - 1] = 1

print(have_snack.count(0))


### FIXED CODE ###

N, K = map(int, input().split())

have_snack = [0 for i in range(N)]

for k in range(K):
    hito_len = int(input())
    have_hito = list(map(int, input().split()))
    for hh in have_hito:
        have_snack[hh - 1] = 1

print(have_snack.count(0))
N = int(input())
A = list(map(int,input().split()))
cnt = 0
while len(A)>1:
    cmin = 10**10
    for i in range(len(A)-2+1):
        if A[i]+A[i+1]<cmin:
            ind = i
            cmin = A[i]+A[i+1]
    cnt += cmin
    A[ind] += A[ind+1]
    A.pop(ind+1)
print(cnt)

### FIXED CODE ###

N = int(input())
A = list(map(int,input().split()))
A.insert(0,0)
B = [0 for _ in range(N+2)]
for i in range(N+1):
    B[i+1] = B[i]+A[i]
dp = [[0 for _ in range(N+2)] for _ in range(N+2)]
for i in range(N):
    dp[i][i+2] = A[i]+A[i+1]
for k in range(3,N+1):
    for i in range(1,N-k+2):
        dp[i][i+k] = dp[i][i+1]+dp[i+1][i+k]
        for j in range(i+2,i+k):
            dp[i][i+k] = min(dp[i][i+k],dp[i][j]+dp[j][i+k])
        dp[i][i+k] += B[i+k]-B[i]
print(dp[1][N+1])
def main():
    import sys
    input = sys.stdin.readline
    n=int(input())
    A=list(map(int,input().split()))
    mod=10**9+7
    from fractions import gcd

    if n==1:
        print(1)
    else:
        g=A[0]
        l=A[0]
        for i in range(n-1):
            g=gcd(l,A[i+1])
            l*=(A[i+1]//g)
        ans=0
        for i in range(n):
            ans+=(l//A[i])%mod        
    print(ans%mod)

if __name__ == '__main__':
    main()

### FIXED CODE ###

import sys
input = sys.stdin.readline
from fractions import gcd
n=int(input())
A=list(map(int,input().split()))
mod=10**9+7
def gyaku(a):
    return pow(a,mod-2,mod)
if n==1:
    print(1)
else:
    gya=[0]*(n)
    g=A[0]
    l=A[0]
    gya[0]=gyaku(A[0])
    for i in range(n-1):
        g=gcd(l,A[i+1])
        l*=(A[i+1]//g)
        gya[i+1]=gyaku(A[i+1])
    ans=0
    for i in range(n):
        ans+=l*gya[i]
        ans%=mod
    print(ans)
import sys
import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline

in_n = lambda: int(readline())
in_nn = lambda: map(int, readline().split())
in_nl = lambda: list(map(int, readline().split()))
in_na = lambda: map(int, read().split())
in_s = lambda: readline().rstrip().decode('utf-8')


def main():
    H, W = in_nn()
    a = np.array(read().split(), np.int32).reshape((H, W))

    odd_count = np.count_nonzero(a % 2 == 1)
    if odd_count % 2 == 1:
        odd_count -= 1

    count = 0
    x, y = 0, 0
    px, py = -1, -1
    odd_f = False
    while True:

        if odd_f:
            print(px + 1, py + 1, x + 1, y + 1)
            if a[y][x] % 2 == 1:
                odd_f = False
        else:
            if a[y][x] % 2 == 1:
                odd_f = True

        px, py = x, y
        if a[y][x] % 2 == 1:
            count += 1
            if count == odd_count:
                break

        if y % 2 == 0:
            if x == W - 1:
                y += 1
            else:
                x += 1
        else:
            if x == 0:
                y += 1
            else:
                x -= 1


if __name__ == '__main__':
    main()


### FIXED CODE ###

import sys
import numpy as np

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline

in_n = lambda: int(readline())
in_nn = lambda: map(int, readline().split())
in_nl = lambda: list(map(int, readline().split()))
in_na = lambda: map(int, read().split())
in_s = lambda: readline().rstrip().decode('utf-8')


def main():
    H, W = in_nn()
    a = np.array(read().split(), np.int32).reshape((H, W))

    odd_count = np.count_nonzero(a % 2 == 1)
    if odd_count % 2 == 1:
        odd_count -= 1

    count = 0
    x, y = 0, 0
    px, py = -1, -1
    odd_f = False

    ans = []
    while True:

        if odd_f:
            ans.append((py + 1, px + 1, y + 1, x + 1))
            if a[y][x] % 2 == 1:
                odd_f = False
        else:
            if a[y][x] % 2 == 1:
                odd_f = True

        px, py = x, y
        if a[y][x] % 2 == 1:
            count += 1
            if count >= odd_count:
                break

        if y % 2 == 0:
            if x == W - 1:
                y += 1
            else:
                x += 1
        else:
            if x == 0:
                y += 1
            else:
                x -= 1

        if y >= H:
            break

    print(len(ans))
    for a in ans:
        print(*a)


if __name__ == '__main__':
    main()
import collections

N = int(input())
a = list(map(int,input().split()))
a = collections.Counter(a)

value, count = zip(*a.most_common())

if count[0]+count[1]+count[2] != N:
    print('No')

elif value[0]^value[1]^value[2] != 0:
    print('No')

elif count[0]==count[1]==count[2]:
    print('Yes')

else:
    print('No')


### FIXED CODE ###

import collections

N = int(input())
a = list(map(int,input().split()))
a = collections.Counter(a)

value, count = list(a.keys()), list(a.values())

if len(value)<3:
    if len(value)==1:
        if sum(a)==0:
            print('Yes')
        else:
            print('No')

    if len(value)==2:
        if 0 in value:
            if count[0]==N/3 or count[1]==N/3:
                print('Yes')
            else:
                print('No')

        else:
            print('No')

if len(value)>=3:
    if count[0]+count[1]+count[2] == N:
        if value[0]^value[1]^value[2] == 0:
            if count[0]==count[1]==count[2]:
                print('Yes')
            else:
                print('No')
        else:
            print('No')
    else:
        print('No')