Harryxun/stf_run huggingface dataset:
N=int(input())
a=input().split(" ")
b=[]
for p in range(0,N):
    b.append(int(a[p]))
c=[]
if b[0]-b[1]>=0:
    c.append(1)
else:
    c.append(0)
for q in range(1,N-1):
    if b[q]-b[q+1]>=0:
        c.append(c[q-1]+1)
    else:
        c.append(0)
print(max(c))

### FIXED CODE ###

N=int(input())
a=input().split(" ")
b=[]
for p in range(0,N):
    b.append(int(a[p]))
if N==1:
    print(0)
else:
    c=[]
    if b[0]-b[1]>=0:
        c.append(1)
    else:
        c.append(0)
    for q in range(1,N-1):
        if b[q]-b[q+1]>=0:
            c.append(c[q-1]+1)
        else:
            c.append(0)
    print(max(c))
a, b, c, d = map(int, input())
if a + b == c + d:
    print('Balanced')
elif a + b < c + d:
    print('Right')
else:
    print('Left')


### FIXED CODE ###

a, b, c, d = map(int, input().split())
if a + b == c + d:
    print('Balanced')
elif a + b < c + d:
    print('Right')
else:
    print('Left')
s = input()
a = s.find('C')

if a == -1:
    print("No")
else:
    if s[a:].find('F') == -1:
        print("No")
    else print("Yes")

### FIXED CODE ###

s = input()
a = s.find('C')

if a == -1:
    print("No")
else:
    if s[a:].find('F') == -1:
        print("No")
    else: print("Yes")
N = int(input())
S = list(input())
n_sharp = S.count("#")
n_period = S.count(".")
temp = [[], []]
k = 0
for i in range(N - 1):
    if S[i] == "#" and S[i + 1] == ".":
        temp[0].append(S[:i + 1].count("#"))
        # print(S[:i + 1], S[i + 1:])
        temp[1].append(S[i + 1:].count("."))
        k += 1
        if k == 1:
            ans = min(temp[0], temp[1])[0]
            # print((ans))
        elif k > 1:
            ans += min(abs(temp[0][k-1] - temp[0][k - 2]), abs(temp[1][k-1] - temp[1][k - 2]))

print(ans)

### FIXED CODE ###

N = int(input())
S = list(input())
S.insert(0,0)
# b = S.count("#")
w = S.count(".")
black = 0
white = w
ans = 2e5
for i in range(N+1):
    if S[i] == "#":
        black += 1
    elif S[i] == ".":
        white -= 1
    # print(black,white)
    ans = min(black + white, ans)
print(ans)
from collections import defaultdict
from itertools import product, groupby
from math import pi
from collections import deque
from bisect import bisect, bisect_left, bisect_right
INF = 10 ** 10


def main():
    n = int(input())
    a_list = list(map(int, input().split()))

    a_list = [1] * (2 * 10 ** 5)
    ans = []
    for i in range(1, len(a_list), 2):
        ans.append(a_list[i])
    ans = ans[::-1]
    for i in range(0, len(a_list), 2):
        ans.append(a_list[i])

    if n % 2 != 0:
        ans = ans[::-1]
    print(*ans)


if __name__ == '__main__':
    main()


### FIXED CODE ###

from collections import defaultdict
from itertools import product, groupby
from math import pi
from collections import deque
from bisect import bisect, bisect_left, bisect_right
INF = 10 ** 10


def main():
    a = list(map(int, input().split()))
    print(sum(a) - max(a))


if __name__ == '__main__':
    main()
N, M = map(int, input().split(' '))

def fib(n):
    a, b = 0, 1
    for i in range(0, n):
        a, b = b, a + b
    return a

a_p = int(input())
sum = fib(a_p)
for i in range(M-1):
    a = int(input())
    diff = a - a_p
    if diff == 1:
        print('0')
        exit()
    sum *= fib(diff-1)
    a_p = a

sum *= fib(N - a_p)

print(sum % 1000000007)


### FIXED CODE ###

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

MOD = 1000000007

def fib(n):
    a, b = 0, 1
    for i in range(0, n):
        a, b = b, a + b
    return a

