CodeEff/ECCO huggingface dataset:
# Original solution
n=int(eval(input()))
xy=[[] for i in range(n)]

for i in range(n):
  a=int(eval(input()))
  for j in range(a):
    x,y=list(map(int,input().split()))
    xy[i].append([x,y])

ans=0
for i in range(1<<n):
  cnt=bin(i).count("1")
  ok=True
  for j in range(n):
    if ok==False:break
    if i&(1<<j):
      for x,y in xy[j]:
        if y==1 and i&(1<<x-1)==0:
          ok=False
        if y==0 and i&(1<<x-1):
          ok=False
  if ok:
    ans=max(cnt,ans)
print(ans)



# Optimized solution
n=int(eval(input()))
xy=[[] for i in range(n)]
for i in range(n):
  a=int(eval(input()))
  for j in range(a):
    x,y=list(map(int,input().split()))
    x-=1
    xy[i].append((x,y))
ans=0
for i in range(1<<n):
  cnt=bin(i).count("1")
  if cnt<=ans:continue
  for j in range(n):
    if i&(1<<j):
      for x,y in xy[j]:
        if y==1 and i&(1<<x):continue
        if y==0 and i&(1<<x)==0:continue
        break
      else:
        continue
      break
  else:
    ans=cnt
print(ans)
# Original solution
#ABC-147
#参考 https://atcoder.jp/contests/abc147/submissions/8896111
N = int(eval(input()))
evidences = [[] for i in range(N)]

for i in range(N):
    A = int(eval(input()))
    for _ in range(A):
        x, y = list(map(int, input().split()))
        evidences[i].append((x-1, y))

result = 0
for i in range(1, 2**N):
    consistent = True
    for j in range(N):
        #すでに矛盾するパターンのiとわかっているならば飛ばす。
        if consistent == False:
            break
        #jが正しいと仮定する。(もし0ならcontinueで飛ばされる。)
        if (i >> j) & 1 == 0:
            continue
        #jの証言を一個ずつ確認していく。
        for x, y in evidences[j]:            
            if (i >> x) & 1 != y:
                consistent = False
                break
    #全ての人の証言で矛盾がないパターンのiだったら、1の数(=正直者の数)をresultに記録しておく。
    if consistent == True:
        result = max(result, bin(i)[2:].count("1"))

print(result)

# Optimized solution
N = int(eval(input()))

memo = [[] for _ in range(N)]
ans = 0

for i in range(N):
    A = int(eval(input()))
    for _ in range(A):
        #配列が0始まりなので、xは-1して使用する
        x, y = list(map(int, input().split()))
        memo[i].append((x,y))

# print(memo)
for i in range(2**N):
    # print(i)#test
    flag = True
    for j in range(N):
        # bitが1の人の証言を確認していく。
        if i >> j & 1:
            for evidence in memo[j]:
                check_evidence = int(bin(i >> (evidence[0]-1))[-1])
                if check_evidence != evidence[1]:
                    # print(check_evidence==evidence[1])
                    flag = False
                    break
        if not flag:
            break
    if flag:
        bin_i = bin(i)
        ans = max(ans, bin_i.count("1"))

print(ans)
# Original solution
n = int(eval(input()))
l = [[] for i in range(n)]

for i in range(n):
    a = int(eval(input()))
    for j in range(a):
        x, y = list(map(int, input().split()))
        l[i].append([x, y])

ans = 0

for b in range(1 << n): # 正直者か不親切か全ての設定パターンを作る。
    cnt = bin(b).count("1")
    judge = True
    for j in range(n):
        if judge == False: #矛盾があれば、ループを止める。
            break
        if b & (1 << j) != 0: # j番目の人が正直者設定なら進む。
            for x, y in l[j]:
                if y == 1 and b & (1 << x - 1) == 0: # 証言:正直者、設定:不親切の場合
                    judge = False
                if y == 0 and b & (1 << x - 1) != 0: # 証言:不親切、設定:正直者の場合
                    judge = False
    if judge == True:
        ans = max(cnt, ans)
print(ans)

# Optimized solution
n = int(eval(input()))
xy = [[] for _ in range(n)]
ans = 0

