Harryxun/stf_run huggingface dataset:
import math
N,M=map(int,input().split())

a1=int(input())
a2=a1
data=[a1]
ans_data=[]
for i in range(M-1):
  a1=a2
  a2=int(input())
  #print("a",a2-a1-1)
  data.append(a2-a1-1)
  
data.append(N-a2-1)
  
data=sorted(data)
#print(data)
if  data[0]==0:
  print(0)
  
elif data[M]==1:
  print(1)
else:
  mm=data.count(1)
  ma=2
  #print("mm=",mm)
  f1=1
  f2=2
  for i in range(0,data[M]+len(data)-2-mm):  
      
    if ma==data[mm]:
      ans_data.append(f2)
      #print("data[mm]",data[mm],"f2",f2,"i",i)
      mm=mm+1
     
    else:
      ma=ma+1
      f11=f1
      f1=f2
      f2=f1+f11
      #print("data[mm]",data[mm],"f2",f2,"ma",ma)
        
        
  ans=1
  #print("ans_data",ans_data)
  for i in range(0,len(ans_data)):
    ans=ans*ans_data[i]
    
  mod=10**9+7
  print(ans%mod)
    
    
    
    

### FIXED CODE ###

N,M=map(int,input().split())
mod=10**9+7
dp=[0]*(N+1)
dp[0]=1
dp[-1]=0
A=[]
for i in range(M):
  A.append(int(input()))
A=set(A)
#print(A)
for i in range(1,N+1):
  if dp[i-1]==0 and dp[i-2]==0:
    break
  elif i in A:
    continue
  else:
    dp[i]=(dp[i-1]+dp[i-2])%mod