broken_step = []
p_a = -1
for i in range(M):
    a = int(input())
    if (a - p_a == 1):
        print("0")
        exit()
    else:
        p_a = a
    broken_step.append(a-1)

count_0 = 0
count_1 = 1
next_broken = 0
pre_is_broken = False
for i in range(N):
    if (next_broken >= len(broken_step) or i != broken_step[next_broken]):
        if (pre_is_broken):
            count_0 = 0
            pre_is_broken = False
        else:
            count_0, count_1 = count_1, count_0 + count_1
            count_0 %= MOD
            count_1 %= MOD
    else:
        next_broken+=1
        count_0 = 0
        pre_is_broken = True

print(count_1)
S = input()
k = int(input())
if S.len()<=k:
  print(S)
else:
  print(S[:k]+"...")
 


### FIXED CODE ###

k = int(input())
S = input()

if len(S)<=k:
  print(S)
else:
  print(S[:k]+"...")
print(input())print(input().count('1'))

### FIXED CODE ###

print(input().count('1'))
lst = []
N = int(input("Enter number of elements : "))
for i in range(0,N):
    lst.append(int(input()))
temp = [x for x in lst if lst.count(x)>1]
list_set = set(temp)
# convert the set to the list
dups = (list(list_set))
n=len(dups)
if (n<2):
   print('0\nNo rectangle can be formed')
else:
    a = dups[0]
    b = dups[1]
    for i in range(0, n):
      for j in range(i + 1, n):
        if (dups[i]*dups[j]>a*b):
             a = dups[i]
             b = dups[j]
    print(a*b)
    print(a,' times ',b,' rectangle can be formed')

### FIXED CODE ###

n = int(input())
vals = list(map(int, input().split()))
d= {}
a = [0, 0]

for i in range(n):
    if(vals[i] in d.keys()):
        d[vals[i]] += 1
    else:
        d[vals[i]] = 1


for i in d.keys():
    if(d[i] >= 4):
        a.append(i)
        a.append(i)
    elif(d[i] >= 2):
        a.append(i)
a.sort()

print(a[-1]*a[-2])
S = input()
T = input()

if (len(S)%2==0)
    if T == S[::-1]:
        print("Yes")
    else:
        print("No")
else:
    if T == S[::-1]:
        print("No")
    else:
        print("Yes")
        

### FIXED CODE ###

S = input()
T = input()
a = ""
for i in range(len(S)+1):
    if i == 0:
        a = (S[-1] + S[:-1])
    else:
        a = a[-1] + a[:-1]
    if a == T:
        print("Yes")
        break
else:
    print("No")
dic = {}
ans = []
a = 0

N = int( input() )
for i in range( N ):
  let = input()
  if let not in dic:
    dic.update( { let : 1 } )
  else:
    num=dic[ let ]
    dic[ let ] = num + 1
dic_sorted = sorted(dic.items(), key=lambda x:x[1])
for each in dic_sorted.keys():
  if dic_sorted[ each ] >= a:
    ans+=1
    a=dic_sorted[ each ]
  else:
    break
ans.sort()
for each in ans:
  print(each)

### FIXED CODE ###

dic = {}
ans = []
a = 0

N = int( input() )
for i in range( N ):
  let = input()
  if let not in dic:
    dic.update( { let : 1 } )
  else:
    num=dic[ let ]
    dic[ let ] = num + 1
dic_sorted = sorted(dic.items(), key=lambda x:x[1],reverse=True)
for each in dic_sorted:
  if each[1] >= a:
    ans.append(each[0])
    a=each[1]
  else:
    break
ans.sort()
for each in ans:
  print(each)
import collections, math, bisect
from fractions import Fraction

local = False
if local:
    file = open("input.txt", "r")
    import time

def inp():
    if local:
        return file.readline().rstrip()
    else:
        return input().rstrip()

def ints():
    return [int(_) for _ in inp().split()]

if local:
    start=time.time()


N, K = ints()