for i in range(n): #証言者 i人目
    a = int(eval(input()))
    for j in range(a): #i人目の証言者のj番目の証言
        x, y = list(map(int, input().split()))
        xy[i].append([x, y])

for b in range(1 << n): #設定上、正直者か不親切かの全パターンを探索
    cnt = bin(b).count("1") #正直者設定の人数をカウント
    judge = True
    for i in range(n):
        if judge == False:
            break
        if b & (1 << i) != 0: #i番目の証言者が正直者設定の場合
            for x, y in xy[i]:
                if y == 1 and b & (1 << x - 1) == 0:
                    #証言:正直者、設定:不親切の場合
                    judge = False
                if y == 0 and b & (1 << x - 1) != 0:
                    #証言:不親切、設定:正直者の場合
                    judge = False
    if judge == True:
        ans = max(ans, cnt)
print(ans)
# Original solution
n = int(eval(input()))
l = [[] for _ in range(n)]
ans = 0

for i in range(n):
    a = int(eval(input()))
    for j in range(a):
        xy = input().split()
        l[i].append(list(map(int, xy)))

for i in range(2**n):
    judge = True
    for j in range(n):
        if i & (1 << j): #証言者が正直者設定なら進む。
            for x, y in l[j]:
                if y == 0 and i & 1 << (x - 1): #証言:不親切 設定:親切
                    judge = False
                if y == 1 and i & 1 << (x - 1) == 0: #証言:正直、設定:不親切
                    judge = False
    if judge == True:
        cnt = bin(i).count("1")
        ans = max(ans, cnt)

print(ans)

# Optimized solution
n = int(eval(input()))
l = [[] for _ in range(n)]
ans = 0

for i in range(n):
    a = int(eval(input()))
    for j in range(a):
        xy = input().split()
        l[i].append(list(map(int, xy)))

for i in range(2**n):
    judge = True
    for j in range(n):
        if judge == False:
            break
        if i & (1 << j): #証言者が正直者設定なら進む。
            for x, y in l[j]:
                if y == 0 and i & 1 << (x - 1): #証言:不親切 設定:親切
                    judge = False
                if y == 1 and i & 1 << (x - 1) == 0: #証言:正直、設定:不親切
                    judge = False
    if judge == True:
        cnt = bin(i).count("1")
        ans = max(ans, cnt)

print(ans)
# Original solution
from itertools import product
N = int(eval(input()))
said = [[-1] * (N+1) for _ in range(N+1)]

for a in range(N):
    K = int(eval(input()))
    for _ in range(K):
        x, y = list(map(int, input().split()))
        said[a][x - 1] = y

ans = 0
for cand in product(list(range(2)), repeat=N):
    isOK = True

    for i, c in enumerate(cand):
        if not c:
            continue
        A = said[i]
        for j in range(N):
            if i == j or A[j] == -1:
                continue
            if cand[j] != A[j]:
                isOK = False
                break

    if isOK:
        ans = max(ans, sum(cand))

print(ans)


# Optimized solution
from itertools import product
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)

N = int(eval(input()))
mention = []
for _ in range(N):
    A = int(eval(input()))
    xy = [list(map(int, input().split())) for _ in range(A)]
    mention.append(xy)

ans = 0
for pair in product(list(range(2)), repeat=N):
    isOK = True
    for i, p in enumerate(pair):
        if not p:
            continue
        for x, y in mention[i]:
            if pair[x - 1] != y:
                isOK = False
    if isOK:
        ans = max(ans, sum(pair))

print(ans)
# Original solution
print((input().replace("2017", "2018")))

# Optimized solution
s = input().split("/")
print(("/".join(["2018", s[1], s[2]])))
# Original solution
print(('2018'+input()[4:]))

# Optimized solution
print((input(2018)[4:]))
# Original solution
print((input().replace("2017","2018")))

# Optimized solution
print(("2018"+input()[4:]))
# Original solution
print(("/".join(["2018"] + input().split("/")[1:])))

# Optimized solution
print((input().replace("017","018")))
# Original solution
print(("2018" + input().rstrip("\n")[4:]))

# Optimized solution
print(("2018" + input()[4:]))
# Original solution
print((input().replace("2017","2018")))

