peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Wrong Answer
a = input()
if a == 3 or 5 or 7:
    print("Yes")
else:
    print("No")
# Judge status: Accepted
S = input()
T = input()

for i in range(len(S)):
    x = S[-i:] + S[:-i]
    if x == T:
        print('Yes')
        break
else:
    print('No')
# Judge status: Accepted
s,c=map(int,input().split())
p=s*2
if p <= c:
  print(s + (c-p)//4)
else:
  print(c//2)
# Judge status: Wrong Answer
a, b = map(int,input().split())
s = input()
if len(s) == a+b+1 and s.count('-') == 1:
  print("Yes")
else:
  print("No")
#  exit(0)

#s1,s2 = s.split('-')
#if a == len(s1) and b == len(s2):
#  print("Yes")
#else:
#  print("No")
# Judge status: Wrong Answer
n,m,a,b = map(int,input().split())
x = list(map(int,input().split()))
y = list(map(int,input().split()))
x.sort()
y.sort()
if x[-1]<y[0]:
    for i in range(x[-1]+1,y[0]+1):
        if a<i<b:
            print("No War")
    else:
        print("War")
else:
    print("War")
# Judge status: Wrong Answer
n, x = map(int, input().split())
a = list(map(int, input().split()))

ans = 0
now = a[0]
for i in a[1:]:
    tmp = max(0, now + i - x)
    now = i - tmp
    ans += tmp
print(ans)
# Judge status: Accepted
N = input()
A = list(map(int, input().split()))

for i in A:
    i = int(i)
    if i % 2 == 0:
        if i % 3 !=0 and i % 5 !=0:
            print("DENIED")
            exit()
print("APPROVED")
# Judge status: Wrong Answer
S = input()
S = list(S)
str_list =  {"A","C","G","T"}
str_max = 0
print(S)
#print(len(S))
for start in range(len(S)):
    for end in range(start+1, len(S)+1):
        S_list = S[start:end]

        if str_list | set(S_list) == str_list:
            str_max = max(str_max, len((S_list)))
           # print(str(S_list)+'はオッケーでした，記録は'+str(len(set(S_list))))
        #else:
           # print(str(S_list)+'はダメでした')

print(str_max)
# Judge status: Accepted
n, m = map(int, input().split())
ac = [0] * (n+1)
pena = 0

for i in range(m):
    p, s = input().split()
    p = int(p)
    if s == "AC":
        if ac[p] != -1:
            pena += ac[p]
            ac[p] = -1

    else:
        if ac[p] != -1:
            ac[p] += 1


print(ac.count(-1), pena)
# Judge status: Accepted
n = int(input())
a = [0] * n
for i in range(n):
    a[i] = int(input())

counter = 0
now = 1
visit = [False] * n
visit[0] = True
while True:
    counter += 1
    if a[now - 1] == 2:
        print(counter)
        break
    elif visit[a[now - 1]-1] == True:
        print(-1)
        break
    else:
        visit[a[now - 1]-1] = True
    now = a[now - 1]
# Judge status: Accepted
N, M, K = map(int, input().split())
for a in range(N + 1):
    for b in range(M + 1):
        black = (a * M) + (b * N) - (a * b) * 2
        # print(a, b, black)
        if black == K:
            print("Yes")
            exit()
print("No")
# Judge status: Wrong Answer
n=int(input())
ans=10e5
for a in range(2,n):
    b=n-a
    ans=min(ans,sum([int(i) for i in str(a)])+sum([int(i) for i in str(b)]))
print(ans)
# Judge status: Accepted
n = int(input())
L = list(map(int,input().split()))
L2 = sorted(L)
L3 = sum(L) - L2[n-1]
if(L3 > L2[n-1]):
  print('Yes')
else:
  print('No')
# Judge status: Accepted
N, Q = map(int, input().split())
S = input()
qn = [list(map(int, input().split())) for _ in range(Q)]
S = "0" + S
cnt = []
cnt.append(0)
for i in range(1, N+1):
    if (S[i-1:i+1] == "AC"):
        cnt.append(cnt[i-1] + 1)
    else:
        cnt.append(cnt[i-1])
for q in qn:
    ans = cnt[q[1]] - cnt[q[0]-1]
    if S[q[0]-1:q[0]+1] == "AC":
        ans -= 1
    print(ans)
# Judge status: Accepted
N = int(input())
 
ans = ":("
 
for X in range(N+1):
  if int(X * 1.08) == N:
    ans = X
    break
    
print(ans)
# Judge status: Accepted
n,m = map(int,input().split())

max_val = 10**5+1
# dictの初期化
ac_L = []
wa_L = []
for val in range(1,max_val):
    wa_L.append(0)
    ac_L.append(0)

ac_ans,wa_ans = 0,0


for i in range(m):
    p,s = map(str,input().split())
    p = int(p)
    # acの処理
    if ac_L[p] ==0 and s == "AC":
        ac_L[p] = 1
        wa_ans += wa_L[p]
    # waの処理
    wa_L[p] += 1


#print(ac_dic,wa_dic)
print(sum(ac_L),wa_ans)
# Judge status: Wrong Answer
N, M = map(int, input().split())
A_LIST = sorted(map(int, input().split()))
C_LIST = []
for i in range(M):
    b, c = map(int, input().split())
    for _ in range(b):
        C_LIST.append(c)
C_LIST.sort(reverse=True)
ans = 0
for i in range(N):
    ans += max(A_LIST[i], C_LIST[i]) if len(C_LIST) >= N else A_LIST[i]
print(ans)
# Judge status: Wrong Answer
n = int(input())

if 400 < n <600:
    print(8)
elif n <800:
    print(7)
elif n <1000:
    print(6)
elif n <1200:
    print(5)
elif n <1400:
    print(4)
elif n <1600:
    print(3)
elif n <1800:
    print(2)
elif n <2000:
    print(1)
# Judge status: Accepted
def resolve():
    N = int(input())
    S = input()
    abc = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    ans = ""
    for i in range(len(S)):
        ans += abc[(abc.index(S[i])+N)%26]
    print(ans)
resolve()
# Judge status: Wrong Answer
S = input()

Str_list = [S[0:len(S)-1] , S[-1]]

if Str_list[1] == "s":
  Str_list[1] = "es"
  
else:
  Str_list.append("s") 

x = len(Str_list)
if x == 2:
  print(Str_list[0]+Str_list[1])
elif x == 3:
  print(Str_list[0]+Str_list[1]+Str_list[2])
# Judge status: Accepted
N=int(input())
P=0
for i in range(1,N+1):
  P+=i*(N//i)*(N//i+1)//2
print(P)
# Judge status: Wrong Answer

def myAnswer(X:int) -> int:
   if(X <= 1): return X
   ans = [0]
   total = 0
   for i in range(1,X):
      total += i
      if(total == X): 
         # print(total,X)
         return i
      if(total >= X):break
      ans.append(total)
      
   # print(ans,total,i)
   return X - ans[-2]
def modelAnswer():
   return
def main():
   X = int(input())
   print(myAnswer(X))
if __name__ == '__main__':
   main()
# Judge status: Accepted
# 解説を参考に作成

def solve():
    X = int(input())
    A, B = 0, 0
    for a in range(-200, 200):
        for b in range(-200, 200):
            if a ** 5 - b ** 5 == X:
                A, B = a, b
                break
    print(A, B)



if __name__ == '__main__':
    solve()
# Judge status: Wrong Answer
N = int(input())
def runLength(s):
  if len(s) == 0: return []
  if len(s) == 1: return [(s, 1)]
  res = []
  lc = 1
  for i in range(1, len(s)):
    if s[i-1] == s[i]:
      lc += 1
    else:
      res.append((s[i-1], lc))
      lc = 1
  res.append((s[i], lc))
  return res

ans = 0
S = runLength(input())

for i in range(1, len(S)):
  if S[i-1][0] == "#" and S[i][0] == ".":
    ans += min(S[i-1][1], S[i][1])
print(ans)
# Judge status: Accepted
n = int(input())
aList = list(map(int, input().split()))
count = 0
change = 0
for i in range(1, n):
    if aList[i - 1] == aList[i]:
        pass
    elif aList[i - 1] < aList[i]:
        if change == -1:
            count += 1
            change = 0
        else:
            change = 1
    else:
        if change == 1:
            count += 1
            change  = 0
        else:
            change = -1
    i += 1
print(count + 1)
# Judge status: Accepted
from collections import Counter
N=int(input())
A=list(map(int,input().split()))
B=[]
C=[]
for i,a in enumerate(A):
  B.append(i+a)
  C.append(i-a)
  
b = Counter(B)
c = Counter(C)
ans=0
for d in b.items():
  ans+=d[1]*c[d[0]]
print(ans)
# Judge status: Accepted
n, m, k = map(int, input().split())

for i in range(n + 1):
    a = i * m
    for j in range(m + 1):
        if a - j * i + j * (n - i) == k:
            print('Yes')
            exit()
print('No')
# Judge status: Accepted
from collections import Counter
N=int(input())
A=Counter(list(map(int,input().split())))
x=[0,0]
for a in A:
    if A[a]>1:x.append(a)
    if A[a]>3:x.append(a)
x.sort()
print(x[-1]*x[-2])
# Judge status: Wrong Answer
S = input()

len_ACGT = 0
canCount = False
max_len = 0
for s in S:
  if (s in "ACGT"):
    if(canCount == False):
      canCount = True
    len_ACGT += 1
  else:
    if(canCount == True):
      if(len_ACGT > max_len):
        max_len = len_ACGT
      canCount = False
      len_ACGT = 0
print(max_len)
# Judge status: Accepted
# -*- coding: utf-8 -*-

def get_digits_sum(val_str):
    digits_sum = 0
    for i in range(len(val_str)):
        digits_sum += int(val_str[i])

    return digits_sum

N = int(input())

if N==2:
    sum_min = 2

for i in range(2, N, 1):
    A = i
    B = N - i
    a_sum = get_digits_sum(str(A))
    b_sum = get_digits_sum(str(B))
    if i==2:
        sum_min = a_sum + b_sum
    elif sum_min > a_sum + b_sum:
        sum_min = a_sum + b_sum
        
print(sum_min)
# Judge status: Accepted
s = input()
red = s.count("0")
blue = s.count("1")

ans = min(red,blue)

print(ans*2)
# Judge status: Accepted
n = int(input())
A = list(map(int, input().split()))

abs_sum = 0
minus = 0
abs_list = []
for i in range(n):
    if A[i] < 0:
        minus += 1
    abs_list.append(abs(A[i]))
    abs_sum += abs_list[i]

if minus % 2 != 0:
    abs_sum -= min(abs_list)*2
print(abs_sum)
# Judge status: Accepted
x = input()

counter = 0
stack = []

for i in range(len(x)):
    if x[i] == "S":
        stack.append("S")
    elif stack:
        stack.pop()
        counter += 1

print(len(x) - 2 * counter)
# Judge status: Accepted
def solve():
    from sys import stdin
    f_i = stdin
    
    Sd = f_i.readline().rstrip()
    T = f_i.readline().rstrip()
    
    for i in range(len(Sd) - len(T), -1, -1):
        for x, t in zip(Sd[i:], T):
            if x != '?' and x != t:
                break
        else:
            ans = Sd[:i] + T + Sd[i+len(T):]
            return ans.replace('?', 'a')
    
    return 'UNRESTORABLE'

print(solve())
# Judge status: Accepted
N = int(input())
A = list(map(int, input().split()))

count = 0
while all(a%2 == 0 for a in A):
    A = [a/2 for a in A]
    count += 1

print(count)
# Judge status: Accepted
#!/usr/bin/env python3
(*p, ) = map(int, input().split())
n = int(input())

m = min(p[0] * 8, p[1] * 4, p[2] * 2, p[3])
m2 = min(p[0] * 4, p[1] * 2, p[2])

if m == p[3]:
    print(n // 2 * m + n % 2 * m2)
else:
    print(n * m // 2)
# Judge status: Accepted
D = int(input())
C = list(map(int, input().split()))
S = [list(map(int, input().split())) for _ in range(D)]

for A in S:
    print(A.index(max(A)) + 1)
# Judge status: Wrong Answer
X, Y = map(int, input().split())

MD = pow(10, 9) + 7

def choose(n, a):
    x, y = 1, 1
    for i in range(a):
        x = x * (n - i) % MD
        y = y * (i + 1) % MD
    return x * pow(y, MD - 2, MD) % MD

if (X+Y) % 3 != 0:
    print(0)
    import sys
    sys.exit()

a = (2*Y-X)//3
b = (Y-2*X)//-3

print(choose(a+b, min(a,b)))
# Judge status: Accepted
N=int(input())
A=list(map(int,input().split()))
anlist=[0]*N
for i in A:
  anlist[i-1]+=1
for i in anlist:
  print(i)
# Judge status: Wrong Answer
S = input()

word = ['qwertyuiopasdfghjklzxcvbnm']

for i in range(len(word)):
    if S.count(word[i]) > 1:
        print('no')
        exit()
        
print('yes')
# Judge status: Accepted
x = int(input())
print(10-x//200)
# Judge status: Accepted
XY = input().split()
X,Y = int(XY[0]), int(XY[1])
if(X % Y != 0):
    print(X)
else:
    print(-1)
# Judge status: Accepted
N=int(input())
L=list(map(int,input().split()))
for i in range(N):
  L[i]-=i
L=sorted(L)
if N%2==1:
  c=L[N//2]
  L1=[abs(i-c) for i in L]
  print(sum(L1))
else:
  c=L[N//2]
  d=L[(N//2)+1]
  L1=[abs(i-c) for i in L]
  L2=[abs(i-d) for i in L]
  print(min(sum(L1),sum(L2)))
# Judge status: Accepted
from fractions import gcd
n,m=map(int,input().split())
a=[int(i)//2 for i in input().split()]
def lcm(x,y):
  return x*y//gcd(x,y)
l=1
for i in a:
  l=lcm(l,i)
for i in a:
  if l//i%2==0:
    print(0)
    exit()
print((m//l+1)//2)
# Judge status: Accepted
K, X = map(int, input().split())

ans = []

for i in range(X-(K-1), X+K):
  ans.append(i)

print(*ans)
# Judge status: Accepted
X = int(input())
if X >=400 and X <= 599:
  print("8")
elif X >=600 and X <= 799:
  print("7")
elif X >=800 and X <= 999:
  print("6")
elif X >=1000 and X <= 1199:
  print("5")
elif X >=1200 and X <= 1399:
  print("4")
elif X >=1400 and X <= 1599:
  print("3")
elif X >=1600 and X <= 1799:
  print("2")
else:
  print("1")
# Judge status: Accepted
s = str(input())
t = str(input())
N = len(s)
S = [0] * N
T = [0] * N

for i in range(N):
  S[i] = s[i]
  T[i] = t[i]
  
for i in range(N):
  for j in range(N):
    if j == 0:
      x = S[j]
      S[j] = S[j + 1]
    elif 1 <= j < N - 1:
      S[j] = S[j + 1]
    else:
      S[j] = x
  #print(S)    
  if S == T:
    print("Yes")
    quit()
    
print("No")
# Judge status: Accepted
import collections
s = set(list(input()))
ans = 'Yes'
if 'N' in s and not 'S' in s or 'S' in s and not 'N' in s:
    ans = 'No'
elif 'W' in s and not 'E' in s or 'E' in s and not 'W' in s:
    ans = 'No'
print(ans)
# Judge status: Wrong Answer
N = int(input())
A = list(map(int, input().split()))

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

max_gcd = 0
for i in range(0,N-1):
    for j in range(i+1,N):
        tmp = gcd(A[i],A[j])
        if tmp > max_gcd:
            max_gcd=tmp
print(max_gcd)
# Judge status: Accepted
x, a, b = map(int,input().split())


print("A" if abs(x - a) < abs(x - b) else "B")
# Judge status: Accepted
d = {"Sunny": "Cloudy", "Cloudy": "Rainy", "Rainy": "Sunny"}
s = input()
print(d[s])
# Judge status: Accepted
from collections import deque

s = deque(input())
q = int(input())

reverse_flag = 1

for _ in range(q):
    query = input().split()
    if query[0] == "1":
        reverse_flag *= -1
    else:
        if (query[1] == "1" and reverse_flag == 1) or (query[1] == "2" and reverse_flag == -1):
            s.appendleft(query[2])
        else:
            s.append(query[2])
if reverse_flag == 1:
    print("".join(s))
else:
    s.reverse()
    print("".join(s))
# Judge status: Wrong Answer
n = int(input())
if n < 3:
  print(0)
else:
  s = list(map(int, input().split()))
  c = 0
  for i in range(n):
    for j in range(i+1, n):
      for k in range(j+1, n):
        m = max(s[i], s[j], s[k])
        su = s[i] + s[j] + s[k]
        if m < su - m and s[i] != s[j] and s[j] != s[k] and s[k] != s[i]:
          c += 1
          print(i, j, k)
  print(c)
# Judge status: Accepted
A = int(input())
B = int(input())
C = 6 - A - B
print(C)
# Judge status: Accepted
a=input()
print("A" if 65<=ord(a)<=90 else "a")
# Judge status: Wrong Answer
[D, T, S] = [int(i) for i in input().split()]
if D <= T * S:
  print("yes")
else:
  print("no")
# Judge status: Accepted
input()
from collections import *
c=Counter(map(int,input().split()))
f=lambda x:sorted(-k for k,v in c.items() if v>x)
a=0;r=f(1);s=f(3)
if len(r)>1: a=r[0]*r[1]
if s: a=max(a,s[0]**2)
print(a)
# Judge status: Wrong Answer
# ABC098C
N = int(input())
S = input()

all_W_E = [0, 0]
for s in S:
    if s == "W":
        all_W_E[0] += 1
    else:
        all_W_E[1] += 1

now_W = 0
now_E = 0
ans_list = [0] * N

for i in range(N):
    ans_list[i] = (now_W + all_W_E[1] - now_E)
    if S[i] == "W":
        now_W += 1
    else:
        now_E += 1
    
print(min(ans_list))
# Judge status: Accepted
from sys import stdin

n,c,k = [int(x) for x in stdin.readline().rstrip().split()]
li = [int(stdin.readline().rstrip()) for _ in range(n)]
li.sort()
time = li[0]
people = 0
bus_num = 1

for i in li:
    people += 1
    if i-time > k or people > c:
        bus_num += 1
        time = i
        people = 1
print(bus_num)
# Judge status: Wrong Answer
a, b, c = map(int, input().split())

count = a // b

if count < c:
  print(count)
else:
  print(c)
# Judge status: Wrong Answer
def main():
    a, b, c, d = map(int, input().split())
    if abs(a-c) <= d:
        print("Yes")
    elif (abs(a-b) <= d and abs(b-c)) <= d:
        print("Yes")
    else:
        print("No")
if __name__ == "__main__":
    main()
# Judge status: Wrong Answer
A,B = map(int, input().split())
if A <= 9 & B <= 9:
    ans = "-1"
else: ans = A*B 
print(ans)
# Judge status: Accepted
n = int(input())
a = list(map(int,input().split()))

a_2 = [0 for i in range(n)]
for i in range(n):
    a_2[a[i]-1] += 1

al = [0 for i in range(n)]
c = 0
for i in a_2:
    if i > 1:
        al[c] += i * (i-1) / 2
    c += 1

sine = sum(al)
for i in range(n):
    f = a[i]
    t = a_2[f-1] - 1
    print(int(sine-(al[f-1]-t*(t-1)/2)))
# Judge status: Accepted
from sys import exit
N = int(input())
posx = 0
posy = 0
now = 0
for _ in range(N):
    t, x, y = map(int, input().split())
    time_elapsed = t - now
    now = t
    if abs(posx - x) + abs(posy - y) <= time_elapsed and time_elapsed % 2 == (abs(posx - x) + abs(posy - y)) % 2:
        posx = x
        posy = y
    else:
        print("No")
        exit()
print("Yes")
# Judge status: Accepted
s = input()
l = []
for t in s:
  if t == '0' or t == '1':
    l.append(t)
  elif t == 'B':
    if l != []:
      l.pop()
for r in l:
  print(r, end='')
# Judge status: Accepted
N,K,Q = map(int, input().split())
li = [0 for i in range(N)]
for i in range(Q):
    a = int(input())
    li[a-1] += 1
for i in range(N):
    if K - (Q-li[i]) <= 0:
        print('No')
    else:
        print('Yes')
# Judge status: Wrong Answer
def func(a):
    if a % 2 == 0:
        return a // 2
    else:
        return 3 * a + 1

s = int(input())
res = []
idx = 0
for i in range(2, 10 ** 6 + 1):
    s = func(s)
    if s in res:
        idx = i
        break
    res.append(s)
print(idx)
# Judge status: Accepted
x,y = map(int,input().split())
print(int(x + y/2))
# Judge status: Accepted
import bisect
n=int(input())
a=list(map(int,input().split()))
b=sorted(a)
m=b[-1]
tmp=m/2

t=bisect.bisect_left(b,tmp)
ans=0
if(b[t]==tmp):
    ans=b[t]
elif(t==0):
    ans=b[0]
elif(t==len(b)-1):
    ans=b[-2]
else:
    c=abs(tmp-b[t-1])
    d=abs(tmp-b[t])
    if(c<=d):
        ans=b[t-1]
    else:
        ans=b[t]
print(m,ans)
# Judge status: Accepted
n, m, x, y = map(int, input().split())
x_list = list(map(int, input().split()))
y_list = list(map(int, input().split()))
if max(x_list + [x]) < min(y_list + [y]):
    print("No War")
else:
    print("War")
# Judge status: Wrong Answer
A=sum([list(map(int,input().split())) for _ in range(3)],[])
N=int(input())
b=[int(input()) for _ in range(N)]
f=0
for i in range(9):
	if A[i]in b:f|=1<<i
print('Yes'if sum(f&v==v for v in[7,23,56,84,146,273,292,448])else'No')
# Judge status: Accepted
w, h, x, y = map(int, input().split(' '))

area = w * h
half = area / 2

if x == w/2 and y == h/2:
    ans = 1
else:
    ans = 0

print(half, ans)
# Judge status: Wrong Answer
S = input()
len = len(S)
start = len
end = 0
for i in range(len):
  if(S[i] == "A"):
    temp_start = i+1
    start = min(start,temp_start)
  if(S[i] == "Z"):
    temp_end = i+1
    end = max(end,temp_end)
print(end-start)
# Judge status: Accepted
from math import gcd as gcd
a, b, c, d = map(int,input().split())
#cでわれるもの
s = gcd(c, d)
p = c * d // s
divide_c = b // c - (a - 1) // c
divide_d = b // d - (a - 1) // d
divide_cd = b // p - (a - 1) // p
print(int(b - a + 1 - divide_c - divide_d + divide_cd))
# Judge status: Accepted
import heapq
N, M = map(int, input().split())
A_list = list(map(lambda x: int(x)*(-1), input().split()))
heapq.heapify(A_list)
for i in range(M):
    max_num = heapq.heappop(A_list) * (-1)
    heapq.heappush(A_list, (-1) * (max_num // 2))
print((-1) * sum(A_list))
# Judge status: Accepted
N = int(input())

r = N % 1000
print(0 if r == 0 else 1000 - r)
# Judge status: Accepted
S = input()
acgt = {'A', 'C', 'G', 'T'}
length = len(S)
start = 0
ans = 0
while start < length:
  while start < length and S[start] not in acgt:
    start += 1
  right = start
  while right < length and S[right] in acgt:
    right += 1
  ans = max(ans, right - start)
  start = right
print(ans)
# Judge status: Accepted
from heapq import heappush, heappop
N, M = map(int, input().split())
ls = []
for i in range(N):
  a, b = map(int, input().split())
  ls += [(a,b)]
ls.sort(reverse=True)
hq = []
ans = 0
for i in range(1,M+1):
  while ls:
    if ls[-1][0]-i==0:
      heappush(hq,-ls[-1][1])
      ls.pop()
    else:
      break
  if hq==[]:
    continue
  ans -= heappop(hq)
print(ans)
# Judge status: Accepted
S=input()
L=[0,0,0]
for i in range(len(S)):
    if S[i]=="a":
        L[0]+=1
    elif S[i]=="b":
        L[1]+=1
    else:
        L[2]+=1
        
L.sort()
if L[2]-L[0]<=1:
    print("YES")
else:
    print("NO")
# Judge status: Wrong Answer
import sys

def main():
    N = int(input())
    
    cnt = 0
    for i in range(N):
        if i < 10:
            cnt += 1
        elif 100 <= i < 1000:
            cnt += 1
        elif 10000 <= i < 100000:
            cnt += 1
                    
            
    print(cnt)
main()
# Judge status: Accepted
n = int(input())
l = list(map(int, input().split()))

ans = 0
tmp = 0
for i in range(1, n):
    if l[i] <= l[i-1]:
        tmp += 1
        if i == n-1:
            ans = max(ans, tmp)
    else:
        ans = max(ans, tmp)
        tmp = 0

print(ans)
# Judge status: Wrong Answer
import math
h, w = map(int, input().split())
print(math.ceil(h*w/2))
# Judge status: Accepted
x=int(input())
ans=0
q,r=divmod(x,11)
ans+=2*q
q,r=divmod(r,6)
ans+=q
if r>0:ans+=1
print(ans)
# Judge status: Accepted
n, k = map(int, input().split())

i = 1
j = k

while n >= j:
    i += 1
    j *= k

print(i)
# Judge status: Accepted
# Python3 (3.4.3)
import sys
input = sys.stdin.readline

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


# -------------------------------------------------------------
# main
# -------------------------------------------------------------
N = int(input())
S = [list(input().rstrip()) for _ in range(N)]

from collections import defaultdict
d = defaultdict(int)

for s in S:
    s.sort()
    d["".join(s)] += 1

ans = 0
for i in d.values():
    ans += i*(i-1)//2

print(ans)
# Judge status: Accepted
import bisect

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

l.sort()
cnt = 0


for i in range(n-2):
  for j in range(i+1, n-1):
    sum = l[i] + l[j]
    index = bisect.bisect_left(l, sum)
    cnt += index - j - 1

print(cnt)
# Judge status: Accepted
n=int(input())
s=list(input())
ans=[0]
for i in s:
  if i=="I":
    ans.append(ans[-1]+1)
  else:
    ans.append(ans[-1]-1)
print(max(ans))
# Judge status: Accepted
h,a=map(int,input().split())
ans=0
while h > 0:
    h -= a
    ans += 1
print(ans)
# Judge status: Wrong Answer
a,b=input().split()
if a*int(b)>=b*int(a):
    print(b*int(a))
else:
    print(b*int(a))
# Judge status: Accepted
a,b=map(int, input().split())

if a == 1 and b == 1:
    print(1)
if a == 1 and b != 1:
    print(b-2)
if a != 1 and b == 1:
    print(a-2)
if a != 1 and b != 1:
    print(a*b-2*(a+b)+4)
# Judge status: Accepted
n = int(input())
ans = 0
if n%2==1:
    print(0)
else:
    n //= 10
    while n > 0 :
        ans += n
        n //= 5
    print(ans)
# Judge status: Accepted
K = int(input())
S = input()
if len(S) <= K:
    print(S)
else:
    print(S[0:K] + '...')
# Judge status: Wrong Answer
import math

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


lcm = a * b / math.gcd(a, b)

num = b-a
c_1 = (b-a)//c
d_1 = (b-a)//d
cd_1 = (b-a)//(lcm)

ans = num - (c_1 + d_1) + cd_1
print(ans)
# Judge status: Wrong Answer
S = input()
T = ''
words = ['dream', 'dreamer', 'erase', 'eraser']
for i in range(len(words)):
    words[i] = words[i][::-1]
for i in S[::-1]:
    T += i
    for q in words:
        if T == q:
            T = ''
if T == '':
    print('YES')
else:
    print('No')
# Judge status: Accepted
a = list(input())
b = list(input())
c = list(input())

num_li = [a,b,c]

now = 0
while True:
    if len(num_li[now])==0:
        print('A' if now==0 else 'B' if now==1 else 'C');exit()

    x = num_li[now].pop(0)
    now = 0 if x=='a' else 1 if x=='b' else 2
# Judge status: Wrong Answer
N, K = map(int, input().split())
D = set(input().split())

i = N
while True:
  flg = True
  for j in str(i):
    if int(j) in D:
      flg = False
      break

  if flg == True:
    print(i)
    exit()

  i += 1
# Judge status: Accepted
n,a,b = [int(x) for x in input().split()]

ans = 0
mod = 10**9+7
ans = (pow(2,n,mod)-1)%mod

com1 = 1
for i in range(n-a+1,n+1):
    com1 = com1*i%mod
for i in range(1,a+1):
    com1 = com1 * pow(i,mod-2,mod)%mod
com2 = 1
for i in range(n-b+1,n+1):
    com2 = com2*i%mod
x = 1
for i in range(1,b+1):
    x = x*i%mod
com2 = com2*pow(x,mod-2,mod)%mod

ans = (ans - com1 - com2)%mod
print(ans)