Harryxun/stf_run huggingface dataset:
N=int(input())
H=list(map(int,input().split()))
ans=0
cnt=o
for i in range(N-1):
  if H[i]>=H[i+1]:
    cnt+=1
  else:
    ans=max(cnt,ans)
    cnt=0
print(ans)

### FIXED CODE ###

N=int(input())
H=list(map(int,input().split()))
ans=0
cnt=0
for i in range(N-1):
  if H[i]>=H[i+1]:
    cnt+=1
  else:
    ans=max(cnt,ans)
    cnt=0
ans=max(ans,cnt)
print(ans)
import sys
sys.setrecursionlimit(10**5)
n = int(input())
cnt = [0,0,0]
dp = [[[0.0]*(n+1) for _ in range(n+1)] for _ in range(n+1)]
for i in map(int,input().split()):
  cnt[i-1] += 1
def fj(i,j,k):
  global dp
  if i < 0 or j < 0 or k < 0 or i>n or j>n or k>cnt[2]:
    return 0.0
  if dp[i][j][k] != 0.0:
    return dp[i][j][k]
  s = i+j+k
  res = n/s + fj(i-1,j,k)*i/s + fj(i+1,j-1,k)*j/s + fj(i,j+1,k-1)*k/s
  dp[i][j][k] = res
  return dp[i][j][k]
print(fj(*cnt)) 

### FIXED CODE ###

n = int(input())
a = list(map(int, input().split()))
uno = a.count(1)
dos = a.count(2)
tres = n - uno - dos
dp = [[[0]*(n+1) for _ in range(dos+tres+1)] for j in range(tres+1)]
for k in range(tres+1):
  for j in range(dos+tres-k+1):
    for i in range(n+1-j-k):
      if i+j+k == 0: continue
      v = i+j+k
      res = n
      if i: res += i * dp[k][j][i-1]
      if j: res += j * dp[k][j-1][i+1]
      if k: res += k * dp[k-1][j+1][i]
      dp[k][j][i] = res / v
print(dp[tres][dos][uno])
s=[str(i) for i in input()]
if str[0]=='R' and str[1]=='S':
	print(1)
elif str[1]=='S' and str[2]=='R':
	print(1)
elif str[0]=='S' and str[1]=='R' and str[2]=='S':
	print(1)
elif str[0]=='R' and str[1]=='R' and str[2]=='S':
	print(2)
elif str[0]=='S' and str[1]=='R' and str[2]=='R':
	print(2)
elif str[0]=='R' and str[1]=='R' and str[2]=='R':
	print(3)
else:
	print(0)

### FIXED CODE ###

s=[str(i) for i in input()]
if s[0]=='R' and s[1]=='S':
	print(1)
elif s[1]=='S' and s[2]=='R':
	print(1)
elif s[0]=='S' and s[1]=='R' and s[2]=='S':
	print(1)
elif s[0]=='R' and s[1]=='R' and s[2]=='S':
	print(2)
elif s[0]=='S' and s[1]=='R' and s[2]=='R':
	print(2)
elif s[0]=='R' and s[1]=='R' and s[2]=='R':
	print(3)
else:
	print(0)
print(("Even","Odd")[int(input())&1])

### FIXED CODE ###

a,b=map(int,input().split())
print(("Even","Odd")[a*b&1])
a=input()
b=input()

flag=0
if len(b) < len(a):
  print('GREATER')
  flag=1
if len(b) > len(a):
  print('LESS')
  flag=1

for i in range(len(a)):
  if b[i] < a[i] and flag==0:
    print('GREATER')
    flag=1
  elif b[i] > a[i] and flag==0:
    print('LESS')
    flag=1
    
if flag==0:
  print('EQUAL')

### FIXED CODE ###

a=input()
b=input()

flag=0

