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

### FIXED CODE ###

N, T = map(int, input().split())
A = list(map(int, input().split()))
ans = T
for i in range(1, N):
  if A[i] - A[i-1] >= T:
    ans += T
  else:
    ans += (A[i] - A[i-1])
print(ans)
a = list(map9int, input().split())

if sum(a) >= 22:
    print('bust')
else:
    print('win')

### FIXED CODE ###

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

if sum(a) >= 22:
    print('bust')
else:
    print('win')
import numpy as np
def eratosthenes(n):
    is_prime = np.ones((n+1,), dtype=bool)
    is_prime[:2] = False
    for i in range(2,n+1):
        if is_prime[i]:
            is_prime[i*2::i]=False
    return np.arange(n+1)[is_prime]
Ps = eratosthenes(1000007)
def divisor(n):
    for p in Ps:
        if p*p>n:return -1
        if n%p==0:return p
def prime_division(n):
    d={}
    while n>1:
        p=divisor(n)
        if p==-1:d[n]=d.get(n,0)+1;break
        else:d[p]=d.get(p,0)+1;n//=p
    return d

def z(n,k,v):
    if len(k)==1:
        return [n*k[0]**i for i in range(v[0]+1)]
    else:
        r=[]
        for i in range(v[0]+1):
             r+=z(n*k[0]**i,k[1:],v[1:])
        return r
def y(n):
    pd=prime_division(n)
    KV=[[k,v] for k,v in pd.items()]
    K=[k for k,v in KV]; V=[v for k,v in KV]
    return z(1,K,V)

N=int(input())
r=0
#print(y(N))
for yk in y(N):
    if yk>1 and N//(yk-1) == N%(yk-1):
        r+=yk-1
print(r)

### FIXED CODE ###

import numpy as np
def eratosthenes(n):
    is_prime = np.ones((n+1,), dtype=bool)
    is_prime[:2] = False
    for i in range(2,n+1):
        if is_prime[i]:
            is_prime[i*2::i]=False
    return np.arange(n+1)[is_prime]
Ps = eratosthenes(1000007)
def divisor(n):
    for p in Ps:
        if p*p>n:return -1
        if n%p==0:return p
def prime_division(n):
    d={}
    while n>1:
        p=divisor(n)
        if p==-1:d[n]=d.get(n,0)+1;break
        else:d[p]=d.get(p,0)+1;n//=p
    return d

def z(n,k,v):
    if len(k)==1:
        return [n*k[0]**i for i in range(v[0]+1)]
    else:
        r=[]
        for i in range(v[0]+1):
             r+=z(n*k[0]**i,k[1:],v[1:])
        return r
def y(n):
    pd=prime_division(n)
    KV=[[k,v] for k,v in pd.items()]
    K=[k for k,v in KV]; V=[v for k,v in KV]
    return z(1,K,V)

N=int(input())
if N==1:print(0);exit()
r=0
#print(y(N))
for yk in y(N):
    if yk>1 and N//(yk-1) == N%(yk-1):
        r+=yk-1
print(r)
I=lambda:map(int,input().split())
n,m=I()
n+=1
g=[[] for _ in range(n)]
v=[0  for _ in range(n)]

for _ in range(m):
  a,b=I()
  g[a]+=[b]
  g[b]+=[a]
l=[]
v[1]=1
def bfs(x,l):
  for j in g[x]:
    if v[j]==0:
      v[j]=1
      return [j]+bfs(j,l)
      break
  else:
    return l
z=[1]+bfs(1,l)
print(len(z))
print(*z)

### FIXED CODE ###

import sys
sys.setrecursionlimit(1000000)
I=lambda:map(int,input().split())
n,m=I()
g=[set() for _ in range(n+1)]
v=[1 for _ in range(n+1)]
v[1]=0

for _ in range(m):
  a,b=I()
  g[a].add(b)
  g[b].add(a)

def dfs(x):
  for j in g[x]:
    if v[j]:
      v[j]=0
      l=dfs(j)
      l.append(j)
      return l
      break
  else:
    return []
z=dfs(1)+[1]+dfs(1)[::-1]
print(len(z))
print(*z)
n,m=map(int,input().split())
mod=10**9+7

    
def fib(j):
    if j==1:
        return 1
    if j==2:
        return 2
    return fib(j-1)+fib(j-2)


