Harryxun/stf_run huggingface dataset:
s1,s2,s3 = input()
if(s1==s2 and s2==s3):
  print('NO')
elif:
  print('YES')

### FIXED CODE ###

a,b,c=input()
if a==b and b==c:
  print("No")
else:
  print("Yes")
a,b = map(input().split())

if a + b[-1] == b :

   print("Yes")

else:
   print("No")

### FIXED CODE ###

s = input()
t = input()

if (s + t[-1]) == t :
    print("Yes")

else :
    print("No")
A * B

### FIXED CODE ###

a, b = (int(x) for x in input().split())
print(a * b)
N,K = map(int,input().split())
P = [0 for i in range(N)]
for i in range(K):
    a = int(input())
    b = list(input().split())
  for j in range(a):
      P[b[j]-1] = 1 
m = 0   
for i in range(N):
    if P[i] == 0:
        m += 1
print(m)

### FIXED CODE ###

n, k = map(int, input().split())
 
m = [0]*n
 
for i in range(k):
    d = int(input())
    a = [int(x) for x in input().split()]
    for j in range(d):
        m[a[j]-1] += 1
 
print(m.count(0))
import sys
sys.setrecursionlimit(4100000)

x,y,a,b,c = map(int,input(),split())
p = sort(list(map(int,input(),split())))
q = sort(list(map(int,input(),split())))
r = list(map(int,input(),split()))
ans = 0

for k in range(1,x+1):
    r.append(p[-k])
for v in range(1,y+1):
    r.append(p[-v])

rs = sort(r)

for i in range(1,X+Y+1):
    ans += rs[-i]
print(str(ans))

### FIXED CODE ###

import sys
sys.setrecursionlimit(4100000)

x,y,a,b,c = map(int,input().split())
p = sorted(list(map(int,input().split())))
q = sorted(list(map(int,input().split())))
r = list(map(int,input().split()))
ans = 0

for k in range(1,x+1):
    r.append(p[-k])
for v in range(1,y+1):
    r.append(q[-v])

rs = sorted(r)

for i in range(1,x+y+1):
    ans += rs[-i]
print(str(ans))
#a, b = map(float, input().split())

a, b = input().split()

