Harryxun/stf_run huggingface dataset:
import math
lst = []
for i in range(5):
  lst.append(int(input()))
minu = 9
temp = 0
for j in range(5):
  if int(str(lst[j])[-1]) < minu and int(str(lst[j])[-1]) > 0:
    minu = int(str(lst[j])[-1])
    temp = lst[j]
lst.remove(temp)
time = 0
for k in range(4):
  time += math.ceil(lst[k]/10) * 10
time += temp
print(time)


### FIXED CODE ###

import math
lst = []
for i in range(5):
  lst.append(int(input()))
minu = 9
temp = 0
count = 0
for j in range(5):
  if int(str(lst[j])[-1]) < minu and int(str(lst[j])[-1]) > 0:
    minu = int(str(lst[j])[-1])
    temp = lst[j]
    count += 1
if count > 0:
  lst.remove(temp)
else:
  temp = lst[0]
  del lst[0]
time = 0
for k in range(4):
  kari = math.ceil(int(lst[k])/10)
  time += int(kari * 10)
time += temp
print(time)
x = input()
if (x % 2 == 0):
  y = x // 2
else:
  y = x//2 + 1

print(y)

### FIXED CODE ###

x = int(input())
if (x % 2 == 0):
  y = x // 2
else:
  y = x//2 + 1

print(y)
H, W = map(int, input().split)
if (H + W) %2 == 0:
  print((H + W) /2)
else:
  preint((H + W -1) /2 +1)

### FIXED CODE ###

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

if H == 1 or W == 1:
  print(1)
elif (H*W)%2 == 0:
  print(int((H*W)/2))
else:
  print(int((H*W-1)/2 + 1))
n,q=map(int,input().split())
s=input()
V=[0]*n
X=[]
for i in range(q):
    l,r=map(int,input().split())
    X.append([l,r])

for i in range(n-1):
    if s[i:i+2]=='AC':
        V[i]+=1

for i in range(q):
    ans=sum(V[X[i][0]-1:X[i][1]])
    if s[X[i][1]-1]=='A' and s[X[i][1]]=='C':
        ans-=1
    print(ans)

### FIXED CODE ###

n,q=map(int,input().split())
s=input()+'Z'
A=[0]*(n+1)
cnt=0
for i in range(n):
    A[i]=cnt
    if s[i]=='A' and s[i+1]=='C':
        cnt+=1
ANS=[]
for i in range(q):
    l,r=map(int,input().split())
    ANS.append(A[r-1]-A[l-1])
for ans in ANS:
    print(ans)
a, b = map(int, input().split())
if a > b:
    print(str(a) + " > " + str(b))
if a < b:
    print(str(a) + " < " + str(b))
if:
    print(str(a) + " == " + str(b))


### FIXED CODE ###

a, b = map(int, input().split())
if a > b:
    print("a > b")
elif a < b:
    print("a < b")
else:
    print("a == b")
a, b, c = map(int, input().split())

result = "NO"
for i in range(1, 100):
    if a * i % b == c:
        result = "YES"
print(result)


### FIXED CODE ###

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

if a[-1] == b[0] and b[-1] == c[0]:
    print("YES")
else:
    print("NO")
import itertools

x1 = input()
x2 = input()
RGB = {"R", "G", "B"}
_sum = 0
for i, rgb in zip(itertools.combinations(range(x1), 3), itertools.combinations(x2, 3)):
    if set(rgb) == RGB and (i[1] - i[0]) != (i[2] - i[1]):
        _sum += 1
print(_sum)

### FIXED CODE ###

from itertools import product

x1 = int(input())
x2 = input()

R_i = [i for i, x in enumerate(x2) if x == "R"]
G_i = [i for i, x in enumerate(x2) if x == "G"]
B_i = {i for i, x in enumerate(x2) if x == "B"}

R = len(R_i)
G = len(G_i)
B = len(B_i)

xs = map(sorted, product(R_i, G_i))

s = 0
for a in xs:
    k = a[1]*2 - a[0]  # 2j-i
    if k in B_i:
        s +=1
    i = a[0]*2 - a[1]  # 2j-k
    if i in B_i:
        s +=1
    j = (a[0] + a[1]) / 2
    if j.is_integer():
        j = int(j)
        if j in B_i:
            s +=1