ans=1
now=0

for i in range(m):
    a=int(input())
    if a==now:
        ans=0
        break
    if a-1==now:
        now=a+1
        continue
    ans*=fib((a-now-1))
    ans=ans%mod
    now=a+1

if now!=n:
    ans*=fib((n-now))
    ans=ans%mod
print(ans)
    


### FIXED CODE ###

n,m=map(int,input().split())
mod=10**9+7

    
dp=[0]*(n+1)
dp[0]=1

a=set(int(input()) for i in range(m))

for i in range(1,n+1):
    if i in a:
        continue
    x=dp[i-1]
    if i>1:
        x+=dp[i-2]
    dp[i]=x%mod
print(dp[-1])
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gcd
from operator import mul
from functools import reduce
from operator import mul
from pprint import pprint



sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007


def digit_dp(n, f):
    dp = [[[0] * f for _ in range(2)] for _ in range(102)]
    dp[0][0][0] = 1
    l = len(str(n))
    for i in range(l):
        max_d = int(str(n)[i])
        for j in range(2):
            for k in range(f):
                for d in range(10 if j else max_d + 1):
                    dp[i + 1][j or (d < max_d)][(k + d) % f] += dp[i][j][k]
                    dp[i + 1][j or (d < max_d)][(k + d) % f] %= mod
    return dp[l][0][0] + dp[l][1][0] - 1


k = I()
d = I()
print(digit_dp(k, d) % mod)


### FIXED CODE ###

from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gcd
from operator import mul
from functools import reduce
from operator import mul
from pprint import pprint



sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007


def digit_dp(n, f):
    dp = [[[0] * f for _ in range(2)] for _ in range(10002)]
    dp[0][0][0] = 1
    l = len(n)
    for i in range(l):
        max_d = int(n[i])
        for j in range(2):
            for ki in range(f):
                for di in range(10 if j else max_d + 1):
                    dp[i + 1][j or (di < max_d)][(ki + di) % f] += dp[i][j][ki]
                    dp[i + 1][j or (di < max_d)][(ki + di) % f] %= mod
    return dp[l][0][0] + dp[l][1][0] - 1


k = input()
d = int(input())
print(digit_dp(k, d) % mod)
def solve():
    a, b = input().split()
    a = int(a)
    b = float(b)
    print(math.floor(a*b))
    return 0

if __name__ == "__main__":
    solve()

### FIXED CODE ###

import math
import collections
import fractions
import itertools
import decimal

def solve():
    a, b = input().split()
    a = decimal.Decimal(a)
    b = decimal.Decimal(b)
    print(int(a*b))
    return 0

if __name__ == "__main__":
    solve()
import numpy as np
s=input()
t=input()

"""
dp[i+1][j+1]:sのi文字目までとtのj文字目まででの LCS の長さ
dp[i+1][j+1]をdp[i][j],dp[i][j+1],dp[i][j+1]を使って表現する。
dp[i+1][j+1]=max(dp[i][j]+1 if s[i]==t[j] else 0,dp[i+1][j],dp[i][j+1])
"""
ns=len(s)
nt=len(t)
dp=np.zeros((ns+1,nt+1),np.int64)
pp=np.full((ns+1,nt+1),'')
ppd={0:'c',1:'l',2:'u'}
for i in range(ns):
  for j in range(nt):
    a=np.array([dp[i][j]+1 if s[i]==t[j] else -1,dp[i+1][j],dp[i][j+1]])
    dp[i+1][j+1]=np.max(a)
    pp[i+1][j+1]=ppd[np.argmax(a)]

i=ns
j=nt
ans=[]
while i>0 and j>0:
  sw=pp[i][j]
  if sw=='c':
        i-=1
        j-=1
        ans.append(s[i])
  elif sw=='l':
        j-=1
  elif sw=='u':
        i-=1
ans1=''
for _ in range(len(ans)):
      ans1+=ans.pop()
print(ans1)

### FIXED CODE ###