from decimal import Decimal
import math
print(math.floor(int(a)*Decimal(b))


### FIXED CODE ###

#a, b = map(float, input().split())

a, b = input().split()
from decimal import Decimal
import math
print(math.floor(int(a)*Decimal(b)))
N=int(input())
number=list(map(int,input().split()))
sum_number=sum(number)
Q=int(input())
number_count=[0]*100000
for i in range(100000):
    number_count[i]=number.count(i)

for j in range(Q):
    B,C=map(int,input().split())
    sum_number += (C-B)*number_count[B]
    number_count[C] += number_count[B]
    number_count[B] -= number_count[B]
    print(sum_number)


### FIXED CODE ###

from collections import Counter
N=int(input())
number=list(map(int,input().split()))
sum_number=sum(number)
Q=int(input())
number_count=Counter(number)


for _ in range(Q):
    B,C=map(int,input().split())
    sum_number += (C-B)*number_count[B]
    number_count[C] += number_count[B]
    number_count[B] = 0
    print(sum_number)
from itertools import combinations
inf = input().split()
N = int(inf[0])
K = int(inf[1])
if K > (N-1)*(N-2)//2:
  print(-1)
else:
  if K==(N-1)*(N-2)//2:
    len(K)
    for i in range(2,N+1):
      print(1,i)
  else:
    ls = [i for i in range(1,N+1)]
    ls = list(combinations(ls,2))
    dic = {x:0 for x in ls}
    for i in range(2,N+1):
      dic[(1,i)] = 1
    m = (N-1)*(N-2)//2
    while m>K:
      for x in ls:
        if dic[x]==0:
          dic[x]=1
          m-=1
          break
    ans = [i for i in dic.keys() if dic[i]==1]
    print(len(ans))
    for x in ans:
      print(x[0], x[1])


### FIXED CODE ###

from itertools import combinations
inf = input().split()
N = int(inf[0])
K = int(inf[1])
if K > (N-1)*(N-2)//2:
  print(-1)
else:
  if K==(N-1)*(N-2)//2:
    print(N-1)
    for i in range(2,N+1):
      print(1,i)
  else:
    ls = [i for i in range(1,N+1)]
    ls = list(combinations(ls,2))
    dic = {x:0 for x in ls}
    for i in range(2,N+1):
      dic[(1,i)] = 1
    m = (N-1)*(N-2)//2
    while m>K:
      for x in ls:
        if dic[x]==0:
          dic[x]=1
          m-=1
          break
    ans = [i for i in dic.keys() if dic[i]==1]
    print(len(ans))
    for x in ans:
      print(x[0], x[1])
n = int(input())
s = input()

num = 0
l = 0
r = 0
for i in range(n):
    if s[i] == ")":
        num += 1
    else:
        num -= 1
    if num == -1:
        l += 1
        num = 0

num = 0
for i in range(n-1, 0, -1):
    if s[i] == "(":
        num += 1
    else:
        num -= 1
    if num == 01:
        r += 1
        num = 0

print("("*l + s + ")"*r)

### FIXED CODE ###

n = int(input())
s = input()

num = 0
lmax = 0
rmax = 0
for i in range(n):
    if s[i] == ")":
        num += 1
    else:
        num -= 1
    lmax = max(lmax, num)

num = 0
for i in range(n-1, -1, -1):
    if s[i] == "(":
        num += 1
    else:
        num -= 1
    rmax = max(rmax, num)

print("("*lmax + s + ")"*rmax)
N = int(input())
S = input()

count[0] = S.count('.')
for i in range(1, len(S)+1):
    count[i] = count[i-1] + (1 if S[i-1]=='#' else 0) - (1 if S[i-1]=='.' else 0)

print(min(count)) 

### FIXED CODE ###

N = int(input())
S = input()

count = [0]*(len(S)+1)
count[0] = S.count('.')
for i in range(1, len(S)+1):
    count[i] = count[i-1] + (1 if S[i-1]=='#' else 0) - (1 if S[i-1]=='.' else 0)

print(min(count))
n,k = map(int,input().split())
l = list(map(int,input().split()))
ls = []
for i in range(n-k+1):
  if l[i] <0 and l[i+k]<0:
    ls.append(abs(l[i]))
  elif l[i] >0 and l[i+k]>0:
    ls.append(abs(l[i]))
  elif l[i] <0 and l[i+k]>0:
    ls.append(min(abs(l[i]),l[i+k])*2 + max(abs(l[i]),l[i+k]))
print(min(ls))

### FIXED CODE ###

n,k = map(int,input().split())
l = list(map(int,input().split()))
ls = []
for i in range(n-k+1):
  a = l[i]
  b = l[i+k-1]
  ls.append(min(abs(a)+abs(a-b), abs(b)+abs(a-b)))
print(min(ls))
N = int(input())
A = list(map(int, input().split()))
ans = 1

limit = pow(10,18)

f = 0
for i in range(N):
    if A[i] != 0:
        ans *= A[i]
    else:
        print(0)
        exit()

    if ans > limit:
        f = 1

if f == 1:
    print(-1)
else:
    print(ans)


### FIXED CODE ###

import math

A,B=input().split()

A = int(A)
N,F = B.split('.')
ans = (A * 100 * int(N) + A * int(F)) //100

print(ans)
import sys
N,M=map(int,input().split())
A=[]
B=[]
A+=[str(input()) for i in range(N)]
B+=[str(input()) for i in range(M)]
for i in range(N-M+1):
  for j in range(N-M+1):
    ans=1
    for k in range(M):
      for l in range(M):
        if B[k][l]!=A[i+k][j+l]:
          ans=0
    if ans:
      print("Yes")
      sys.exit()
print("No")

### FIXED CODE ###

A,B=map(int, input().split())
if (A+12)%14 > (B+12)%14:
  print("Alice")
elif A==B:
  print("Draw")
else:
  print("Bob")
s = input()
for i in range(97, 113+1):
    if s.find(chr(i)) == -1:
        print(c)
        exit()
    
print('None')

### FIXED CODE ###

s = input()
for c in 'abcdefghijklmnopqrstuvwxyz':
    if s.find(c) == -1:
        print(c)
        exit()
    
print('None')
n = int(input())
a = list(map(int, input().split()))

if n%2 == 1:
    r = a[::-2]
    l = a[1::2]
else:
    r = a[::-2]
    l = a[::2]
    
print(*r,*l)

### FIXED CODE ###

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

if n%2 == 1:
    r = a[::-2]
    l = a[1::2]
else:
    r = a[::-2]
    l = a[::2]
    
print(*r,end=" ")
print(*l)
'''
Fuad Ashraful Mehmet
University of Asia Pacific,Bangladesh
Date: 7th May 2020
'''


n,k=[int(x) for x in input().split()]
vis=[-1 for i in range(n+4)]
node=0
a=[int(x) for x in input().split()]
a=[0]+a
#print(a)

def dfs(u,l,turn):
    if turn<=0:
        print(u)
        return -1
    if vis[u]!=-1:
        global node
        node=u
        #print("node "+str(node))
        return l-vis[node]
    vis[u]=l
    return dfs(a[u],l+1,turn-1)

diff=dfs(1,0,k)
if diff==-1:
    exit()
lo=1
hi=10**25
cost=vis[node]

while lo<=hi:
    mid=(lo+hi)//2
    temp=mid*diff
    #print(lo,hi)
    if cost+temp<=k:
        lo=mid+1
    else:
        hi=mid-1


t=hi*diff+cost

#print(k-t)

def dfs2(u,turn):
    if turn<=0:
        print(u)
        return
    
    dfs2(a[u],turn-1)

dfs2(node,k-t)


### FIXED CODE ###

'''
Fuad Ashraful Mehmet
University of Asia Pacific,Bangladesh
Date: 7th May 2020
'''

n,k=map(int,input().split())
a=list(map(int,input().split()))
a=[0]+a
vis=[-1]*(n+5)


turn=k
now=1
c=0
while vis[now]==-1:

    if turn<=0:
        print(now)
        exit()
    vis[now]=c
    c+=1
    now=a[now]
    turn=turn-1

diff =c-vis[now]

lo=1
hi=10**25
cost=vis[now]
while lo<=hi:

    mid=(lo+hi)//2
    t=mid*diff
    if t+cost<=k:
       lo=mid+1
    else:
        hi=mid-1

t=hi*diff+cost


rem=k-t

while rem>0:
    now=a[now]
    rem-=1

print(now)
n = int(input())
kotae = 0
if n == 100000:
  kotae = 90909
elif n => 10000:
  kotae = 909 + (n - 10000 + 1)
elif n => 1000:
  kotae = 909
elif n => 100:
  kotae = 9 + (n- 100 +1)
elif n => 10:
  kotae = 9
else:
  kotae = n

### FIXED CODE ###

n = int(input())
kotae = 0
if n == 100000:
  kotae = 90909
elif n >= 10000:
  kotae = 909 + (n - 10000 + 1)
elif n >= 1000:
  kotae = 909
elif n >= 100:
  kotae = 9 + (n- 100 +1)
elif n >= 10:
  kotae = 9
else:
  kotae = n
print(kotae)
print("縦と横の長さを入力")

a=int(input("a:"))
b=int(input("b:"))

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



### FIXED CODE ###


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

r=a*b
length=a*2+b*2
print(r,length)
S, T = input().split(' ')
A, B = list(map(int, input().split(' ')))
U = input()
if U==S: return A-1,B
if U==T: return A,B-1

### FIXED CODE ###

S, T = input().split(' ')
A, B = list(map(int, input().split(' ')))
U = input()
if U==S: print(A-1,B)
if U==T: print(A,B-1)
N = int(input())
L_list = list(map(int, input().split()))

max_ = max(L_list)
L_list.remove(max_)

if max_ < np.sum(L_list):
    print("Yes")
else:
    print("No")

### FIXED CODE ###

import numpy as np
N = int(input())
L_list = list(map(int, input().split()))

max_ = max(L_list)
L_list.remove(max_)

if max_ < np.sum(L_list):
    print("Yes")
else:
    print("No")
N,M = list(map(int,input().split()))
MAX = 1000000000
S = []
Room = [MAX for i in range(N)]#2 - N
Room[0] = 0
ACCESS = [0 for i in range(N-1)]
for _ in range(M):
    a,b = list(map(int,input().split()))
    S.append([a,b])
    S.append([b,a])
for i in S:
    if i[0] == 1:
        Room[i[1]-1] = 1
        ACCESS[i[1]-2] = 1
        S.remove(i)
depth = 1
while max(Room) > MAX/2:
    for i in range(len(Room)):
        if Room[i] ==depth:
            k = 0
            for _ in range(len(S)):
                j = S[k]
                if (j[0] == i+1)*(Room[j[1]-1]>MAX/2):
                    Room[j[1]-1] = depth+1
                    ACCESS[j[1]-2] = i+1
                    S.remove(j)
                    S.remove(j[::-1])
                    k -= 1
                k += 1
    depth += 1
print('Yes')
for i in ACCESS:
    print(i)

### FIXED CODE ###

N,M = list(map(int,input().split()))
MAX = 1000000000
import queue
dist = [MAX for i in range(N)]
pre = [-1 for i in range(N)]
To = [[] for i in range(N)]#indexに向かっている部屋番号の集合

que = queue.Queue()

for _ in range(M):
    a,b = list(map(int,input().split()))
    a -= 1
    b -= 1
    To[a].append(b)
    To[b].append(a)
dist[0] = 0
que.put(0)
while(not que.empty()):
    v = que.get()
    for u in To[v]:
        if pre[u] != -1: continue
        dist[u] = dist[v] + 1
        que.put(u)
        pre[u] = v
        
        
print('Yes')
for i in pre[1:N]:
    print(i+1)
import itertools


def ij(m):
    return m[0] < m[1]


def mod(m):
    return (m[0] * m[1]) % 2019


def main():
    (l, r) = list(map(int, input().split()))

    print(min(map(mod, filter(ij, itertools.product(range(l, r + 1), range(l, r + 1))))))


if __name__ == "__main__":
    main()


### FIXED CODE ###

def main():
    (l, r) = list(map(int, input().split()))

    ans = 2020
    for i in range(l, min(r + 1, l + 2019)):
        for j in range(i + 1, min(r + 1, i + 2020)):
            mod = i * j % 2019
            if mod <= ans:
                ans = mod

    print(ans)

if __name__ == "__main__":
    main()
def dfs(f, stack, cnt):
    while stack:
        x, y = stack.pop()
        f[y][x] = '.'
        cnt += 1

        dxy = [(0,1), (0,-1), (1,0), (-1,0)]
        for dx, dy in dxy:
            nx, ny = x + dx, y + dy
            if 0 <= nx < w and 0 <= ny < h:
                if f[ny][nx] == '#':
                    stack.append([nx, ny])
                    cnt = dfs(f, stack, cnt)
    return cnt


h, w = map(int, input().split())
f = [list(input()) for i in range(h)]

flg = False
dxy = [(0,1), (0,-1), (1,0), (-1,0)]
stack = []
for y in range(h):
    for x in range(w):
        if f[y][x] == '#':
            stack.append([x, y])
            cnt = 0
            cnt = dfs(f, stack, cnt)
            if cnt < 2:
                flg = True
                break
    if flg:
        break

print('No') if flg else print('Yes')

### FIXED CODE ###

h, w = map(int, input().split())
f = [["."] * (w + 2)] + \
    [list("." + input() + ".") for i in range(h)] + \
    [["."] * (w + 2)]

flg = False
for y in range(h):
    for x in range(w):
        if f[y][x] == '#':
            cnt = 0
            if f[y+1][x] == f[y-1][x] == f[y][x+1] == f[y][x-1] == '.':
                flg = True

print('No') if flg else print('Yes')
import sys
import bisect
from functools import lru_cache
from collections import defaultdict
inf = float('inf')
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**6)
def input(): return sys.stdin.readline().rstrip()
def read():
  return int(readline())