oneprob = Fraction(1, N)
ans = 0
for i in range(1, N+1):
    if i>=K:
        break
        
    doubling_amounts = math.ceil(math.log2(K/i))
    ans+=Fraction(1,2)**doubling_amounts

ans*=oneprob

if N>K:
    ans+=Fraction(N-K+1, N)

print("{:.20f}".format(float(ans)))

if local:
    fin = (time.time()-start)*1000
    print("{:.2f}".format(fin) + "ms")





### FIXED CODE ###

import collections, math, bisect
from fractions import Fraction

local = False
if local:
    file = open("input.txt", "r")
    import time

def inp():
    if local:
        return file.readline().rstrip()
    else:
        return input().rstrip()

def ints():
    return [int(_) for _ in inp().split()]

if local:
    start=time.time()


N, K = ints()

oneprob = Fraction(1, N)
ans = 0
for i in range(1, N+1):
    if i>=K:
        break
        
    doubling_amounts = math.ceil(math.log2(K/i))
    ans+=Fraction(1,2)**doubling_amounts

ans*=oneprob

if N>=K:
    ans+=Fraction(N-K+1, N)

print("{:.20f}".format(float(ans)))

if local:
    fin = (time.time()-start)*1000
    print("{:.2f}".format(fin) + "ms")
N, M = map( int, input().split() )
A = list( map( int, input().split() ) )


# 桁数の一番大きいものが最大。そのあと数を大きい順に並べればいい
dp = [-float('inf')] * (N+1)             # dp[i]: i 本のマッチで条件を満たす整数の最大桁数
cost = [ 0, 2, 5, 5, 4, 5, 6, 3, 7, 6 ]  # 各数字に必要なマッチ棒の数(逆順)

dp[0] = 0
for num_match in range( 2, N+1 ):
    for Aj in A:
        if num_match >= cost[Aj]:
            dp[num_match] = max( dp[num_match], dp[num_match-cost[Aj]]+1 )

ans = ""
digit = dp[N]

A.sort( reverse=True )
while N > 0:
    for Ai in A:
        if dp[N-cost[Ai]] == digit-1 :
            ans += str(Ai)
            N -= cost[Ai]
            digit -= 1
            break

print( int(ans) )

### FIXED CODE ###

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


# 桁数の一番大きいものが最大。そのあと数を大きい順に並べればいい
dp = [0] + [-float('inf')] * (N+1)       # dp[i]: i 本のマッチで条件を満たす整数の最大桁数
cost = [ 0, 2, 5, 5, 4, 5, 6, 3, 7, 6 ]  # 各数字に必要なマッチ棒の数(逆順)

for num_match in range( 2, N+1 ):
    for Aj in A:
        if num_match >= cost[Aj]:
            dp[num_match] = max( dp[num_match], dp[num_match-cost[Aj]]+1 )


ans = ""
digit = dp[N]

A.sort( reverse=True )
while N > 0:
    for Ai in A:
        if N-cost[Ai] >=0 and dp[N-cost[Ai]] == digit-1:
            ans += str(Ai)
            N -= cost[Ai]
            digit -= 1
            break

print( ans )
def main():
    s, c = map(int, input.row().split())
    count = 0
    for i in range(s):
        if(c >= 2):
            count += 1
            c -= 2
        else:
            break
    for i in range(c):
        if(c >= 4):
            count += 1
            c -= 4
        else:
            break
    return count

print main()

### FIXED CODE ###

def main():
    s, c = map(int, raw_input().split())
    count = 0
    if s > c/2:
        return c/2
    elif s == c/2:
        return s
    elif s < c/2:
        return s + ((c-2*s)/4)
print main()
def get_input():
      w = input()
      h = input()
      a = []
      for i in range(w):
            sub_a = []
            for j in range(h):
                  sub_a.append(raw_input())
            a.append(sub_a)
      return a

def transpose(mat):
      mat2 =[[row[i] for row in mat] for i in range(len(mat[0]))]
      return mat2

