Harryxun/stf_run huggingface dataset:
n=int(input())
a=0
b=0
for i in range(2,10,1):
  if n%i=0 and n/i<=9:
    a=1
  else:
    b+=1
    
if a==1:
  print("Yes")
else:
  print("No")
    
    
  

### FIXED CODE ###

n=int(input())
a=1
b=0
for i in range(1,10,1):
  if n%i==0 and n/i<=9:
    a=a*0
  else:
    b+=1
    
if a==0:
  print("Yes")
else:
  print("No")
days = {"SUN":7, "SAT": 1, "FRI":2, "THU":3, "WED":4, "TUR":5, "MON": 6}
s = input()
print(days[s])


### FIXED CODE ###

dic = {"SUN": 7, "MON": 6, "TUE": 5, "WED": 4, "THU": 3, "FRI": 2, "SAT": 1}
print(dic[input()])
from math import sqrt

n = int(input())
 
def calc(n):
    if n < 6:
        return 0
    if n == 6:
        return 1
    if 6 < n < 11:
        return 0
    if n == 11:
        return 3
    if 11 < n < 17:
        return 0
    if n == 17:
        return 3
    if n == 18:
        return 3
    ans = 0
    for x in range(1, sqrt(n)//1):
        for y in range(1, sqrt(n)//1):
            for z in range(1, sqrt(n)//1):
                if x**2 + y**2 + z**2 + x*y + y*z + z*x == n:
                    ans += 1
 
    return ans
 
for i in range(1, n+1):
    print(calc(i))


### FIXED CODE ###

n = int(input())
ans = [0 for _ in range(n+1)]
def calc(n):
    for x in range(1, int(n**0.5)+1):
        for y in range(1, int(n**0.5)+1):
            for z in range(1, int(n**0.5)+1):
                v = x**2 + y**2 + z**2 + x*y + y*z + z*x
                if v < n+1:
                    ans[v] += 1

calc(n)
for i in range(n):
    print(ans[i+1])
a,b,k = map(int,input().split())

li = [i for i in range(a,b+1)]
print(li[0])
print(li[k-1])
print(li[-k])
print(li[-1])


### FIXED CODE ###

A,B,K = map(int,input().split())
if (B - A + 2)//2 <= K:
    L = list(range(A,B+1))
else:
    L = list(range(A,A+K)) + list(range(B-K+1,B+1))
for i in L:
    print(i)
import math

def f(x, y, z):
  return(x ** 2 + y ** 2 + z ** 2 + x * y + y * z + z * x)

n = int(input())
fs = [0] * n

lim = math.floor(math.sqrt(n))
rng = range(2, lim)

for(x in rng):
  for(y in rng):
    for(z in rng):
      v = f(x, y, z)
      if v <= n:
      	fs[v - 1] += 1
      
for(i in range(n)):
  print(fs[i])


### FIXED CODE ###

import math

def f(x, y, z):
  return(x ** 2 + y ** 2 + z ** 2 + x * y + y * z + z * x)

n = int(input())
fs = [0] * n

lim = math.floor(math.sqrt(n))
rng = range(1, lim)

for x in rng:
  for y in rng:
    for z in rng:
      v = f(x, y, z)
      if v <= n:
      	fs[v - 1] += 1
      
for i in range(n):
  print(fs[i])
N=int(input())
v=list(map(int,input().split()))
v.sort()
if len(v)==1:
    print(v[0])
elif len(v)==2:
    print((v[0]+v[1])/2)
else:
    s+=0
    s+=(v[0]+v[1])/2
    for j in range(2,N):
        s+=v[j]/(2**(N+1-j))    
    print(s)

### FIXED CODE ###

N=int(input())
v=list(map(int,input().split()))
v.sort()
s=v[0]
for j in range(1,N):
    s=(s+v[j])/2
print(s)
n,g,s = map(int,input().split())
G = [[] for _ in range(n)]
for i in range(n):
  a,b = map(int,input().split())
  G[a-1].append(b-1)
  G[b-1].append(a-1)
  
def dfs(V,v,d):
  if V[v] != -1:
    return
  V[v] = d
  for nv in G[v]:
    dfs(V,nv,d+1)
  
if len(G[g-1])==1 and G[g-1][0]==s-1:
  print(0)
else:
  vs = [-1]*n
  vg = [-1]*n
  dfs(vs,s-1,0)
  dfs(vg,g-1,0)
  
  ans = 0
  for i in range(n):
    if vs[i]>vg[i]:
      ans = max(ans,vs[i])
      
  print(ans-1)

### FIXED CODE ###

import sys
sys.setrecursionlimit(10**6)

n,g,s = map(int,input().split())
G = [[] for _ in range(n)]
for i in range(n-1):
  a,b = map(int,input().split())
  G[a-1].append(b-1)
  G[b-1].append(a-1)
  
def dfs(V,v,d):
  if V[v] != -1:
    return
  V[v] = d
  for nv in G[v]:
    dfs(V,nv,d+1)
  
if len(G[g-1])==1 and G[g-1][0]==s-1:
  print(0)
else:
  vs = [-1]*n
  vg = [-1]*n
  dfs(vs,s-1,0)
  dfs(vg,g-1,0)
  
  ans = 0
  for i in range(n):
    if vs[i]>vg[i]:
      ans = max(ans,vs[i])
      
  print(ans-1)
# A * B  = N - C
N = int(input())
count = 0
for i in range(1, N):
    AB = N - i
    count += len(make_divisors(AB))

print(count)

### FIXED CODE ###

N = int(input())

N_m1 = N - 1
counter = 0
for i in range(1, N_m1 + 1):
    counter += N_m1 // i

print(counter)
S=input()
l=len(S)
s=list(S)
if s[l]=="s":
  print(S+"es")
else:
  print(S+"s")

### FIXED CODE ###

S=input()
l=len(S)
s=list(S)
if s[l-1]=="s":
  print(S+"es")
else:
  print(S+"s")
n, k = map(int, input().split())
check = 0
ans = []
for i in range(n):
    a, b = map(int, input().split())
    check += b
    ans.append(str(a)*b)
    if check >= k:
        ans = "".join(ans)
        print(ans[k-1])
        break 

### FIXED CODE ###

N, K = map(int, input().split())
ans = 0
memory = [0]*(10**5+1)

for i in range(N):
    a, b = map(int, input().split())
    memory[a] += b

for i in range(10**5+1):
    ans += memory[i]
    if ans >= K:
        print(i)
        break
N,M=map(int,input().split())
ab=[list(map(int,input().split()))for _ in range(M)]

class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

uf=UnionFind(N)
for a,b in ab:
    uf.union(a,b)
print(uf.group_count()-1)

### FIXED CODE ###

N,M=map(int,input().split())
ab=[list(map(int,input().split()))for _ in range(M)]

class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

uf=UnionFind(N)
for a,b in ab:
    uf.union(a-1,b-1)
print(uf.group_count()-1)
g=str(input())
print("x"*len(s))

### FIXED CODE ###

g=str(input())
print("x"*len(g))
from itertools import*
from math import*
from collections import*
from heapq import*
from bisect import bisect_left,bisect_right
from copy import deepcopy
inf = float("inf")
mod = 10**9+7
from functools import reduce
import sys
sys.setrecursionlimit(10**7)


N = int(input())
pair=defaultdict(int)
xy = []
for i in range(N):
    x,y = map(int,input().split())
    xy.append((x,y))
for i in range(N):
    for j in range(N):
        if i != j
        pair[(xy[j][0]-xy[i][0],xy[j][1]-xy[i][1])] += 1

m = 0
for v in pair.values():
    m = max(m,v)
print(N-m)

### FIXED CODE ###

from itertools import*
from math import*
from collections import*
from heapq import*
from bisect import bisect_left,bisect_right
from copy import deepcopy
inf = float("inf")
mod = 10**9+7
from functools import reduce
import sys
sys.setrecursionlimit(10**7)


N = int(input())
pair=defaultdict(int)
xy = []
for i in range(N):
    x,y = map(int,input().split())
    xy.append((x,y))
for i in range(N):
    for j in range(N):
        if i != j:
            pair[(xy[j][0]-xy[i][0],xy[j][1]-xy[i][1])] += 1

m = 0
for v in pair.values():
    m = max(m,v)
print(N-m)
def main(n, m, p_s):
    st = [False for _ in range(n)]
    ac, wa = 0, 0

    for p, s in p_s:
        if st[p - 1]:
            continue

        if s == "AC":
            ac += 1
            st[p - 1] = True
        if s == "WA":
            wa += 1

    print(ac, wa)


if __name__ == "__main__":
    n, m = map(int, input().split())
    p_s = [list(map(int, input().split())) for _ in range(m)]

    main(n, m, p_s)


### FIXED CODE ###

def main(n: int, m: int, p_s: list):
    bool_ac = [False for _ in range(n)]
    count_wa = [0 for _ in range(n)]
    ac, wa = 0, 0

    for p, s in p_s:
        p = int(p)

        if bool_ac[p - 1]:
            continue

        if s == "AC":
            bool_ac[p - 1] = True
            wa += count_wa[p - 1]
            ac += 1
        elif s == "WA":
            count_wa[p - 1] += 1

    print(ac, wa)


if __name__ == "__main__":
    n, m = map(int, input().split())
    p_s = [input().split() for _ in range(m)]

    main(n, m, p_s)
# when input length is odd, n-1 / 2
# when input length is even, n / 2
# 6
# 2 7 1 8 2 8
# 1 8 7 8 2 2
# # # # # #
# 3個(len/2)４の倍数がYesを出力できる
# 4の倍数の個数がlen/2以下になるときその個数分*2個分２があれば、Yesを出力できる
N = int(input())
input_list = [int(i) for i in input().split()]
four_count = 0
two_count = 0

for i in input_list:
    if i % 4 == 0:
        four_count += 1
    elif i % 2 == 0:
        two_count += 1

const = N // 2

if const > four_count:
    if 2 * (const - four_count) =< two_count:
        print("Yes")
    else:
        print("No")
elif const == four_count:
    print("Yes")
else:
    print("Yes")

### FIXED CODE ###

N = int(input())
input_list = [int(i) for i in input().split()]
four_count = 0
two_count = 0

for i in input_list:
    if i % 4 == 0:
        four_count += 1
    elif i % 2 == 0:
        two_count += 1

others_count = N - four_count - two_count

if two_count:
    if others_count <= four_count:
        print("Yes")
    else:
        print("No")
else:
    if others_count <= four_count + 1:
        print("Yes")
    else:
        print("No")
#import sys
N = int(input())
NL = list(range(1,N+1))
print(sum(NL) - N)



### FIXED CODE ###

N = int(input())
print(N * (N - 1) // 2)
from decimal import *

a, b, c = map(int, input().split())
if Decimal(a).sqrt() + Decimal(b).sqrt() < Decimal(c).sqrt():
    print("Yes")
else:
    print("No")

### FIXED CODE ###

a = [0,1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]

print(a[int(input())])
i=1
while input()!=0
    print("Case " ,i,":",input())
    i += 1


### FIXED CODE ###

i=1
while True:
    x = int(input())
    if x==0: break
    print("Case {0}: {1}".format(i,x))
    i += 1
n, d, a = map(int, input().split())
lst = []
for i in range(n):
    xi, hi = map(int, input().split())
    if hi % a == 0:
        hi = hi // a
    else:
        hi = hi // a + 1
    lst.append([xi, hi])
lst.sort(key=lambda x: x[0])
x, h = [], []
for i in range(n):
    x.append(lst[i][0])
    h.append(lst[i][1])

x.append(10**11)
h.append(0)

kougeki_start = 0
kougeki_end = 0
cnt = 0
i = 0
while i <= n:
    if h[i] > 0:
        left = i # 可能
        right = n # 不可能
        while left+1 < right:
            mid = (left + right) // 2
            if x[mid] - x[i] <= 2*d:
                left = mid
            else:
                right = mid
        cnt += h[i]
        hiku = h[i]
        bit = 0
        for j in range(i, left+1):
            h[j] -= hiku
            if bit == 0 and h[j] > 0:
                next_i = j
                bit = 1
        i = next_i

print(cnt)

### FIXED CODE ###

n, d, a = map(int, input().split())
lst = []
for i in range(n):
    xi, hi = map(int, input().split())
    if hi % a == 0:
        hi = hi // a
    else:
        hi = hi // a + 1
    lst.append([xi, hi])
lst.sort(key=lambda x: x[0])
x, h = [], []
for i in range(n):
    x.append(lst[i][0])
    h.append(lst[i][1])

x.append(10**11)
h.append(0)

# 攻撃に巻き込めるインデックスを求める
left = 0 # 可能
right = n # 不可能
while left+1 < right:
    mid = (left + right) // 2
    if x[mid] - x[0] <= 2*d:
        left = mid
    else:
        right = mid
makikomi = [left]
right = left
for i in range(1, n):
    while x[right] - x[i] <= 2*d:
        right += 1
    right -= 1
    makikomi.append(right)

cnt = [0 for i in range(n)]
left = 0
already = 0
for i in range(n):
    while x[makikomi[left]] < x[i]:
        already -= cnt[left]
        left += 1
    cnt[i] = max(h[i] - already, 0)
    already += cnt[i]

print(sum(cnt))
N=int(input())
A=map(int,input().split())
ans=1
for i in range(N):
  ans*=A[i]
  if ans > 10**18:
    break
if ans > 10**18:
  print(-1)
else:
  print(ans)

### FIXED CODE ###

N=int(input())
A=list(map(int,input().split()))
if 0 in A:
    print(0)
else:
    ans=1
    for i in range(N):
        ans*=A[i]
        if ans >10**18:
            break
    if ans > 10**18:
      print(-1)
    else:
      print(ans)
N, M = map(int, input().split())
A = list(map(int, input().split())
         
print(max(-1, N-sum(A)))

### FIXED CODE ###

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

print(max(-1, N-sum(A)))
def gost(lis,ky):
    
    lens=len(lis)
    
    if lens <= 5:
        if ky in lis:
            return True
        else:
            return False
    
    if ky <= lis[lens//2]:
        return gost(lis[:lens],ky)
    else:
        return gost(lis[lens:],ky)
    

n = int(input())
a = input()
s=list(map(int,a.split()))

q = int(input())
a = input()
t=list(map(int,a.split()))


i = 0
for it in t:
    if gost(s,it):
        i = i+1
print(i)

### FIXED CODE ###

def gost(lis,ky,r,l):
    
    lens=l-r+1
    
    if lens <= 5:
        if ky in lis[r:l+1]:
            return True
        else:
            return False
    
    if ky <= lis[r+(lens//2)-1]:
        return gost(lis,ky,r,r+(lens//2)-1)
    else:
        return gost(lis,ky,r+(lens//2),l)
    

n = int(input())
a = input()
s=list(map(int,a.split()))

q = int(input())
a = input()
t=list(map(int,a.split()))


i = 0
for it in t:
    if gost(s,it,0,n-1):
        i = i+1
print(i)
a=[]
import sys
for s.strip() in sys.stdin:
 if s=='0 0':break
 a.append(s)
for t in a:
 x,y=map(int,t.split())
 print(f'{y} {x}') if x>y else print(t)

### FIXED CODE ###

import sys
for s in sys.stdin:
 if'0 0\n'==s:break
 print(*sorted(map(int,s.split())))
from math import floor:
h = int(input())

c = 0

def attack(h):
  if h == 1:
    c += 1
    return c
  else:
    return attack(floor(2/h)) + attack(floor(2/h))
  
print(attack(h))

### FIXED CODE ###

from math import floor,log2
h = int(input())
d = floor(log2(h))
c = 1
for i in range(0,d):
  c += 2 ** (d-i)

print(c)
A, B, C, D = map(int, input().split())

if abs(A - C) <= D: #直接会話する場合
  print("Yes")
else:
  if (abs(A - B) <= D) AND (abs(B - C) <= D):
    print("Yes")
  else:
    print("No")

### FIXED CODE ###

A, B, C, D = map(int, input().split())

if abs(A - C) <= D: #直接会話する場合
  print("Yes")
elif (abs(A - B) <= D) and (abs(B - C) <= D): #間接的に会話する場合
  print("Yes")
else:
  print("No")
W, H, N = map(int,input().split())
dx, dy = 0, 0

for i in range(N):
  x, y, a = map(int,input().split())
  if(a == 1):
    dx = max(dx, x)
  elif(a == 2):
    W = min(W, x)
  elif(a == 3):
    dy = max(dy, y)
  else:
    H = min(H, y)
if(dx <= W or dy <= H):
  print(0)
else:
  print((dx-W) * (dy-H))


### FIXED CODE ###

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

if((a+b == c) or (b+c == a) or (a+c == b)):
  print("Yes")
else:
  print("No")
import math
n= int(input())


counter = 0
for i in range(1,13):
    if int(26*(pow(26,i-1))/(26-1)) <= n < int(26*(pow(26,i))/(26-1)):
        counter = i
        break
kekka = n - int(26*(pow(26,counter-1))/(26-1)) + 1
syo = int(kekka/26)
amari = kekka%26

alplist=["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]

lists = []
i = counter-1
while i>= 0 :
    sho = int(kekka / pow(26,i))
    kekka = kekka - pow(26,i)*sho
    i -=1
    if i >= 0:
        lists.append(alplist[sho])
    else:
        lists.append(alplist[sho-1])


print("".join(lists))


### FIXED CODE ###


def C():
    import math
    n= int(input())

    counter = 0
    for i in range(1,13):
        if int(26*(pow(26,i-1))/(26-1)) <= n < int(26*(pow(26,i))/(26-1)):
            counter = i
            break
    kekka = n - int(26*(pow(26,counter-1))/(26-1))

    alplist=["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]

    kekkalist = []
    i = counter-1
    while i>= 0 :
        sho = int(kekka / pow(26,i))
        kekka = kekka - pow(26,i)*sho

        i -=1
        if i >= 0:
            kekkalist.append(alplist[sho])
        else:
            kekkalist.append(alplist[sho])


    print("".join(kekkalist))


C()
import sys
input = sys.stdin.readline
write = lambda x: sys.stdout.write(str(x))
LMIIS = lambda : list(map(int,input().split()))
II = lambda : int(input())
dbg = lambda *something : print(*something) if DEBUG is True else 0
DEBUG = False

def main():

    N = II()
    t = [-1] * N


    E = [  [] for _ in range(N)]
 
    reached = [False] * N
    for _ in range(N-1):
        u,v,w = LMIIS()
        u -=1
        v -=1
        E[u].append((v,w))
        E[v].append((u,w))
    dbg(E)
    t[E[0][0][0]] = 0

     
    def search(u):
        for v,w in E[u]:
            if t[v] == -1:
                t[v] = t[u] if w % 2 == 0 else t[u]^1
                search(v)
                

    search(E[0][0][0])

    for i in t:
        write(i)
        write(' ')






    pass
if __name__ == '__main__':
    main()

### FIXED CODE ###

import sys
sys.setrecursionlimit(2**31-1)
input = sys.stdin.readline
write = lambda x: sys.stdout.write(str(x))
LMIIS = lambda : list(map(int,input().split()))
II = lambda : int(input())
dbg = lambda *something : print(*something) if DEBUG is True else 0
DEBUG = False

def main():

    N = II()
    t = [-1] * N


    E = [  [] for _ in range(N)]
 
    reached = [False] * N
    for _ in range(N-1):
        u,v,w = LMIIS()
        u -=1
        v -=1
        E[u].append((v,w))
        E[v].append((u,w))
    dbg(E)
    t[E[0][0][0]] = 0

     
    def search(u):
        for v,w in E[u]:
            if t[v] == -1:
                t[v] = t[u] if w % 2 == 0 else t[u]^1
                search(v)
                

    search(E[0][0][0])

    for i in t:
        write(i)
        write(' ')






    pass
if __name__ == '__main__':
    main()
x, y = map(int, input().split())
ans = 10 ** 10
for i in range(2):
    for j in range(2):
        a = x
        b = y
        cnt = 0
        if i == 1:
            a *= -1
            cnt = 1
        if j == 1:
            b *= -1
            cnt += 1
        if a >= b:
            continue
        cnt += b - a
        a += b - a¥
        if a == b:
            ans = min(ans, cnt)

print(ans)


### FIXED CODE ###

x, y = map(int, input().split())
ans = 10 ** 10
for i in range(2):
    for j in range(2):
        a = x
        b = y
        cnt = 0
        if i == 1:
            a *= -1
            cnt = 1
        if j == 1:
            b *= -1
            cnt += 1
        if a > b:
            continue
        cnt += b - a
        a += b - a
        #print(cnt, a, b)
        if a == b:
            ans = min(ans, cnt)

print(ans)
_s = str(input())
 
l_arr = _s.split("L")
r_arr = _s.split("R")
l_max = max([len(x) for x in l_arr])
r_max = max([len(x) for x in r_arr])
t = max(l_max, r_max)
if t % 2 != 0:
    t -= 1
 
s = list(_s)
 
lg = len(s)
arr = [1 for i in range(lg)]
 
for i in range(t):
    next_arr = [0 for i in range(lg)]
    for j in range(lg):
        cmd = s[j]
        curr = arr[j]
        if cmd == "L":
            next_arr[j - 1] += curr
        else:
            next_arr[j + 1] += curr
    arr = next_arr
    
print(" ".join(map(str, arr)))
_s = str(input())

l_arr = _s.split("L")
r_arr = _s.split("R")
l_max = max([len(x) for x in l_arr])
r_max = max([len(x) for x in r_arr])
t = max(l_max, r_max)
if t % 2 != 0:
    t -= 1

s = list(_s)

lg = len(s)
arr = [1 for i in range(lg)]

for i in range(t):
    next_arr = [0 for i in range(lg)]
    for j in range(lg):
        cmd = s[j]
        curr = arr[j]
        if cmd == "L":
            next_arr[j - 1] += curr
        else:
            next_arr[j + 1] += curr
    arr = next_arr
    
print(" ".join(map(str, arr)))
提出情報
提出日時	2019-08-12 10:13:16
問題	D - Gathering Children
ユーザ	rororo 
言語	PyPy3 (2.4.0)


### FIXED CODE ###

s = list(str(input()))
n = len(s)
ans = [0] * n
for ri in range(2):
    cnt = 0
    for i in range(n):
        if s[i] == "R":
            cnt += 1
        else:
            ans[i] += cnt // 2
            ans[i - 1] += (cnt + 1) // 2
            cnt = 0

    s.reverse()
    ans.reverse()
    for i in range(n):
        if s[i] == "L":
            s[i] = "R"
        else:
            s[i] = "L"

print(" ".join(map(str, ans)))
import math
N = int(input())
A = list(map(int,input().split()))

L = [0]
g = 0
for i in range(N-1):
    g = math.gcd(g, A[i])
    L.append(g)

R = []
g = 0
for i in range(N-1):
    g = math.gcd(g, A[N-1-i])
    R.append(g)
R.reverse()
R.append(0)

ans = 0
for i in range(N):
    ans = max(ans, math.gcd(L[i],R[i]))

print(ans)





### FIXED CODE ###

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

def gcd(a, b):
    if a < b:
        a, b = b, a
    while b:
        a, b = b, a % b
    return a

L = [0]
g = 0
for i in range(N-1):
    g = gcd(g, A[i])
    L.append(g)

R = []
g = 0
for i in range(N-1):
    g = gcd(g, A[N-1-i])
    R.append(g)
R.reverse()
R.append(0)

ans = 0
for i in range(N):
    ans = max(ans, gcd(L[i],R[i]))

print(ans)
mod = 10**9+7
N = int(input())
A = list(map(int, input().split()))
n = max(A).bit_length()
S = [0]*N
for i, a in enumerate(A):
    S[i]=S[i-1]^a
index = [[-1] for _ in range(2<<n)]
cumsum = [0]*(N+1)
for i, s in enumerate(S):
    index[s].append(i)
    cumsum[i] = cumsum[i-1]
    if s == 0:
        cumsum[i]+=1
ans = 0
if S[-1] == 0:
    for i in range(1, 1<<n):
        l = len(index[i])
        if l == 1:
            continue
        dp = [0]*(l-1)
        dp_cum = [0]*(l-1)
        for j, k in enumerate(index[i][1:]):
            dp[j] = (dp_cum[j-1]*(cumsum[k]-cumsum[index[i][j]])+1)%mod
            dp_cum[j] = (dp_cum[j-1]+dp[j])%mod
        ans+=dp_cum[-1]
        ans%=mod
    ans+=pow(2, cumsum[N-1]-1, mod)
    ans%=mod
else:
    print(1/0)
    l = len(index[S[-1]])
    dp = [0]*(l-1)
    dp_cum = [0]*(l-1)
    for j, k in enumerate(index[S[-1]][1:]):
        dp[j] = (dp_cum[j-1]*(cumsum[k]-cumsum[index[S[-1]][j]])+1)%mod
        dp_cum[j] = (dp_cum[j-1]+dp[j])%mod
    ans = dp[-1]%mod
print(ans)

        



### FIXED CODE ###

from collections import defaultdict
from bisect import bisect_left as bisect
import sys
mod = 10**9+7
N = int(input())
A = list(map(int, input().split()))
S = [0]*(N+1)
zeros = []
count = defaultdict(list)
now = -1
for i in range(N):
    S[i] = S[i-1]^A[i]
    if S[i] == 0:
        zeros.append(i)
    else:
        count[S[i]].append(i)
if S[N-1] != 0:
    a = S[N-1]
    res = []
    cnt = 0
    for i in count[a]:
        res.append(bisect(zeros, i)-cnt)
        cnt+=res[-1]
    res0 = 1
    res1 = 0
    for c in res:
        res0 = res0+res1*c
        res1 = res1+res0
        res0%=mod
        res1%=mod
    print(res0)
    sys.exit()
ans = pow(2, len(zeros)-1, mod)
for a in count.keys():
    cnt = 0
    res = []
    for i in count[a]:
        res.append(bisect(zeros, i)-cnt)
        cnt+=res[-1]
    res0 = 1
    res1 = 0
    for c in res:
        res0 = res0+res1*c
        res1 = res1+res0
        res0%=mod
        res1%=mod
    ans+=res1
    ans%=mod
print(ans)
a=input()
if a[1]==a[2]==a[3]
  print("No")
else:
  print("Yes")

### FIXED CODE ###

a=input()
if a[0]==a[1]==a[2]:
  print("No")
else:
  print("Yes")