Harryxun/stf_run huggingface dataset:
#salmonize の文
n,k = map(int,input().split()) 
 #複数文字の入力
ans = 0

for i in range(1,n+1):
j=0 
  #カウンター設置
  while i<k:
    i*=2
    j+=1
  ans=1/2**j
print("{:.12}".format(ans/n))

### FIXED CODE ###

n,k = map(int,input().split()) 
 #複数文字の入力
ans = 0

for i in range(1,n+1):
  j=0 
  #カウンター設置
  while i<k:
    i*=2
    j+=1
  ans+=1/2**j
print("{:.12}".format(ans/n))
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))

if sum(a) < sum(b):
    print(-1)
    exit()

q = []
p = []
d = 0

for i in range(n):
    if a[i] - b[i] < 0:
        q.append(a[i]-b[i])
    elif a[i] - b[i] > 0:
        p.append(a[i]-b[i])
    else:
        d += 1

s = sum(q)
p = sorted(p)
while s < 0:
    if p == []:
        print(-1)
        exit()
    else:
        t = p.pop()
        s += t

print(n - d - len(p))



### FIXED CODE ###

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

if a == {1, 9, 7, 4}:
    print("YES")
else:
    print("NO")
N = input()

max_a= [0]*N
max_b = [0]*N
max_c = [0]*N

for i in range(0,N):
  a,b,c = map(int,input.split())
  max_a[i] = max(max_b[i-1]+a,max_c+a) 
  max_b[i] = max(max_a[i-1]+b,max_c[i-1]+b) 
  max_c[i] = max(max_a[i-1]+c,max_b[i-1]+c) 
  
print(max(max_a[-1],max_b[-1],max_c[-1]))

### FIXED CODE ###

N = int(input())

max_a = [0] * N
max_b = [0] * N
max_c = [0] * N
if N>1:
    for i in range(0, N):
        a, b, c = map(int, input().split())
        max_a[i] = max(max_b[i - 1] + a, max_c[i-1] + a)
        max_b[i] = max(max_a[i - 1] + b, max_c[i - 1] + b)
        max_c[i] = max(max_a[i - 1] + c, max_b[i - 1] + c)

    print(max(max_a[-1], max_b[-1], max_c[-1]))
else:
    a, b, c = map(int, input().split())

    print(max(a, b, c))
N, Q = map(int, input().split())
S = input()

hit = [0] * N

for i in range(0, N - 1):
    hit[i + 1] = hit[i]

    if S[i:i+2] == 'AC':
        hit[i + 1] += 1

for _ in range(0, Q):
    result = hit[r - 1] - hit[l - 1]
    print(result)



### FIXED CODE ###

N, Q = map(int, input().split())
S = input()

hit = [0] * N

for i in range(0, N - 1):
    hit[i + 1] = hit[i]

    if S[i:i+2] == 'AC':
        hit[i + 1] += 1

for _ in range(0, Q):
    l, r = map(int, input().split())
    result = hit[r - 1] - hit[l - 1]
    print(result)
s = input()
t = input()
new_s = s.sort()
new_t = t.sort(reverse = True)
js = ''.join(new_s)
jt = ''.join(new_t)
if js > jt:
  print('Yes')
else:
  print('No')

### FIXED CODE ###

s = list(input())
t = list(input())
s.sort()
t.sort(reverse = True)
js = ''.join(s)
jt = ''.join(t)
if js < jt:
  print('Yes')
else:
  print('No')
import math

li=[int(input()) for _ in range(5)]
m,last,ans=10,li[0],0

for i in range(5):
  l = li[i]
  if 0 < l % 10 < m :
    m = l % 10
    last = l
    lm = i

for i in range(5):
  l=li[i]
  if l == last and i == lm:
    ans += l
  else:
    ans += math.ceil(l/10)*10
    
print(ans)

### FIXED CODE ###

import math

li=[int(input()) for _ in range(5)]
m,last,ans,lm=10,li[0],0,0

for i in range(5):
  l = li[i]
  if 0 < l % 10 < m :
    m = l % 10
    last = l
    lm = i

for i in range(5):
  l=li[i]
  if l == last and i == lm:
    ans += l
  else:
    ans += math.ceil(l/10)*10
    