print(R*G*B - s)
from bisect import bisect_left
N = int(input())
*A, = map(int, input().split())
A.sort()
m = A[-1]
x = m / 2
print(m, min(abs(x - A[bisect_left(A, x)]), abs(x - A[bisect_left(A, x) + 1])))

### FIXED CODE ###

N = int(input())
*A, = map(int, input().split())
A.sort()
m = A[-1]
x = m / 2
ans = A[0]
for i in range(1, N-1):
    if abs(ans - x) > abs(A[i] - x):
        ans = A[i]
print(m, ans)
a=int(input())
moji=input()
r=[]
g=[]
b=[]
for i in range(a):
    if moji[i]=="R":
        r.append(i)
    elif moji[i]=="G":
        g.append(i)
    elif moji[i]=="B":
        b.append(i)
res=len(r)*len(g)*len(b)
if len(r)==0 or len(g)==0 or len(b)==0:
    print(0)
else:
    min_len={len(r):r,len(g):g,len(b):b}
    tmp=list(min_len.keys()).sort()
    r=min_len[tmp[0]]
    g=min_len[tmp[1]]
    b=min_len[tmp[2]]
    for i in r:
        for j in g:
            if -abs(i-j)+min(i,j) in b:
                res-=1
            if abs(i-j)+max(i,j) in b:
                res-=1
            if abs(i-j)%2==0 and  int(abs(i-j)/2)+min(i,j) in b:
                res-=1
    print(res)

### FIXED CODE ###

a=int(input())
moji=input()
r=[]
g=[]
b=[]
for i in range(a):
    if moji[i]=="R":
        r.append(i)
    elif moji[i]=="G":
        g.append(i)
    else:
        b.append(i)
res=len(r)*len(g)*len(b)
if len(r)==0 or len(g)==0 or len(b)==0:
    print(0)
else:
    for i in range(0,a-2):
      for j in range(i+1,a-1):
        if 2*j-i<a and moji[i]!=moji[j] and moji[j]!=moji[2*j-i] and moji[2*j-i]!=moji[i]:
          res-=1
    print(res)
INF=10**18
N,M,L=map(int,input().split())
d=[[INF for i in range(N)] for j in range(N)]
for i in range(N):
    d[i][i]=0
for m in range(M):
    A,B,C=map(int,input().split())
    d[A-1][B-1]=C
    d[B-1][A-1]=C

for k in range(N):
    for i in range(N):
        for j in range(N):
            d[i][j]=min(d[i][j],d[i][k]+d[k][j])
for i in range(N):
        for j in range(N):
            if d[i][j]<=L:
                d[i][j]=1
for k in range(N):
    for i in range(N):
        for j in range(N):
            d[i][j]=min(d[i][j],d[i][k]+d[k][j])
ans=[]
Q=int(input())
for i in range(Q):
    s,t=map(int,input().split())
    dis=d[s-1][t-1]
    if dis==INF:
        ans.append(-1)
    else:
        ans.append(dis-1)

for a in ans:
    print(int(a))


### FIXED CODE ###

INF=10**15
N,M,L=map(int,input().split())
d=[[INF for i in range(N)] for j in range(N)]
d1=[[INF for i in range(N)] for j in range(N)]
for i in range(N):
    d[i][i]=0
for m in range(M):
    A,B,C=map(int,input().split())
    d[A-1][B-1]=C
    d[B-1][A-1]=C

for k in range(N):
    for i in range(N):
        for j in range(N):
            d[i][j]=min(d[i][j],d[i][k]+d[k][j])
for i in range(N):
        for j in range(N):
            if i!=j and d[i][j]<=L:
                d1[i][j]=1
                d1[j][i]=1
for k in range(N):
    for i in range(N):
        for j in range(N):
            d1[i][j]=min(d1[i][j],d1[i][k]+d1[k][j])

Q=int(input())
for _ in range(Q):
    s,t=map(int,input().split())
    dis=d1[s-1][t-1]
    if dis==INF:
        print(-1)
    else:
        print(dis-1)
a=int(input())
b=int(input())

x=(a+b)/2
if x%1==0:
    print(int(x))