def get_output(mat):
      # done_flag = False
      point_count = 0
      i = 0
      while i<len(mat):
            j = 0
            while j<len(mat[0]):
                  if(mat[i][j] == '.'):
                        point_count += 1
                  j+=1            
            
            if point_count == len(mat[0]):
                  del mat[i]
                  i = 0
                  point_count = 0
                  continue
            i+=1
            point_count = 0
            # print(mat)

      mat = transpose(mat)

      point_count = 0
      i = 0
      while i<len(mat):
            j = 0
            while j<len(mat[0]):
                  if(mat[i][j] == '.'):
                        point_count += 1
                  j+=1            
            
            if point_count == len(mat[0]):
                  del mat[i]
                  i = 0
                  point_count = 0
                  continue
            i+=1
            point_count = 0
            # print(mat)

      return transpose(mat)

if __name__ == '__main__':
    mat = get_input()
    mat2 = get_output(mat)

    print mat2

# del a[1]

### FIXED CODE ###

h, w = [int(n) for n in input().split()]
grid = [input() for _ in range(h)]
row_hashs = set()
column_hashs = set()

for i, row in enumerate(grid):
    for j, ch in enumerate(row):
        if ch == '#':
            row_hashs.add(i)
            column_hashs.add(j)

new_grid = []

for i, row in enumerate(grid):
    if i not in row_hashs:
        continue
    new_grid.append([])
    for j, ch in enumerate(row):
        if j not in column_hashs:
            continue
        new_grid[-1].append(ch)
    new_grid[-1] = "".join(new_grid[-1])


print("\n".join(new_grid))
# print(*new_grid, sep="\n")
S = list(input())
acgt = ['A','C','G','T']
lengths = []
length = 0
for s in S:
  if s in acgt:
    length+=1
  else:
    lengths.append(length)
print(max(lengths))

### FIXED CODE ###

S = list(input())
acgt = ['A', 'C', 'G', 'T']
lengths = []
l = 0
for x in S:
  if x in acgt:
    l += 1
  else:
    lengths.append(l)
    l = 0

if len(lengths) == 0 or l > 0:
  lengths.append(l)

print(max(lengths))
A,B,C,K= map(int, input().split())
Z = [1,]*A + [0,]*B+[-1,]*C
ans = 0
for i in Z[0:K]:
    ans += i
print(ans)

### FIXED CODE ###

A,B,C,K= map(int, input().split())
if A >= K:
    print(K)
    #print("a")
else:
    ans = A
    if B >= K-A:
        print(A)
        #print("b")
    else:
        print(A-(K-(A+B)))
        #print("c")
