Harryxun/stf_run huggingface dataset:
s=input()
n=len(s)
x=(n-1)//2
while i in range(x):
  if s[i]!=s[n-1-i] or s[i]!=s[x-1-i]:
    print('No')
    break 
else:
  print('Yes')

### FIXED CODE ###

s=input()
n=len(s)
x=(n-1)//2
v=0
for i in range(x):
  if s[i]==s[n-1-i]==s[x-1-i]:
    v=v+1
if v==x:
  print('Yes')
else:
  print('No')
import math
a,b,c,d=map(int,input().split())
x=b-(b//c+b//d-b//(c*d/math.gcd(c,d)))
y=(a-1)-((a-1)//c+(a-1)//d-(a-1)//(c*d/math.gcd(c,d)))

print(int(x-y))

### FIXED CODE ###

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

def lcm(a, b):
    return a * b // gcd (a, b)

a,b,c,d=map(int,input().split())
b_num=b//c + b//d - b//lcm(d,c)
a_num=(a-1)//c + (a-1)//d - (a-1)//lcm(d,c)

print(b-(a-1)-(b_num-a_num))
import sys
input - sys.stdin.readline
def main():
    K = int(input())
    
    if K%2==0:
        print(-1)
        return
    
    if K % 7:
        L = 9*K
    else:
        L = 9*K//7
    a = 1
    for i in range(1,K+10):
        a = (a * 10) % L
        if a == 1:
            print(i)
            return
    print(-1)
main()

### FIXED CODE ###

import sys
input=sys.stdin.readline


def main():
    k = int(input())

    if k % 2 == 0:
        print(-1)
        return

    rest = [7 % k]

    for i in range(k):
        rest.append(rest[-1] * 10 % k)

    tmp = 0
    for i in range(k):
        if (tmp + rest[i]) % k == 0:
            print(i + 1)
            return
        else:
            tmp = (tmp + rest[i]) % k
    else:
        print(-1)
main()
N=int(input())
S=[*str(input())]

n=1
while N>n:
	n*=2

d=[[0]*(2*n) for _ in range(26)]

def ci(c):
	return "abcdefghijklmnopqrstuvwxyz".find(c)

def update(d,k,a):
	k+=n-1
	d[k]=a
	while k>0:
		k=~-k//2
		d[k]=d[k*2+1]+d[k*2+2]

def query(d,a,b,k,l,r):
	if r<=a or b<=l:
		return 0
	if a<=l and r<=b:
		return d[k]
	else:
		return query(d,a,b,k*2+1,l,(l+r)//2)+query(d,a,b,k*2+2,(l+r)//2,r)

for i,c in enumerate(S):
	update(d[ci(c)],i,1)

for i in range(int(input())):
	t,x,y=input().split()
	if t=='1':
		update(d[ci(S[int(x)-1])],int(x)-1,0)
		update(d[ci(y)],int(x)-1,1)
	else:
		a=0
		for j in range(26):
			if query(d[j],int(x)-1,int(y),0,0,n)>0:
				a+=1
		print(a)


### FIXED CODE ###

import bisect

N=int(input())
S=list(str(input()))

def ci(x):
  return "abcdefghijklmnopqrstuvwxyz".find(x)

d=[[] for _ in range(26)]
for i,s in enumerate(S):
  d[ci(s)].append(i)

for i in range(int(input())):
  t,x,y=input().split()
  if t=="1":
    x=int(x)-1
    if S[x]!=y:
      l=bisect.bisect_left(d[ci(S[x])],x)
      d[ci(S[x])].pop(l)
      bisect.insort(d[ci(y)],x)
      S[x]=y
  else:
    x,y=int(x)-1,int(y)-1
    c=0
    for j in range(26):
      l=bisect.bisect_left(d[j],x)
      if l<len(d[j]) and d[j][l] <= y:
        c += 1
    print(c)
import fractions 
A, B, C = [int(k) for k in raw_input().split(' ')]
print(C * ((A * B)/ (fractions.gcd(A, B) ** 2 )))



### FIXED CODE ###

import fractions 
A, B, C = [int(k) for k in raw_input().split(' ')]
print(C * ((A * B)/ (fractions.gcd(A, B) ** 2 )))
from collections import defaultdict
def main():
    N = int(input())
    depth = [0 for _ in range(N)]
    def dfs(v,p,d):
        depth[v] = d
        for u in tree[v]:
            if u[0] == p:continue
            dfs(u[0],v,d+u[1])
    tree = defaultdict(list)
    for _ in range(N-1):
        a,b,c = map(int,input().split())
        a -= 1
        b -= 1
        tree[a] += [[b,c]]
        tree[b] += [[a,c]]
    Q,K = map(int,input().split())
    K -= 1
    dfs(K,-1,0)
    Ans = []
    for _ in range(Q):
        x,y = map(int,input().split())
        x -= 1
        y -= 1
        ans = depth[x]+depth[y]
        Ans.append(ans)
    for ans in Ans:
        print(ans)


if __name__ == "__main__":
    main()

### FIXED CODE ###

from collections import defaultdict,deque
def main():
    N = int(input())
    depth = [-1 for _ in range(N)]
    tree = defaultdict(list)
    for _ in range(N-1):
        a,b,c = map(int,input().split())
        a -= 1
        b -= 1
        tree[a] += [[b,c]]
        tree[b] += [[a,c]]
    Q,K = map(int,input().split())
    K -= 1
    stack = deque([K])
    depth[K] = 0
    while stack:
        v = stack.popleft()
        for e in tree[v]:
            u,c = e
            if u == K:
                continue
            if depth[u] == -1:
                stack.appendleft(u)
                depth[u] = depth[v] + c

    for _ in range(Q):
        x,y = map(int,input().split())
        x -= 1
        y -= 1
        ans = depth[x]+depth[y]
        print(ans)

if __name__ == "__main__":
    main()
# ABC132 D Blue and Red Balls

from scipy.misc import comb

N, K = map(int, input().split())
MOD = int(1e9)+7

for i in range(1, K+1):
    temp = comb(N-K+1, i) * comb(K-1, i-1)
    print(int(temp % MOD))

### FIXED CODE ###

# ABC132 D Blue and Red Balls

def comb(n, r):
    if n == 0 or r == 0:
        return 1
    if n < r:
        return 0
    a = b = 1
    r = min(n-r, r)
    for i in range(n-r+1,n+1):
        a*=i
    for i in range(1,r+1):
        b*=i
    
    return a//b

N, K = map(int, input().split())
MOD = int(1e9)+7

for i in range(1, K+1):
    temp = comb(N-K+1, i) * comb(K-1, i-1)
    print(int(temp % MOD))
n = int(input())

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

a = 0

for i in range(len(l)):
    for j in range(i+1,len(l)):
        a = a + int(len(for k in l if i > l[i]+l[j]))
        

print(a)

### FIXED CODE ###

import bisect
n = int(input())
 
l = list(map(int, input().split()))
l.sort()
a = 0
#print(l)
for i in range(n-2):
    for j in range(i+1,n-1):
        s = bisect.bisect_left(l,l[i]+l[j])-j-1
        a+=s


print(a)
import heapq
from collections import deque
n,k=map(int,input().split())
l=[list(map(int,input().split())) for i in range(n)]

for i in range(n):
  l[i].reverse()
  l[i][0]*=-1
heapq.heapify(l)

check=[0 for i in range(10**5+1)]
L=[]
L2=[]
L2=deque(L2)
ans=[]

for i in range(k):
  x=heapq.heappop(l)
  if check[x[1]]==0:
    L.append(-x[0])
    check[x[1]]=1
  else:
    L2.append(-x[0])
p=sum(check)
ans.append(sum(L)+sum(L2)+p**2)

y=n-k
while y!=0:
  x=heapq.heappop(l)
  if check[x[1]]==0:
    L.append(-x[0])
    check[x[1]]=1
    z=L2.pop()
    p+=1
    ans.append(ans[-1]-(p-1)**2-x[0]-z+p**2)
  y-=1

print(max(ans))

### FIXED CODE ###

import heapq
from collections import deque
n,k=map(int,input().split())
l=[list(map(int,input().split())) for i in range(n)]

for i in range(n):
  l[i].reverse()
  l[i][0]*=-1
heapq.heapify(l)

check=[0 for i in range(10**5+1)]
L=[]
L2=[]
L2=deque(L2)
ans=[]

for i in range(k):
  x=heapq.heappop(l)
  if check[x[1]]==0:
    L.append(-x[0])
    check[x[1]]=1
  else:
    L2.append(-x[0])
p=sum(check)
ans.append(sum(L)+sum(L2)+p**2)

y=n-k
while y!=0:
  x=heapq.heappop(l)
  if check[x[1]]==0:
    L.append(-x[0])
    check[x[1]]=1
    if len(L2)==0:
      break
    z=L2.pop()
    p+=1
    ans.append(ans[-1]-(p-1)**2-x[0]-z+p**2)
  y-=1

print(max(ans))
from scipy.special import comb

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

MOD = 10**9 + 7

for i in range(1, K+1):
    a = comb(N-K+1, i)%MOD
    b = comb(K-1, i-1)%MOD
    ans = (a*b)%MOD
    print(int(ans))



### FIXED CODE ###

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

MOD = 10**9 + 7

dp = [[0]*(N+1) for _ in range(N+1)]
dp[0][0] = 1
for i in range(N):
    for j in range(i+1):
        dp[i+1][j] += dp[i][j]
        dp[i+1][j+1] += dp[i][j]

for i in range(1, K+1):
    a = dp[N-K+1][i]
    b = dp[K-1][i-1]
    ans = (a * b) % MOD
    print(ans)
import math

a = list(map(int , input().split()))
A = a[0]
B = a[1]

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

print(lcm(A, B))

### FIXED CODE ###

import fractions

a = list(map(int , input().split()))
A = a[0]
B = a[1]

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)

print(int(lcm(A, B)))
import math
R = int(input())
print(2*math.pi()*R)

### FIXED CODE ###

import math
N = int(input())
print(2*math.pi*N)
# coding:utf-8
H,W = map(int,input().split())

A = [[0 for i in range(W)] for j in range(H)]
ans = [[0 for i in range(W)] for j in range(H)]
B = [0] * H

for i in range(H):
	B[i] = input()

for i in range(H):
	char = list(B[i])
	for j in range(W):
		A[i][j] = char[j]


for i in range(H):
	for j in range(W):
		if A[i][j] == '#':
			for h in range(-1,2):
				for k in range(-1,2):
					if h == 0 and k == 0:
						continue
					if (i == 0 and h == -1) or (i == H -1 and h == 1) or (j == 0 and k == -1) or (j == W-1 and k == 1):
						continue

					if (A[i+h][j+k]) != '#':
 						ans[i+h][j+k] += 1  
			ans[i][j] = '#'
		
print (ans)

### FIXED CODE ###

# coding:utf-8
a,b,c = map(int,input().split())#標準入力を行う

def out_of_three():
	if a == b:
		return c
	if a == c:
		return b
	if b == c:
		return a

print (out_of_three())
n=int(input());print(sum(sorted(list(map(int,input().split())))[::2]))
print("RE WA?"

### FIXED CODE ###

n=int(input())
A=sorted(list(map(int,input().split())))
print(sum(A[::2]))
A, B = input().split()
A = int(A)
B = float(B)
B = int(B*100)
print(a*b//100)

### FIXED CODE ###

A, B = input().split()
A = int(A)
B = float(B)
B = round(B*100)
print(A*B//100)
import fractions

n = int(input())
a = list(map(int, input().split()))
mod = 10 ** 9 + 7

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)

g = lcm(a[0], a[1])

for val in a[2:]:
    g = lcm(g, val)

ans = 0
for val in a:
    ans += g//val % mod

print(ans % mod)

### FIXED CODE ###

import fractions

n = int(input())
a = list(map(int, input().split()))
mod = 10 ** 9 + 7

aset = set(a)

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)

if n == 1:
    print(1)

elif 1 < n:
    g = lcm(a[0], a[1])

    if n != 2:
        for val in aset:
            g = lcm(g, val)

    ans = 0
    for val in a:
        ans += g//val

    print(ans % mod)
a,b,c=input().split()
print((a[0],b[0],c[0],sep='').upper())


### FIXED CODE ###

a,b,c=input().split()
print((a[0]+b[0]+c[0]).upper())
N, M = map(int,input().split()) 
P = [list(map(int,input().split())) for i in range(M)]
A = [ [0 for __ in range(N)] for _ in range(N)]
for path in P:
    A[path[1]-1][path[0]-1]=1
    A[path[0]-1][path[1]-1]=1
#print(A)
depth_list = [0 for _ in range(N)]
next_generation = set([0])
depth = 0
#old_generation = set()
direction = [0 for _ in range(N)]
used = [0 for _ in range(N)]
while len(next_generation)!=0:
    #print('next_gen',next_generation)
    current = next_generation
    for node in next_generation:
        used[node] = 1
    #[old_generation.add(node) for node in next_generation]
    next_generation = set()
    for index in current:
        depth_list[index]=depth
    for node in current:
        #print('node',node,':',A[node])
        
        #print('old',old_generation)
        for i,neighbor in enumerate(A[node]):
            #print("trm",neighbor)

            if neighbor == 1 and used[i]==0:
                #print("unseen",i)
                next_generation.add(i)
                direction[i]=node+1
    depth+=1
if used.count(1) != N:
    print('No')
else:
    print('Yes')
    for d in direction[1:]:
        print(d)
#print(depth_list)
        

### FIXED CODE ###

n=input()
if int(n[len(n)-1]) in [2,4,5,7,9]:
    print('hon') 
elif int(n[len(n)-1]) in [0,1,6,8]:
    print('pon')
else:
    print('bon')
N = map(int, input().replace(" ", ""))
print("YES" if N%4==0 else "NO")

### FIXED CODE ###

x =int(input().replace(" ", ""))
print("YES" if x%4 == 0 else "NO")
import sys
sys.setrecursionlimit(10 ** 7)

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

AB = [list(map(int, input().split())) for _ in range(M)]

graph = [[] for _ in range(N)]
for a,b in AB:
    graph[a−1].append(b-1)
    graph[b-1].append(a-1)

# 二部グラフかどうかの判定
color = [None] * N
color[0] = 0
q = [0]
while q:
    x = q.pop()
    for y in graph[x]:
        if color[y] is None:
            color[y] = 1 - color[x]
            q.append(y)

# 二部グラフかどうか
bg = all(color[a] != color[b] for a, b in AB)

if bg:
    # 完全二部グラフにする
    x = sum(color)
    y = N - x
    answer = x*y - M
else:
    # 完全グラフにする(奇数長のパスがある場合は必ず2ずつ減らしていけば長さが3になる)
    answer = N*(N-1)//2 - M

print(answer)


### FIXED CODE ###

import sys
sys.setrecursionlimit(10 ** 7)

N, M = map(int, input().split())
AB = [list(map(int, input().split())) for _ in range(M)]
graph = [[] for _ in range(N)]

for a, b in AB:
    graph[a-1].append(b-1)
    graph[b-1].append(a-1)

# 二部グラフかどうかの判定
color = [None] * N
color[0] = 0
q = [0]
while q:
    x = q.pop()
    for y in graph[x]:
        if color[y] is None:
            color[y] = 1 - color[x]
            q.append(y)

# 二部グラフかどうか
is_bg = all(color[a-1] != color[b-1] for a, b in AB)

if is_bg:
    # 完全二部グラフにする
    x = sum(color)
    y = N - x
    answer = x*y - M
else:
    # 完全グラフにする(奇数長のパスがある場合は必ず2ずつ減らしていけば長さが3になる)
    answer = N*(N-1)//2 - M

print(answer)
import math
def digit(b, n):
    if n < b:
        return n
    else:
        return digit(b, math.floor(n/b)) + n % b

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

if n == s:
    print(n+1)
    exit()

if n < s:
    print(-1)
    exit()

for i in range(2, int(math.sqrt(n))):
    if digit(i, n) == s:
        print(i)
        exit()
    else:
        continue

for p in range(1,int(math.sqrt(n))):
    b = (n-s)//p + 1
    if digit(b, n) == s:
        print(b)
        exit()
print(-1)    


### FIXED CODE ###

import math
def digit(b, n):
    if n < b:
        return n
    else:
        return digit(b, math.floor(n/b)) + n % b

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

if n == s:
    print(n+1)
    exit()

if n < s:
    print(-1)
    exit()

for i in range(2, int(math.sqrt(n)) + 2):
    if digit(i, n) == s:
        print(i)
        exit()

for p in range(1,int(math.sqrt(n)))[::-1]:
    q = s - p
    b = (n-s)//p +1
    if 1 <= p < b and 0 <= q < b and (n - s)%p == 0:
        if digit(b, n) == s:
            print(b)
            exit()
print(-1)
import sys
a=int(sys.argv[1])
b=int(sys.argv[2])
sum=a*500
if b>sum:
  print("Yes")
else:
  print("NO")

### FIXED CODE ###

a,b=map(int,input().split( ))
sum=a*500
if sum>=b:
  print("Yes")
else:
  print("No")
exit()
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

n = ii()
dp = [0]*(n+1)
for i in range(1,n+1):
    s = str(i)
    if s[0] == s[-1]:
        dp[int(s[0])] += 1
    elif s[-1] == "0":
        continue
    else:
        ima = int(s[0])*10 + int(s[-1])
        dp[ima] += 1
ans = 0
for i in range(1,100):
    s = str(i)
    if s[0] == s[-1]:
        ans += dp[int(s[0])]**2
        dp[int(s[0])] = 0
    elif s[-1] == "0":
        continue
    else:
        ima = int(s[0])*10 + int(s[-1])
        ima2 = int(s[-1])*10 + int(s[0])
        ans += dp[ima] * dp[ima2] *2
        dp[ima] = 0
        dp[ima2] = 0
print(ans)



### FIXED CODE ###

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

n = ii()
dp = [0]*max(101,(n+1))
for i in range(1,n+1):
    s = str(i)
    if s[0] == s[-1]:
        dp[int(s[0])] += 1
    elif s[-1] == "0":
        continue
    else:
        ima = int(s[0])*10 + int(s[-1])
        dp[ima] += 1
ans = 0
for i in range(1,min(100,n+1)):
    s = str(i)
    if s[0] == s[-1]:
        ans += dp[int(s[0])]**2
        dp[int(s[0])] = 0
    elif s[-1] == "0":
        continue
    else:
        ima = int(s[0])*10 + int(s[-1])
        ima2 = int(s[-1])*10 + int(s[0])
        ans += dp[ima] * dp[ima2] *2
        dp[ima] = 0
        dp[ima2] = 0
print(ans)
a,b,c = int(input());
if((a-b)<c):
  print(c-(a-b))
else:
  print(0)

### FIXED CODE ###

a,b,c = map(int,input().split());
if((a-b)<c):
  print(c-(a-b))
else:
  print(0)
a, b = map(int, input().split())
dif = b - a
sum = int(dif / 2 * (1 + dif))
print(sum - b)

### FIXED CODE ###

N = int(input())
if N <= 999:
	print("ABC")
if N > 999:
	print("ABD")
import math

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

a = sorted(a, reverse=True)

for i in range(m):
    a[0] = math.floor(a[0] / 2)
    if a[0] < a[1]:
        a = sorted(a, reverse=True)

print(sum(a))


### FIXED CODE ###

import heapq

n, m = map(int, input().split())
a = list(map(lambda x: int(x) * (-1), input().split()))

heapq.heapify(a)

for _ in range(m):
    tmp_min = heapq.heappop(a)
    heapq.heappush(a, (-1) * (-tmp_min // 2))

print(-sum(a))
import sys
sys.setrecursionlimit(10**8)

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

primes = []
for i in range(2, 10**3+10):
    if all(i%p for p in primes):
        primes.append(i)
# print(primes)

def gcd(a, b):
    if a < b:
        a, b = b, a
    if b == 0:
        return a
    return gcd(b, a%b)

g = gcd(A, B)
count = 0
for p in primes:
    if g < p:
        break
    if g%p == 0:
        c += 1

print(count+1)


### FIXED CODE ###

import sys
sys.setrecursionlimit(10**8)

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

def gcd(a, b):
    if a < b:
        a, b = b, a
    if b == 0:
        return a
    return gcd(b, a%b)

g = gcd(A, B)
count = 0
for i in range(2, 10**6+3):
    if g%i == 0:
        count += 1
    while g%i == 0:
        g //= i
if g != 1:
    count += 1

print(count+1)
n = int(input())
s = [int(input()) for i in range(n)]
s.sort()
x = 0
y = 0

if sum(s)%10 != 0:
    print(sum(s))

else:
    while y == 0:
        if s[x]%10 != 0:
            s.pop(x)
            y = 1
            break
        else:
            x += 1
        if x == len(s)-1:
            print(0)
            exit()

    print(sum(s))

### FIXED CODE ###

n = int(input())
s = [int(input()) for i in range(n)]
s.sort()
x = 0
y = 0

if sum(s)%10 != 0:
    print(sum(s))

else:
    while y == 0:
        if s[x]%10 != 0:
            s.pop(x)
            y = 1
            break
        else:
            x += 1
        
        if x >= len(s)-1:
            print(0)
            exit()

    print(sum(s))
n, m = map(int, input().split())
a = sorted(list(map(int, input().split())))

if n == 1:
    for _ in range(m):
        a[0] //=2
    print(a[0])
    exit()

temp = []
temp.append(a.pop())

while m > 0:
    if temp[-1] < a[-1]:
        temp.append(a.pop())
    else:
        temp = sorted(temp)
        temp[-1] //= 2
        m -= 1

print(sum(temp)+sum(a))

### FIXED CODE ###

import heapq

n, m = map(int, input().split())
a = [-int(i) for i in input().split()]

heapq.heapify(a)

for _ in range(m):
    temp = heapq.heappop(a)
    temp = -(-temp//2)
    heapq.heappush(a, temp)

print(-sum(a))
x = int(input())
l = []
for i in range(-100,100):
    l.append(i**5)
ans =[]
for i in l:
    for j in l:
        if i - j == x:
            ans.append([i,j])
i,j = ans[0][0],ans[0][1]
print(l.index(i)-100,l.index(j)-100)

### FIXED CODE ###

x = int(input())
l = []
for i in range(-400,400):
    l.append(i**5)
ans =[]
for i in l:
    for j in l:
        if i - j == x:
            ans.append([i,j])
i,j = ans[0][0],ans[0][1]
print(l.index(i)-400,l.index(j)-400)
import sys
data = list(input())
for i, _str in enumerate(data):
  if _str == "?":
    if i == 0:
      if data[i + 1] == "D" or data[i + 1] == "?":
        data[i] = "P"
      else:
        data[i] = "D"
    elif i == len(data) - 1:
      data[i] = "D"
    else:
      if data[i - 1] == "D" or data[i + 1] == "D":
        data[i] = "P"
      else:
        data[i] = "D"
ans = "".join(data)
print(ans)

### FIXED CODE ###

import sys
data = list(input())
for i, _str in enumerate(data):
  if _str == "?":
    data[i] = "D"
ans = "".join(data)
print(ans)
s = input()
t = input()

sset = set(s)
tset = set(t)
slist = list()
tlist = list()

for i in range(len(s)):
   smoji = s[i]
   if s[i] in slist:
      continue
   else:
      si = string(i)
      s.replace(s[i], si)
for i in range(len(t)):
   tmoji = t[i]
    if t[i] in tlist:
      continue
    else:
       ti = string(i)
       t.replace(t[i], ti)

    
if len(sset) != len(tset):
   print("No")
else:
   if s != t:
      print("No")
   else:
      print("Yes")



### FIXED CODE ###

S = input()
T = input()

i = 0
j = 0
ss = list()
tt = list()
slist = list()
tlist = list()

if len(S) == len(T):
   for s in S:
      if s in slist:
         ss.append(slist.index(s))
      else:
         ss.append(i)
         slist.append(s)
         i += 1

   for t in T:
      if t in tlist:
         tt.append(tlist.index(t))
      else:
         tt.append(j)
         tlist.append(t)
         j += 1

   if ss == tt:
      print("Yes")
   else:
      print("No")
else:
   print("No")
# -*- coding utf-8 -*-

a,b,x=map(int,input().split())
ans=0

for i in range(a,b+1):
    if i%x==0:
        ans+=1
    else:
        ans+=0
print(ans)


### FIXED CODE ###

# -*- coding utf-8 -*-

x,y,z =list(map(str,input().split()))

print(x[0].upper() + y[0].upper() + z[0].upper())
N = input()
M = int(N)

def cal(a):
	return a%1000

 
if M=1000
  print(0)


print(1000-cal(M))




### FIXED CODE ###

N = input()
M = int(N)
 
def cal(a):
	return a%1000
 
 
if M % 1000==0:
  print(0)
 
 
else:
	print(1000-cal(M))
a,b = map(int, raw_input().split())
op = f.read()

while(1):
  if op == "+":
    c = a+b
    print "%d" %(c)
  elif op == "-":
    c = a-b
    print "%d" %(c)
  elif op == "*":
    c = a*b
    print "%d" %(c)
  elif op == "/":
    c = a/b
    print "%d" %(c)
  elif op == "?":
    break

### FIXED CODE ###

while(1):
  a,op,b = raw_input().split()
  a = int(a)
  b = int(b)
  if op == "+":
    print (a+b)
  elif op == "-":
    print (a-b)
  elif op == "*":
    print (a*b)
  elif op == "/":
    print (a/b)
  elif op == "?":
    break
#ABC073
x,t = map(int,input())
print( max(0,x-t) )

### FIXED CODE ###

#ABC073
x,t = map(int,input().split())
print( max(0,x-t) )
a,b,c,d,e,f = map(int,input().split())
kis = a * 60 + b
nel = c * 60 + d
print(nel - f - kis)

### FIXED CODE ###

a,b,c,d,e = map(int,input().split())
kis = a * 60 + b
nel = c * 60 + d
print(nel - e - kis)
import sys
input = sys.stdin.readline()
N = int(input())
A = [int(i) for i in input().split()]
count0 = [0 for i in range(60)]
count1 = [0 for i in range(60)]
for a in A:
    a_tmp = bin(a).replace("0b","")
    a_tmp = a_tmp.zfill(60)
    for i,b in enumerate(a_tmp):
        if b == "1":
            count1[i] += 1
        else:
            count0[i] += 1
cnt = 0
ans = 0
for c0,c1 in zip(count0[::-1],count1[::-1]):
    ans += c0*c1*(2**cnt)
    cnt += 1
print(ans%(10**9+7))


### FIXED CODE ###

import sys
input = sys.stdin.readline
N = int(input())
A = [int(i) for i in input().split()]
count0 = [0 for i in range(60)]
count1 = [0 for i in range(60)]
for a in A:
    a_tmp = bin(a).replace("0b","")
    a_tmp = a_tmp.zfill(60)
    for i,b in enumerate(a_tmp):
        if b == "1":
            count1[i] += 1
        else:
            count0[i] += 1
cnt = 0
ans = 0
for c0,c1 in zip(count0[::-1],count1[::-1]):
    ans += c0*c1*(2**cnt)
    cnt += 1
print(ans%(10**9+7))
N,M =map(int,input().split())
if M>0:
    a = [0]*M
    for i in range(M):
        a[i] = int(input())

ans = int(1)

A = [0]*(M+1)
A[0] = a[0]-1
A[M] = N - a[M-1]-1
for i in range(M-1):
    A[i+1] = a[i+1] - a[i]- 2
    if A[i+1]==-1:
        ans = 0


SA =[0]*N
SA[0] = int(1)
SA[1] = int(1)
for i in range(N-2):
    SA[i+2] = SA[i+1] + SA[i]
    SA[i+2] = SA[i+2]%1000000007

for i in range(M+1):
    if A[i]>=0:
        ans *= SA[A[i]]
        ans = ans%1000000007


print(ans)

### FIXED CODE ###

def examC():
    N, M = LI()
    A = [I() for _ in range(M)]
    A.append(N+1)
    fib = [1]*(N+2)
    for i in range(1,N):
        fib[i+2] = fib[i+1] + fib[i]
    fib[0] = 0
#    print(fib)
    ans = fib[A[0]]%mod
    for i in range(M):
        ans *= fib[A[i+1]-A[i]-1]
        ans %=mod
    print(ans)
    return

def examD():
    return

import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,inf
mod = 10**9 + 7
inf = float('inf')

if __name__ == '__main__':
    examC()
x = int(input())

for a in range(100):
    for b in range(100):
        if a**5 + b**5 == x:
            print(a, b)
            exit()

### FIXED CODE ###

s = input()

if s == 'ABC':
    print('ARC')
else:
    print('ABC')