print(dp[N]%mod)
a,b,c,d,e,f = (int(i) for i in input().split())
w,s,num,answer = set(),set(),0,[a*100,0]
for i in range((f-f%(a*100))//(a*100)+1):
	for j in range((f-f%(b*100))//(b*100)+1):
		if i*a*100+j*b*100 <= f:
			w.add(i*a*100+j*b*100)
		else:
			break
smax = int(e*f/((100+e)*1.0))
for i in range((smax-smax%c)//c+1):
	for j in range((smax-smax%d)//d+1):
		if i*c+j*d <= smax:
			s.add(i*c+j*d)
		else:
			break
w2,s2 = sorted(list(w))[::-1],sorted(list(s))[::-1]
for i in w2:
	for j in s2:
		if 0 < i+j <= f and e*i>=100*j and num<(j/((i+j)*1.0)):
			num =  j/((i+j)*1.0)
			answer = [i,j]
print(sum(answer),answer[1])


### FIXED CODE ###

n = int(input())
a = int(input())
print(n**2-a)
S = input()

if S == "RRR":
    print(3)
elif S[0,1] == "R" or S[1,2] == "R":
    print(2)
elif S[0,1] == "S" or S[1,2] == "S":
    print(1)
else:
    print(0)


### FIXED CODE ###

S = input()

if S == "RRR":
    print(3)
elif S == "SSS":
    print(0)
elif S[0:2] == "RR" or S[1:3] == "RR":
    print(2)
else:
    print(1)
n,k=map(int,input().split())
h=list(map(int,input().split()))

dp=[0]
for i in range(1,n): # dp[i]の最小を決めていく。
    dpi=float('inf')
    for j in range(1,k+1):
        if i<j:
            break
        else:
            dpi=min(dp[i-j]+abs(h[i]-h[i-j]),dpi)
    dp.append(dpi)
print(dp[-1])

### FIXED CODE ###

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

# nの足場までいく最小コストを a_n とする。
# a_1のコストは0,  a_2のコストは(h_1からの１通りなので)\h_1-h_2\
dp=[0]*n
dp[1]=abs(h[0]-h[1])
for i in range(2,n):
    dp[i]=min(dp[i-2]+abs(h[i]-h[i-2]),dp[i-1]+abs(h[i]-h[i-1]))

print(dp[-1])
from collections import Counter
n = int(input())
num_list = list(map(int,input().split()))
a = Counter(num_list)
count = 0
for i in a.values():
  count += (i*(i-1))//2
for j in num_list:


### FIXED CODE ###

from collections import Counter
n = int(input())
num_list = list(map(int,input().split()))
a = Counter(num_list)
count = 0
for i in a.values():
  count += (i*(i-1))//2
for j in num_list:
  print(count-(a[j]-1))
import copy


def prepare(n, MOD):
 
    # 1! - n! の計算
    f = 1
    factorials = [1]  # 0!の分
    for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    # n!^-1 の計算
    inv = pow(f, MOD - 2, MOD)
    # n!^-1 - 1!^-1 の計算
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv
     
    return factorials, invs

def func(r, c):
    return f[r+1+c+1] * i[r+1] % MOD * i[c+1] % MOD

MOD = 10**9+7
f, i = prepare(10**6, MOD)


r1, c1, r2, c2 = map(int,input().split())

combi = func(r2, c2) - func(r2, c1-1) - func(r1-1, c2) + func(r1-1, c1-1)
print(combi % MOD)   

### FIXED CODE ###

import copy


def prepare(n, MOD):
 
    # 1! - n! の計算
    f = 1
    factorials = [1]  # 0!の分
    for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    # n!^-1 の計算
    inv = pow(f, MOD - 2, MOD)
    # n!^-1 - 1!^-1 の計算
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv
     
    return factorials, invs

def func(r, c):
    return f[r+1+c+1] * i[r+1] % MOD * i[c+1] % MOD

MOD = 10**9+7
f, i = prepare(2*10**6 + 2, MOD)


r1, c1, r2, c2 = map(int,input().split())

combi = func(r2, c2) - func(r2, c1-1) - func(r1-1, c2) + func(r1-1, c1-1)
print(combi % MOD)
n = int(input()) #waiting_for_pudging
a = list(map(int, input().split())) #waiting_for_pudging
b = list(map(int, input().split())) #waiting_for_pudging
c = list(map(int, input().split())) #waiting_for_pudging
summ = 0 #waiting_for_pudging
for i in range(n-1): #pudging
    if a[i] + 1 == a[i + 1]: #pudging
        summ += c[a[i]] #pudging
        summ += b[a[i]] #pudging
    else: #pudging
        summ += b[a[i-1]] #pudging
print(summ) #pudging
#accepted
    

### FIXED CODE ###

n = int(input()) #waiting_for_pudging
a = list(map(int, input().split())) #waiting_for_pudging
b = list(map(int, input().split())) #waiting_for_pudging
c = list(map(int, input().split())) #waiting_for_pudging
summ = 0 #waiting_for_pudging
for i in range(n-1): #pudging
    if a[i] + 1 == a[i + 1]: #pudging
        summ += c[a[i]-1] #pudging
        summ += b[a[i]-1] #pudging
    else: #pudging
        summ += b[a[i]-1] #pudging
print(summ + b[a[n-1]-1]) #pudging
#accepted
from fractions import Fraction

count = int(input())
number_list = map(int, input().split(' '))

sum = 0
for number in number_list:
	sum += Fraction(1, number)

up, down = map(int, str(sum).split('/'))
print(down / up)    

### FIXED CODE ###

if __name__ == "__main__":
    N = int(input())
    s = input().split()
    sum = 0

    for i in range(N):
        sum = sum + 1/(int(s[i]))
    print(1/sum)
a=int(input())
b=int(input())
c=int(input())
if a*b<c:
    print(c)
else:
    print(b/a)

### FIXED CODE ###

a,b,c = map(int,input().split())
if a*c<b:
    print(c)
else:
    print(b//a)
#intの場合
N = int(input()) #ここで標準入力
print (type(N),N) 
#<class 'int'> 20

#List にしたい時
#intの場合
huga = list(map(int, input().split()))
print(type(huga),huga)
# <class 'list'> [12, 34]
print(type(huga[0]),huga[0])
# <class 'int'> 12

ans = 1

for int i in huga:
    ans = ans * i

print(ans)

### FIXED CODE ###

#intの場合
N = int(input()) #ここで標準入力

#List にしたい時
#intの場合
huga = list(map(int, input().split()))
if 0 in huga:
    print(0)
else:
    ans = 1
    flg = 0
    for number in huga:
        ans = ans * number
        if ans > 10**18:
            flg = 1
            break
    if flg == 0:
        print(ans)
    else:
        print('-1')
import math
import decimal
#decimal.getcontext().prec = 22

#getcontext().prec=20
a,b,h,m=map(int,input().split())
a=decimal.Decimal(a)
b=decimal.Decimal(b)
h=decimal.Decimal(h)
m=decimal.Decimal(m)

#print(a,b,h,m)

ang1=decimal.Decimal(360*(h/12)+30*m/60)
ang2=decimal.Decimal(360*m/60)
ang=decimal.Decimal(abs(ang1-ang2))
#print(ang)
if ang>=180.0:
    ang=ang-180.0

#print(ang)
ans = ((a)**2 + (b)**2 - decimal.Decimal(2.0)*(a)*(b)*decimal.Decimal(math.cos(math.radians(ang))))
ans = (math.sqrt(ans))
#print(math.cos(math.radians(ang)))

print(ans)

### FIXED CODE ###

import math
#import decimal
#decimal.getcontext().prec = 12

#getcontext().prec=20
a,b,h,m=map(int,input().split())
#a=decimal.Decimal(a)
#b=decimal.Decimal(b)
#h=decimal.Decimal(h)
#m=decimal.Decimal(m)

#print(a,b,h,m)

#ang1=decimal.Decimal(360*(h/12)+30*m/60)
#ang2=decimal.Decimal(360*m/60)
#ang=decimal.Decimal(abs(ang1-ang2))
ang1=360*(h/12)+30*m/60
ang2=360*m/60
ang=abs(ang1-ang2)
#print(ang)
if ang>=180.0:
#    ang=ang-180.0
    ang=360.0-ang

#print(ang)
#ans = ((a)**2 + (b)**2 - decimal.Decimal(2.0)*(a)*(b)*decimal.Decimal(math.cos(math.radians(ang))))
ans = a**2 + b**2 - 2.0*a*b*math.cos(math.pi*ang/180.0)
ans = math.sqrt(ans)
#print(math.cos(math.radians(ang)))

print(ans)
a = map(float, raw_input().spli())

Pi = 3.141592658979

print a*a*Pi, 2*a*Pi

### FIXED CODE ###

import math

a = float(input())

print("%f %f" % (a*a*math.pi, 2*a*math.pi))
A,B,C = map(int,input().split())
K = int(input())
for i in range(K):
    if C<=B:
        C*=2
    elif B<A and C>B:
        B*=2
if B>A and C>B:
    print("Yes")
else:
    print("No")

### FIXED CODE ###

X = int(input())
if X >= 400 and X<600:
    print(8)
elif X >= 600 and X<800:
    print(7)
elif X >= 800 and X<1000:
    print(6)
elif X >= 1000 and X<1200:
    print(5)
elif X >= 1200 and X<1400:
    print(4)
elif X >= 1400 and X<1600:
    print(3)
elif X >= 1600 and X<1800:
    print(2)
elif X >= 1800 and X<2000:
    print(1)
n = input()
p = input().split()


n = int(n)

cnt=0

for i in range(1,n-1):
  if(p[i]<p[i+1] and p[i]>p[i-1]) or (p[i]>p[i+1] and p[i]<p[i-1]):
    cnt+=1;


   
  
print(cnt)

### FIXED CODE ###

s=[]
s = input()
cnt=0
 
if(s[0] == s[1]):
    cnt+=1

if(s[0] == s[2]):
    cnt+=1
 
 
if(s[0] == s[3]):
    cnt+=1
 
 
if(s[1] == s[2]):
    cnt+=1
 
 
if(s[1] == s[3]):
    cnt+=1
 
 
if(s[2] == s[3]):
    cnt+=1
 
 
if cnt == 2 :
  print("Yes")
else :
  print("No")
n, k = map(int, input().split())
p = list(map(int, input().split()))

def S(n):
    return n * (n + 1) // 2

for i in range(k):
    ans += S(p[i]) / p[i]

for i in range(k, n):
    ans = max(ans, ans + S(p[i]) / p[i] - S(p[i - k]) / p[i - k])
    
print(ans)

### FIXED CODE ###

n, k = map(int, input().split())
p = list(map(int, input().split()))

ans = 0
for i in range(k):
    ans += (p[i] + 1) / 2
t = ans
for i in range(k, n):
    t += (p[i] + 1) / 2 - (p[i - k] + 1) / 2
    ans = max(ans, t)

print(ans)
import itertools

N, M, X = map(int, input().split())
C = []; A = []; T = []
for _ in range(N):
    s = list(map(int, input().split()))
    T.append(s)


comb = []

for i in range(1,N):
    comb.append(list(itertools.combinations(T, i)))

comb = itertools.chain.from_iterable(comb)
count = []

for j in comb:
    t = [0, 0, 0, 0]
    for k in range(len(j)):
        t[0] += j[k][0]
        t[1] += j[k][1]
        t[2] += j[k][2]
        t[3] += j[k][3]
    count.append(t)

count.sort()


for i in count:
    if min(i[1:]) >= X:
        print(i[0])
        exit()

print(-1)



### FIXED CODE ###

N, M, X = map(int, input().split())
C = []; A = []; T = []
for _ in range(N):
    s = list(map(int, input().split()))
    C.append(s[0])
    A.append(s[1:])

INF = 10**9
ans = INF
# シフトで2^nまで全探索
for s in range(0, 1 << N):
    # 習得度をいれるリストを定義
    smart = [0] * M
    cost_sum = 0
    # sには10進数が入る
    for i in range(N):
        # 買っていない時
        if (s >> i) % 2 == 0: continue
        cost_sum += C[i]
        for j in range(M):
            smart[j] += A[i][j]
    ok = True
    if min(smart) < X:
        ok = False
    if ok:
        ans = min(ans, cost_sum)

if ans == INF:
    print(-1)
else:
    print(ans)
N = int(input())
n = 0

for i in range(1,N+1,1)
  n += i
  
print(n)

### FIXED CODE ###

N = int(input())
n = 0

for i in range(1,N+1,1):
  n += i
  
print(n)
N = int(input())

if N%2 == 0:
    print(int(N/2-1))
else:
    print(int((N+1)/2-1)

### FIXED CODE ###

N = int(input())

if N%2 == 0:
    print(int(N//2-1))
else:
    print(int((N+1)//2-1))
import math
import sys
sys.setrecursionlimit(10**9)

def binary_research(start,end,search_list,function):
    if start==end:
        return search_list[start]
    middle=math.ceil((start+end)/2)
    if function(search_list[middle],k,a_sum,b_sum):
        start=middle
    else:
        end=middle-1
    return binary_research(start, end, search_list, function)

# ==================================================-

n,m,k=[int(i) for i in input().split()]
a=[int(i) for i in input().split()]
b=[int(i) for i in input().split()]
a_sum=[0]
b_sum=[0]
for book in a:
    a_sum.append(a_sum[-1]+book)
for book in b:
    b_sum.append(b_sum[-1]+book)


def can_read(num,k,a_sum,b_sum):

    min_read_time=1000000000000000
    for i in range(max(0,num-m),n+1):
        a_num=i
        b_num=num-i
        min_read_time=min(min_read_time,a_sum[a_num]+b_sum[b_num])
    if min_read_time<=k:
        return True
    return False

search_list=list(range(n+m+1))
start=0
end=n+m

print(binary_research(start,end,search_list,can_read))


### FIXED CODE ###

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

def make_sumlist(book_list):
    sumnum=0
    container=[0]
    for i in book_list:
        container.append(sumnum+i)
        sumnum+=i
    return container

total_a=make_sumlist(a)
total_b=make_sumlist(b)

# print(n,m,k)
# print(total_a)
# print(total_b)


#r個読めるか
def readable(r):
    #全部読んでも無理
    if r>n+m:
        return False
    if r==0:
        return True
    max_book=100000000000
    for a_n in range(max(0,r-m),min(n,r)+1):
        b_n=r-a_n
        # print(a_n,b_n)
        book_sum=total_a[a_n]+total_b[b_n]
        # print(book_sum)
        max_book=min(max_book,book_sum)
    if max_book<=k:
        return True
    return False

def nibuntansaku(start,end):
    if start==end:
        return start
    middle=(start+end)//2+1
    if readable(middle):
        start=middle
    else:
        end=middle-1
    return nibuntansaku(start,end)

print(nibuntansaku(0,k))
N = int(input())
if N == 1:
    print("Hello World)
elif N == 2
    a,b = int(input().split())
    print(a+b)


### FIXED CODE ###

n = int(input())
if n == 1:
    print("Hello World")
elif n == 2:
    a = int(input())
    b = int(input())
    print(a + b)
N = int(input())
As = map(int, input().split())
max_diff = - float('inf')
for i in range(N):
    for j in range(i + 1, N):
        max_diff = max(max_diff, abs(As[i] - As[j]))
print(max_diff)


### FIXED CODE ###

N = int(input())
a = sorted(map(int, input().split()))
print(a[-1] - a[0])
a = input()
b = input()

for a<b :
  print a < b

for b<a :
  print b < a

else
  print a = b

### FIXED CODE ###

a, b = map(int, raw_input().split())
  
if a>b:
  print 'a > b'
elif a<b:
  print 'a < b'
elif a==b:
  print 'a == b'
X, Y = map(int, input().split())
ans = 'No'
    for a in range(X + 1):
        b = X - a
        if 2 * a + 4 * b == Y:
            ans = 'Yes'
print(ans)

### FIXED CODE ###

x,y = map(int,input().split())
kame=(y//2)-x
if y%2!=0:
    print("No")
elif (kame>=0)&(kame<=x):
    print("Yes")
else:
    print("No")
a,b,k = map(int,input().split())
d = []
for i in range(100) :
  if a % i == 0 and b % i == 0 :
    d.append(i)
d.sort(reverse = True)
print(d[k-1])

### FIXED CODE ###

a,b,k = map(int,input().split())
d = []
for i in range(1 ,101) :
  if a % i == 0 and b % i == 0 :
    d.append(i)
d.sort(reverse = True)
print(d[k-1])
import math
n=int(input())
a=int(input())
b=int(input())
c=int(input())
d=int(input())
e=int(input())
miti=[a,b,c,d,e]
mini=min(miti)
retu=math.ceil(n/miti)
  print(4+retu)


### FIXED CODE ###

import math
n=int(input())
a=int(input())
b=int(input())
c=int(input())
d=int(input())
e=int(input())
miti=[a,b,c,d,e]
mini=min(miti)
retu=math.ceil(n/mini)
print(4+retu)
N,M=map(int, input().split())

if X==M:
	print('Yes')
else:
	print('No')

### FIXED CODE ###

N,M=map(int, input().split())
 
if N==M:
	print('Yes')
else:
	print('No')
m, n = map(int, input().split())
edge = [[False for j in range(n)] for i in range(n)]
for _ in range(m):
	a, b = map(int, input().split())
	edge[a-1][b-1] = edge[b-1][a-1] = True
visited = [False for _ in range(n)]
ans = 0
def dfs(v):
	visited[v] = True
	if all(x==True for x in visited):
		global ans
		ans += 1
		return
	for i in range(0, n):
		if edge[v][i]==True and visited[i]==False:
			dfs(i)
			visited[i] = False
dfs(0)
print(ans)

### FIXED CODE ###

n, m = map(int, input().split())
edge = [[False for j in range(n)] for i in range(n)]
for _ in range(m):
	a, b = map(int, input().split())
	edge[a-1][b-1] = edge[b-1][a-1] = True
visited = [False for _ in range(n)]
ans = 0
def dfs(v):
	visited[v] = True
	if all(x==True for x in visited):
		global ans
		ans += 1
		return
	for i in range(0, n):
		if edge[v][i]==True and visited[i]==False:
			dfs(i)
			visited[i] = False
dfs(0)
print(ans)
N, K = map(int, input().split())
L = [int(l) for l in input().split()]
L.sort(reverse=True)

print(sum(L[0:K:]))

### FIXED CODE ###

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

if A % 3 == 0:
    print('Possible')
elif B % 3 == 0:
    print('Possible')
elif (A+B) % 3 == 0:
    print('Possible')
else:
    print('Impossible')
B = {}#辞書作成
N = int(input())
A = list(map(int, input().split()))


for i in range(N):
    B[i+1] = 0
#print(B)
for j in A:
    B[j] += 1
#print(B)
for k in B.values():
    print(k)



### FIXED CODE ###

import itertools
N, M, Q = map(int, input().split())

K= [list(map(int, input().split())) for i in range(Q)]#二次配列

ans = 0
for A in itertools.combinations_with_replacement([i for i in range(1, M + 1)], N):
    ans1 = 0
    for i in range(Q):
        a, b, c, d = K[i]#各数字に配列の値を代入する
        if (A[b - 1] - A[a - 1] == c):
            ans1 += d
        ans = max(ans, ans1)
print(ans)
N = long(raw_input())
def dig(A,B):
        if A > B:
                return A
        else:
                return B
A = 0
B = 0 
X = []
i = long(1)
while N > i:
        if N%i == 0:
                A = long(i)
                B = long(N/i)
                X.append(dig(A,B))
        if A in X:
                break
        i+=1
print len(str(min(X)))

### FIXED CODE ###

N = long(raw_input())
def dig(A,B):
        if A > B:
                return A
        else:
                return B
A = 0
B = 0 
X = []
i = long(1)
while N >= A*A:
        A = long(i)
        if N%i == 0:
                B = long(N/i)
                X.append(dig(A,B))
        if A in X:
                break
        i+=1
print len(str(min(X)))
n=int(input())
if n==25:
    print(Christmas)
if n==24:
    print(Christmas Eve)
if n==23:
    print(Christmas Eve Eve)
if n==22:
    print(Christmas Eve Eve Eve)

### FIXED CODE ###

n=int(input())
if n==25:
    print('Christmas')
if n==24:
    print('Christmas Eve')
if n==23:
    print('Christmas Eve Eve')
if n==22:
    print('Christmas Eve Eve Eve')
from collections import deque


def dfs(start, goal, tree):
    """startからgoalまでの木上のpathを出力する"""
    q = deque([start])
    visited = {}
    visited[start] = -1
    while True:
        pos = q.pop()
        if pos == goal:
            break
        for child in tree[pos]:
            if child in visited:
                continue
            visited[child] = pos
            q.append(child)
    res = []
    pos = goal
    while True:
        par = visited[pos]
        if par == -1:
            break
        res.append((min(par, pos), max(par, pos)))
        pos = par
    return res


n = int(input())
info = [list(map(int, input().split())) for i in range(n - 1)]
m = int(input())
path = [list(map(int, input().split())) for i in range(m)]

tree = [[] for i in range(n)]
memo = {}
for i in range(n - 1):
    a, b = info[i]
    a -= 1
    b -= 1
    tree[a].append(b)
    tree[b].append(a)
    memo[(min(a, b), max(a, b))] = i
  

li_path = [0] * m
for i in range(m):
    s, g = path[i]
    s -= 1
    g -= 1
    res = dfs(s, g)
    tmp = 0
    for j in res:
        tmp += (1 << memo[j])
    li_path[i] = tmp
  
ans = 0
for bit_state in range(1 << m):
    mask = 0
    cnt = 0
    for i in range(m):
        if bit_state & (1 << i):
            cnt += 1
            mask |= li_path[i]
    num_n = bin(mask).count("1")
    if cnt % 2 == 0:
        ans += 2 ** (n - 1 - num_n)
    else:
        ans -= 2 ** (n - 1 - num_n)
print(ans)


### FIXED CODE ###

n = int(input())
info = [list(map(int, input().split())) for i in range(n - 1)]
m = int(input())
path = [list(map(int, input().split())) for i in range(m)]

tree = [[] for i in range(n)]
memo = {}
for i in range(n - 1):
    a, b = info[i]
    a -= 1
    b -= 1
    tree[a].append(b)
    tree[b].append(a)
    memo[(min(a, b), max(a, b))] = i


def dfs(par, pos, goal):
    if pos == goal:
        return True
    for child in tree[pos]:
        if child == par:
            continue
        if dfs(pos, child, goal):
            res.append((min(pos, child), max(pos, child)))
            return True
    return False
  

li_path = [0] * m
for i in range(m):
    res = []
    s, g = path[i]
    s -= 1
    g -= 1
    dfs(-1, s, g)
    tmp = 0
    for j in res:
        tmp += (1 << memo[j])
    li_path[i] = tmp
  
ans = 0
for bit_state in range(1 << m):
    mask = 0
    cnt = 0
    for i in range(m):
        if bit_state & (1 << i):
            cnt += 1
            mask |= li_path[i]
    num_n = bin(mask).count("1")
    if cnt % 2 == 0:
        ans += 2 ** (n - 1 - num_n)
    else:
        ans -= 2 ** (n - 1 - num_n)
print(ans)
if (n1 == 0 or n2 == 0) or (n1 > 12 and n2 > 12):
    print('NA')
elif n1 <= 12:
    print('MMYY')
elif n2 <= 12:
    print('YYMM')
else:
    print('AMBIGUOUS')

### FIXED CODE ###

s = list( map( int, input() ) )

n1 = s[0]*10 + s[1]
n2 = s[2]*10 + s[3]

if n1 > 0 and n1 <=12:
    if n2 > 0 and n2 <= 12:
        ans = 'AMBIGUOUS'
    else:
        ans = 'MMYY'
else:
    if n2 > 0 and n2 <= 12:
        ans = 'YYMM'
    else:
        ans = 'NA'

print(ans)
from sys import stdin,stdout
def INPUT():return list(int(i) for i in stdin.readline().split())
def inp():return stdin.readline()
def out(x):return stdout.write(x)
import math
import random
J=int(1e9)+7

###############################################################################\n=17
n=int(input())
A=INPUT()
sum=0
for i in range(n):
    sum+=A[i]
sum=sum*sum

s=0
for i in range(n):
    s+=A[i]**2

ans=(sum-j)//2
ans%=J
print(ans)


### FIXED CODE ###

from sys import stdin,stdout
def INPUT():return list(int(i) for i in stdin.readline().split())
def inp():return stdin.readline()
def out(x):return stdout.write(x)
import math
import random
J=int(1e9)+7

###############################################################################\n=17
n=int(input())
A=INPUT()
sum=0
for i in range(n):
    sum+=A[i]
sum=sum*sum

s=0
for i in range(n):
    s+=A[i]**2

ans=(sum-s)//2
ans%=J
print(ans)
a,b,c=map(int,input().split())

if a=b and b=c :
    print('No')
elif a=b or a=c or b=c:
    print("Yes")
else:
    print('No') 

### FIXED CODE ###

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

if a==b and b==c :
    print('No')
elif a==b or a==c or b==c:
    print("Yes")
else:
    print('No')
S, T = map(str, input().split)
A, B = map(int, input().split)
U = input()

a = A - 1
b = B - 1

if U == S:
  print({} {}.format(a,B))
else:
  print({} {}.format(A.b))


### FIXED CODE ###

S, T = map(str, input().split())
A, B = map(int, input().split())
U = input()

a = A - 1
b = B - 1

if U == S:
  print('{} {}'.format(a,B))
else:
  print('{} {}'.format(A,b))