def f_must_be_rectangular(N, Positions):
    # 参考: https://atcoder.jp/contests/abc131/submissions/6086451
    # x軸, y軸をまとめて1つのリストで扱う
    import sys
    sys.setrecursionlimit(10**6)

    vertex_maxsize = 10**5
    target = [[] for _ in range(2 * vertex_maxsize)]
    is_visited = [False] * (2 * vertex_maxsize)

    for x, y in Positions:
        y += vertex_maxsize  # 1つのリストで扱う都合上、ずらす
        target[x].append(y)
        target[y].append(x)

    def dfs(v):
        if is_visited[v]:
            return
        is_visited[v] = True
        count[v // vertex_maxsize] += 1  # vがx軸かy軸かどっちを指しているか
        for u in target[v]:
            dfs(u)  # 頂点vに接続されている頂点へ向かう

    ans = 0
    for i in range(2 * vertex_maxsize):
        if is_visited[i]:
            continue
        count = [0] * 2
        dfs(i)  # 頂点iにつながっている頂点を調べる
        # x座標とy座標のそれぞれについて、ペアにすると矩形が完成する
        # 座標がいくつあるか。その積が解となる
        ans += count[0] * count[1]
    return ans - N  # 最初に与えられた座標の分、引く

N = int(input())
Positions = [[int(i) for i in input().split()] for j in range(N)]
print(f_must_be_rectangular(N, Positions))

### FIXED CODE ###

def f_must_be_rectangular(N, Positions):
    # 参考: https://atcoder.jp/contests/abc131/submissions/6086451
    # x軸, y軸をまとめて1つのリストで扱う
    import sys
    sys.setrecursionlimit(10**7)

    vertex_maxsize = 10**5 + 5
    target = [[] for _ in range(2 * vertex_maxsize)]
    is_visited = [False] * (2 * vertex_maxsize)
    count = [0] * 2
    for x, y in Positions:
        y += vertex_maxsize  # 1つのリストで扱う都合上、ずらす
        target[x].append(y)
        target[y].append(x)

    def dfs(v):
        if is_visited[v]:
            return
        is_visited[v] = True
        count[v // vertex_maxsize] += 1  # vがx軸とy軸のどっちを指しているか
        for u in target[v]:
            dfs(u)  # 頂点vに接続されている頂点へ向かう

    ans = 0
    for i in range(2 * vertex_maxsize):
        if is_visited[i]:
            continue
        count = [0] * 2
        dfs(i)  # 頂点iにつながっている頂点を調べる
        # x座標とy座標のそれぞれについて、ペアにすると矩形が完成する
        # 座標がいくつあるか。その積が解となる
        ans += count[0] * count[1]
    return ans - N  # 最初に与えられた座標の分、引く

N = int(input())
Positions = [[int(i) for i in input().split()] for j in range(N)]
print(f_must_be_rectangular(N, Positions))
n, p = map(int,input().split())
s = input()
count = 0
for i in range(1, n + 1):
    for j in range(n - i + 1):
        num = 0
        for k in range(i):
            num += int(s[j + k]) * (10 ** (i - k - 1))
        if(num % p == 0):
            count += 1
print(count)

### FIXED CODE ###

A = False
B = False
s=input()
for char in s:
    if char == "A":
        A = True
    if char == "B":
        B = True
if(A and B):
    print("Yes")
else:
    print("No")
def judge1(Num,a):
    s = list(range(Num))
    for l in range(2,Num):
        if Num%l == 0:
            alpha = list(a)
            j = int(Num/l - 1)
            b = []
            c = []
            for i in range(j+1):
                b.append(alpha[i])
            for k in range(l):
                c = c + b
            if alpha == c:
                s[l] = 1
            else:
                s[l] = 0
        else:
            s[l] = 0
    return s

N = int(input())
S = input()
a = judge1(N,S)
if 1 == a[2]:
    print("yes")
else:
    print("No")

### FIXED CODE ###

def judge(N,str):
    a = list(str)
    b = []
    c = []
    if N%2 == 0:
        for k in range(int(N/2)):
            b.append(a[k])
            c.append(a[k+int(N/2)])
        if b == c:
            print("Yes")
        else:
            print("No")
    else:
        print("No")
N = int(input())
S = input()
judge(N,S)
def solve(c,h,w,count):
	if 0 <= h < H and 0 <= w < W:
		if c in "#@*" and c == A[h][w]:
			A[h][w] = count
			solve(c,h+1,w,count)
			solve(c,h-1,w,count)
			solve(c,h,w+1,count)
			solve(c,h,w-1,count)

while 1:
	H,W = map(int,raw_input().split())
	if H == W == 0:
		break
	A = [list(raw_input()) for i in range(H)]
	count = 0
	for h in range(H):
		for w in range(W):
			if str(A[h][w]) in "#@*":
				solve(A[h][w],h ,w,count)
				count += 1
	print count

### FIXED CODE ###

import sys
sys.setrecursionlimit(20000)
def solve(h,w,count,c):
    if 0 <= h < H and 0 <= w < W and A[h][w] == c:
        A[h][w] = count
        for dh,dw in zip([1,0,-1,0],[0,1,0,-1]):
            solve(h+dh,w+dw,count,c)
while 1:
    H,W = map(int,raw_input().split())
    if H == W == 0: break
    A = [list(raw_input()) for _ in range(H)]
    count = 0
    for h in range(H):
        for w in range(W):
            if type(A[h][w]) is not int:
                solve(h,w,count,A[h][w])
                count += 1
    print count
,K=map(int,input().split())
A=list(map(int, input().split()))
dp=[[0,0]for _ in range(42)]
#2の41乗が10**12とちょっと

for i in range(1,42):
  if dp[i-1][1]==1:
    dp[i][1]=1
  
  cnt=0
  #リストA内のiケタ目の1の数をカウント
  for j in range(N):
    if (A[j]>>(41-i))&1==1:
      cnt+=1
      
  #1の方が多いときは、0を当てはめる
  if cnt>=N-cnt:
    dp[i][0]=dp[i-1][0]+(2**(41-i))*cnt
    if (K>>(41-i))&1==1:
      dp[i][1]=1
  else:
    if dp[i][1]==1:
      dp[i][0]=dp[i-1][0]+(2**(41-i))*(N-cnt)
    else:
      if (K>>(41-i))&1==1:
        #そのケタが1ならば問題なし
        dp[i][0]=dp[i-1][0]+(2**(41-i))*(N-cnt)
      else:
        #桁が0ならば0にするしかない
        dp[i][0]=dp[i-1][0]+(2**(41-i))*cnt
print(dp[41][0])

### FIXED CODE ###

N,K=map(int,input().split())
A=list(map(int, input().split()))
dp=[[0,0]for _ in range(42)]
#2の41乗が10**12とちょっと

for i in range(1,42):
  if dp[i-1][1]==1:
    dp[i][1]=1
  
  cnt=0
  #リストA内のiケタ目の1の数をカウント
  for j in range(N):
    if (A[j]>>(41-i))&1==1:
      cnt+=1
      
  #1の方が多いときは、0を当てはめる
  if cnt>=N-cnt:
    dp[i][0]=dp[i-1][0]+(2**(41-i))*cnt
    if (K>>(41-i))&1==1:
      dp[i][1]=1
  else:
    if dp[i][1]==1:
      dp[i][0]=dp[i-1][0]+(2**(41-i))*(N-cnt)
    else:
      if (K>>(41-i))&1==1:
        #そのケタが1ならば問題なし
        dp[i][0]=dp[i-1][0]+(2**(41-i))*(N-cnt)
      else:
        #桁が0ならば0にするしかない
        dp[i][0]=dp[i-1][0]+(2**(41-i))*cnt
print(dp[41][0])
from heapq import heapify, heappop

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

slice_L = [v[:i] for i in range(N + 1)]
sum_L = [0]
for vv in v:
    sum_L.append(sum_L[-1] + vv)

slice_R = [v[N - 1 - i:] for i in range(-1, N)]
sum_R = [0]
for vv in v[::-1]:
    sum_R.append(sum_R[-1] + vv)

ans = 0
for put, pick in enumerate(range(K, 0, -1), 0):
    for left in range(pick + 1):
        m_put = put
        right = pick - left
        t = sum_L[left] + sum_R[right]
        q = slice_L[left] + slice_R[right]
        heapify(q)
        while m_put > 0 and q:
            t -= heappop(q)
            m_put -= 1
        if m_put > 0:
            continue
        ans = max(ans, t)
print(ans)


### FIXED CODE ###

from heapq import heapify, heappop

N, K = map(int, input().split())
vl = list(map(int, input().split()))
vr = list(reversed(vl))
sum_L = [0]
for vv in vl:
    sum_L.append(sum_L[-1] + vv)

sum_R = [0]
for vv in vr:
    sum_R.append(sum_R[-1] + vv)

ans = 0
for pick in range(min(K, N) + 1):
    for to_remove in range(K + 1):
        if pick + to_remove > K: break
        for left in range(pick + 1):
            right = pick - left

            t = sum_L[left] + sum_R[right]

            q = vl[:left] + vr[:right]
            heapify(q)

            cnt = 0
            while cnt < to_remove and q:
                t -= heappop(q)
                cnt += 1
            ans = max(ans, t)
print(ans)
print("縦と横の長さを入力")

a=int(input())
b=int(input())

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




### FIXED CODE ###


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

r=a*b
length=a*2+b*2
print(r,length)
N=int(input())
A=list(map(int,input().split()))

import fractions
from functools import reduce
from copy import copy

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

gcds=[]
for i in range(N):
    A_=copy(A)
    A_=pop(i)
    gcds.append(gcd(*A_))

print(max(gcds))


### FIXED CODE ###

A,B,T=map(int,input().split())
print(T//A*B)
H,W = int(input().split())
h,w = int(input().split())

print(H*W - h*w)

### FIXED CODE ###

H,W = map(int,input().split())
h,w = map(int,input().split())

print((H-h) * (W-w))
N = int(input())
list = list(input())
n = 0
if N % 2 != 0:
	print("No")
else:
    for i in range(N//2):
	    if not list[i] == list[i+ N//2]:
            print("No")
            break
        n += 1
    if n == N//2 - 1:
        print("Yes")


### FIXED CODE ###

N = int(input())
list = list(input())
n = 0
if N % 2 != 0:
	print("No")
else:
    for i in range(N//2):
        if not list[i] == list[i+ N//2]:
            print("No")
            break
        n += 1
    if n == N//2:
        print("Yes")
n,m = map(int, input().split())
a = list(map(int, input().split()))
a.sort(reverse = True)
if a[m] * 4*m >= sum(a):
    print('Yes')
else:
    print('No')

### FIXED CODE ###

n,m = map(int, input().split())
a = list(map(int, input().split()))
a.sort(reverse = True)
if a[m-1] * 4*m >= sum(a):
    print('Yes')
else:
    print('No')
x= int(input())

def prime_check(num,count):
    if (num % count) != 0:
        if num <= count**2:
            print(num)
        else:
            prime_check(num,count+1)
    else :
        prime_check(num+1,2)

if x==2 :
    print (2)
else:
    print(prime_check(x,2))


### FIXED CODE ###

X = int(input())

def get_sieve_of_eratosthenes_new(n):
    import math
    if not isinstance(n, int):
        raise TypeError('n is int type.')
    if n < 2:
        raise ValueError('n is more than 2')
    prime = []
    limit = math.sqrt(n)
    data = [i + 1 for i in range(1, n)]
    while True:
        p = data[0]
        if limit <= p:
            return prime + data
        prime.append(p)
        data = [e for e in data if e % p != 0]

prime = get_sieve_of_eratosthenes_new(10**6)
for num in prime:
    if num >= X:
        print(num)
        break
x=int(input())
i=0
u=0
while 500>=x:
    x-=500
    i+=1
while >=5:
    x-=5
    u+=1
print(5*i+u)

### FIXED CODE ###

x=int(input())
i=0
u=0
while 500<=x:
    x-=500
    i+=1
while x>=5:
    x-=5
    u+=1
print(1000*i+5*u)
N = int(input())
a = [int(input) for _ in range(5)]

print(n // min(a) + 5)


### FIXED CODE ###

from math import ceil

N = int(input())
a = [int(input()) for _ in range(5)]

print(ceil(N / min(a)) + (5-1))
n = int(input())
lis = list(map(int,input().split()))
ing_total = 0

for i in range(n):
    ing_total+= 1 / lis[i]

print(int(1/ing_total)


### FIXED CODE ###

n = int(input())
lis = list(map(int,input().split()))
ing_total = 0

for i in range(n):
    ing_total+= 1 / lis[i]

print(1/ing_total)
h, w = map(int, input().split())
mass = [list(input()) for _ in range(h)]

ans = "Yes"
for i in range(w):
    for j in range(h):
        if mass[i][j] == "#":
            if i < w-1:
                if mass[i+1][j] == "#":
                    continue
            if 0 < i:
                if mass[i-1][j] == "#":
                    continue
            if j < h-1:
                if mass[i][j+1] == "#":
                    continue
            if 0 < j:
                if mass[i][j-1] == "#":
                    continue
            ans = "No"
            break

print(ans)

### FIXED CODE ###

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

ans = "Yes"
for i in range(h):
    for j in range(w):
        if mass[i][j] == "#":
            if i < h-1:
                if mass[i+1][j] == "#":
                    continue
            if 0 < i:
                if mass[i-1][j] == "#":
                    continue
            if j < w-1:
                if mass[i][j+1] == "#":
                    continue
            if 0 < j:
                if mass[i][j-1] == "#":
                    continue
            ans = "No"
            break

print(ans)