Harryxun/stf_run huggingface dataset:
import bisect

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

x_negative = x[:bisect.bisect_left(x,0)]
x_positive = x[bisect.bisect_left(x,0):]

# 0以上の地点にロウソクが無い場合
if len(x_positive) == 0:
    print(abs(x_negative[-K]))
    exit()

# 地点0にロウソクがある場合
if x_positive[0] == 0:
    if K == 1:
        print(0)
        exit()
    K -= 1
    del x_positive[0]

t_list = []

# 全くターンしない場合
if len(x_negative) >= K:
    t_list.append(abs(x_negative[-K]))
if len(x_positive) >= K:
    t_list.append(x_positive[K-1])

# 1回だけターンする場合
for i in range(1, K-1):
    t_list.append(2*abs(x_negative[-i]) + x_positive[K-i-1])
    t_list.append(2*x_positive[i-1] + abs(x_negative[-(K-i)]))

print(min(t_list))

### FIXED CODE ###

import bisect

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

x_negative = x[:bisect.bisect_left(x,0)]
x_positive = x[bisect.bisect_left(x,0):]

# 0以上の地点にロウソクが無い場合
if len(x_positive) == 0:
    print(abs(x_negative[-K]))
    exit()

# 地点0にロウソクがある場合
if x_positive[0] == 0:
    if K == 1:
        print(0)
        exit()
    K -= 1
    del x_positive[0]

t_list = []

# 全くターンしない場合
if len(x_negative) >= K:
    t_list.append(abs(x_negative[-K]))
if len(x_positive) >= K:
    t_list.append(x_positive[K-1])

# 1回だけターンする場合
for i in range(1, K-1):
    try:
        t_list.append(2*abs(x_negative[-i]) + x_positive[K-i-1])
    except IndexError:
        pass
    
for i in range(1, K-1):
    try:
        t_list.append(2*x_positive[i-1] + abs(x_negative[-(K-i)]))
    except IndexError:
        pass

print(min(t_list))
A = int(input())
B = int(input())
C = int(input())

if A==B and B==C:
    print("No")
elif A != B and B != C:
    print("No")
else:
    print("Yes")

### FIXED CODE ###

def main():
    a, b, c = map(int, input().split())
    if (a == b and a != c) or (a == c and b != c) or (b == c and a != b):
        print("Yes")
    else:
        print("No")

if __name__ == '__main__':
    main()
x=int(input())
if x.=0:
    print(0)
else:
    print(1)

### FIXED CODE ###

x=int(input())
if x==0:
    print(1)
else:
    print(0)
N = int(input())
S = str(input())
dic = {'a':0,'b':0,'c':0,'d':0,'e':0,'f':0,'g':0,'h':0,'i':0,'j':0,'k':0,'l':0,'m':0,'n':0,'o':0,'p':0,'q':0,'r':0,'s':0,'t':0,'u':0,'v':0,'w':0,'x':0,'y':0,'z':0}

ans = 1

for i in range(N):
	dic[S[i]] += 1

for key in list(dic.keys()):
	ans *= (dic[key]+1)