if len(a)==1 and len(b)==1:
  if int(b) < int(a):
    print('GREATER')
    flag=1
  elif int(b) > int(a):
    print('LESS')
    flag=1
  else:
    print('EQUAL')
    flag=1
    
if len(a)==1 and len(b) > 1:
    print('LESS')
    flag=1
    
if len(a) > 1 and len(b)==1:
    print('GREATER')
    flag=1

if len(b) < len(a) and flag==0:
  print('GREATER')
  flag=1
if len(b) > len(a) and flag==0:
  print('LESS')
  flag=1

  
if len(a)==len(b):  
  for i in range(len(a)):
    if b[i] < a[i] and flag==0:
      print('GREATER')
      flag=1
    elif b[i] > a[i] and flag==0:
      print('LESS')
      flag=1
    
if flag==0:
  print('EQUAL')
input()**3

### FIXED CODE ###

print(int(input()) ** 3)
n = int(input())
li = list(input())
print(max(li)-min(li))

### FIXED CODE ###

n = int(input())
li = list(map(int,input().split()))
print(max(li)-min(li))
S = int(input())

a = 0

for i in S:
  if a == 0 and i == "C":
    a += 1
  if a == 1 and i == "F":
    a += 1
    
if a == 2:
  print ("Yes")
else:
  print ("No")

### FIXED CODE ###

S = input()

a = 0

for i in S:
  if a == 0 and i == "C":
    a += 1
  if a == 1 and i == "F":
    a += 1
    
if a == 2:
  print ("Yes")
else:
  print ("No")
import math
from collections import defaultdict

N = int(input())
a = defaultdict(list)
for i in range(1, N + 1):
    a[int(input())].append(i)

def check(key):
    # print(key)
    if key == 1:  # find goal
        return 1
    elif key == 2:  # forming infinite loop
        return math.inf
    else:
        values = a[key]
        if len(values) == 0:
            return math.inf
        return min([check(v) for v in values]) + 1

if a.get(2):
    ans = min([check(v) for v in a[2]])
else:
    ans = math.inf

if ans == math.inf:
    print(-1)
else:
    print(ans)


### FIXED CODE ###

n = int(input())
a = []
for i in range(n):
  a.append(int(input()))
b = a[0]
c = []
while True:
  if b == 2:
    print(len(c)+1)
    exit()
  if len(c)> n:
    print(-1)
    exit()
  else:
    c.append(b)
    b = a[c[-1]-1]
K = int(input())
if K % 2 == 0 or K % 5 == 0:
    print(-1)
else:
    if K % 7 == 0:
        L = 9 * K // 7
    else:
        L = 9 * K
n = 1
P = 10 % L
while True:
    if P == 1:
        print(n)
        break
    n += 1
    P = (10 * P) % L

### FIXED CODE ###

K = int(input())
if K % 2 == 0 or K % 5 == 0:
    print(-1)
    
else:
    if K % 7 == 0:
        L = 9 * K // 7
    else:
        L = 9 * K
    n = 1
    P = 10 % L
    while True:
        if P == 1:
            print(n)
            break
        n += 1
        P = (10 * P) % L
n, q = map(int, input().split())
s=input()
for i in range(n):
  l[i],r[i] = map(int, input().split())
  t[i]=s[l[i]:r[i]+1].count("AC")
  print(t(i))

### FIXED CODE ###

n, q = map(int, input().split())
s=input()
d=[0]*n
c=0
for i in range(n-1):
  if s[i:i+2]=="AC":
    c+=1
  d[i+1]=c
for i in range(q):
  l,r= map(int, input().split())
  print(d[r-1]-d[l-1])
A,B,C=map(int,input().split())

print (map(int(C,A,B).split))

### FIXED CODE ###

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

print (C,A,B)
def gcd(a,b):
  if a*b == 0:
    return max(a,b)
  if a<b:
    a,b = b,a
  return gcd(b,a%b)