def reads():
  return map(int, readline().split())
K=reads()
mod=7//K
index=1
dic=defaultdict(int)
while(True):
    if mod==0:
        print(index)
        exit
    if dic[mod]==1:
        print(-1)
        exit
    dic[mod]=1
    mod=mod*10+7
    i+=1
    

### FIXED CODE ###

import sys
import bisect
from functools import lru_cache
from collections import defaultdict
inf = float('inf')
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**6)
def input(): return sys.stdin.readline().rstrip()
def read():
  return int(readline())
def reads():
  return map(int, readline().split())
K=read()
mod=7%K
index=1
dic=defaultdict(int)
while(True):
    if mod==0:
        print(index)
        exit()
    if dic[mod]==1:
        print(-1)
        exit()
    dic[mod]=1
    mod=mod*10+7
    mod%=K
    index+=1
A,B,H,M = map(int,input().split())

x = 6*M - (30*H + 0.5*M)
print(x)
X = 2*math.pi*x/360
print(X)
print(math.sqrt(A**2 + B**2 - A*B*math.cos(X)))

### FIXED CODE ###

import math

A,B,H,M = map(int,input().split())

C = 2*math.pi/12
D = 2*math.pi/60
E = 2*math.pi/(12*60)
x = abs(D*M - (C*H + E*M))