print(ans)
# 入力
input_int = lambda:int(input())
input_ints = lambda:map(int,input().split())
input_str = lambda:input()
input_strs = lambda:input().split()
input_lines = lambda n,f:[f() for _ in range(n)]

import functools,fractions
import numpy as np
gcd = lambda a:functools.reduce(fractions.gcd,a) # 最大公約数（リスト）
lcm_base = lambda a,b:(a*b)//fractions.gcd(a,b) # 最小公倍数(2値)
lcm = lambda a:functools.reduce(lcm_base,a,1) # 最小公倍数(リスト)

def solution():
    N = input_int()
    Ts = input_lines(N,input_int)

    ans = lcm(Ts)
    print(ans)

if __name__ == '__main__':
    solution()

### FIXED CODE ###

# 入力
input_int = lambda:int(input())
input_ints = lambda:map(int,input().split())
input_str = lambda:input()
input_strs = lambda:input().split()
input_lines = lambda n,f:[f() for _ in range(n)]

import functools,fractions
import numpy as np
gcd = lambda a:functools.reduce(fractions.gcd,a) # 最大公約数（リスト）
lcm_base = lambda a,b:(a*b)//fractions.gcd(a,b) # 最小公倍数(2値)
lcm = lambda a:functools.reduce(lcm_base,a,1) # 最小公倍数(リスト)

def solution():
    N = input_int()
    Ts = input_lines(N,input_int)

    ans = lcm(Ts)
    print(ans)

if __name__ == '__main__':
    solution()
N = int(input())
A = [0] + list(map(int, input().split()))

for i in range(N-1, 0, -1):
    tmp = 0
    for t in range(i, N+1, i):
        tmp += A[t]
    if tmp % 2 == i:
        break

print(tmp)
for i in range(1, tmp+1):
    if i % tmp == 0:
        print(i)


### FIXED CODE ###

N = int(input())
A = [0] + list(map(int, input().split()))