else:
    print(int(x)+1)
  

### FIXED CODE ###

a,b=map(int,input().split()) #入力を改行ではなくてスペース1マスあける

x=(a+b)/2
if x%1==0:
    print(int(x))
else:
    print(int(x)+1)
import numpy as np

MOD = 10**9 + 7
n, k = map(int, input().split())
a = np.array(list(map(int, input().split())))
ans = 1
plus = a[a >= 0]
plus = np.sort(plus)[::-1]
plus = np.append(plus, [-np.inf, np.inf])
minus = a[a < 0]
minus = np.sort(minus)
minus = np.append(minus, [np.inf, -np.inf])
if len(plus) == 2 and k % 2 == 1:
    for i in range(3, k + 3):
        ans *= minus[-i]
        ans %= MOD
else:
    c = 0
    cplus = 0
    cminus = 0
    while c < k - 1:
        if plus[cplus] * plus[cplus + 1] > minus[cminus] * minus[cminus + 1]:
            ans *= plus[cplus]
            ans %= MOD
            cplus += 1
            c += 1
        else:
            ans *= minus[cminus] * minus[cminus + 1]
            ans %= MOD
            cminus += 2
            c += 2
    if c == k - 1:
        ans *= plus[cplus]
        ans %= MOD
print(int(ans))




### FIXED CODE ###

    #n,k,*a=map(int,open(0).read().split())
n, k = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
a.sort()
mod=10**9+7
ans=1
i=0
j=-1
kk=k
while kk>1:
    if a[i]*a[i+1]>a[j]*a[j-1]:
        ans=ans*a[i]*a[i+1]%mod
        i+=2
        kk-=2
    else:
        ans=ans*a[j]%mod
        j-=1
        kk-=1
if kk==1:
    ans=ans*a[j]%mod

if a[-1]<0 and k%2==1:
    ans=1
    for i in a[n-k:]:
        ans=ans*i%mod
print(ans)
n = int(input())
h = input().split()

ans = 1
m = n - 1
high = int(h[0])

for i in range(m):
  if int(h[i+1]) >= high:
    ans += 1
    high = int(h[i+1])
   else:
    continue

print(ans)

### FIXED CODE ###

n = int(input())
h = input().split()
 
ans = 1
m = n-1
high = int(h[0])
 
for i in range(m):
    if int(h[i+1]) >= high:
        ans += 1
        high = int(h[i+1])
    else:
        continue
        
 
print(ans)
w,a,b=map(int,input().split())
x,y=a+w,a-w
print(0 if x<b<y else min(abs(x-b,y-b)))

### FIXED CODE ###

w,a,b=map(int,input().split())
print(0 if a<=b+w and b<=a+w else min(abs(a+w-b),abs(a-w-b)))
def main():
  n = int(input())
  a = list(map(int, input().split()))
  ans = [0] * 10**5
  for i in a:
    ans[i] += 1
    ans[i+1] += 1
    ans[i+2] += 1
  print(max(ans))

main()

### FIXED CODE ###

def main():
  n = int(input())
  a = list(map(int, input().split()))
  ans = [0] * (10**5+2)
  for i in a:
    ans[i] += 1
    ans[i+1] += 1
    ans[i+2] += 1
  print(max(ans))

main()
s1, s2, s3 = map(int,input().split())
sum = s1 + s2 + s3

print(sum)
    

### FIXED CODE ###

s = input()

s1 = int(s[0])
s2 = int(s[1])
s3 = int(s[2])

print(str(s1+s2+s3))
div = ["dream", "dreamer", "erase", "eraser"]
rev = []
t = ""
s_rev = s[::-1]
for d in div:
    rev.append(d[::-1])

result = True
i = 0
while i < len(s):
    print(i)
    can_divide = False
    for d in rev:
        if s_rev[i:i + len(d)] == d:
            can_divide = True
            i += len(d)
    if not can_divide:
        result = False
        break

print("YES" if result else "NO")

### FIXED CODE ###

