peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Wrong Answer
n,k = map(int, input().split())
d = list(input().split())
for i in range(n,10000):
    for j in d:
        if j in str(i):
            break
    else:
        print (i)
        exit ()
# Judge status: Accepted
a, b, t = map(int, input().split())
if t < a:
    print(0)
else:
    print(t // a * b)
# Judge status: Wrong Answer
import numpy as np
 
N,K=map(int, input().split())
A=list(map(int, input().split()))
 
x=np.prod(A[0:K])
y=np.prod(A[1:K+1])

for i in range(N-K):
    if i == 0:
        print('Yes' if x < y else 'No')
    else:
        x = x*A[K+i-1]/A[i-1]
        y = x*A[K+i]/A[i]
        print('Yes' if x < y else 'No')
# Judge status: Wrong Answer
import math
a,b=map(int,input().split())
print(math.gcd(a, b))
# Judge status: Accepted
p=1000000007
n,m=map(int,input().split())

# 0段目
dp=[1] * (n +1)

for i in range(m):
    a= int(input())
    dp[a] = 0

for i in range(n-2,-1,-1):
    if dp[i] == 0:
        continue

    dp[i] = (dp[i+1] + dp[i+2]) %p

print(dp[0])
# Judge status: Accepted
x, y = map(int, input().split())
G = 'XACABABAABABA'

print("Yes" if(G[x] == G[y]) else "No")
# Judge status: Wrong Answer
N=int(input())
A=list(map(int,input().split()))
S=set()
cnt=0
for i in A:
  if i>=3200:
    cnt+=1
  else:
    S.add(i//400)
low=len(S)
high=cnt+low
print(low,high)
# Judge status: Wrong Answer
a, b = list(map(int, input().split()))
if a == b:
  my_result = a + b
elif a > b:
  my_result = 2 * a + 1
else:
  my_result = 2 * b + 1
print(my_result)
# Judge status: Wrong Answer
def readInt():
    return int(input())
def readList():
    return list(map(int,input().split()))
def readMap():
	return map(int,input().split())
def readStr():
    return input()
inf=float('inf')
mod = 10**9+7
import math
from itertools import permutations
def solve(N):
    count=0
    for i in range(1,N):
        count+=(N-1)//i
    return count

# N=readInt()
# print(solve(N))

for i in range(1,101):
    print(solve(i))
# Judge status: Wrong Answer
N, R =(int(x) for x in input().split())
if N >= 10:
  print(R)
else:
  print(R - 100 * (10 - N))
# Judge status: Accepted
import itertools as it
n=int(input())
a=sorted(map(int,input().split()))
print(sum(sum(x)>2*x[2]and len(x)==len(set(x))for x in it.combinations(a, 3)))
# Judge status: Accepted
n, a, b = map(int, input().split())
if a % 2 == b % 2:
    print((b - a) // 2)
else:
    if a > n - b + 1:
        rest = (b - a) // 2
        print(n - a - rest)
    else:
        rest = (b - a) // 2
        print(b - 1 - rest)
    #print(max(a, n - b + 1) - 1)
# Judge status: Accepted
n,y=map(int,input().split())
#1000円がn-a-b枚、5000円がa枚、10000万円がb枚とする
for i in range(0,n+1):
    for j in range(0,n-i+1):
        if 1000*(n-i-j)+5000*i+10000*j==y:
            print(j,i,n-i-j)
            exit()
print(-1,-1,-1)
# Judge status: Accepted
n,x=map(int,input().split())
L=list(map(int,input().split()))
ans = 1
cnt = 0
for l in L:
  cnt += l
  if x >= cnt:
    ans += 1
print(ans)
# Judge status: Wrong Answer
a,b,c = map(int, input().split())
coins = [1,5,10,50,100,500]
if a==1 or a==5 or a==10 or a==50 or a==100 or a==500:
  if b==1 or b==5 or b==10 or b==50 or b==100 or b==500:
    if a+b >= c:
      print("Yes")
    else: print("No")
  else: print("No")
else: print("No")
# Judge status: Accepted
A,B,C=map(int, input().split())
m = max([A,B,C])
s = sum([m-A, m-B, m-C])
if s %2 == 0:
    print(s//2)
else:
    s += 1
    print(1+s//2)
# Judge status: Accepted
import math

X = int(input())

m = 100
z=0

while X > m:
    m = m * 1.01
    z = z + 1
    m = math.floor(m)


print(z)
# Judge status: Accepted
# 2101~2101
A,B=map(int,input().split())
print(A*B)
# Judge status: Wrong Answer
s = input()
t = input()

s2 = []
t2 = []

sdic = {}
tdic = {}

cnt = 0
for c in s:
    if c in sdic:
        s2.append(sdic[c])
    else:
        s2.append(cnt)
        sdic[c] = cnt
        cnt += 1

cnt = 0
for c in t:
    if c in tdic:
        t2.append(tdic[c])
    else:
        t2.append(cnt)
        tdic[c] = cnt
        cnt += 1
        
print(s2)
print(t2)

print("Yes" if s2 == t2 else "No")
# Judge status: Accepted
def resolve():
    S = input()
    d = {
        "Sunny": "Cloudy",
        "Cloudy": "Rainy",
        "Rainy": "Sunny"
    }
    print(d[S])
    
if '__main__' == __name__:
    resolve()
# Judge status: Accepted
n = int(input())
a = list(map(int, input().split()))

mode="?"
cnt=0
last=a[0]
for num in a:
    if mode=="a":
        if last > num:
            cnt+=1
            mode="?"
    elif mode=="d":
        if last < num:
            cnt+=1
            mode="?"
    else:
        if last > num:
            mode="d"
        if last < num:
            mode="a"
    last=num
print(cnt+1)
# Judge status: Wrong Answer
x = int(input())

if 400 <= x < 600:
    print(8)
elif 600 <= x < 799:
    print(7)
elif 800 <= x < 999:
    print(6)
elif 1000 <= x < 1199:
    print(5)
elif 1200 <= x < 1399:
    print(4)
elif 1400 <= x < 1599:
    print(3)
elif 1600 <= x < 1799:
    print(2)
else:
    print(1)
# Judge status: Accepted
n=int(input())
A=list(map(int,input().split()))

s=0
cap=[]
flag=False
for i,a in enumerate(A):
    s*=2
    s+=a
    cap.append(min(2**i-s,(n+1-i)*10**8))
    if s>2**i:
        flag=True
        break

if flag:
    print(-1)
else:
    remain=2**n-s
    ans=0
    node=0
    for i in range(n,-1,-1):
        a=A[i]
        c=cap[i]
        node=min(c,node)+a
        ans+=node
    print(ans)
# Judge status: Wrong Answer
a, b = (int(t) for t in input().split())
s = (a + b) % 2
x = (a + b) / 2
if s == 0:
	print(x)
else:
	print(x + 0.5)
# Judge status: Accepted
X,Y,A,B,C=map(int,input().split())
p=sorted(map(int,input().split()))
q=sorted(map(int,input().split()))
r=sorted(map(int,input().split()))
ans=[]
ans+=p[A-X:]
ans+=q[B-Y:]
ans.sort()
j=0
k=0
for i in ans:
	if len(r)>1:
		k=r[-1]
	elif len(r)==1:
		k=r[0]
	else:
		break
	if i<k:
		ans[j]=r.pop()
		j+=1
	else:
		break
print(sum(ans))
# Judge status: Wrong Answer
#AtCorder
def main():
	a,b=map(int, input().split())
	if a*10**b <=b*10**a:
		print(str(a)*b)
	else:
		print(str(b)*a)
main()
# Judge status: Wrong Answer
N,M=map(int,input().split())
D=[]
for i in range(1,int(M**0.5+1)):
  if M%i==0:
    D.append(i)
    D.append(M//i)
D.sort()
print(D)
for j in D:
  if j >=N:
    print(M//j)
    exit()
# Judge status: Accepted
A, B = map(int, input().split())
K = (B ** 2 - A ** 2) / (2 * A - 2 * B)
print(int(abs(K))) if K.is_integer() else print('IMPOSSIBLE')
# Judge status: Accepted
import numpy as np

def main():

    test = input()
    if test[0] != "A":
        print("WA")
        return

    if test[:-1][2:].count("C") != 1:
        print("WA")
        return

    for i in range(len(test)):
        if i == 0 and test[i] == "A": continue
        if 2 <= i <= len(test) - 2 and test[i] == "C": continue

        if test[i].lower() != test[i]:
            print("WA")
            return

    print("AC")







if __name__ == "__main__":
    main()
# Judge status: Accepted
str = input()
int = int(str[-3:])

if(int == 0):
    print(0)
else:
    print(1000-int)
# Judge status: Accepted
s = input()
ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ans = 'None'
for c in ascii_lowercase:
    if c not in s:
        ans = c
        break
print(ans)
# Judge status: Wrong Answer
i= list(map(int, input().split()))
j=1
while i[0]>i[1]**j:
  j+=1
print(j)
# Judge status: Accepted
a,b = map(int,input().split())
if (a + b) % 2 == 1: 
    print('IMPOSSIBLE')
    exit()
print((a+b) // 2)
# Judge status: Accepted
import math


def resolve():
    X = int(input())
    ans = 100
    year = 0
    while ans < X:
        ans = math.floor(ans * 1.01)
        year += 1

    print(year)


resolve()
# Judge status: Accepted
n, m = map(int,input().split())
l_lis = []
r_lis = []
for _ in range(m):
    tmp = list(map(int,input().split()))
    l_lis.append(tmp[0])
    r_lis.append(tmp[1])
ll = max(l_lis)
rr = min(r_lis)
count = rr - ll + 1
if count <= 0:
    print(0)
else:
    print(count)
# Judge status: Accepted
a,b=map(int,input().split())
if a+b>=24:
  print(a+b-24)
else:
  print(a+b)
# Judge status: Wrong Answer
import numpy as np
from bisect import bisect_right

n, m, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a = np.cumsum(a)
b = np.cumsum(b)

ans = 0
for a_num, time in enumerate(a):
    if time > k:
        continue
    b_num = bisect_right(b, k - time)
    num = a_num + b_num + 1
    if num > ans:
        ans = num
print(ans)
# Judge status: Accepted
import sys

K, A, B = map(int, sys.stdin.readline().split())

if K + 1 < A:
    print(K+1)
else:
    if A + 2 < B:
        # print("here")
        n = K - (A - 1)
        r = n // 2
        # print(n % 2)
        print(A + r * (B - A) + n % 2)
            
    else:
        print(K+1)
# Judge status: Accepted
N = int(input())
X = list(map(int, input().split()))
print(min(sum((x - P) ** 2 for x in X) for P in range(max(X) + 1)))
# Judge status: Accepted
n = int(input())
ans = 1

for i in range(1, n+1):
  ans *= i
  ans %= 10**9+7

print(ans)
# Judge status: Accepted
n = int(input())

count = 0
for i in range(1,n+1):
  temp_count = 0
  if i%2 == 0:
    continue
  for j in range(1,i+1):
    if i%j == 0:
      temp_count += 1
  if temp_count == 8:
    count += 1
    
print(count)
# Judge status: Accepted
N, *XL = map(int, open(0).read().split())

A = sorted(((x + l, x - l) for x, l in zip(*[iter(XL)] * 2)), key=lambda x: x[0])

ans = 0
cur = -10 ** 9
for t, s in A:
    if cur <= s:
        cur = t
        ans += 1

print(ans)
# Judge status: Wrong Answer
from collections import Counter

def solve():
    N = int(input())
    S = input()
    
    c = Counter(S)
    
    ans = 1
    for v in c.values():
        ans = ans*(v+1)
    return ans-1
print(solve())
# Judge status: Accepted
import sys

input = sys.stdin.readline


def main():
    A, B, C = map(int, input().split())

    if A == B == C and A % 2 == 0:
        print(-1)
        exit()

    ans = 0
    while True:
        if (A % 2 == 1) or (B % 2 == 1) or (C % 2 == 1):
            break
        ans += 1
        A, B, C = (B + C) // 2, (A + C) // 2, (A + B) // 2

    print(ans)


if __name__ == "__main__":
    main()
# Judge status: Accepted
n,m = map(int, input().split())

left = 1
right = n

for i in range(m):
    a, b = map(int, input().split())
    left = max(left, a)
    right = min(right,b)
    
print(max(right - left +1 , 0))
# Judge status: Wrong Answer
N = int(input())
p = list(map(int, input().split()))
answer = 0
streak = 0
for i in range(1, N):
    if i == p[i-1]:
        answer += 1
        if i-1 == p[i-2]:
            answer -= 1
            temp = p[i-1]
            p[i-1] = p[i-2]
            p[i-2] = temp

print(answer)
# Judge status: Accepted
n=int(input())
al=list()
bl=list()
for i in range(n):
    a,b=map(int,input().split())
    al.append(a)
    bl.append(b)
al.sort()
bl.sort()
l=n//2
if n%2==0:
    print(bl[l-1]+bl[l]-al[l-1]-al[l]+1)
else:
    print(bl[l]-al[l]+1)
# Judge status: Accepted
N=int(input())
a=list(map(int,input().split()))

chk=1
for i in a:
  if i==chk:
    chk+=1
if chk==1:
  print(-1)
else:
  print(len(a)-chk+1)
# Judge status: Accepted
from collections import defaultdict, deque
import sys
import heapq
import bisect
import math
import itertools
import string
import queue
import copy
import time
# import numpy as np
from fractions import gcd

sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7

def inp(): return int(sys.stdin.readline())
 
def inp_list(): return list(map(int, sys.stdin.readline().split()))

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


N, R = inp_list()
I = 0
if N >= 10:
    I = R
else:
    I = R + 100 * (10 - N)
print(I)
# Judge status: Accepted
n,m=map(int,input().split())
if n==m//2:
  print(m//2)
  exit()
if n>m//2:
  print(m//2)
  exit()
ans=0
ans+=n
m-=2*n
ans+=m//4
print(ans)
# Judge status: Accepted
n = int(input())

if n == 0:
    print(1)
else:
    print(0)
# Judge status: Accepted
from functools import lru_cache
import sys

H,N = [int(i) for i in input().rstrip().split(' ')]
M = [[int(i) for i in input().rstrip().split(' ')] for _ in range(N)]

sys.setrecursionlimit(10**9)
DP = [0]*(H+1)

for x in range(1,H+1):
    DP[x] = min(DP[max(x-a,0)] + b for a,b in M)

print(DP[H])
# Judge status: Wrong Answer
import math
from functools import reduce

def gcd(*numbers):
  return reduce(math.gcd, numbers)

def sumgcd(K):
  for a in range (len(la)):
    for b in range(len(lb)):
      for c in range(len(lc)):
        sum += gcd(la[a],lb[b],lc[c])
# Judge status: Wrong Answer
from collections import deque
N = int(input())
M = deque(map(int, input().split()))

j = []

prev = M.popleft()

for i in range(N-1):
    cor = M.popleft()
    if cor > prev:
        j.append(True)
    else:
        j.append(False)

    prev = cor

if all(j) == True:
    print('YES')
elif j[0] == j[-1] == False:
    print('YES')
else:
    print('NO')
# Judge status: Accepted
#048-A
a, b, c = input().split()
print(a[0]+b[0]+c[0])
# Judge status: Wrong Answer
import math

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


sum_v = 0

if n > k :
    j = k
    s = [0]*(k-1)
else:
    j = n + 1
    s = [0]*n
    
for i in range(1, j):
    s[i-1] = math.ceil(math.log2(k/i))
    sum_v += (1/2)**s[i-1]
    #print(i,s[i-1],sum_v)
    
if n - k >= 0: 
    p1 = (n-k+1)/n
else:
    p1 = 0
    
p2 = sum_v/n
print(p1 + p2)
# Judge status: Accepted
N = int(input())
while N**0.5 % 1:
    N -= 1
print(N)
# Judge status: Wrong Answer
n=int(input())
h=list(map(int,input().split()))

cnt=0
for i in range(n-1):
    if h[i]>=h[i+1]:
        cnt+=1
    else:
        cnt=0

print(cnt)
# Judge status: Accepted
n, k = map(int, input().split())
a = list(map(int, input().split()))

for i in range(k, n):
    if a[i - k] < a[i]:
        print("Yes")
    else:
        print("No")
# Judge status: Accepted
H,M,K,T,S = map(int,input().split())
print(max(((K*60+T-H*60-M-S)+1440)%1440,0))
# Judge status: Accepted
alfa = 'abcdefghijklmnopqrstuvwxyz'
S = input()
for i in range(len(alfa)):
    if alfa[i] not in S:
        print(alfa[i])
        break
else:
    print('None')
# Judge status: Wrong Answer
from collections import Counter
n = int(input())
a = Counter(list(map(int, input().split())))
a = [list(x) for x in a.items() if x[1]>=2]
a.sort(reverse=True, key=lambda x: (x[0], x[1]))
count = 0
base = 4
for l, c in a:
    if c>=base:
        print(l*l)
        exit()
    elif count == 1:
        print(l*l1)
        exit()
    else:
        l1 = l
        count += 1
print(0)
# Judge status: Accepted
N=int(input())
S={}
for n in range(N):
  s=input()
  S[s]=S.get(s,0)+1

maxS=max(S.values())
S=[k for k,v in S.items() if v==maxS]
print('\n'.join(sorted(S)))
# Judge status: Accepted
a=int(input())
b=int(input())
c=int(input())
d=int(input())
e=int(input())
k=int(input())
if e-a>k:
  print(':(')
else:
  print('Yay!')
# Judge status: Accepted
N=int(input())
List=[input() for i in range(N)]

dict = {}

for i in range(N):
	if List[i] in dict:
		dict[List[i]] += 1
	else:
		dict[List[i]] = 1

dict_list = list(dict.items())
dict_list.sort(key=lambda x: x[1], reverse=True)
max = dict_list[0][1]
dict_list.sort(key=lambda x: x[0])

for id in dict_list:
	if max == id[1]:
		print(id[0])
# Judge status: Accepted
n = int(input())
XL = []
for _ in range(n):
    x, l = map(int, input().split())
    x_min = x - l
    x_max = x + l
    XL.append((x,l, x_min, x_max))

XL = sorted(XL, key=lambda x: x[3])

now = 0
count = 0
for i in range(1,n):
    if XL[now][3] > XL[i][2]:
        count += 1
    else:
        now = i
ans = n - count

print(int(ans))
# Judge status: Accepted
a,b=map(int,input().split())
ans=[]
i=0
while i<1000 and a+i<=b:
    ans.append((a+i)%2019)
    i+=1
ans.sort()
minn=10**6
for i in range(len(ans)):
    for j in range(i+1,len(ans)):
        minn=min(minn,(ans[i]*ans[j])%2019)
print(minn)
# Judge status: Wrong Answer
from math import gcd
from numba import jit

@jit
def calc(): 
  k=int(input())
  ans=0
  for a in range(1,k+1):
    for b in range(1,k+1):
      d=gcd(a,b)
      for c in range(1,k+1):
        ans+=gcd(d,c)
  print(ans)
# Judge status: Accepted
a, b = input().split()
aa = a * int(b)
bb = b * int(a)
words = [aa, bb]
words.sort()
print(words[0])
# Judge status: Accepted
n = int(input())
A = list(map(int, input().split()))

d = dict()

for a in A:
    d[a] = d.get(a, 0) + 1

x = [(l, n) for l, n in sorted(d.items(), reverse=True, key=lambda x:x[0]) if n >= 2]
y = [(l, n) for l, n in sorted(d.items(), reverse=True, key=lambda x:x[0]) if n >= 4]

if x == [] and y == []:
    print(0)
else:
    ans = 0
    if len(x) >= 2:
        ans = max(ans, x[0][0] * x[1][0])
    if len(y) >= 1:
        ans = max(ans, y[0][0]**2)
    print(ans)
# Judge status: Accepted
import sys

input = sys.stdin.readline

ri = lambda: int(input())
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]

a, b = ril()
x = str(a) * b
y = str(b) * a
print(min(x, y))
# Judge status: Wrong Answer
n,k=list(map(int, input().split()))
stones=list(map(int, input().split()))
infini=(10**4)*(10**5)
dp = [infini for _ in range(n)]
dp[0]=0

for pos in range(0, n-1):
   for m in range(1, k):
      if pos+k < n:
         dp[pos+k] = min(dp[pos+k], dp[pos] + abs(stones[pos] - stones[pos+k]))
print(dp[-1])
# Judge status: Accepted
a = int(input())
print(a + a**2 + a**3)
# Judge status: Accepted
def resolve():
    N = int(input())
    W = [input() for _ in range(N)]
    if len(set(W)) != N:
        print('No')
        return
    for i in range(N-1):
        if W[i][-1] != W[i+1][0]:
            print('No')
            return
    print('Yes')
    return

resolve()
# Judge status: Wrong Answer
N, K = map(int, input().split())
A = []
a = []

for i in range(N):
    a.append(i + 1)

for i in range(K):
    d = int(input())
    A = [int(x) for x in input().split()]
    try:
        for j in range(d):
            a.remove(A[j])
    except:
        pass
    d = ""
    A = []

print(len(a))
# Judge status: Wrong Answer
if( int(input()) <= 30  ):
  print("Yes")
else:
  print("No")
# Judge status: Wrong Answer
n,a=map(int,open(0));print('NYoe s'[n//500<=a::2])
# Judge status: Accepted
t = input()
ans = 0
for x in t:
    print('P' if x == 'P' else 'D', end = '')
print('')
# Judge status: Accepted
n,k=map(int,input().split())
ans=0
for i in range(1,n+1):
    now=int(i)
    cnt=int(0)
    while now<k:
        cnt+=1
        now*=2
    add=int(1)

    for j in range(cnt):
        add/=2
    ans+=add

print(ans/n)
# Judge status: Accepted
S = input()
alf = 'abcdefghijklmnopqrstuvwxyz'

s = set()
a = set()

for i in range(len(S)):
  s.add(S[i])
for i in range(len(alf)):
  a.add(alf[i])

str = ''
hoge = a ^ s
for h in hoge:
  str += h
  
str=sorted(str)
if str:
  print(str[0])
else:
  print('None')
# Judge status: Accepted
h1, m1, h2, m2, k = map(int, input().split())

print((h2-h1)*60 + (m2-m1) - k)
# Judge status: Accepted
n = int(input())
x = list(map(int, input().split()))

ans = 10**10
for i in range(101):
    t = 0
    for j in x:
        d = i-j
        t += d*d
    ans = min(ans, t)
print(ans)
# Judge status: Accepted
n=int(input())
a=list(map(int,input().split()))

a=sorted(a,reverse=True)

alice =0
bob =0

for i in range(n):
    if i%2==0:
        alice +=a[i]
    else:
        bob +=a[i]


print(alice-bob)
# Judge status: Wrong Answer
n = int(input())
al = list(map(int, input().split()))
four, two = 0, 0

for a in al:
    if a%4 == 0:
        four += 1
    elif a == 2:
        two += 1

if (n-two//2*2)//2 <= four:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
a = input()
if (a[-1]!="s"):
    a+="s"
else:
    a+="es"

print(a)
# Judge status: Accepted
n,m = list(map(int,input().split()))
if 2*n <= m:
    print(n+(m-2*n)//4)
else:
    print(m//2)
# Judge status: Wrong Answer
a,b = map(int,input().split())
s = input()
if len(s) == a + b + 1:
    if s[a] == "-":
        s = s.replace("-","")
        print(s)
        if s.isdecimal():
            print("Yes")
        else:
            print("No")
    else:
        print("No")
else:
    print("No")
# Judge status: Wrong Answer
print('Yes' if '9' in list(input(())) else 'No')
# Judge status: Accepted
n = int(input())
a = list(map(int, input().split()))

dict = {}
for i in range(n):
    if a[i] in dict:
        dict[a[i]] = dict[a[i]] + 1
    else:
        dict[a[i]] = 1

total_cnt = 0
for k, v in dict.items():
    a_cnt = 0
    if k > v:
        a_cnt += v
    else:
        a_cnt += (v - k)
    total_cnt += a_cnt
print(total_cnt)
# Judge status: Accepted
N = int(input())
H = list(map(int,input().split()))

a = 0
b = 0
h = H[0]

for i in range(1,N):
    if h >= H[i]:
        h = H[i]
        a +=1
    else:
        b = (a if a > b else b)
        a = 0
        h = H[i]
b = (a if a > b else b)


print(b)
# Judge status: Accepted
S=input()
K=int(input())

for i in range(K):
    if S[i]!='1':
        break;

print(S[i])
# Judge status: Accepted
x=int(input())
ans=1
for i in range(1,1000+1):
    for j in range(2,11):
        if i**j<=x:
            ans=max(ans,i**j)

print(ans)
# Judge status: Accepted
n,k  = list(map(int,input().split()))
s = list(input())
s[k-1] = s[k-1].lower()
print("".join(s))
# Judge status: Accepted
import collections

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

P = [i+A[i] for i in range(N)]
Q = [j-A[j] for j in range(N)]

Q_dict = collections.Counter(Q)

cnt = 0
for i in range(N-1):
    Q_dict[Q[i]] -= 1
    cnt += Q_dict[P[i]]

print(cnt)
# Judge status: Accepted
n = int(input()) 
p = list(map(int,input().split()))

ans = 0
skip = False
for i in range(n):
    if skip:
        skip = False
        continue
    if i+1 == p[i]:
        ans += 1
        skip = True

print(ans)
# Judge status: Accepted
n = int(input())
a = list(map(int,input().split()))
b1 = []
b2 = []
for i in range(n):
    if i%2==0:b1.append(a[i])
    else:b2.append(a[i])

if n%2==0:
    b2.reverse()
    print(*b2+b1)
else:
    b1.reverse()
    print(*b1+b2)
# Judge status: Wrong Answer
n = input()
a = list(map(int, input().split()))
s = 0

for i in a:
    for j in a:
        if i > j:
            s += i * j

print(s % (10 ** 9 + 7))
# Judge status: Wrong Answer
n,a,b = map(int,input().split())
if a+b>=n:
    print(a)
elif a == 0:
    print(0)
elif b == 0:
    print(n)
else:
    c = n//(a+b)
    d = n%(a+b)
    if a>=d:
        print(c*a + d)
    else:
        print(c*a + a)
# Judge status: Accepted
n,k,q=list(map(int,input().split()))
a=[]
for i in range(q):
  a.append(int(input()))
from collections import Counter
ac_ans=Counter(a)


for i in range(n):
  if (k-q)+ac_ans.get(i+1,0)>0:
    print("Yes")
  else:
    print("No")
# Judge status: Accepted
N, M = map(int,input().split())
ans = 0
if M - 2*N >= 0:
  M -= 2*N
  ans = N + M//4
else:    
  ans = M//2
print(ans)
# Judge status: Accepted
x=int(input())
l=[]
for i in range(1,x+1):
    for k in range(2,11):
        z = i**k
        if z <= x:
            l.append(z)
print(max(l))
# Judge status: Accepted
n = int(input())
c = 0
for i in range(1,n+1):
    t = n//i
    c += i*t*(t+1)//2
print(c)
# Judge status: Accepted
n,x = list(map(int, input().split()))
lst = [0]+list(map(int, input().split()))
ans = 0

for i in range(n):
    if lst[i]+lst[i+1]>x:
        ans+=(lst[i]+lst[i+1]-x)
        lst[i+1]-=(lst[i]+lst[i+1]-x)
print(ans)
# Judge status: Wrong Answer
n,a,b=map(int,input().split())
s=0
def kumi(x,y):
  k=1
  for i in range(y):
    k=k*(x-i)
  return x
def comb(x,y):
  return (kumi(x,y)//kumi(y,y))
for i in range(1,n+1):
  if i==a or i==b:
    s=s
  else:
    s=s+(comb(n,i)%(10**9+7))
print(s)
# Judge status: Accepted
x,y = map(int,input().split())

print(int(x+y/2))
# Judge status: Accepted
n=str(input())
n=list(n)
count=0
for i in range(len(n)):
  if(n[i]=="7"):
    count+=1
if(count!=0):
  print("Yes")
else:
  print("No")
# Judge status: Accepted
s=list(input())
while(True):
    s.pop()
    s.pop()
    tmp=len(s)//2
    ans=0
    for i in range(tmp):
        if s[i]==s[i+tmp]:
            ans+=1
    if ans==tmp:
        print(tmp*2)
        break