for i in range(N//2, 0, -1):
    # tmp = 0
    # j = i
    # while j < N+1:
    #     tmp += A[j]
    #     j += j
    # A[i] = tmp % 2
    A[i] = sum(A[i::i]) % 2
ans = [i for i, j in enumerate(A) if j == 1]

print(len(ans))
print(*ans)
n,m =map(int, input().split())
if n==m==1:
    print(0)
elif n==1:
    print(cmb(m,2))
elif m==1:
    print(cmb(n,2))
else:
    print(cmb(n,2)+cmb(m,2))

### FIXED CODE ###

nCr = {}
def cmb(n, r):
    if r == 0 or r == n: return 1
    if r == 1: return n
    if (n,r) in nCr: return nCr[(n,r)]
    nCr[(n,r)] = cmb(n-1,r) + cmb(n-1,r-1)
    return nCr[(n,r)]
  
n,m =map(int, input().split())
if n==m==1:
    print(0)
elif n==1 or n==0:
    print(cmb(m,2))
elif m==1 or m==0:
    print(cmb(n,2))
else:
    print(cmb(n,2)+cmb(m,2))
n,m = map(int,input().split())
ab = sorted([list(map(int,input().split())) for _ in range(m)])
relaypoint = []
i = 0
while(ab[i][0] == 1):
  relaypoint.append(ab[i][1])
  i += 1
ab.sort(key = lambda ab:ab[1],reverse = True)
relaypoint = set(relaypoint)
x = len(relaypoint)
j = 0
flag = 0
while(ab[j][1] == n):
  if ab[j][0] in relaypoint:
    flag = 1
  j += 1
if flag == 1:
  print("POSSIBLE")
else:
  print("IMPOSSIBLE")


### FIXED CODE ###

n,m = map(int,input().split())
ab = sorted([list(map(int,input().split())) for _ in range(m)])
relaypoint = []
for i in range(m):
  if ab[i][0] == 1:
    relaypoint.append(ab[i][1])
  else:
    break
ab.sort(key = lambda ab:ab[1],reverse = True)
relaypoint = set(relaypoint)
x = len(relaypoint)
j = 0
flag = 0
while(ab[j][1] == n):
  if ab[j][0] in relaypoint:
    flag = 1
  j += 1
if flag == 1:
  print("POSSIBLE")
else:
  print("IMPOSSIBLE")
n, k = map(int, input().split())
A = list(map(int,input().split()))
mod = 10**9 + 7

ans = 1
if k == n:
    for i in A:
        ans*=i
elif sum([A[i]<0 for i in range(n)]) == n and k%2 ==1:
    A = sorted(A, key=abs)
    for i in range(k):
        ans *= A[i]
else:
    A = sorted(A, key=abs, reverse=True)
    ctr = 0
    i = 0
    negactr = 0
    posictr = 0
    nega = 1
    posi = 1
    if k%2 ==1:
        while posictr < 1:
            if A[i] > 0:
                posictr+=1
                ans *= A[i]
                ctr += 1
            else:
                negactr +=1
                nega*=A[i]

            if negactr ==2:
                negactr=0
                ctr+=2
                ans*=nega
                nega=1
            i+=1
        posictr=0

    while ctr < k:
        if A[i] > 0:
            posictr+=1
            posi *= A[i]
        else:
            negactr +=1
            nega*=A[i]

        if posictr ==2:
            posictr=0
            ctr+=2
            ans*=posi
            posi=1
        elif negactr ==2:
            negactr=0
            ctr+=2
            ans*=nega
            nega=1
        i+=1

ans %=mod 
print(ans)


### FIXED CODE ###

def solve(n,k,a):
    mod = 10**9 + 7
    ans = 1
    l = 0
    r = n-1
    a.sort()
    
    if k%2 == 1:
        ans *= a[r]
        r-=1
    
    if ans < 0:
        ans = 1
        for i in range(k):
            ans*= a[n-i-1]
            ans%= mod
        return ans
    
    for i in range(k//2):
        tmp_min=a[l]*a[l+1]
        tmp_max=a[r]*a[r-1]
        if tmp_max> tmp_min:
            ans*=tmp_max
            ans%=mod
            r-=2
        else:
            ans*= tmp_min
            ans%=mod
            l+=2
    return ans


n, k = map(int, input().split())
A = list(map(int,input().split()))
ans = solve(n,k,A)
print(ans)
if n != 101:
  print((100**d)*n)
else:
  print((100**d)*(n+1))

### FIXED CODE ###

d,n = map(int,input().split())

if n != 100:
  print((100**d)*n)
else:
  print((100**d)*(n+1))
x1, y1, x2, y2 = map(int, input().split(" "))
a_2 = (x1 - x2) ** 2 + (y1 - y2) ** 2
x2dash = x2 - x1
y2dash = y2 - y1
x3, y3, x4, y4 = [None, None, None, None]

for x in range(-250, 250):
	for y in range(-250, 250):
		first = (x2dash - x) ** 2 + (y2dash - y) ** 2
		second = x ** 2 + y ** 2
		if first == a_2 and second == 2 * a_2:
			if x2dash >= 0 and y2dash >= 0:
				if x <= x2dash and y >= y2dash:
					x3, y3 = [x, y]
					break
			elif x2dash >= 0 and y2dash <= 0:
				if x >= x2dash and y >= y2dash:
					x3, y3 = [x, y]
					break
			elif x2dash <= 0 and y2dash <= 0:
				if x >= x2dash and y <= y2dash:
					x3, y3 = [x, y]
					break
			else:
				if x <= x2dash and y <= y2dash:
					x3, y3 = [x, y]
					break

for x in range(-250, 250):
	for y in range(-250, 250):
		first = x ** 2 + y ** 2
		second = (x3 - x) ** 2 + (y3 - y) ** 2
		if first == a_2 and second == a_2 and x != x2dash and y != y2dash:
			x4, y4 = [x, y]
			break

print(x3 + x1, y3 + y1, x4 + x1, y4 + y1)


### FIXED CODE ###

x1, y1, x2, y2 = map(int, input().split(" "))
x = x2 - x1
y = y2 - y1
print(x2 - y, y2 + x, x1 - y, y1 + x)
n, q = map(int, input().split())
s = input()
ans = []
for i in range(3):
    l, r = map(int, input().split())
    ans.append(s[l - 1: r].replace("AC", "*").count("*"))
print(*ans, sep="\n")


### FIXED CODE ###

n, q = map(int, input().split())
s = input()
appmap = [0] * (n + 1)
for i in range(n):
    appmap[i + 1] = appmap[i] + (1 if s[i: i + 2] == "AC" else 0)
for i in range(q):
    l, r = map(int, input().split())
    print(appmap[r - 1] - appmap[l - 1])
# -*- coding:utf-8 -*-
import sys
sys.setrecursionlimit(1000000)

def preDatasets():
	#f = open('a.txt')
	datas = sys.stdin.readlines()
	#f.close()
	for i in range(len(datas)):
		datas[i] = datas[i].strip('\n')
	return datas

def dfs(x, y, sym):
	tile[x][y] = '.'
	for i in range(len(DX)):
		nx = x + DX[i]
		ny = y + DY[i]
		if(nx>=0 and nx<N and ny>=0 and ny<M and tile[nx][ny]==sym):
			dfs(nx, ny, sym)

def solve():
	res = 0
	for i in range(N):
		for j in range(M):
			if not tile[i][j] == '.':
				if tile[i][j] == '@':
					dfs(i, j, '@')
					res += 1
				elif tile[i][j] == '#':
					dfs(i, j, '#')
					res += 1
				elif tile[i][j] == '*':
					dfs(i, j, '*')
					res += 1
	print(res)

index = 0	
while True:
	datas = preDatasets()
	DX = [-1, 0, 1, 0]
	DY = [0, -1, 0, 1]

	N = int(datas[index].split(' ')[0])
	M = int(datas[index].split(' ')[1])
	tile = [[0 for i in range(N)]for j in range(M)]
	
	for i in range(len(tile)):
		tile[i] = list(datas[index+i+1])
	print(tile)

	if N == 0:
		break
	else:
		solve()
		index += N+1

### FIXED CODE ###

# -*- coding:utf-8 -*-
import sys
def dfs(x, y, sym):
	tile[x][y] = "."
	for i in range(len(DX)):
		nx = x + DX[i]
		ny = y + DY[i]
		if (0<=nx and nx<N and 0<=ny and ny<M and tile[nx][ny] is sym):
			dfs(nx, ny, sym)

def solve():
	res = 0
	for i in range(N):
		for j in range(M):
			sym = tile[i][j]
			if tile[i][j] != ".":
				if tile[i][j] is sym:
					dfs(i, j, sym)
					res += 1
	print(res)

counter=0
DX = [-1,0,1,0]
DY = [0,-1,0,1]
sys.setrecursionlimit(10**7)
while True:
	line = input()
	if " " in line:
		nums = line.split(" ")
		N = int(nums[0])
		M = int(nums[1])
		tile = [[0 for i in range(M)] for j in range(N)]
	else:
		tile[counter-1] = list(line)
	if N is 0 and M is 0:
		break
	counter += 1
	if counter-1 is N:
		solve()
		counter = 0
n=str(input())
if n[1]=="7" or n[0]=="7" or n[2]=="7"
    print("Yes")
else:
    print("No")

### FIXED CODE ###

n=str(input())
if n[-1]=="7" or n[-3]=="7" or n[-2]=="7":
    print("Yes")
else:
    print("No")
import numpy as np

N, Q = list(map(int, input().split()))
tree = np.eye(N)

for i in range(N-1):
  a, b = list(map(int, input().split()))
  ids = tree[:, a-1] > 0
  tree[ids, b-1] = 1
  
r = np.zeros(N)
for i in range(Q):
  p, x = list(map(int, input().split()))
  r += (tree[p-1] > 0)*x
  
r = np.array(r, dtype=int)
print(' '.join(map(str, r)))

### FIXED CODE ###

from collections import deque

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

tree = dict(zip([i for i in range(1, N+1)], [[] for _ in range(N)]))
for i in range(N-1):
  a, b = map(int, input().split())
  tree[a].append(b)
  tree[b].append(a)

counter = [0] * (N+1)
for i in range(Q):
  p, x = map(int, input().split())
  counter[p] += x

d = deque([[1, 0]])
while d:
  node, parent = d.popleft()
  counter[node] += counter[parent]
  children = tree[node]
  for child in children:
    if child == parent:
      continue
      
    d.append([child, node])
    
  
print(' '.join(map(str, counter[1:])))
N,X=map(int, input().split()) 
L=list(map(int, input().split())) 
D = 0
for i in range(N+1):
  D = D + L[i]
  if D > X:
    print(i+1)
    break


### FIXED CODE ###

X,A=map(int, input().split()) 

if X < A:
  print(0)
else:
  print(10)
n,m = map(int,input().split())
a = []
for i in range(n):
    a.append(str(input()))
b = []
for i in range(m):
    b.append(str(input()))

f = [0]*m
count = 0
for j in range(m):
    f[j] = a[j].find(b[j])

while -1 in f: f.remove(-1)
if len(f) == 0:
    print('No')
else:
    flag = 1
    for i in range(len(f)):
        if (b[f[i]] in a[f[i]]) == False:
            flag =0
    if flag == 1:
        print('Yes')
    else:
        print('No')

### FIXED CODE ###

n,m = map(int,input().split())
a = []
for i in range(n):
    a.append(str(input()))
b = []
for i in range(m):
    b.append(str(input()))

f = [0]*m
tmp = []
for j in range(m):
    f[j] = a[j].find(b[j])
    if f[j] != -1:
        tmp.append(j)
while -1 in f: f.remove(-1)

try:
    if len(f) == 0:
        print('No')
    else:
        count = 0
        for i in range(len(tmp)):
            count += 1
            if (b[tmp[i]] in a[tmp[i]]) == False:
                count = 0
        if count == m:
            print('Yes')
        else:
            print('No')
except:
    print('No')
a,b,k=map(int,input().split())
l,s=0
while s < k:
    l += 1
    if a%(l+1)==0 and b%(l+1)==0:
            s += 1
print(l)

### FIXED CODE ###

a,b,k=map(int,input().split())
N=[]
for i in range(1,min(a,b)+1):
    if (a%i==0 and b%i==0):
            N.append(i)
N.reverse()
print(N[k-1])
s = input()

ans = 1
cur = 0
tmp = s[0]

for i in range(len(s)-1):
    #print(cur)
    if cur >= len(s)-2:
        if tmp == s[cur+1]:
            break
        else:
            ans += 1
            break
    if tmp == s[cur+1]:
        tmp = s[cur+1] + s[cur+2]
        cur += 2
        ans += 1
    else:
        tmp = s[cur+1]
        cur += 1
        ans += 1
        
print(ans)

### FIXED CODE ###

s = input()

ans = 1
cur = 0
tmp = s[0]

for i in range(len(s)-1):
    #print(cur)
    if cur == len(s)-1:
        break
    if cur >= len(s)-2:
        if tmp == s[cur+1]:
            break
        else:
            ans += 1
            break
    if tmp == s[cur+1]:
        tmp = s[cur+1] + s[cur+2]
        cur += 2
        ans += 1
    else:
        tmp = s[cur+1]
        cur += 1
        ans += 1
        
print(ans)
import sys

sys.setrecursionlimit(10000)

def solve(prev, r, dic):
    d = 0
    t = r
    if r in dic:
        for vtx, cost in dic[r]:
            if vtx == prev:
                continue
            d1, t1 = solve(r, vtx, dic)
            d1 += cost
            if d < d1:
                d = d1
                t = t1
    return d, t

line = input()
n = int(line)
edge = {}
for _ in range(0, n - 1):
    line = input()
    s, t, d = list(map(int, line.split()))
    if s not in edge:
        edge[s] = [[t, d]]
    else:
        edge[s] += [[t, d]]
    if t not in edge:
        edge[t] = [[s, d]]
    else:
        edge[t] += [[s, d]]
r1, t1 = solve(-1, 0, edge)
r2, t2 = solve(-1, t1, edge)
print(r2)


### FIXED CODE ###

def solve(prev, r, dic):
    d = 0
    t = r
    stack = []
    stack += [[prev, r, d]]
    while stack:
        prev, r, d1 = stack.pop(-1)
        if r in dic:
            for vtx, cost in dic[r]:
                if vtx == prev:
                    continue
                stack += [[r, vtx, d1 + cost]]
                if d < d1 + cost:
                    d = d1 + cost
                    t = vtx
    return d, t

line = input()
n = int(line)
edge = {}
for _ in range(0, n - 1):
    line = input()
    s, t, d = list(map(int, line.split()))
    if s not in edge:
        edge[s] = [[t, d]]
    else:
        edge[s] += [[t, d]]
    if t not in edge:
        edge[t] = [[s, d]]
    else:
        edge[t] += [[s, d]]
r1, t1 = solve(-1, 0, edge)
r2, t2 = solve(-1, t1, edge)
print(r2)
N = input()
op_cnt = len(N) - 1 #隙間の個数
for i in range(2 ** op_cnt):
     op = ['-'] * op_cnt #とりあえず演算子は-を3つとしておく
     for j in range(op_cnt):
          if((i >> j) | 1):
               

### FIXED CODE ###

a = list(input())
 
sign = "+-"
 
for i in range(2):  #1つめの正負
 for j in range(2):  #2つ目の正負
  for k in range(2):  #3つ目の正負
    if eval(a[0]+sign[i]+a[1]+sign[j]+a[2]+sign[k]+a[3] ) == 7:
     print(str(a[0]+sign[i]+a[1]+sign[j]+a[2]+sign[k]+a[3])+'=7')
     exit()
h,w = map(int, input().split())
l = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
for i in range(w):
  tmp = list(map(str, input().split()))
  if tmp.count('snuke') == 1:
    a = l[tmp.index('snuke')]
    b = str(i + 1)
print(a + b)

### FIXED CODE ###

h,w = map(int, input().split())
l = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
for i in range(h):
  tmp = list(map(str, input().split()))
  if tmp.count('snuke') == 1:
    a = l[tmp.index('snuke')]
    b = str(i + 1)
print(a + b)
a = []
for i in range(input()):
    a.append(input())
print sorted(a,reverse = True)

### FIXED CODE ###

n = input()
li = map(int,raw_input().split())
while n >= 1:
    print li[n-1],
    n -= 1
n, m = map(int, input().split())
ab = [list(map(int, input().split())) for _ in range(m)]

cnt = [0] * n

for i in range(m):
    cnt[ab[i][0] - 1] += 1
    cnt[ab[i][1] - 1] += 1

for i in range(n):
    print(cnt(i))


### FIXED CODE ###

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

cnt = [0] * n

for i in range(m):
    cnt[ab[i][0] - 1] += 1
    cnt[ab[i][1] - 1] += 1

for i in range(n):
    print(cnt[i])
from sympy import sieve

X=int(input())

PL=[i for i in sieve.primerange(1, 10**5+1)]

PL.append(X)
PL.sorted()

ID=PL.index(X)

print(ID+1)

### FIXED CODE ###

import math
 
def is_prime(n):
    for i in range(2, int(math.sqrt(n))+1):
        if n % i == 0:
            return False
    return True
 
def main():
    X = int(input())
    while True:
        result = is_prime(X)
        if result:
            print(X)
            exit()
        X +=1
 
if __name__ == '__main__':
    main()
N=int(input())
P=list(map(int,input().split()))

Min=P[0]
ans=1

for i in range(1,N):
    if Min>=P[i]:
        ans+=1
        Min=P[i]
    
print(ans)

### FIXED CODE ###

N,M=map(str,input().split())

if M==N:
    print('Yes')
else:
    print('No')
w,h x,y,r=map(int,input().split())
if w-r>=x and h-r>=y


### FIXED CODE ###

w,h,x,y,r=map(int,input().split())
if w-r>=x and h-r>=y and x>=r and y>=r:
    print('Yes')
else:
    print('No')
n = input()

lst = []
res = []

while n > 0:
    lst.append(n%10)
    n //= 10
lst.reverse()

for i in lst:
    if i == 1:
        res.append(9)
    elif i == 9:
        res.append(1)
    else:
        res.append(i)

Str = ""

for j in res:
    Str += str(j)

print(Str)


### FIXED CODE ###

n = int(input())

lst = []
res = []

while n > 0:
    lst.append(n%10)
    n //= 10
    
lst.reverse()


for i in lst:
    if i == 1:
        res.append(9)
    elif i == 9:
        res.append(1)
    else:
        res.append(i)


S = ""

for j in res:
    S += str(j)

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

### FIXED CODE ###

s = input()
if s[0] == s[1] and s[1] == s[2]:
  print("No")
else:
  print("Yes")
from sys import stdin

a = stdin.readline().rstrip()
a = int(a)

b = stdin.readline().rstrip()
b = int(b)

if a * b % 2 == 0:
    print("Even")
else:
    print("Odd")


### FIXED CODE ###

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

if a * b % 2 == 0:
    print("Even")
else:
    print("Odd")
## parse input
N, M = map(int, input().split()) # throw N away
Hs = list(map(int, input().split())) # int[N]
Rs = [] # (int, int)[M]

for i in range(M):
  a, b = map(int, input().split())
  Rs.append((a-1, b-1))

## preperation
height_conds = [False]*N*N # boolean[N, N] if Hs[fst] > Hs[snd]
for i in range(N):
  for j in range(i+1, N):
    height_conds[i*N+j] = Hs[i] > Hs[j]
    height_conds[j*N+i] = Hs[j] > Hs[i]

## main
goods = [True] * N

for r in Rs:
  a, b = r
  if goods[a]:
  	goods[a] = height_conds[a*N+b]
  if goods[b]:
  	goods[b] = height_conds[b*N+a]

counter = 0
for i in range(N):
  if goods[i]:
    counter += 1

print(counter)

### FIXED CODE ###

## parse input
N, M = map(int, input().split()) # throw N away
Hs = list(map(int, input().split())) # int[N]
Rs = [] # (int, int)[M]

for i in range(M):
  a, b = map(int, input().split())
  Rs.append((a-1, b-1))

## preperation
#height_conds = [False]*N*N # boolean[N, N] if Hs[fst] > Hs[snd]
#for i in range(N):
#  for j in range(i+1, N):
#    height_conds[i*N+j] = Hs[i] > Hs[j]
#    height_conds[j*N+i] = Hs[j] > Hs[i]

## main
goods = [True] * N

for r in Rs:
  a, b = r
  if goods[a]:
  	goods[a] = Hs[a]>Hs[b]#height_conds[a*N+b]
  if goods[b]:
  	goods[b] = Hs[b]>Hs[a]#height_conds[b*N+a]

counter = 0
for i in range(N):
  if goods[i]:
    counter += 1

print(counter)
n = int(input())
c0 = 0
c1 = 0
c2 = 0
c3 = 0

for i in range(n):
    test = input()
    if test == "AC":
        c0 += 1
    elif test == "WA":
        c1 += 1
    elif test == "TLE":
        c2 +=1
    elif test == "RE":
        c3 += 1
print("AC x", c0)
print("WA x", c1)
print("TLE x", c2)
ptinr("RE x", c3)

### FIXED CODE ###

n = int(input())
c0 = 0
c1 = 0
c2 = 0
c3 = 0

for i in range(n):
    test = input()
    if test == "AC":
        c0 += 1
    elif test == "WA":
        c1 += 1
    elif test == "TLE":
        c2 +=1
    elif test == "RE":
        c3 += 1
print("AC x", c0)
print("WA x", c1)
print("TLE x", c2)
print("RE x", c3)
#! /usr/local/bin/python3
# coding: utf-8

from sys import setrecursionlimit

setrecursionlimit(22)


class Node():
    def __init__(self, parent=-1, child=[]):
        self.parent = parent
        self.child = child


def node_depth(u, id):
    if u[id].parent == -1:
        return 0
    else:
        return node_depth(u, u[id].parent) + 1


def node_type(u, id):
    if u[id].parent == -1:
        return "root"
    elif u[id].child == []:
        return "leaf"
    else:
        return "internal node"


def main():
    n = int(input())
    u = [Node() for _ in range(n)]

    for i in range(n):
        _, _, *child = (int(x) for x in input().split())
        u[i].child = child
        for c in child:
            u[c].parent = i

    for i in range(n):
        print("node {}: parent = {}, depth = {}, {}, {}".
              format(i, u[i].parent,
                     node_depth(u, i), node_type(u, i),
                     u[i].child))


if __name__ == '__main__':
    main()



### FIXED CODE ###

class Node():
    def __init__(self, parent=-1, child=[]):
        self.parent = parent
        self.child = child


def node_depth(u, id):
    if u[id].parent == -1:
        return 0
    else:
        return node_depth(u, u[id].parent) + 1


def node_type(u, id):
    if u[id].parent == -1:
        return "root"
    elif u[id].child == []:
        return "leaf"
    else:
        return "internal node"


def main():
    n = int(input())
    u = [Node() for _ in range(n)]

    for _ in range(n):
        id, _, *child = (int(x) for x in input().split())
        u[id].child = child
        for c in child:
            u[c].parent = id

    for id in range(n):
        print("node {}: parent = {}, depth = {}, {}, {}".
              format(id, u[id].parent,
                     node_depth(u, id), node_type(u, id),
                     u[id].child))


main()