import numpy as np
s=np.array(list(input()))
t=np.array(list(input()))
is_eq=np.array(s[:,None]==t[None,])
# is_eq[i][j]:sのi文字目とtのj文字目が等しいかどうか
# print(is_eq)
ns=len(s)
nt=len(t)
dp=np.zeros((ns+1,nt+1),np.int64)

# dp[i+1][j+1]:sのi文字目までとtのj文字目までで最長の部分列
# dp[0][j]=0,dp[i][0]=0,dp[n+1][w+1]の値がsとtで最長の部分列の長さ
for i in range(ns): #sのi文字目までの文字列で調査
    dp[i+1][1:]=np.maximum(dp[i][:-1]+is_eq[i],dp[i][1:])#左上からの更新、真上からの更新
    dp[i+1]=np.maximum.accumulate(dp[i+1])#左からの更新
i=ns
j=nt
ans=['']
while i>0 and j>0:
      if dp[i][j]==dp[i-1][j]:
            i-=1
      elif dp[i][j]==dp[i][j-1]:
            j-=1
      else:
            ans.append(s[i-1])
            i-=1
            j-=1
a=''
for _ in range(len(ans)):
      a+=ans.pop()
print(a)
Sa = list(raw_input())
Sb = list(raw_input())
Sc = list(raw_input())

ne = Sa.pop(0)
s = len(Sa)
while s!=0:
    if ne == "a":
        ne = Sa.pop(0)
        s = len(Sa)
    if ne == "b":
        ne = Sb.pop(0)
        s = len(Sb)
    if ne == "c":
        ne = Sc.pop(0)
        s = len(Sc)
print ne.upper()

### FIXED CODE ###

Sa = list(raw_input())
Sb = list(raw_input())
Sc = list(raw_input())

def choise(t):
    if t == "a":
        if Sa == []:
            print "A"
        else:
            choise(Sa.pop(0))
    elif t== "b":
        if Sb == []:
            print "B"
        else:
            choise(Sb.pop(0))
    else:
        if Sc == []:
            print "C"
        else:
            choise(Sc.pop(0))