# Optimized solution
print((input().replace("17","18")))
# Original solution
print((input().replace("2017", "2018")))

# Optimized solution
S = input().replace("2017", "2018")
print(S)
# Original solution
import re
S = list(input())
S[3] = "8"
out = ""
for s in S:
  out += s
print(out)



# Optimized solution
S = input()
print("2018"+S[4:])
# Original solution
H, W = list(map(int, input().split()))
h, w = list(map(int, input().split()))
H -= h
W -= w
print((H * W))

# Optimized solution
H, W = list(map(int, input().split()))
h, w = list(map(int, input().split()))
print(((H-h)*(W-w)))
# Original solution
H,W=list(map(int,input().split()))
h,w=list(map(int,input().split()))
print((H*W-H*w-h*W+h*w))

# Optimized solution
H,W=list(map(int,input().split()))
h,w=list(map(int,input().split()))
print((H*W-h*W-H*w+h*w))
# Original solution
H, W = list(map(int, input().split()))
h, w = list(map(int, input().split()))
HM = H * W
hW = W * h
h1 = H - h
h2 = h1 * w
h3 = HM - hW - h2
print(h3)

# Optimized solution
H, W = list(map(int, input().split()))
h, w = list(map(int, input().split()))
s = H * W
s1 = h * W
s2 = H * w
s3 = s1 + s2 - h * w
print((s - s3))
# Original solution
H, W = list(map(int, input().split()))
h, w = list(map(int, input().split()))

print((H * W - h * W - H * w + h * w))

# Optimized solution
H, W = list(map(int, input().split()))
h, w = list(map(int, input().split()))
print(((H - h) * (W - w)))
# Original solution
H,W = list(map(int,input().split()))
h,w = list(map(int,input().split()))
print(((H-h)*(W-w)))

# Optimized solution
# Python3 (3.4.3)
import sys
input = sys.stdin.readline

# -------------------------------------------------------------
# function
# -------------------------------------------------------------


# -------------------------------------------------------------
# main
# -------------------------------------------------------------
H,W = list(map(int,input().split()))
h,w = list(map(int,input().split()))

print(((H-h)*(W-w)))
# Original solution
H, W = (int(i) for i in input().split())
h, w = (int(i) for i in input().split())
ans = H * W
sel = h * W + w * (H - h)
ans -= sel
print(ans) 

# Optimized solution
def main():
    H, W = (int(i) for i in input().split())
    h, w = (int(i) for i in input().split())
    ans = H*W - W*h - H*w + h*w
    print(ans)


if __name__ == '__main__':
    main()
# Original solution
# AtCoder Beginner Contest 121
# https://atcoder.jp/contests/abc121
import sys

