Harryxun/stf_run huggingface dataset:
A = int(input())
S = input()

if A >= 3200:
    print(S)
else:
    print("red")


### FIXED CODE ###

import numpy

A = int(input())
S = input()

if A >= 3200:
    print(S)
else:
    print("red")
import numpy as np
from math import inf

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

dp = np.zeros((N + 1, 2))
dp[0][1] = -inf
# dp[i][0]:=1-indexedで、a_iとa_i+1を反転させない場合の最大値
# dp[i][1]:=1-indexedで、a_iとa_i+1を反転させる場合の最大値

for i, aa in enumerate(a, 0):
    dp[i + 1][0] = max(dp[i][0] + aa, dp[i][1] - aa)
    dp[i + 1][1] = max(dp[i][0] - aa, dp[i][1] + aa)
print(dp[N][0])


### FIXED CODE ###

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

sa = 0
min_v = float('inf')
minus_count = 0
for aa in a:
    if aa < 0:
        minus_count += 1
        aa = abs(aa)
    min_v = min(min_v, aa)
    sa += aa

if minus_count % 2 == 0:
    print(sa)
else:
    print(sa - min_v * 2)
import sys
sys.setrecursionlimit(1000000)
import math
a, b = input().split()
c = int(math.floor(int(a) * float(b))
print(c)


### FIXED CODE ###

a,b = map(int, input().split())
c = a * b
print(c)
def gcd(a,b):
    while b:
        a,b=b,a%b
    return a

N,X=[int(i) for i in input().split()]
a=input().split()
x=[]
for i in range(N):
    x.append(int(a[i]))
if(N==1):
    print(abs(x[0]-X))
    exit()
x=list(map(lambda y:abs(y-X) , x))
ans=gcd(x[0],x[1])
for i in range(2:N):
    ans=gcd(x[i],ans)
    
print(ans)


### FIXED CODE ###

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

N,X=[int(i) for i in input().split()]
a=input().split()
x=[]
for i in range(N):
    x.append(int(a[i]))
if(N==1):
    print(abs(x[0]-X))
    exit()
x=list(map(lambda y:abs(y-X) , x))
ans=gcd(x[0],x[1])
for i in range(2,N):
    ans=gcd(x[i],ans)
print(ans)
OddString

### FIXED CODE ###

S = str(input())

print(S[::2])
nk = list(map(int,input().split()))
p = list(map(int,input().split()))
ans = [0] * (nk[0] + nk[1])
 
zeros = [0] * nk[1]
 
seq4search = zeros + p
 
for i in range(nk[1], nk[0] + nk[1]):
    seq4search[i] = (seq4search[i] + 1) / 2
    ans[i] = ans[i-1] + seq4search[i] - seq4search[i - k] 
 
print(max(ans))

### FIXED CODE ###

nk = list(map(int,input().split()))
p = list(map(int,input().split()))
ans = [0] * (nk[0] + nk[1])
 
zeros = [0] * nk[1]
 
seq4search = zeros + p
 
for i in range(nk[1], nk[0] + nk[1]):
    seq4search[i] = (seq4search[i] + 1) / 2
    ans[i] = ans[i-1] + seq4search[i] - seq4search[i - nk[1]] 
 
print(max(ans))
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

for i, val in enumerate(elements):
    if i is K:
        print(val)
        break

### FIXED CODE ###

elements = [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]
K = int(input())
th = K-1
print(elements[th])
A,B,K=map(int,input().split())
num_right=num[:K]
num_left=sorted(num,reverse=True)[:K]
ans=list(set(num_right+num_left))
for i in ans:
    print(i)

### FIXED CODE ###

A,B,K=map(int,input().split())
if B-A+1-2*K>=0:
    for i in range(A,A+K):
        print(i)
    for i in range(B-K+1,B+1):
        print(i)
else:
    for i in range(A,B+1):
        print(i)
def Sum_xxor(ans_tmp,A,tmp,saiteki,ind_max):

    ans_ret = 0
    ans_x = ans_tmp

    for i in range(ind_max):
        if Ones[i] <= N-Ones[i]:
            ans_x += bits[i]*1
        else:
            ans_x += bits[i]*0

    for a in A:
        ans_ret += ans_x ^ a

    return ans_ret

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

Ones   = [0 for _ in range(41)]
bits  = [0 for _ in range(41)]

for i in range(41):
    if i == 0:
        bit = 1
    else:
        bit *= 2
    bits[i] = bit

    Ones_i = 0

    for a in A:
        if a & bit:
            Ones_i += 1

    Ones[i] = Ones_i

t,ans = bit, 0
ind = 41
ans_tmp = 0
ch = 0
while t:
    if ch == 0:
        if not(t & (K+1)):
            ans_tmp += 0
        else:
            ch = 1

            ind_max = ind - 1
            ans = max(ans, Sum_xxor(ans_tmp,A,Ones,saiteki,ind_max))

            ans_tmp += t

    else:
        if t & (K+1):

            ind_max = ind - 1
            ans = max(ans, Sum_xxor(ans_tmp,A,Ones,saiteki,ind_max))

            ans_tmp += t


    t  //= 2
    ind -= 1


print(ans)


### FIXED CODE ###

#https://atcoder.jp/contests/abc117/submissions/4165407
n,k=map(int,input().split())
a=list(map(int,input().split()))
t,ans=2**40,0
while t:
    c=sum([(a[i]&t)//t for i in range(n)])
    if k<t or c*2>=n:
        ans+=t*c
    else:
        ans+=t*(n-c)
        k -= t
    t //= 2

print(ans)
S = input()
T = input()
alll = ['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']
alfa = {'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'}
count_s = set()
count_t = set()
for s in range(len(S)):
    if count_s == alfa:
        break
    if S[s] in count_s:
        continue
    count_s.add(S[s])
    S = S.replace(S[s],str(alll[s]))
for t in range(len(T)):
    if count_t == alfa:
        break
    if t in count_t:
        continue
    count_t.add(T[t])
    T = T.replace(T[t],str(alll[t]))
if S == T:
    print('Yes')
else:print('No')

### FIXED CODE ###

S = input()
T = input()
check = {'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'}
alll = ['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']
alfa = {'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'}
count_s = set()
count_t = set()
nums = 0
numt = 0
for s in range(len(S)):
    if count_s == alfa:
        break
    if S[s] in check:
        continue
    count_s.add(S[s])
    S = S.replace(S[s],str(alll[nums]))
    nums += 1
for t in range(len(T)):
    if count_t == alfa:
        break
    if T[t] in check:
        continue
    count_t.add(T[t])
    T = T.replace(T[t],str(alll[numt]))
    numt += 1
if S == T:
    print('Yes')
else:print('No')
import sys

N,P=[int(i) for i in input().split()]
i=2
ans = 1
c=0
if N == 1:
  print(P)
  sys.exit()
while P>i*i:
  if P%i==0:
    P//=i
    c+=1
    if c==N:
      ans*=i
      c=0
  else:
    c=0
    i+=1
if p==i and c+1 ==N:
  ans*=i
print(ans)


### FIXED CODE ###

import sys

N,P=[int(i) for i in input().split()]
i=2
ans = 1
c=0
if N == 1:
  print(P)
  sys.exit()
while P>i*i-4:
  if P%i==0:
    P//=i
    c+=1
    if c==N:
      ans*=i
      c=0
  else:
    c=0
    i+=1
if P==i and c+1 ==N:
  ans*=i
print(ans)
n = int(input())
m = int(input())
print(n*m - 1)

### FIXED CODE ###

n,m = map(int,input().split())
print((n-1)*(m-1))
S = input()
a = count("A")
if a == 3:
    print("No")
else:
    print("Yes")

### FIXED CODE ###

S = input()
a = S.count("A")

if a == 3 or a == 0:
    print("No")
else:
    print("Yes")
import math

A, B = [int(i) for i in input().split()]

answer = (A * B) // math.gcd(A, B)
print(answer)

### FIXED CODE ###

A, B = [int(i) for i in input().split()]

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

def lcm(a, b):
    return (a * b) // gcd(a, b)
	
answer = lcm(A, B)
print(answer)
from collections import defaultdict
from operator import itemgetter


def solve():
    N, M = map(int, input().split())
    xy_dict = defaultdict(int)
    xy = [[] for _ in range(N)]
    for _ in range(M):
        x, y, z = map(lambda j: int(j)-1, input().split())
        xy_dict[x] += 1
        xy_dict[y] += 1
        xy[x].append(y)
        xy[y].append(x)
    
    xy_sorted = sorted(xy_dict.items(), key=itemgetter(1), reverse=True)
    opened = [0 for _ in range(N)]
    ans = N
    length = len(xy_sorted)
    for i in range(length):
        parent = xy_sorted[i][0]
        if opened[parent] == 1:
            for child in xy[parent]:
                if opened[child] == 0:
                    opened[child] = 1
                    ans -= 1
            continue
        opened[parent] = 1
        for child in xy[parent]:
            opened[child] = 1
        ans -= xy_dict[parent]
    print(ans)


if __name__ == '__main__':
    solve()


### FIXED CODE ###

def solve():
    N, K = map(int, input().split())
    s = input()
    s_lower = s.lower()
    s = list(s)
    s[K-1] = s_lower[K-1]
    print(''.join(s))

if __name__ == '__main__':
    solve()
N = int(input())
print(lst)
for i in range(1000):
    if N in lst:
        print(N)
        break
    else:
        N += 1

### FIXED CODE ###

N = int(input())
lst = [i*100+i*10+i for i in range(1,10)]
for i in range(1000):
    if N in lst:
        print(N)
        break
    else:
        N += 1
c=0
def doublet(n,f):
    global c
    if n<f:
        c=c+1
        return doublet(2*n,f)
    else:
        return c
num=int(input())
k=int(input())
if (num>=1 and num<=10**5) and (k>=1 and k<=10**5):
    sum_power=0.0
    for i in range(1,(num+1),1):
        count=doublet(i,k)
        p=pow(2,count)*num
        sum_power=sum_power+(1/p)
        c=0
    print(sum_power)


    


### FIXED CODE ###

n,K=input().split()
n=int(n)
K=int(K)
S=input()
print(S[:(K-1)]+chr(ord(S[K-1])+32)+S[(K):])
#

array = list(map(int, input().strip().split(' ')))


N =  array[0]

T =  array[1]


#print(N)
#print(T)

if N < 1:
    quit()

if N > 100:
    quit()


if T < 1:
    quit()

if T > 1000:
    quit()




c_min = 9999


for i in range(N):
    array1 = list(map(int, input().strip().split(' ')))
    cN =  array1[0]

    tN =  array1[1]

    if cN < 1:
        quit()

    if cN > 1000:
        quit()

    if tN < 1:
        quit()

    if tN > 1000:
        quit()

    if tN <= T:
        if c_min > cN:

            c_min = cN

if c_min == 0:
    print("TLE")

else:
    print(c_min)

    

### FIXED CODE ###

n = int(input())


if n == 1:
    print("Hello World")

elif n == 2:

     a = int(input())
     b = int(input())

     c = a + b
     print(c)
import math
def is_prime(n):
    if n == 1:
        return False
    for k in range(2, int(math.sqrt(n)) + 1):
        if n % k == 0:
            return False
    return True
    
x = int(input())
for i in range(x, 2*x:
    if is_prime(i):
        print(i)
        break

### FIXED CODE ###

import math
def is_prime(n):
    if n == 1:
        return False
    for k in range(2, int(math.sqrt(n)) + 1):
        if n % k == 0:
            return False
    return True
    
x=int(input())
for i in range(x, 2*x):
    if is_prime(i):
        print(i)
        break
while True
  x = input()
  if x == 0 :
    break 

  else:
   sum = 0 
   for i  in range(len(x)) :  
   sum += int(x[i])

### FIXED CODE ###

while True :
  x = input()
  if x == '0' :
    break 

  else:
   sum = 0 
   for i  in range(len(x)) :  
    sum += int(x[i])

  print(sum)
contest = int(input())

if contest == "ABC":
  print("ARC")
else:
  print("ABC")



### FIXED CODE ###

contest = str(input())
 
if contest == "ABC":
  print("ARC")
else:
  print("ABC")
import fractions

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

def l(m):
    if m == 0:
        return 0
    else:
        return fractions.gcd(l(m-1),a[m-1])
def r(m):
    if m == 0:
        return 0
    else:
        return fractions.gcd(r(m-1),a[n-m])
print(max([fractions.gcd(l(i),r(n-i-1)) for i in range(n)]))

### FIXED CODE ###

def gcd(x,y):
    while y != 0:
        x,y = y,x%y
    return x
n = int(input())
a = list(map(int,input().split()))

L,R = [0],[0]
for i in range(1,n+1): #L[i]は左i個,R[i]は右i個
    L.append(gcd(L[-1],a[i-1]))
    R.append(gcd(R[-1],a[n-i]))
print(max(gcd(L[i],R[n-i-1]) for i in range(n)))
i = int(input())
s = input()
print(s[0:k-1] if len(s) > k else s)


### FIXED CODE ###

k = int(input())
s = input()
print(s[0:k] + "..." if len(s) > k else s)
n = int(input())
h = list(map(int,input().split()))

dp = [0, abs(h[1]-[0])]

for i in range(2,n):
    dp.append(min(dp[i-1] + abs(h[i]-h[i+1]), dp[i] + abs(h[i]-h[i+2])))
    
print(dp[-1])

### FIXED CODE ###

n = int(input())
h = list(map(int, input().split()))
dp = [float('inf')] * n
dp[0] = 0

for i in range(n - 1):
    if i <= n - 3:
        dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i] - h[i + 1]))
        dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i] - h[i + 2]))
    elif i == n - 2:
        dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i] - h[i + 1]))