print(math.sqrt(A**2 + B**2 - 2*A*B*math.cos(x)))
import sys
import math
import itertools

def main():
  n,k = map(int, input().split())
  a = list(map(int,sys.stdin.readline().split()))

  now = 0
  times = 0
  visit =[[0],[0]]

  for _ in range(k):
    times += 1
    now = a[now] - 1

    if now in visit[0]:
      roop = times - visit[1][visit[0].index(now)] #何個の町でループしてるかをroopに代入
      roop_start = visit[1][visit[0].index(now)] #ループが始めった待ちの最初に訪れた時に何回ループしていたかをroop_startに代入
      break
    else:
      visit[0].append(now)
      visit[1].append(times)

  if roop > 0:
    k = (k - roop_start) % roop

  # print(roop_start)
  # print(roop)
  # print(k)
  # print(visit[0])
  print(visit[0][roop_start + k] + 1)

  # now = 0
  # for _ in range(roop_start):
  #   now = a[now] - 1

  # for _ in range(k):
  #   now = a[now] -1

  # print(now+1)


if __name__ == '__main__':
  main()

### FIXED CODE ###

import sys
import math
import itertools

def main():
  n,k = map(int, input().split())
  a = list(map(int,sys.stdin.readline().split()))

  now = 0
  times = 0
  visit =[[0],[-1 for _ in range(n)]]
  visit[1][0] = 0
  roop = 0
  roop_start = 0

  for _ in range(k):
    times += 1
    now = a[now] - 1

    if visit[1][now] != -1:
      roop_start = visit[1][now] #ループが始めった待ちの最初に訪れた時に何回ループしていたかをroop_startに代入
      roop = times - roop_start #何個の町でループしてるかをroopに代入
      break
    else:
      visit[0].append(now)
      visit[1][now] = len(visit[0]) - 1

  if roop > 0:
    k = (k - roop_start) % roop

  # print(roop_start)
  # print(roop)
  # print(k)
  # print(visit[0])
  print(visit[0][roop_start + k] + 1)

  # now = 0
  # for _ in range(roop_start):
  #   now = a[now] - 1

  # for _ in range(k):
  #   now = a[now] -1

  # print(now+1)