s = input()
t = ""
while len(t) < len(s):
    target_len = len(s) - len(t)

    if s[len(t)] == 'd':
        if target_len == 5:
            t += "dream"
        elif target_len == 7:
            t += "dreamer"
        elif target_len > 7:
            if s[len(t) + 5] != 'd' and s[len(t) + 5:len(t) + 7 + 1] != "era":
                t += "dreamer"
            else:
                t += "dream"
        else:
            break
    else:
        if target_len == 5:
            t += "erase"
        elif target_len == 6:
            t += "eraser"
        elif target_len > 6:
            if s[len(t) + 5] != 'd' and s[len(t) + 5:len(t) + 6 + 2] != "era":
                t += "eraser"
            else:
                t += "erase"
        else:
            break

    if s[0:len(t)] != t:
        break

print("YES" if s == t else "NO")
N, M = list(map(int, input().split()))
a_list = sorted(list(map(int, input().split())))
b_c_list = []
for _ in range(M):
    b, c = list(map(int, input().split()))
    b_c_list.append((b, c))
b_c_list = sorted(b_c_list, key=lambda x: x[1], reverse=True)

def b_c_gen():
    for b, c in b_c_list:
        for _ in range(b):
            yield c

def a_gen():
    while True:
        yield a_list.pop(0)

total = 0
for a, c in zip(a_gen(), b_c_gen()):
    if a >= c:
        break
    total += c

a_list.append(a)

total += sum(a_list)
print(total)


### FIXED CODE ###

N, M = list(map(int, input().split()))
a_list = sorted(list(map(int, input().split())))
b_c_list = []
for _ in range(M):
    b, c = list(map(int, input().split()))
    b_c_list.append((b, c))
b_c_list = sorted(b_c_list, key=lambda x: x[1], reverse=True)

def b_c_gen():
    for b, c in b_c_list:
        for _ in range(b):
            yield c

total = 0
for i, c in enumerate(b_c_gen()):
    if i >= N:
        break
    if a_list[i] >= c:
        i -= 1
        break
    total += c
i += 1

if i < N:
    total += sum(a_list[i:])
print(total)
N, D = map(int, input().split())
A=N//2D+1
print(A)

### FIXED CODE ###

N, D = map(int, input().split())
B=2*D+1
if N % B == 0:
  A=N//B
else:
  A=N//B+1
print(A)
N = int(input())
S = input()
ans = 0
for i in range(10):
  l = 0
  while(True):
    if(i == int(S[l])):
      for j in range(10):
        m = l + 1
        while(True):
          if(j == int(S[m])):
            for k in range(10):
              for n in range(m+1, N):
                if(k == int(S[n])):
                  ans += 1
                  break
          m += 1
          if(m >= N - 1 or j == int(S[m - 1])):
             break
    l += 1
    if(l >= N - 2 or i == int(S[l - 1])):
      break
print(ans)

### FIXED CODE ###

M1, D1 = input().split()
M2, D2 = input().split()
if(M1 != M2):print(1)
else: print(0)
import sys
N, K = map(int, input().split())
s = input()
  
group = []
sign = s[0]
curr = 0
for i in range(N):
  curr += 1
  if s[i] != sign: 
    group += [curr-1]
    curr = 1
    sign = s[i]
else:group += [curr]

if s[0] == '0' :
  if s[N-1] == '0':
    m = (len(group)+1)//2
    if K >= m:
      print(N)
      sys.exit()
    score = [sum(group[:2*K])]
    for i in range(m-K):
      score += [score[-1] - group[2*i] + group[2*i+2*K]]
  else :
    m = (len(group)+1)//2
    if K >= m:
      print(N)
      sys.exit()
    score = [sum(group[:2*K])]
    for i in range(m-K):
      score += [score[-1] - group[2*i] + group[2*i+2*K]]
    score[-1] += group[-1]
else:
  0/0
  m = len(group)//2
  group += [0]
  if K >= m:
    print(N)
    sys.exit()
  score = [sum(group[:2*K+1])]
  for i in range(m-K):
    score += [score[-1] - group[2*i] - group[2*i+1] + group[2*i+2*K+1]+group[2*i+2*K +2]]

print(max(score))

### FIXED CODE ###

a,b = map(int,input().split())
if a == b:
  print(2*a)
else:
  print(2*max(a,b)-1)
#include <bits/stdc++.h>
using namespace std;