choise(Sa.pop(0))
a, b, t = [int(i) for i in input().split()]
print(b * (c // a))

### FIXED CODE ###

a, b, t = (int(i) for i in input().split())

print(t // a * b)
x = input()

if x >= 30:
    print("Yes")
else:
    print("No")

### FIXED CODE ###

x = int(input())

if x >= 30:
    print("Yes")
else:
    print("No")
n, m, k = map(int, input().split())

friends = [[] for i in range(n)]
cands = [[] for i in range(n)]
visited = [False for i in range(n)]
count = [0 for i in range(n)]
for _ in range(m):
    a, b = map(lambda x: int(x)-1, input().split())
    friends[a].append(b)
    friends[b].append(a)

def dfs(x):
    if visited[x]:
        return
    visited[x] = True
    cycle.append(x)
    for i in friends[x]:
        dfs(i)
    return

for i, v in enumerate(visited):
    if v:
        continue
    cycle = []
    dfs(i)
    l = len(cycle)
    for fr in cycle:
        cands[fr] = cycle
        count[fr] = l - 1 - len(friends[fr])

for _ in range(k):
    a, b = map(lambda x: int(x)-1, input().split())
    if a in cands[b]:
        count[a] -= 1
        count[b] -= 1

for i in count:
    print(i, end=" ")

### FIXED CODE ###

import time, sys
sys.setrecursionlimit(int(1e7))

n, m, k = map(int, input().split())

friends = [[] for i in range(n)]
cands = [None for i in range(n)]
cycles = []
visited = [False for i in range(n)]
count = [0 for i in range(n)]
for _ in range(m):
    a, b = map(lambda x: int(x)-1, input().split())
    friends[a].append(b)
    friends[b].append(a)

def dfs(x):
    visited[x] = True
    cycle.add(x)
    for i in friends[x]:
        if not visited[i]:
            dfs(i)
    return


for i, v in enumerate(visited):
    if v:
        continue
    cycle = set()
    dfs(i)
    l = len(cycle)
    ind = len(cycles)
    cycles.append(cycle)
    for fr in cycle:
        cands[fr] = ind
        count[fr] = l - 1 - len(friends[fr])


for _ in range(k):
    a, b = map(lambda x: int(x)-1, input().split())
    if a in cycles[cands[b]]:
        count[a] -= 1
        count[b] -= 1

for i in count:
    print(i, end=" ")
inf = 10000000000

def main():
    h,n = map(int,input().split())
    a=[0 for i in range(n)]
    b=[0 for i in range(n)]
    ans = [inf for i in range(h+1)]
    for i in range(n):
        tmp = list(map(int,input().split()))
        a[i] = tmp[0]
        b[i] = tmp[1]
        ans[a[i]] = b[i]
    
    
    for i in range(len(ans)):
        if ans[i]!=inf:
            for j in range(len(a)):
                if ans[i]+b[j] < ans[min(h,a[j]+i)]:
                    ans[min(h,a[j]+i)] = ans[i]+b[j]
    print(ans[h])
if __name__=="__main__":
    main()
    

### FIXED CODE ###

INF = 10000000000
a=[0 for i in range(int(1e5))]
b=[0 for i in range(int(1e5))]
ans = [INF for i in range(int(1e5))]

def main():
    h,n = map(int,input().split())
    for i in range(n):
        tmp = list(map(int,input().split()))
        a[i] = tmp[0]
        b[i] = tmp[1]
        index = min(h,a[i])
        if b[i] < ans[index]:
            ans[index] = b[i]
    
    
    for i in range(h):
        if ans[i]!=INF:
            for j in range(n):
                index = min(h,a[j]+i)
                if ans[i]+b[j] < ans[index]:
                    ans[index] = ans[i]+b[j]
    print(ans[h])
if __name__=="__main__":
    main()
S = input()

if S[-1]!="A" or S[-1]=="R":
    print("NO")
    exit(0)
i = 0
for s in "AKIHABARA":
    if S[i]==s:
        i+=1
        continue
    elif s=="A":
        continue
    else:
        print("NO")
        exit()

if i>=len(S)-1:
    print("YES")
else:
    print("NO")

### FIXED CODE ###



import re


S = input()

if re.fullmatch(r"A?KIHA?BA?RA?",S):
    print("YES")
else:
    print("NO")
exit()
n=int(input())
arr=list(map(int,input().split()))
arr=arr.sort()
s=0
for i in range(0,(2*n)-1,2):
  s+=arr[i]
print(s)

### FIXED CODE ###

n=int(input())
arr=list(map(int,input().split()))
arr.sort()
s=0
for i in range(0,(2*n)-1,2):
  s+=arr[i]
print(s)
n = int(input())
a = list(map(int,input.split()))
a = sorted(a)
prod = 1
for x in a:
  prod *= x
  if prod > 10**18:
    prod = -1
    break
print(prod)

### FIXED CODE ###

n = int(input())
a = list(map(int,input().split()))
a = sorted(a)
prod = 1
for x in a:
	prod *= x
	if prod > 10**18:
		prod = -1
		break
print(prod)
import math
a, b = list(map(int, input().split()))
x = a * 100 + b

flag = False
for i in range(1,int(math.sqrt(x))+1):
    if i ** 2 == x:
        flag =True
        break:

print("Yes" if flag 2 else "No")

### FIXED CODE ###

import math
a, b = input().split()
x = int(a) * 10 ** len(b) + int(b)

flag = False
for i in range(1,int(math.sqrt(x))+1):
    if i ** 2 == x:
        flag =True
        break

print("Yes" if flag else "No")
n = input()
for i in range(1,n+1):
  m[i][i] = 0

  p[i-1], p[i] = map(int, raw_input().split())

for m in range(2,n+1):
  for i in range(1,n-m+1+1):
    j = i + m - 1
    m[i][j] = 999999999999999
    for k in range(i,j-1+1):
      m[i][j] = min(m[i][j], m[i][k] + m[i][k] + m[k+1][j] + p[i-1] * p[k] * p[j])

print m[1][n]

### FIXED CODE ###

n = int(raw_input())
p = [0 for i in range(0, 101)]
m = [[0 for i in range(0, 101)] for j in range(0, 101)]
for i in range(1, n+1):
    p[i-1], p[i] = map(int, raw_input().split())
     
for l in range(2, n+1):
    for i in range(1, n-l+2):
        j = i+l-1
        m[i][j] = float("inf")
        for k in range(i, j):
            m[i][j] = min(m[i][j], m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j])
 
print m[1][n]
# B - Five Dishes
import numpy as np
n=[]
for i in range(5):
    t = int(input())
    n.append(t)
n = np.array(n)

m = [e for e in n%10 if e not in dl]
s = np.ceil(n/10)*10
print(int(np.sum(s)-min(m)))

### FIXED CODE ###

# B - Five Dishes
import numpy as np
n=[]
for i in range(5):
    t = int(input())
    n.append(t)
n = np.array(n)
dl = [0]
s = np.ceil(n/10)*10

if max(n%10)==0:
    print(int(np.sum(s)))
    exit()
m = [e for e in n%10 if e not in dl]
print(int(np.sum(s)-(10-min(m))))
K = int(input())
max_index = numbers.index(max(numbers))
result = [numbers[i] * 2 ** K if i == max_index else numbers[i] for i in range(len(numbers))]
print(sum(result))

### FIXED CODE ###

a, b = list(map(int, input().split()))
if a <= b:
    print(a)
else:
    print(a-1)
A,B = map(int,input().split())
counter = 0
for _ in range(A,B+1):
    str = str(_)
    alist = list(str)
    print(alist)
    list_ = []
    long = len(alist)
    for i in range(long-1,-1,-1):
        list_.append(alist[i])
    num = "".join(list_)
    if num == str:
        counter += 1
        continue
    else:
        continue

print(counter)


### FIXED CODE ###

A, B = map(int, input().split())
counter = 0
for num in range(A, B + 1):
    if str(num) == str(num)[::-1]:
        counter += 1

print(counter)
n, p = map(int, input().split())
a = list(map(int, input().split()))

odd = 0
even = 0

for i in a:
    if a %2 ==0:
        even +=1
    else:
        odd+=1
if even == n:
    if p == 0:
        print(2**n)
    else:
        print(0)
else:
    print(2**(n-1))

### FIXED CODE ###

n, p = map(int, input().split())
a = list(map(int, input().split()))

odd = 0
even = 0

for i in a:
    if i %2 ==0:
        even +=1
    else:
        odd+=1
if even == n:
    if p == 0:
        print(2**n)
    else:
        print(0)
else:
    print(2**(n-1))
N, M = [int(x) for x in input().split()]
links = [tuple(map(int, input().split())) for _ in range(M)]
S, T = [int(x) for x in input().split()]

d = {}
for x, y in links:
    if x in d:
        d[x][0].add(y)
    else:
        d[x] = [{y}, False]

def next_node(start):
    history = set()
    for s in start:
        if s in d:
            history |= d[s][0]
    return history

history = {S}
for i in range(1, 1000000):
    for _ in range(3):
        history = next_node(history)
    if T in history:
        print(i)
        break
    for h in tuple(history):
        if d[h][1]:
            history.remove(h)
        else:
            d[h][1] = True
    if len(history) == 0:
        print(-1)
        break


### FIXED CODE ###

N, M = [int(x) for x in input().split()]
links = [tuple(map(int, input().split())) for _ in range(M)]
S, T = [int(x) for x in input().split()]

d = {}
for x, y in links:
    if x in d:
        d[x][0].add(y)
    else:
        d[x] = [{y}, False]

def next_node(start):
    history = set()
    for s in start:
        if s in d:
            history |= d[s][0]
    return history

history = {S}
s = 1
while True:
    for _ in range(3):
        history = next_node(history)
    if T in history:
        print(s)
        break
    for h in tuple(history):
        if h not in d or d[h][1]:
            history.remove(h)
        else:
            d[h][1] = True
    if len(history) == 0:
        print(-1)
        break
    s += 1
n,k,q = map(int,input().split())
A = []
for i range in(q):
  a = int(input())
  A.append(a)
point = [k - q]*n

for i range(q):
  tmp = A[i] - 1
  point[tmp] += 1

for i in range(n):
    if point[i] > 0:
        print("Yes")
    else:
        print("No")


### FIXED CODE ###

n,k,q = map(int,input().split())
A = []
for i in range (q):
  a = int(input())
  A.append(a)
point = [k - q]*n

for i in range(q):
  tmp = A[i] - 1
  point[tmp] += 1

for i in range(n):
    if point[i] > 0:
        print("Yes")
    else:
        print("No")
import sys
input = sys.stdin.readline

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

    tmp = 1
    tl = []
    tl_a = tl.append

    if k < n:
        for i in range(k):
            tmp = nlis[tmp - 1]
        print(tmp)
    else:
        for i in range(n):
            if not nlis[tmp - 1] in tl:
                tl_a(nlis[tmp - 1])
                tmp = nlis[tmp - 1]
            else:
                tl = tl[tl.index(nlis[tmp - 1]):]
                print(tl[((k - i) % len(tl)) - 1])
                break

if __name__ == "__main__":
    main()

### FIXED CODE ###

s= input()
t = input()
flag = True

for i in range(len(s)):
  if s[i] != t[i]:
    flag = False
    
print(['No', 'Yes'][flag])
N, M = map(int, input().split())
MOD = 1000000007

broken = []
for i in range(M):
    broken.append(int(input()))

dp = [0] * (N + 2)
dp[N] = 1
for i in reversed(range(N)):
    if i in broken:
        dp[i] = 0
        if len(broken) != 0:
            broken.pop(-1)
        continue
    dp[i] = (dp[i+1] + dp[i+2]) % MOD

print(dp[0])


### FIXED CODE ###

def abc():
    p, q, r = map(int, input().split())
    print(min(p + q, q + r, r + p))


abc()
#!/usr/bin/env python3
import sys
import math
import bisect
INF = float("inf")


def solve(N: int):

    count = 0
    for r in range(1, int(math.sqrt(N))+1):  # 商
        # 余りは二分探索で良い
        lower = -(-N//r+1)
        upper = N//r
        while lower + 1 < upper:
            mid = (lower+upper)//2
            if N % mid >= r:
                lower = mid
            else:
                upper = mid
        if N % lower == r:
            count += lower
    print(count)

    return


def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    solve(N)


if __name__ == '__main__':
    main()


### FIXED CODE ###

#!/usr/bin/env python3
import sys
import math
import bisect
INF = float("inf")


def solve(N: int):

    if N == 1:
        print(0)
        return
    count = 0
    for r in range(1, int(math.sqrt(N))+1):  # 商
        # 余りは二分探索で良い
        lower = -(-N//r+1)
        upper = N//r
        while lower + 1 < upper:
            mid = (lower+upper)//2
            if N % mid >= r:
                lower = mid
            else:
                upper = mid
        if N % lower == r:
            count += lower
    print(count)

    return


def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    solve(N)


if __name__ == '__main__':
    main()
if __name__ == "__main__":
	S = S[0:4] + " " + S[4:]

### FIXED CODE ###

s=input()
print(s[:4]+ " "+s[4:])
from itertools import combinations as comb
import numpy as np
N, K = map(int, input().split())
ans = 10 ** 18 + 1
choice = min(K, 4)
ps = np.array([list(map(int, input().split())) for i in range(N)])
for idxs in comb(range(N), choice):
	rep_ps = ps[idxs, :]
	x_max = rep_ps[:, 0].max()
	y_max = rep_ps[:, 1].max()
	x_min = rep_ps[:, 0].min()
	y_min = rep_ps[:, 1].min()
	in_num = sum((ps[:, 0] <= x_max) & (ps[:, 0] >= x_min) & (ps[:, 1] <= y_max) & (ps[:, 1] >= y_min))
	area = (y_max - y_min) * (x_max - x_min)
	if K >= in_num and area < ans:
		ans = area
print(area)


### FIXED CODE ###

A, B, C = map(int, input().split())
if A == B:
	print(C)
elif B == C:
	print(A)
else:
	print(B)
N = int(input())
H = list(map(int, input().split())).reverse()
max = 0
cnt = 0

for i in range(N):
  if H[i] <= H[i+1]:
    cnt += 1
  elif cnt > max:
    max = cnt
print(max)

### FIXED CODE ###

N = int(input())
H = list(map(int, input().split()))
H.reverse()
max = 0
cnt = 0
 
for i in range(N-1):
  if H[i] <= H[i+1]:
    cnt += 1
  else:
    cnt = 0
  if cnt > max:
    max = cnt
if cnt > max:
  max = cnt
print(max)