if __name__ == '__main__':
  main()
# -*- coding:utf-8 -*-
import sys
sys.setrecursionlimit(1000000)

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
	return res
	
res=0	
counter=0 
DX = [-1, 0, 1, 0]
DY = [0, -1, 0, 1]
while True:
	counter+=1
	line = input()
	if ' ' in line:
		N = int(line.split(' ')[0])
		M = int(line.split(' ')[1])
		tile = [[0 for i in range(N)]for j in range(M)]
	else:
		tile[counter-2] = list(line)
	if N==0 and M==0:
		break
	if counter-1==M:
		res = solve()
		counter = 0
		print(res)

### 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
def getNumNeg(L):
    return sum([i<0 for i in L])

def findmax(L):
    numNeg = getNumNeg(L)
    print(numNeg)
    if numNeg % 2 == 0: # end-point: all positive
         while getNumNeg(L) != 0:
            i = L.index(min(L[:-1]))
            j = i + 1
            L[i] = L[i] * (-1)
            L[j] = L[j] * (-1)
        print(sum(L))
    else: # end-point: smallest abs(number) is negative
        absL = list(map(abs, L))
        stop = min(absL)*(-1)
        while (getNumNeg(L) != 1) or (min(L) != stop):
            i = L.index(min(L[:-1]))
            j = i + 1
            L[i] = L[i] * (-1)
            L[j] = L[j] * (-1)
        print(sum(L))

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

### FIXED CODE ###

def getNumNeg(L):
  return sum([i<0 for i in L])
  