int main() {
    int N,K;
    cin >> N >> K;
    // 初期値とKを比較 小さい方を足す
    int num = 1;
    for (int i = 0; i < N; i++) {
        if (num <= K) {
            num *= 2;
        }
        else {
            num += K;
        }
    }
    cout << num << endl;
}

### FIXED CODE ###

N,K = [int(input()) for i in range(2)]
p = 1
for i in range(N):
  p = min(2*p,p+K)
print(p)
S = input()
N = int(input())
if N % sum(S) == 0:
    print("Yes")
else:
    print("No")

### FIXED CODE ###

N = int(input())
S = sum([int(n) for n in str(N)])
if N % S == 0:
    print("Yes")
else:
    print("No")
import sys

for x in sys.stdin.read().split():
    print len(str(x[0]+x[1])

### FIXED CODE ###

while True:
    try:
        a, b = map(int, raw_input().split())
        print len(str(a+b))
    except:
        break
class TreeNode(object):
    def __init__(self, val):
        self.container = []
        self.val = val
        self.counter = 0

    def concatenate(self, node):
        self.container.append(node)

    def getNodes(self):
        return self.container

def traverseAndIncrement(root, val):
    if root:
        root.counter += val
        for node in root.getNodes():
            traverseAndIncrement(node, val)

if __name__ == '__main__':
    N, Q = map(int, input().split())
    tree = {}
    for i in range(N):
        tree[i + 1] = TreeNode(i + 1)

    for _ in range(N - 1):
        parent, child = map(int, input().split())
        tree[parent].concatenate(tree[child])

    for _ in range(Q):
        root_idx, val = map(int, input().split())
        traverseAndIncrement(tree[root_idx], val)

    for idx in range(N):
        print(tree[idx + 1].counter, end=' ')

### FIXED CODE ###

from collections import deque

if __name__ == '__main__':
    N, Q = map(int, input().split())
    count = [0] * (N + 1)
    tree = [[] for _ in range(N + 1)]
    for _ in range(N - 1):
        a, b = map(int, input().split())
        tree[a].append(b)
        tree[b].append(a)

    for _ in range(Q):
        idx, val = map(int, input().split())
        count[idx] += val

    q = deque()
    q.append(1)

    is_valid = [1] * (N + 1)
    while q:
        idx = q.pop()
        is_valid[idx] = 0
        for t in tree[idx]:
            if is_valid[t] == 0: continue
            count[t] += count[idx]
            q.append(t)
    print(*count[1:])
a,b,c,d = map(int,input().split())
print(min(a+c,a+d,b+c,b+d))

### FIXED CODE ###

a = int(input())
b = int(input())
c = int(input())
d = int(input())
print(min(a+c,a+d,b+c,b+d))
n = list(map(int, input().split()))
s = [int(input()) for i in range(n[1])]
s.append(n[0]+1)
memo = [0] * 100000
def stairs(x):
    memo[0] = 1
    memo[1] = 1
    for i in range(2, x+1):
        memo[i] = memo[i-2] + memo[i-1]

salst = [s[0]-1]
for i in range(n[1]):
    sa = (s[i+1]-1) - (s[i]+1)
    salst.append(sa)
    if sa < 0:
        break
if salst[-1] < 0:
    print(0)
else:
    ans = 1
    maxnum = max(salst)
    stairs(maxnum)
    for l in salst:
        ans *= memo[l]
    print(ans%1000000007)


### FIXED CODE ###

n = list(map(int, input().split()))
s = [int(input()) for i in range(n[1])]
s.append(n[0]+1)
memo = [0] * 100001
def stairs(x):
    memo[0] = 1
    memo[1] = 1
    for i in range(2, x+1):
        memo[i] = memo[i-2] + memo[i-1]

salst = [s[0]-1]
for i in range(n[1]):
    sa = (s[i+1]-1) - (s[i]+1)
    salst.append(sa)
    if sa < 0:
        break
if salst[-1] < 0:
    print(0)
else:
    ans = 1
    maxnum = max(salst)
    stairs(maxnum)
    for l in salst:
        ans *= memo[l]
    print(ans%1000000007)
S=input()
T=S.replace("x","")
if all(s==t for s,t in zip(T,T[::-1])):
    ans=0
    i=0
    j=len(S)-1
    while i<j:
        pi=i
        pj=j
        while S[i]=="x":
            i+=1
        while S[j]=="x":
            j-=1
        ans+=abs(i-pi-j+pj)
        i+=1
        j-=1
    print(ans)
else:
    print(-1)

### FIXED CODE ###

S=input()
T=S.replace("x","")
if all(s==t for s,t in zip(T,T[::-1])):
    ans=0
    i=0
    j=len(S)-1
    while i<j:
        pi=i
        pj=j
        while i<len(S) and S[i]=="x":
            i+=1
        while j>=0 and S[j]=="x":
            j-=1
        if i>j:
            break
        ans+=abs(i-pi-pj+j)
        i+=1
        j-=1
    print(ans)
else:
    print(-1)
import math
def counter(A):
    cnt = 0
    for i,ai in enumerate(A):
        cnt += sum(a < ai for a in A[i+1:])
    return cnt
def counter_two(A):
    cnt = 0
    for i,ai in enumerate(A):
        cnt += sum(a < ai for a in A)
    return cnt
  

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

one_a = counter_one(A)
two_a = counter_two(A)

ans = (one_a*K)+((two_a)*(K*(K-1)//2))
print(int(ans%((10**9)+7)))  

### FIXED CODE ###

import math
def counter_one(A):
    cnt = 0
    for i,ai in enumerate(A):
        cnt += sum(a < ai for a in A[i+1:])
    return cnt
def counter_two(A):
    cnt = 0
    for i,ai in enumerate(A):
        cnt += sum(a < ai for a in A)
    return cnt
  

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

one_a = counter_one(A)
two_a = counter_two(A)

ans = (one_a*K)+((two_a)*(K*(K-1)//2))
print(int(ans%((10**9)+7)))
x = raw_input()
print x * x * x

### FIXED CODE ###

x = int(raw_input())
print x * x * x
import sys


stdin = sys.stdin
def ns(): return stdin.readline().rstrip()
def ni(): return int(stdin.readline().rstrip())
def nm(): return map(int, stdin.readline().split())
def nl(): return list(map(int, stdin.readline().split()))


def main():
    S = ns()
    A = []
    ans = 0
    for s in S:
        if s == 'R':
            ans += 1
        else:
            A.append(ans)
            ans = 0
    print(max(A))


if __name__ == '__main__':
    main()


### FIXED CODE ###

import sys


stdin = sys.stdin
def ns(): return stdin.readline().rstrip()
def ni(): return int(stdin.readline().rstrip())
def nm(): return map(int, stdin.readline().split())
def nl(): return list(map(int, stdin.readline().split()))


def main():
    S = ns()
    if S == 'RRR':
        print(3)
    elif S == 'RRS' or S == 'SRR':
        print(2)
    elif S == 'SSR' or S == 'SRS' or S == 'RSS' or S == 'RSR':
        print(1)
    else:
        print(0)


if __name__ == '__main__':
    main()
# coding: utf-8
N,K=map(int,input().split())
A=list(map(int,input().split()))
MOD=10**9+7

ans=1

if K==N:
    for i in range(N):
        ans*=A[i]
        if ans>0
            ans=ans%MOD
elif max(A)<0 and K%2==1:
    A.sort(reverse=True)
    for i in range(K):
        ans*=A[i]
        if ans>0
            ans=ans%MOD
else:
    Ap=[]
    Am=[]
    
    for i in range(N):
        if A[i]>0:
            Ap.append(A[i])
        else:
            Am.append(A[i])
        

    Ap.sort(reverse=True)
    Am.sort()
    
    if K%2==1:
        ans*=Ap.pop(0)
    
    if len(Ap)%2==1:
        Ap.append(1)
    
    P=[]
    
    for i in range(len(Ap)//2):
        P.append(Ap[i*2]*Ap[i*2+1]%MOD)
    
    for i in range(len(Am)//2):
        P.append(Am[i*2]*Am[i*2+1]%MOD)
    
    P.sort(reverse=True)
    
    for i in range(K//2):
        ans*=P[i]
        ans=ans%MOD

print(ans%MOD)

### FIXED CODE ###

# coding: utf-8
N,K=map(int,input().split())
A=list(map(int,input().split()))
MOD=10**9+7

ans=1

if K==N:
    for i in range(N):
        ans*=A[i]
        if ans>0:
            ans=ans%MOD
elif max(A)<=0 and K%2==1:
    A.sort(reverse=True)
    for i in range(K):
        ans*=A[i]
        if ans>0:
            ans=ans%MOD
else:
    Ap=[]
    Am=[]
    
    for i in range(N):
        if A[i]>0:
            Ap.append(A[i])
        else:
            Am.append(A[i])
        

    Ap.sort(reverse=True)
    Am.sort()
    
    if K%2==1 and Ap:
        ans*=Ap.pop(0)
    
    P=[]
    
    for i in range(len(Ap)//2):
        P.append(Ap[i*2]*Ap[i*2+1])
    
    for i in range(len(Am)//2):
        P.append(Am[i*2]*Am[i*2+1])
    
    P.sort(reverse=True)
    
    for i in range(K//2):
        ans*=P[i]
        ans=ans%MOD

print(ans%MOD)
a = int(input())
print(a * pi * 2)

### FIXED CODE ###

import sys, re
import math
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul	# 
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd	# 最大公約数
from heapq import heappush, heappop

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

# -*- coding: utf-8 -*-

a = INT() 
print(a * pi * 2)
import numpy as np

# 入力行N，列D
N, D = map(int, input().split())
points = [list(map(int, input().split())) for i in range(N)]

def calc_distance(p1, p2):
    sum = 0
    for i in range(len(p1)):
        sum += (p1[i] - p2[i]) ** 2
    return np.sqrt(sum)

count = 0
for i, point in enumerate(points):
    for point2 in points[i + 1:]:
        outp = calc_distance(point, point2)
        if outp.is_integer():
            count += 1

print(count)

### FIXED CODE ###

import numpy as np

# 入力行N，列D
N, D = map(int, input().split())
points = [list(map(int, input().split())) for i in range(N)]

def calc_distance(p1, p2):
    sum = 0
    for i in range(len(p1)):
        sum += (p1[i] - p2[i]) ** 2
    return np.sqrt(sum)

count = 0
for i, point in enumerate(points):
    for point2 in points[i + 1:]:
        outp = calc_distance(point, point2)
        if outp.is_integer():
            count += 1

print(count)
A,B,K = map(int,input().split())
li = []

for i in range(1,min(A,B)):
  if A % i == 0 and B % i == 0:
    li.append(i)
    
print(li[K-1])

### FIXED CODE ###

A,B,K = map(int,input().split())
li = []

for i in range(1,min(A,B)+1):
  if A % i == 0 and B % i == 0:
    li.append(i)

print(li[len(li)-K])
s = input()
c = True
for i in range(len(s)):
    if i % 2 == 0:
        if s[i] != 'U' && s[i] != 'D' && s[i] != 'L':
            c = False
    if i % 2 == 1:
        if s[i] != 'U' && s[i] != 'D' && s[i] != 'R':
            c = False

if c:
    print('Yes')
else:
    print('No')
    

### FIXED CODE ###

s = input()
c = True
for i in range(len(s)):
    if i % 2 == 1:
        if s[i] != 'U' and s[i] != 'D' and s[i] != 'L':
            c = False
    if i % 2 == 0:
        if s[i] != 'U' and s[i] != 'D' and s[i] != 'R':
            c = False

if c:
    print('Yes')
else:
    print('No')
N = int(input())
ls = list(map(int,input().split()))
n=0
nls = []
for i in range(N-1):
    if ls[i] >= ls[i+1]:
        n += 1 
    elif ls[i] < ls[i+1]:
        nls.append(n)
        n = 0
    
    if i==N-2:
        nls.append(n)

print(max(nls))

### FIXED CODE ###

N = int(input())
ls = list(map(int,input().split()))
ans=0
n=0
nls = []
for i in range(N-1):
    if ls[i] >= ls[i+1]:
        n += 1 
    elif ls[i] < ls[i+1]:
        ans = max(ans,n)
        n = 0
    
    if i==N-2:
        ans = max(ans,n)

print(ans)