print(str((ans-1)%(10**9+7))

### FIXED CODE ###

N = int(input())
S = str(input())
dic = {'a':0,'b':0,'c':0,'d':0,'e':0,'f':0,'g':0,'h':0,'i':0,'j':0,'k':0,'l':0,'m':0,'n':0,'o':0,'p':0,'q':0,'r':0,'s':0,'t':0,'u':0,'v':0,'w':0,'x':0,'y':0,'z':0}

ans = 1

for i in range(N):
	dic[S[i]] += 1

for key in list(dic.keys()):
	ans *= (dic[key]+1)

print(str((ans-1)%(10**9+7)))
n=int(input())
x=list(map(int, input().split()))

x.sort()
ans=0

for i range(n):
  ans=ans+x[i*2]
    
print(ans)


### FIXED CODE ###

N = int(input())

L = list(map(int, input().split()))

L.sort()

ans = 0

for i in range(N):
    ans = ans + L[i*2]
    
print(ans)
X,Y=input().split(' ')

X=int(X)
Y=int(Y)

num=4*A

if B>num:
    print("No")
else:
    print("Yes")

### FIXED CODE ###

#getting input from user
#cranes and turtle already give the information
#condition yes or no 
X,Y= map(int,input().split())
cranes= 2 # assign 2 to cranes
turtles= 4 # assign 4 to turtle
ans="No"
for i in range(X+1): 
    b=X-i
    if cranes*i + turtles*b == Y:
        ans = "Yes"
print(ans)

# Time complixity O(X)
T = list(map(str, input()))
count = 0
ans = []

if T[0] == '?':
    T.pop(0)
    if T[1] == 'D' or T[1] == '?':
        ans.append('P')
        T.insert(0, 'P')
    else:
        ans.append('D')
        T.insert(0, 'D')
else:
    ans.append(T[0])

for i in range(1, len(T)):
    if T[i] == '?':
        if ans[i - 1] == 'D':
            if len(T) % 2 == 0:
                ans.append('P')
            else:
                ans.append('D')
        else:
            ans.append('D')
    else:
        ans.append(T[i])

ans_ans = ''.join(ans);

print(ans_ans)

### FIXED CODE ###

T = list(map(str, input()))
count = 0
ans = []




for i in range(0, len(T)):
    if T[i] == '?':
        ans.append('D')
    else:
        ans.append(T[i])


ans_ans = ''.join(ans);

print(ans_ans)
def main()->None:
    W, H, N = map(int, input().split())
    range_N = range(N)
    xy = []
    a_i = []
    for i in range_N:
        x, y, a = map(int, input().split())
        xy.append([x, y])
        a_i.append(a)
    
    flag = False
    for x, y, a in zip(xy, a_i):
        if a % 4 == 1:
            W -= x
        if a % 4 == 2:
            W -= x
        if a % 4 == 3:
            H -= y
        else:
            H -= y
        if W <= 0 or H <= 0:
            flag = True
            break
    if flag: print(0)
    else: print(W*H)



if __name__ == "__main__":
    main()

### FIXED CODE ###




def main()->None:
    W, H, N = map(int, input().split())
    range_N = range(N)
    xl, xr, yd, yu = 0, W, 0, H
    for i in range_N:
        x, y, a = map(int, input().split())
        if a == 1:
            xl = max(x, xl)
        elif a == 2:
            xr = min(x, xr)
        elif a == 3:
            yd = max(y, yd)
        else:
            yu = min(y, yu)
    if xl >= xr or yd >= yu:
        print(0)
    else:
        print((xr - xl) * (yu - yd))

if __name__ == "__main__":
    main()
if len(S) > K:
    print(S[:K]+"...")
else:
    print(S)

### FIXED CODE ###

K = int(input())
S = input()

if len(S) > K:
    print(S[:K]+"...")
else:
    print(S)
w = input()
count = 0
while True:
    t = input().lower
    if t == "END_OF_TEXT": break
    count += t.count(w)
print(int(count))

### FIXED CODE ###

w = input()
count = 0
while True:
    t = input()
    if t == "END_OF_TEXT": break
    for c in t.lower().split(' '):
        if c == w: count += 1
print(int(count))
lis=list(map(int,input().split()))
mod=(10**9)+7
pascal=[]
#print(lis[0]-lis[1]+1,lis[1]-1)
rank=max(lis[0]-lis[1]+1,lis[1]-1)
for i in range(rank):
    pascal.append([])
    for j in range(i+2):
        if j==0 or j==i+1:
            pascal[i].append(1)
        else:
            pascal[i].append(pascal[i-1][j-1]+pascal[i-1][j])
#print(pascal)
for i in range(1,1+lis[1]):
    ans=pascal[lis[0]-lis[1]][i]*pascal[lis[1]-2][i-1]%mod
    print(ans)


### FIXED CODE ###

lis=list(map(int,input().split()))
mod=(10**9)+7
pascal=[]
#print(lis[0]-lis[1]+1,lis[1]-1)
rank=max(lis[0]-lis[1]+1,lis[1]+1)
for i in range(rank):
    pascal.append([])
    for j in range(i+2):
        if j==0 or j==i+1:
            pascal[i].append(1)
        else:
            pascal[i].append(pascal[i-1][j-1]+pascal[i-1][j])
#print(len(pascal[-1]))
for i in range(1,1+lis[1]):
    if i<=lis[0]-lis[1]+1:
        ans=pascal[lis[0]-lis[1]][i]*pascal[lis[1]-2][i-1]%mod
    else:
        ans=0
    print(ans)
K=int(input())
ANS=[]
for i in range(1,10**6*2):
  LEN=len(str(i))
  STR=str(i)
  if LEN==1:
    ANS+=[i]
  for k in range(LEN-1):
    if abs(int(STR[k])-int(STR[k+1]))>1:
      break
    if k==LEN-2:
      ANS+=[i]
ans=ANS[K-1] 
print(ans)

### FIXED CODE ###

K=int(input())
ANS=[i for i in range(1,10)]
i=0
while len(ANS)<=10**5:
  last=str(ANS[i])[-1]
  if last=="0":
    ANS+=[ANS[i]*10,ANS[i]*10+1]
  elif last=="9":
    ANS+=[ANS[i]*10+8,ANS[i]*10+9]
  else:
    ANS+=[ANS[i]*10+int(last)-1,ANS[i]*10+int(last),ANS[i]*10+int(last)+1]
  i+=1  
ans=ANS[K-1]
print(ans)
n, k = list(map(int, input().split()))

proba = 0
for i in range(1, N):
  x = i
  p = 1
  while x < K:
    p *= 0.5
    x += 1
  proba += p/N
  
print(proba)

### FIXED CODE ###

N, K = list(map(int, input().split()))
 
ans = 0
for i in range(1, N+1):
    p = 1
    x = i
    while x < K:
        p *= 0.5
        x *= 2
    
    ans += p/N
 
print(ans)
import sys
sys.setrecursionlimit(10000)

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

key = {1:2, 2:5, 3:5, 4:4, 5:5, 6:6, 7:3, 8:7, 9:6}
#k = [1, 7, 4, 5, 3, 2, 9, 6, 8]

dpi = [-1<<50] * 9 + [0]
def dp(i):
    '''i should be started from 1'''

    ans = []
    for j in a:
        ans.append(dpi[len(dpi) - key[j]] + 1)
    dpi.append(max(ans))

    if i == n:
        return dpi[len(dpi) - 1]
    else:
        return dp(i + 1)

i = dp(1)
a.sort()

s = ''
cur = -1
for j in range(i):
    for k in reversed(a):
        if dpi[cur-key[k]] == dpi[cur] - 1:
            s += str(k)
            cur -= key[k] 
            break
        else:
            continue

print(int(s))


### FIXED CODE ###

import sys
sys.setrecursionlimit(15000)

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

key = {1:2, 2:5, 3:5, 4:4, 5:5, 6:6, 7:3, 8:7, 9:6}
#k = [1, 7, 4, 5, 3, 2, 9, 6, 8]

dpi = [-1<<50] * 9 + [0]
def dp(i):
    '''i should be started from 1'''

    ans = []
    for j in a:
        ans.append(dpi[len(dpi) - key[j]] + 1)
    dpi.append(max(ans))

    if i == n:
        return dpi[len(dpi) - 1]
    else:
        return dp(i + 1)

i = dp(1)
a.sort()

s = ''
cur = -1
for j in range(i):
    for k in reversed(a):
        if dpi[cur-key[k]] == dpi[cur] - 1:
            s += str(k)
            cur -= key[k] 
            break
        else:
            continue

print(int(s))
H=int(input())+1
A=[0]+list(map(int,input().split()))
def h(i):
 l=2*i;r=l+1
 if r<H && l<H:
  if A[i]<A[l]:
   if A[l]<A[r]:A[i],A[r]=A[r],A[i];h(r)
   else:A[i],A[l]=A[l],A[i];h(l)
  elif A[i]<A[r]:A[i],A[r]=A[r],A[i];h(r)
 elif l<H and A[i]<A[l]:A[i],A[l]=A[l],A[i];h(l)
for i in range(H//2,0,-1):h(i)
print(' '+' '.join(map(str,A[1:])))


### FIXED CODE ###

H=int(input())+1
A=[0]+list(map(int,input().split()))
def h(i):
 l=2*i;r=l+1
 if r<H and l<H:
  if A[i]<A[l]:
   if A[l]<A[r]:A[i],A[r]=A[r],A[i];h(r)
   else:A[i],A[l]=A[l],A[i];h(l)
  elif A[i]<A[r]:A[i],A[r]=A[r],A[i];h(r)
 elif l<H and A[i]<A[l]:A[i],A[l]=A[l],A[i];h(l)
for i in range(H//2,0,-1):h(i)
print(' '+' '.join(map(str,A[1:])))
import sys
from collections import Counter
n,m=map(int,input().split())
a=list(map(int,read().split()))
c=Counter(a)
ans="YES"
for i in c.values():
  if i%2:
    ans="NO"
print(ans)

### FIXED CODE ###

import sys
from collections import Counter
read=sys.stdin.read
n,m=map(int,input().split())
a=list(map(int,read().split()))
c=Counter(a)
ans="YES"
for i in c.values():
  if i%2:
    ans="NO"
print(ans)
N = int(input())
S = [str(input()) for i in range(N)]

ans = 0
firstB = 0
lastA = 0
cnt = 0
for s in S:
    if s[0] == 'B':
        firstB += 1
    if s[-1:] == 'A':
        lastA += 1

    if s[0] == 'B' and s[-1:] == 'A':
        cnt += 1

    ans += s.count('AB')
    
if cnt == max([firstB,lastA]):
    print(ans + cnt -1)
else:
    print(ans+ min([firstB,lastA]))

### FIXED CODE ###

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

print(N - K + 1)
a = list(int,input().split())
if sum(a) >= 22:
  print('bust')
else:
  print('win')

### FIXED CODE ###

a = list(map(int,input().split()))
if sum(a) >= 22:
  print('bust')
else:
  print('win')
import math
a, b, x = map(int, input().split())

if x < a*a*b/2:
    tan = 2*x / (a*b*b)
else:
    i = a**3
    j = 2*(a*a*b-x)
    tan = i/j

deg = math.degrees(math.atan(tan))
print(90-deg)

### FIXED CODE ###

import math
a, b, x = map(int, input().split())

if x < a*a*b/2:
    tan = 2*x / (a*b*b)
    deg = math.degrees(math.atan(tan))
    print(90-deg)
elif x == a*a*b:
    print(0)
else:
    i = a**3
    j = 2*(a*a*b-x)
    tan = i/j
    deg = math.degrees(math.atan(tan))
    print(90-deg)
N,M=map(int,input().split())
S=input()
T=input()
g=gcd(N,M)
m=(N//g)*(M//g)*g
a=0
b=0
A=m//N
B=m//M
t=True
while(a<N):
    if S[a]==T[b]:
        a+=B
        b+=A
    else:
        print(-1)
        quit()
print(m)


### FIXED CODE ###

from fractions import gcd
from math import sqrt
from heapq import *
from math import factorial
from collections import defaultdict

N,M=map(int,input().split())
S=input()
T=input()
g=gcd(N,M)
m=(N//g)*(M//g)*g
a=0
b=0
A=m//N
B=m//M
t=True
while(a<N):
    if S[a]==T[b]:
        a+=B
        b+=A
    else:
        print(-1)
        quit()
print(m)
n=int(input())
L=[]
L.append(2)
L.append(1)
for i in range(3,n+1):
  x=L[i-1]+L[i-2]
  L.append(x)

print(L[n])

### FIXED CODE ###

n=int(input())
l=[0 for i in range(n+1)]
l[0]=2
l[1]=1
for j in range(2,n+1):
  l[j]=l[j-1]+l[j-2]
print(l[n])
S = int(input())
h = int(S/3600)
m = S- 9nt(h*3600)/60)
sec = S- h*3600-m*60;
print(str(h)+":"+str(m)+":"+str(sec))


### FIXED CODE ###

S = int(input())
h = int(S/3600)
m = int((S- h*3600)/60)
sec = S- h*3600-m*60;
print(str(h)+":"+str(m)+":"+str(sec))
n = int(input())

if n[0] == n[2]:
  print("Yes")
else:
  print("No")

### FIXED CODE ###

n = input()

if n[0] == n[2]:
  print("Yes")
else:
  print("No")
N = int(input())
for i in range(1,1+N):
  if N % 3 != 0 or N%5 !=0:
    x += i
print(x)

### FIXED CODE ###

N = int(input())
x = 0
for i in range(1, N+1):
    if (i % 3) != 0 and (i % 5) != 0:
        x = x+i
print(x)
a = int(input())
b = int(input())

print( a*b, 2*(a+b) )


### FIXED CODE ###

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

print( a*b, 2*(a+b) )
def calc():
    d = a
    a = b
    b = d

    d = a
    a = c
    c = d
    return a, b, c

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

### FIXED CODE ###

def calc():
    x, y, z = c, a, b

    print(x, y, z)

a, b, c = map(int, input().split())
calc()
import numpy as np
from collections import defaultdict

memo = {}
def dp(v, d, c):
    if memo.get((v, d), False):
        return None

    memo[(v, d)] = True
    if d == 0:
        res[v-1] = c
        return None

    dp(v, d-1, c)
    for e in dic.get(v, []):
        dp(e, d-1, c)


N, M = tuple(map(int, input().split(' ')))

dic = defaultdict(list)

for m in range(M):
    a, b = tuple(map(int, input().split(' ')))
    dic[a].append(b)
    dic[b].append(a)

Q = int(input())

vdc = [None]*Q

for q in range(Q):
    vdc[q] = tuple(map(int, input().split(' ')))

res = np.zeros(N)

for q in range(Q-1, -1, -1):
    v, d, c = vdc[q]
    dp(v, d, c)


for i in range(N):
    print(int(res[i]))


### FIXED CODE ###

import numpy as np


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

res = 0
for i in range(len(a[N:])):
    if i % 2 == 0:
        res += a[N+i]

print(res)
n = int(input())
a = [0]
for i in range(n):
    a.append(int(input()))


btn2 = a.index(2)
cnt = 1
idx = 1
for i in range(n+1):
    if a[idx] == btn2:
        cnt += 1
        print(cnt)
        break

    else:
        idx = a[idx]
        cnt += 1
else:
    print(-1)

### FIXED CODE ###

n = int(input())
a = [0]
for i in range(n):
    a.append(int(input()))

cnt = 1
idx = 1
for i in range(n):
    if a[idx] == 2:
        print(cnt)
        break

    else:
        idx = a[idx]
        cnt += 1
else:
    print(-1)
N = int(input())
L_2 = 2
L_1 = 1
p = 0
for i in range(2,N+1):
  K = L_1+L_2
  L_2 = L_1
  L_1 = K
print(K)

### FIXED CODE ###

L = [2,1]
for i in range(100):
  L.append(L[i+1]+L[i])
n = int(input())
print(L[n])
import itertools
import math
N = int(input())
alphabet = list('abcdefghijklmnopqrstuvwxyz')
num = math.ceil(math.log(N, 26))
cnt = [26**i for i in range(1, 15)]
cumsum = list(itertools.accumulate(cnt))
if num == 1:
    ans_n = N-1
    ans_li = list(itertools.product(alphabet, repeat=num))
    print(''.join(ans_li[ans_n]))
else:
    ans = ''
    # for i in range(num):
    #     if i == 1:
    #         ans_n = N-1
    #         ans_li = list(itertools.product(alphabet, repeat=num))
    #         ans += ans_li[ans_n]
    #     else:
    #         now_n = N-26**(i-1) - 1
    #         pre = 26**(i-1)
    #         tmp = ans_n//pre

    ans_n = N - cumsum[num-1] - 1
    pre = 26**(num-1)
    tmp = ans_n//pre
    ans = alphabet[tmp]
    final = ans_n - pre*tmp
    ans_li = list(itertools.product(alphabet, repeat=num-1))
    print(ans + ''.join(ans_li[final]))



### FIXED CODE ###

n = int(input())
ans = ''
i = 1
while n > 0 :
    x = n % 26
    if x != 0:
        ans += chr(x+96)
    else:
        ans += 'z'
        n -= 1
    n = n//26
print(ans[::-1])
a = int(input())
b = int(input())
print(int(a*b))

### FIXED CODE ###

a, b = map(int, input().split())
print(int(a*b))
n = int(input())
a = [tuple(map(int, input().split())) for i in range(n)]
t = set(a)
minans = 1000000000000
for i in range(n):
    for j in range(i + 1, n):
        r = t.copy()
        p = a[i][0] - a[j][0]
        q = a[i][1] - a[j][1]
        curans = 0
        while r:
            curans += 1
            m = r.pop()
            z = m.copy()
            while (m[0] + p, m[1] + q) in r:
                m = (m[0] + p, m[1] + q)
                r.remove(m)
            m = z.copy()
            while (m[0] - p, m[1] - q) in r:
                m = (m[0] - p, m[1] - q)
                r.remove(m)
        minans = min(minans, curans)
print(minans)


### FIXED CODE ###

n = int(input())
a = [tuple(map(int, input().split())) for i in range(n)]
t = set(a)
assert len(t) == len(a)
minans = 1000000000000
for i in range(n):
    for j in range(i + 1, n):
        r = t.copy()
        p = a[i][0] - a[j][0]
        q = a[i][1] - a[j][1]
        curans = 0
        while r:
            curans += 1
            m = r.pop()
            z = m
            while (m[0] + p, m[1] + q) in r:
                m = (m[0] + p, m[1] + q)
                r.remove(m)
            m = z
            while (m[0] - p, m[1] - q) in r:
                m = (m[0] - p, m[1] - q)
                r.remove(m)
        minans = min(minans, curans)
if minans == 1000000000000:
    print(1)
else:
    print(minans)
S = list(input()
N = int(input())
ma=0
for i in range(N-1):
    ma=max(len(set(S[:i]) & set(S[i:])), ma)
print(ma)

### FIXED CODE ###

N= int(input())
S = list(input())
count=0
saidai=0
for i in range(1, N-1):
    count = len(set(S[:i]) & set(S[i:]))
    saidai=max(saidai, count) 
print(saidai)
N=int(input())
print((10**N-9**N-9**N+8**N)/(10**7+7)

### FIXED CODE ###

MOD=10**9+7
N=int(input())
ans=pow(10,N,MOD)
ans-=2*pow(9,N,MOD)
ans+=pow(8,N,MOD)
ans%=MOD
print(ans)
n,m,c=map(int,input().split())
sum=0
count=0
for i in range(m):
    b=list(map(int,input().split()))
    a=list(map(int,input().split()))
    sum+=b[i]*a[i]
for j in range(n):
    if sum>-c:
        count+=1
print(count)

### FIXED CODE ###

n,m,c=map(int,input().split())
b=list(map(int,input().split()))
count=0
for i in range(n):
    p=c
    a=list(map(int,input().split()))
    for j in range(m):
        p+=a[j]*b[j]
    if p>0:
        count+=1
print(count)
a = input()
b = input()
a += b
can = 0
for i in range(1,100):
  if(i*i == int(a)):
    can = 1
if(can == 1):
  print("Yes")
else:
  print("No")

### FIXED CODE ###

a,b = input().split()
a += b
can = 0
for i in range(1,1000):
  if(i*i == int(a)):
    can = 1
if(can == 1):
  print("Yes")
else:
  print("No")
#coding: utf-8
import sys
N = int(input())
l = []
for i in range(N):
    a = list(map(int, input().split()))
    l.append(a)
    if N == 1:
      print(a[0], a[1], a[2])
      sys.exit()

for i in range(N-1):
    ans = []
    for cx in range(101):
        for cy in range(101):
          if l[i][2] + abs(l[i][0] - cx) + abs(l[i][1] - cy) == l[i+1][2] + abs(l[i+1][0] - cx) + abs(l[i+1][1] - cy):
            if i == 0:
              ans.append([cx, cy])
            else:
              if [cx, cy] in ansn:
                ans.append([cx, cy])
    ansn = ans[:]
    if len(ans) == 1:
        break

print(ans[0][0], ans[0][1], l[0][2] + abs(l[0][0] - ans[0][0]) + abs(l[0][1] - ans[0][1]))

### FIXED CODE ###

#coding: utf-8
N = int(input())
l = []
for i in range(N):
    a = list(map(int, input().split()))
    if a[2] > 0:
      l.append(a)
if len(l) >= 2:
    for i in range(len(l)-1):
        ans = []
        for cx in range(101):
            for cy in range(101):
                if l[i][2] + abs(l[i][0] - cx) + abs(l[i][1] - cy) == l[i+1][2] + abs(l[i+1][0] - cx) + abs(l[i+1][1] - cy) and l[i][2] != 0 and l[i+1][2] != 0:
                    if i == 0:
                        ans.append([cx, cy])
                    else:
                        if [cx, cy] in ansn:
                            ans.append([cx, cy])
        ansn = ans[:]
        if len(ans) == 1:
            break
    print(ans[0][0], ans[0][1], l[0][2] + abs(l[0][0] - ans[0][0]) + abs(l[0][1] - ans[0][1]))
else:
    print(l[0][0], l[0][1], l[0][2])
a, b, k = map(int,input().split())

ans = {i for i in range(a,a+k)}
ans2 = {i for i in range(b,b-k,-1)}

ans.add(ans2)
ans = sorted(list(ans))

for an in ans: print(an) 


### FIXED CODE ###

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

ans = {i for i in range(a,min(a+k,b+1))}
ans2 = {i for i in range(b,max(b-k,a-1),-1)}

ans = ans | ans2
ans = sorted(list(ans))

for an in ans: print(an)
x = int(input())

if x< 1200;
  print("ABC")
else:
  print("ARC")


### FIXED CODE ###

x = int(input())

if x< 1200:
  print("ABC")
else:
  print("ARC")
from collections import deque

s = input()
q = int(input())
query = [input() for _ in range(q)]

#s = deque(s)

inv = 0
for q in query :
    if q[0] == '1':
        inv += 1
    else:
        _,f,c = q.split()
        if f == '1':
            if inv % 2 == 0:
                s.append(c)
            else:
                s.appendleft(c)
s = ''.join(s)
print(s if inv % 2 == 0 else s[::-1])


### FIXED CODE ###

from collections import deque

s = input()
q = int(input())
query = [input() for _ in range(q)]

s = deque(s)

inv = 0
for q in query :
    if q[0] == '1':
        inv += 1
    else:
        _,f,c = q.split()
        if f == '1':
            if inv % 2 == 0:
                s.appendleft(c)
            else:
                s.append(c)
        else:
            if inv % 2 ==0:
                s.append(c)
            else:
                s.appendleft(c)
s = ''.join(s)
print(s if inv % 2 == 0 else s[::-1])
x = input()
for i in range(5):

    alist = list(map(int,x))
    result = sum(alist)
    x = str(result

if result%9 == 0 :
    print("yes")
else:
    print("no")

### FIXED CODE ###

m = input("")
s = m.split(".")
sum = 0
if len(s) == 1 and int(m)>=0 and int(m)<10**200000:
    for i in m :
        sum = sum+int(i)
    if sum % 9 == 0:
        print("Yes")
    else:
        print("No")
graph = [[] for _ in range(N + 1)]
for a, b in AB:
  graph[a].append(b)
  graph[b].append(a)
  
def make_tree(graph, root) -> (list, list):
  INF = 10 ** 15
  dist = [INF] * len(graph)
  parent = [-1] * len(graph)
  stack = [root]
  dist[root] = 0
  parent[root] = root
  while stack:
    s = stack.pop()
    for g in graph[s]:
      if dist[g] > dist[s] + 1:
        dist[g] = dist[s] + 1
        parent[g] = s
        stack.append(g)
  return dist, parent
 
def lca(u, v, dist, parent):
  distu, distv = dist[u], dist[v]
  if distu > distv:
    for _ in range(distu - distv):
      u = parent[u]
  if distv > distu:
    for _ in range(distv - distu):
      v = parent[v]
  while u != v:
    u, v = parent[u], parent[v]
  return u

# root = 1
# dist, parent = make_tree(graph, root)
# print("dist:", dist[1:])
# print("parent:", parent[1:])

### FIXED CODE ###

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

print("Yes" if N == M else "No")