def findmax2(L):
  numNeg = getNumNeg(L)
  absL = list(map(abs, L))
  if numNeg % 2 == 0:
    print(sum(absL))
  else:
    print(sum(absL)-2*min(absL))
        
n = int(input())
a = list(map(int, input().split()))
findmax2(a)
n = int(input())
t, a = map(int,input().split())
h = list(map(int,input().split()))

counter = 0
diff = abs(a - (t - h[0] * 0.006))

for x in h:
    average_temple = t - x * 0.006
    counter += 1
    if diff > abs(a - average_temple):
        poss = counter

print(poss)

### FIXED CODE ###

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

atlist = []
for i in h:
    atlist.append(abs(a - (t - i * 0.006)))

print(atlist.index(min(atlist)) + 1)
N,M=map(int,input().split())
A=list(map(int,input().split()))

if N>=sum(A):
    print(N-A)
else:
    print(-1)

### FIXED CODE ###

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

if N>=B:
    print(N-B)
else:
    print(-1)
import math
 
N, M = list(map(int, input().split()))
a = []

for i in range(M):
  a.append(int(input()))
  
answer = 0
# a = [3]
for i in range(len(a) + 1):
	if i == 0:
		dif = a[i] - 1
	elif i == len(a):
		dif = N - a[-1] - 1
	else:
		dif = a[i] - a[i - 1] - 2
	if dif >= 2:
		b = dif // 2
		tmp_sum = 0
		for j in range(b + 1):
			tmp_sum += math.factorial(j + dif - j * 2) / (math.factorial(j) * math.factorial(dif - j * 2))
			print(tmp_sum)
		if tmp_sum != 0 and answer == 0:
			answer += 1
		answer *= tmp_sum
    
print(answer)

### FIXED CODE ###

import math
 
N, M = list(map(int, input().split()))
stairs = [0] * (N + 1)

for i in range(M):
	stairs[int(input())] = -1

# all element of stairs
for i in range(N, -1, -1):
	# last is always 1
	if i == N:
		stairs[i] = 1
	# if stair[N - 1] is not broken 
	elif i == N - 1 and stairs[i] != -1:
		stairs[i] = stairs[i + 1]
	# if stairs[i] is not broken
	elif stairs[i] != -1:
		if stairs[i + 1] != -1:
			stairs[i] += stairs[i + 1]
		if stairs[i + 2] != -1:
			stairs[i] += stairs[i + 2]
print(int(stairs[0]) % 1000000007)
#!/usr/bin/env python

n = int( input() )
xy = []
for _ in range(n): xy.append( [ int(x) for x in input().strip().split() ] )
#
distmap = dict()
for i in range(n):
    xi,yi = xy[i]
    for j in range(i+1,n):
        xj, yj = xy[j]
        xd = xi - xj
        yd = yi - yj
        k = "{} {}".format(xd,yd)
        distmap[k]= distmap.get(k,0) + 1
#
d = max( distmap.values() )
print( n-d )

### FIXED CODE ###

#!/usr/bin/env python

n = int( input() )
xy = []
for _ in range(n): xy.append( [ int(x) for x in input().strip().split() ] )
#
if n==1:
    print( 1 )
    exit()
#
xy.sort( key=lambda x: (x[0],x[1]) )
distmap = dict()
for i in range(n):
    xi,yi = xy[i]
    for j in range(i+1,n):
        xj, yj = xy[j]
        xd = xj - xi
        yd = yj - yi
        k = "{} {}".format(xd,yd)
        distmap[k]= distmap.get(k,0) + 1
#
d = max( distmap.values() )
print( n-d )
print(int(input())/int(input()))

### FIXED CODE ###

a,b=map(int,input().split());print(a/b)
import math
A, B, C, D = list(map(int, input().split()))

def num(x, y):
    return (x * y) // math.gcd(x, y)

print(B-A+1-((B//C+B//D-B//(num(C, D)))-((A-1)//C+(A-1)//D-(A-1)//(num(C, D)))))


### FIXED CODE ###

from fractions import gcd
A, B, C, D = list(map(int, input().split()))

def num(x, y):
    return (x * y) // gcd(x, y)

print(B-A+1-((B//C+B//D-B//(num(C, D)))-((A-1)//C+(A-1)//D-(A-1)//(num(C, D)))))