n = int(input())
ls = list(map(int,input().split()))
length = 2**((n-1).bit_length())
calc = gcd
unit = 0
Seg = [unit for i in range(length*2-1)]
def init():
  for i in range(n):
    Seg[i+length-1] = ls[i]
  for i in range(length//2,-1,-1):
    Seg[i] = calc(Seg[2*i+1],Seg[2*i+2])
def update(i,x):
  i += length-1
  Seg[i] = x
  while i>0:
    i = (i-1)//2
    Seg[i] = calc(Seg[2*i+1],Seg[2*i+2])
def query(a,b,k,l,r):
  if r<=a or b<=l:
    return unit
  if l<=a and b<=r:
    return Seg[k]
  else:
    vl = query(a,b,2*k+1,l,(l+r)//2)
    vr = query(a,b,2*k+2,(l+r)//2,r)
    return calc(vl,vr)

init()
ans = []
for i in range(n):
  update(i,0)
  ans.append(query(0,n,0,0,length))
  update(i,ls[i])
print(max(ans))

### FIXED CODE ###

from fractions import gcd
def gc(a,b):
  if a==0 or b==0:
    return max(a,b)
  else:
    return gcd(a,b)
n=int(input())
a=list(map(int,input().split()))
a=[0]+a+[0]
lgcd=[0]
rgcd=[0]
for i in range(1,n):
  lgcd.append(gc(a[i],lgcd[-1]))
  rgcd.append(gc(a[-i-1],rgcd[-1]))
GCD=0
for i in range(n):
  GCD=max(GCD,gc(lgcd[i],rgcd[-i-1]))
print(GCD)
a = map(int, input())
s = map(str, input())

if a>=3200:
  print(s)
else:
  print('red')

### FIXED CODE ###

a = int(input())
s = str(input())
 
if a>=3200:
  print(s)
else:
  print('red')
from math import factorial as f
n,k=[int(i) for i in input().split()]
d=[0]*n
for j in range(n-1):
  a,b=[int(i)-1 for i in input().split()]
  d[a]+=1
  d[b]+=1
m=1000000007
l=k*int(f(k-1)/f(k-d[0]))%m
for i in d[1:]:
  l=l*int(f(k-2)/f(k-i-1))%m
print(l)


### FIXED CODE ###

import sys
sys.setrecursionlimit(1000000)
def input():
    return sys.stdin.readline()
n, k = [int(i) for i in input().split()]
e = [[] for _ in range(n)]
for _ in range(n - 1):
    a, b = [int(i) for i in input().split()]
    a -= 1
    b -= 1
    e[a].append(b)
    e[b].append(a)
ans = 1
mod = 10**9+7


def dfs(i=0, r=-1):
    global ans
    if r == -1:
        ans *= k
        ans %= mod

        p = k-1
        for j in e[i]:
            if j == r:
                continue
            ans *= p
            ans %= mod
            p -= 1
            dfs(j, i)
    else:
        p = k-2
        for j in e[i]:
            if j == r:
                continue
            ans *= p
            ans %= mod
            p -= 1
            dfs(j, i)


dfs()
print(ans)
k = int(input())
a,b = map(int,input().split())
for i in range(a,b):
  if i % k == 0:
    ans = 'OK'
    break
  else:
    ans = 'NG'
print(ans)

### FIXED CODE ###

k = int(input())
a, b = map(int, input().split())
p = a % k
q = k - p
if (p == 0) or ((a + q) <= b):
    print('OK')
else:
    print('NG')
n = int(input())
a = [int(input()), for _ in range(n)]

for i in range(n):
  tmp = a
  tmp[i-1] = 0
  print(max(tmp))
  tmp = a

### FIXED CODE ###

n = int(input())
a  =[]
for i in range(n):
  x = int(input())
  a.append(x)
ma = max(a)
b = sorted(a)
for i in range(n):
  if a[i] != ma:
    print(ma)
  else:
    print(b[-2])
import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import dijkstra

def resolve():
    N, M = map(int, input().split())
    G = np.zeros((N + 1, N + 1), dtype=np.int64)

    for _ in range(M):
        x, y = map(int, input().split())
        G[x, y] += 1
        G[y, x] += 1
    csr = csr_matrix(G)
    dist, pred = dijkstra(csgraph=csr, indices=1, return_predecessors=True, directed=False)

    ans = pred[2:]
    impos = any(ans >= 0)
    if impos:
        print("Yes")
        print(*ans, sep="\n")
    else:
        print("No")

if __name__ == "__main__":
    resolve()

### FIXED CODE ###


from collections import deque
def resolve():
    N, M = map(int, input().split())
    G = [[] for _ in range(N)]
    for _ in range(M):
        x, y = map(lambda x:int(x)-1, input().split())
        G[x].append(y)
        G[y].append(x)

    dist = [-1]*N
    ans = [0]*N
    q = deque()
    q.append(0)
    while q:
        fm = q.popleft()
        for to in G[fm]:
            if dist[to] != -1:
                continue
            dist[to] += 1
            ans[to] = fm
            q.append(to)

    print("Yes")
    for i in range(1, N):
        print(ans[i] + 1)
        
if __name__ == "__main__":
    resolve()
a = 0
o = ""
while True:
  s = raw_input()
  if s == "=":
    break
  if s in ["+", "-", "*", "/"]:
    o = s
  else:
    a = eval(str(a) + o + s)
print a

### FIXED CODE ###

(a, o) = ("", "")
while True:
  s = raw_input()
  if s == "=":
    break
  if s in ["+", "-", "*", "/"]:
    o = s
  else:
    a = eval(str(a) + o + s)
print a
#coding: utf-8

print(24 - M + 24)

### FIXED CODE ###

#coding: utf-8

a = int(input())

print(24 - a + 24)
N, M = map(int, input().split())
a = [int(input()) for _ in range(M)]
def fibo(i):
    c, b = 1, 0
    while i > 0:
        c, b = c + b, c
        i -= 1
    return c
m = a[0] + 1
num = fibo(m - 2)
for i in range(M - 1):
    m = a[i + 1] - a[i]
    if m > 1:
        num = num * fibo(m - 2)
    elif m == 1:
        num = 0
        break
num = num * fibo(N - a[M - 1] - 1)
print(num % 1000000007)


### FIXED CODE ###

N, M = map(int, input().split())
kaidan = [0] * (N + 1)
for i in range(M):
    tmp = int(input())
    kaidan[tmp] = -1
kaidan[0] = 1
for i in range(1,N + 1):
    if i == 1:
        if kaidan[i] != -1:
            kaidan[i] = 1
        else:
            kaidan[i] = 0
    else:
        if kaidan[i] != -1:
            kaidan[i] = kaidan[i -1] + kaidan[i - 2]
        else:
            kaidan[i] = 0
print(kaidan[N] % (10 ** 9 + 7))
n=int(input())
sum=0

for i in range(n+1):
  if i%3==1 or i%3==2:
    if i%5==1 or i%5==2 or i%5==3 or i%5==4:
      sum+=i
print sum


### FIXED CODE ###

n=int(input())
sum=0

for i in range(1,n+1):
  if i%3!=0 and i%5!=0:
    sum+=i
print(sum)
MAX = 2*10**5
def popcount(x):
    '''xの立っているビット数をカウントする関数
    (xは64bit整数)'''

    # 2bitごとの組に分け、立っているビット数を2bitで表現する
    x = x - ((x >> 1) & 0x5555555555555555)

    # 4bit整数に 上位2bit + 下位2bit を計算した値を入れる
    x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)

    x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f # 8bitごと
    x = x + (x >> 8) # 16bitごと
    x = x + (x >> 16) # 32bitごと
    x = x + (x >> 32) # 64bitごと = 全部の合計
    return x & 0x0000007f
s_map = [0 for i in range(MAX+1)]
def solve(n):
    if n == 0:
        return 1
    if s_map[n] > 0:
        return s_map[n]
    s_map[n] = 1 + solve(n % popcount(n))
    return s_map[n]

N = int(input())
X = input()
num_x = int(X, 2)
p_cnt = X.count('1')
for i in range(N):
    c_p_cnt = p_cnt+1 if X[i] == '0' else p_cnt-1
    x = num_x + 2**(N-1-i) if X[i] == '0' else num_x - 2**(N-1-i)
    print(solve(x % c_p_cnt))



### FIXED CODE ###

def popcount(x):
    return bin(x).count("1")
def solve(n):
    if n == 0:
        return 0
    return 1+solve(n % popcount(n))

N = int(input())
X = input()
num_x = int(X, 2)
p_cnt = X.count('1')
if p_cnt == 1:
    for i in range(N):
        if X[i] == '1':
            print(0)
        elif i == N-1:
            print(2)
        else:
            print(1)
    exit()
r0_p = num_x % (p_cnt+1)
r0_m = num_x % (p_cnt-1)
for i in range(N):
    if X[i] == '0':
        c_p_cnt = p_cnt+1
        r = (r0_p + pow(2, (N - 1 - i), c_p_cnt)) % c_p_cnt
    else:
        c_p_cnt = p_cnt-1
        if c_p_cnt == 0:
            print(0)
            continue
        r = (r0_m- pow(2, (N - 1 - i), c_p_cnt)) % c_p_cnt
    print(1 + solve(r % c_p_cnt))
def main():
    
    N = input()
    a = [input() for y in range(N)]
    a_max = -10**9
    for i in xrange(1,len(a)):
        if (max(a[(i+1):]) - a[i]) >= a_max:
            a_max = max(a[(i+1):]) - a[i]
    return a_max

main()

### FIXED CODE ###

def main():
    N = input() 
    a = [input() for y in range(N)] 
    a_max = -10**9
    a_min = a[0]
    for j in xrange(1,len(a)):
        if a[j] - a_min > a_max:
            a_max = a[j] - a_min
        if a[j] < a_min:
            a_min = a[j]
    print a_max
main()
from fractions import gcd

A, B, K = [int(i) for i in input()]

count = 0
for i in range(gcd(a, b), 0, -1):
    if A % i == 0 and B % i == 0:
        count += 1
        if count == K:
            print(i)
            break


### FIXED CODE ###

from fractions import gcd

A, B, K = [int(i) for i in input().split()]

count = 0
for i in range(gcd(A, B), 0, -1):
    if A % i == 0 and B % i == 0:
        count += 1
        if count == K:
            print(i)
            break
def c_guess_the_number():
    N, M = [int(i) for i in input().split()]
    Conds = [[int(i) for i in input().split()] for j in range(M)]

    digit = [-1] * N
    # 同じ桁に異なる数字を割り当てている場合を検出
    for s, c in Conds:
        if digit[s - 1] not in (-1, c):
            return -1
        digit[s - 1] = c

    # N 桁目に 0 を割り当てなければならない場合
    # 基本的に N+1 桁の数となり矛盾するが、例外的に N = 1 だと 0 とすればよい。
    if digit[0] == 0:
        return -1 if N >= 2 else 0

    # 指定されなかった桁は基本的に 0 とすればよいが、N 桁目は 0 にできない。
    # 例外的に、N = 1, M = 0 だと N 桁目も 0 にできる。
    if N == 1 and M == 0:
        return 0
    for d, value in enumerate(digit):
        if value == -1:
            digit[d] = 0 if d != 0 else 1
    return ''.join(map(str, digit))

print(c_guess_the_number())

### FIXED CODE ###

A = [[int(i) for i in input().split()] for j in range(3)]
N = int(input())
B = [int(input()) for j in range(N)]

for b in B:
    for row in range(3):
        for col in range(3):
            if A[row][col] == b:
                A[row][col] = 0

cond = [
    A[0][0] == A[0][1] and A[0][1] == A[0][2],
    A[1][0] == A[1][1] and A[1][1] == A[1][2],
    A[2][0] == A[2][1] and A[2][1] == A[2][2],
    A[0][0] == A[1][0] and A[1][0] == A[2][0],
    A[0][1] == A[1][1] and A[1][1] == A[2][1],
    A[0][2] == A[1][2] and A[1][2] == A[2][2],
    A[0][0] == A[1][1] and A[1][1] == A[2][2],
    A[0][2] == A[1][1] and A[1][1] == A[2][0]
]
print('Yes' if any(cond) else 'No')
N = int(input())
A = list(map(int, input().split()))
         
import math
from functools import reduce

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

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

print(gcd_list(A))
# 3

### FIXED CODE ###

import functools
import math
import fractions

N = int(input())
A = list(map(int, input().split()))
         
a = functools.reduce(fractions.gcd, A)
print(a)
n=int(input)
ans = 1
while pow(ans,2) <= n:
  ans += 1
print(pow(ans-1,2))

### FIXED CODE ###

n=int(input())
ans = 1
while ans**2 <= n:
  ans += 1
ans -= 1
print(ans**2)
K = input()
try:
  if 0 > int(K) or int(K) >= 100:
    print("K's value must be over 1 and under 100")
    exit()
except ValueError:
  print("K's value must be integer")
  exit()

S = input()
if 1 > len(S) or 100 < len(S):
  print("S's length must be over 1 and under 100")
  exit()
  
if len(S) <= int(K):
  print(S)
else:
  S = S[:K]
  S.append('...')
  print(S)
  

### FIXED CODE ###

K = input()
S = input()

   
if len(S) <= int(K):
  print(S)
else:
  S = S[:int(K)]
  S += '...'
  print(S)
a = input().split()
b = input().split()
c = a[0] * b[1]
d = a[1] * b[0]
print(a[0] * a[1] - (c + d - b[0] * b[1]))

### FIXED CODE ###

a = input().split()
b = input().split()
a = list(map(int, a))
b = list(map(int, b))
c = a[0] * b[1]
d = a[1] * b[0]
print(a[0] * a[1] - (c + d - b[0] * b[1]))
arr = [e, d, c, b, a]
leng_arr = []
for i in range(len(arr)):
  for j in range(4-i):
    leng = arr[i]-arr[j+1]
    leng_arr.append(leng)
    
if all([i =< k for i in leng_arr]):
  print('Yay')
else:
  print(':(')
  

  

### FIXED CODE ###

A = [int(input()) for i in range(5)]
K = int(input())

if (A[-1]-A[0] <= K):
    print("Yay!")
else:
    print(":(")
N = int(input())
C0 = 0
C1 = 0
C2 = 0
C3 = 0

for A in N :
    str = input()
    if str == 'AC' :
        C0 += 1
    if str == 'WA' :
        C1 += 1
    if str == 'TLE':
        C2 += 1
    if str == 'RE' :
        C3 += 1

print('AC x ' + str(C0))
print('WA x ' + str(C1))
print('TLE x ' + str(C2))
print('RE x ' + str(C3))


### FIXED CODE ###

N = int(input())
for A in range(11) :
    if A * 1000 >= N :
        break
oturi = A * 1000 - N
print(oturi)
N = int(input())
X = input()
S = []
for a in range(N):
    S.append(X[a])
if N == 1:
    print(S)
else:
    
    for i in range(N-1):
        if S[i] != S[i+1] or S[i] == 'X':
            continue
        else:
            j = i+1
        while S[i] == S[j]:
            j += 1
            for l in range(i+1,j):
                S[l] = 'X'
lista = [k for k in S if k != 'X']
print(''.join(lista))

### FIXED CODE ###

N = int(input())
X = input()
S = []
for a in range(N):
    S.append(X[a])

if N == 1:
    print(1)
else:
    for i in range(1,N):
        if S[i] != S[i-1]:
            continue
        else:
            S[i-1] = 'X'
    lista = [k for k in S if k != 'X']
    print(len(lista))
#dp[i][j]:S[i-x:i]==S[j-x:j]となる最大のx
import numpy as np

def solve(N, S, dp):
    for i in range(N - 1):
        for j in range(i + 1, N):
            dp[i][j] = min(j - i, dp[i - 1][j - 1] + 1) if S[i] == S[j] else 0
    return dp.max()

def main():
    N = int(input())
    S = np.array([ord(_) for _ in input()])
    dp = np.zeros((N + 1, N + 1), dtype=np.int)
    print(solve(N, S, dp))

def cc_export():
    from numba.pycc import CC
    cc = CC('my_module')
    cc.export('solve', '(i8[:],)')(solve)
    cc.compile()

if __name__ == '__main__':
    import sys
    if sys.argv[-1] == 'ONLINE_JUDGE':
        cc_export()
        exit(0)
    from my_module import solve
    main()


### FIXED CODE ###

import itertools
N = int(input())
S = input()
dp = [[0] * N for _ in range(N)]
ans = 0
for i, j in itertools.combinations(range(N), 2):
    if S[i] == S[j]:
        dp[i][j] = dp[i - 1][j - 1] + 1
    else:
        dp[i][j] = 0
    ans = max(ans, min(j - i, dp[i][j]))
print(ans)
a = int(input())

b = []

for i in a*2:
    b.append(input())

res = 0

num = a.pop(0) * 2

for i in range(b):
    if (b[i] == 'BTC'):
        c = int(a[i-1]) * 380000
        res += c
    elif (b[i] == 'JPY'):
        res += int(b[i-1])
    else:
        pass

print(res) 

### FIXED CODE ###

a = int(input())

b = []

for i in range(a):
    b.append(input().split())

res = 0

for i in b:
    if (i[1] == 'BTC'):
        res += float(i[0])*380000
    else:
        res += int(i[0])

print(res)
from collections import deque
n, k = map(int,input().split())
a = list(map(int,input().split()))
mod = 10 ** 9 + 7

p = []
m = []
for i in a:
    if i > 0:p.append(i)
    elif i < 0:p.append(i)

flag = 0
if len(p) < k:
    flag = 1
    p, m = m, p

p.sort(reverse=True)
m.sort()
double = []
    
for i in range(len(p) - 1):
    if i % 2 == 0:
        temp = p[i] * p[i + 1]
        double.append([temp, 1])
for i in range(len(m) - 1):
    if i % 2 == 0:
        temp = m[i] * m[i + 1]
        double.append([temp, 2])

if p[0] < 0:
    double.sort()
else:
    double.sort(reverse=True)

res = 1
p = deque(p)
m = deque(m)
double = deque(double)
while k:
    if double and k - 2 >= 0:
        temp, ind = double.popleft()
        if ind == 1:
            p.popleft()
            p.popleft()
        else:
            m.popleft()
            m.popleft()
        res = (res * temp) 
        k -= 2
    else:
        if not flag:
            if p:
                res = (res * p.popleft()) 
            else:
                res = (res * m.pop()) 
        else:
            if not m:
                res = (res * p.popleft())
            else:
                temp1 = m.popleft()
                temp2 = p.popleft()
                if temp1 <= -temp2:
                    res = (res * temp1)
                    p.appendleft(temp2)
                else:
                    res = (res * temp2)
                    m.appendleft(temp1)
        k -= 1
        
print(res%mod)

### FIXED CODE ###

from collections import deque
n, k = map(int,input().split())
a = list(map(int,input().split()))
mod = 10 ** 9 + 7

p = []
m = []
for i in a:
    if i >= 0:p.append(i)
    elif i < 0:m.append(i)

p.sort(reverse=True)
m.sort()
res = 1
if n == k:
    for i in a:
        res = (res * i) %mod
    print(res)
    exit()
    
if len(p) == 0 and k % 2 == 1:
    for i in range(k):
        res = (res * m[-(i + 1)]) %mod
    print(res)

else:
    p_ind = 0
    m_ind = 0
    while k:
        if k == 1:
            res = (res * p[p_ind]) % mod
            break
        
        temp = p[p_ind] * p[p_ind + 1] if p_ind + 1 < len(p) else 0
        temp1 = m[m_ind] * m[m_ind + 1] if m_ind + 1 < len(m) else 0
        if temp > temp1:
            res = (res * p[p_ind]) %mod
            p_ind += 1
            k -= 1
        else:
            res = (res * temp1) %mod
            m_ind += 2
            k -= 2
    print(res)
import sys
N, K = map(int, input().split()) #N: 町の数, K: ちょうどこの回数でたどり着く町

visited = [False for _ in range(N)]

A = list(map(lambda n: int(n)-1, input().split()))
tmp = 0 #次に訪れる番号
visited[0] = True
#cnt = 0 #テレポートの回数
log = [0] #テレポートの記録

for i in range(1, K+1):
    tmp = A[tmp]
    if visited[tmp]:
        start = log.index(tmp)
        break

    visited[tmp] = True
    log.append(tmp)

if i == K:
    print(log[K])
else:
    loop = log[start:i+1]
    period = len(loop)
    remain = K - i
    print(loop[remain%period] + 1)   

### FIXED CODE ###

import sys
N, K = map(int, input().split()) #N: 町の数, K: ちょうどこの回数でたどり着く町

visited = [False for _ in range(N)]

A = list(map(lambda n: int(n)-1, input().split()))
tmp = 0 #次に訪れる番号
visited[0] = True
#cnt = 0 #テレポートの回数
log = [0] #テレポートの記録

for i in range(1, K+1):
    tmp = A[tmp]
    if visited[tmp]:
        start = log.index(tmp)
        break

    visited[tmp] = True
    log.append(tmp)

if i == K:
    print(tmp+1)
else:
    loop = log[start:i+1]
    period = len(loop)
    remain = K - i
    print(loop[remain%period] + 1)
H, N = map(int, input().split())
x = [list(map(int, input().split())) for n in range(N)]
x = [[tmp[i] for tmp in x] for i in range(len(x[0]))]
A = x[0]
B = x[1]

memo = [-1] * (H + 1)

def ibis(H):
    if memo[H] >= 0:
        return memo[H]
    if H <= 0:
        return 0
    mp = []
    for n in range(N):
        mp.append(B[n] + ibis(H - A[n]))
    memo[H] = min(mp)
    return memo[H]

print(ibis(H))


### FIXED CODE ###

H, N = map(int, input().split())
x = [list(map(int, input().split())) for n in range(N)]
x = [[tmp[i] for tmp in x] for i in range(len(x[0]))]
A = x[0]
B = x[1]

def ibis(H, A, B):
    dp = [max(B) * H] * (H + 1)
    dp[0] = 0
    for h in range(H):
        for n in range(N):
            hp = min(h + A[n], H)
            dp[hp] = min(dp[hp], dp[h] + B[n])
    return dp[H]

print(ibis(H, A, B))
x = int(input())
if x == 7:
  ans = 'YES'
elif x == 5:
  ans = 'YES
elif x == 3:
  ans = 'YES'
else:
  ans = 'NO'
print(ans)
    

### FIXED CODE ###

x = int(input())
if x == 7:
  ans = 'YES'
elif x == 5:
  ans = 'YES'
elif x == 3:
  ans = 'YES'
else:
  ans = 'NO'
print(ans)