s2nn = lambda s: list(map(int, s.split(' ')))
ss2nn = lambda ss: list(map(int, ss))
ss2nnn = lambda ss: [s2nn(s) for s in ss]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [sys.stdin.readline().rstrip() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    H, W = i2nn()
    h, w = i2nn()
    n = (H - h) * (W - w)
    print(n)

main()


# Optimized solution
# AtCoder Beginner Contest 121
# https://atcoder.jp/contests/abc121
import sys
#import numpy as np

s2nn = lambda s: list(map(int, s.split(' ')))
ss2nn = lambda ss: list(map(int, ss))
ss2nnn = lambda ss: [s2nn(s) for s in ss]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [sys.stdin.readline().rstrip() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    H, W = i2nn()
    h, w = i2nn()
    n = (H - h) * (W - w)
    print(n)

main()
# Original solution
a,b=[list(map(int,input().split())) for i in range(2)]
print(((a[0]-b[0])*(a[1]-b[1])))

# Optimized solution
H,W=list(map(int,input().split()))
h,w=list(map(int,input().split()))
print(((H-h)*(W-w)))
# Original solution
H,W = list(map(int,input().split()))
h,w = list(map(int,input().split()))
ans = (H-h)*(W-w)
print(ans)


# Optimized solution
H, W = list(map(int,input().split()))
h, w = list(map(int,input().split()))
ans = H*W -(h*W+w*H) + h*w
print(ans)
# Original solution
[print(f.reduce(o.mul,f.reduce(lambda x,y:[x[0]-y[0],x[1]-y[1]],[[int(i)for i in input().split()],[int(i)for i in input().split()]])))for f,o in[[__import__('functools'),__import__('operator')]]]


# Optimized solution
[print((H-h)*(W-w))for H,W,h,w in[map(int,open(0).read().split())]]
# Original solution
H,W = list(map(int,input().split()))
h,w = list(map(int,input().split()))
print(((H-h) * (W-w)))

# Optimized solution
def main():
    H, W = list(map(int, input().split()))
    h, w = list(map(int, input().split()))
    print(((H-h)*(W-w)))


main()
# Original solution
H, W = list(map(int, input().split()))
h, w = list(map(int, input().split()))
ans = 0

masu = [[0] * W for i in range(H)]

for i in range(h):
    for j in range(W):
        masu[i][j] = 1

for i in range(H):
    for j in range(w):
        masu[i][j] = 1

for i in range(H):
    for j in range(W):
        if masu[i][j] == 0:
            ans += 1

print(ans)

# Optimized solution
H, W = list(map(int, input().split()))
h, w = list(map(int, input().split()))

print(((H - h) * (W - w)))
# Original solution
uh, uw = list(map(int, input().split()))
h, w = list(map(int, input().split()))
print((int((uh*uw) - (uh*w) - (uw*h) + (h*w))))

# Optimized solution
uh,uw = list(map(int, input().split()))
h, w = list(map(int, input().split()))
print(((uh-h)*(uw-w)))
# Original solution
h,w = list(map(int,input().split()))
p, q = list(map(int,input().split()))
print((h * w - p * w - q * h + p * q))


# Optimized solution
H,W = list(map(int,input().split()))
h,w = list(map(int,input().split()))
print(((H - h) * (W - w)))
# Original solution
H,W=list(map(int,input().split()))
h,w=list(map(int,input().split()))
lw=H*W-(h*W+H*w-h*w)
print(lw)

# Optimized solution
H,W=list(map(int,input().split()))
h,w=list(map(int,input().split()))

print(((H-h)*(W-w)))
# Original solution
H,W = list(map(int,input().split()))

h,w = list(map(int,input().split()))

print(((H-h)*(W-w)))

# Optimized solution
H,W=list(map(int,input().split()))
h,w=list(map(int,input().split()))

s=(H-h)*(W-w)

print(s)
# Original solution
N=int(eval(input()))
result = 0;
for i in range(1,N+1):
    result += i
        
print(result)

# Optimized solution
n=int(eval(input()))
s=0
for i in range(1,n+1):
  s+=i
print(s)
# Original solution
def resolve():
    n=int(eval(input()))
    print(((1+n)*n//2))
resolve()

# Optimized solution
def resolve():
    n=int(eval(input()))
    ans=0
    for i in range(1,n+1):
        ans+=i
    print(ans)
resolve()
# Original solution
val1=int(eval(input()))
print((int(val1*(val1+1)/2)))

# Optimized solution
s=int(eval(input()))

print((int(s*(s+1)/2)))
# Original solution
N = int(eval(input()))
sum = 0
for i in range(1, N+1):
    sum += i
print(sum)

# Optimized solution
print((sum(list(range(1, int(eval(input()))+1)))))
# Original solution
n = eval(input())
x = int(n)
y = 0.5*x*(x+1)
print((int(y)))

# Optimized solution
N=int(eval(input()))
print((int(N*(N+1)/2)))
# Original solution
N= int(eval(input()))

C=0
for i in range(N):
    C = C + i + 1

print(C)

# Optimized solution
N = int(eval(input()))
print((N*(N+1)//2))
# Original solution
child_num = eval(input())
child_num = int(child_num)
candy_num = int((child_num**2 + child_num) / 2)
print(candy_num)

# Optimized solution
#子供の数を入力
child_num = int(eval(input()))

candy_num = int((child_num**2 + child_num) / 2)
print(candy_num)
# Original solution
n = int(eval(input()))
ans = 0
for i in range(1,n+1):
    ans += i
print(ans)

# Optimized solution
def main():
    N = int(eval(input()))
    print((N*(N+1)//2))


if __name__ == '__main__':
    main()
# Original solution
print((sum(range(int(eval(input()))+1))))

# Optimized solution
n=int(eval(input()));print((n*(n+1)//2))
# Original solution
n=int(eval(input()));print((n*-~n//2))

# Optimized solution
print((sum(range(int(eval(input()))+1))))
# Original solution
N=int(eval(input()))
print((N*(N+1)//2))

# Optimized solution
N=int(eval(input()))
i=1
s=0
while i<=N:
    s+=i
    i+=1
print(s)
# Original solution
a = int(eval(input()))
print((int((1+a)*a/2)))

# Optimized solution
a = int(eval(input()))
print((int(a*(a+1)/2)))
# Original solution
n = int(eval(input()))

answer = int((n + 1) * n / 2)

print(answer)

# Optimized solution
n = int(eval(input()))
print((int((n + 1) * n / 2)))
# Original solution
def main():
    N = int(eval(input()))
    candys = N * (1 + N) // 2
    print(candys)

if __name__ == '__main__':
    main()

# Optimized solution
N = int(eval(input()))
cnt = N *(1+N)//2
print(cnt)
# Original solution
N=int(eval(input()))
print((N*(N+1)//2))


# Optimized solution
n=int(eval(input()))
i=0
for m in range(n+1):
	i=i+m
print(i)
# Original solution
N = int(eval(input()))
print((int(N*(N+1)/2)))

# Optimized solution
N = int(eval(input()))
print((N*(N+1)//2))
# Original solution
def acum(n):
    if n <= 1:
        return 1
    return n + acum(n - 1)
print((acum(int(eval(input())))))

# Optimized solution
n=int(eval(input()));print((n*-~n>>1))
# Original solution
N = int(eval(input()))
ans = sum([i for i in range(N+1)])
print(ans)

# Optimized solution
def resolve():
    N = int(eval(input()))
    print((int((1+N) * N * (1/2))))

resolve()
# Original solution
print((sum([i for i in range(1, int(eval(input()))+1)])))

# Optimized solution
n = int(eval(input()))
print((n*(n+1)//2))
# Original solution
N = int(eval(input()))

cnt = 0
for i in range(1,N+1):
  cnt += i
print(cnt)

# Optimized solution
N = int(eval(input()))

def dfs(n):
  ret = 0
  for i in range(1,n+1):
    ret += i
  return ret
print((dfs(N)))
# Original solution
N = int(eval(input()))
num = 0
for i in range(1,N+1):
  num += i
print(num)

# Optimized solution
N = int(eval(input()))
print((sum([i for i in range(1, N+1)])))
# Original solution
#coding:utf-8
N = int(eval(input()))
trees = [list(input().split()) for i in range(N)]

class BinaryTree:
    def __init__(self,key,p=None,l=None,r=None):
        self.key = key
        self.p = p
        self.l = l
        self.r = r

def Insert(root,z):
    y = None
    x = root
    while x != None:
        y = x
        if z.key < x.key:
            x = x.l
        else:
            x = x.r
    z.p = y

    if y == None:
        root = z
    elif z.key < y.key:
        y.l = z
    else:
        y.r = z
    return root

def preOrder(x):
    if x == None:
        return
    global preList
    preList.append(x.key)
    
    preOrder(x.l)
    preOrder(x.r)

def inOrder(x):
    if x == None:
        return
    inOrder(x.l)

    global inList
    inList.append(x.key)
    
    inOrder(x.r)

def Find(x,target):
    if x == None:
        return 
    if x.key == target:
        global yes
        yes = True
        return True
    Find(x.l,target)
    Find(x.r,target)

root = None
for data in trees:
    if data[0] == "insert":
        z = BinaryTree(int(data[1]))
        root = Insert(root,z)
    if data[0] == "find":
        yes = False
        a = Find(root, int(data[1]))
        if yes:
            print("yes")
        else:
            print("no")
        
    if data[0] == "print":
        inList = []
        preList = []
        inOrder(root)
        a = " " + " ".join([str(num) for num in inList])
        print(a)

        preOrder(root)
        a = " " + " ".join([str(num) for num in preList])
        print(a)


# Optimized solution
#coding:utf-8
N = int(eval(input()))
trees = [list(input().split()) for i in range(N)]

class BinaryTree:
    def __init__(self,key,p=None,l=None,r=None):
        self.key = key
        self.p = p
        self.l = l
        self.r = r

def Insert(root,z):
    y = None
    x = root
    while x != None:
        y = x
        if z.key < x.key:
            x = x.l
        else:
            x = x.r
    z.p = y

    if y == None:
        root = z
    elif z.key < y.key:
        y.l = z
    else:
        y.r = z
    return root

def preOrder(x):
    if x == None:
        return
    global preList
    preList.append(x.key)
    
    preOrder(x.l)
    preOrder(x.r)

def inOrder(x):
    if x == None:
        return
    inOrder(x.l)

    global inList
    inList.append(x.key)
    
    inOrder(x.r)

def Find(x,target):
    while x != None:
        y = x
        if target < x.key:
            x = x.l
        elif target > x.key:
            x = x.r
        else:
            print("yes")
            return
    print("no")

root = None
for data in trees:
    if data[0] == "insert":
        z = BinaryTree(int(data[1]))
        root = Insert(root,z)
    if data[0] == "find":
        Find(root, int(data[1]))
      
    if data[0] == "print":
        inList = []
        preList = []
        inOrder(root)
        a = " " + " ".join([str(num) for num in inList])
        print(a)

        preOrder(root)
        a = " " + " ".join([str(num) for num in preList])
        print(a)
# Original solution
import sys
import time

class Node:
    def __init__(self, key = None):
        self.key = key
        self.left = None
        self.right = None

def insert(key):
    global root
    z = Node(key)
    y = None
    x = root
    while x is not None:
        y = x
        if z.key < x.key:
            x = x.left
        else:
            x = x.right

    if y is None:
        root = z
    elif z.key < y.key:
        y.left = z
    else:
        y.right = z

def find(node, key):
    if node is None:
        return False
    elif node.key == key:
        return True
    else:
        return find(node.left, key) or find(node.right, key)

def inorderTreeWalk(node):
    if node:
        return inorderTreeWalk(node.left) + " " + str(node.key) + inorderTreeWalk(node.right)
    return ""

def preorderTreeWalk(node):
    if node:
        return " " + str(node.key) + preorderTreeWalk(node.left) + preorderTreeWalk(node.right)
    return ""

if __name__ == "__main__":
    lines = sys.stdin.readlines()
    del lines[0]

    root = None
    for line in lines:
        if line[0] == "p":
            print(inorderTreeWalk(root))
            print(preorderTreeWalk(root))
        else:
            com = line.split()
            if com[0][0] == "i":
                insert(int(com[1]))
            else:
                if find(root, int(com[1])):
                    print("yes")
                else:
                    print("no")

# Optimized solution
import sys
import time

class Node:
    def __init__(self, key):
        self.key = key
        self.parent = None
        self.left = None
        self.right = None

def insert(z):
    global root
    y = None
    x = root
    while x is not None:
        y = x
        if z.key < x.key:
            x = x.left
        else:
            x = x.right
    z.parent = y
    if y is None:
        root = z
    elif z.key < y.key:
        y.left = z
    else:
        y.right = z

def find(node, key):
    if node is None:
        return False
    elif node.key == key:
        return True
    elif node.key > key:
        return find(node.left, key)
    else:
        return find(node.right, key)

def inorderTreeWalk(node):
    global In
    if node:
        inorderTreeWalk(node.left)
        In.append(str(node.key))
        inorderTreeWalk(node.right)

def preorderTreeWalk(node):
    global Pre
    if node:
        Pre.append(str(node.key))
        preorderTreeWalk(node.left)
        preorderTreeWalk(node.right)

if __name__ == "__main__":
    lines = sys.stdin.readlines()
    del lines[0]

    root = None
    for line in lines:
        if line[0] == "p":
            In = []
            Pre = []
            inorderTreeWalk(root)
            print(" " + " ".join(map(str, In)))
            preorderTreeWalk(root)
            print(" " + " ".join(map(str, Pre)))
        else:
            com = line.split()
            if com[0][0] == "i":
                insert(Node(int(com[1])))
            else:
                if find(root, int(com[1])):
                    print("yes")
                else:
                    print("no")