print(dp[-1])
= int(input())
S = input().strip()
cmax = 0
for k in range(1,N//2+1):
    C = {}
    x = S[:k]
    C[x]=[0]
    for i in range(1,N-k+1):
        x = x[1:]+S[i+k-1]
        if x not in C:
            C[x]=[]
        C[x].append(i)
    flag = 0
    for a in C:
        if len(C[a])>1:
            if C[a][0]-C[a][-1]>=k:
                cmax = max(cmax,k)
                flag = 1
                break
            if flag==1:break
print(cmax)

### FIXED CODE ###

N = int(input())
S = input().strip()
cmax = 0
for k in range(1,N):
    X = S[:N-k]
    Y = S[k:]
    cur = 0
    cnt = 0
    for i in range(N-k):
        if X[i]!=Y[i]:
            cmax = max(cmax,min(cnt,k))
            cur = i
            cnt = 0
        else:
            cnt += 1
    cmax = max(cmax,min(cnt,k))
print(cmax)
n,m=[int(i) for i in input().split()]
P=[[int(i) for i in input().split()] for j in range(m)]

def prefecturesort(i):
    return i[0]

def yearsort(i):
    return i[1]

W=[]
Z=[]

for i in range(m):
    P[i].append(i)
    W.append(P[i][0])

P.sort(key=prefecturesort)
P_c=[]
sum=0
for i in range(n):
    P_c.append(P[sum:W.count(i+1)+sum])
    sum+=c
    P_c[i].sort(key=yearsort)
for x in P_c:
    for j in range(len(x)):
        X=str("{0:06d}".format(x[j][0]))
        Y=str("{0:06d}".format(j+1))
        Z.append([X+Y,x[j][2]])
Z.sort(key=yearsort)
for i in range(m):
    print(Z[i][0])

### FIXED CODE ###

n,m=[int(i) for i in input().split()]
P=[[int(i) for i in input().split()] for j in range(m)]

def prefecturesort(i):
    return i[0]

def yearsort(i):
    return i[1]

W=[0 for i in range(n)]
Z=[]

for i in range(m):
    P[i].append(i)
    W[P[i][0]-1]+=1

P.sort(key=prefecturesort)
P_c=[]
sum=0
for i in range(n):
    c=W[i]
    if c==0:
        P_c.append([])
    else:
        P_c.append(P[sum:c+sum])
    sum+=c
    P_c[i].sort(key=yearsort)
for x in P_c:
    for j in range(len(x)):
        X=str("{0:06d}".format(x[j][0]))
        Y=str("{0:06d}".format(j+1))
        Z.append([X+Y,x[j][2]])
Z.sort(key=yearsort)
for i in range(m):
    print(Z[i][0])
n=int(input())
K=input()
if len(k)<=n:
  print(k)
else:
  a=k[0:n+1]
  print(a+"...")

### FIXED CODE ###

n=int(input())
k=input()
if len(k)<=n:
  print(k)
else:
  a=k[:n]
  print(a+"...")
import math

n,x = [int(i) for i in input().split()]

lis = list(map(int,input().split()))
diffs = []
for i in range(n):
    diff = abs(lis[i]-x)
    diffs.append(diff)

if n > 1:
    com = math.gcd(diffs[0],diffs[1])
    for i in range(n-2):
        com = math.gcd(com, diffs[i+2])
else:
    com = diffs[0]

print(com)

### FIXED CODE ###

import fractions

n,x = [int(i) for i in input().split()]

lis = list(map(int,input().split()))
diffs = []
for i in range(n):
    diff = abs(lis[i]-x)
    diffs.append(diff)


if len(diffs) > 1:
    com = fractions.gcd(diffs[0],diffs[1])
    for i in range(len(diffs)-2):
        com = fractions.gcd(com, diffs[i+2])
else:
    com = diffs[0]

print(com)
import math
a, b, x = map(int,input().split())
sita = 0
c = 0
if a*a*b/2 <= x:
  c = a*a*a/2/(a*a*b-x)
  sita = math.atan(c)
else:
  c = 2*x/a/b/b
  sita = math.atan(c)
print(90.0000-math.degrees(sita))

### FIXED CODE ###

import math
a, b, x = map(int,input().split())
sita = 0
c = 0
if x == a*b*b:
  sita = math.pi/2
elif a*a*b/2 <= x:
  c = a*a*a/2/(a*a*b-x)
  sita = math.atan(c)
else:
  c = 2*x/a/b/b
  sita = math.atan(c)
print('{:.10g}'.format(90-math.degrees(sita)))
a, b = map(int(input()).split())
seki = a * b
sekito = seki % 2
if sekito == 1:
  response = 'Odd'
else :
  response = 'Even'
print(response)

### FIXED CODE ###

a, b = map(int, input().split())
seki = a * b
sekito = seki % 2
if sekito == 1:
  response = 'Odd'
else :
  response = 'Even'
print(response)
a,b=map(int,input().split())
if a-2b>0:
  print(a-2b)
else:
  print(0)

### FIXED CODE ###

a,b=map(int,input().split())
if a-2*b>0:
  print(a-2*b)
else:
  print(0)
uppers = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
lowers = 'abcdefghijklmnopqrstuvwxyz'
s = []
while len(s) < 1200:
    s += list(input())
for i in range(26):
    print(lowers[i] + ' : ' + str(s.count(uppers[i]) + s.count(lowers[i])))

### FIXED CODE ###

import sys
uppers = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
lowers = 'abcdefghijklmnopqrstuvwxyz'
s = []
for line in sys.stdin:
    s += line
for i in range(26):
    print(lowers[i] + ' : ' + str(s.count(uppers[i]) + s.count(lowers[i])))
x ** 3

### FIXED CODE ###

x = int(input())
print(x ** 3)
import numpy as np
a = int(input())
b = np.array(list(map(int, input().split())))
b = np.prod(b)
if c > 10**18:
    print('-1')
else:print(c)


### FIXED CODE ###

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

if 0 in a:
    print(0)
    exit()

mult = 1

for i in a:
    mult *= i
    if mult > 10**18:
        print(-1)
        exit()
print(mult)
a = int(input())
b = int(input())
c = int(input())
print(c, a, b)


### FIXED CODE ###

a, b, c = map(int, input().split())
print(c, a, b)
n = [int,input() for i in range(1,5)]

x = min(n[0], n[1])+ min(n[2], n[3])

print(x)


### FIXED CODE ###

l = [int(input()) for i in range(1, 5)]
print(min(l[0], l[1]) + min(l[2], l[3]))
N=int(input())
A=[0 for i in range(N)]
B=[0 for i in range(N)]
C=[0 for i in range(N)]
for i in range(N):
  a,b,c=map(int,input().split())
  A+=[a]
  B+=[b]
  C+=[c]
dp=[0 for i in range(N)]#dp[i]はi+1日目の活動終了時の幸福量
dpk=[o for i in range(N)]#dpk[i]はi+1日目に選んだアクティビティ
def maxk(n,x):#n番めにxになるもの（a,b,cのいずれか）
  if A[n]==x:
    return a
  elif B[n]==x:
    return b
  elif C[n]==x:
    return c
  else:
    return "error"
dp[0]=max(A[0],B[0],C[0])
dpk[0]=maxk(0,dp[0])
dp[1]=
  

### FIXED CODE ###

N=int(input())
A=[]
B=[]
C=[]
for i in range(N):
  l1,l2,l3=map(int,input().split())
  A+=[l1]
  B+=[l2]
  C+=[l3]
dp=[[0,0,0] for i in range(N)]#dp[i][j]はi+1日目にアクティビティjを選んだ時の活動終了時の幸福量
dp[0][0]=A[0]
dp[0][1]=B[0]
dp[0][2]=C[0]
for i in range(1,N):
  dp[i][1]=max(dp[i-1][2]+B[i],dp[i-1][0]+B[i])
  dp[i][0]=max(dp[i-1][1]+A[i],dp[i-1][2]+A[i])
  dp[i][2]=max(dp[i-1][1]+C[i],dp[i-1][0]+C[i])
ans=max(dp[N-1])
print(ans)
n, k = map(int, input().split(' '))
s = list(map(int, list(input())))

s.append(9)
ran = []
a = 0
i = 1
#ランレングス圧縮
while i < len(s):
    if s[a] == s[i]:
        i +=1
    else:
        ran.append(i-a)
        a = i
        i += 1
ran.append(0)
ran.append(0)
ran.append(0)
b = s[0]
result = []
i = 0
counter = 0
if n/2 <= k:
    print(n)
else:
    while i+2*k <= len(ran):
        if s[counter] == 1:
            result.append(sum(ran[i:2*k+i+1]))
        else:
            result.append(sum(ran[i:2*k+i]))
        counter += ran[i]
        i += 1
    print(max(result))

### FIXED CODE ###

n, k = map(int, input().split())
s = list(map(int, list(str(input()))))
c = 0
ran = [0,0]
for i in range(n):
    if s[c] == s[i]:
        ran[-1] += 1
    else:
        ran.append(i+1)
        c = i
result = []
for i in range(1, len(ran)):
    if s[ran[i-1]] == 1:
        result.append(ran[min(i+2*k,len(ran)-1)]-ran[i-1])
    else:
        result.append(ran[min(i+2*k-1, len(ran)-1)]-ran[i-1])
print(max(result))
s = input()
for i in range(len(s)):
    if s[i] == '?':
        s[i] = 'D'
print(s)

### FIXED CODE ###

s = input()
print(s.replace('?', 'D'))
n = int(input())
a = input().split(' ')

if len(set(a)) == n:
  print('YES')
else
  print('NO')

### FIXED CODE ###

n = int(input())
a = input().split(' ')
 
if len(set(a)) == n:
  print('YES')
else:
  print('NO')
list=[]
for i in input.split():
    if i=='+':
        list[len(list)-1]=list[len(list)-1]+list[len(list)]
        list.pop()
    elif i=='-':
        list[len(list)-1]=[len(list)-1]-list[len(list)]
        list.pop()
    elif i=='*':
        list[len(list)-1]=[len(list)-1]*list[len(list)]
        list.pop()
    else:
        list.append()
print(list[0])



### FIXED CODE ###

list=[]
for i in input().split():
    if i=='+':
        list[len(list)-2]=int(list[len(list)-2])+int(list[len(list)-1])
        list.pop()
    elif i=='-':
        list[len(list)-2]=int(list[len(list)-2])-int(list[len(list)-1])
        list.pop()
    elif i=='*':
        list[len(list)-2]=int(list[len(list)-2])*int(list[len(list)-1])
        list.pop()
    else:
        list.append(i)
print(list[0])
import numpy as np
max_change = 1000
s = input()
t = input()
list_t = np.array([ _ for _ in t])
for i in range(1,len(s) - len(t) + 1):
    s_sample = s[i-1:len(t)+i-1]
    list_ss = np.array([ _ for _ in list_ss])
    list_tf = list_t == list_ss
    n_change = len(list_t) - sum(list_tf)
    if n_change < max_change:
        max_change = n_change
    else:
        pass
print(max_change)

### FIXED CODE ###

import numpy as np
max_change = 1000
s = input()
t = input()
list_t = np.array([ _ for _ in t])
if len(s) == len(t):
    list_s = np.array([ _ for _ in s])
    list_tf = list_t == list_s
    n_change = len(list_t) - sum(list_tf)
    if n_change < max_change:
        max_change = n_change
    else:
        pass
else:
    for i in range(1,len(s) - len(t) + 1):
        s_sample = s[i-1:len(t)+i-1]
        list_ss = np.array([ _ for _ in s_sample])
        list_tf = list_t == list_ss
        n_change = len(list_t) - sum(list_tf)
        if n_change < max_change:
            max_change = n_change
        else:
            pass
print(max_change)
import sys
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7

a = LIR(3)
n = I()
b = IR(n)


def check(A, B):
   S = set(b)
 
   # check each row
   for r in range(3):
      cnt = 0
      for c in range(3):
         if A[r][c] in S:
            cnt += 1
      if cnt == 3:
         return True
 
   # check each colum
   for c in range(3):
      cnt = 0
      for r in range(3):
         if A[r][c] in S:
            cnt += 1
      if cnt == 3:
         return True
 
   # check back diagonal
   cnt = 0
   for i in range(3):
      if A[i][i] in S:
         cnt += 1
   if cnt == 3:
      return True
 
   # check forward diagonal
   cnt = 0
   for i in range(3):
      if A[i][2-i] in S:
         cnt += 1
   if cnt == 3:
      return True
 
   return False
 
 
print('Yes' if check(A, B) else 'No')


### FIXED CODE ###

import sys
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7

a = LIR(3)
n = I()
b = IR(n)


def check(A, B):
   S = set(b)
 
   # check each row
   for r in range(3):
      cnt = 0
      for c in range(3):
         if A[r][c] in S:
            cnt += 1
      if cnt == 3:
         return True
 
   # check each colum
   for c in range(3):
      cnt = 0
      for r in range(3):
         if A[r][c] in S:
            cnt += 1
      if cnt == 3:
         return True
 
   # check back diagonal
   cnt = 0
   for i in range(3):
      if A[i][i] in S:
         cnt += 1
   if cnt == 3:
      return True
 
   # check forward diagonal
   cnt = 0
   for i in range(3):
      if A[i][2-i] in S:
         cnt += 1
   if cnt == 3:
      return True
 
   return False
 
 
print('Yes' if check(a, b) else 'No')