Kefa decided to make some money doing business on the Internet for exactly n days. He knows that on the i-th day (1 ≤ i ≤ n) he makes a_{i} money. Kefa loves progress, that's why he wants to know the length of the maximum non-decreasing subsegment in sequence a_{i}. Let us remind you that the subsegment of the sequence is its continuous fragment. A subsegment of numbers is called non-decreasing if all numbers in it follow in the non-decreasing order.

Help Kefa cope with this task!


-----Input-----

The first line contains integer n (1 ≤ n ≤ 10^5).

The second line contains n integers a_1,  a_2,  ...,  a_{n} (1 ≤ a_{i} ≤ 10^9).


-----Output-----

Print a single integer — the length of the maximum non-decreasing subsegment of sequence a.


-----Examples-----
Input
6
2 2 1 3 4 1

Output
3
Input
3
2 2 9

Output
3


-----Note-----

In the first test the maximum non-decreasing subsegment is the numbers from the third to the fifth one.

In the second test the maximum non-decreasing subsegment is the numbers from the first to the third one.

Difficulty: EASY
Tags: Dynamic programming

Implementation

Complete search
Skill types: Dynamic programming

Complete search

Starter code:

Solutions:
n = int(input())
a = list(map(int, input().split()))
pm = 1
max = 0
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		pm += 1
	else:
		if pm > max:
			max = pm
		pm = 1
if pm > max:
	max = pm
print(max)


n = int(input())
a = list(map(int, input().split()))
num = 1
maxnum = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		num = num + 1
		if num > maxnum:
			maxnum = num
	else:
		num = 1
print(maxnum)


n = int(input())
t = input().split()
max1 = 1
lst = []
for i in range(n - 1):
	if int(t[i + 1]) >= int(t[i]):
		max1 += 1
		lst.append(max1)
	else:
		max1 = 1
max2 = 1
for i in lst:
	if int(i) > max2:
		max2 = i
print(max2)


def seperateints(x):
	k = ''
	l = []
	for i in x:
		if i == ' ':
			l.append(int(k))
			k = ''
			continue
		k = k + i
	l.append(int(k))
	return l

def luckynum(x):
	for i in x:
		if i != '4' and i != '7':
			return False
	return True
n = int(input())
l = seperateints(input())
k = 1
s = 1
for i in range(n):
	if i == 0:
		continue
	if l[i] >= l[i - 1]:
		k += 1
	else:
		if k > s:
			s = k
		k = 1
	if i == n - 1 and k > s:
		s = k
print(s)


n = int(input())
a = list(map(int, input().split()))
c = 1
s = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		c = c + 1
	else:
		s = max(c, s)
		c = 1
print(max(s, c))


n = int(input())
a = list(map(int, input().split()))
if n == 1:
	print('1')
else:
	list_of_count = []
	count = 1
	for i in range(n - 1):
		if a[i] <= a[i + 1]:
			count = count + 1
		else:
			count = 1
		list_of_count.append(count)
	output = max(list_of_count)
	print(output)


n = int(input())
mas = list((int(i) for i in input().split()))
c = m = s = 0
for i in mas:
	c = c + 1 if i >= s else 1
	m = max(m, c)
	s = i
print(m)


n = int(input())
list1 = [int(x) for x in input().split(' ')]
cou = 1
l = 1
for i in range(n - 1):
	if list1[i + 1] >= list1[i]:
		cou += 1
	else:
		cou = 1
	l = max(l, cou)
if n == 1:
	print(1)
else:
	print(l)


I = lambda : list(map(int, input().split()))
[n] = I()
x = I()
res = 1
aux = 1
for i in range(1, len(x)):
	if x[i] >= x[i - 1]:
		aux = aux + 1
	else:
		aux = 1
	res = max(res, aux)
print(res)


x = int(input())
y = list(map(int, input().split()))
c = 1
m = 1
for i in range(1, len(y)):
	if y[i] >= y[i - 1]:
		c += 1
	else:
		if m < c:
			m = c
		c = 1
if m < c:
	m = c
print(m)


n = int(input())
li = list(map(int, input().split()))
dp = [0] * n
dp[0] = 1
for i in range(1, n):
	if li[i] >= li[i - 1]:
		dp[i] = dp[i - 1] + 1
	else:
		dp[i] = 1
print(max(dp))


n = int(input())
a = [int(i) for i in input().split()]
x = 0
y = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		y += 1
	else:
		x = max(x, y)
		y = 1
x = max(x, y)
print(x)


x = int(input())
n = [int(x) for x in input().split(' ')]
b = [0]
for i in range(len(n) - 1):
	if n[i] > n[i + 1]:
		b.append(i + 1)
b.append(len(n))
l = 0
if len(b) == 2:
	print(len(n))
else:
	for i in range(len(b) - 1):
		if b[i + 1] - b[i] > l:
			l = b[i + 1] - b[i]
	print(l)


m = 1
l = 1
n = int(input())
l1 = list(map(int, input().split()))
for i in range(1, n):
	if l1[i] >= l1[i - 1]:
		l += 1
	else:
		if m < l:
			m = l
		l = 1
if m < l:
	m = l
print(m)


n = int(input())
a = [int(i) for i in input().split()]
l = len(a)
f = [0] * l
f[0] = 1
for i in range(1, l):
	f[i] = f[i - 1] + 1 if a[i] >= a[i - 1] else 1
print(max(f))


input()
arr = list(map(int, input().split()))
ans = 1
c = 1
(i, j) = (0, 0)
t = arr[0]
for x in range(1, len(arr)):
	if t <= arr[x]:
		c += 1
		ans = max(ans, c)
	else:
		c = 1
	t = arr[x]
print(ans)


n = int(input())
string = input().split()
combo = 1
comboArray = []
for i in range(n):
	string[i] = int(string[i])
for i in range(0, n - 1):
	if string[i + 1] >= string[i]:
		combo += 1
	elif string[i + 1] < string[i]:
		comboArray.append(combo)
		combo = 1
comboArray.append(combo)
comboArray.sort()
print(max(comboArray))


import unittest

def solve(n, a):
	s = 1
	p = 0
	for i in range(1, len(a)):
		if a[i] >= a[i - 1]:
			s = max(s, i - p + 1)
		else:
			p = i
	return s

def main():
	n = int(input())
	a = list(map(int, input().split()))
	print(solve(n, a))
main()

class Tests(unittest.TestCase):

	def test_1(self):
		n = int('6')
		a = list(map(int, '2 2 1 3 4 1'.split()))
		self.assertEqual(solve(n, a), 3)

	def test_2(self):
		n = int('3')
		a = list(map(int, '2 2 9'.split()))
		self.assertEqual(solve(n, a), 3)

	def test_3(self):
		n = int('3')
		a = list(map(int, '3 2 1'.split()))
		self.assertEqual(solve(n, a), 1)

	def test_4(self):
		n = int('3')
		a = list(map(int, '1 2 3'.split()))
		self.assertEqual(solve(n, a), 3)

	def test_5(self):
		n = int('5')
		a = list(map(int, '2 2 2 2 2'.split()))
		self.assertEqual(solve(n, a), 5)

	def test_9(self):
		n = int('1')
		a = list(map(int, '1'.split()))
		self.assertEqual(solve(n, a), 1)


i = int(input())
ls = list(map(int, input().split()))
ans = 1
temp = 1
for x in range(1, i):
	if ls[x] >= ls[x - 1]:
		temp += 1
	else:
		if temp > ans:
			ans = temp
		temp = 1
if temp > ans:
	ans = temp
print(ans)


n = int(input())
a = [int(i) for i in input().split()]
a.append(0)
c = []
for i in range(0, n):
	temp = 1
	c.append(temp)
m = 1
for i in range(0, n):
	if a[i] <= a[i + 1]:
		m = m + 1
	else:
		c[i] = m
		m = 1
print(max(c))


n = int(input())
l = list(map(int, input().split()))
c = t = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		c += 1
	else:
		if t < c:
			t = c
		c = 1
if t < c:
	t = c
print(t)


m = int(input())
t = [int(x) for x in input().split()]
start = 0
seg = []
for i in range(m):
	if t[i] < t[i - 1]:
		seg.append(i - start)
		start = i
else:
	seg.append(i + 1 - start)
print(max(seg))


n = int(input())
A = list(map(int, input().split()))
s = 1
B = []
if n == 1:
	print('1')
else:
	for i in range(n - 1):
		if A[i] <= A[i + 1]:
			s += 1
		else:
			B.append(s)
			s = 1
	if len(B) == 0:
		print(s)
	else:
		print(max(max(B), s))


n = int(input())
a = [int(i) for i in input().split()]
ans = 0
maxAns = 0
num = a[0]
for i in range(1, len(a)):
	if num <= a[i]:
		ans += 1
	else:
		ans = 0
	if ans > maxAns:
		maxAns = ans
	num = a[i]
print(maxAns + 1)


int(input())
count = 1
cc = 1
a = list(map(int, input().split()))
for i in range(len(a) - 1):
	if a[i + 1] >= a[i]:
		count += 1
	else:
		count = 1
	cc = max(cc, count)
print(cc)


n = int(input())
arr = list(map(int, input().split()))
nd_curr = 0
nd_max = 0
for i in range(n - 1):
	if arr[i] <= arr[i + 1]:
		nd_curr += 1
	else:
		nd_curr = 0
	if nd_curr > nd_max:
		nd_max = nd_curr
print(nd_max + 1)


n = int(input())
a = [int(i) for i in input().split()]
ans = 0
i = 0
while i < n:
	j = i + 1
	while j < n and a[j - 1] <= a[j]:
		j += 1
	ans = max(ans, j - i)
	i = j
print(ans)


def CF580A():
	N = int(input())
	arr = tuple(map(int, input().split()))
	curr = 1
	best = 1
	for i in range(1, N):
		if arr[i] >= arr[i - 1]:
			curr += 1
			best = max(best, curr)
		else:
			best = max(best, curr)
			curr = 1
	best = max(best, curr)
	return best
res = CF580A()
print(res)


def count_max_sequence(a):
	max_curr = 1
	element_prev = a[0]
	counter = 1
	for i in range(1, len(a)):
		if a[i] >= element_prev:
			counter += 1
			element_prev = a[i]
		else:
			element_prev = a[i]
			max_curr = max(counter, max_curr)
			counter = 1
	return max(counter, max_curr)

def main():
	_ = input()
	array = list(map(int, input().split(' ')))
	result = count_max_sequence(array)
	print(result)
main()


n = int(input())
a = [int(x) for x in input().split()]
ans = 1
i = 0
while i < n - 1:
	m = a[i]
	for j in range(i, n):
		if a[j] < m:
			break
		m = a[j]
	else:
		ans = max(ans, j - i + 1)
		i += j - i
		continue
	ans = max(ans, j - i)
	i += j - i
print(ans)


n = int(input())
lst = [int(x) for x in input().split()]
maxim = 0
last = 0
line = 0
for num in lst:
	if num >= last:
		line += 1
		last = num
	else:
		if line > maxim:
			maxim = line
		line = 1
		last = num
else:
	if line > maxim:
		maxim = line
print(maxim)


n = int(input())
l = list(map(int, input().split()))
(subl, ll) = (1, 1)
for i in range(1, len(l), 1):
	if l[i] >= l[i - 1]:
		subl += 1
		if subl > ll:
			ll = subl
	else:
		subl = 1
print(ll)


def firstSteps(li):
	k = [0] * len(li)
	k[0] = 1
	for i in range(1, len(li)):
		if li[i - 1] <= li[i]:
			k[i] = k[i - 1] + 1
		else:
			k[i] = 1
	return max(k)
n = int(input())
li = [int(x) for x in input().split()]
print(firstSteps(li))


x = int(input())
lista = list(map(int, input().split()))
soma = maior = 1
for c in range(1, x):
	if lista[c] >= lista[c - 1]:
		soma += 1
	else:
		soma = 1
	if soma > maior:
		maior = soma
print(maior)


n = int(input())
m = list(map(int, input().split()))
c = 1
p = []
for i in range(len(m) - 1):
	if m[i] <= m[i + 1]:
		c += 1
	else:
		p.append(c)
		c = 1
p.append(c)
maxm = max(p)
print(maxm)


n = int(input())
l = list(map(int, input().split()))
dp = 1
ans = 1
k = l[0]
for i in range(1, len(l)):
	if l[i] >= k:
		dp += 1
		k = l[i]
	else:
		ans = max(ans, dp)
		dp = 1
		k = l[i]
ans = max(ans, dp)
print(ans)


n = int(input().strip())
l = list(map(int, input().strip().split()))
result = 1
count = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		count += 1
		result = max(result, count)
	else:
		count = 1
print(result)


n = int(input())
a = [int(x) for x in input().split()]
max_ = 1
cur = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		cur += 1
	else:
		max_ = cur if cur > max_ else max_
		cur = 1
max_ = cur if cur > max_ else max_
print(max_)


n = int(input())
a = [*map(int, input().split())]
ans = 0
current = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		current += 1
	else:
		if current > ans:
			ans = current
		current = 1
print(max(ans, current))


num = input()
team = input().split()
moving = 1
max = 1
for i in range(1, len(team)):
	if int(team[i - 1]) <= int(team[i]):
		moving += 1
		if moving >= max:
			max = moving
	else:
		moving = 1
print(max)


n = int(input())
s = list(map(int, input().split()))
q = 1
i = 0
maxi = 0
s.append(-1)
while i < len(s) - 1:
	while s[i] <= s[i + 1]:
		q += 1
		i += 1
	maxi = max(q, maxi)
	q = 1
	i += 1
print(maxi)


n = int(input())
l = list(map(int, input().split()))
l2 = [1 for i in range(n)]
for i in range(1, n):
	if l[i] >= l[i - 1]:
		l2[i] = l2[i - 1] + 1
print(max(l2))


n = int(input())
a = list(map(int, input().split()[:n]))
streak = 0
k = 0
for i in range(1, n):
	if a[i] >= a[i - 1]:
		k += 1
	else:
		if k > streak:
			streak = k
		k = 0
if k > streak:
	streak = k
print(streak + 1)


n = int(input())
arr = [int(x) for x in input().split()]
ans = 1
now = 1
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		now += 1
	else:
		ans = max(ans, now)
		now = 1
ans = max(ans, now)
print(ans)


max_num = 1
current_max_num = 1
num = int(input())
list_nums = [int(i) for i in input().split()]
for i in range(num - 1):
	if list_nums[i] <= list_nums[i + 1]:
		current_max_num += 1
	else:
		current_max_num = 1
	if current_max_num > max_num:
		max_num = current_max_num
print(max_num)


n = int(input())
arr = list(map(int, input().split()))
t = 1
d = []
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		t += 1
	else:
		d.append(t)
		t = 1
d.append(t)
print(max(d))


from sys import stdin, stdout
num = int(stdin.readline())
list1 = [int(i) for i in stdin.readline().split()]
i = 0
count = 0
result = 0
while 1:
	try:
		if list1[i] <= list1[i + 1]:
			count += 1
			i += 1
			continue
	except IndexError:
		if count > result:
			result = count
			break
		else:
			break
	else:
		if count > result:
			result = count
		else:
			count = 0
			i += 1
			continue
stdout.write(str(result + 1))


t = int(input())
l = list(map(int, input().split()))
r = [1] * (len(l) - 1)
m = 1
for i in range(len(l) - 1):
	if l[i + 1] >= l[i]:
		if i == 0:
			r[i] += 1
		else:
			r[i] = r[i - 1] + 1
		if r[i] > m:
			m = r[i]
print(m)


import math as python_lib_Math
import math as Math
from os import path as python_lib_os_Path
import inspect as python_lib_Inspect
import os as python_lib_Os
import functools as python_lib_Functools
try:
	import msvcrt as python_lib_Msvcrt
except:
	pass
import random as python_lib_Random
import subprocess as python_lib_Subprocess
import sys as python_lib_Sys
try:
	import termios as python_lib_Termios
except:
	pass
import time as python_lib_Time
import timeit as python_lib_Timeit
try:
	import tty as python_lib_Tty
except:
	pass

class _hx_AnonObject:

	def __init__(self, fields):
		self.__dict__ = fields

class Enum:
	_hx_class_name = 'Enum'
	__slots__ = ('tag', 'index', 'params')
	_hx_fields = ['tag', 'index', 'params']
	_hx_methods = ['__str__']

	def __init__(self, tag, index, params):
		self.tag = tag
		self.index = index
		self.params = params

	def __str__(self):
		if self.params is None:
			return self.tag
		else:
			_this = self.params
			return HxOverrides.stringOrNull(self.tag) + '(' + HxOverrides.stringOrNull(','.join([python_Boot.toString1(x1, '') for x1 in _this])) + ')'

class EnumValue:
	_hx_class_name = 'EnumValue'

class Kefa:
	_hx_class_name = 'Kefa'
	__slots__ = ()
	_hx_statics = ['main']

	@staticmethod
	def main():
		stdin = Sys.stdin()
		n = Std.parseInt(stdin.readLine())
		_this = stdin.readLine()
		nums = list(map(Std.parseInt, _this.split(' ')))
		longest = 0
		curr = 0
		prev = 0
		_g = 0
		while _g < len(nums):
			num = nums[_g] if _g >= 0 and _g < len(nums) else None
			_g = _g + 1
			if num >= prev:
				curr = curr + 1
			else:
				curr = 1
			prev = num
			if curr > longest:
				longest = curr
			else:
				longest = longest
		print(str(longest))

class Reflect:
	_hx_class_name = 'Reflect'
	__slots__ = ()
	_hx_statics = ['field']

	@staticmethod
	def field(o, field):
		return python_Boot.field(o, field)

class Std:
	_hx_class_name = 'Std'
	__slots__ = ()
	_hx_statics = ['string', 'parseInt', 'shortenPossibleNumber', 'parseFloat']

	@staticmethod
	def string(s):
		return python_Boot.toString1(s, '')

	@staticmethod
	def parseInt(x):
		if x is None:
			return None
		try:
			return int(x)
		except Exception as _hx_e:
			_hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
			e = _hx_e1
			try:
				prefix = HxString.substr(x, 0, 2).lower()
				if prefix == '0x':
					return int(x, 16)
				raise _HxException('fail')
			except Exception as _hx_e:
				_hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
				e1 = _hx_e1
				x1 = Std.parseFloat(x)
				r = None
				try:
					r = int(x1)
				except Exception as _hx_e:
					_hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
					e2 = _hx_e1
					r = None
				if r is None:
					r1 = Std.shortenPossibleNumber(x)
					if r1 != x:
						return Std.parseInt(r1)
					else:
						return None
				return r

	@staticmethod
	def shortenPossibleNumber(x):
		r = ''
		_g1 = 0
		_g = len(x)
		while _g1 < _g:
			i = _g1
			_g1 = _g1 + 1
			c = '' if i < 0 or i >= len(x) else x[i]
			_g2 = HxString.charCodeAt(c, 0)
			if _g2 is None:
				break
			else:
				_g21 = _g2
				if (((((((((_g21 == 57 or _g21 == 56) or _g21 == 55) or _g21 == 54) or _g21 == 53) or _g21 == 52) or _g21 == 51) or _g21 == 50) or _g21 == 49) or _g21 == 48) or _g21 == 46:
					r = ('null' if r is None else r) + ('null' if c is None else c)
				else:
					break
		return r

	@staticmethod
	def parseFloat(x):
		try:
			return float(x)
		except Exception as _hx_e:
			_hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
			e = _hx_e1
			if x is not None:
				r1 = Std.shortenPossibleNumber(x)
				if r1 != x:
					return Std.parseFloat(r1)
			return Math.NaN

class StringTools:
	_hx_class_name = 'StringTools'
	__slots__ = ()
	_hx_statics = ['startsWith']

	@staticmethod
	def startsWith(s, start):
		if len(s) >= len(start):
			return HxString.substr(s, 0, len(start)) == start
		else:
			return False

class sys_FileSystem:
	_hx_class_name = 'sys.FileSystem'
	__slots__ = ()
	_hx_statics = ['fullPath']

	@staticmethod
	def fullPath(relPath):
		return python_lib_os_Path.realpath(relPath)

class haxe_IMap:
	_hx_class_name = 'haxe.IMap'
	__slots__ = ()

class haxe_ds_StringMap:
	_hx_class_name = 'haxe.ds.StringMap'
	__slots__ = ('h',)
	_hx_fields = ['h']

	def __init__(self):
		self.h = dict()

class python_HaxeIterator:
	_hx_class_name = 'python.HaxeIterator'
	__slots__ = ('it', 'x', 'has', 'checked')
	_hx_fields = ['it', 'x', 'has', 'checked']
	_hx_methods = ['next', 'hasNext']

	def __init__(self, it):
		self.checked = False
		self.has = False
		self.x = None
		self.it = it

	def next(self):
		if not self.checked:
			self.hasNext()
		self.checked = False
		return self.x

	def hasNext(self):
		if not self.checked:
			try:
				self.x = self.it.__next__()
				self.has = True
			except Exception as _hx_e:
				_hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
				if isinstance(_hx_e1, StopIteration):
					s = _hx_e1
					self.has = False
					self.x = None
				else:
					raise _hx_e
			self.checked = True
		return self.has

class Sys:
	_hx_class_name = 'Sys'
	__slots__ = ()
	_hx_statics = ['environ', 'time', 'exit', 'print', 'println', 'args', 'getEnv', 'putEnv', 'environment', 'sleep', 'setTimeLocale', 'getCwd', 'setCwd', 'systemName', 'command', 'cpuTime', 'executablePath', '_programPath', 'programPath', 'getChar', 'stdin', 'stdout', 'stderr']

	@staticmethod
	def time():
		return python_lib_Time.time()

	@staticmethod
	def exit(code):
		python_lib_Sys.exit(code)

	@staticmethod
	def print(v):
		python_Lib.print(v)

	@staticmethod
	def println(v):
		python_Lib.println(v)

	@staticmethod
	def args():
		argv = python_lib_Sys.argv
		return argv[1:None]

	@staticmethod
	def getEnv(s):
		return Sys.environ.h.get(s, None)

	@staticmethod
	def putEnv(s, v):
		python_lib_Os.putenv(s, v)
		Sys.environ.h[s] = v

	@staticmethod
	def environment():
		return Sys.environ

	@staticmethod
	def sleep(seconds):
		python_lib_Time.sleep(seconds)

	@staticmethod
	def setTimeLocale(loc):
		return False

	@staticmethod
	def getCwd():
		return python_lib_Os.getcwd()

	@staticmethod
	def setCwd(s):
		python_lib_Os.chdir(s)

	@staticmethod
	def systemName():
		_g = python_lib_Sys.platform
		x = _g
		if StringTools.startsWith(x, 'linux'):
			return 'Linux'
		else:
			_g1 = _g
			_hx_local_0 = len(_g1)
			if _hx_local_0 == 5:
				if _g1 == 'win32':
					return 'Windows'
				else:
					raise _HxException('not supported platform')
			elif _hx_local_0 == 6:
				if _g1 == 'cygwin':
					return 'Windows'
				elif _g1 == 'darwin':
					return 'Mac'
				else:
					raise _HxException('not supported platform')
			else:
				raise _HxException('not supported platform')

	@staticmethod
	def command(cmd, args=None):
		if args is None:
			return python_lib_Subprocess.call(cmd, **python__KwArgs_KwArgs_Impl_.fromT(_hx_AnonObject({'shell': True})))
		else:
			return python_lib_Subprocess.call([cmd] + args)

	@staticmethod
	def cpuTime():
		return python_lib_Timeit.default_timer()

	@staticmethod
	def executablePath():
		return python_internal_ArrayImpl._get(python_lib_Sys.argv, 0)

	@staticmethod
	def programPath():
		return Sys._programPath

	@staticmethod
	def getChar(echo):
		ch = None
		_g = Sys.systemName()
		_g1 = _g
		_hx_local_0 = len(_g1)
		if _hx_local_0 == 5:
			if _g1 == 'Linux':
				fd = python_lib_Sys.stdin.fileno()
				old = python_lib_Termios.tcgetattr(fd)
				a1 = fd
				a2 = python_lib_Termios.TCSADRAIN
				a3 = old

				def _hx_local_1():
					python_lib_Termios.tcsetattr(a1, a2, a3)
				restore = _hx_local_1
				try:
					python_lib_Tty.setraw(fd)
					x = python_lib_Sys.stdin.read(1)
					restore()
					ch = HxString.charCodeAt(x, 0)
				except Exception as _hx_e:
					_hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
					e = _hx_e1
					restore()
					raise _HxException(e)
			else:
				x1 = _g
				raise _HxException('platform ' + ('null' if x1 is None else x1) + ' not supported')
		elif _hx_local_0 == 3:
			if _g1 == 'Mac':
				fd = python_lib_Sys.stdin.fileno()
				old = python_lib_Termios.tcgetattr(fd)
				a1 = fd
				a2 = python_lib_Termios.TCSADRAIN
				a3 = old

				def _hx_local_2():
					python_lib_Termios.tcsetattr(a1, a2, a3)
				restore = _hx_local_2
				try:
					python_lib_Tty.setraw(fd)
					x = python_lib_Sys.stdin.read(1)
					restore()
					ch = HxString.charCodeAt(x, 0)
				except Exception as _hx_e:
					_hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
					e = _hx_e1
					restore()
					raise _HxException(e)
			else:
				x1 = _g
				raise _HxException('platform ' + ('null' if x1 is None else x1) + ' not supported')
		elif _hx_local_0 == 7:
			if _g1 == 'Windows':
				ch = HxString.charCodeAt(python_lib_Msvcrt.getch().decode('utf-8'), 0)
			else:
				x1 = _g
				raise _HxException('platform ' + ('null' if x1 is None else x1) + ' not supported')
		else:
			x1 = _g
			raise _HxException('platform ' + ('null' if x1 is None else x1) + ' not supported')
		if echo:
			python_Lib.print(''.join(map(chr, [ch])))
		return ch

	@staticmethod
	def stdin():
		return python_io_IoTools.createFileInputFromText(python_lib_Sys.stdin)

	@staticmethod
	def stdout():
		return python_io_IoTools.createFileOutputFromText(python_lib_Sys.stdout)

	@staticmethod
	def stderr():
		return python_io_IoTools.createFileOutputFromText(python_lib_Sys.stderr)

class haxe_io_Bytes:
	_hx_class_name = 'haxe.io.Bytes'
	__slots__ = ('length', 'b')
	_hx_fields = ['length', 'b']
	_hx_methods = ['getString', 'toString']

	def __init__(self, length, b):
		self.length = length
		self.b = b

	def getString(self, pos, _hx_len):
		if (pos < 0 or _hx_len < 0) or pos + _hx_len > self.length:
			raise _HxException(haxe_io_Error.OutsideBounds)
		return self.b[pos:pos + _hx_len].decode('UTF-8', 'replace')

	def toString(self):
		return self.getString(0, self.length)

class haxe_io_BytesBuffer:
	_hx_class_name = 'haxe.io.BytesBuffer'
	__slots__ = ('b',)
	_hx_fields = ['b']
	_hx_methods = ['getBytes']

	def __init__(self):
		self.b = list()

	def getBytes(self):
		buf = bytearray(self.b)
		_hx_bytes = haxe_io_Bytes(len(buf), buf)
		self.b = None
		return _hx_bytes

class haxe_io_Input:
	_hx_class_name = 'haxe.io.Input'
	__slots__ = ('bigEndian',)
	_hx_fields = ['bigEndian']
	_hx_methods = ['readByte', 'set_bigEndian', 'readLine']

	def readByte(self):
		raise _HxException('Not implemented')

	def set_bigEndian(self, b):
		self.bigEndian = b
		return b

	def readLine(self):
		buf = haxe_io_BytesBuffer()
		last = None
		s = None
		try:
			while True:
				last = self.readByte()
				if not last != 10:
					break
				_this = buf.b
				_this.append(last)
			s = buf.getBytes().toString()
			if HxString.charCodeAt(s, len(s) - 1) == 13:
				s = HxString.substr(s, 0, -1)
		except Exception as _hx_e:
			_hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
			if isinstance(_hx_e1, haxe_io_Eof):
				e = _hx_e1
				s = buf.getBytes().toString()
				if len(s) == 0:
					raise _HxException(e)
			else:
				raise _hx_e
		return s

class haxe_io_Eof:
	_hx_class_name = 'haxe.io.Eof'
	__slots__ = ()
	_hx_methods = ['toString']

	def __init__(self):
		pass

	def toString(self):
		return 'Eof'

class haxe_io_Error(Enum):
	__slots__ = ()
	_hx_class_name = 'haxe.io.Error'

	@staticmethod
	def Custom(e):
		return haxe_io_Error('Custom', 3, [e])
haxe_io_Error.Blocked = haxe_io_Error('Blocked', 0, list())
haxe_io_Error.Overflow = haxe_io_Error('Overflow', 1, list())
haxe_io_Error.OutsideBounds = haxe_io_Error('OutsideBounds', 2, list())

class haxe_io_Output:
	_hx_class_name = 'haxe.io.Output'
	__slots__ = ('bigEndian',)
	_hx_fields = ['bigEndian']
	_hx_methods = ['set_bigEndian']

	def set_bigEndian(self, b):
		self.bigEndian = b
		return b

class python_Boot:
	_hx_class_name = 'python.Boot'
	__slots__ = ()
	_hx_statics = ['keywords', 'toString1', 'fields', 'simpleField', 'field', 'getInstanceFields', 'getSuperClass', 'getClassFields', 'prefixLength', 'unhandleKeywords']

	@staticmethod
	def toString1(o, s):
		if o is None:
			return 'null'
		if isinstance(o, str):
			return o
		if s is None:
			s = ''
		if len(s) >= 5:
			return '<...>'
		if isinstance(o, bool):
			if o:
				return 'true'
			else:
				return 'false'
		if isinstance(o, int):
			return str(o)
		if isinstance(o, float):
			try:
				if o == int(o):
					return str(Math.floor(o + 0.5))
				else:
					return str(o)
			except Exception as _hx_e:
				_hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
				e = _hx_e1
				return str(o)
		if isinstance(o, list):
			o1 = o
			l = len(o1)
			st = '['
			s = ('null' if s is None else s) + '\t'
			_g1 = 0
			_g = l
			while _g1 < _g:
				i = _g1
				_g1 = _g1 + 1
				prefix = ''
				if i > 0:
					prefix = ','
				st = ('null' if st is None else st) + HxOverrides.stringOrNull(('null' if prefix is None else prefix) + HxOverrides.stringOrNull(python_Boot.toString1(o1[i] if i >= 0 and i < len(o1) else None, s)))
			st = ('null' if st is None else st) + ']'
			return st
		try:
			if hasattr(o, 'toString'):
				return o.toString()
		except Exception as _hx_e:
			_hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
			pass
		if python_lib_Inspect.isfunction(o) or python_lib_Inspect.ismethod(o):
			return '<function>'
		if hasattr(o, '__class__'):
			if isinstance(o, _hx_AnonObject):
				toStr = None
				try:
					fields = python_Boot.fields(o)
					_g2 = []
					_g11 = 0
					while _g11 < len(fields):
						f = fields[_g11] if _g11 >= 0 and _g11 < len(fields) else None
						_g11 = _g11 + 1
						x = '' + ('null' if f is None else f) + ' : ' + HxOverrides.stringOrNull(python_Boot.toString1(python_Boot.simpleField(o, f), ('null' if s is None else s) + '\t'))
						_g2.append(x)
					fieldsStr = _g2
					toStr = '{ ' + HxOverrides.stringOrNull(', '.join([x1 for x1 in fieldsStr])) + ' }'
				except Exception as _hx_e:
					_hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
					e2 = _hx_e1
					return '{ ... }'
				if toStr is None:
					return '{ ... }'
				else:
					return toStr
			if isinstance(o, Enum):
				o2 = o
				l1 = len(o2.params)
				hasParams = l1 > 0
				if hasParams:
					paramsStr = ''
					_g12 = 0
					_g3 = l1
					while _g12 < _g3:
						i1 = _g12
						_g12 = _g12 + 1
						prefix1 = ''
						if i1 > 0:
							prefix1 = ','
						paramsStr = ('null' if paramsStr is None else paramsStr) + HxOverrides.stringOrNull(('null' if prefix1 is None else prefix1) + HxOverrides.stringOrNull(python_Boot.toString1(o2.params[i1] if i1 >= 0 and i1 < len(o2.params) else None, s)))
					return HxOverrides.stringOrNull(o2.tag) + '(' + ('null' if paramsStr is None else paramsStr) + ')'
				else:
					return o2.tag
			if hasattr(o, '_hx_class_name'):
				if o.__class__.__name__ != 'type':
					fields1 = python_Boot.getInstanceFields(o)
					_g4 = []
					_g13 = 0
					while _g13 < len(fields1):
						f1 = fields1[_g13] if _g13 >= 0 and _g13 < len(fields1) else None
						_g13 = _g13 + 1
						x1 = '' + ('null' if f1 is None else f1) + ' : ' + HxOverrides.stringOrNull(python_Boot.toString1(python_Boot.simpleField(o, f1), ('null' if s is None else s) + '\t'))
						_g4.append(x1)
					fieldsStr1 = _g4
					toStr1 = HxOverrides.stringOrNull(o._hx_class_name) + '( ' + HxOverrides.stringOrNull(', '.join([x1 for x1 in fieldsStr1])) + ' )'
					return toStr1
				else:
					fields2 = python_Boot.getClassFields(o)
					_g5 = []
					_g14 = 0
					while _g14 < len(fields2):
						f2 = fields2[_g14] if _g14 >= 0 and _g14 < len(fields2) else None
						_g14 = _g14 + 1
						x2 = '' + ('null' if f2 is None else f2) + ' : ' + HxOverrides.stringOrNull(python_Boot.toString1(python_Boot.simpleField(o, f2), ('null' if s is None else s) + '\t'))
						_g5.append(x2)
					fieldsStr2 = _g5
					toStr2 = '#' + HxOverrides.stringOrNull(o._hx_class_name) + '( ' + HxOverrides.stringOrNull(', '.join([x1 for x1 in fieldsStr2])) + ' )'
					return toStr2
			if o == str:
				return '#String'
			if o == list:
				return '#Array'
			if callable(o):
				return 'function'
			try:
				if hasattr(o, '__repr__'):
					return o.__repr__()
			except Exception as _hx_e:
				_hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
				pass
			if hasattr(o, '__str__'):
				return o.__str__([])
			if hasattr(o, '__name__'):
				return o.__name__
			return '???'
		else:
			return str(o)

	@staticmethod
	def fields(o):
		a = []
		if o is not None:
			if hasattr(o, '_hx_fields'):
				fields = o._hx_fields
				return list(fields)
			if isinstance(o, _hx_AnonObject):
				d = o.__dict__
				keys = d.keys()
				handler = python_Boot.unhandleKeywords
				for k in keys:
					a.append(handler(k))
			elif hasattr(o, '__dict__'):
				d1 = o.__dict__
				keys1 = d1.keys()
				for k in keys1:
					a.append(k)
		return a

	@staticmethod
	def simpleField(o, field):
		if field is None:
			return None
		field1 = '_hx_' + field if field in python_Boot.keywords else '_hx_' + field if ((len(field) > 2 and ord(field[0]) == 95) and ord(field[1]) == 95) and ord(field[len(field) - 1]) != 95 else field
		if hasattr(o, field1):
			return getattr(o, field1)
		else:
			return None

	@staticmethod
	def field(o, field):
		if field is None:
			return None
		field1 = field
		_hx_local_0 = len(field1)
		if _hx_local_0 == 10:
			if field1 == 'charCodeAt':
				if isinstance(o, str):
					s1 = o

					def _hx_local_1(a11):
						return HxString.charCodeAt(s1, a11)
					return _hx_local_1
		elif _hx_local_0 == 11:
			if field1 == 'lastIndexOf':
				if isinstance(o, str):
					s3 = o

					def _hx_local_2(a15):
						return HxString.lastIndexOf(s3, a15)
					return _hx_local_2
				elif isinstance(o, list):
					a4 = o

					def _hx_local_3(x4):
						return python_internal_ArrayImpl.lastIndexOf(a4, x4)
					return _hx_local_3
			elif field1 == 'toLowerCase':
				if isinstance(o, str):
					s7 = o

					def _hx_local_4():
						return HxString.toLowerCase(s7)
					return _hx_local_4
			elif field1 == 'toUpperCase':
				if isinstance(o, str):
					s9 = o

					def _hx_local_5():
						return HxString.toUpperCase(s9)
					return _hx_local_5
		elif _hx_local_0 == 9:
			if field1 == 'substring':
				if isinstance(o, str):
					s6 = o

					def _hx_local_6(a19):
						return HxString.substring(s6, a19)
					return _hx_local_6
		elif _hx_local_0 == 4:
			if field1 == 'copy':
				if isinstance(o, list):

					def _hx_local_7():
						return list(o)
					return _hx_local_7
			elif field1 == 'join':
				if isinstance(o, list):

					def _hx_local_8(sep):
						return sep.join([python_Boot.toString1(x1, '') for x1 in o])
					return _hx_local_8
			elif field1 == 'push':
				if isinstance(o, list):
					x7 = o

					def _hx_local_9(e):
						return python_internal_ArrayImpl.push(x7, e)
					return _hx_local_9
			elif field1 == 'sort':
				if isinstance(o, list):
					x11 = o

					def _hx_local_10(f2):
						python_internal_ArrayImpl.sort(x11, f2)
					return _hx_local_10
		elif _hx_local_0 == 5:
			if field1 == 'shift':
				if isinstance(o, list):
					x9 = o

					def _hx_local_11():
						return python_internal_ArrayImpl.shift(x9)
					return _hx_local_11
			elif field1 == 'slice':
				if isinstance(o, list):
					x10 = o

					def _hx_local_12(a16):
						return python_internal_ArrayImpl.slice(x10, a16)
					return _hx_local_12
			elif field1 == 'split':
				if isinstance(o, str):
					s4 = o

					def _hx_local_13(d):
						return HxString.split(s4, d)
					return _hx_local_13
		elif _hx_local_0 == 7:
			if field1 == 'indexOf':
				if isinstance(o, str):
					s2 = o

					def _hx_local_14(a13):
						return HxString.indexOf(s2, a13)
					return _hx_local_14
				elif isinstance(o, list):
					a = o

					def _hx_local_15(x1):
						return python_internal_ArrayImpl.indexOf(a, x1)
					return _hx_local_15
			elif field1 == 'reverse':
				if isinstance(o, list):
					a5 = o

					def _hx_local_16():
						python_internal_ArrayImpl.reverse(a5)
					return _hx_local_16
			elif field1 == 'unshift':
				if isinstance(o, list):
					x14 = o

					def _hx_local_17(e2):
						python_internal_ArrayImpl.unshift(x14, e2)
					return _hx_local_17
		elif _hx_local_0 == 3:
			if field1 == 'map':
				if isinstance(o, list):
					x5 = o

					def _hx_local_18(f1):
						return python_internal_ArrayImpl.map(x5, f1)
					return _hx_local_18
			elif field1 == 'pop':
				if isinstance(o, list):
					x6 = o

					def _hx_local_19():
						return python_internal_ArrayImpl.pop(x6)
					return _hx_local_19
		elif _hx_local_0 == 8:
			if field1 == 'iterator':
				if isinstance(o, list):
					x3 = o

					def _hx_local_20():
						return python_internal_ArrayImpl.iterator(x3)
					return _hx_local_20
			elif field1 == 'toString':
				if isinstance(o, str):
					s8 = o

					def _hx_local_21():
						return HxString.toString(s8)
					return _hx_local_21
				elif isinstance(o, list):
					x13 = o

					def _hx_local_22():
						return python_internal_ArrayImpl.toString(x13)
					return _hx_local_22
		elif _hx_local_0 == 6:
			if field1 == 'charAt':
				if isinstance(o, str):
					s = o

					def _hx_local_23(a1):
						return HxString.charAt(s, a1)
					return _hx_local_23
			elif field1 == 'concat':
				if isinstance(o, list):
					a12 = o

					def _hx_local_24(a2):
						return python_internal_ArrayImpl.concat(a12, a2)
					return _hx_local_24
			elif field1 == 'filter':
				if isinstance(o, list):
					x = o

					def _hx_local_25(f):
						return python_internal_ArrayImpl.filter(x, f)
					return _hx_local_25
			elif field1 == 'insert':
				if isinstance(o, list):
					a3 = o

					def _hx_local_26(a14, x2):
						python_internal_ArrayImpl.insert(a3, a14, x2)
					return _hx_local_26
			elif field1 == 'length':
				if isinstance(o, str):
					return len(o)
				elif isinstance(o, list):
					return len(o)
			elif field1 == 'remove':
				if isinstance(o, list):
					x8 = o

					def _hx_local_27(e1):
						return python_internal_ArrayImpl.remove(x8, e1)
					return _hx_local_27
			elif field1 == 'splice':
				if isinstance(o, list):
					x12 = o

					def _hx_local_28(a17, a21):
						return python_internal_ArrayImpl.splice(x12, a17, a21)
					return _hx_local_28
			elif field1 == 'substr':
				if isinstance(o, str):
					s5 = o

					def _hx_local_29(a18):
						return HxString.substr(s5, a18)
					return _hx_local_29
		else:
			pass
		field2 = '_hx_' + field if field in python_Boot.keywords else '_hx_' + field if ((len(field) > 2 and ord(field[0]) == 95) and ord(field[1]) == 95) and ord(field[len(field) - 1]) != 95 else field
		if hasattr(o, field2):
			return getattr(o, field2)
		else:
			return None

	@staticmethod
	def getInstanceFields(c):
		f = c._hx_fields if hasattr(c, '_hx_fields') else []
		if hasattr(c, '_hx_methods'):
			f = f + c._hx_methods
		sc = python_Boot.getSuperClass(c)
		if sc is None:
			return f
		else:
			scArr = python_Boot.getInstanceFields(sc)
			scMap = set(scArr)
			_g = 0
			while _g < len(f):
				f1 = f[_g] if _g >= 0 and _g < len(f) else None
				_g = _g + 1
				if not f1 in scMap:
					scArr.append(f1)
			return scArr

	@staticmethod
	def getSuperClass(c):
		if c is None:
			return None
		try:
			if hasattr(c, '_hx_super'):
				return c._hx_super
			return None
		except Exception as _hx_e:
			_hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
			pass
		return None

	@staticmethod
	def getClassFields(c):
		if hasattr(c, '_hx_statics'):
			x = c._hx_statics
			return list(x)
		else:
			return []

	@staticmethod
	def unhandleKeywords(name):
		if HxString.substr(name, 0, python_Boot.prefixLength) == '_hx_':
			real = HxString.substr(name, python_Boot.prefixLength, None)
			if real in python_Boot.keywords:
				return real
		return name

class python__KwArgs_KwArgs_Impl_:
	_hx_class_name = 'python._KwArgs.KwArgs_Impl_'
	__slots__ = ()
	_hx_statics = ['fromT']

	@staticmethod
	def fromT(d):
		this1 = python_Lib.anonAsDict(d)
		return this1

class python_Lib:
	_hx_class_name = 'python.Lib'
	__slots__ = ()
	_hx_statics = ['print', 'println', 'anonToDict', 'anonAsDict', 'dictAsAnon']

	@staticmethod
	def print(v):
		_hx_str = Std.string(v)
		python_lib_Sys.stdout.buffer.write(_hx_str.encode('utf-8', 'strict'))
		python_lib_Sys.stdout.flush()

	@staticmethod
	def println(v):
		_hx_str = Std.string(v)
		python_lib_Sys.stdout.buffer.write(('' + ('null' if _hx_str is None else _hx_str) + '\n').encode('utf-8', 'strict'))
		python_lib_Sys.stdout.flush()

	@staticmethod
	def anonToDict(o):
		if isinstance(o, _hx_AnonObject):
			return o.__dict__.copy()
		else:
			return None

	@staticmethod
	def anonAsDict(o):
		if isinstance(o, _hx_AnonObject):
			return o.__dict__
		else:
			return None

	@staticmethod
	def dictAsAnon(d):
		return _hx_AnonObject(d)

class python_internal_ArrayImpl:
	_hx_class_name = 'python.internal.ArrayImpl'
	__slots__ = ()
	_hx_statics = ['concat', 'iterator', 'indexOf', 'lastIndexOf', 'toString', 'pop', 'push', 'unshift', 'remove', 'shift', 'slice', 'sort', 'splice', 'map', 'filter', 'insert', 'reverse', '_get']

	@staticmethod
	def concat(a1, a2):
		return a1 + a2

	@staticmethod
	def iterator(x):
		return python_HaxeIterator(x.__iter__())

	@staticmethod
	def indexOf(a, x, fromIndex=None):
		_hx_len = len(a)
		l = 0 if fromIndex is None else _hx_len + fromIndex if fromIndex < 0 else fromIndex
		if l < 0:
			l = 0
		_g1 = l
		_g = _hx_len
		while _g1 < _g:
			i = _g1
			_g1 = _g1 + 1
			if a[i] == x:
				return i
		return -1

	@staticmethod
	def lastIndexOf(a, x, fromIndex=None):
		_hx_len = len(a)
		l = _hx_len if fromIndex is None else _hx_len + fromIndex + 1 if fromIndex < 0 else fromIndex + 1
		if l > _hx_len:
			l = _hx_len
		while True:
			l = l - 1
			tmp = l
			if not tmp > -1:
				break
			if a[l] == x:
				return l
		return -1

	@staticmethod
	def toString(x):
		return '[' + HxOverrides.stringOrNull(','.join([python_Boot.toString1(x1, '') for x1 in x])) + ']'

	@staticmethod
	def pop(x):
		if len(x) == 0:
			return None
		else:
			return x.pop()

	@staticmethod
	def push(x, e):
		x.append(e)
		return len(x)

	@staticmethod
	def unshift(x, e):
		x.insert(0, e)

	@staticmethod
	def remove(x, e):
		try:
			x.remove(e)
			return True
		except Exception as _hx_e:
			_hx_e1 = _hx_e.val if isinstance(_hx_e, _HxException) else _hx_e
			e1 = _hx_e1
			return False

	@staticmethod
	def shift(x):
		if len(x) == 0:
			return None
		return x.pop(0)

	@staticmethod
	def slice(x, pos, end=None):
		return x[pos:end]

	@staticmethod
	def sort(x, f):
		x.sort(key=python_lib_Functools.cmp_to_key(f))

	@staticmethod
	def splice(x, pos, _hx_len):
		if pos < 0:
			pos = len(x) + pos
		if pos < 0:
			pos = 0
		res = x[pos:pos + _hx_len]
		del x[pos:pos + _hx_len]
		return res

	@staticmethod
	def map(x, f):
		return list(map(f, x))

	@staticmethod
	def filter(x, f):
		return list(filter(f, x))

	@staticmethod
	def insert(a, pos, x):
		a.insert(pos, x)

	@staticmethod
	def reverse(a):
		a.reverse()

	@staticmethod
	def _get(x, idx):
		if idx > -1 and idx < len(x):
			return x[idx]
		else:
			return None

class _HxException(Exception):
	_hx_class_name = '_HxException'
	__slots__ = ('val',)
	_hx_fields = ['val']
	_hx_methods = []
	_hx_statics = []
	_hx_super = Exception

	def __init__(self, val):
		self.val = None
		message = str(val)
		super().__init__(message)
		self.val = val

class HxOverrides:
	_hx_class_name = 'HxOverrides'
	__slots__ = ()
	_hx_statics = ['eq', 'stringOrNull', 'mapKwArgs']

	@staticmethod
	def eq(a, b):
		if isinstance(a, list) or isinstance(b, list):
			return a is b
		return a == b

	@staticmethod
	def stringOrNull(s):
		if s is None:
			return 'null'
		else:
			return s

	@staticmethod
	def mapKwArgs(a, v):
		a1 = python_Lib.dictAsAnon(python_Lib.anonToDict(a))
		k = python_HaxeIterator(iter(v.keys()))
		while k.hasNext():
			k1 = k.next()
			val = v.get(k1)
			if hasattr(a1, k1):
				x = getattr(a1, k1)
				setattr(a1, val, x)
				delattr(a1, k1)
		return a1

class HxString:
	_hx_class_name = 'HxString'
	__slots__ = ()
	_hx_statics = ['split', 'charCodeAt', 'charAt', 'lastIndexOf', 'toUpperCase', 'toLowerCase', 'indexOf', 'toString', 'substring', 'substr']

	@staticmethod
	def split(s, d):
		if d == '':
			return list(s)
		else:
			return s.split(d)

	@staticmethod
	def charCodeAt(s, index):
		if ((s is None or len(s) == 0) or index < 0) or index >= len(s):
			return None
		else:
			return ord(s[index])

	@staticmethod
	def charAt(s, index):
		if index < 0 or index >= len(s):
			return ''
		else:
			return s[index]

	@staticmethod
	def lastIndexOf(s, _hx_str, startIndex=None):
		if startIndex is None:
			return s.rfind(_hx_str, 0, len(s))
		else:
			i = s.rfind(_hx_str, 0, startIndex + 1)
			startLeft = max(0, startIndex + 1 - len(_hx_str)) if i == -1 else i + 1
			check = s.find(_hx_str, startLeft, len(s))
			if check > i and check <= startIndex:
				return check
			else:
				return i

	@staticmethod
	def toUpperCase(s):
		return s.upper()

	@staticmethod
	def toLowerCase(s):
		return s.lower()

	@staticmethod
	def indexOf(s, _hx_str, startIndex=None):
		if startIndex is None:
			return s.find(_hx_str)
		else:
			return s.find(_hx_str, startIndex)

	@staticmethod
	def toString(s):
		return s

	@staticmethod
	def substring(s, startIndex, endIndex=None):
		if startIndex < 0:
			startIndex = 0
		if endIndex is None:
			return s[startIndex:]
		else:
			if endIndex < 0:
				endIndex = 0
			if endIndex < startIndex:
				return s[endIndex:startIndex]
			else:
				return s[startIndex:endIndex]

	@staticmethod
	def substr(s, startIndex, _hx_len=None):
		if _hx_len is None:
			return s[startIndex:]
		else:
			if _hx_len == 0:
				return ''
			return s[startIndex:startIndex + _hx_len]

class python_io_NativeInput(haxe_io_Input):
	_hx_class_name = 'python.io.NativeInput'
	__slots__ = ('stream', 'wasEof')
	_hx_fields = ['stream', 'wasEof']
	_hx_methods = ['throwEof']
	_hx_statics = []
	_hx_super = haxe_io_Input

	def __init__(self, s):
		self.wasEof = None
		self.stream = s
		self.set_bigEndian(False)
		self.wasEof = False
		if not self.stream.readable():
			raise _HxException('Write-only stream')

	def throwEof(self):
		self.wasEof = True
		raise _HxException(haxe_io_Eof())

class python_io_IInput:
	_hx_class_name = 'python.io.IInput'
	__slots__ = ()
	_hx_methods = ['set_bigEndian', 'readByte', 'readLine']

class python_io_IFileInput:
	_hx_class_name = 'python.io.IFileInput'
	__slots__ = ()

class python_io_NativeOutput(haxe_io_Output):
	_hx_class_name = 'python.io.NativeOutput'
	__slots__ = ('stream',)
	_hx_fields = ['stream']
	_hx_methods = []
	_hx_statics = []
	_hx_super = haxe_io_Output

	def __init__(self, stream):
		self.stream = None
		self.set_bigEndian(False)
		self.stream = stream
		if not stream.writable():
			raise _HxException('Read only stream')

class python_io_IOutput:
	_hx_class_name = 'python.io.IOutput'
	__slots__ = ()
	_hx_methods = ['set_bigEndian']

class python_io_IFileOutput:
	_hx_class_name = 'python.io.IFileOutput'
	__slots__ = ()

class python_io_NativeTextInput(python_io_NativeInput):
	_hx_class_name = 'python.io.NativeTextInput'
	__slots__ = ()
	_hx_fields = []
	_hx_methods = ['readByte']
	_hx_statics = []
	_hx_super = python_io_NativeInput

	def __init__(self, stream):
		super().__init__(stream)

	def readByte(self):
		ret = self.stream.read(1)
		if len(ret) == 0:
			self.throwEof()
		return HxString.charCodeAt(ret, 0)

class python_io_FileTextInput(python_io_NativeTextInput):
	_hx_class_name = 'python.io.FileTextInput'
	__slots__ = ()
	_hx_fields = []
	_hx_methods = []
	_hx_statics = []
	_hx_super = python_io_NativeTextInput

	def __init__(self, stream):
		super().__init__(stream)

class python_io_NativeTextOutput(python_io_NativeOutput):
	_hx_class_name = 'python.io.NativeTextOutput'
	__slots__ = ()
	_hx_fields = []
	_hx_methods = []
	_hx_statics = []
	_hx_super = python_io_NativeOutput

	def __init__(self, stream):
		super().__init__(stream)
		if not stream.writable():
			raise _HxException('Read only stream')

class python_io_FileTextOutput(python_io_NativeTextOutput):
	_hx_class_name = 'python.io.FileTextOutput'
	__slots__ = ()
	_hx_fields = []
	_hx_methods = []
	_hx_statics = []
	_hx_super = python_io_NativeTextOutput

	def __init__(self, stream):
		super().__init__(stream)

class python_io_IoTools:
	_hx_class_name = 'python.io.IoTools'
	__slots__ = ()
	_hx_statics = ['createFileInputFromText', 'createFileOutputFromText']

	@staticmethod
	def createFileInputFromText(t):
		return sys_io_FileInput(python_io_FileTextInput(t))

	@staticmethod
	def createFileOutputFromText(t):
		return sys_io_FileOutput(python_io_FileTextOutput(t))

class sys_io_FileInput(haxe_io_Input):
	_hx_class_name = 'sys.io.FileInput'
	__slots__ = ('impl',)
	_hx_fields = ['impl']
	_hx_methods = ['set_bigEndian', 'readByte', 'readLine']
	_hx_statics = []
	_hx_super = haxe_io_Input

	def __init__(self, impl):
		self.impl = impl

	def set_bigEndian(self, b):
		return self.impl.set_bigEndian(b)

	def readByte(self):
		return self.impl.readByte()

	def readLine(self):
		return self.impl.readLine()

class sys_io_FileOutput(haxe_io_Output):
	_hx_class_name = 'sys.io.FileOutput'
	__slots__ = ('impl',)
	_hx_fields = ['impl']
	_hx_methods = ['set_bigEndian']
	_hx_statics = []
	_hx_super = haxe_io_Output

	def __init__(self, impl):
		self.impl = impl

	def set_bigEndian(self, b):
		return self.impl.set_bigEndian(b)
Math.NEGATIVE_INFINITY = float('-inf')
Math.POSITIVE_INFINITY = float('inf')
Math.NaN = float('nan')
Math.PI = python_lib_Math.pi

def _hx_init_Sys_environ():

	def _hx_local_0():
		Sys.environ = haxe_ds_StringMap()
		env = python_lib_Os.environ
		key = python_HaxeIterator(iter(env.keys()))
		while key.hasNext():
			key1 = key.next()
			_this = Sys.environ
			value = env.get(key1, None)
			_this.h[key1] = value
		return Sys.environ
	return _hx_local_0()
Sys.environ = _hx_init_Sys_environ()
Sys._programPath = sys_FileSystem.fullPath(python_lib_Inspect.getsourcefile(Sys))
python_Boot.keywords = set(['and', 'del', 'from', 'not', 'with', 'as', 'elif', 'global', 'or', 'yield', 'assert', 'else', 'if', 'pass', 'None', 'break', 'except', 'import', 'raise', 'True', 'class', 'exec', 'in', 'return', 'False', 'continue', 'finally', 'is', 'try', 'def', 'for', 'lambda', 'while'])
python_Boot.prefixLength = len('_hx_')
Kefa.main()


input()
_c = 1
_m = 0
_ = list(map(int, input().split()))
for __ in range(len(_) - 1):
	if _[__] <= _[__ + 1]:
		_c += 1
	else:
		if _c >= _m:
			_m = _c
		_c = 1
if _c >= _m:
	_m = _c
print(_m)


k = input()
k = int(k)
a = input().split(' ')
a = list(map(int, a))
x = 1
g = 1
for i in range(len(a) - 1):
	if a[i] <= a[i + 1]:
		x += 1
		if x > g:
			g = x
	else:
		x = 1
print(g)


import sys
from collections import defaultdict
from math import sqrt
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())

def s(d):
	dis = 1 + 4 * 2 * 3 * d
	ds = sqrt(dis)
	return (-1 + ds) / 6

def main():
	d = inp()
	v = inlt()
	l = v[0]
	m = 1
	mx = 1
	for (i, vv) in enumerate(v[1:]):
		if vv >= l:
			l = vv
			m += 1
			mx = max(m, mx)
		else:
			m = 1
			l = vv
	print(mx)
main()


n = int(input())
valores = list(map(int, input().split()))
ans = 1
parcial = 1
for i in range(n - 1):
	if valores[i + 1] >= valores[i]:
		parcial += 1
	else:
		parcial = 1
	if parcial > ans:
		ans = parcial
print(ans)


input()
lens = []
a = input().split()
s = 0
first = a[0]
for i in a:
	if int(i) >= int(first):
		s += 1
		first = i
	else:
		first = i
		lens.append(s)
		s = 1
lens.append(s)
print(max(lens))


n = input()
m = input().split()
c = 1
x = 1
for i in range(len(m) - 1):
	if int(m[i]) <= int(m[i + 1]):
		c += 1
		if x <= c:
			x = c
	else:
		c = 1
print(x)


n = int(input())
a = [int(i) for i in input().split(' ')]
x = 0
i = 0
temp = 1
if len(a) <= 1:
	x = 1
else:
	while i < len(a) - 1:
		if a[i] <= a[i + 1]:
			temp += 1
		else:
			temp = 1
		if temp > x:
			x = temp
		i += 1
print(x)


n = int(input())
A = [int(i) for i in input().split()]
count = 1
cList = []
if n == 1:
	print(1)
else:
	for i in range(n - 1):
		if A[i + 1] >= A[i] and i == n - 2:
			count += 1
			cList.append(count)
		elif A[i + 1] >= A[i]:
			count += 1
		else:
			cList.append(count)
			count = 1
	print(max(cList))


n = int(input())
l = input().split()
p = [int(x) for x in l]
ss = 1
sss = [1]
for i in range(n - 1):
	if p[i + 1] >= p[i]:
		ss += 1
		sss.append(ss)
	else:
		ss = 1
print(max(sss))


input()
a = list(map(int, input().split()))
ans = 0
cur_len = 1
a.append(a[len(a) - 1] - 1)
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		cur_len += 1
	else:
		ans = max(ans, cur_len)
		cur_len = 1
print(ans)


n = int(input())
t = list(map(int, input().split()))
r = []
x = 1
for i in range(n - 1):
	if t[i] <= t[i + 1]:
		x += 1
	else:
		r.append(x)
		x = 1
r.append(x)
print(max(tuple(r)))


n = int(input())
a_list = list(map(int, input().split()))
count = 1
count_lst = []
for i in range(len(a_list) - 1):
	if a_list[i + 1] >= a_list[i]:
		count += 1
	else:
		count_lst.append(count)
		count = 1
count_lst.append(count)
print(max(count_lst))


t = int(input())
l = list(map(int, input().split()))
s = 1
a = l[0]
r = []
for i in range(t):
	if i == t - 1:
		r.append(s)
		print(max(r))
		break
	if l[i] <= l[i + 1]:
		s += 1
	else:
		r.append(s)
		s = 1
		a = l[i]
		continue
	pass


n = int(input())
l = list(map(int, input().split()))
count = 1
maxi = 1
i = 1
while i < n:
	if l[i] >= l[i - 1]:
		count += 1
		i += 1
	else:
		count = 1
		i += 1
	maxi = max(maxi, count)
print(maxi)


n = int(input())
arr = list(map(int, input().split()))
l = 1
vida = l
for i in range(0, len(arr) - 1):
	if arr[i] <= arr[i + 1]:
		l += 1
	else:
		if vida < l:
			vida = l
		l = 1
if l > vida:
	vida = l
print(vida)


n = int(input())
a = list(map(int, input().split()))
count = 0
z = []
y = 0
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		count += 1
	else:
		z.append(count)
		count = 0
z.append(count)
print(max(z) + 1)


n = input()
a = list(map(int, list(input().split())))
sub = []
nd = 0
for k in range(len(a) - 1):
	if a[k + 1] >= a[k]:
		nd += 1
	else:
		sub.append(nd)
		nd = 0
sub.append(nd)
print(max(sub) + 1)


qtd = int(input())
x = list(map(int, input().split()))
back = x[0]
maior = 1
c = 1
for i in range(1, qtd):
	if back > x[i]:
		maior = max(maior, c)
		c = 1
		back = x[i]
	else:
		c += 1
		back = x[i]
maior = max(maior, c)
print(maior)


def f():
	input()
	n = [int(i) for i in input().split(' ')]
	m = 0
	j = 0
	c = 0
	for i in n:
		if i < j:
			if c > m:
				m = c
			c = 1
		else:
			c += 1
		j = i
	if c > m:
		m = c
	print(m)
f()


n = int(input())
a = map(int, input().split(' '))
maximum = 0
prev = 0
cur = 0
for i in a:
	if i >= prev:
		cur += 1
	else:
		maximum = max(cur, maximum)
		cur = 1
	prev = i
maximum = max(cur, maximum)
print(maximum)


n = int(input())
s = input().split()
a = []
for i in s:
	a.append(int(i))
c = sorted(a)
if a == c:
	print(n)
else:
	b = []
	i = 0
	while i < n - 1:
		c = 1
		for j in range(i + 1, n):
			if a[j - 1] <= a[j]:
				c = c + 1
				if j == n - 1:
					i = n
					b.append(c)
					break
			else:
				b.append(c)
				i = j
				break
	print(max(b))


x = int(input())
(n, f) = (0, 0)
p = list(map(int, input().split()))
for i in range(x - 1):
	if p[i] <= p[i + 1]:
		f += 1
	else:
		n = max(n, f)
		f = 0
n = max(n, f)
print(n + 1)


n = int(input())
lst = list(map(int, input().split()))
i = 0
count = 1
maximum = 1
while i < n - 1:
	if lst[i] <= lst[i + 1]:
		count += 1
		if count > maximum:
			maximum = count
	else:
		count = 1
	i += 1
print(maximum)


n = int(input())
l = [int(x) for x in input().split()]
l1 = []
count = 1
for i in range(1, len(l)):
	if l[i] >= l[i - 1]:
		count = count + 1
	else:
		l1.append(count)
		count = 1
l1.append(count)
if len(l1) >= 1:
	print(max(l1))
else:
	print(l[0])


(z, zz) = (input, lambda : list(map(int, z().split())))
zzz = lambda : [int(i) for i in stdin.readline().split()]
(szz, graph, mod, szzz) = (lambda : sorted(zz()), {}, 10 ** 9 + 7, lambda : sorted(zzz()))
from string import *
from re import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0 and x != 2 or x == 0:
			return 0
	return 1

def dfs(u, visit, graph):
	visit[u] = True
	for i in graph[u]:
		if not visit[i]:
			dfs(i, visit, graph)
num = 1
for _ in range(num):
	n = int(z())
	l = zzz()
	ans = 0
	x = l[-1]
	j = 1
	for i in range(2, n + 1):
		if l[-i] > x:
			ans = max(ans, j)
			j = 1
		else:
			j += 1
		x = l[-i]
	ans = max(ans, j)
print(ans)


input()
c = m = prevEl = 0
for i in map(int, input().split()):
	if i < prevEl:
		c = 1
	else:
		c = c + 1
	m = max(m, c)
	prevEl = i
print(m)


input()
revenues = [int(i) for i in input().split()]
l = 1
max = 1
for i in range(0, len(revenues) - 1):
	l = l + 1 if revenues[i + 1] >= revenues[i] else 1
	max = l if l > max else max
print(max)


n = int(input())
l = [int(l) for l in input().split()]
z = 0
j = 0
k = 0
for i in range(len(l)):
	if l[i] >= z:
		j += 1
		if k < j:
			k = j
	else:
		j = 1
	z = l[i]
print(k)


n = int(input())
a = list(map(int, input().split()))
ans = 1
temp = 1
for i in range(n - 1):
	if a[i + 1] < a[i]:
		ans = max(ans, temp)
		temp = 1
	else:
		temp += 1
print(max(ans, temp))


n = int(input())
lst = list(map(int, input().strip().split()))[:n]
max_len = 0
length = 1
for i in range(1, len(lst)):
	if lst[i] >= lst[i - 1]:
		length = length + 1
	else:
		if max_len < length:
			max_len = length
		length = 1
if max_len < length:
	max_len = length
if max_len == 0:
	print(length)
else:
	print(max_len)


n = int(input())
l = list(map(int, input().split()))
i = 0
res = []
while i < len(l) - 1:
	if l[i + 1] >= l[i]:
		count = 0
		while l[i + 1] >= l[i]:
			i = i + 1
			count = count + 1
			if i >= len(l) - 1:
				break
		res.append(count)
	i = i + 1
if len(res) == 0:
	print(1)
else:
	print(max(res) + 1)


import sys
n = int(input())
a = [int(i) for i in input().split()]
l = 1
ml = 1
for i in range(n):
	if i > 0:
		if a[i] >= a[i - 1]:
			l += 1
			ml = max(ml, l)
		else:
			l = 1
print(ml)


n = int(input())
money = list(map(int, input().rstrip().split()))
res = 0
i = 0
while i < n:
	count = 0
	temp = 0
	for j in range(i, n):
		if temp <= money[j]:
			temp = money[j]
			count += 1
		else:
			break
		i += 1
	res = max(res, count)
print(res)


n = int(input())
s = list(map(int, input().split()))
ans = [1]
for i in range(1, n):
	if s[i] >= s[i - 1]:
		ans.append(ans[-1] + 1)
	else:
		ans.append(1)
print(max(ans))


def firstSteps(li):
	count = 1
	m = 1
	for i in range(1, len(li)):
		if li[i - 1] <= li[i]:
			count += 1
			m = max(m, count)
		else:
			count = 1
	return m
n = int(input())
li = [int(x) for x in input().split()]
print(firstSteps(li))


n = int(input())
asd = [int(x) for x in input().split()]
ccc = 1
ddd = 0
eee = 1
while ddd < len(asd) - 1:
	if asd[ddd] <= asd[ddd + 1]:
		ccc = ccc + 1
	else:
		if ccc > eee:
			eee = ccc
		else:
			eee = eee
		ccc = 1
	ddd = ddd + 1
if ccc > eee:
	eee = ccc
else:
	pass
print(eee)


i1 = int(input())
i2 = list(map(int, input().strip().split()))
k1 = 1
k2 = 1
for j in range(len(i2) - 1):
	if i2[j] <= i2[j + 1]:
		k1 = k1 + 1
		if k1 > k2:
			k2 = k1
	if i2[j] > i2[j + 1]:
		k1 = 1
print(k2)


n = int(input())
a = list(map(int, input().split()))
k = 1
b = []
for i in range(1, n):
	if a[i] >= a[i - 1]:
		k += 1
	else:
		b.append(k)
		k = 1
b.append(k)
if len(b) == 0:
	print(n)
else:
	print(max(b))


p = int(input())
str = input().split()
count = 0
l = 0
countt = 0
for i in str:
	k = int(i)
	if k >= l:
		count = count + 1
	if count > countt:
		countt = count
	if k < l:
		count = 1
	l = int(i)
print(countt)


n = int(input())
lst = list(map(int, input().split()))
maximum = 1
i = 0
while i < n - 1:
	k = 1
	while i < n - 1 and lst[i] <= lst[i + 1]:
		i += 1
		k += 1
	if k > maximum:
		maximum = k
	i += 1
print(maximum)


def main():
	n = int(input())
	a = list(map(int, input().split()))
	sum = 1
	mylist = []
	if n == 1:
		return 1
	for i in range(1, n):
		sum = sum + 1 if a[i] >= a[i - 1] else 1
		mylist.append(sum)
	return max(mylist)
print(main())


n = int(input())
l = [int(x) for x in input().split()]
k = 1
o = 0
i = 1
while i < n:
	if l[i - 1] <= l[i]:
		k += 1
	else:
		o = max(o, k)
		k = 1
	i += 1
o = max(o, k)
print(o)


n = int(input())
a = list(map(int, input().split(' ')))
j = 0
c = 1
k = [0] * n
for i in range(1, n):
	if a[i] >= a[i - 1]:
		c += 1
		k[j] = c
	else:
		j += 1
		c = 1
max = k[0]
for i in range(0, n):
	if k[i] > max:
		max = k[i]
if max == 0:
	max = 1
print(max)


n = int(input())
a = [int(s) for s in input().split()]
k = maxi = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		k += 1
		if k > maxi:
			maxi = k
	else:
		k = 1
print(maxi)


n = int(input())
a = list(map(int, input().split()))
m = 1
mm = 1
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		mm += 1
	else:
		m = max(m, mm)
		mm = 1
m = max(m, mm)
print(m)


n = int(input())
string = input()
arrS = string.split(' ')
arrN = [int(i) for i in arrS]
checkMax = 0
rs = 1
check = 1
if n == 1:
	print(1)
	exit()
for i in range(n - 1):
	j = i + 1
	if arrN[j] >= arrN[i]:
		check += 1
	else:
		check = 1
	if check >= rs:
		rs = check
print(rs)


from sys import stdin, stdout
n = stdin.readline()
a = stdin.readline().split()
count = int(a[0])
k = 1
n = int(n)
highest = 1
a = list(map(int, a))
for i in range(1, n):
	if a[i] >= count:
		count = a[i]
		k += 1
	else:
		count = a[i]
		if k > highest:
			highest = k
		k = 1
if k > highest:
	highest = k
stdout.write(str(highest))


n = int(input())
seq = list(map(int, input().strip().split()))
flux = [seq[i + 1] - seq[i] for (i, j) in enumerate(seq) if i < len(seq) - 1]
sol = 0
max_sol = 0
for i in flux:
	if i >= 0:
		sol += 1
		if sol > max_sol:
			max_sol = sol
	else:
		sol = 0
print(max_sol + 1)


n = int(input())
l = list(map(int, input().split()))
c = 1
d = 0
for i in range(n - 1):
	if l[i] <= l[i + 1]:
		c += 1
	else:
		d = max(c, d)
		c = 1
d = max(c, d)
print(d)


input()
t = input().split()
s = n = 1
for (x, y) in zip(t[:-1], t[1:]):
	if int(x) > int(y):
		s = 0
	s += 1
	n = max(s, n)
print(n)


import sys
n = int(input())
a = [int(x) for x in input().split()]
cur = 0
ans = 0
for i in range(0, n):
	if i > 0 and a[i] >= a[i - 1]:
		cur += 1
	else:
		cur = 1
	ans = max(ans, cur)
print(ans)


n = int(input())
arr = list(map(int, input().split(' ')))
(max_, k) = (0, 1)
for i in range(1, n):
	if arr[i - 1] <= arr[i]:
		k += 1
		continue
	if max_ < k:
		max_ = k
	k = 1
if max_ < k:
	max_ = k
print(max_)


n = int(input())
money = [int(a) for a in input().split()]
money.append(0)
cnt = 1
lenList = []
for i in range(0, n):
	if money[i] <= money[i + 1]:
		cnt += 1
	else:
		lenList.append(cnt)
		cnt = 1
print(max(lenList))


size = int(input())
revenue = list(map(int, input().split()))
current_max = 1
maximum_length = 1
previous_r = revenue[0]
for r in revenue[1:]:
	if previous_r <= r:
		current_max += 1
		maximum_length = max(maximum_length, current_max)
	else:
		current_max = 1
	previous_r = r
print(maximum_length)


n = int(input())
l = list(map(int, input().split()))
aux = 1
max = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		aux += 1
	else:
		aux = 1
	if aux > max:
		max = aux
print(max)


n = int(input())
d = input()
l = []
for i in d.split():
	l.append(int(i))
dp = [1] * len(l)
for i in range(1, len(l)):
	if l[i] >= l[i - 1]:
		dp[i] = 1 + dp[i - 1]
print(max(dp))


numberOfDays = int(input())
currentLength = 0
maxLength = 1
salaries = map(int, input().split(' '))
previousSalary = 0
for salary in salaries:
	if salary >= previousSalary:
		currentLength += 1
		if currentLength > maxLength:
			maxLength += 1
	else:
		currentLength = 1
	previousSalary = salary
print(maxLength)


n = int(input())
seq = list(map(int, input().split()))
last = seq[0]
sub_seq = 1
max_sub_seq = 1
for i in range(1, n):
	if seq[i] >= last:
		sub_seq += 1
	else:
		sub_seq = 1
	if sub_seq > max_sub_seq:
		max_sub_seq = sub_seq
	last = seq[i]
print(max_sub_seq)


n = int(input())
step = input().split()
arr = []
hasil = 1
maxx = 1
for i in range(len(step)):
	arr.append(int(step[i]))
for i in range(n):
	if i == n - 1:
		break
	if arr[i + 1] >= arr[i]:
		hasil += 1
		if hasil > maxx:
			maxx = hasil
	else:
		hasil = 1
if maxx > n:
	maxx -= 1
print(maxx)


n = int(input())
a = [int(i) for i in input().split()]
(l, m, c) = (0, 0, 0)
for i in a:
	if i >= l:
		c += 1
	else:
		c = 1
	m = max(m, c)
	l = i
print(m)


n = int(input())
a = [int(i) for i in input().split()]
lmax = 0
i = 0
while i <= n - 1:
	l = 1
	j = i
	while j <= n - 2 and a[j + 1] >= a[j]:
		l += 1
		j += 1
	lmax = max(l, lmax)
	i += l
print(lmax)


n = int(input())
input_line = input()
inputs = input_line.split()
for i in range(n):
	inputs[i] = int(inputs[i])
first = inputs[0]
count = 1
counts = []
for i in range(n):
	if i == n - 1:
		counts.append(count)
		break
	if inputs[i] <= inputs[i + 1]:
		count = count + 1
	else:
		counts.append(count)
		count = 1
print(max(counts))


n = int(input())
ar = list(map(int, input().split()))
c = 1
m = 1
for i in range(1, n):
	if ar[i] >= ar[i - 1]:
		c += 1
	else:
		if m < c:
			m = c
		c = 1
if m < c:
	m = c
print(m)


n = int(input())
list1 = list(map(int, input().split()))
(max_len, count) = ([], 1)
if len(list1) == 1:
	print(1)
else:
	for i in range(n - 1):
		if list1[i] <= list1[i + 1]:
			count += 1
		else:
			max_len.append(count)
			count = 1
		if i == n - 2 and list1[i] <= list1[i + 1]:
			max_len.append(count)
	print(max(max_len))


count = int(input())
previous = answer = 0
counter = 0
for i in input().split():
	i = int(i)
	counter = counter + 1 if i >= previous else 1
	previous = i
	answer = max(answer, counter)
print(answer)


n = int(input())
L = input().split()
length = 1
max = 1
for i in range(n - 1):
	if int(L[i]) <= int(L[i + 1]):
		length += 1
		if length > max:
			max = length
	else:
		length = 1
print(max)


n = int(input())
a = list(map(int, input().split(' ')))
d1 = []
d2 = 1
if n == 1:
	d1 = [1]
for i in range(n - 1):
	if i == n - 2:
		d1.append(d2 + (a[n - 1] >= a[n - 2]))
		break
	if a[i] <= a[i + 1]:
		d2 += 1
	else:
		d1.append(d2)
		d2 = 1
print(str(max(d1)))


n = int(input())
l = list(map(int, input().split()))
res = 0
i = 0
if n == 1:
	print(1)
else:
	while i < n - 1:
		k = i
		c = 1
		while True:
			if k + 1 < n and l[k] <= l[k + 1]:
				c += 1
				k += 1
			else:
				break
		if res < c:
			res = c
		i = k + 1
	print(res)


n = int(input())
dp = [1 for i in range(n)]
arr = [int(i) for i in input().split()]
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		dp[i] = max(dp[i - 1] + 1, dp[i])
print(max(dp))


import sys
from os import path
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def solve():
	n = int(input())
	a = [int(i) for i in input().split()]
	count = 1
	ans = 1
	curr = a[0]
	for i in range(1, n):
		if a[i] >= curr:
			count += 1
		else:
			ans = max(ans, count)
			count = 1
		curr = a[i]
	ans = max(ans, count)
	print(ans)

def main():
	tc = 1
	for case in range(tc):
		solve()
main()


n = int(input())
a = [int(i) for i in input().split()]
k = 1
m = 1
for i in range(1, n):
	if a[i] < a[i - 1]:
		if k > m:
			m = k
		k = 1
	else:
		k += 1
if k > m:
	m = k
print(m)


N = int(input())
nums = list(map(int, input().split()))
count = 1
biggest = 1
for i in range(1, N):
	if nums[i] >= nums[i - 1]:
		count += 1
		biggest = max(biggest, count)
	else:
		count = 1
print(biggest)


n = int(input())
nums = list(map(int, input().split()))
count = 1
c = []
for i in range(1, n):
	if nums[i] >= nums[i - 1]:
		count += 1
	else:
		c.append(count)
		count = 1
if count == n:
	print(n)
else:
	c.append(count)
	c.sort()
	print(c[-1])


n = int(input())
l = list(map(int, input().split()))
p = l[0]
count = 1
max = 1
for i in range(1, len(l)):
	if l[i] >= p:
		count = count + 1
		if max < count:
			max = count
	else:
		count = 1
	p = l[i]
print(max)


n = int(input())
arr = list(map(int, input().split()))
arr = [0] + arr
x = 0
m = 0
for i in range(1, n + 1):
	if arr[i] >= arr[i - 1]:
		x += 1
	else:
		x = 1
	if x > m:
		m = x
print(m)


inputs_num = int(input())
lst = list(map(int, input().split()))
(temp, ctn) = (0, 0)
for i in range(inputs_num):
	temp += 1
	if temp > ctn:
		ctn = temp
	if i < inputs_num - 1 and lst[i + 1] < lst[i]:
		temp = 0
print(ctn)


n = int(input())
l = list(map(int, input().split()))
l1 = []
c = 1
for i in range(n - 1):
	if l[i] <= l[i + 1]:
		c += 1
	else:
		l1.append(c)
		c = 1
l1.append(c)
print(max(l1))


import sys
import os
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
import math
import random
import re
import heapq
n = int(input())
s = list(map(int, input().split()))
st = 0
max_len = 1
for i in range(1, len(s)):
	if s[i] < s[i - 1]:
		st = i
	if i - st + 1 > max_len:
		max_len = i - st + 1
print(max_len)


maximum = 1
cnt = 1
n = int(input())
days = list(map(int, input().split()))
for i in range(1, n):
	if days[i] >= days[i - 1]:
		cnt += 1
		if cnt > maximum:
			maximum = cnt
	else:
		cnt = 1
print(maximum)


n = int(input())
inp = list(map(int, input().split()))
best = 1
current = 1
for i in range(n - 1):
	if inp[i] <= inp[i + 1]:
		current += 1
	else:
		if current > best:
			best = current
		current = 1
if current > best:
	best = current
print(best)


n = int(input())
a = [int(i) for i in input().strip().split()]
out = []
out.append(1)
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		out.append(out[i] + 1)
	else:
		out.append(1)
print(max(out))


t = int(input())
p = 0
lst = list(map(int, input().split()))
max1 = 0
for i in range(t - 1):
	if lst[i] <= lst[i + 1]:
		p += 1
	else:
		p = 0
	if p > max1:
		max1 = p
print(max1 + 1)


import sys

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def input():
	return sys.stdin.readline().strip()
n = int(input())
Arr = get_array()
max_length_till_now = 1
current_length = 1
for i in range(1, n):
	if Arr[i] >= Arr[i - 1]:
		current_length += 1
	else:
		if max_length_till_now < current_length:
			max_length_till_now = current_length
		current_length = 1
print(max(max_length_till_now, current_length))


n = int(input())
array = [int(number) for number in input().split()]
new_array = [0] * n
new_array[0] = 1
for i in range(1, n):
	if array[i] >= array[i - 1]:
		new_array[i] = new_array[i - 1] + 1
	else:
		new_array[i] = 1
print(max(new_array))


from sys import stdin

def main():
	n = int(stdin.readline())
	a = [int(x) for x in stdin.readline().split()]
	(maxi, cnt) = (0, 1)
	for i in range(len(a) - 1):
		if a[i] > a[i + 1]:
			if cnt > maxi:
				maxi = cnt
			cnt = 1
		else:
			cnt += 1
	if cnt > maxi:
		maxi = cnt
	print(maxi)
main()


n = int(input())
s = [int(i) for i in input().split()]
c = 0
m = 0
for i in range(n - 1):
	if s[i] <= s[i + 1]:
		c = c + 1
		if c > m:
			m = c
	else:
		c = 0
print(m + 1)


n = int(input())
arr = [int(x) for x in input().split(' ')]
ln = 1
mxln = 1
for i in range(len(arr) - 1):
	if arr[i] <= arr[i + 1]:
		ln += 1
	else:
		ln = 1
	mxln = max(mxln, ln)
print(mxln)


n = int(input())
days = list(map(int, input().split()))
maxstr1 = 0
anot = 0
last = 0
for d in days:
	if d >= last:
		anot += 1
	else:
		if anot > maxstr1:
			maxstr1 = anot
		anot = 1
	last = d
if anot > maxstr1:
	maxstr1 = anot
print(maxstr1)


def main():
	input()
	a = list(map(int, input().split()))
	ans = 0
	count = 1
	for i in range(len(a) - 1):
		if a[i] <= a[i + 1]:
			count += 1
		else:
			ans = max(ans, count)
			count = 1
	ans = max(ans, count)
	print(ans)
	pass
main()


quant = int(input())
digits = input().split()
result = 0
flag = 1
for i in range(1, quant):
	if int(digits[i]) >= int(digits[i - 1]):
		flag = flag + 1
	elif int(digits[i]) < int(digits[i - 1]):
		if flag > result:
			result = flag
		flag = 1
	if i == quant - 1:
		if flag > result:
			result = flag
if result == 0:
	print(flag)
else:
	print(result)


n = int(input())
A = list(map(int, input().split()))
B = []
t = 1
if n == 1:
	print('1')
else:
	for i in range(n - 1):
		if A[i] > A[i + 1]:
			t = 1
			B.append(t)
		else:
			t = t + 1
			B.append(t)
	print(max(B))


input()
a = [int(i) for i in input().split()]
(nr, res) = (len(a) - 1, 1)
for i in range(len(a) - 2, -1, -1):
	if a[i] > a[i + 1]:
		nr = i
	res = max(res, nr - i + 1)
print(res)


n = int(input())
numbers = [int(x) for x in input().split()]
count = 1
maxLength = 1
for i in range(1, n):
	if numbers[i] >= numbers[i - 1]:
		count += 1
		if i == n - 1:
			if count > maxLength:
				maxLength = count
	else:
		if count > maxLength:
			maxLength = count
		count = 1
print(maxLength)


m = 0
n = int(input())
s = list(map(int, input().split()))
s.append(0)
k = 1
for i in range(1, n + 1):
	if s[i] >= s[i - 1]:
		k += 1
	else:
		m = max(k, m)
		k = 1
print(m)


n = int(input())
s = input().split()
counter = 1
inyt = 1
for i in range(n - 1):
	if int(s[i]) <= int(s[i + 1]):
		counter = counter + 1
	else:
		counter = 1
	if counter >= inyt:
		inyt = counter
print(inyt)


n = int(input())
arr = list(map(int, input().strip().split()))[:n]
m = len(arr)
brr = []
count = 0
a = arr[0]
for i in range(m):
	if arr[i] >= a:
		count = count + 1
		a = arr[i]
		if i == m - 1:
			brr.append(count)
		else:
			pass
	else:
		brr.append(count)
		count = 1
		a = arr[i]
c = sorted(brr)
j = len(c)
print(c[j - 1])


n = int(input())
arr = [int(x) for x in input().split()]
curr = 1
m = 1
for i in range(1, len(arr)):
	if arr[i] >= arr[i - 1]:
		curr += 1
	else:
		curr = 1
	if curr > m:
		m = curr
print(m)


n = int(input())
a = [int(x) for x in input().split()]
count = 1
mx = 1
for i in range(n - 1):
	if a[i + 1] < a[i]:
		mx = max(mx, count)
		count = 1
	else:
		count += 1
mx = max(mx, count)
print(mx)


sq = input()
sq = list(map(int, input().split()))
(tln, ln) = (1, 1)
if len(sq) > 1:
	for (index, value) in enumerate(sq[1:], 1):
		prev = sq[index - 1]
		if value >= prev:
			tln += 1
		else:
			ln = max(tln, ln)
			tln = 1
ln = max(tln, ln)
print(ln)


n = int(input())
x = list(map(int, input().split()))
cunt = 0
mx = 0
for (i, j) in enumerate(x):
	if i == 0 or j >= x[i - 1]:
		cunt += 1
	else:
		if cunt > mx:
			mx = cunt
		cunt = 1
if cunt > mx:
	mx = cunt
print(mx)


n = int(input())
money = [int(x) for x in input().split()]
a = 1
m = 1
for i in range(n - 1):
	if money[i] <= money[i + 1]:
		a += 1
		if i == n - 2:
			if a > m:
				m = a
	elif money[i] > money[i + 1]:
		if a > m:
			m = a
		a = 1
print(m)


count = int(input())
numbers = list(map(int, input().split(' ')))
temp = int('1')
max = int('1')
for i in range(0, count - 1):
	if numbers[i] <= numbers[i + 1]:
		temp += 1
	else:
		temp = int('1')
	if temp > max:
		max = temp
print(max)


n = int(input())
li = list(map(int, input().strip().split()))
c = 1
cc = [1]
for i in range(len(li) - 1):
	if li[i] <= li[i + 1]:
		c += 1
	else:
		c = 1
	cc.append(c)
print(max(cc))


m = int(input())
a = [int(x) for x in input().split()]
ans = 0
dp = [1]
for i in range(1, m):
	if a[i] >= a[i - 1]:
		dp.append(dp[i - 1] + 1)
	else:
		dp.append(int(1))
	ans = max(ans, dp[i])
if m == 1:
	ans = 1
print(ans)


a = int(input())
b = list(map(int, input().split(' ')))
mx = 0
temp = 0
for i in range(0, a - 1):
	if b[i] <= b[i + 1]:
		temp += 1
	else:
		temp = 0
	if mx < temp:
		mx = temp
print(mx + 1)


n = int(input())
a = list(map(int, input().split(' ')))
length = 1
i = 0
current_length = 1
while i < len(a) - 1:
	if a[i] <= a[i + 1]:
		current_length += 1
		if current_length > length:
			length = current_length
	else:
		current_length = 1
	i += 1
print(length)


n = int(input())
a = list(map(int, input().split()))
l = []
for i in range(n):
	if i == 0:
		l.append(1)
	elif a[i - 1] > a[i]:
		l.append(0)
	elif l[i - 1] == 0:
		l.append(l[i - 1] + 2)
	else:
		l.append(l[i - 1] + 1)
print(max(l))


def rex():
	n = int(input())
	maxL = 0
	temp = 0
	x = input().split(' ')
	x[0] = int(x[0])
	for i in range(1, n):
		x[i] = int(x[i])
		if x[i] - x[i - 1] >= 0:
			temp += 1
		else:
			if maxL < temp:
				maxL = temp
			temp = 0
		if i == n - 1:
			if maxL < temp:
				maxL = temp
	return maxL + 1
print(rex())


n = int(input())
a = list(map(int, input().split()))
i = -1
m = 0
q = 0
while i < n - 1:
	i += 1
	if i == 0 or a[i - 1] > a[i]:
		if q > m:
			m = q
		q = 0
	else:
		q += 1
if q > m:
	m = q
print(m + 1)


n = int(input())
arr = [int(x) for x in input().split()]
res = 0
k = 1
for i in range(1, n):
	if arr[i - 1] <= arr[i]:
		k += 1
	else:
		res = max(res, k)
		k = 1
res = max(res, k)
print(res)


n = int(input())
l = [int(e) for e in input().split()]
count = 1
m = -1
for i in range(len(l) - 1):
	if l[i] > l[i + 1]:
		m = max(m, count)
		count = 1
	else:
		count += 1
print(max(m, count))


n = int(input())
l = list(map(int, input().split()))
m = 0
t = 0
for e in l:
	if t == 0:
		t = 1
		s = e
	else:
		if s <= e:
			t += 1
		else:
			t = 1
		s = e
	if m < t:
		m = t
print(m)


n = int(input())
arr = list(map(int, input().split()))
gmax = 0
lmax = 0
for i in range(1, len(arr)):
	if arr[i] >= arr[i - 1]:
		lmax += 1
	else:
		if lmax > gmax:
			gmax = lmax
		lmax = 0
print(gmax + 1 if gmax > lmax else lmax + 1)


n = int(input())
lista = input().split()
lista = [int(x) for x in lista]
contador = 0
cont_max = 0
for i in range(n - 1):
	if lista[i + 1] >= lista[i]:
		contador += 1
	else:
		if contador > cont_max:
			cont_max = contador
		contador = 0
if contador > cont_max:
	print(contador + 1)
else:
	print(cont_max + 1)


n = int(input())
l = list(map(int, input().split()))
tmax = 1
cmax = 1
for i in range(len(l) - 1):
	if l[i] <= l[i + 1]:
		cmax += 1
	else:
		if cmax > tmax:
			tmax = cmax
		cmax = 1
if cmax > tmax:
	print(cmax)
else:
	print(tmax)


input()
si = list(map(int, input().split()))
count = 1
maxc = 0
for i in range(len(si) - 1):
	(a, b) = (si[i], si[i + 1])
	if b >= a:
		count += 1
	else:
		if count > maxc:
			maxc = count
		count = 1
if count > maxc:
	print(count)
else:
	print(maxc)


no_tier = int(input())
segments = [int(x) for x in input().split()]
max_cnt = 1
cnt = 1
for i in range(1, no_tier):
	if segments[i] >= segments[i - 1]:
		cnt += 1
	else:
		cnt = 1
	if cnt > max_cnt:
		max_cnt = cnt
print(max_cnt)


n = input()
count = 1
max = 1
lis = [int(x) for x in input().split()]
for i in range(len(lis) - 1):
	if lis[i + 1] >= lis[i]:
		count += 1
	else:
		count = 1
	if max < count:
		max = count
print(max)


n = int(input())
a = [int(i) for i in input().split()]
f = [0] * n
f[0] = 1
max_value = 1
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		f[i] = f[i - 1] + 1
		if f[i] > max_value:
			max_value = f[i]
	else:
		f[i] = 1
print(max_value)


n = int(input())
a = list(map(int, input().split()))
best = [1 for i in range(n)]
tot = -1
for i in range(1, n):
	if a[i - 1] <= a[i]:
		best[i] = best[i - 1] + 1
	tot = max(tot, best[i])
tot = max(tot, best[-1])
print(tot)


k = int(input())
l = [int(i) for i in input().split()]
n = 1
ln = 1
for i in range(1, k):
	if l[i] >= l[i - 1]:
		n += 1
		if n > ln:
			ln = n
	else:
		n = 1
print(ln)


y = int(input())
k = [int(x) for x in input().split()]
c = []
res = 1
res = int(res)
if len(k) == 1:
	print(1)
else:
	for i in range(1, y):
		if len(k) == 1:
			print(1)
			break
		if k[i - 1] <= k[i]:
			res += 1
			c.append(res)
		else:
			c.append(res)
			res = 1
	print(max(c))


n = int(input())
ch = input()
l = ch.split()
c = 1
i = 0
l1 = []
l.append(0)
for i in range(len(l)):
	l[i] = int(l[i])
for i in range(len(l) - 1):
	if l[i] <= l[i + 1]:
		c += 1
	else:
		l1.append(c)
		c = 1
print(max(l1))


n = int(input())
a = map(int, input().split())
prev = 0
max_subsequent = 0
subsequent = 0
for i in a:
	if i < prev:
		max_subsequent = max(max_subsequent, subsequent)
		subsequent = 0
	subsequent += 1
	prev = i
max_subsequent = max(max_subsequent, subsequent)
print(max_subsequent)


n = int(input())
li1 = list(map(int, input().split()))
cn = 1
li1.append(0)
tp = []
for i in range(1, n + 1):
	if li1[i] < li1[i - 1]:
		tp.append(cn)
		cn = 1
	else:
		cn += 1
try:
	print(max(tp))
except:
	print(0)


import unittest
import sys

class Steps:

	def __init__(self, test_inputs=None):
		it = iter(test_inputs.split('\n')) if test_inputs else None

		def uinput():
			return next(it) if it else sys.stdin.readline().rstrip()
		[self.n] = map(int, uinput().split())
		self.nums = list(map(int, uinput().split()))

	def calculate(self):
		maxsf = 0
		maxc = 0
		for i in range(len(self.nums)):
			if i != 0:
				if self.nums[i] >= self.nums[i - 1]:
					maxc += 1
					maxsf = max(maxsf, maxc)
				else:
					maxc = 0
		return str(maxsf + 1)

class unitTests(unittest.TestCase):

	def test_single_test(self):
		test = '6\n2 2 1 3 4 1'
		d = Steps(test)
		self.assertEqual(d.n, 6)
		self.assertEqual(d.nums[0:3], [2, 2, 1])
		self.assertEqual(Steps(test).calculate(), '3')
		test = '3\n2 2 9'
		self.assertEqual(Steps(test).calculate(), '3')
		test = '2\n0'
		self.assertEqual(Steps(test).calculate(), '1')
		test = '2\n0 0'
		self.assertEqual(Steps(test).calculate(), '2')
		test = '3\n0 -1 1 1'
		self.assertEqual(Steps(test).calculate(), '3')
		test = ''

	def time_limit_test(self, nmax):
		import random
		import timeit
		test = str(nmax) + ' ' + str(nmax) + '\n'
		numnums = [str(i) + ' ' + str(i + 1) for i in range(nmax)]
		test += '\n'.join(numnums) + '\n'
		nums = [random.randint(1, 10000) for i in range(nmax)]
		test += ' '.join(map(str, nums)) + '\n'
		start = timeit.default_timer()
		d = Steps(test)
		calc = timeit.default_timer()
		d.calculate()
		stop = timeit.default_timer()
		print('\nTimelimit Test: ' + '{0:.3f}s (init {1:.3f}s calc {2:.3f}s)'.format(stop - start, calc - start, stop - calc))
sys.setrecursionlimit(100000)
if sys.argv[-1] == '-ut':
	unittest.main(argv=[' '])
sys.stdout.write(Steps().calculate())


n = int(input())
s = [int(x) for x in input().split()]
a = []
q = []
for i in range(n - 1):
	if s[i] <= s[i + 1]:
		a.append(s[i])
		q.append(a)
	else:
		a = []
print(1 if q == [] else max((len(i) for i in q)) + 1)


n = int(input())
s = list(map(int, input().split()))
i = 1
t = []
for x in range(len(s) - 1):
	if s[x] <= s[x + 1]:
		i += 1
	else:
		t.append(i)
		i = 1
t.append(i)
t.sort()
print(t[-1])


n = int(input())
a = [int(x) for x in input().split()]
b = [1] * n
c = a[0]
for i in range(1, n):
	if a[i] >= c:
		b[i] = 1 + b[i - 1]
	c = a[i]
print(max(b))


n = int(input())
arr = [int(i) for i in input().split()]
c = 0
ma = 0
for i in range(len(arr) - 1):
	if arr[i] <= arr[i + 1]:
		c = c + 1
	else:
		c = 0
	if c >= ma:
		ma = c
print(ma + 1)


n = int(input())
a = [int(i) for i in input().split()]
b = [0] * n
b[0] = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		b[i] = b[i - 1] + 1
	else:
		b[i] = 1
print(max(b))


import math
import sys
withFile = 0
if withFile == 1:
	fin = open('input.txt', 'r')
	fout = open('output.txt', 'w')

def getl():
	if withFile == 0:
		return input()
	else:
		return fin.readline()

def printl(s):
	if withFile == 0:
		print(s)
	else:
		fout.write(str(s))

def get_arr():
	x = getl().split(' ')
	if x[-1] == '':
		x = x[:-1]
	return list(map(int, x))
n = get_arr()[0]
a = get_arr()
f = [1 for i in range(n)]
for i in range(n):
	if i == 0:
		continue
	if a[i] >= a[i - 1]:
		f[i] += f[i - 1]
print(max(f))
if withFile == 1:
	fin.close()
	fout.close()


N = int(input())
moneys = [int(i) for i in input().split(' ')]
length = 0
ans = 0
lasm = moneys[0]
for m in moneys:
	if m >= lasm:
		length += 1
		lasm = m
		continue
	if length > ans:
		ans = length
	length = 1
	lasm = m
print(max(ans, length))


n = int(input())
l = [int(x) for x in input().split()]
maxi = 1
curr = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		curr += 1
	else:
		curr = 1
	if curr > maxi:
		maxi = curr
print(maxi)


_ = input()
l = list(map(int, input().split()))
maxL = 1
curL = 1
for i in range(1, len(l)):
	if l[i] < l[i - 1]:
		curL = 1
		continue
	curL += 1
	if curL > maxL:
		maxL = curL
print(maxL)


n = int(input())
a = [int(x) for x in input().split()]
r = [1] * len(a)
maxi = 1
for i in range(1, len(a)):
	if a[i - 1] <= a[i]:
		r[i] = r[i - 1] + 1
		maxi = max(maxi, r[i])
print(maxi)


n = int(input())
lst = list(map(int, input().split()))
count = max_count = 1
i = 0
while i < n - 1:
	if lst[i + 1] >= lst[i]:
		count += 1
	else:
		count = 1
	max_count = max(count, max_count)
	i += 1
print(max_count, end='')


number = int(input())
data = list(map(int, input().split()))
(a, result, count) = (0, [], 0)
for m in data:
	if m >= a:
		count += 1
	else:
		result.append(count)
		count = 1
	a = m
result.append(count)
print(max(result))


def mlnds():
	input()
	numbers = input().split(' ')
	max_len = 0
	previous_num = 0
	cur_len = 0
	for (ind, num) in enumerate(numbers):
		num = int(num)
		if ind == 0:
			previous_num = num
			cur_len = 1
		elif num >= previous_num:
			previous_num = num
			cur_len += 1
		else:
			previous_num = num
			cur_len = 1
		if cur_len > max_len:
			max_len = cur_len
	return max_len
print(mlnds())


n = int(input())
lst = list(map(int, input().strip().split()))
(a, b, c) = (0, 0, 1)
l = []
if len(lst) > 1:
	for (i, j) in enumerate(range(len(lst) - 1), start=1):
		s = lst[i - 1]
		if lst[i] >= s:
			c += 1
		else:
			l.append(c)
			c = 1
else:
	l.append(1)
l.append(c)
m = max(l)
print(m)


n = int(input())
ar = list(map(int, input().split()))
(cnt, m) = (1, 0)
tmp = ar[0]
for i in range(1, len(ar)):
	if tmp > ar[i]:
		m = cnt if cnt > m else m
		cnt = 1
	else:
		cnt += 1
	tmp = ar[i]
m = cnt if cnt > m else m
print(m)


n = int(input())
c = 1
arr = list(map(int, input().split()))
maxi = c
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		c += 1
	else:
		c = 1
	if maxi < c:
		maxi = c
print(maxi)


n = int(input())
a = list(map(int, input().split()))
a.append(-1)
maxx = tmax = 1
for i in range(n):
	if a[i] <= a[i + 1]:
		tmax += 1
		if tmax >= maxx:
			maxx = tmax
	else:
		tmax = 1
print(maxx)


n = int(input())
s = input()
a = [int(i) for i in s.split()]
ans = 0
k = 0
for i in range(n - 1):
	if a[i + 1] >= a[i]:
		ans += 1
	else:
		break
if ans == n - 1:
	print(n)
else:
	j = ans + 1
	while j <= n - 2:
		if a[j + 1] >= a[j]:
			k += 1
		else:
			ans = max(ans, k)
			k = 0
		j += 1
	ans = max(ans, k)
	print(ans + 1)


import sys
n = int(sys.stdin.readline())
l = list(map(int, sys.stdin.readline().split()))
ans = 1
maxx = 1
k = l[0]
for i in range(1, n):
	if l[i] >= k:
		maxx += 1
		k = l[i]
	else:
		ans = max(ans, maxx)
		maxx = 1
		k = l[i]
ans = max(ans, maxx)
print(ans)


input()
num = n = count = 0
for m in input().split():
	m = int(m)
	num = num + 1 if m >= n else 1
	count = max(count, num)
	n = m
print(count)


n = int(input())
c = maxV = t = 0
for i in input().split():
	i = int(i)
	c = c + 1 if i >= t else 1
	maxV = max(maxV, c)
	t = i
print(maxV)


n = int(input())
nums = list(map(int, input().split()))
dp = [1 for i in range(n)]
for i in range(1, n):
	if nums[i - 1] <= nums[i]:
		dp[i] = max(dp[i - 1] + 1, dp[i])
ans = 0
for i in range(n):
	ans = max(dp[i], ans)
print(ans)


from sys import stdin, stdout, exit as sys_ret
(f_input, f_print, f_flush) = (stdin.readline, stdout.write, stdout.flush)
amount = int(f_input())
numbers = [int(i) for i in f_input().split()]
(length, result) = (1, 0)
for i in range(1, amount):
	if numbers[i] >= numbers[i - 1]:
		length += 1
	else:
		result = max(result, length)
		length = 1
f_print(str(max(result, length)))


t = int(input())
c = 1
max = 1
a = list(map(int, input().split(' ')))
for i in range(t - 1):
	if a[i] <= a[i + 1]:
		c = c + 1
		if max < c:
			max = c
	else:
		c = 1
print(max)


def main():
	n = int(input())
	A = tuple(map(int, input().rstrip().split()))
	(ans, cnt, cur) = (0, 0, 0)
	for i in A:
		if i >= cur:
			cnt += 1
		else:
			ans = max(ans, cnt)
			cnt = 1
		cur = i
	print(max(ans, cnt))
main()


n = input()
lst = [int(i) for i in input().split()]
(res, pntr, cnt) = (0, 0, 0)
for i in lst:
	if i >= pntr:
		cnt += 1
	else:
		if cnt > res:
			res = cnt
		cnt = 1
	pntr = i
if cnt > res:
	res = cnt
print(res)


s = int(input())
r = list(map(int, input().split()))
w = []
count = 1
for i in range(s - 1):
	if r[i] <= r[i + 1]:
		count += 1
	else:
		w.append(count)
		count = 1
w.append(count)
print(max(w))


n = int(input())
nums = [int(x) for x in input().split()]
seq_len = 1
max_len = 1
prev = nums[0]
for number in nums[1:]:
	if number < prev:
		seq_len = 1
	else:
		seq_len += 1
	if seq_len > max_len:
		max_len = seq_len
	prev = number
print(max_len)


n = int(input())
data = [int(i) for i in input().split()]
p = 1
ans = 1
for i in range(n - 1):
	if data[i] <= data[i + 1]:
		p += 1
		ans = max(ans, p)
	else:
		ans = max(ans, p)
		p = 1
print(ans)


n = int(input())
a = list(map(int, input().split()))
start = 0
mx = 0
while start < n:
	end = start + 1
	while end < n:
		if a[end] >= a[end - 1]:
			end += 1
		else:
			mx = max(mx, end - start)
			start = end
			break
	if start == n - 1:
		mx = max(mx, 1)
		break
	if end == n:
		mx = max(mx, end - start)
		break
print(mx)


s = input()
p = input()
p = p.split()
l = list()
l2 = list()
count = 0
for i in p:
	l.append(int(i))
for j in range(len(l) - 1):
	m = l[j]
	n = l[j + 1]
	if m <= n:
		count = count + 1
	else:
		k = count + 1
		l2.append(k)
		count = 0
h = count + 1
l2.append(h)
print(max(l2))


n = input()
x = input()
y = x.split()
(maxcount, count) = (1, 1)
for i in range(int(n) - 1):
	if int(y[i]) <= int(y[i + 1]):
		count += 1
	else:
		maxcount = max(maxcount, count)
		count = 1
print(max(maxcount, count))


N = int(input())
(A, V) = ([int(x) for x in input().split()], [0])
for i in range(1, len(A)):
	if A[i] < A[i - 1]:
		V.append(i)
V.append(N)
result = 0
for i in range(1, len(V)):
	result = max(result, V[i] - V[i - 1])
print(result)


n = int(input())
a = list(map(int, input().split(' ')))
length = []
i = 1
while i < n:
	sub = 0
	while i < n and a[i] >= a[i - 1]:
		sub += 1
		i += 1
	i += 1
	length.append(sub)
print(max(length) + 1 if length else 1)


n = int(input())
a = list(map(int, input().split()))
m = 0
mm = 0
l = len(a)
for i in range(l):
	if i == 0:
		m += 1
	elif a[i - 1] <= a[i]:
		m += 1
	elif a[i - 1] > a[i]:
		m = 1
	mm = max(mm, m)
print(mm)


q = int(input())
w = list(map(int, input().split()))
k = []
e = [w[0]]
for i in range(1, q):
	if w[i] < e[-1]:
		k.append(e)
		e = [w[i]]
		i += 1
	else:
		e.append(w[i])
k.append(e)
l = []
for i in k:
	l.append(len(i))
print(max(l))


n = int(input())
s = input().split(' ')
for i in range(n):
	s[i] = int(s[i])
L = 1
d = 1
for i in range(1, n):
	if s[i] >= s[i - 1]:
		d += 1
		if d > L:
			L = d
	else:
		d = 1
print(L)


n = int(input())
l = list(map(int, input().split()))
a = [1 for x in l]
for i in range(1, n):
	if l[i] >= l[i - 1]:
		a[i] += a[i - 1]
print(max(a))


n = int(input())
a = [int(z) for z in input().split()]
count = 0
max = -10 ** 7
current = a[0]
for ele in a:
	if ele < current:
		count = 1
	else:
		count += 1
	current = ele
	if count > max:
		max = count
print(max)


input()
l = list(map(int, input().strip().split()))
prev = 0
m = 0
n = 0
for i in l:
	if i >= prev:
		n += 1
		m = max(m, n)
	else:
		n = 1
	prev = i
print(max(m, n))


n = int(input())
a = [k for k in map(int, input().split())]
progress = [1 for k in a]
for i in range(1, n):
	if a[i] >= a[i - 1]:
		progress[i] = progress[i - 1] + 1
print(max(progress))


n = int(input())
ai = [int(k) for k in input().split()]
l = []
nCount = 1
for i in range(0, n - 1, 1):
	if ai[i] <= ai[i + 1]:
		nCount += 1
	else:
		l.append(nCount)
		nCount = 1
l.append(nCount)
l.sort()
print(l[-1])


n = input()
n = int(n)
aq = input()
j = 0
a = aq.split(' ')
j = 0
while j < n:
	a[j] = int(a[j])
	j = j + 1
i = 0
ans = 0
temp = 1
while i < n - 1:
	if a[i + 1] >= a[i]:
		temp = temp + 1
		i = i + 1
	else:
		if temp > ans:
			ans = temp
		temp = 1
		i = i + 1
if temp > ans:
	ans = temp
print(ans)


n = int(input())
l = list([int(x) for x in input().split()])
a = 1
s = 1
for i in range(n - 1):
	if l[i] > l[i + 1]:
		a = 1
	else:
		a += 1
		s = max(s, a)
print(s)


x = input()
y = input().split()
a = len(y) - 1
s = 1
l = []
for i in range(0, a):
	if int(y[i]) <= int(y[i + 1]):
		s = s + 1
	else:
		l.append(s)
		s = 1
else:
	l.append(s)
print(max(l))


x = int(input())
y = input().split(' ')
y.append('-1')
max = 1
m = 0
for i in range(1, x + 1):
	if int(y[i]) >= int(y[i - 1]):
		max = max + 1
	else:
		if max > m:
			m = max
		max = 1
print(m)


n = int(input())
l = list(map(int, input().split()))
m = j = 1
for i in range(n - 1):
	if l[i + 1] >= l[i]:
		j += 1
		m = max(j, m)
	else:
		j = 1
print(m)


input()
prev = -1
nums = list(map(int, input().split(' ')))
max_length = 0
length = 0
for num in nums:
	if num >= prev:
		length += 1
		max_length = max(max_length, length)
	else:
		length = 1
	prev = num
print(max_length)


n = int(input())
l = [int(x) for x in input().split()]
a = 1
b = l[0]
c = []
if n >= 2:
	for i in range(1, n):
		if l[i] >= b:
			b = l[i]
			a += 1
			c.append(a)
		else:
			b = l[i]
			a = 1
			c.append(a)
	print(max(c))
else:
	print(1)


n = int(input())
l = list(map(int, input().split()))
ma = l[0]
z = 1
v = []
for i in range(1, n):
	if l[i] >= ma:
		ma = l[i]
		z += 1
	else:
		ma = l[i]
		z = 1
	v.append(z)
if v == []:
	print(1)
else:
	print(max(v))


a = int(input())
b = [int(i) for i in input().split(' ')]
i = 0
k = 1
d = 0
max_len = 0
while i < len(b) - 1:
	if b[i] <= b[i + 1]:
		k += 1
		i += 1
		d += 1
	elif k > max_len:
		max_len = k
		k = 1
		i += 1
	else:
		k = 1
		i += 1
if d == len(b) - 1:
	print(len(b))
elif k > max_len:
	print(k)
else:
	print(max_len)


n = int(input())
lst = [int(x) for x in input().split()]
nmax = 1
counter = 1
for i in range(0, n - 1):
	if lst[i] <= lst[i + 1]:
		counter += 1
	else:
		counter = 1
	if counter > nmax:
		nmax = counter
print(nmax)


from sys import stdin, stdout
I = lambda : stdin.readline().strip()
read = lambda : list(map(int, input().split()))
n = int(I())
arr = read()
temp = -10 ** 9
max_count = 0
count = 0
for i in arr:
	if i >= temp:
		count += 1
	else:
		max_count = max(count, max_count)
		count = 1
	temp = i
max_count = max(count, max_count)
print(max_count)


import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue

class Scanner:

	@staticmethod
	def int():
		return int(sys.stdin.readline().rstrip())

	@staticmethod
	def string():
		return sys.stdin.readline().rstrip()

	@staticmethod
	def map_int():
		return [int(x) for x in Scanner.string().split()]

	@staticmethod
	def string_list(n):
		return [input() for i in range(n)]

	@staticmethod
	def int_list_list(n):
		return [Scanner.map_int() for i in range(n)]

	@staticmethod
	def int_cols_list(n):
		return [int(input()) for i in range(n)]

class Math:

	@staticmethod
	def gcd(a, b):
		if b == 0:
			return a
		return Math.gcd(b, a % b)

	@staticmethod
	def lcm(a, b):
		return a * b // Math.gcd(a, b)

	@staticmethod
	def round_up(a, b):
		return -(-a // b)

	@staticmethod
	def is_prime(n):
		if n < 2:
			return False
		if n == 2:
			return True
		if n % 2 == 0:
			return False
		d = int(n ** 0.5) + 1
		for i in range(3, d + 1, 2):
			if n % i == 0:
				return False
		return True

class PriorityQueue:

	def __init__(self, l=[]):
		self.q = l
		heapq.heapify(self.q)
		return

	def push(self, n):
		heapq.heappush(self.q, n)
		return

	def pop(self):
		return heapq.heappop(self.q)
MOD = int(1000000000.0) + 7
INF = int(1000000000000000.0)

def main():
	N = Scanner.int()
	A = Scanner.map_int()
	ans = 0
	cnt = 1
	for i in range(1, N):
		if A[i - 1] <= A[i]:
			cnt += 1
		else:
			ans = max(ans, cnt)
			cnt = 1
	ans = max(ans, cnt)
	print(ans)
main()


n = int(input())
c = 0
dp = [1] * (n + 1)
arr = [int(x) for x in input().split()]
for index in range(2, n + 1):
	if arr[index - 2] <= arr[index - 1]:
		dp[index] = 1 + dp[index - 1]
	else:
		dp[index] = 1
print(max(dp))


def main():
	size = int(input())
	arr = list(map(lambda x: int(x), input().split(' ')))
	max = 1
	local = 1
	for i in range(1, size):
		if arr[i] >= arr[i - 1]:
			local += 1
			if local > max:
				max = local
		else:
			local = 1
	print(max)
main()


n = int(input())
seq = list(map(int, input().split()))
ans = 1
cnt = 1
for i in range(n - 1):
	if seq[i + 1] < seq[i]:
		ans = max(ans, cnt)
		cnt = 1
	else:
		cnt += 1
ans = max(ans, cnt)
print(ans)


input()
r = 0
t = 0
a = 10 ** 10
for x in map(int, input().split()):
	if x < a:
		t = 0
	t += 1
	r = max(r, t)
	a = x
print(r)


days = input()
money_list = input().split(' ')
max_sequence = 0
current_sequence = 0
previous_money = 0
for money in money_list:
	if previous_money > int(money):
		if current_sequence > max_sequence:
			max_sequence = current_sequence
		current_sequence = 0
	current_sequence += 1
	previous_money = int(money)
print(max(max_sequence, current_sequence))


n = int(input())
k = 1
i = 0
arr = [0]
a = [i for i in map(int, input().split())]
while i < n - 1:
	if a[i] <= a[i + 1]:
		k += 1
	else:
		arr.append(k)
		k = 1
	i += 1
arr.append(k)
print(max(arr))


n = int(input())
a = list(map(int, input().split()))
s = 0
count = 0
b = []
for i in range(n):
	if a[i] >= s:
		s = a[i]
		count += 1
		b.append(count)
	else:
		s = a[i]
		count = 1
p = max(b)
print(p)


import sys
s = sys.stdin.read()
S = s.split()
n = int(S[0])
S.pop(0)
S = [int(i) for i in S]
k = 1
m = 1
for i in range(1, n):
	if S[i] >= S[i - 1]:
		k = k + 1
	else:
		k = 1
	if k > m:
		m = k
	else:
		pass
print(m)


def diff(x):
	lst = []
	while x != 0:
		if x % 10 in lst:
			return -1
		else:
			lst.append(x % 10)
		x = x // 10
	return len(lst)

def main():
	n = int(input())
	inputLst = [int(x) for x in input().split()]
	lnds = [0] * n
	lnds[0] = 1
	for it in range(1, n):
		if inputLst[it] >= inputLst[it - 1]:
			lnds[it] = lnds[it - 1] + 1
		else:
			lnds[it] = 1
	print(max(lnds))
main()


import math

def lenLNDS(seq):
	if not seq:
		return 0
	(maxl, l, p) = (1, 1, seq[0])
	for i in seq[1:]:
		if i >= p:
			l += 1
		else:
			if l > maxl:
				maxl = l
			l = 1
		p = i
	if l > maxl:
		maxl = l
	return maxl
n = int(input().split()[0])
s = input().split()
a = [int(i) for i in s]
print(lenLNDS(a))


n = int(input())
d = (input() + ' -10000').split(' ')
M = 0
Mt = 0
for k in range(n):
	if int(d[k]) <= int(d[k + 1]):
		Mt += 1
	else:
		Mt = 0
	M = max(Mt, M)
print(M + 1)


n = int(input())
money = list(map(int, input().split(' ')))
ans = 0
res = 0
prev = -1
for i in money:
	if i >= prev:
		ans += 1
	else:
		res = max(res, ans)
		ans = 1
	prev = i
res = max(ans, res)
print(res)


a = int(input())
l = [int(i) for i in input().split()]
(count, ans) = (1, 1)
for i in range(a - 1):
	if l[i] <= l[i + 1]:
		count += 1
	else:
		ans = max(ans, count)
		count = 1
	ans = max(ans, count)
print(ans)


n = int(input())
global_max = local_max = 1
values = map(int, input().split(' '))
prev_value = next(values)
for i in range(n - 1):
	value = next(values)
	if value >= prev_value:
		local_max += 1
	elif value < prev_value:
		local_max = 1
	if local_max > global_max:
		global_max = local_max
	prev_value = value
print(global_max)


input()
t = map(lambda i: int(i), input().split())
s = n = j = 0
for i in t:
	if j > i:
		(n, s) = (max(n, s), 0)
	s += 1
	j = i
print(max(n, s))


n = int(input())
a = list(map(int, input().split()))
dp = []
c = 0
for i in range(1, n):
	if a[i - 1] <= a[i]:
		c += 1
	else:
		dp.append(c)
		c = 0
dp.append(c)
print(max(dp) + 1)


n_numbers = int(input())
numbers = [int(i) for i in input().split()]
count = 0
max_count = 0
for i in range(1, n_numbers):
	if numbers[i] >= numbers[i - 1]:
		count += 1
	else:
		if count > max_count:
			max_count = count
		count = 0
if max_count > count:
	print(max_count + 1)
else:
	print(count + 1)


n = int(input())
A = input().split()
A = [int(i) for i in A]
B = [-1 for i in range(0, n)]
B[0] = 1
for i in range(1, n):
	if A[i] >= A[i - 1]:
		B[i] = B[i - 1] + 1
	else:
		B[i] = 1
result = 0
for i in range(0, n):
	if result < B[i]:
		result = B[i]
print(result)


n = int(input())
l = [int(x) for x in input().split()]
num = l[0]
length = [1] * n
for i in range(1, n):
	if l[i] >= num:
		length[i] = length[i - 1] + 1
	num = l[i]
length.sort()
print(length[-1])


def sol():
	n = int(input())
	A = [int(i) for i in input().split()]
	mx = 0
	c = 0
	prev = -1
	for i in range(n):
		if A[i] >= prev:
			c += 1
			if c > mx:
				mx = c
		else:
			c = 1
		prev = A[i]
	print(mx)
sol()


n = int(input())
s = list(map(int, input().strip().split()))
if n == 0:
	print(0)
	import sys
	sys.exit(0)
a = 1
trav = 1
ans = 1
while trav < n:
	if s[trav] >= s[trav - 1]:
		a += 1
		if a > ans:
			ans = a
		trav += 1
	else:
		a = 1
		trav += 1
print(ans)


amount = int(input())
number = list(map(int, input().split()))
for j in range(len(number)):
	number[j] = int(number[j])
counter = 0
result = []
for i in range(1, amount):
	if number[i] >= number[i - 1]:
		counter += 1
	else:
		if counter != 0:
			result.append(counter + 1)
		counter = 0
result.append(counter + 1)
print(max(result))


n = int(input())
if n == 1:
	print(1)
	exit()
a = [int(i) for i in input().split()]
max = 0
c = 0
f = 0
for i in range(len(a) - 1):
	if a[i] <= a[i + 1]:
		c += 1
		f = 1
	else:
		if c != 0:
			c += 1
		else:
			continue
		if c > max:
			max = c
		c = 0
if a[i] <= a[i + 1]:
	if c + 1 > max:
		max = c + 1
		f = 1
if f == 0:
	max = 1
print(max)


n = int(input())
m = list(map(int, input().split()[:n]))
(ans, cn) = (0, 1)
for i in range(1, n):
	if m[i] >= m[i - 1]:
		cn += 1
	else:
		ans = max(ans, cn)
		cn = 1
ans = max(ans, cn)
print(ans)


input()
numbers = input().split()
numbers = [int(x) for x in numbers]
streak = 0
streaks = []
for (x, number) in enumerate(numbers):
	try:
		if numbers[x + 1] >= number:
			streak += 1
		else:
			streaks.append(streak)
			streak = 0
	except IndexError:
		streaks.append(streak)
if len(streaks) > 0:
	print(max(streaks) + 1)
else:
	print(len(numbers))


n = int(input())
seq = list(map(int, input().split()))
tmp_c = 0
larg_seq_c = 0
for i in range(n - 1):
	if seq[i] > seq[i + 1]:
		tmp_c = 0
	else:
		tmp_c += 1
	if larg_seq_c < tmp_c:
		larg_seq_c = tmp_c
print(larg_seq_c + 1)


def solve():
	n = int(input())
	l = list(map(int, input().strip().split()))
	ma = 1
	c = 1
	for i in range(1, n):
		if l[i] >= l[i - 1]:
			ma += 1
		else:
			if c < ma:
				c = ma
			ma = 1
	if c < ma:
		c = ma
	print(c)
solve()


from sys import stdin, stdout

def solve(n, money):
	max_segment = 1
	cur_segment = 1
	for i in range(1, len(money)):
		if money[i - 1] <= money[i]:
			cur_segment += 1
		else:
			max_segment = max(max_segment, cur_segment)
			cur_segment = 1
	return max(max_segment, cur_segment)
n = int(input())
l = [int(x) for x in input().split()]
solution = solve(n, l)
print(solution)


l = [1]
temp = 1
n = int(input())
arr = list(map(int, input().split()))
for i in range(n - 1):
	if arr[i] <= arr[i + 1]:
		temp = temp + 1
	else:
		temp = 1
	l.append(temp)
print(max(l))


n = int(input())
l = list(map(int, input().split()))
max_counter = 0
counter = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		counter += 1
	else:
		max_counter = max(max_counter, counter)
		counter = 1
max_counter = max(counter, max_counter)
print(max_counter)


import sys
n1 = sys.stdin.readline().strip('\n')
n2 = sys.stdin.readline().strip('\n')
max = 0
cmax = 0
last = 0
for nr in n2.split(' '):
	k = int(nr)
	if k >= last:
		cmax += 1
	else:
		cmax = 1
	if cmax > max:
		max = cmax
	last = k
print(max)


n = int(input())
a = input().split()
for i in range(n):
	a[i] = int(a[i])
b = []
count = 0
for j in range(n):
	if j == 0:
		count += 1
		if j == n - 1:
			b.append(count)
	elif a[j] >= a[j - 1]:
		count += 1
		if j == n - 1:
			b.append(count)
	else:
		b.append(count)
		count = 1
		if j == n - 1:
			b.append(count)
print(max(b))


def solve(n, a):
	maxi = 1
	cur = 1
	for i in range(1, n):
		if a[i] >= a[i - 1]:
			cur += 1
			maxi = max(maxi, cur)
		else:
			cur = 1
	return maxi

def main():
	n = int(input())
	a = list(map(int, input().split()))
	print(solve(n, a))
main()


n = int(input())
list1 = list(map(int, input().split()))
list2 = []
count = 1
for x in range(1, n):
	if list1[x] >= list1[x - 1]:
		count += 1
	else:
		list2.append(count)
		count = 1
list2.append(count)
print(max(list2))


def d():
	arrlen = int(input())
	arr = list(map(int, input().split()))
	maxl = 1
	cont = 1
	for i in range(1, arrlen):
		if arr[i] >= arr[i - 1]:
			cont += 1
		else:
			maxl = max(maxl, cont)
			cont = 1
	maxl = max(maxl, cont)
	print(maxl)
d()


n = int(input())
l = list(map(int, input().split()))
list_number_sequence = []
counter = 0
for i in range(0, len(l) - 1):
	if l[i] <= l[i + 1]:
		counter += 1
	else:
		list_number_sequence.append(counter + 1)
		counter = 0
list_number_sequence.append(counter + 1)
print(max(list_number_sequence))


n = int(input())
a = list(map(int, input().split()))
l = 1
t = 1
for i in range(n - 1):
	if a[i + 1] - a[i] >= 0:
		t = t + 1
		if t > l:
			l = t
	else:
		t = 1
print(l)


n = int(input())
l = [int(i) for i in input().split()]
a = []
s = 0
for i in range(1, n):
	if l[i] >= l[i - 1]:
		s += 1
	else:
		a.append(s + 1)
		s = 0
a.append(s + 1)
print(max(a))


n = int(input())
l = [int(i) for i in input().split()]
m = 1
c = 1
for i in range(n - 1):
	if l[i] <= l[i + 1]:
		c += 1
	else:
		m = max(c, m)
		c = 1
m = max(c, m)
print(m)


n = int(input())
a = list(map(int, input().strip().split()))
c = 1
l = [1]
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		c += 1
		l.append(c)
	elif a[i] > a[i + 1]:
		c = 1
print(max(l))


n = int(input())
ls = [int(x) for x in input().split()]
res = 1
cur = 1
for i in range(n - 1):
	if ls[i + 1] < ls[i]:
		if cur > res:
			res = cur
		cur = 1
	else:
		cur += 1
if cur > res:
	res = cur
print(res)


n = int(input())
a = [int(x) for x in input().split()]
l = 0
cur = 0
prev = 0
for x in a:
	if x >= prev:
		cur += 1
		l = max(l, cur)
	else:
		cur = 1
	prev = x
print(l)


n = int(input())
num = input()
arr = []
count = 0
for i in range(0, len(num)):
	if num[i] == ' ':
		arr.append(int(num[count:i]))
		count = i + 1
	elif i == len(num) - 1:
		arr.append(int(num[count:len(num)]))
store = 1
count = 1
for i in range(1, len(arr)):
	if i == len(arr) - 1:
		if arr[i] >= arr[i - 1]:
			count += 1
			if count > store:
				store = count
		elif count > store:
			store = count
	elif arr[i] >= arr[i - 1]:
		count += 1
	else:
		if count > store:
			store = count
		count = 1
print(store)


l = int(input())
a = list(map(int, input().split()))
c = 1
m = 0
for i in range(1, l):
	if a[i] >= a[i - 1]:
		c += 1
	else:
		m = max(m, c)
		c = 1
m = max(m, c)
print(m)


n = int(input())
data = [int(i) for i in input().split()]
now = 1
ans = 1
for i in range(n):
	if i > 0:
		if data[i] >= data[i - 1]:
			now += 1
		else:
			now = 1
		ans = max([now, ans])
print(str(ans))


n = int(input())
s = list(map(int, input().split()))
lst = []
a = 0
if len(s) == 1:
	print(1)
else:
	for i in range(n - 1):
		if s[i] <= s[i + 1]:
			a += 1
		else:
			lst.append(a)
			a = 0
		if i == n - 2:
			lst.append(a)
	print(max(lst) + 1)


n = int(input())
m = list(map(int, input().split()))
max = 0
count = 0
for i in range(n):
	if i == 0:
		continue
	elif m[i] >= m[i - 1]:
		count += 1
	else:
		count = 0
	if count > max:
		max = count
print(max + 1)


n = int(input())
r = t = 0
a = 100000000
for x in map(int, input().split()):
	if x < a:
		t = 0
	t += 1
	r = max(r, t)
	a = x
print(r)


n = int(input(''))
valorInput = input('')
lista = valorInput.split(' ')
biggest = 1
new = 1
valAnt = int(lista.pop())
for i in range(n - 1):
	newVal = int(lista.pop())
	if valAnt >= newVal:
		new += 1
	else:
		if biggest < new:
			biggest = new
		new = 1
	valAnt = newVal
if biggest < new:
	biggest = new
print(biggest)


n = int(input())
A = [int(s) for s in input().split()]
res = 0
cur = 1
for i in range(1, n):
	if A[i] >= A[i - 1]:
		cur += 1
	else:
		res = max(cur, res)
		cur = 1
res = max(cur, res)
print(res)


def main():
	a = int(input())
	list1 = list(input().split())
	m = 1
	list_num = []
	list_check = []
	check = 1
	for i in range(a):
		list_num += [int(list1[i])]
	num = list_num[0]
	if len(list_num) == 1:
		list_check += [1]
	else:
		for k in list_num[1:]:
			m += 1
			if k >= num:
				check += 1
				num = k
			else:
				num = k
				list_check += [check]
				check = 1
			if m == len(list1):
				list_check += [check]
	list_check.sort()
	output = list_check[::-1]
	print(output[0])
main()


n = int(input().strip())
l = list(map(int, input().split()))
x = [1]
for i in range(1, len(l)):
	if l[i - 1] <= l[i]:
		x.append(x[i - 1] + 1)
	else:
		x.append(1)
print(max(x))


n = int(input())
c = ans = 0
p = -1
for i in map(int, input().split()):
	if i >= p:
		c += 1
		ans = max(ans, c)
	else:
		c = 1
	p = i
print(ans)


def main():
	N = int(input())
	l = list(map(int, input().strip().split()))
	maxLen = 0
	curLen = 0
	for i in range(1, len(l)):
		curLen += 1
		if l[i] < l[i - 1]:
			maxLen = max(curLen, maxLen)
			curLen = 0
	print(max(maxLen, curLen + 1))
main()


n = int(input())
values = list(map(int, input().strip().split()))
i = 1
lst = []
for num in range(0, len(values) - 1):
	if values[num + 1] >= values[num]:
		i += 1
	else:
		lst.append(i)
		i = 1
lst.append(i)
print(max(lst))


n = int(input())
a = list(map(int, input().split()))
ctr = 1
prev = a[0]
m = 1
for i in range(1, n):
	if a[i] >= prev:
		ctr += 1
		if ctr > m:
			m = ctr
	else:
		ctr = 1
	prev = a[i]
print(m)


input()
A = list(map(int, input().split()))
cur = 1
l = A[0]
an = 1
for i in A[1:]:
	if i < l:
		cur = 1
	else:
		cur += 1
		an = max(an, cur)
	l = i
print(an)


nos = int(input())
ll = list(map(int, input().split()))
temp = ll[0]
count = 1
maxm = 0
for i in ll[1:]:
	if i >= temp:
		count += 1
		temp = i
	else:
		if maxm < count:
			maxm = count
		count = 1
		temp = i
if count > maxm:
	maxm = count
print(maxm)


n = int(input())
money = list(map(int, input().split(' ')))
highest_streak = 1
current_streak = 1
previous_number = money[0]
for i in range(1, n):
	if money[i] >= previous_number:
		current_streak += 1
	else:
		current_streak = 1
	previous_number = money[i]
	if current_streak > highest_streak:
		highest_streak = current_streak
print(highest_streak)


n = int(input())
l = [int(x) for x in input().split()]
streak = 1
beststreak = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		streak += 1
		beststreak = max(streak, beststreak)
	else:
		streak = 1
print(beststreak)


n = int(input())
lst = list(map(int, input().split()))
dp = [1] * n
for i in range(1, n):
	if lst[i] >= lst[i - 1]:
		dp[i] = dp[i - 1] + 1
	else:
		dp[i] = 1
print(max(dp))


n = int(input())
array = list(map(int, input().split()))
high = 1
count = 1
for i in range(1, len(array)):
	if array[i] >= array[i - 1]:
		count += 1
		if count > high:
			high = count
	else:
		count = 1
print(high)


n = int(input())
a = list(map(int, input().split()))
num = a[0]
count = 0
ans = []
for x in range(n):
	if a[x] < num:
		ans.append(int(count))
		count = 1
	else:
		count += 1
	num = a[x]
ans.append(int(count))
print(max(ans))


k = int(input())
l = list(map(int, input().split()))
c = 0
p = [0]
for t in range(k - 1):
	if l[t + 1] < l[t]:
		c = 0
	else:
		c += 1
	p.append(c)
print(max(p) + 1)


(n, d, a) = (int(input()), 1, [])
l = list(map(int, input().split()))
l.append(-1)
for x in range(n):
	if l[x + 1] - l[x] >= 0:
		d += 1
	else:
		a.append(d)
		d = 1
print(max(a))


def sub(n, ar):
	dp = [0] * (n + 1)
	dp[0] = 1
	for i in range(1, n):
		if ar[i] >= ar[i - 1]:
			dp[i] = dp[i - 1] + 1
		else:
			dp[i] = 1
	return max(dp)
n = int(input())
ar = list(map(int, input().split()))
ans = sub(n, ar)
print(ans)


input()
r = 0
n = 0
t = 0
for i in map(int, input().split()):
	if i >= t:
		n += 1
		t = i
	else:
		r = max(r, n)
		n = 1
		t = i
print(max(n, r))


n = int(input())
arr = list(map(int, input().split()))
maximum = 0
current_max = 1
for i in range(len(arr) - 1):
	if arr[i] <= arr[i + 1]:
		current_max += 1
	else:
		maximum = max(current_max, maximum)
		current_max = 1
maximum = max(current_max, maximum)
print(maximum)


n = int(input(''))
count = 0
list1 = list(map(int, input().split()))
list2 = []
for i in range(len(list1) - 1):
	if list1[i] <= list1[i + 1]:
		count += 1
	elif list1[i] > list1[i + 1]:
		list2.append(count)
		count = count - count
list2.append(count)
print(max(list2) + 1)


n = int(input())
c = list(map(int, input().split(' ')))
l = [0]
s = 0
for j in range(n - 1):
	if c[j + 1] >= c[j]:
		s += 1
		l.append(s)
	else:
		s = 0
print(max(l) + 1)


n = int(input(''))
a = [int(i) for i in input().split()]
b = 1
c = 1
for i in range(n - 1):
	if a[i + 1] >= a[i]:
		b += 1
	if b > c:
		c = b
	if a[i + 1] < a[i]:
		b = 1
print(c)


n = input()
ma = a = c = 0
for i in input().split():
	i = int(i)
	if i >= a:
		c += 1
	else:
		c = 1
	ma = max(ma, c)
	a = i
print(ma)


def get_values():
	num = int(input())
	li = list(map(int, input().split()))
	counter = 1
	li2 = []
	for i in range(num - 1):
		if li[i] <= li[i + 1]:
			counter += 1
		elif li[i] > li[i + 1]:
			li2.append(counter)
			counter = 1
		else:
			counter += 0
	li2.append(counter)
	return print(max(li2))
get_values()


n = int(input())
a = [int(i) for i in input().split()]
maxi = 0
cont = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		cont += 1
	else:
		if cont > maxi:
			maxi = cont
		cont = 1
if cont > maxi:
	maxi = cont
print(maxi)


n = int(input())
a = list(input().split())
a = [int(x) for x in a]
(counter, old_counter) = (1, 1)
(i, j) = (0, 0)
while i < len(a):
	j = i + 1
	while j < len(a):
		if a[j] >= a[i]:
			old_counter += 1
			i += 1
			j += 1
		else:
			old_counter = 1
			break
		if old_counter > counter:
			counter = old_counter
	i = j
print(counter)


n = int(input())
a = [int(i) for i in input().split()]
ans = 0
c = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		c += 1
	else:
		ans = max(ans, c)
		c = 1
print(max(ans, c))


n = int(input())
a = list(map(int, input().split()))
mx = 1
i = 0
while i < n:
	d = 1
	r = 1
	for j in range(i + 1, n):
		if a[j] >= a[j - 1]:
			r += 1
			d += 1
		else:
			break
	if d > mx:
		mx = d
	i += r
print(mx)


n = int(input())
ar = [int(x) for x in input().split()]
cnt = 1
prev = 0
for i in range(n - 1):
	if ar[i] <= ar[i + 1]:
		cnt += 1
	else:
		if prev < cnt:
			prev = cnt
		cnt = 1
if prev < cnt:
	prev = cnt
print(prev)


n = int(input())
l = list(map(int, input().split()))
res = 0
ll = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		ll += 1
	else:
		res = max(ll, res)
		ll = 1
print(max(res, ll))


amount = int(input())
nums = input().split()
new_nums = [int(item) for item in nums]
max_length = 1
length = 1
for item in range(1, amount):
	if new_nums[item] >= new_nums[item - 1]:
		length += 1
	else:
		length = 1
	max_length = max(max_length, length)
print(max_length)


n = int(input())
a = [int(i) for i in input().split()]
count = 1
mex = 1
for i in range(len(a) - 1):
	if a[i] <= a[i + 1]:
		count += 1
	else:
		count = 1
	mex = max(mex, count)
print(mex)


n = int(input())
array = list(map(int, input().split(' ')))
max_length = 1
length = 1
last = array[0]
for i in range(1, n):
	if array[i] >= last:
		length += 1
	else:
		if length > max_length:
			max_length = length
		length = 1
	last = array[i]
if length > max_length:
	max_length = length
print(max_length)


c = int(input())
d = list(map(int, input().split()))
max = 1
t = 1
for i in range(len(d) - 1):
	if d[i] <= d[i + 1]:
		t += 1
	else:
		t = 1
	if max < t:
		max = t
print(max)


n = int(input())
ss = input().split()
i = ans = 0
while i < len(ss):
	(res, j) = (1, i)
	while j + 1 < len(ss) and int(ss[j + 1]) >= int(ss[j]):
		(res, j) = (res + 1, j + 1)
	(ans, i) = (max(ans, res), j + 1)
print(ans)


n = int(input())
m = [int(i) for i in input().split(' ')]
a = 1
r = a
for i in range(len(m) - 1):
	if m[i] <= m[i + 1]:
		a += 1
	else:
		a = 1
	r = r if r > a else a
print(r)


n = int(input())
a = list(map(int, input().split()))
maxans = 1
cur_max = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		cur_max += 1
	else:
		cur_max = 1
	if cur_max > maxans:
		maxans = cur_max
print(maxans)


n = int(input())
money = [int(x) for x in input().split()]
day_1 = 0
day_2 = 0
tc = 0
for i in range(n):
	if tc <= money[i]:
		day_1 += 1
		tc = money[i]
		day_2 = max(day_1, day_2)
	else:
		day_1 = 1
		tc = money[i]
print(day_2)


x = int(input())
maxi = [int(x) for x in input().split()]
a = 0
count = 1
yolo = []
while a + 1 <= len(maxi) - 1 and x > 1:
	if maxi[a] <= maxi[a + 1]:
		a += 1
		count += 1
	else:
		a += 1
		yolo.append(count)
		count = 1
if count != 1:
	yolo.append(count)
if x == 1:
	print(1)
else:
	print(max(yolo))


n = 0
l = []
l1 = []
j = 0
maxctr = 0
ctr = 0
n = int(input())
l = input().split(' ')
for i in l:
	l1.append(int(i))
l = [l1[0]]
for i in range(len(l1) - 1):
	if l1[i + 1] >= l1[i]:
		l.append(l1[i + 1])
	else:
		if maxctr < len(l):
			maxctr = len(l)
		l = [l1[i]]
if maxctr < len(l):
	maxctr = len(l)
print(maxctr)


n = int(input())
li = [int(num) for num in input().split()]
l = len(li)
c = 0
lis = []
for i in range(l):
	if i == l - 1:
		lis.append(c)
		break
	if li[i] <= li[-(l - 1 - i)]:
		c += 1
	else:
		lis.append(c)
		c = 0
lis.sort()
r = lis[-1] + 1
print(r)


n = int(input())
inp = list(map(int, input().split()))
max_len = 0
now_len = 0
prev = 0
for i in inp:
	if i >= prev:
		now_len += 1
	else:
		if now_len > max_len:
			max_len = now_len
		now_len = 1
	prev = i
if now_len > max_len:
	max_len = now_len
print(max_len)


n = int(input())
seq1 = map(int, input().split())
lst1 = list(seq1)
lst1.append(0)
lst = [0]
lst.extend(lst1)
i = 1
k = 0
l = 0
m = 0
while i <= n + 1:
	if lst[i] >= k:
		l += 1
	else:
		m = max(m, l)
		l = 1
	k = lst[i]
	i += 1
print(max(m, l))


n = int(input())
d = 0
r = 0
s = 0
a = list(map(int, input().split()))
for i in range(n):
	if a[i] >= d:
		d = a[i]
		r = r + 1
	else:
		if r > s:
			s = r
		r = 1
		d = a[i]
if r > s:
	s = r
print(s)


n = int(input())
line = [int(x) for x in input().split()]
m = [1] * n
for i in range(n - 1):
	if line[i + 1] >= line[i]:
		m[i + 1] = m[i] + 1
	else:
		m[i + 1] = 1
print(int(max(m)))


n = int(input())
l = list(map(int, input().split()))
counter = 1
max_list = []
for i in range(0, len(l)):
	if i == len(l) - 1 and counter != 1:
		max_list.append(counter)
	elif i == len(l) - 1:
		break
	elif l[i] <= l[i + 1]:
		counter += 1
	else:
		max_list.append(counter)
		counter = 1
if len(max_list) == 0:
	print(1)
else:
	print(max(max_list))


n = int(input())
a = list(map(int, input().split()))
a.append(0)
k = []
s = 0
for i in range(0, n):
	k.append(a[i])
	if a[i] > a[i + 1]:
		if len(k) > s:
			s = len(k)
		k = []
print(str(s))


x = int(input())
b = list(map(int, input().split()))
m = 1
count = 1
for i in range(len(b) - 1):
	if b[i] <= b[i + 1]:
		count += 1
		m = max(count, m)
	else:
		count = 1
		continue
print(m)


n = int(input())
l = list(map(int, input().split()))
ans = 1
i = 0
j = 0
while i < n:
	j = i
	while j < n - 1:
		if l[j] <= l[j + 1]:
			j += 1
		else:
			break
		ans = max(ans, j - i + 1)
	i = j + 1
print(ans)


from itertools import groupby
i = input
i()
s = list(map(int, i().split()))
print(1 + max([len(list(i)) for (o, i) in groupby((c >= p for (p, c) in zip(s, s[1:]))) if o] + [0]))


n = int(input())
arr = list(map(int, input().split()))
cur = 1
ans = 1
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		cur = cur + 1
	else:
		ans = max(cur, ans)
		cur = 1
print(max(ans, cur))


n = int(input())
a = list(map(int, input().split()))
cnt = 0
ans = 1
prev = 0
for x in a:
	if x >= prev:
		cnt += 1
		ans = max(ans, cnt)
	else:
		cnt = 1
	prev = x
print(ans)


n = int(input())
s = str(input())
l = s.split()
ans = []
lst = [0]
z = 0
for i in l:
	i = int(i)
	if i < lst[0]:
		ans += [z]
		z = 1
		lst.pop(0)
		lst += [i]
	else:
		z += 1
		lst.pop(0)
		lst += [i]
ans += [z]
a = max(ans)
print(a)


import functools
import logging
import os
import sys
import time
from typing import List
logger = logging.getLogger()
reader = sys.stdin
is_judge = os.getenv('DEBUGGING') is None

def timeit(func):

	@functools.wraps(func)
	def timed(*args, **kwargs):
		if is_judge:
			rv = func(*args, **kwargs)
		else:
			ts = time.time()
			rv = func(*args, **kwargs)
			te = time.time()
			logger.debug('performance %r %2.2fms', func.__name__, (te - ts) * 1000)
		return rv
	return timed

def read_ints():
	return [int(v) for v in reader.readline().strip().split(' ')]

@timeit
def main():
	n = read_ints()
	a = read_ints()
	res = 0
	cur_seq = 0
	pv = None
	for v in a:
		if pv is None or v >= pv:
			cur_seq += 1
			res = max(cur_seq, res)
		else:
			cur_seq = 1
		pv = v
	print(res)

def setup():
	global logger, reader
	if is_judge:
		logger.setLevel(logging.WARNING)
	else:
		handler = logging.StreamHandler(sys.stdout)
		handler.setLevel(logging.DEBUG)
		formatter = logging.Formatter('{asctime}s - {message}', style='{')
		handler.setFormatter(formatter)
		logger.addHandler(handler)
		logger.setLevel(logging.DEBUG)
		reader = open('input.txt')
setup()
try:
	main()
except KeyboardInterrupt:
	logger.debug('KeyboardInterrupt')
except IOError as e:
	logger.error(f'I/O error({e.errno}): {e.strerror}')


input()
l = input().split()
ant = int(l.pop(0))
maior = cont = 1
for atual in l:
	atual = int(atual)
	if atual >= ant:
		cont += 1
		if cont > maior:
			maior = cont
	else:
		cont = 1
	ant = atual
print(maior)


n = int(input())
arr = [int(x) for x in input().split()]
m = [1] * n
i = 1
while i < n:
	if arr[i - 1] <= arr[i]:
		m[i] = m[i - 1] + 1
	i += 1
print(max(m))


n = int(input())
ai = input().split()
for i in range(len(ai)):
	ai[i] = int(ai[i])
s = [0] * n
s[0] = 1
for i in range(1, n):
	if ai[i] >= ai[i - 1]:
		s[i] = s[i - 1] + 1
		continue
	s[i] = 1
print(max(s))


n = int(input())
a = list(map(int, input().split()))
b = []
count = 1
for i in range(n):
	if i != n - 1 and a[i + 1] >= a[i]:
		count += 1
	else:
		b.append(count)
		count = 1
print(max(b))


n = int(input())
l = list(map(int, input().split()))
lf = list()
mx = 0
if n == 1:
	print(1)
else:
	for i in range(len(l) - 1):
		if l[i] <= l[i + 1]:
			mx += 1
		else:
			mx = 0
		lf.append(mx)
	print(max(lf) + 1)


n = int(input())
nums = [int(i) for i in input().split()]
most = 1
current = 1
for i in range(len(nums) - 1):
	if nums[i] <= nums[i + 1]:
		current += 1
	else:
		current = 1
	most = max(most, current)
print(most)


a = int(input())
num = list(map(int, input().split()))
count = 1
max = 1
for i in range(0, a):
	if i == a - 1:
		continue
	elif num[i + 1] >= num[i]:
		count = count + 1
		if count > max:
			max = count
	else:
		count = 1
print(max)


n = int(input())
a = list(map(int, input().split(' ')))
max_l = 1
loc_l = 1
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		loc_l += 1
		max_l = max(loc_l, max_l)
	else:
		loc_l = 1
print(max_l)


n = int(input())
l = list(map(int, input().split(' ')))
tmp_max = 1
cur = 1
for i in range(1, len(l)):
	if l[i] >= l[i - 1]:
		cur += 1
	else:
		tmp_max = max(tmp_max, cur)
		cur = 1
tmp_max = max(tmp_max, cur)
print(tmp_max)


n = int(input())
l = [0] + list(map(int, input().split()))
good = 1
maxi = 0
tmp = 0
for i in range(1, n + 1):
	if tmp != 0:
		if l[i] < l[i - 1]:
			tmp = 0
	tmp += 1
	if tmp > maxi:
		maxi = tmp
print(maxi)


n = int(input())
a = list(map(int, input().split()))
d = []
count = 1
if n == 1:
	print(1)
else:
	for i in range(n - 1):
		if a[i] <= a[i + 1] and i < n - 2:
			count += 1
		elif a[i] > a[i + 1]:
			d.append(count)
			count = 1
		elif a[i] <= a[i + 1] and i == n - 2:
			count += 1
			d.append(count)
	print(max(d))


n = int(input())
arr = [int(x) for x in input().split()]
(start, end) = (0, 0)
max_count = 0
if n == 1:
	print('1')
else:
	for i in range(len(arr) - 1):
		if arr[i + 1] >= arr[i]:
			end = i + 1
		else:
			start = i + 1
			end = i + 1
		max_count = end - start + 1 if max_count < end - start + 1 else max_count
	print(max_count)


num = int(input())
money = list(map(int, input().split()))
k = 0
now = 0
answer = 0
for i in money:
	if i >= now:
		k += 1
	if i < now:
		k = 1
	now = i
	if k > answer:
		answer = k
print(answer)


def len_non_dec_Sub_Arr(a, n):
	len = 1
	m = 1
	for i in range(n - 1):
		if a[i + 1] >= a[i]:
			len += 1
		else:
			if len > m:
				m = len
			len = 1
		if len > m:
			m = len
	return m
n = int(input())
a = list(map(int, input().split()))[:n]
print(len_non_dec_Sub_Arr(a, n))


def main():
	inp = int(input())
	L = [int(x) for x in input().split()]
	Max = 0
	c = 1
	for i in range(1, inp):
		if L[i] >= L[i - 1]:
			c += 1
		else:
			Max = max(Max, c)
			c = 1
	Max = max(Max, c)
	print(Max)
main()


n = int(input())
l = list(map(int, input().rstrip().split()))
count = 1
greatest = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		count += 1
	else:
		count = 1
	if count > greatest:
		greatest = count
print(greatest)


n = int(input())
b = []
c = []
cnt = 1
a = list(map(int, input().split()))
if len(a) == 1:
	print(1)
else:
	while len(a) != 1:
		if a[1] >= a[0]:
			cnt += 1
		else:
			c.append(cnt)
			cnt = 1
		a.remove(a[0])
		if len(a) == 1:
			c.append(cnt)
	print(max(c))


n = int(input())
pro = [int(x) for x in input().split()]
a = 1
day = 1
if n == 1:
	print('1')
else:
	for i in range(n - 1):
		if pro[i] <= pro[i + 1]:
			a += 1
			day = max(day, a)
		else:
			a = 1
			if len(pro) >= 2:
				continue
			else:
				break
	print(day)


input()
(l, maxl, ex) = (1, 1, 10000000000)
for k in input().split():
	if ex <= int(k):
		l += 1
		maxl = max(maxl, l)
	else:
		l = 1
	ex = int(k)
print(maxl)


n = int(input())
ls = list(map(int, input().split()))
count = 0
p = []
for i in range(len(ls) - 1):
	if ls[i] <= ls[i + 1]:
		count += 1
	else:
		p.append(count + 1)
		count = 0
if p != None:
	p.append(count + 1)
	print(max(p))
else:
	print(count + 1)


n = int(input())
list = [int(x) for x in input().split()]
count = 0
out = [0]
for x in range(n - 1):
	if list[x] <= list[x + 1]:
		count += 1
	else:
		count = 0
	out.append(count)
out.sort(reverse=True)
print(out[0] + 1)


import sys
it = iter(sys.stdin.read().splitlines())
n = int(next(it))
earnings = [int(x) for x in next(it).split(' ')]
max = 0
current = 1
for i in range(1, n):
	if earnings[i] >= earnings[i - 1]:
		current += 1
	else:
		if current > max:
			max = current
		current = 1
if current > max:
	max = current
print(max)


k = int(input())
a = list(map(int, input().split()))
c = 0
(b, d) = (0, 0)
for i in a:
	if i >= b:
		c += 1
	else:
		c = 1
	d = max(c, d)
	b = i
print(d)


n = int(input())
c = 1
m = []
f = 0
l = list(map(int, input().split()))
for i in range(0, n - 1):
	if l[i] <= l[i + 1]:
		c = c + 1
	else:
		f = 1
		c = 1
	m.append(c)
if f == 0:
	print(c)
else:
	print(max(m))


def main():
	max_numbers = 0
	counter = 1
	n = int(input())
	A = list(map(int, input().split()))
	if n == 1:
		max_numbers = 1
	else:
		for i in range(n - 1):
			if A[i] <= A[i + 1]:
				counter += 1
			else:
				counter = 1
			if max_numbers < counter:
				max_numbers = counter
	print(max_numbers)
main()


n = int(input())
l = list(map(int, input().split()))
s = []
ans = 0
for i in range(n):
	if len(s) == 0 or s[-1] <= l[i]:
		s.append(l[i])
	else:
		ans = max(ans, len(s))
		s = []
		s.append(l[i])
ans = max(ans, len(s))
print(ans)


n = int(input())
a = [int(x) for x in input().split()]
res = 1
n = 0
for i in range(1, len(a)):
	if a[i - 1] <= a[i]:
		n += 1
	else:
		n += 1
		res = max(n, res)
		n = 0
else:
	n += 1
	res = max(n, res)
print(res)


n = int(input())
arr = list(map(int, input().split()))
cnt = 1
maxm = -1
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		cnt += 1
	else:
		maxm = max(cnt, maxm)
		cnt = 1
maxm = max(cnt, maxm)
print(maxm)


n = int(input())
l = list(map(int, input().split()))
maxx = 1
s = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		s += 1
		maxx = max(s, maxx)
	else:
		s = 1
print(maxx)


n = int(input())
m = list(map(int, input().split()))
counter = 0
maxSeq = 0
curr = m[0]
for i in range(1, n):
	if m[i] >= m[i - 1]:
		counter += 1
	else:
		if counter > maxSeq:
			maxSeq = counter
		counter = 0
	if counter > maxSeq:
		maxSeq = counter
print(maxSeq + 1)


n = int(input())
num = [i for i in map(int, input().split())]
a = 1
ans = []
if n != 1:
	for i in range(n - 1):
		if num[i] <= num[i + 1]:
			a += 1
		else:
			ans.append(a)
			a = 1
	ans.append(a)
else:
	ans.append(1)
print(max(ans))


input()
maxx = 1
k = 0
now = 10000000 * 9
l = list(map(int, input().split()))
for x in l:
	if x < now:
		k = 0
	k += 1
	maxx = max(maxx, k)
	now = x
print(maxx)


n = int(input())
l = [int(n) for n in input().split()]
longest = 0
streak = 0
curmax = l[0]
for i in range(n):
	if l[i] >= curmax:
		streak += 1
		curmax = l[i]
		if streak > longest:
			longest = streak
	else:
		streak = 1
		curmax = l[i]
print(longest)


n = int(input())
l = list(map(int, input().split()))
maxx = -9999999999
c = 0
prev = -99999999
f = 0
for i in l:
	if prev <= i:
		c += 1
		prev = i
		if maxx < c:
			maxx = c
	else:
		c = 1
		prev = i
print(maxx)


N = int(input())
arr = list(map(int, input().split()))
(i, j) = (0, 1)
res = 1
while i <= j and j < len(arr):
	if arr[j] - arr[j - 1] >= 0:
		res = max(res, j - i + 1)
	else:
		i = j
	j += 1
print(res)


import math
n = int(input())
A = [int(x) for x in input().split()]
max_k = 0
k = 1
for i in range(len(A) - 1):
	if A[i + 1] >= A[i]:
		k += 1
	else:
		if max_k < k:
			max_k = k
		k = 1
if max_k < k:
	max_k = k
print(max_k)


a = int(input())
b = list(map(int, input().split()))
c = b.copy()
del b[0]

def weigh(x, y):
	if x - y >= 0:
		return 1
	else:
		return 0
d = list(map(weigh, b, c))
final = ''
import re
for letter in d:
	final += str(letter)
e = re.findall('1*', final)
g = max(list(map(len, e))) + 1
print(g)


N = int(input())
arr = list(map(int, input().split()))
arr1 = [0] * N
arr1[0] = 1
for i in range(N - 1):
	if arr[i] <= arr[i + 1]:
		arr1[i + 1] = arr1[i] + 1
	else:
		arr1[i + 1] = 1
print(max(arr1))


n = int(input())
arr = list(map(int, input().split()))
(bg, max_len) = (0, 0)
for i in range(1, n):
	if arr[i] < arr[i - 1]:
		max_len = max(max_len, i - bg)
		bg = i
max_len = max(max_len, n - bg)
print(max_len)


n = int(input())
arr = input().split()
count = 1
max_len = 1
for i in range(n - 1):
	arr[i] = int(arr[i])
	arr[i + 1] = int(arr[i + 1])
	if arr[i] <= arr[i + 1]:
		count += 1
	else:
		if count > max_len:
			max_len = count
		count = 1
if count > max_len:
	max_len = count
print(max_len)


n = int(input())
last = 0
longest = 0
actual = 0
for i in map(int, input().split(' ')):
	if i >= last:
		actual += 1
		last = i
	else:
		if actual > longest:
			longest = actual
		actual = 1
		last = i
if actual > longest:
	longest = actual
print(longest)


n = int(input())
nums = [int(num) for num in input().split()]
prev_num = 0
max_seq = 0
cur_seq = 0
for num in nums:
	if num < prev_num:
		cur_seq = 0
	cur_seq += 1
	max_seq = max(max_seq, cur_seq)
	prev_num = num
print(max_seq)


n = int(input())
arr = list(map(int, input().split()))
counter = 1
ans = 0
for i in range(1, len(arr)):
	if arr[i] >= arr[i - 1]:
		counter += 1
	else:
		ans = max(ans, counter)
		counter = 1
print(max(ans, counter))


n = int(input())
a = list(map(int, input().strip().split()))[:n]
c = 1
m = 0
for i in range(0, n - 1):
	if a[i] <= a[i + 1]:
		c += 1
	else:
		if c > m:
			m = c
		c = 1
if c > m:
	m = c
print(m)


n = int(input())
a = input().split()
max = 1
temp = 1
for i in range(n - 1):
	if int(a[i + 1]) >= int(a[i]):
		temp += 1
		if temp > max:
			max = temp
	else:
		temp = 1
print(max)


t = int(input())
a = list(map(int, input().split()))
length = 1
max_value = length
for i in range(t - 1):
	if a[i + 1] >= a[i]:
		length = length + 1
		max_value = max(max_value, length)
	else:
		length = 1
print(max_value)


n = int(input())
line = input().split()
if n == 1:
	print(1)
else:
	L = []
	k = 0
	s = n
	while k < s - 1:
		count = 1
		for i in range(k, s - 1):
			if int(line[i]) <= int(line[i + 1]):
				count += 1
			else:
				break
		k += count
		L.append(count)
	a = len(L)
	if a == 1:
		print(int(L[0]))
	else:
		L = sorted(L)
		print(int(L[a - 1]))


n = int(input())
arr = [int(x) for x in input().split()]
m = []
cur = 1
flag = False
for i in range(n - 1):
	if arr[i] <= arr[i + 1]:
		cur += 1
		flag = True
	else:
		m.append(cur)
		cur = 1
m.append(cur)
if flag == True or n == 1:
	print(max(m))
else:
	print(1)


l = int(input())
n = input().split(' ')
p = 1
m = 1
for i in range(l - 1):
	if int(n[i]) <= int(n[i + 1]):
		p += 1
	else:
		p = 1
	if p > m:
		m = p
print(m)


count = 0
length = int(input())
max_count = 0
values = input()
int_values = list(map(int, values.split()))
for index in range(0, length - 1):
	if int_values[index] <= int_values[index + 1]:
		count += 1
	else:
		if count > max_count:
			max_count = count
		count = 0
if 'max_count' in locals() and max_count > count:
	print(max_count + 1)
else:
	print(count + 1)


import sys
it = iter(sys.stdin.read().splitlines())
n = int(next(it))
s = [int(x) for x in next(it).split()]
temp = 0
count = 0
max = 0
for i in range(n):
	number = s[i]
	if number >= temp:
		temp = number
		count += 1
	else:
		temp = number
		count = 1
	if count > max:
		max = count
print(max)


n = int(input())
prices = [int(i) for i in input().split()]
a = 1
l = []
for i in range(n - 1):
	if prices[i] <= prices[i + 1]:
		a += 1
	else:
		l.append(a)
		a = 1
l.append(a)
print(max(l))


n = int(input())
if n == 1:
	print(1)
else:
	num = [int(x) for x in input().split()]
	sum = 1
	m = []
	for i in range(n - 1):
		if i == n:
			break
		elif num[i] <= num[i + 1]:
			sum += 1
		else:
			sum = 1
		m.append(sum)
	s = max(m)
	print(s)


n = int(input())
arr = list(map(int, input().split()))
prev = 0
count = 0
maxx = 0
for i in range(n):
	curr = arr[i]
	if curr >= prev:
		count += 1
	else:
		if count > maxx:
			maxx = count
		count = 1
	prev = arr[i]
if count > maxx:
	maxx = count
print(maxx)


n = int(input())
a = list(map(int, input().split()))
x = 1
y = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		x += 1
		y = max(y, x)
	else:
		x = 1
print(y)


n = int(input())
A = [*map(int, input().split())]
gmax_ = 0
lmax_ = 0
for (i, a) in enumerate(A):
	if i == 0:
		lmax_ = 1
	elif i > 0 and A[i] >= A[i - 1]:
		lmax_ += 1
	else:
		lmax_ = 1
	gmax_ = max(gmax_, lmax_)
print(gmax_)


l = int(input())
a = input().split()
b = 10000000000
c = 1
d = 1
for i in range(l):
	n = int(a[i])
	if n >= b:
		c += 1
		b = n
		if c > d:
			d = c
	else:
		c = 1
		b = n
print(d)


n = input()
revenue = [int(i) for i in input().split()]
(current, maximum) = (1, 1)
for i in range(1, len(revenue)):
	if revenue[i - 1] > revenue[i]:
		current = 1
	else:
		current += 1
		maximum = max(current, maximum)
print(maximum)


x = int(input())
a = list(map(int, input().split()))
j = 1
i = 0
k = 1
while j < x:
	if a[j] >= a[j - 1]:
		k += 1
		j += 1
	else:
		j += 1
		i = max(i, k)
		k = 1
i = max(i, k)
print(i)


n = int(input())
arr = list(map(int, input().split()))
segs = [1]
for i in range(1, n):
	if arr[i] - arr[i - 1] >= 0:
		segs[-1] += 1
	else:
		segs.append(1)
print(max(segs))


import itertools as it
import functools
import operator
import collections
import math
import sys

def solve(xs):
	cnt = collections.defaultdict(int)
	prev = 0
	for (i, x) in enumerate(xs, 1):
		if prev <= x:
			cnt[i] = cnt[i - 1] + 1
		else:
			cnt[i] = 1
		prev = x
	return max(cnt.values())

def print_stderr(*args, **kwargs):
	print(*args, file=sys.stderr, **kwargs)

def main():
	n = int(input())
	xs = [int(i) for i in input().strip().split()]
	assert len(xs) == n
	result = solve(xs)
	print(result)
main()


a = int(input())
arr = list(map(int, input().split()))
count = 1
c = []
for i in range(a - 1):
	if arr[i] <= arr[i + 1]:
		count += 1
		if i != a - 2:
			continue
	c.append(count)
	count = 1
if c == []:
	print(1)
else:
	print(max(c))


n = int(input())
a = list(map(int, input().split()))
aux = 1
counter = 1
for i in range(1, n):
	if int(a[i]) >= int(a[i - 1]):
		counter += 1
	else:
		aux = max(aux, counter)
		counter = 1
	aux = max(aux, counter)
print(aux)


import itertools as it
import functools
import operator
import collections
import math
import sys

def solve(xs):
	cnt = {0: 0}
	prev = 0
	for (i, x) in enumerate(xs, 1):
		if prev <= x:
			cnt[i] = cnt[i - 1] + 1
		else:
			cnt[i] = 1
		prev = x
	return max(cnt.values())

def solve2(xs):
	neighbors = zip(xs, xs[1:])
	acc = 1
	maxval = 0
	for (a, b) in neighbors:
		if a <= b:
			acc += 1
		else:
			acc = 1
		maxval = max(maxval, acc)
	return maxval

def scanl(f, ini, iterable):
	return it.accumulate(it.chain((ini,), iterable), f)

def solve3(xs):

	def _f(acc, pair):
		(a, b) = pair
		if a <= b:
			return acc + 1
		else:
			return 1
	neighbors = zip(xs, xs[1:])
	iterable = scanl(_f, 1, neighbors)
	return max(iterable)

def print_stderr(*args, **kwargs):
	print(*args, file=sys.stderr, **kwargs)

def main():
	n = int(input())
	xs = [int(i) for i in input().strip().split()]
	assert len(xs) == n
	result = solve3(xs)
	print(result)
main()


n = int(input())
a = list(map(int, input().split()))
count = 1
maximum = 0
for i in range(0, n - 1):
	if a[i] > a[i + 1]:
		if count > maximum:
			maximum = count
			count = 1
		else:
			count = 1
	else:
		count += 1
if count > maximum:
	maximum = count
print(maximum)


n = int(input())
a = list(input().split())
v = 0
i = 0
c = [int() for _ in range(n)]
for x in a:
	if int(x) >= v:
		v = int(x)
		c[i] += 1
	elif int(x) < v:
		v = int(x)
		i += 1
		c[i] += 1
print(max(c))


a = int(input())
b = input().split()
x = 0
while x < len(b) and 1 <= int(b[x]) <= 1000000000:
	b[x] = int(b[x])
	x = x + 1
y = 0
z = 1
maxi = 1
while y < len(b) - 1 and 1 <= a <= 100000:
	if b[y] <= b[y + 1]:
		z = z + 1
		if y == len(b) - 2 and z > maxi:
			maxi = z
	elif b[y] > b[y + 1]:
		if z > maxi:
			maxi = z
		z = 1
	y = y + 1
print(maxi)


n = int(input())
l = list(map(int, input().split()))
count = 1
nl = []
for i in range(1, len(l)):
	if l[i] >= l[i - 1]:
		count += 1
	else:
		nl.append(count)
		count = 1
else:
	nl.append(count)
print(max(nl))


x = int(input())
y = [int(a) for a in input().split()]
z = y[0]
t = 1
a = [1]
for i in range(1, x):
	if y[i] >= z:
		z = y[i]
		t += 1
		a.append(t)
	else:
		t = 1
		z = y[i]
print(max(a))


import math as mt
import sys as sy

class abc:

	def mkl(self):
		n = int(input())
		arr = list(map(int, sy.stdin.readline().split()))
		m = 1
		l = 1
		for i in range(1, n):
			if arr[i] >= arr[i - 1]:
				l = l + 1
			else:
				if m <= l:
					m = l
				l = 1
		if m < l:
			m = l
		print(m)
b = abc()
b.mkl()


n = int(input())
ar = list(map(int, input().split()))
res = 1
cur = 1
for i in range(1, len(ar)):
	if ar[i] < ar[i - 1]:
		res = max(res, cur)
		cur = 1
	else:
		cur += 1
res = max(res, cur)
print(res)


n = int(input())
a = [int(i) for i in input().split()]
l = [1]
for _ in range(1, n):
	l.append(0)
for i in range(1, n):
	if a[i] >= a[i - 1]:
		l[i] = l[i - 1] + 1
	else:
		l[i] = 1
mx = 0
for t in l:
	if t >= mx:
		mx = t
print(mx)


n = int(input())
l = list(map(int, input().split()))
ans = 1
s = 1
for i in range(n - 1):
	if l[i + 1] >= l[i]:
		s += 1
	else:
		if s > ans:
			ans = s
		s = 1
	if l[i + 1] >= l[i] and i == n - 2:
		if s > ans:
			ans = s
print(ans)


num = 1
n = int(input())
num_list = []
li = list(map(int, input().split(' ')))
if len(li) == 1:
	print(1)
else:
	for i in range(n - 1):
		if li[i] <= li[i + 1]:
			num += 1
			num_list.append(num)
		else:
			num_list.append(num)
			num = 1
			pass
	print(max(num_list))


n = int(input())
A = list(map(int, input().split()))
d = 1
c = 1
for i in range(len(A) - 1):
	if A[i] <= A[i + 1]:
		c += 1
	else:
		c = 1
	if c > d:
		d = c
print(d)


n = int(input())
L = [int(x) for x in input().split()]
s = []
num = 1
for i in range(1, n):
	if L[i] >= L[i - 1]:
		num += 1
	else:
		s.append(num)
		num = 1
s.append(num)
print(max(s))


n = int(input())
s = input()
l = s.split()
newl = []
nc = [1]
for i in range(n):
	newl.append(int(l[i]))
c = 1
for j in range(len(newl) - 1):
	if newl[j] <= newl[j + 1]:
		c += 1
		nc.append(c)
	else:
		c = 1
print(max(nc))


import sys
N = int(input())
L = list(map(int, input().strip().split(' ')))
(s, x) = (1, 0)
for i in range(len(L) - 1):
	if L[i] <= L[i + 1]:
		s += 1
	else:
		x = max(x, s)
		s = 1
print(max(x, s))


n = int(input())
l = list(map(int, input().split()))
lenn = 1
maxlen = 1
for i in range(n - 1):
	if l[i] <= l[i + 1]:
		lenn += 1
		if lenn >= maxlen:
			maxlen = lenn
	else:
		if lenn >= maxlen:
			maxlen = lenn
		lenn = 1
print(maxlen)


n = int(input())
x = list(map(int, input().split()))
l = 1
result = 0
for i in range(1, n):
	if x[i - 1] <= x[i]:
		l += 1
	else:
		result = max(result, l)
		l = 1
if l > result:
	result = l
print(result)


n = int(input())
arr = [int(x) for x in input().split()]
cur = arr[0]
count = 0
m = 0
for i in arr:
	if i >= cur:
		count += 1
	else:
		if count >= m:
			m = count
		count = 1
	cur = i
if count >= m:
	print(count)
else:
	print(m)


n = int(input())
l = list(map(int, input().split()))
m = 0
c = 0
for i in range(1, len(l)):
	if l[i] >= l[i - 1]:
		c += 1
	else:
		c = 0
	if m < c:
		m = c
print(m + 1)


n = int(input())
a = list(map(int, input().split()))
z = [1] * n
m = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		z[i] = z[i - 1] + 1
	m = max(m, z[i])
print(m)


t = int(input())
l = list(map(int, input().split()))
q = 1
a = []
for i in range(1, t):
	if l[i] >= l[i - 1]:
		q = q + 1
		if i == t - 1:
			a.append(q)
	else:
		a.append(q)
		q = 1
if q == t:
	a.append(q)
print(max(a))


def solve():
	(ans, ts) = (1, 1)
	n = input()
	a = [int(i) for i in input().split()]
	if n == '1':
		print('1')
		return
	l = a[0]
	for i in a[1:]:
		if i >= l:
			ts += 1
			ans = max(ans, ts)
		else:
			ts = 1
		l = i
	print(ans)
solve()


def longest_increasing_subsequence(arr, n):
	max_val = 1
	curr = 1
	for i in range(1, n):
		if arr[i] >= arr[i - 1]:
			curr += 1
		else:
			max_val = max(max_val, curr)
			curr = 1
	max_val = max(max_val, curr)
	return max_val
N = int(input())
arr = list(map(int, input().split(' ')))
print(longest_increasing_subsequence(arr, N))


n = int(input())
l = list(map(int, input().split()))
ll = []
llll = []
if len(l) == 1:
	print(1)
else:
	for i in range(n - 1):
		if l[i] <= l[i + 1]:
			ll.append(1)
		else:
			ll.append(0)
	import itertools
	lll = [len(list(v)) for (k, v) in itertools.groupby(ll)]
	if len(lll) == 1:
		if ll[0] == 1:
			print(n)
		else:
			print(1)
	else:
		if len(lll) % 2 == 0:
			if ll[0] == 1:
				for i in range(int(len(lll) / 2)):
					llll.append(lll[2 * i])
			else:
				for i in range(int(len(lll) / 2)):
					llll.append(lll[2 * i + 1])
		elif ll[0] == 1:
			for i in range(int(len(lll) // 2 + 1)):
				llll.append(lll[2 * i])
		else:
			for i in range(int(len(lll) // 2)):
				llll.append(lll[2 * i + 1])
		print(max(llll) + 1)


t = eval(input())
progress = list(map(int, input().split()))
maxi = 0
count = 1
for day in range(t - 1):
	if progress[day] > progress[day + 1]:
		if count > maxi:
			maxi = count
		count = 1
	else:
		count += 1
if count > maxi:
	maxi = count
print(maxi)


n = int(input())
v = [int(i) for i in input().split()]
c = 1
cmax = 1
for i in range(1, n):
	if v[i] >= v[i - 1]:
		c = c + 1
	else:
		if c > cmax:
			cmax = c
		c = 1
print(max(c, cmax))


l = 1
c = 1
k = int(input())
p = list(map(int, input().split()))
for i in range(k - 1):
	if p[i] <= p[i + 1]:
		l += 1
		if l >= c:
			c = l
	else:
		l = 1
print(c)


t = int(input())
nums = list(input().split())
maxm = 0
count = 0
for x in range(0, len(nums) - 1):
	if int(nums[x]) <= int(nums[x + 1]):
		count += 1
	else:
		count = 0
	maxm = max(maxm, count)
print(maxm + 1)


def fun(a, n):
	count = 1
	prev = 1
	for i in range(0, n - 1):
		if a[i + 1] >= a[i]:
			count = count + 1
		else:
			if prev <= count:
				prev = count
			count = 1
	if prev > count:
		return prev
	else:
		return count
n = int(input())
if 1 <= n and n <= 10 ** 5:
	a = list(map(int, input().split()))
	count = 0
	if len(a) == n:
		print(fun(a, n))


_ = input()
a = list(map(int, input().split()))
c = 0
d = 1
(out, save) = ([], [])
while c < len(a) and d < len(a):
	if a[c] <= a[d]:
		out.append(1)
		c += 1
		d += 1
	else:
		save.append(len(out))
		out = []
		c = d
		d += 1
save.append(len(out))
print(max(save) + 1, end='')


input()
days = list(map(int, input().split()))
mx = progress = prev = 0
for today in days:
	progress = progress + 1 if today >= prev else 1
	prev = today
	mx = max(mx, progress)
print(mx)


n = int(input())
a = input().split()
a = [int(a[i]) for i in range(n)]
length = [1]
for i in range(1, n):
	if a[i] >= a[i - 1]:
		length.append(length[i - 1] + 1)
	else:
		length.append(1)
print(max(length))


n = int(input())
arr = list(map(int, input().split()))
if n == 1:
	print(1)
else:
	start = 1
	mx = 1
	mxsofar = 0
	while start < n:
		prev = arr[start - 1]
		current = arr[start]
		if current >= prev:
			mx += 1
		else:
			mx = 1
		mxsofar = max(mxsofar, mx)
		start += 1
	print(mxsofar)


n = int(input())
Array = [int(x) for x in input().split()]
count = 1
max_count = 1
prev = Array[0]
for i in Array[1:]:
	if i >= prev:
		count += 1
		max_count = max(max_count, count)
	else:
		count = 1
	prev = i
print(max_count)


def main():
	a = int(input())
	b = input().split(' ')
	b = [int(x) for x in b]
	(prev, streak, maxstreak) = (0, 0, 0)
	for x in b:
		if x >= prev:
			streak += 1
			prev = x
			if streak > maxstreak:
				maxstreak = streak
		else:
			streak = 1
			prev = x
	print(maxstreak)
main()


n = int(input())
seq = input().split()
maxAll = maxl = 0
for i in range(n - 1):
	if int(seq[i]) > int(seq[i + 1]):
		maxAll = max(maxAll, maxl)
		maxl = 0
	else:
		maxl += 1
maxAll = max(maxAll, maxl)
print(maxAll + 1)


n = int(input())
sq = [int(x) for x in input().split()]
cnt = 1
lrgst = 1
for i in range(len(sq) - 1):
	if sq[i] <= sq[i + 1]:
		cnt += 1
		if cnt > lrgst:
			lrgst = cnt
	else:
		cnt = 1
print(lrgst)


__author__ = 'suvasish'
lst = []
n = int(input())
tc = input().split()
count = 0
tmp_count = 1
for i in range(len(tc) - 1):
	if int(tc[i]) <= int(tc[i + 1]):
		tmp_count += 1
	else:
		if tmp_count > count:
			count = tmp_count
		tmp_count = 1
if count > tmp_count:
	print(count)
else:
	print(tmp_count)


n = input()
n = int(n)
resp = 1
num = list(map(int, input().split()))
num.append(0)
lista = [0]
for (x, y) in zip(num, num[1:]):
	if x <= y:
		resp += 1
	elif x > y:
		lista.append(resp)
		resp = 1
	else:
		lista.append(resp)
		break
r = max(lista)
print(r)


n = int(input())
arr = list(map(int, input().split()))
dp = [1] * n
for i in range(1, len(arr)):
	if arr[i] >= arr[i - 1]:
		dp[i] = dp[i - 1] + 1
print(max(dp))


n = int(input())
a = list(map(int, input().split()))
t = 0
k = 0
h = []
for i in a:
	if i >= k:
		k = i
		t += 1
	else:
		h.append(t)
		t = 1
		k = i
h.append(t)
print(max(h))


i = lambda : map(int, input().split())
n = int(input())
l = list(i())
maxm = 1
c = 1
for j in range(n):
	if n == 1:
		break
	if j == n - 1:
		if c > maxm:
			maxm = c
		break
	if l[j] > l[j + 1]:
		maxm = max(c, maxm)
		c = 1
	if l[j] <= l[j + 1]:
		c += 1
print(maxm)


n = int(input())
l = [int(x) for x in input().split(' ')]
max1 = 0
count = 1
if n == 1:
	max1 = 1
for i in range(0, n - 1):
	if l[i] <= l[i + 1]:
		count = count + 1
	else:
		count = 1
	if count > max1:
		max1 = count
print(max1)


n = int(input())
a = [int(x) for x in input().split()]
dp = 1
dp_max = 1
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		dp += 1
		if dp > dp_max:
			dp_max = dp
	else:
		dp = 1
print(dp_max)


n = int(input())
lis = list(map(int, input().strip().split()))
k = 1
m = 0
for i in range(len(lis) - 1):
	if lis[i] <= lis[i + 1]:
		k = k + 1
	else:
		m = max(m, k)
		k = 1
m = max(m, k)
print(m)


n = int(input())
lijst = list(map(int, input().split(' ')))
langste = 1
huidig = 1
for i in range(n - 1):
	if lijst[i + 1] >= lijst[i]:
		huidig += 1
		if langste < huidig:
			langste = huidig
	else:
		huidig = 1
print(langste)


n = int(input())
a = list(map(int, input().split()))
b = [0] * n
b[0] = 1
j = 1
while j < n:
	if a[j - 1] <= a[j]:
		b[j] = b[j - 1] + 1
	else:
		b[j] = 1
	j += 1
print(max(b))


n = int(input())
l = list(map(int, input().split()))
c = 1
k = []
for i in range(n - 1):
	if l[i] <= l[i + 1]:
		c += 1
		if i == n - 2:
			k.append(c)
	else:
		k.append(c)
		c = 1
if len(k) == 0:
	print('1')
else:
	print(max(k))


n = int(input())
s = input().split()
s = list(map(int, s))
max = 1
count = 1
for i in range(n - 1):
	if s[i] <= s[i + 1]:
		count += 1
	elif max < count:
		max = count
		count = 1
	else:
		count = 1
if max < count:
	print(count)
else:
	print(max)


n = int(input())
arr = list(map(int, input().split()))
(res, prev) = (1, 1)
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		prev += 1
		res = max(res, prev)
	else:
		prev = 1
print(res)


n = int(input())
liste = list(map(int, input().split(' ')))
subseq = list()
subseq.append(1)
for i in range(1, n):
	if liste[i] < liste[i - 1]:
		subseq.append(1)
	else:
		subseq.append(subseq[len(subseq) - 1] + 1)
print(max(subseq))


n = int(input())
a = list(map(int, input().split()))
c = [0] * len(a)
for i in range(len(a) - 1):
	if a[i] <= a[i + 1]:
		c[i] = 1
(d, m) = (0, 0)
for i in c:
	if i == 1:
		d = d + 1
	else:
		m = max(m, d)
		d = 0
print(m + 1)


import math
n = int(input())
a = [int(i) for i in input().split()]
start = 0
end = 1
l = []
for i in range(0, len(a) - 1):
	if a[i + 1] >= a[i]:
		end = end + 1
	else:
		l.append(abs(start - end))
		end = end + 1
		start = end - 1
l.append(abs(start - end))
print(max(l))


n = int(input())
lst = list(map(int, input().split()))
count = 1
j = 0
lst1 = [1]
for i in range(n):
	if i < n - 1:
		if lst[i + 1] >= lst[i]:
			lst1[j] += 1
		else:
			lst1.append(1)
			j += 1
print(max(lst1))


count = int(input())
data = [int(i) for i in input().split()]
high = 1
num = 1
for i in range(count - 1):
	if data[i] <= data[i + 1]:
		num += 1
		if num > high:
			high = num
	else:
		num = 1
print(high)


def kefa(lst):
	(maximum, count) = (0, 1)
	for i in range(len(lst)):
		if i + 1 < len(lst) and lst[i] <= lst[i + 1]:
			count += 1
		else:
			if count > maximum:
				maximum = count
			count = 1
	return max(count, maximum)
n = int(input())
a = [int(j) for j in input().split()]
print(kefa(a))


from builtins import input
input()
l = list(map(int, input().split()))
length = len(l)
max_len = 1
temp_len = 1
for i in range(1, length):
	if l[i] >= l[i - 1]:
		temp_len += 1
		max_len = max(temp_len, max_len)
	else:
		temp_len = 1
print(max_len)


input()
a = [int(i) for i in input().split(' ')]
r = 1
c = 1
for i in range(len(a) - 1):
	if a[i + 1] >= a[i]:
		c += 1
	else:
		r = max(r, c)
		c = 1
r = max(r, c)
print(r)


import sys
from collections import *
from math import *
import re

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	c = 0
	for i in range(2, n):
		if prime[i]:
			c += 1
	return c

def iseven(n):
	return [False, True][0 if n % 2 else 1]

def inp_arr():
	return list(map(int, input().split()))

def inp():
	return map(int, input().split())

def lcm(a, b):
	return a * b / gcd(a, b)
max_int = sys.maxsize
mod = 10 ** 9 + 7
n = int(input())
arr = inp_arr()
(include, ans) = (1, 0)
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		include += 1
	else:
		ans = max(ans, include)
		include = 1
print(max(ans, include))


n = int(input())
k = [int(x) for x in input().split()]
c = m = s = 0
for i in k:
	if i >= s:
		c = c + 1
	else:
		c = 1
	m = max(m, c)
	s = i
print(m)


n = int(input())
A = [1 for i in range(0, n)]
INP = input().split(' ')
max = 1
for i in range(1, n):
	if int(INP[i - 1]) <= int(INP[i]):
		A[i] = A[i - 1] + 1
	if A[i] > max:
		max = A[i]
print(max)


n = int(input())
arr = [int(x) for x in input().split()]
arr2 = []
maxL = -1
if len(arr) == 1:
	print(1)
else:
	for i in range(n - 1):
		if i == 0:
			arr2.append(i)
		if arr[i + 1] >= arr[i]:
			arr2.append(arr[i])
		else:
			maxL = max(maxL, len(arr2))
			arr2 = []
			arr2.append(arr[i])
	print(max(maxL, len(arr2)))


n = int(input())
t = list(map(int, input().split()))
r = [1]
count = 1
for i in range(len(t) - 1):
	if t[i] <= t[i + 1]:
		count += 1
		r.append(count)
	else:
		count = 1
print(max(r))


n = int(input())
lista = list(map(int, input().split()))
maior = 1
atual = 1
for l in range(1, n):
	if lista[l] >= lista[l - 1]:
		atual += 1
	else:
		atual = 1
	maior = max(maior, atual)
print(maior)


n = int(input())
A = input().split()
b = list()
b += [A[0]]
c = [1] * (n + 1)
j = 1
l = 0
for i in range(n - 1):
	if int(A[i + 1]) >= int(A[i]):
		b += [A[i + 1]]
		j = len(b)
		c[l] = j
	else:
		b = [A[i + 1]]
		l += 1
		j = len(b)
		c[l] = j
c = sorted(c)
print(c[len(c) - 1])


N = int(input())
L = list(map(int, input().strip().split()))
dp = [1 for i in range(N)]
for i in range(1, N):
	if L[i] >= L[i - 1]:
		dp[i] = dp[i - 1] + 1
print(max(dp))


def main():
	n = int(input())
	arr = list(map(int, input().rstrip().split()))
	count = 0
	maxcount = 0
	temp = 0
	for i in arr:
		if temp <= i:
			count += 1
		else:
			maxcount = max(maxcount, count)
			count = 1
		temp = i
	maxcount = max(maxcount, count)
	print(maxcount)
main()


n = int(input())
a1 = list(map(int, input().split()))[:n]
if len(a1) == 1:
	print(1)
	exit()
mx = 0
cnt = 1
for i in range(0, n):
	if i == len(a1) - 1:
		break
	if a1[i] <= a1[i + 1]:
		cnt = cnt + 1
	else:
		cnt = 1
	if cnt > mx:
		mx = cnt
print(mx)


counter = 0
holder = 0
currcounter = 0
n = int(input())
l = list(map(int, input().split()))
for a in l:
	if a >= holder:
		currcounter += 1
		holder = a
	else:
		currcounter = 1
		holder = a
	counter = max(counter, currcounter)
print(counter)


count = 1
sub = -1
n = int(input())
array = input().split()
i = 1
while i < n:
	var = int(array[i])
	last = int(array[i - 1])
	if var >= last:
		count += 1
	else:
		if sub < count:
			sub = count
		count = 1
	i += 1
if sub < count:
	sub = count
print(sub)


N = int(input())
a = list(map(int, input().split()))
answer = 0
prev = 0
count = 0
for i in range(N):
	if a[i] >= prev:
		count += 1
		if answer < count:
			answer = count
	else:
		count = 1
	prev = a[i]
print(answer)


n = int(input())
l = [int(i) for i in input().split()]
l1 = []
c = 1
if n == 1:
	print(1)
elif n == 2:
	if l[0] <= l[1]:
		print(2)
	else:
		print(1)
else:
	for i in range(n - 1):
		if l[i] // l[i + 1] == 0 or (l[i] // l[i + 1] == 1 and l[i] == l[i + 1]):
			c += 1
			l1.append(c)
		else:
			l1.append(c)
			c = 1
	print(max(l1))


l = int(input())
array = [int(j) for j in input().split()]
t = 0
tot = 0
for i in range(0, len(array) - 1):
	if array[i + 1] >= array[i]:
		t += 1
	else:
		t = 0
	tot = max(t, tot)
print(tot + 1)


n = int(input())
arr = list(map(int, input().split()))
x = 1
k = 0
while k < n:
	c = 1
	while k < n - 1 and arr[k] <= arr[k + 1]:
		c += 1
		k += 1
	k += 1
	if c > x:
		x = c
print(x)


n = int(input())
a = [int(i) for i in input().split()]
t = a[0]
count = 1
maxx = 1
for i in range(1, len(a)):
	if t <= a[i]:
		t = a[i]
		count += 1
	else:
		t = a[i]
		count = 1
	if count > maxx:
		maxx = count
print(maxx)


n_val = int(input())
(*arr,) = map(int, input().split())
count = 1
maxval = 0
for i in range(n_val - 1):
	if arr[i] <= arr[i + 1]:
		count += 1
	else:
		if count > maxval:
			maxval = count
		count = 1
else:
	if count > maxval:
		maxval = count
	count = 1
print(maxval)


n = int(input())
k = [int(x) for x in input().split()]
maxi = 1
c = 1
last = k[0]
i = 1
while i < n:
	if k[i] >= k[i - 1]:
		c += 1
		if c > maxi:
			maxi = c
	else:
		c = 1
	i += 1
print(maxi)


from math import *

def main():
	n = int(input())
	a = list(map(int, input().split()))
	ans = 0
	mx = 0
	for i in range(n - 1):
		if a[i] <= a[i + 1]:
			mx += 1
			if mx > ans:
				ans = mx
		else:
			if mx > ans:
				ans = mx
			mx = 0
	print(ans + 1)
main()


i = input
n = int(input())
s = i().split()
s += '0'
(f, t, l) = [0, 0, 0]
for x in range(1, len(s)):
	if int(s[x]) < int(s[x - 1]):
		if l < x - f:
			l = x - f
		f = x
print(l)


n = int(input())
line = [int(i) for i in input().split()]
maximum = 1
length = 1
for i in range(1, n):
	if line[i] >= line[i - 1]:
		length += 1
	else:
		maximum = max(length, maximum)
		length = 1
	if i == n - 1:
		maximum = max(length, maximum)
print(maximum)


def lenmax(m):
	b = 0
	for x in m:
		if len(x) > b:
			b = len(x)
	return b

def liststr(m):
	return ''.join(m)
n = input()
n = int(n)
list = input().split(' ')
count = []
for i in range(n):
	list[i] = int(list[i])
for x in range(n - 1):
	if list[x] <= list[x + 1]:
		count.append('1')
	else:
		count.append('0')
count = liststr(count)
ls = count.split('0')
print(lenmax(ls) + 1)


n = int(input())
l = [int(i) for i in input().split()]
a = []
for i in range(1, n):
	if l[i] < l[i - 1]:
		a.append(i)
if len(a) == 0:
	print(len(l))
else:
	b = [a[0]]
	for j in range(1, len(a)):
		b.append(int(a[j] - a[j - 1]))
	b.append(n - a[len(a) - 1])
	print(max(b))


n = int(input())
l = list(map(int, input().split()))
m = 0
c = 1
s = [l[0]]
for e in l[1:]:
	if e >= s[-1]:
		s.append(e)
		c = c + 1
	else:
		m = max(m, c)
		c = 1
		s.append(e)
print(max(m, c))


x = int(input())
l = list(map(int, input().split()))
final = [1]
for i in range(x - 1):
	if l[i] <= l[i + 1]:
		final.append(final[i] + 1)
	else:
		final.append(1)
print(max(final))


n = int(input())
s = list(map(int, input().split()))
first = s[0]
cont = 0
maxi = 0
for i in range(len(s)):
	if s[i] >= s[i - 1]:
		cont += 1
		maxi = max(maxi, cont)
	else:
		cont = 1
print(maxi)


n = int(input())
a = list(map(int, input().split()))
le = 1
maxi = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		le += 1
	else:
		if maxi < le:
			maxi = le
		le = 1
if maxi < le:
	maxi = le
print(maxi)


n = int(input())
m = input().split()
z = 1
a = 1
for i in range(len(m)):
	m[i] = int(m[i])
for i in range(len(m) - 1):
	if m[i + 1] >= m[i]:
		z = z + 1
		a = max(z, a)
	else:
		z = 1
print(a)


n = int(input())
l = [int(j) for j in input().split()]
k = 1
mx = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		k += 1
		mx = max(mx, k)
	else:
		k = 1
print(mx)


n = int(input())
x = input().split()
for i in range(n):
	x[i] = int(x[i])
lista = []
e = 0
for i in range(n):
	if i != n - 1:
		if x[i] <= x[i + 1]:
			e += 1
		if x[i] > x[i + 1]:
			e += 1
			lista.append(e)
			e = 0
	if i == n - 1:
		if x[i] >= x[i - 1]:
			e += 1
	lista.append(e)
lista.sort()
print(lista[len(lista) - 1])


(c, p, v) = (0, 0, 0)
input()
for a in map(int, input().split()):
	if a >= p:
		c += 1
		if c > v:
			v = c
	else:
		c = 1
	p = a
print(v)


def main():
	n = int(input())
	a = list(map(int, input().split()))
	lenp = 1
	arrlenp = []
	for i in range(1, len(a)):
		if a[i] >= a[i - 1]:
			lenp += 1
		else:
			arrlenp.append(lenp)
			lenp = 1
	arrlenp.append(lenp)
	print(max(arrlenp))
main()


a = int(input())
b = list(map(int, input().split()))
q = c = 1
for i in range(1, a):
	if b[i] >= b[i - 1]:
		c += 1
		q = max(q, c)
	else:
		c = 1
print(q)


n = int(input())
nums = [int(x) for x in input().split()]
prev = -float('inf')
longest = 0
current = 0
for num in nums:
	if num >= prev:
		current += 1
	else:
		current = 1
	prev = num
	longest = max(longest, current)
print(longest)


n = int(input())
arr = list(map(int, input().split()))
maxLen = 1
currLen = 1
for i in range(n - 1):
	if arr[i + 1] >= arr[i]:
		currLen += 1
		maxLen = max(maxLen, currLen)
	else:
		currLen = 1
print(maxLen)


days = int(input())
money = list(map(int, input().split()))
currLength = 1
maxLength = 1
for i in range(1, days):
	if money[i - 1] <= money[i]:
		currLength += 1
	else:
		if maxLength < currLength:
			maxLength = currLength
		currLength = 1
if maxLength < currLength:
	maxLength = currLength
print(maxLength)


n = int(input())
a = input()
a = a.split()
a = [int(i) for i in a]
d = []
cont = 1
b = -1
for i in range(0, n - 1):
	if a[i] <= a[i + 1]:
		cont += 1
	else:
		d.append(cont)
		cont = 1
d.append(cont)
d.sort()
print(d[len(d) - 1])


input()
c = m = 0
a = 11 ** 11
for i in map(int, input().split()):
	if i < a:
		m = 0
	m += 1
	c = max(c, m)
	a = i
print(c)


n = int(input())
a = list(map(int, input().split()))
solution = 1
count = 1
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		count += 1
		if i == n - 2 and count > solution:
			solution = count
	else:
		if count > solution:
			solution = count
		count = 1
print(solution)


n = int(input())
s = input().split()
g = [0 for i in range(n + 1)]
for i in range(n):
	g[i] = int(s[i])
g[n] = -1
summ = 0
maxx = 0
for i in range(1, n + 1):
	if g[i] >= g[i - 1]:
		summ += 1
	else:
		if maxx < summ:
			maxx = summ
		summ = 0
print(maxx + 1)


n = int(input())
a = list(map(int, input().split()))
b = [1] * n
for ind in range(1, n):
	if a[ind] >= a[ind - 1]:
		b[ind] = b[ind - 1] + 1
print(max(b))


from collections import defaultdict as dfd
import math
import sys

def II():
	return int(sys.stdin.readline())

def MI():
	return map(int, sys.stdin.readline().split())

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

def LLI(rows_number):
	return [LI() for _ in range(rows_number)]

def main():
	x = II()
	A = LI()
	t = 0
	maxi = 0
	for i in range(len(A)):
		if i == 0:
			t += 1
			maxi = max(t, maxi)
		elif A[i] >= A[i - 1]:
			t += 1
			maxi = max(t, maxi)
		else:
			t = 1
	print(maxi)
main()


x = int(input())
arr = list(map(int, input().split()))
n = 1
ans = 1
for i in range(1, x):
	if arr[i] >= arr[i - 1]:
		n += 1
		if n > ans:
			ans = n
	else:
		n = 1
print(ans)


input()
c = p = n = 0
s = set()
for i in map(int, input().split()):
	c = [1, c + 1][i >= p]
	p = i
	s.add(c)
print(max(s))


n = int(input())
l = [int(i) for i in input().split()]
if n != 1:
	i = 0
	ans = []
	while i < n - 1:
		cnt = 0
		st = i
		while i < n - 1 and l[i] <= l[i + 1]:
			cnt += 1
			i += 1
		ans.append(cnt + 1)
		i += 1
	print(max(ans))
else:
	print(1)


x = int(input())
li = list(map(int, input().split()))
li.append(0)
count = 0
mx_len = 0
i = 0
while i < len(li) - 1:
	if not li[i] < li[i - 1]:
		count += 1
	else:
		if mx_len < count:
			mx_len = count
		count = 1
	i += 1
print(max(count, mx_len))


n = int(input())
arr = list(map(int, input().split()))
maxlen = 0
prev = -2 ** 31 - 1
lent = 0
for i in range(len(arr)):
	if arr[i] >= prev:
		lent = lent + 1
		prev = arr[i]
	else:
		lent = 1
		prev = arr[i]
	maxlen = max(maxlen, lent)
print(maxlen)


def Mayor(a, b):
	if a > b:
		return a
	else:
		return b
n = int(input())
A = [int(x) for x in input().split()]
k = 0
r = 1
mayor = 1
for i in range(n - 1):
	if A[k] <= A[k + 1]:
		r = r + 1
		mayor = Mayor(mayor, r)
	else:
		r = 1
	k = k + 1
print(mayor)


n = int(input())
lst = list(map(int, input().split()))
(curr, ans) = (1, 1)
for i in range(1, len(lst)):
	if lst[i] >= lst[i - 1]:
		curr += 1
		ans = max(ans, curr)
	else:
		curr = 1
print(ans)


days = int(input())
income = [int(i) for i in input().split()]
max_length = 0
length = 1
if days == 1:
	print(days)
else:
	for i in range(1, days):
		if income[i] >= income[i - 1]:
			length += 1
		else:
			length = 1
		if length > max_length:
			max_length = length
	print(max_length)


n = int(input())
money = list(map(int, input().split()))
no = []
count = 0
if n > 1:
	for i in range(1, len(money)):
		if i == 1:
			if money[0] <= money[1]:
				no.append(money[0])
				no.append(money[1])
				count = max(count, len(no))
		elif money[i - 1] <= money[i]:
			no.append(money[i])
			count = max(count, len(no))
		else:
			count = max(count, len(no))
			no = []
			no.append(money[i])
else:
	count = 1
print(count)


n = int(input())
c = 0
mc = 0
pr = 100000000000
for x in [int(x) for x in input().split()]:
	if x >= pr:
		c += 1
	else:
		mc = max(c, mc)
		c = 0
	pr = x
print(max(mc, c) + 1)


import math
num = int(input())
x = input()
lst = x.split()
arr = list(map(int, lst))
ans = 0
lens = 1
for i in range(0, num - 1):
	if arr[i] > arr[i + 1]:
		ans = max(ans, lens)
		lens = 0
	lens += 1
ans = max(ans, lens)
print(ans)


n = int(input())
A = list(map(int, input().split()))
i = 1
res = tmp = 1
while i < n:
	if A[i] >= A[i - 1]:
		tmp += 1
	else:
		res = max(res, tmp)
		tmp = 1
	i += 1
res = max(res, tmp)
print(res)


a = 0
lst = [1]
z = int(input())
x = list(map(int, input().split()))
for i in range(1, z):
	if x[i - 1] <= x[i]:
		a += 1
	else:
		a = 0
	lst.append(a + 1)
print(max(lst))


n = int(input())
l = list(map(int, input().split()))
mx = 0
curr = 0
prev = 0
for el in l:
	if el >= prev:
		curr += 1
	else:
		curr = 1
	prev = el
	mx = max(mx, curr)
print(mx)


n = int(input())
a = list(map(int, input().split()))
i = 1
ans = 1
tans = 1
while i < n:
	if a[i] >= a[i - 1]:
		tans += 1
		if tans > ans:
			ans = tans
	else:
		tans = 1
	i += 1
print(ans)


n = int(input())
an = 1
ans = 1
line = input().split()
line = [int(i) for i in line]
for i in range(1, n):
	if line[i] >= line[i - 1]:
		an += 1
	else:
		an = 1
	ans = max(an, ans)
print(ans)


n = int(input())
aa = list(map(int, input().split(' ')))
res = 0
c = -100
l = 0
for a in aa:
	if c <= a:
		l += 1
		res = max(res, l)
	else:
		l = 1
	c = a
print(res)


r = input
n = int(r())
a = list(map(int, r().split()))
lenth = 1
i = 0
while i < n and i + lenth < n:
	for j in range(i + 1, n):
		if a[j] < a[j - 1]:
			i = j
			break
		elif j - i + 1 > lenth:
			lenth = j - i + 1
print(lenth)


n = int(input())
arr = list(map(int, input().split()))
j = 0
c = 0
if len(arr) == 1:
	print(1)
else:
	for i in range(1, n):
		if arr[i] >= arr[i - 1]:
			i += 1
			c = max(i - j, c)
		else:
			c = max(i - j, c)
			j = i
			i += 1
	print(c)


def integerize(list):
	for i in range(len(list)):
		list[i] = int(list[i])
	return list
n = int(input())
list = input().split()
list = integerize(list)
count = 1
max = 1
i = 0
while i <= len(list) - 2:
	if list[i] <= list[i + 1]:
		count += 1
	else:
		count = 1
	if count > max:
		max = count
	i += 1
print(max)


n = int(input(''))
nums = list(map(int, input('').split(' ')))
result = 1
curr = 1
for i in range(1, len(nums)):
	if nums[i] >= nums[i - 1]:
		curr += 1
		result = max(result, curr)
	else:
		curr = 1
print(result)


n = int(input())
a = list(map(int, input().split()))
maxi = 1
i = 0
while i < n - 1:
	curMax = 1
	if a[i] <= a[i + 1]:
		while i < n - 1 and a[i] <= a[i + 1]:
			curMax += 1
			i += 1
		i -= 1
	if curMax > maxi:
		maxi = curMax
	i += 1
print(maxi)


n = int(input())
m = list(map(int, input().split()))
d = [1]
c = 1
for i in range(n - 1):
	j = i + 1
	if m[j] >= m[i]:
		c += 1
		d.append(c)
	else:
		c = 1
print(max(d))


N = int(input())
lst = list(map(int, input().split()))
k = x = 1
for i in range(N - 1):
	if lst[i] <= lst[i + 1]:
		k += 1
		x = max(k, x)
	else:
		k = 1
print(x)


n = int(input())
line = [int(x) for x in input().split()]
num = line[0]
length = [1] * n
if n == 1:
	print(1)
else:
	for i in range(1, n):
		if line[i] >= num:
			length[i] = length[i - 1] + 1
			num = line[i]
		else:
			num = line[i]
	length.sort()
	print(length[-1])


n = int(input())
l = list((int(x) for x in input().split()))
k = m = 1
for i in range(n - 1):
	k = k + 1 if l[i + 1] >= l[i] else 1
	m = max(m, k)
print(m)


n = int(input())
lineArr = []
for i in input().split(' '):
	lineArr.append(int(i))
maxSegment = 1
currentSegment = 1
for i in range(len(lineArr) - 1):
	a = lineArr[i]
	b = lineArr[i + 1]
	if a <= b:
		currentSegment += 1
	else:
		currentSegment = 1
	if currentSegment > maxSegment:
		maxSegment = currentSegment
print(maxSegment)


n = int(input())
list1 = list(map(int, input().split()))
len1 = len(list1)
l = 1
ml = 1
for i in range(1, len1):
	if list1[i] >= list1[i - 1]:
		l += 1
		ml = max(l, ml)
	else:
		l = 1
print(ml)


n = int(input())
l = list(map(int, input().split()))
count = 0
maxLen = 0
tmpLen = 0
while count < n - 1:
	if l[count + 1] >= l[count]:
		tmpLen += 1
		if maxLen < tmpLen:
			maxLen = tmpLen
	else:
		tmpLen = 0
	count += 1
print(maxLen + 1)


n = int(input())
s = list(map(int, input().split()))
ans = k = t = 0
for i in s:
	if i >= t:
		k += 1
	else:
		k = 1
	ans = max(k, ans)
	t = i
print(ans)


n = int(input())
s = str(input()).split()
m = 1
mx = 1
for i in range(n):
	s[i] = int(s[i])
	if i != 0:
		if s[i] >= s[i - 1]:
			m += 1
			if m > mx:
				mx = m
		else:
			m = 1
print(mx)


s = int(input())
d = [int(x) for x in input().split()]
l = []
num = 1
for i in range(1, s):
	if d[i] >= d[i - 1]:
		num += 1
	else:
		l.append(num)
		num = 1
l.append(num)
print(max(l))


n = int(input())
s = list(map(int, input().split()))
i = 1
aa = set()

def c(n):
	x = 1
	j = 0
	for j in range(n - 1):
		if s[i + j - 1] - s[i + j] <= 0:
			x = x + 1
		else:
			break
	return (x, j + 1)
while n > 1:
	(a, b) = c(n)
	i += b
	n -= b
	aa.add(a)
else:
	aa.add(1)
print(max(aa))


n = int(input())
a = input().split()
l = []
d = 0
c = 0
xyz = 0
for i in a:
	l.append(int(i))
for x in range(0, n):
	if xyz > x + 1:
		continue
	c = 0
	if x + 1 == n:
		break
	for y in range(x + 1, n):
		if l[y] - l[y - 1] >= 0:
			c += 1
			if y + 1 == n:
				if c > d:
					d = c
					xyz = x + c
		else:
			if c > d:
				d = c
			xyz = x + c
			break
print(d + 1)


n = int(input())
a = input()
total = 1
list1 = a.split(' ')
list2 = []
for i in range(1, n):
	if int(list1[i]) >= int(list1[i - 1]):
		total += 1
	else:
		list2.append(total)
		total = 1
list2.append(total)
print(max(list2))


def main():
	n = int(input())
	a = [int(x) for x in input().split()]
	c = 0
	m = 0
	for i in range(n - 1):
		if a[i] <= a[i + 1]:
			c += 1
		else:
			m = max(c, m)
			c = 0
	print(max(m + 1, c + 1))
main()


n = int(input())
arr = list(map(int, input().split()))
seg_length = []
count = 0
for i in range(len(arr)):
	if arr[i - 1] <= arr[i]:
		count += 1
		seg_length.append(count)
	elif arr[i - 1] > arr[i]:
		seg_length.append(count)
		count = 0
		count = 1
seg_length.sort()
print(seg_length[-1])


n = int(input())
entrada = list(map(int, input().split()))
arreglo = []
if n == 1:
	print(1)
else:
	cont = 1
	for i in range(n - 1):
		if entrada[i + 1] >= entrada[i]:
			cont += 1
		else:
			arreglo.append(cont)
			cont = 1
		arreglo.append(cont)
	print(max(arreglo))


n = int(input())
profits = str(input()).split(' ')
current = 0
count = 0
max_count = 0
for profit in profits:
	if int(profit) >= current:
		count += 1
		current = int(profit)
	else:
		current = int(profit)
		if max_count < count:
			max_count = count
		count = 1
	if count > max_count:
		max_count = count
print(max_count)


n = int(input())
l = list(map(int, input().split()))
c = 1
i = 0
m = 1
while i < n - 1:
	if l[i] <= l[i + 1]:
		c += 1
		i = i + 1
	else:
		if c > m:
			m = c
		c = 1
		i = i + 1
if c > m:
	print(c)
else:
	print(m)


n = int(input())
a = list(map(int, input().split()))
count = 1
result = 1
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		count += 1
	else:
		count = 1
	if count >= result:
		result = count
print(result)


n = int(input())
l = list(map(int, input().split()))
m = 0
cl = [10 ** 10]
k = 0
for i in range(n):
	if cl[k - 1] > l[i]:
		m = max(m, len(cl))
		cl.clear()
		k = 0
	cl.append(l[i])
	k += 1
m = max(m, len(cl))
print(m, end='')


n = int(input())
a = list(map(int, input().split()))
if n <= 1:
	print(1)
else:
	MaxLen = 1
	CurrLen = 1
	for i in range(1, n):
		if a[i - 1] <= a[i]:
			CurrLen += 1
		else:
			CurrLen = 1
		MaxLen = max(MaxLen, CurrLen)
	print(MaxLen)


n = int(input())
N = [int(i) for i in input().split()]
count = 1
maximum = 1
for i in range(0, n - 1):
	if N[i + 1] >= N[i]:
		count += 1
	else:
		count = 1
	maximum = max(maximum, count)
print(maximum)


n = int(input())
a = [int(x) for x in input().split()]
x = [1] * n
num = a[0]
for i in range(1, n):
	if a[i] >= num:
		x[i] = x[i - 1] + 1
	num = a[i]
x.sort()
print(x[-1])


n = input()
ax = list(map(int, input().split()))
c = 0
last = -1
cmax = 0
for a in ax:
	if a >= last:
		c += 1
	else:
		cmax = max(c, cmax)
		c = 1
	last = a
cmax = max(c, cmax)
print(cmax)


n = int(input())
a = [int(x) for x in input().split()]
count = 1
b = []
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		count += 1
	else:
		b.append(count)
		count = 1
b.append(count)
print(max(b))


n = int(input())
l = list(map(int, input().split()))
sum = 0
max = 0
j = 0
a = 0
for i in l:
	if i >= j:
		sum = sum + 1
	else:
		if sum >= max:
			max = sum
		sum = 1
	j = i
if max >= sum:
	print(max)
else:
	print(sum)


n = int(input())
a = list(map(int, input().split()))
(l, ma) = (1, 1)
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		l += 1
	else:
		l = 1
	if l > ma:
		ma = l
print(ma)


def sol(arr, n):
	(res, pos) = ([], arr[0])
	tem = tem1 = 1
	for i in range(1, n):
		tem = max(tem, tem1)
		if arr[i] >= pos:
			(pos, tem1) = (arr[i], tem1 + 1)
		else:
			(tem1, pos) = (1, arr[i])
	return max(tem, tem1)
n = int(input())
arr = list(map(int, input().split()))
print(sol(arr, n))


n = int(input())
l = list(map(int, input().split()))

def lenOfLongIncSubArr(l, n):
	m = 1
	c = 1
	for i in range(1, n):
		if l[i] >= l[i - 1]:
			c = c + 1
		else:
			if m < c:
				m = c
			c = 1
	if m < c:
		m = c
	return m
print(lenOfLongIncSubArr(l, n))


n = int(input())
L = list(map(int, input().split()))
d = [1]
c = 0
for a in range(1, n):
	if L[a] >= L[a - 1]:
		d.append(max(d[a - 1], a - c + 1))
	else:
		d.append(d[a - 1])
		c = a
print(d[-1])


n = int(input())
nums = list(map(int, input().split()))
max_len = 1
cur_len = 1
for i in range(1, len(nums)):
	if nums[i] < nums[i - 1]:
		max_len = max(max_len, cur_len)
		cur_len = 1
	else:
		cur_len += 1
max_len = max(max_len, cur_len)
print(max_len)


n = int(input())
a = list(map(int, input().split(' ')))
max_seq = 0
seq = 1
for i in range(1, n):
	if a[i - 1] <= a[i]:
		seq += 1
	else:
		max_seq = max(max_seq, seq)
		seq = 1
max_seq = max(max_seq, seq)
print(max_seq)


n = input()
n = int(n)
income = [int(x) for x in input().split()]
day = []
i = 0
if n >= 2:
	while i <= n - 1:
		lasting = 0
		for j in range(i, n - 1):
			if income[j] <= income[j + 1]:
				lasting = lasting + 1
			else:
				i = j + 1
				break
		day.append(lasting + 1)
		if j == n - 2:
			break
	print(max(day))
else:
	print(1)


a = int(input())
lista = [int(i) for i in input().split()]
count = 0
countM = 0
condicion = 0
i = 0
while i < a:
	if count == 0:
		if i != 0:
			i -= 1
		count += 1
	else:
		ant = lista[i - 1]
		atual = lista[i]
		if ant <= atual:
			count += 1
		elif count > countM:
			countM = count
			count = 0
			condicion = 1
		else:
			count = 0
	i += 1
if count > countM:
	countM = count
if condicion == 0:
	countM = count
print(countM)


n = int(input())
coins = [int(i) for i in input().split()]
dp = [0] * n
dp[0] = 1
max = 1
for i in range(1, n):
	if coins[i] >= coins[i - 1]:
		dp[i] = dp[i - 1] + 1
	else:
		dp[i] = 1
	if dp[i] > max:
		max = dp[i]
print(max)


n = int(input())
seq = [int(c) for c in input().split()]
ans = cnt = 1
for i in range(1, n):
	if seq[i] >= seq[i - 1]:
		cnt += 1
	else:
		cnt = 1
	ans = max(ans, cnt)
print(ans)


n = int(input())
num = input().split()
for i in range(n):
	num[i] = int(num[i])
f = [1] * n
for i in range(1, n):
	if num[i] >= num[i - 1]:
		f[i] = f[i - 1] + 1
ans = 0
for i in range(n):
	if f[i] > ans:
		ans = f[i]
print(ans)


from sys import stdin, stdout
n = int(stdin.readline())
lis = list(map(int, stdin.readline().split()))
length = [0] * n
length[0] = 1
for i in range(len(lis) - 1):
	if lis[i] <= lis[i + 1]:
		length[i + 1] = length[i] + 1
	else:
		length[i + 1] = 1
stdout.write(str(max(length)) + '\n')


n = int(input())
b = list(map(int, input().split()))
counter = 0
maximum = 0
for i in range(len(b) - 1):
	if b[i] <= b[i + 1]:
		counter += 1
		if counter > maximum:
			maximum += 1
	else:
		counter = 0
print(maximum + 1)


n = int(input())
l = [int(i) for i in input().split(' ')]
result = 1
ans = 1
for i in range(n - 1):
	if l[i] <= l[i + 1]:
		ans += 1
	else:
		result = max(result, ans)
		ans = 1
result = max(result, ans)
print(result)


n = int(input())
al = list(map(int, input().split()))
(res, t) = (0, 0)
last = -1
for i in al:
	if i >= last:
		t += 1
	else:
		res = max(t, res)
		t = 1
	last = i
print(max(t, res))


__author__ = 'kolya'
n = int(input())
m = [int(i) for i in input().split()]
counter = 1
max = 1
f = m[0]
for i in range(1, n):
	if m[i] >= f:
		counter += 1
	else:
		if counter > max:
			max = counter
		counter = 1
	f = m[i]
if counter > max:
	max = counter
print(max)


n = int(input())
p = [int(x) for x in input().split()]
array = []
hasil = 1
temp = p[0]
if len(p) > 1:
	for i in range(1, len(p)):
		if p[i] >= temp:
			hasil += 1
			temp = p[i]
		if p[i] < temp or i == len(p) - 1:
			array += [hasil]
			hasil = 1
			temp = p[i]
else:
	array = [1]
print(max(array))


def nondecresingsubseq(l):
	if len(l) == 1:
		return 1
	(maximum, c) = (0, 0)
	(i, j) = (1, 0)
	while i < len(l):
		c = 0
		while i < len(l) and l[j] <= l[i]:
			c += 1
			i += 1
			j += 1
		maximum = max(c + 1, maximum)
		i += 1
		j += 1
	return maximum
n = int(input())
l = list(map(int, input().split()))
print(nondecresingsubseq(l))


n = int(input())
s = list(map(int, input().split()))
count = 1
list_max = []
list_max.append(count)
for num in range(n - 1):
	if s[num] <= s[num + 1]:
		count += 1
		list_max.append(count)
	else:
		count = 1
print(max(list_max))


n = int(input())
A = list(map(int, input().split()))
answer = 0
num = 1
for i in range(1, n):
	if A[i] >= A[i - 1]:
		num += 1
	else:
		if num > answer:
			answer = num
		num = 1
if num > answer:
	answer = num
print(answer)


n = int(input())
a = [int(i) for i in input().split()]
s = 1
k = 0
d = 1
while k < n - 1:
	if a[k] <= a[k + 1]:
		s += 1
		d = max(d, s)
	else:
		s = 1
	k += 1
print(d)


n = int(input())
A = list(map(int, input().split()))
if n == 1:
	print(1)
else:
	B = []
	for i in range(n - 1):
		B.insert(i, 0)
	x = 0
	i = 0
	while i < n - 1:
		j = 0
		if i + j + 1 > n - 1:
			break
		while A[i + j + 1] + 1 > A[i + j]:
			j += 1
			if i + j > n - 2:
				break
		B[i] = j
		if x < B[i]:
			x = B[i]
		i += j
		i += 1
	print(x + 1)


n = int(input())
a = [int(i) for i in input().split()]
curr_len = 0
curr_no = a[0]
max_len = 1
for i in a:
	if curr_no > i:
		max_len = max(max_len, curr_len)
		curr_len = 1
	else:
		curr_len += 1
	curr_no = i
max_len = max(max_len, curr_len)
print(max_len)


n = int(input())
arr = [int(i) for i in input().split()]
length = 1
maxLength = 1
for i in range(1, len(arr)):
	if arr[i] >= arr[i - 1]:
		length += 1
	else:
		length = 1
	if length > maxLength:
		maxLength = length
print(maxLength)


n = int(input())
s = list(map(int, input().split()))
j = 1
z = 0
for i in range(n - 1):
	if s[i + 1] >= s[i]:
		j += 1
	else:
		z = max(z, j)
		j = 1
z = max(z, j)
print(z)


def lenOfLongIncSubArr(arr, n):
	m = 1
	l = 1
	for i in range(1, n):
		if arr[i] >= arr[i - 1]:
			l += 1
		else:
			if m < l:
				m = l
			l = 1
	if m < l:
		m = l
	return m
arr_size = int(input())
arr = list(map(int, input().split()))
res = lenOfLongIncSubArr(arr, arr_size)
print(res)


n = int(input())
l = list(map(int, input().split()))
c = o = s = 0
for i in l:
	c = c + 1 if i >= s else 1
	o = max(o, c)
	s = i
print(o)


n = int(input())
a = input().split()
for i in range(n):
	a[i] = int(a[i])
sm = 0
st = 0
for i in range(n - 1):
	if a[i] > a[i + 1]:
		if st > sm:
			sm = st
		st = 0
	else:
		st += 1
if st > sm:
	print(st + 1)
else:
	print(sm + 1)


n = int(input())
a = list(map(int, input().split()))
answer = 1
temp = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		temp += 1
	else:
		if temp > answer:
			answer = temp
		temp = 1
if temp > answer:
	answer = temp
print(answer)


n = int(input())
r = list(map(int, input().split()))
k = 1
res = 1
for i in range(n - 1):
	if r[i] <= r[i + 1]:
		k += 1
	else:
		res = max(res, k)
		k = 1
	if i == n - 2:
		res = max(res, k)
		k = 1
print(res)


n = int(input())
a = list(map(int, input().split()))
Max = 1
cnt = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		cnt += 1
	else:
		cnt = 1
	Max = max(cnt, Max)
print(Max)


n = int(input())
lt = list(map(int, input().split()))
d = 1
mx = 1
for i in range(n - 1):
	if lt[i] <= lt[i + 1]:
		d += 1
	else:
		d = 1
	if d > mx:
		mx = d
print(mx)


n = int(input())
temp = input().split()
a = []
for i in range(n):
	a.append(int(temp[i]))
(max_length, length) = (1, 1)
for i in range(1, n):
	if a[i] < a[i - 1]:
		length = 1
	else:
		length += 1
	if max_length < length:
		max_length = length
print(max_length)


_ = input()
seq = list(map(int, input().split()))
l = 1
max_l = 1
for i in range(1, len(seq)):
	if seq[i] >= seq[i - 1]:
		l += 1
	else:
		max_l = max(max_l, l)
		l = 1
max_l = max(max_l, l)
print(max_l)


n = int(input())
a = input().split()
max = list(range(0, n))
for i in range(0, n):
	a[i] = int(a[i])
	max[i] = 1
j = 0
for i in range(1, n):
	if a[i] >= a[i - 1]:
		max[j] += 1
	else:
		j += 1
maxi = max[0]
for i in max:
	if i > maxi:
		maxi = i
print(maxi)


n = int(input())
line = input().split()
ans = 0
last = 0
curr_streak = 0
for char_num in line:
	num = int(char_num)
	if num >= last:
		curr_streak += 1
	else:
		if curr_streak >= ans:
			ans = curr_streak
		curr_streak = 1
	last = num
if curr_streak >= ans:
	ans = curr_streak
print(ans)


n = int(input())
a = [int(x) for x in input().split(' ')]
maxx = 1
cnt = 1
for i in range(0, len(a) - 1):
	if a[i + 1] >= a[i]:
		cnt += 1
	else:
		cnt = 1
	if cnt > maxx:
		maxx = cnt
print(maxx)


n = int(input())
a = input().split(' ')
c = 0
j = 0
count = 0
for i in range(0, n):
	if int(a[i]) >= count:
		c = c + 1
	else:
		c = 1
	if c > j:
		j = c
	count = int(a[i])
print(j)


n = int(input())
a = list(map(int, input().split()))
s = 1
t = [1]
for i in range(len(a) - 1):
	if a[i] <= a[i + 1]:
		s += 1
		t.append(s)
	elif a[i] > a[i + 1]:
		s = 1
print(max(t))


n = int(input())
data = [int(x) for x in input().split()]
ans = [0] * n
ans[0] = 1
max = 1
for q in range(1, n):
	if data[q] >= data[q - 1]:
		ans[q] = ans[q - 1] + 1
		if ans[q] > max:
			max = ans[q]
	else:
		ans[q] = 1
print(max)


a = int(input())
b = list(map(int, input().split()))
k = []
g = 1
for t in range(a - 1):
	if b[t + 1] >= b[t]:
		g += 1
		k.append(g)
	else:
		g = 1
else:
	k.append(1)
print(max(k))


m = int(input())
a = [int(i) for i in input().split()]
b = []
d = 0
e = 0
for i in a:
	if e > i:
		b.append(d)
		d = 0
	d += 1
	e = i
b.append(d)
print(max(b))


n = int(input())
s = input()
max1 = 0
maxc = 1
mynums = [int(i) for i in s.split()]
my = [1]
for i in range(1, len(mynums)):
	if mynums[i] >= mynums[i - 1]:
		my.append(my[len(my) - 1] + 1)
	else:
		my.append(1)
print(max(my))


j = 1
b = []
c = int(input())
a = list(map(int, input().split()))
i = 0
if len(a) == c:
	if len(a) == 1:
		print('1')
	else:
		while i < len(a) - 1:
			if a[i] <= a[i + 1]:
				j = j + 1
			elif a[i] > a[i + 1]:
				j = 1
			b.append(j)
			i = i + 1
		print(max(b))


n = int(input())
a = []
a = [int(x) for x in input().split()]
c = 1
max1 = 0
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		c = c + 1
	else:
		if c > max1:
			max1 = c
		c = 1
if c > max1:
	max1 = c
print(max1)


n = int(input())
c = 1
maxi = 0
l = [int(i) for i in input().split()]
for i in range(1, n):
	if l[i] >= l[i - 1]:
		c += 1
	else:
		maxi = max(maxi, c)
		c = 1
maxi = max(maxi, c)
print(maxi)


n = int(input())
a = list(map(int, input().split()))
m = 1
t = 1
cur = a[0]
for i in range(1, n):
	if cur > a[i]:
		t = 1
	else:
		t += 1
		m = max(m, t)
	cur = a[i]
print(m)


n = int(input())
arr = list(map(int, input().split()))
length = len(arr)
mx = 0
prev = 0
cnt = 0
for i in range(length):
	if arr[i] >= prev:
		cnt += 1
	else:
		cnt = 1
	if cnt > mx:
		mx = cnt
	prev = arr[i]
print(mx)


input()
y = input()
m = 0
curr = 0
y = list(map(int, y.split()))
for i in range(len(y) - 1):
	if y[i] <= y[i + 1]:
		curr += 1
		m = max(curr, m)
	else:
		curr = 0
print(m + 1)


n = int(input())
a = list(map(int, input().split()))
i = 0
count = []
temp = 0
while i < n - 1:
	if a[i + 1] >= a[i]:
		temp += 1
	else:
		count.append(temp)
		temp = 0
	i += 1
	if i == n - 1:
		count.append(temp)
if temp >= 0 and len(count) == 0:
	print(temp + 1)
elif len(count) > 0:
	print(max(count) + 1)
else:
	print(0)


a = int(input())
b = [int(x) for x in input().split()]
max = 1
y = b[0]
l = 1
for x in b[1:]:
	if x >= y:
		l += 1
		if l > max:
			max = l
	else:
		l = 1
	y = x
print(max)


n = int(input())
l = [int(n) for n in input().split()]
(a, c, d) = (0, 0, 0)
for b in l:
	if b >= a:
		c += 1
	if c > d:
		d = c
	if b < a:
		c = 1
	a = b
print(d)


input()
rem = m = counter = 0
for i in map(int, input().split()):
	rem = [rem + 1, 1][i < counter]
	m = max(m, rem)
	counter = i
print(m)


n = int(input())
a = list(map(int, input().rstrip().split()))
count = 1
i = 0
b = [0, 1]
while i < n - 1:
	if a[i] <= a[i + 1]:
		count += 1
		i = i + 1
		b.append(count)
	else:
		count = 1
		i = i + 1
print(max(b))


n = int(input())
max = -1
count = 0
lastdigit = 0
for i in list(map(int, input().split())):
	if i >= lastdigit:
		count += 1
		if count > max:
			max = count
	else:
		count = 1
	lastdigit = i
print(max)


n = int(input())
data = [int(i) for i in input().split(' ')]
row = 0
maxRow = 0
num = 0
for i in data:
	if i >= num:
		row += 1
		maxRow = max(maxRow, row)
	else:
		row = 1
	num = i
print(maxRow)


m = int(input())
l = list(map(int, input().split()))
f = 0
u = 0
for i in range(len(l) - 1):
	if l[i] <= l[i + 1]:
		f = f + 1
		if f > u:
			u = f
	else:
		f = 0
print(u + 1)


n = int(input())
d = input().split()
data = []
i = 0
while i < n - 1:
	data1 = [d[i]]
	for j in range(i, n - 1):
		if int(d[j]) <= int(d[j + 1]):
			data1 += [d[j + 1]]
			i += 1
		else:
			i += 1
			break
	if len(data1) > 1:
		data += [data1]
for i in range(len(data) - 1):
	for j in range(i + 1, len(data)):
		if len(data[i]) < len(data[j]):
			temp = data[i]
			data[i] = data[j]
			data[j] = temp
if len(data) == 0:
	print('1')
else:
	print(len(data[0]))


n = int(input())
x = input()
x = x.split()
c = 1
t = 0
for i in range(n):
	x[i] = int(x[i])
for i in range(1, n):
	if x[i] >= x[i - 1]:
		c += 1
	else:
		t = max(t, c)
		c = 1
t = max(t, c)
print(t)


n = int(input())
x = [int(y) for y in input().split()]
len = 1
l = []
for i in range(n - 1):
	if x[i] <= x[i + 1]:
		len += 1
	else:
		l.append(len)
		len = 1
l.append(len)
print(max(l))


size = int(input())
work = list(map(int, input().split()))
(sequence, best, prev) = (0, 0, work[0])
for i in work:
	if i >= prev:
		sequence += 1
	else:
		sequence = 1
	best = max(best, sequence)
	prev = i
print(best)


n = int(input())
m = input()
x = y = z = 0
for i in m.split():
	i = int(i)
	if i >= y:
		x += 1
		z = max(x, z)
		y = i
	else:
		x = 1
		z = max(z, x)
		y = i
print(z)


import math
n = int(input())
a = list(map(int, input().split()))
ans = -math.inf
tmp = 1
for i in range(1, n):
	if a[i - 1] <= a[i]:
		tmp += 1
	else:
		ans = max(ans, tmp)
		tmp = 1
print(max(ans, tmp))


n = int(input())
d = 1
t = 1
a = [int(i) for i in input().split()]
for i in range(n - 1):
	if a[i + 1] >= a[i]:
		t += 1
		if t > d:
			d = t
	else:
		if t > d:
			d = t
		t = 1
print(d)


num = int(input())
money = [int(i) for i in input().split(' ')]
max_seq = 1
aux = 1
for i in range(1, num):
	if money[i] >= money[i - 1]:
		aux += 1
		if max_seq < aux:
			max_seq = aux
	else:
		aux = 1
print(max_seq)


n = int(input())
a = input()
a = a.split(' ')
if n > 1:
	num = set()
	count = 1
	for i in range(n - 1):
		if int(a[i]) <= int(a[i + 1]):
			count = count + 1
			num.add(count)
		else:
			num.add(count)
			count = 1
	print(max(num))
else:
	print('1')


a = int(input())
b = list(map(int, input().split()))
last = 0
count_max = 0
count = 0
for i in b:
	if i >= last:
		count += 1
		if count_max < count:
			count_max = count
	else:
		count = 1
	last = i
print(count_max)


n = int(input())
arr = list(map(int, input().split()))
count = 0
new = []
if len(arr) != 1:
	for i in range(len(arr) - 1):
		if arr[i] <= arr[i + 1]:
			count += 1
			new.append(count)
		else:
			count = 0
			pass
	if new != []:
		print(max(new) + 1)
	elif new == []:
		print(1)
elif len(arr) == 1:
	print(1)


n = int(input())
a = list(map(int, input().split()))
cnt = 0
prev = 0
grtcnt = 0
for i in a:
	if i >= prev:
		cnt += 1
		prev = i
		if grtcnt < cnt:
			grtcnt = cnt
	else:
		cnt = 1
		prev = i
print(grtcnt)


n = input()
sequence = list(map(int, input().split()))
last_element = -1
improving = 0
max_improving = 0
for element in sequence:
	if element >= last_element:
		improving += 1
	else:
		if max_improving < improving:
			max_improving = improving
		improving = 1
	last_element = element
if max_improving < improving:
	max_improving = improving
print(max_improving)


n = int(input())
f = list(map(int, input().split()))
k = 1
m = 1
for i in range(1, n):
	if f[i] >= f[i - 1]:
		k += 1
	else:
		m = max(m, k)
		k = 1
m = max(m, k)
print(m)


n = int(input())
numbers = input().split()
count = 1
temp = numbers[0]
maxcount = []
if n == 1:
	print('1')
else:
	for i in range(1, n):
		if int(numbers[i]) >= int(temp):
			count += 1
			if i == n - 1:
				maxcount.append(count)
		else:
			maxcount.append(count)
			count = 1
		temp = numbers[i]
	print(max(maxcount))


def solve():
	n = int(input())
	d = input().split(' ')
	if len(d) <= 1:
		print(len(d))
		return
	data = []
	ndc = [1]
	for i in d:
		r = int(i)
		data.append(r)
	for i in range(1, len(d)):
		t = 1
		if data[i] >= data[i - 1]:
			t = ndc[i - 1] + 1
		ndc.append(t)
	print(max(ndc))
solve()


n = int(input())
a = [0] + [int(s) for s in input().split()]
dp = [0] * (n + 2)
for i in range(1, n + 1):
	if a[i] >= a[i - 1]:
		dp[i] = dp[i - 1] + 1
	else:
		dp[i] = 1
print(max(dp))


t = int(input())
values = list(map(lambda x: int(x), input().split(' ')))
max_seq = 0
current = 0
last_num = -1
for i in range(t):
	if values[i] >= last_num:
		current += 1
		last_num = values[i]
		if current > max_seq:
			max_seq = current
	else:
		current = 1
		last_num = values[i]
print(max_seq)


n = int(input())
l = list(map(int, input().split()))
k = 1
mx = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		k += 1
	else:
		k = 1
	if mx < k:
		mx = k
print(mx)


n = int(input())
max = 0
count = 0
tmp1 = 0
a = input().split(' ')
for i in a:
	tmp = int(i)
	if tmp >= tmp1:
		count += 1
	else:
		max = count if max < count else max
		count = 1
	tmp1 = tmp
max = count if max < count else max
print(max)


b = int(input())
s = input()
n = [int(s) for s in s.split()]
ma = 0
f = 1
for i in range(1, b):
	if n[i] >= n[i - 1]:
		f += 1
	else:
		if f > ma:
			ma = f
		f = 1
if f > ma:
	ma = f
print(ma)


w = int(input())
j = 1
m = list(map(int, input().split()))
n = [1] * w
for i in range(w - 1):
	if m[i + 1] >= m[i]:
		n[i + 1] = n[i] + 1
print(max(n))


f = int(input())
series = list(map(int, input().split()))
n = 0
m = 1
for i in range(len(series) - 1):
	if series[i] <= series[i + 1]:
		m += 1
		n = max(m, n)
	else:
		n = max(m, n)
		m = 1
if len(series) == 1:
	n = 1
print(n)


n = int(input())
A = [int(x) for x in input().split(' ')]
maxq = 0
for i in range(n):
	if i == 0:
		m = A[i]
		q = 1
		continue
	if A[i] < m:
		if q > maxq:
			maxq = q
		q = 1
	else:
		q += 1
	m = A[i]
if q > maxq:
	maxq = q
print(maxq)


t = int(input())
ls1 = list(map(int, input().split(' ')))
c = 0
ls2 = []
for i in range(len(ls1) - 1):
	if ls1[i] > ls1[i + 1]:
		ls2.append(c)
		c = 0
	else:
		c += 1
ls2.append(c)
print(max(ls2) + 1)


l = int(input())
x = list(map(int, input().split()))
ll = 1
s = 1
for i in range(1, l):
	if x[i - 1] <= x[i]:
		s = s + 1
	else:
		s = 1
	ll = max(ll, s)
print(ll)


x = int(input())
y = [int(a) for a in input().split()]
step = maximum = 0
for i in range(x - 1):
	if y[i] <= y[i + 1]:
		step += 1
	else:
		step = 0
	maximum = max(maximum, step)
print(maximum + 1)


n = int(input())
a = list(map(int, input().split()))
max_range_count = 0
tmp_count = 1
last_int = a[0]
for i in range(1, n):
	if last_int <= a[i]:
		tmp_count += 1
	else:
		max_range_count = max(max_range_count, tmp_count)
		tmp_count = 1
	last_int = a[i]
max_range_count = max(max_range_count, tmp_count)
print(max_range_count)


n = int(input())
arr = list(map(int, input().split()))
if n == 1:
	print(1)
	exit()
i = 0
j = 1
mm = 0
while i < n and j < n:
	if arr[j] >= arr[j - 1]:
		j += 1
	else:
		mm = max(mm, j - i)
		i = j
		j += 1
mm = max(mm, j - i)
print(mm)


n = int(input())
a = list(map(int, input().split()))
ma = 1
mac = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		mac += 1
	else:
		if mac > ma:
			ma = mac
		mac = 1
print(max(mac, ma))


n = int(input())
l = [int(i) for i in input().split()]
(c, k, o) = (0, 0, 0)
for i in l:
	if i >= c:
		c = i
		k = k + 1
	else:
		c = i
		if k > o:
			o = k
		k = 1
else:
	if k > o:
		o = k
print(o)


n = int(input())
a = list(map(int, input().split()))
if len(a) < 2:
	print(1)
else:
	x = z = 1
	for i in range(1, len(a)):
		if a[i] < a[i - 1]:
			x = 1
		else:
			x += 1
			z = max(z, x)
	print(z)


n = int(input())
a = input().split()
if n == 1:
	print('1')
else:
	for i in range(n - 1):
		if int(a[i]) > int(a[i + 1]):
			a[i] = a[i] + '+'
		a[i] = a[i] + '-'
	b = ''.join(a)
	c = b.split('+')
	for i in range(len(c)):
		c[i] = c[i].split('-')
	ma = len(c[0])
	for i in range(1, len(c)):
		ma = max(ma, len(c[i]) - 1)
	print(ma)


n = int(input())
a = list(map(int, input().split()))
(m, curl) = (1, 1)
for i in range(1, n):
	if a[i - 1] <= a[i]:
		curl += 1
	else:
		if curl > m:
			m = curl
		curl = 1
if curl > m:
	m = curl
print(m)


input()
(max_seq, cur_seq, prev_el) = (1, 1, None)
for el in map(int, input().split()):
	cur_seq = cur_seq + 1 if prev_el and el >= prev_el else 1
	prev_el = el
	max_seq = max(max_seq, cur_seq)
print(max_seq)


n = int(input())
A = input()
B = []
for i in A.split():
	B.append(int(i))
a = 0
b = 0
for j in range(0, n - 1):
	if B[j] <= B[j + 1]:
		a = a + 1
		if a > b:
			b = a
	else:
		a = 0
print(b + 1)


n = input()
array = input()
a = array.split(' ')
coins = list(map(int, a))
m = 1
step = 1
for i in range(1, int(n)):
	if coins[i] >= coins[i - 1]:
		step += 1
	else:
		m = max(m, step)
		step = 1
print(max(m, step))


n = input()
nn = input().split(' ')
maxs = []
i = 0
M = 1
while i + 1 < len(nn):
	if int(nn[i + 1]) >= int(nn[i]):
		M += 1
	elif M != 1:
		maxs.append(M)
		M = 1
	i += 1
maxs.append(M)
print(sorted(maxs, reverse=True)[0])


num = input()
n = input().split(' ')
numbers = list(map(int, n))
ans = 1
max = 1
for i in range(1, len(numbers)):
	if numbers[i] >= numbers[i - 1]:
		ans += 1
		if ans > max:
			max = ans
	else:
		ans = 1
print(max)


n = int(input())
seg = list(map(int, input().split()))
subseg = []
ctr = 0
for i in range(len(seg) - 1):
	ctr = (ctr + 1, 0)[seg[i + 1] < seg[i]]
	subseg.append(ctr)
print(max(subseg) + 1 if subseg else 1)


n = int(input())
numbers = [int(i) for i in input().split(' ')]
max_count = -1
previous = 10000000000000000000
temp_count = 0
for i in numbers:
	if i >= previous:
		temp_count += 1
	else:
		temp_count = 1
	if temp_count > max_count:
		max_count = temp_count
	previous = i
print(max_count)


n = int(input())
vetor = [int(c) for c in input().split()]
last = vetor[0]
currentCount = 1
maxCount = 1
for i in range(1, n):
	elem = vetor[i]
	if elem < last:
		currentCount = 1
	else:
		currentCount += 1
		maxCount = max(maxCount, currentCount)
	last = elem
print(maxCount)


input()
a = list(map(int, input().split()))
max_s = 0
curr = 0
last = 0
for i in a:
	if i >= last:
		curr += 1
		if curr > max_s:
			max_s = curr
	else:
		curr = 1
	last = i
print(max_s)


def length_of_maximum(sequence):
	lengths = []
	current_length = 1
	next_position = 0
	while True:
		next_position += 1
		if next_position == len(sequence):
			lengths.append(current_length)
			break
		elif int(sequence[next_position - 1]) <= int(sequence[next_position]):
			current_length += 1
		else:
			lengths.append(current_length)
			current_length = 1
	return max(lengths)
shit_input = input()
t1 = input()
print(length_of_maximum(t1.split(' ')))


rg = int(input())
ls = list(map(int, input().split()))
ls1 = []
c = 1
for x in range(1, len(ls)):
	if ls[x] >= ls[x - 1]:
		c += 1
	else:
		ls1.append(c)
		c = 1
ls1.append(c)
ls1.sort(reverse=True)
if len(ls1) == 0:
	print(c)
else:
	print(ls1[0])


def list_input():
	return list(map(int, input().split()))

def multiple_input():
	return map(int, input().split())
n = int(input())
a = list_input()
(cur, m) = (1, 1)
for i in range(1, n):
	if a[i] >= a[i - 1]:
		cur += 1
	else:
		m = max(m, cur)
		cur = 1
m = max(cur, m)
print(m)


n = int(input())
c = 1
count = 1
a = [int(i) for i in input().strip().split()]
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		count += 1
	else:
		count = 1
	c = max(c, count)
print(c)


n = int(input())
s = list(map(int, input().split()))
m = -1
x = 0
for i in range(1, n):
	if s[i] >= s[i - 1]:
		if x == 0:
			x += 2
		else:
			x += 1
	else:
		x = 0
	m = max(m, x)
if m == -1 or m == 0:
	print(1)
else:
	print(m)


i = input
i()
m = s = c = 0
for i in i().split():
	i = int(i)
	c = c + 1 if i >= s else 1
	m = max(m, c)
	s = i
print(m)


n = int(input())
Line = [int(i) for i in input().split()]
m = len(Line)
k = 1
p = 1
if m == 1:
	print(1)
else:
	for i in range(1, m):
		if Line[i] >= Line[i - 1]:
			p += 1
			k = max(k, p)
		else:
			p = 1
	print(k)


n = int(input())
l = list(map(int, input().split()))
count = 1
mxlen = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		count += 1
	else:
		if mxlen < count:
			mxlen = count
		count = 1
if mxlen < count:
	mxlen = count
print(mxlen)


n = int(input())
arr = list(map(int, input().split()))
c = s = 0
max_count = 0
for i in arr:
	if i >= s:
		c += 1
	else:
		c = 1
	max_count = max(max_count, c)
	s = i
print(max_count)


n = int(input())
arr = [int(x) for x in input().split()] + [-1]
max_len = 1
current_len = 1
for i in range(1, n + 1):
	if arr[i] >= arr[i - 1]:
		current_len += 1
	else:
		max_len = max(current_len, max_len)
		current_len = 1
print(max_len)


x = int(input())
i = 0
c = 0
array = list(map(int, input().split()))
max1 = c
while i < x:
	if i == x - 1:
		break
	if array[i] <= array[i + 1]:
		c += 1
	else:
		max1 = max(c + 1, max1)
		c = 0
	i += 1
max1 = max(c + 1, max1)
print(max1)


import math as mt
import sys, string, bisect
input = sys.stdin.readline
import random
from collections import deque, defaultdict
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
d = defaultdict(int)
n = I()
l = L()
c = 1
m = c
if n > 1:
	for i in range(1, n):
		if l[i] >= l[i - 1]:
			c += 1
			m = max(m, c)
		else:
			m = max(m, c)
			c = 1
print(m)


n = int(input())
thing = input()
stringList = thing.split(' ')
moneyList = []
for term in stringList:
	moneyList += [int(term)]
currentStreak = 1
maxStreak = 1
for day in range(1, n):
	if moneyList[day] >= moneyList[day - 1]:
		currentStreak += 1
		if maxStreak < currentStreak:
			maxStreak = currentStreak
	else:
		currentStreak = 1
print(maxStreak)


n = int(input())
lista_n = list(map(int, input().split()))
lista_len = []
length = 1
for x in range(1, len(lista_n)):
	if lista_n[x] >= lista_n[x - 1]:
		length += 1
	else:
		lista_len.append(length)
		length = 1
lista_len.append(length)
print(max(lista_len))


n = int(input())
d = list(map(int, input().strip().split()[:n]))
count = 1
k = 0
b = False
for x in range(n):
	if x != n - 1:
		if d[x] <= d[x + 1]:
			count += 1
			if count > k:
				k = count
			b = True
		else:
			count = 1
if b == True:
	print(k)
else:
	print(count)


n = int(input())
a = [*map(int, input().split())]
s = m = 1
for (i, j) in zip(a, a[1:]):
	s = [s + 1, 1][j < i]
	m = max(m, s)
print(m)


N = int(input())
L = list(map(int, input().split()))
overall = 1
inner = 1
for i in range(0, N - 1):
	if L[i] <= L[i + 1]:
		inner += 1
		if i == N - 2:
			if overall < inner:
				overall = inner
	else:
		if inner > overall:
			overall = inner
		inner = 1
print(overall)


n = int(input())
a = [int(x) for x in input().split()]
s = 1
ms = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		s += 1
		ms = max(s, ms)
	else:
		ms = max(ms, s)
		s = 1
print(ms)


n = int(input())
s = [int(x) for x in input().split()]
b = [1] * n
num = s[0]
for i in range(1, n):
	if s[i] >= num:
		b[i] = b[i - 1] + 1
	num = s[i]
b.sort()
print(b[-1])


size = int(input())
string_array = input()
The_array = string_array.split()
count = 1
b = 1
for i in range(size):
	The_array[i] = int(The_array[i])
for i in range(1, size):
	if The_array[i] >= The_array[i - 1]:
		count += 1
		if count > b:
			b = count
	else:
		count = 1
print(b)


a = int(input())
t = []
m = []
n = input().split(' ')
for i in range(a):
	t.append(int(n[i]))
b = 1
for i in range(a - 1):
	if t[i] <= t[i + 1]:
		b = b + 1
	else:
		m.append(b)
		b = 1
m.append(b)
print(max(m))


import math
n = int(input())
arr = list(map(int, input().split()))
result = 1
temp = 1
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		temp += 1
		if temp > result:
			result = temp
	else:
		temp = 1
print(result)


n = int(input())
an = [int(x) for x in input().split()]
output = i = 0
while i < n:
	count = 1
	for j in range(i + 1, n):
		if an[j] >= an[j - 1]:
			count += 1
		else:
			break
	i += count
	output = max(output, count)
print(output)


d = []
e = []
d.append(0)
n = int(input())
x = [int(x) for x in input().split()]
for i in range(n - 1):
	if x[i] <= x[i + 1]:
		continue
	else:
		d.append(i + 1)
d.append(n)
for i in range(len(d) - 1):
	e.append(d[i + 1] - d[i])
print(max(e))


x = int(input())
t = 1
m = []
s = input().split()
if x == 1:
	m.append(t)
else:
	for i in range(1, x):
		if int(s[i]) >= int(s[i - 1]):
			t = t + 1
			m.append(t)
		else:
			m.append(t)
			t = 1
print(max(m))


import sys
n = int(input())
inputs = sys.stdin.readline().split()
a = [int(x) for x in inputs]
l = 1
m = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		l = l + 1
	else:
		if m < l:
			m = l
		l = 1
if m < l:
	m = l
print(m)


n = int(input())
maxCount = 1
count = 1
profits = list(map(int, input().split(' ')))[:n]
for i in range(n):
	if i > 0:
		if profits[i] >= profits[i - 1]:
			count += 1
			maxCount = max(maxCount, count)
		else:
			count = 1
print(maxCount)


n = int(input())
ar = [1] * n
lis = list(map(int, input().split()))
for i in range(1, n):
	if lis[i - 1] <= lis[i]:
		ar[i] = ar[i - 1] + 1
	else:
		ar[i] = 1
print(max(ar))


length = int(input())
sequence = list(map(int, input().split(' ')))
maxSequence = increasing = lastElement = 0
for i in range(length):
	if sequence[i] >= lastElement:
		increasing += 1
	else:
		maxSequence = max(maxSequence, increasing)
		increasing = 1
	lastElement = sequence[i]
maxSequence = max(maxSequence, increasing)
print(maxSequence)


try:
	k = int(input())
	p = list(map(int, input().split()))
	a = b = c = 0
	for i in p:
		c = c + 1 if i >= b else 1
		a = max(a, c)
		b = i
	print(a)
except:
	pass


n = int(input())
a = [int(e) for e in input().split(' ')]
(l, ans) = (1, 1)
for i in range(1, n):
	if a[i] >= a[i - 1]:
		l += 1
		ans = max(ans, l)
	else:
		l = 1
print(ans)


input()
lista = list(map(int, input().split()))
counter = max_counter = last = 0
for i in lista:
	if i >= last:
		counter += 1
	else:
		counter = 1
	max_counter = max(max_counter, counter)
	last = i
print(max_counter)


num = int(input())
arr = list(map(int, input().split()))
count = 1
mx = 1
for t in range(1, num):
	if arr[t] >= arr[t - 1]:
		count += 1
	else:
		count = 1
	mx = max(count, mx)
print(mx)


n = int(input())
list_a = list(map(int, input().split()))
m = 0
count = 1
list_count = []
if len(list_a) == 1:
	print(1)
else:
	while m <= n - 2:
		if list_a[m] <= list_a[m + 1]:
			count += 1
		else:
			list_count.append(count)
			count = 1
		m += 1
		list_count.append(count)
	print(max(list_count))


n = int(input())
L = [int(s) for s in input().split()]

def subseg(l):
	if l == []:
		return 0
	if len(l) == 1:
		return 1
	Length = [1 for i in range(len(l))]
	for i in range(1, len(l)):
		Length[i] = (l[i] >= l[i - 1]) * Length[i - 1] + 1
	return max(Length)
print(subseg(L))


n = int(input())
l = [int(x) for x in input().split()]
L = [1]
k = 1
for i in range(n - 1):
	if i < n - 2:
		if l[i] <= l[i + 1]:
			k = k + 1
		else:
			L.append(k)
			k = 1
	elif l[i] <= l[i + 1]:
		k = k + 1
		L.append(k)
	else:
		L.append(k)
		L.append(1)
print(max(L))


n = int(input())
nums = [int(i) for i in input().split()]
arrlen = len(nums)
max = 1
templen = 1
for i in range(1, arrlen):
	if nums[i] >= nums[i - 1]:
		templen += 1
	else:
		if max < templen:
			max = templen
		templen = 1
if max < templen:
	max = templen
print(max)


n = input()
l = list(map(int, input().split()))
mx = 0
count = 1
for i in range(len(l)):
	if i + 1 < len(l) and l[i] <= l[i + 1]:
		count += 1
	else:
		if mx < count:
			mx = count
		count = 1
print(mx)


n = int(input())
a = [int(x) for x in input().split(' ')]
Max = 1
k = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		k += 1
	else:
		if k > Max:
			Max = k
		k = 1
if k > Max:
	Max = k
print(Max)


n = int(input())
s = input()
s = s.split()
s = list(map(int, s))
cnt = 1
ans = 0
pre = s[0]
for i in s[1:]:
	if i >= pre:
		cnt = cnt + 1
	else:
		ans = max(ans, cnt)
		cnt = 1
	pre = i
ans = max(ans, cnt)
print(ans)


n = int(input())
a = list(map(int, input().split()))
ans = 1
count = 1
for i in range(0, n - 1):
	if a[i + 1] >= a[i]:
		count += 1
	if count > ans:
		ans = count
	if a[i + 1] < a[i]:
		count = 1
print(ans)


import unittest
from random import randint
from sys import maxsize

class StressTest(unittest.TestCase):
	known_values = (([2, 2, 1, 3, 4, 1], 3), ([2, 2, 9], 3), ([8], 1))

	def test_known_cases(self):
		for (A, expected) in self.known_values:
			self.assertEqual(expected, NaiveSolution().kefa(A))

	def test_all_cases(self):
		while True:
			break

class NaiveSolution:

	def kefa(self, A):
		count = 1
		max_val = -maxsize
		for i in range(len(A)):
			if i + 1 < len(A) and A[i] <= A[i + 1]:
				count += 1
			else:
				count = 1
			max_val = max(max_val, count)
		return max_val

class BestSolution:
	pass
n = int(input())
A = [int(x) for x in input().strip().split()]
ans = NaiveSolution().kefa(A)
print(ans)


def main():
	n = int(input())
	ip = [int(item) for item in input().split(' ')]
	max_length = 1
	temp = 1
	prev = ip[0]
	for i in range(1, len(ip)):
		if ip[i] >= prev:
			temp += 1
		else:
			max_length = max(max_length, temp)
			temp = 1
		prev = ip[i]
	print(max(max_length, temp))
main()


n = int(input())
a = list(map(int, input().split()))
c = 0
m = []
if len(a) == 1:
	print(1)
else:
	for i in range(len(a) - 1):
		if a[i] <= a[i + 1]:
			c += 1
		else:
			m.append(c + 1)
			c = 0
		if i == len(a) - 2 and c != 0:
			m.append(c + 1)
	print(max(m))


a = int(input())
L = list(map(int, input().split()))
c = 1
d = -1
for i in range(1, len(L)):
	if L[i] < L[i - 1] or i == len(L) - 1:
		if i == len(L) - 1 and L[i] >= L[i - 1]:
			c += 1
		if d < c or d == -1:
			d = c
		c = 1
	else:
		c += 1
if a == 1:
	d = 1
print(d)


n = int(input())
l = input()
l = l.split()
last = int(l[0])
k = 1
o = 1
for i in range(1, n):
	if int(l[i]) >= int(l[i - 1]):
		k += 1
	else:
		o = max(o, k)
		k = 1
o = max(o, k)

def max(a, b):
	if a > b:
		return a
	else:
		return b
print(o)


n = int(input())
arr = [int(i) for i in input().split()]
cur = 1
mx = 1
for i in range(n - 1):
	if arr[i] <= arr[i + 1]:
		cur += 1
		mx = max(mx, cur)
	else:
		cur = 1
print(mx)


n = int(input())
a = list(map(int, input().split()))
b = [0] * n
for i in range(1, n):
	if a[i] >= a[i - 1]:
		b[i] += b[i - 1] + 1
print(max(b) + 1)


n = int(input())
a = [int(x) for x in input().split()]
ctn = 0
out = []
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		ctn += 1
	else:
		out += [ctn + 1]
		ctn = 0
else:
	out += [ctn + 1]
print(max(out))


n = int(input())
a = list(map(int, input().split()))
count = 0
count_list = [0]
a.append(0)
m = 3
for i in range(n):
	if a[i + 1] >= a[i]:
		count = count + 1
		if i == n - 1:
			count_list.append(count + 1)
	elif count != 0 or i == n - 1:
		count_list.append(count + 1)
		count = 0
if n == 1:
	count_list.append(1)
print(max(count_list))


from sys import stdin
n = int(stdin.readline().strip())
nums = [int(num) for num in stdin.readline().strip().split(' ')]
max_non_decreasing_len = 0
curr_non_decreasing_len = 0
prev = None
for i in range(n):
	if prev is None or nums[i] < prev:
		curr_non_decreasing_len = 1
	else:
		curr_non_decreasing_len += 1
	prev = nums[i]
	if curr_non_decreasing_len > max_non_decreasing_len:
		max_non_decreasing_len = curr_non_decreasing_len
print(max_non_decreasing_len)


n = int(input())
l = [int(i) for i in input().split()]
p = [1]
for i in range(1, len(l)):
	if l[i] >= l[i - 1]:
		p.append(p[-1] + 1)
	else:
		p.append(1)
print(max(p))


n = int(input())
money = list(map(int, input().split()))
non_D_P = 1
p_D_P = 1
for i in range(n - 1):
	if money[i + 1] >= money[i]:
		p_D_P += 1
		if non_D_P < p_D_P:
			non_D_P = p_D_P
	else:
		p_D_P = 1
print(non_D_P)


n = int(input())
seq = list(map(lambda x: int(x), input().split(' ')))

def LIS(s):
	longest = 1
	current = 1
	for i in range(len(s)):
		if i > 0 and s[i] >= s[i - 1]:
			current += 1
			longest = max(current, longest)
		else:
			current = 1
	return longest
print(LIS(seq))


i = input
l = r = s = 0
i()
for x in map(int, i().split()):
	s = [s + 1, 1][x < l]
	l = x
	r = max(s, r)
print(r)


n = int(input())
arr = list(map(int, input().split()))
cnt = 0
prev = 0
m = 0
L = []
for i in arr:
	if i >= prev:
		cnt += 1
	else:
		m = max(m, cnt)
		cnt = 1
	prev = i
print(max(m, cnt))


size = int(input())
seq = input().split(' ')
seq = list(map(int, seq))
previous = 0
max_seg = 0
orders = []
for i in seq:
	if previous <= i:
		max_seg = max_seg + 1
	else:
		orders.append(max_seg)
		max_seg = 1
	previous = i
orders.append(max_seg)
print(max(orders))


line = input()
n = int(line)
line = input()
v = []
for word in line.split():
	v.append(int(word))
dp = [1] * n
for i in range(1, n):
	if v[i - 1] <= v[i]:
		dp[i] = dp[i - 1] + 1
	else:
		dp[i] = 1
biggest = 0
for number in dp:
	biggest = max(biggest, number)
print(biggest)


a = int(input())
m = [int(x) for x in input().split()]
summ = 1
maxx = 1
for i in range(1, a):
	if m[i] >= m[i - 1]:
		summ += 1
		maxx = max(maxx, summ)
	else:
		summ = 1
		maxx = max(maxx, summ)
print(maxx)


input()
c = m = s = 0
for i in map(int, input().split()):
	c = [c + 1, 1][i < s]
	m = max(m, c)
	s = i
print(m)


n = int(input())
nums = list(map(int, input().split()))
(pre, cur_cnt, cur_max) = (nums[0], 1, 1)
for i in range(1, len(nums)):
	if nums[i] >= pre:
		cur_cnt += 1
	else:
		cur_max = max(cur_max, cur_cnt)
		cur_cnt = 1
	pre = nums[i]
cur_max = max(cur_max, cur_cnt)
print(cur_max)


days = input()
earnings = input()
earnings_list = earnings.split()
incr_pay_days = 1
counter = -1
incr_pay_days_max = 1
for pay in earnings_list:
	counter += 1
	if counter == 0:
		continue
	if int(earnings_list[counter - 1]) <= int(pay):
		incr_pay_days += 1
		if incr_pay_days_max < incr_pay_days:
			incr_pay_days_max = incr_pay_days
	else:
		incr_pay_days = 1
print(incr_pay_days_max)


while True:
	try:

		def solution(n):
			ar = list(map(int, input().split()))
			dp = [0] * (n + 1)
			dp[1] = 1
			s = 1
			for o in range(1, n, 1):
				if ar[o] >= ar[o - 1]:
					s += 1
					dp[o + 1] = max(dp[o], s)
				else:
					s = 1
					dp[o + 1] = max(dp[o], s)
			print(dp[n])

		def read():
			n = int(input())
			solution(n)
		if __name__ == '__main__':
			read()
	except EOFError:
		break


import collections

class Reader:

	def __init__(self):
		self.data = collections.deque()

	def next_num(self):
		if len(self.data) == 0:
			self.data.extend(input().split())
		d = int(self.data.popleft())
		return d
r = Reader()
n = r.next_num()
p = r.next_num()
cc = 0
pc = 0
for i in range(n - 1):
	c = r.next_num()
	if c >= p:
		cc += 1
		pc = max(pc, cc)
	else:
		cc = 0
	p = c
print(pc + 1)


n = int(input())
b = list(map(int, input().split()))
i = 0
ma = 1
for x in range(1, n):
	if b[x] < b[x - 1]:
		ma = max(ma, x - i)
		i = x
	elif x == n - 1:
		ma = max(ma, x + 1 - i)
print(ma)


n = int(input())
a = list(map(int, input().split()))
ans = [1] * n
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		ans[i] = ans[i - 1] + 1
print(max(ans))


length = input()
numbers = input()
numbers = numbers.split()
max = 0
if len(numbers) > 0:
	max = 1
temp_max = max
for i in range(1, len(numbers)):
	if int(numbers[i]) >= int(numbers[i - 1]):
		temp_max += 1
	else:
		if temp_max > max:
			max = temp_max
		temp_max = 1
if temp_max > max:
	max = temp_max
print(max)


n = int(input())
a = list(map(int, input().split()))
i = 0
l = 0
m = 0
while i <= len(a) - 1:
	if a[i - 1] <= a[i]:
		i += 1
		l += 1
		m = max(m, l)
		continue
	else:
		i += 1
		l = 1
		continue
print(m)


n = input()
l = input().split()
count = 1
ans = 0
for i in range(0, int(n) - 1):
	if int(l[i]) <= int(l[i + 1]):
		count = count + 1
	else:
		if count > ans:
			ans = count
		count = 1
print(max(ans, count))


input()
(a, b, c) = (0, 0, 0)
for d in map(int, input().split()):
	if a > d:
		b = 0
	b = b + +1
	a = d
	c = max(c, b)
print(c)


n = int(input())
a = list(map(int, input().split()))
result = -1
cnt = 1
former = a[0]
for num in a[1:]:
	if num >= former:
		cnt += 1
	else:
		result = max(result, cnt)
		cnt = 1
	former = num
result = max(result, cnt)
print(result)


n = int(input())
arr = [int(i) for i in input().split()]
(c, m) = (1, 1)
for i in range(n - 1):
	if arr[i] > arr[i + 1]:
		c = 1
	else:
		c += 1
		if m < c:
			m = c
print(m)


n = int(input())
arr = [int(v) for v in input().strip().split()]
mem = [1 for i in range(n)]
mem = [1 for i in range(n)]
for i in range(1, n):
	if arr[i - 1] <= arr[i]:
		mem[i] = mem[i - 1] + 1
print(max(mem))


n = int(input())
a = list(map(int, input().split()))
size = 0
best = 0
for i in range(1, n):
	if a[i] >= a[i - 1]:
		size += 1
	else:
		best = max(size, best)
		size = 0
print(max(size + 1, best + 1))


n = int(input())
s = list(map(int, input().split(' ')))
(count, m) = (1, 1)
for i in range(1, n):
	if s[i] < s[i - 1]:
		count = 1
	else:
		count += 1
	if count > m:
		m = count
print(m)


n = int(input())
ai = list(map(int, input().split()))
if n == 1:
	print(1)
else:
	cnt = 0
	lst = []
	for i in range(len(ai) - 1):
		if ai[i] <= ai[i + 1]:
			cnt += 1
		else:
			lst.append(cnt)
			cnt = 0
		lst.append(cnt)
	print(max(lst) + 1)


j = int(input())
l = list(map(int, input().split()))
c = []
d = []
c.append(l[0])
for i in range(1, j):
	if l[i - 1] <= l[i]:
		c.append(l[i])
	else:
		d.append(len(c))
		c = []
		if i + 1 < j:
			c.append(l[i + 1])
d.append(len(c))
print(max(d))


def ml(v):
	v.append(-1)
	n = len(v)
	(s, m) = (0, 0)
	for x in range(n - 1):
		nx = x + 1
		if v[x] <= v[nx]:
			continue
		else:
			m = max(m, nx - s)
			s = nx
	return m
input()
v = [int(x) for x in input().split()]
print(ml(v))


n = int(input())
a = list(map(int, input().split()))
ans = [1] * n
for x in range(1, n):
	ans[x] = ans[x - 1] + 1 if a[x] >= a[x - 1] else 1
print(max(ans))


from sys import stdin
input = stdin.readline
n = int(input())
a = list(map(int, input().split()))
dp = [1] * n
for i in range(1, n):
	if a[i] >= a[i - 1]:
		dp[i] = 1 + dp[i - 1]
	else:
		dp[i] = 1
print(max(dp))


n = int(input())
money = [int(i) for i in input().split()]
days = 1
total = 1
for i in range(n - 1):
	if money[i + 1] >= money[i]:
		total += 1
	else:
		days = max(total, days)
		total = 1
print(max(total, days))


s = 1
maxs = 1
a = []
n = int(input())
inp = input().split()
for i in range(n):
	a.append(int(inp[i]))
for i in range(n - 1):
	if a[i + 1] >= a[i]:
		s += 1
		if s > maxs:
			maxs = s
	else:
		s = 1
print(maxs)


n = int(input())
a = list(map(int, input().split(' ')))
L = []
l = 1
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		l += 1
	else:
		L.append(l)
		l = 1
L.append(l)
print(max(L))


n = int(input())
money = input()
m = money.split()
for i in range(0, len(m)):
	m[i] = int(m[i])
count = 0
max = 0
for i in range(0, len(m) - 1):
	if m[i] <= m[i + 1]:
		count = count + 1
		if max < count:
			max = count
	elif m[i] > m[i + 1]:
		count = 0
y = max + 1
print(y)


n = int(input())
a = list(map(int, input().split(' ')))
tmp = 1
max_tmp = 1
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		tmp += 1
		if tmp > max_tmp:
			max_tmp = tmp
	else:
		tmp = 1
print(max_tmp)


input()
c = l = m = 0
for a in map(int, input().split()):
	c = [c + 1, 1][a < l]
	m = max(m, c)
	l = a
print(m)


n = int(input())
a = [int(x) for x in input().split()]
b = []
foo = 0
if n == 1:
	print(1)
else:
	for i in range(len(a) - 1):
		if a[i + 1] < a[i]:
			foo = 1
			b.append(i + 1)
if foo == 1:
	c = []
	for i in range(len(b) - 1):
		c.append(b[i + 1] - b[i])
	c.append(b[0])
	c.append(n - b[len(b) - 1])
if foo == 1:
	print(max(c))
elif foo == 0 and n != 1:
	print(n)


def basic(n, arr):
	first = 0
	res = 0
	if len(arr) == 1:
		return 1
	for i in range(1, len(arr)):
		if i > 0 and arr[i - 1] > arr[i]:
			first = i
		res = max(res, i - first + 1)
	return res
n = int(input())
arr = list(map(int, input().split(' ')))
print(basic(n, arr))


n = int(input())
prices = [int(x) for x in input().split()]
last_price = prices[0]
longest_length = 1
current_length = 1
for i in range(1, len(prices)):
	if prices[i] >= last_price:
		current_length += 1
		longest_length = max(current_length, longest_length)
	else:
		current_length = 1
	last_price = prices[i]
print(longest_length)


n = int(input())
lists = [int(i) for i in input().split(' ')]
result = [0] * n
cnt = 0
for i in range(n - 1):
	if lists[i] <= lists[i + 1]:
		result[cnt] += 1
	else:
		cnt += 1
print(max(result) + 1)


n = int(input())
li = [int(i) for i in input().split(' ')]
mx = 0
cnt = 1
for i in range(1, n):
	if li[i] < li[i - 1]:
		mx = max(cnt, mx)
		cnt = 1
	else:
		cnt += 1
mx = max(mx, cnt)
print(mx)


n = int(input())
a = [int(x) for x in input().split()]
d = 1
m = 1
for i in range(n - 1):
	if a[i + 1] < a[i]:
		if m < d:
			m = d
		d = 1
	else:
		d += 1
if m < d:
	m = d
print(m)


def main():
	n = int(input())
	lst = [int(x) for x in input().split()]
	m_l = 1
	l = 1
	for i in range(1, n):
		if lst[i] >= lst[i - 1]:
			l += 1
		else:
			m_l = max(m_l, l)
			l = 1
	m_l = max(m_l, l)
	print(m_l)
main()


l = int(input())
data = input()
data = data.split()
data = [int(x) for x in data]
best = 0
M = 0
for i in range(len(data) - 1):
	if data[i + 1] >= data[i]:
		best += 1
	else:
		best = 0
	M = max(best, M)
print(M + 1)


n = int(input())
s = [int(i) for i in input().split()]
max_len = 1
length = 1
for i in range(n - 1):
	if s[i] <= s[i + 1]:
		length += 1
		if length > max_len:
			max_len = length
	else:
		length = 1
print(max_len)


x = int(input())
l = list(map(int, input().split()))
l1 = []
max = -999
if x == 1:
	max = 1
for i in range(0, x - 1):
	if l[i] <= l[i + 1]:
		l1.append(l[i])
	else:
		l1.append(l[i])
		if max < len(l1):
			max = len(l1)
		l1 = []
if l[len(l) - 2] <= l[len(l) - 1]:
	l1.append(l[len(l) - 1])
if max < len(l1):
	max = len(l1)
print(max)


from sys import stdin
input = stdin.readline
k = int(input())
number = list(map(int, input().split()))
t = 0
j = 0
for i in range(k):
	if i == 0 or number[i - 1] <= number[i]:
		j += 1
	else:
		j = 1
	t = max(t, j)
print(t)


n = int(input())
y = input().split()
x = []
for i in range(len(y)):
	x.append(y[i])
temp = 1
hasil = 1
for i in range(1, n):
	if int(x[i - 1]) <= int(x[i]):
		temp += 1
	else:
		temp = 1
	if hasil < temp:
		hasil = temp
print(hasil)


n = int(input())
a = [int(x) for x in input().split()]
long = -1
curr = 0
for i in range(n - 1):
	if a[i + 1] >= a[i]:
		curr += 1
	if a[i + 1] < a[i]:
		curr = 0
	if curr > long:
		long = curr
print(max(1, long + 1))


n = int(input())
a = [int(i) for i in input().split()]
x = 1
xm = 0
m = a[0]
for i in a[1:]:
	if i >= m:
		x += 1
	else:
		xm = max(x, xm)
		x = 1
	m = i
xm = max(x, xm)
print(xm)


def f():
	x = int(input())
	l = list(map(int, input().split()))
	premax = 0
	macs = 0
	it = 0
	while it < len(l) - 1:
		if l[it] <= l[it + 1]:
			premax += 1
		else:
			premax = 0
		if premax > macs:
			macs = premax
		it += 1
	print(macs + 1)
f()


n = int(input())
ara = list(map(int, input().split()))
count = 1
li = []
for i in range(n - 1):
	if ara[i] <= ara[i + 1]:
		count = count + 1
	else:
		li.append(count)
		count = 1
li.append(count)
print(max(li))


n = int(input())
l = list(map(int, input().split()))
ans = 1
tans = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		tans += 1
		ans = max(ans, tans)
	else:
		tans = 1
print(ans)


n = int(input())
num1 = list(map(int, input().split()))

def maxLengthNonDecreasingSubSegment(arr, size):
	s = 1
	a = 1
	for i in range(size - 1):
		if arr[i + 1] >= arr[i]:
			s += 1
		else:
			s = 1
		a = max(a, s)
	return a
print(maxLengthNonDecreasingSubSegment(num1, n))


def getData():
	line = input()
	line = line.split()
	for i in range(len(line)):
		line[i] = int(line[i])
	return line
n = int(input())
data = getData()
ln = 0
maxlen = 0
back = 0
for i in range(n):
	if data[i] >= back:
		ln += 1
		back = data[i]
	else:
		if ln > maxlen:
			maxlen = ln
		ln = 1
		back = data[i]
if ln > maxlen:
	maxlen = ln
print(maxlen)


n = int(input())
arr = list(map(int, input().split()))
maxi = 0
t = 0
k = 0
for i in range(1, len(arr)):
	if arr[i - 1] <= arr[i]:
		maxi += 1
	else:
		k = 1
		if t < maxi + 1:
			t = maxi + 1
		maxi = 0
if k == 0:
	print(len(arr))
else:
	print(max(t, maxi + 1))


number = int(input())
seq = [int(i) for i in input().split()]
max_len = 1
temp = 1
counter = 0
while counter != len(seq) - 1:
	if seq[counter] <= seq[counter + 1]:
		temp += 1
		if temp > max_len:
			max_len = temp
		counter += 1
	else:
		temp = 1
		counter += 1
print(max_len)


n = int(input())
p = list(map(int, input().split(' ')))
maxx = 0
ans = 1
for i in range(1, len(p)):
	if p[i] >= p[i - 1]:
		ans = ans + 1
	else:
		ans = 1
	if maxx < ans:
		maxx = ans
if n > 1:
	print(maxx)
else:
	print('1')


N = int(input())
L = list(map(int, input().split()))
temp = []
S = 1
for i in range(N - 1):
	if L[i] <= L[i + 1]:
		S += 1
		temp.append(S)
	else:
		S = 1
if len(temp) > 1:
	print(max(temp))
elif len(temp) == 1:
	print(temp[0])
else:
	print(1)


n = int(input())
a = [int(x) for x in input().split()]
max_diff = 1
diff = 1
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		diff += 1
	elif max_diff < diff:
		max_diff = diff
		diff = 1
	else:
		diff = 1
if max_diff < diff:
	max_diff = diff
print(max_diff)


n = int(input())
li = list(map(int, input().split()))
(li1, c) = ([], 1)
for i in range(0, n - 1):
	if li[i] <= li[i + 1]:
		c += 1
	else:
		li1.append(c)
		c = 1
li1.append(c)
print(max(li1))


a = int(input())
b = list(map(int, input().split()))
sum = 0
max = 0
for k in range(0, a - 1):
	if b[k] <= b[k + 1]:
		sum += 1
	else:
		if sum > max:
			max = sum
		sum = 0
if sum > max:
	print(sum + 1)
else:
	print(max + 1)


t = int(input())
a = list(map(int, input().split()))
m = 0
c = 0
for i in range(len(a) - 1):
	if a[i] <= a[i + 1]:
		c = c + 1
	else:
		c = 0
	if m < c:
		m = c
print(m + 1)


n = int(input())
lix = [int(i) for i in input().split()][:n]
nondecmax = 1
k = 1
j = 1
while j < len(lix):
	if lix[j] >= lix[j - 1]:
		k += 1
		if k > nondecmax:
			nondecmax = k
	else:
		k = 1
	j += 1
print(nondecmax)


def kefa(ls):
	count = 0
	num = 0
	temp = []
	for i in range(len(ls)):
		if ls[i] >= num:
			count += 1
		else:
			temp.append(count)
			count = 1
		num = ls[i]
	temp.append(count)
	return max(temp)
n = int(input())
na = input().split()
ls = []
for i in range(n):
	ls.append(int(na[i]))
res = kefa(ls)
print(res)


n = int(input())
A = list(map(int, input().split()))
count = 0
ans = 0
prev = -1
for a in A:
	if prev <= a:
		count += 1
		ans = max(ans, count)
	else:
		count = 1
	prev = a
print(ans)


input()
l = [int(x) for x in input().split()]
(olde, ml, mg) = (l[0], 1, 1)
for e in l[1:]:
	if olde <= e:
		ml += 1
	else:
		ml = 1
	mg = ml if ml > mg else mg
	olde = e
print(mg)


n = int(input())
l = [int(i) for i in input().split()]
o = []
k = 1
for i in range(n - 1):
	if l[i] <= l[i + 1]:
		k += 1
	else:
		o.append(k)
		k = 1
o.append(k)
print(max(o))


import sys
a = int(input())
c = 0
d = []
b = list(map(int, input().split()))
if a == 1:
	print('1')
	sys.exit()
for i in range(0, a - 1):
	if b[i] <= b[i + 1]:
		c = c + 1
	if i == a - 2:
		d.append(c)
	elif b[i] > b[i + 1]:
		d.append(c)
		c = 0
d.sort()
print(d[len(d) - 1] + 1)


n = int(input())
L = list(map(int, input().split()))
L1 = []
c = 1
for i in range(len(L) - 1):
	if L[i + 1] >= L[i]:
		c = c + 1
	else:
		L1.append(c)
		c = 1
L1.append(c)
print(max(L1))


n = int(input())
arr = list(map(int, input().split()))
p = 0
i = 0
q = 0
r = 0
while i <= n - 2:
	while arr[i] <= arr[i + 1]:
		p += 1
		i += 1
		r = 1
		if i == n - 1:
			break
	if p > q:
		q = p
	p = 0
	if r != 1:
		i += 1
	r = 0
q += 1
print(q)


def get():
	res = [int(x) for x in input().split()]
	return res[0] if len(res) == 1 else res
(n, l) = (get(), get())
(now, mx) = (1, 1)
for i in range(1, n):
	if l[i - 1] <= l[i]:
		now += 1
		mx = max(mx, now)
	else:
		now = 1
print(mx)


import sys
from sys import stdin, stdout
import math
import random
import heapq
from collections import Counter
from functools import lru_cache
try:
	for _ in range(1):
		n = int(input())
		arr = [int(i) for i in input().split()]
		ptr = 0
		mx = 0
		while ptr < n:
			c = 0
			x = arr[ptr]
			while ptr < n and arr[ptr] >= x:
				x = arr[ptr]
				c += 1
				ptr += 1
			ptr -= 1
			if c > mx:
				mx = c
			ptr += 1
		print(mx)
except EOFError as e:
	print(e)


n = int(input())
A = list(map(int, input().split()))
(cnt, m) = (0, 0)
for i in range(n - 1):
	if A[i] <= A[i + 1]:
		cnt += 1
	else:
		m = max(m, cnt)
		cnt = 0
m = max(m, cnt)
print(m + 1)


n = int(input())
x = list(map(int, input().split()))
coun = int(1)
ans = coun
for i in range(len(x)):
	if i != 0:
		if x[i - 1] <= x[i]:
			coun += 1
		else:
			coun = 1
	ans = max(ans, coun)
print(ans)


n = int(input())
A = list(map(int, input().split()))
max_length = 1
accumulate = 1
for i in range(1, len(A)):
	if A[i] >= A[i - 1]:
		accumulate += 1
	else:
		accumulate = 1
	if accumulate > max_length:
		max_length = accumulate
print(max_length)


n = int(input())
As = list(map(int, input().split()))
ans = 1
record = 1
prev_a = As[0]
for a in As[1:]:
	if a >= prev_a:
		ans += 1
		if ans > record:
			record = ans
	else:
		ans = 1
	prev_a = a
print(record)


n = int(input())
L = list(map(int, input().split())) + [0]
(cont, mayor) = (1, 0)
for k in range(n):
	if L[k + 1] >= L[k]:
		cont += 1
	else:
		if cont > mayor:
			mayor = cont
		cont = 1
print(mayor)


x = int(input())
y = input().split()
c = 0
r = 0
for i in range(len(y) - 1):
	if int(y[i]) <= int(y[i + 1]):
		c += 1
	else:
		c = 0
	r = max(c, r)
print(r + 1)


n = int(input())
a = tuple(map(int, input().split()))
q = [0]
e = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		e += 1
	else:
		q += [e]
		e = 1
q += [e]
print(max(q))


n = int(input())
x = input()
sequence = x.split()
max = 1
index = 0
while index <= n - 2:
	c = 1
	while int(sequence[index]) <= int(sequence[index + 1]):
		c += 1
		index += 1
		if index > n - 2:
			break
	index += 1
	if max < c:
		max = c
print(max)


n = int(input())
array = [int(i) for i in input().split()]
a = 0
MAX = 0
for i in range(n - 1):
	if array[i] <= array[i + 1]:
		a += 1
	else:
		MAX = max(MAX, a)
		a = 0
print(max(MAX, a) + 1)


n = int(input())
s = list(map(int, input().split()))
c = 0
a = 0
arr = []
for i in range(n):
	if s[i] >= a:
		a = s[i]
		c = c + 1
	else:
		a = s[i]
		arr.append(c)
		c = 1
if len(arr) == 0:
	print(n)
elif c > max(arr):
	print(c)
else:
	print(max(arr))


n = int(input())
s = list(map(int, input().split()))
i = 1
aa = set()
while n > i:
	su = 1
	for j in range(i, n):
		if s[j] >= s[j - 1]:
			su += 1
			i = j + 1
		else:
			i = j + 1
			break
	aa.add(su)
else:
	aa.add(1)
print(max(aa))


s = 0
ss = []
a = int(input())
l = list(map(int, input().split()))
i = 0
j = 1
nb = 1
if len(l) != 1:
	while j < len(l):
		if l[i] <= l[j]:
			i += 1
			j += 1
			nb += 1
		else:
			nb = 1
			i += 1
			j += 1
		ss.append(nb)
	print(max(ss))
else:
	print(1)


n = int(input())
ar = [int(i) for i in input().split()]
res = 1
maxx = 1
if len(ar) == 1:
	print(1)
else:
	for i in range(len(ar) - 1):
		if ar[i] <= ar[i + 1]:
			res += 1
			if res > maxx:
				maxx = res
		else:
			res = 1
	print(maxx)


n = int(input())
(m, t, h) = (1, 0, 0)
for i in input().split():
	if h <= int(i):
		t += 1
		if m < t:
			m = t
	else:
		t = 1
	h = int(i)
print(m)


def kefa(arr, n):
	i = 1
	c = 1
	maxi = 1
	while i < n:
		if arr[i] >= arr[i - 1]:
			c += 1
			maxi = max(maxi, c)
		else:
			c = 1
		i += 1
	return maxi
n = int(input())
arr = list(map(int, input().split()))
print(kefa(arr, n))


n = int(input())
matrix = [1 for i in range(n)]
li = input().split()
li = [int(i) for i in li]
for i in range(1, n):
	if li[i] >= li[i - 1]:
		matrix[i] = matrix[i - 1] + 1
print(max(matrix))


cnt = int(input())
num_list = list(map(int, input().split()))
increased_ord = []
idx = 0
i = 1
while idx < len(num_list) - 1:
	if num_list[idx] <= num_list[idx + 1]:
		i += 1
	else:
		increased_ord.append(i)
		i = 1
	idx += 1
else:
	increased_ord.append(i)
print(max(increased_ord))


num = int(input())
nums = [int(i) for i in input().split()]
max_seq = 0
seq = 0
current = 0
for i in nums:
	if i >= current:
		seq += 1
	else:
		if seq > max_seq:
			max_seq = seq
		seq = 1
	current = i
print(max(seq, max_seq))


n = int(input())
a = list(map(int, input().split()))
c = 0
i = 0
j = 0
m = []
while j < n:
	if a[i] <= a[j]:
		c = c + 1
		i = j
		j = j + 1
	else:
		i = j
		m.append(c)
		c = 0
m.append(c)
print(max(m))


days = int(input())
money_list = list(map(int, input().split()))
max_non_decreasing_days = 0
non_decreasing = 0
i = 1
while i < len(money_list):
	if money_list[i] >= money_list[i - 1]:
		non_decreasing += 1
	else:
		non_decreasing = 0
	if non_decreasing > max_non_decreasing_days:
		max_non_decreasing_days = non_decreasing
	i += 1
print(max_non_decreasing_days + 1)


input()
nums = list(map(int, input().split()))
last = nums[0] + 1
best = 0
cur = 0
for n in nums:
	if n >= last:
		cur += 1
		best = max(cur, best)
	else:
		cur = 0
	last = n
print(best + 1)


n = int(input())
l = list(map(int, input().split()))
list = [1]
for i in range(n - 1):
	if l[i] <= l[i + 1]:
		list[-1] += 1
	else:
		list.append(1)
list.sort()
print(list[-1])


tst = int(input())
seq = list(map(int, input().split()))
(mx, cx) = (0, 1)
for iv in range(tst - 1):
	if seq[iv] > seq[iv + 1]:
		if cx > mx:
			mx = cx
		cx = 1
	else:
		cx += 1
if cx > mx:
	mx = cx
print(mx)


def codeforces():
	_ = input()
	lst = list(map(int, input().split()))
	count = 1
	mx = 1
	for i in range(1, len(lst)):
		if lst[i - 1] <= lst[i] and mx <= count and (i == len(lst) - 1):
			mx = count + 1
		elif lst[i - 1] > lst[i] and mx < count:
			mx = count
			count = 1
		elif lst[i - 1] > lst[i]:
			count = 1
		else:
			count += 1
	print(mx)
codeforces()


(a, c, d) = (int(input()), 1, [1])
b = list(map(int, input().split()))
for x in range(1, a):
	if b[x] >= b[x - 1]:
		c += 1
	else:
		d.append(c)
		c = 1
d.append(c)
print(max(d))


n = int(input(''))
a = input('')
a = a.split(' ')
count = 1
countmax = 1
for i in range(1, n):
	if int(a[i - 1]) <= int(a[i]):
		count += 1
	else:
		count = 1
	if count > countmax:
		countmax = count
print(countmax)


n = int(input())
a = [int(x) for x in input().split()]
c = 0
max = 0
ind = 0
for i in range(1, n):
	if a[i] >= a[i - 1]:
		c += 1
		ind = i
	else:
		if c > max:
			max = c
		c = 0
if ind == n - 1 and c > max:
	max = c
print(max + 1)


n = int(input())
l = list(map(int, input().split()))
q = []
for i in range(n):
	q.append(1)
for i in range(1, n):
	if l[i] >= l[i - 1]:
		q[i] = q[i - 1] + 1
print(max(q))


R = lambda : map(int, input().split())
n = int(input())
(res, cnt, prev) = (0, 0, 0)
for x in R():
	if x >= prev:
		cnt += 1
	else:
		cnt = 1
	prev = x
	res = max(res, cnt)
print(res)


t = int(input())
li = [int(k) for k in input().split()]
o = 0
k = 1
for i in range(t - 1):
	if li[i + 1] >= li[i]:
		k += 1
	else:
		o = max(o, k)
		k = 1
o = max(o, k)
print(o)


days = int(input())
money = input().split(' ')
count = []
l = 1
for i in range(1, len(money)):
	if int(money[i]) >= int(money[i - 1]):
		l += 1
	else:
		count.append(l)
		l = 1
count.append(l)
print(max(count))


n = int(input())
a = [int(x) for x in input().split()]
now = 1
sum = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		now += 1
	else:
		now = 1
	sum = max(sum, now)
print(sum)


n = int(input())
s = [int(s) for s in input().split()]
s.append(0)
l = []
count = 0
for i in range(n):
	if i < n - 1 and s[i] <= s[i + 1]:
		count = count + 1
	elif i == n - i or s[i] > s[i + 1]:
		l.append(count + 1)
		count = 0
print(max(l))


import sys
input = sys.stdin.readline
read = lambda : map(int, input().split())
read_float = lambda : map(float, input().split())

def ceil(x):
	if x != int(x):
		x = int(x) + 1
	return x

def factorial(x, m):
	val = 1
	while x > 0:
		val = val * x % m
		x -= 1
	return val

def fact(x):
	val = 1
	while x > 0:
		val *= x
		x -= 1
	return val

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def lcm(a, b):
	return a * b // math.gcd(a, b)

def nCr(n, k):
	if k > n:
		return 0
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def primefs(n):
	primes = {}
	while n % 2 == 0 and n > 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0 and n > 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	(prime[0], prime[1]) = (False, False)
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def phi(n):
	result = n
	p = 2
	while p * p <= n:
		if n % p == 0:
			while n % p == 0:
				n = n // p
			result = result * (1.0 - 1.0 / float(p))
		p = p + 1
	if n > 1:
		result = result * (1.0 - 1.0 / float(n))
	return int(result)

def is_prime(n):
	if n == 0:
		return False
	if n == 1:
		return True
	for i in range(2, int(n ** (1 / 2)) + 1):
		if not n % i:
			return False
	return True
MAXN = int(100000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i
spf = [0 for i in range(MAXN)]

def factoriazation(x):
	res = []
	for i in range(2, int(x ** 0.5) + 1):
		while x % i == 0:
			res.append(i)
			x //= i
	if x != 1:
		res.append(x)
	return res

def factors(n):
	res = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			res.append(i)
			res.append(n // i)
	return list(set(res))

def int_array():
	return list(map(int, input().strip().split()))

def float_array():
	return list(map(float, input().strip().split()))

def str_array():
	return input().strip().split()

def binary_search(low, high, w, h, n):
	while low < high:
		mid = low + (high - low) // 2
		if check(mid, w, h, n):
			low = mid + 1
		else:
			high = mid
	return low

def check(l, a, n):
	print(l, a, n)
	for i in range(n - l):
		if a[i:l] == list(sorted(a[i:l])):
			return True
	print('YEAAH')
	return False
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
from itertools import permutations
import math
import bisect as bis
import random
import sys

def solve():
	n = int(input())
	a = list(read())
	m = 0
	if a == list(sorted(a)):
		print(n)
		return
	c = 0
	last = -1
	for x in a:
		m = max(c, m)
		if x >= last:
			c += 1
			last = x
		else:
			c = 1
			last = x
	m = max(c, m)
	print(m)
for _ in range(1):
	solve()


list_length = int(input())
array = list(map(int, input().split()))[:list_length]
n = len(array)

def longNonDecreasingSubset(arr, n):
	maximum = 1
	l = 1
	for i in range(1, n):
		if arr[i] >= arr[i - 1]:
			l = l + 1
		else:
			if maximum < l:
				maximum = l
			l = 1
	if maximum <= l:
		maximum = l
	return maximum
print(longNonDecreasingSubset(array, n))


n = int(input())
n1 = list(map(int, input().split()))
count = 1
list1 = []
for i in range(len(n1) - 1):
	if n1[i] <= n1[i + 1]:
		count = count + 1
		list1.append(count)
	else:
		count = 1
if len(list1) == 0:
	print(count)
else:
	print(max(list1))


n = int(input())
a = input().split()
tmp_count = 0
prev_i = 0
len_seq = []
for i in a:
	i = int(i)
	if i >= prev_i:
		tmp_count += 1
	else:
		len_seq.append(tmp_count)
		tmp_count = 1
	prev_i = i
len_seq.append(tmp_count)
print(max(len_seq))


n = int(input())
list1 = [int(i) for i in input().split()]
m = 1
list2 = []
for i in range(0, n, 1):
	if i == n - 1:
		list2.append(m)
		break
	if list1[i] <= list1[i + 1]:
		m = m + 1
	else:
		list2.append(m)
		m = 1
print(max(list2))


n = int(input())
m = list(map(int, input().split()))
c = m[0]
v = 1
b = 1
for i in range(1, n):
	if m[i] >= c:
		v += 1
		c = m[i]
		if b < v:
			b = v
	else:
		c = m[i]
		v = 1
print(b)


n = int(input())
a = [int(s) for s in input().split()]
k = 1
kmax = 0
for i in range(1, n):
	if a[i] >= a[i - 1]:
		k += 1
	else:
		kmax = max(kmax, k)
		k = 1
kmax = max(kmax, k)
print(kmax)


__author__ = 'pxy'
i = int(input())
g = [int(j) for j in input().split()]
k = 1
maxx = 0
for j in range(i - 1):
	if g[j] <= g[j + 1]:
		k += 1
	else:
		if k > maxx:
			maxx = k
		k = 1
print(max(k, maxx))


def sol(val):
	res = 0
	v = 0
	m = 0
	for i in val:
		if i >= v:
			res += 1
		else:
			res = 1
		v = i
		m = max(m, res)
	return m
int(input().strip())
val = [int(i.strip()) for i in input().split()]
print(sol(val))


s = int(input())
l = [int(i) for i in input().split()]
a = []
ma = 1
c = 1
for i in range(1, s):
	if l[i - 1] <= l[i]:
		c = c + 1
		if c > ma:
			ma = c
	else:
		c = 1
print(ma)


n = int(input())
a = [int(x) for x in input().strip().split()]
a.insert(0, 0)
dp = [0] * (n + 1)
for i in range(1, n + 1):
	if a[i - 1] > a[i]:
		dp[i] = 1
	else:
		dp[i] = dp[i - 1] + 1
print(max(dp))


def lics(lst):
	(s, ans) = (0, 1)
	for i in range(len(lst)):
		if lst[i] >= lst[i - 1]:
			ans = max(ans, i - s + 1)
		else:
			s = i
	return ans
n = int(input())
a = list(map(int, input().split()))
print(lics(a))


n = int(input())
a = list(map(int, input().split()))
(answer, left, right) = (1, 0, 0)
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		right += 1
	else:
		if answer < right - left + 1:
			answer = right - left + 1
		(left, right) = (i, i)
print(max(answer, right - left + 1))


n = int(input())
l = list(map(int, input().split()))
count = 1
large = 0
for i in range(len(l) - 1):
	if l[i] <= l[i + 1]:
		count = count + 1
		if count >= large:
			large = count
	else:
		count = 1
if n <= 1 or large == 0:
	print(1)
else:
	print(large)


n = int(input())
j = []
e = 1
d = 0
l = [int(x) for x in input().split()]
if len(l) == 1:
	print(1)
else:
	for b in range(1, n):
		if l[b] >= l[b - 1]:
			e += 1
			j.append(e)
		else:
			e = 1
			j.append(e)
	if sum(j) == n - 1:
		print(1)
	else:
		print(max(j))


n = int(input())
line = list(map(int, input().split(' ')))
k = 1
i = 0
while i < n - 1:
	c = 1
	while i < n - 1 and line[i] <= line[i + 1]:
		c = c + 1
		i = i + 1
	if k < c:
		k = c
	i = i + 1
print(k)


a = int(input())
f = 1
p = []
k = list(map(int, input().split()))
j = 0
while j < len(k) - 1:
	if k[j] <= k[j + 1]:
		f += 1
	else:
		p.append(f)
		f = 1
	j = j + 1
p.append(f)
print(max(p))


length = list(map(int, input().split()))
Array = list(map(int, input().split()))
biggesC = 1
counter = 1
for a in range(len(Array) - 1):
	if Array[a] <= Array[a + 1]:
		counter += 1
		if biggesC < counter:
			biggesC = counter
	elif Array[a] > Array[a + 1]:
		counter = 1
print(biggesC)


input()
a = [int(x) for x in input().split()]
a.append(-1)
ans = now = 1
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		now += 1
	else:
		ans = max(ans, now)
		now = 1
print(ans)


n = int(input())
x = list(map(int, input().split()))
m = 0
c = 1
for i in range(1, n):
	if x[i] >= x[i - 1]:
		c += 1
	else:
		m = max(m, c)
		c = 1
		continue
m = max(m, c)
print(m)


a = input()
s = m = l = 0
for i in map(int, input().split()):
	s = [s + 1, 1][i < l]
	m = max(m, s)
	l = i
print(m)


n = int(input())
lis = [int(x) for x in input().split()]
c = m = 0
for i in range(n - 1):
	if lis[i] <= lis[i + 1]:
		c += 1
	else:
		c = 0
	m = max(m, c)
print(m + 1)


n = int(input())
a = list(map(int, input().split()))
d = [1] * n
for i in range(1, n):
	if a[i - 1] <= a[i]:
		d[i] = d[i - 1] + 1
print(max(d))


n = int(input())
array = [int(data) for data in input().split(' ')]
max_range = 0
count_range = 0
for i in range(0, n - 1):
	if array[i] <= array[i + 1]:
		count_range += 1
	else:
		if max_range < count_range:
			max_range = count_range
		count_range = 0
if max_range < count_range:
	max_range = count_range
print(max_range + 1)


import sys
import math
n = int(input())
a = [int(e) for e in input().split()]
ans = 1
f = [0] * n
f[0] = 1
for i in range(1, n):
	if a[i] < a[i - 1]:
		f[i] = 1
	else:
		f[i] = f[i - 1] + 1
print(max(f))


n = int(input())
ans = 0
cnt = 0
last = 0
for i in map(int, input().split()):
	if i >= last:
		cnt += 1
	else:
		ans = max(ans, cnt)
		cnt = 1
	last = i
ans = max(ans, cnt)
print(ans)


n = int(input())
lst = input().split()
temp = [int(lst[0])]
max_temp = len(temp)
for i in range(1, len(lst)):
	if int(lst[i]) >= temp[-1]:
		temp.append(int(lst[i]))
		if len(temp) > max_temp:
			max_temp = len(temp)
	else:
		temp = [int(lst[i])]
print(max_temp)


n = int(input())
sequence = [int(i) for i in input().split(' ')]
max1 = 1
max2 = 1
for i in range(1, n):
	if sequence[i] >= sequence[i - 1]:
		max1 += 1
	else:
		max2 = max(max1, max2)
		max1 = 1
print(max(max1, max2))


n = int(input())
num = [int(i) for i in input().split()]
count = 1
check = []
M = num[0]
counter = 0
for i in range(1, n):
	if num[i] >= M:
		count += 1
		M = num[i]
	else:
		counter += 1
		check.append(count)
		M = num[i]
		count = 1
check.append(count)
check.sort()
l = len(check)
print(check[l - 1])


n = int(input())
l = [int(i) for i in input().split()]
ans = []
ln = 0
mx = 0
for i in l:
	if i >= mx:
		ln += 1
		mx = i
	elif i < mx:
		ans.append(ln)
		ln = 1
		mx = i
ans.append(ln)
print(max(ans))


n = int(input())
segments = list(map(int, input().split()))
unbrekable_increase = t = 0
for (p, n) in zip(segments[1:], segments):
	if p >= n:
		unbrekable_increase += 1
		t = max(unbrekable_increase, t)
	else:
		unbrekable_increase = 0
print(t + 1)


def Main():
	n = int(input())
	arr = list(map(int, input().split()))
	maxx = 1
	curr = 1
	for i in range(1, n):
		if arr[i - 1] <= arr[i]:
			curr += 1
		else:
			curr = 1
		if curr > maxx:
			maxx = curr
	print(maxx)
Main()


n = int(input())
init = list(map(int, input().split()))
fin = []
c = 1
for i in range(n - 1):
	if init[i] <= init[i + 1]:
		c += 1
	else:
		fin.append(c)
		c = 1
fin.append(c)
print(max(fin))


n = int(input())
income_o = input().split()
income = list()
for item in income_o:
	income.append(int(item))
t = 1
i = 0
list_t = list()
list_t.append(1)
while i in range(n - 1):
	if income[i] <= income[i + 1]:
		t = t + 1
		list_t.append(t)
		i = i + 1
	else:
		i = i + 1
		t = 1
ans = max(list_t)
print(ans)


import sys
file = sys.stdin.readlines()
line = file[1]
line = line.split()
line[-1] = line[-1].strip()
i = 0
while i < len(line):
	line[i] = int(line[i])
	i += 1
counter = 1
counterlist = [1]
i = 0
while i < len(line):
	if i != len(line) - 1:
		if line[i] <= line[i + 1]:
			counter += 1
		else:
			counterlist.append(counter)
			counter = 1
	i += 1
counterlist.append(counter)
print(max(counterlist))


def main():
	n = int(input())
	_ = [int(i) for i in input().split(' ')]
	max_len = 1
	nums = 1
	for i in range(1, n):
		if _[i - 1] <= _[i]:
			nums += 1
			if nums > max_len:
				max_len = nums
		else:
			nums = 1
	print(max_len)
main()


n = int(input())
coins = list(map(int, input().split()))
k = 1
o = 1
for i in range(1, len(coins)):
	if coins[i] >= coins[i - 1]:
		k += 1
	else:
		o = max(o, k)
		k = 1
	o = max(o, k)
print(o)


n = int(input())
money = list(map(int, input().split()))
sublist = list()
subseq = 1
for i in range(n):
	if i == n - 1:
		break
	elif money[i + 1] >= money[i]:
		subseq += 1
	else:
		sublist.append(subseq)
		subseq = 1
if len(sublist) == 0 or max(sublist) < subseq:
	print(subseq)
else:
	print(max(sublist))


n = int(input())
a = [int(x) for x in input().split()]
c = 1
l = [1] * n
j = 0
for i in range(1, n):
	if a[i] >= a[i - 1]:
		c += 1
	l[j] = c
	if a[i] < a[i - 1]:
		c = 1
		j += 1
print(max(l))


n = int(input())
l = list(map(int, input().split()))
i = 0
length = 0
seq = 0
while i < n - 1:
	if l[i] <= l[i + 1]:
		seq += 1
	else:
		if seq > length:
			length = seq
		seq = 0
	i += 1
if seq > length:
	length = seq
print(length + 1)


n = int(input())
a = [int(i) for i in input().split()]
res = 1
curr = 1
for i in range(1, n):
	if a[i] < a[i - 1]:
		curr = 1
	else:
		curr += 1
		res = max(res, curr)
print(res)


from sys import stdin

def main(n, a):
	best = 0
	curr = 1
	for i in range(1, n):
		if a[i] >= a[i - 1]:
			curr += 1
		else:
			if curr > best:
				best = curr
			curr = 1
	if curr > best:
		best = curr
	print(best)
n = int(stdin.readline())
a = [int(s) for s in stdin.readline().split()]
main(n, a)


n = int(input())
a = [int(i) for i in input().split()]
p = []
s = 1
if n == 1:
	p.append(1)
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		s += 1
		if i == n - 2:
			p.append(s)
	else:
		p.append(s)
		s = 1
print(max(p))


n = int(input())
lis = list(map(int, input().split()))
prev = 0
big = 0
ans = 0
for i in lis:
	if i >= prev:
		big += 1
	else:
		big = 1
	ans = max(ans, big)
	prev = i
print(ans)


n = int(input())
a = list(map(int, input().split()))
l = 1
i = 0
p = 0
for j in range(1, len(a)):
	if a[j] >= a[p]:
		g = j - i + 1
		if g > l:
			l = g
	else:
		i = j
	p = j
print(l)


n = int(input())
a = list(map(int, input().split()))
c = 1
Max = 1
for x in range(0, n - 1):
	if a[x] <= a[x + 1]:
		c += 1
	else:
		if Max < c:
			Max = c
		c = 1
if Max < c:
	Max = c
print(Max)


n = int(input())
z = list(map(int, input().split()))
arr = []
count = 1
for i in range(n - 1):
	if z[i] <= z[i + 1]:
		count += 1
		if i == n - 2:
			arr.append(count)
	else:
		arr.append(count)
		count = 1
if n == 1:
	print(1)
else:
	print(max(arr))


n = int(input())
s = list(map(int, input().split()))
l = [0] + [i + 1 for i in range(n - 1) if s[i] > s[i + 1]] + [n]
print(max((l[i + 1] - l[i] for i in range(len(l) - 1))))


n = int(input())
a = [int(s) for s in input().split(' ')]
chain = 1
max_chain = 1
for ii in range(n - 1):
	if a[ii + 1] >= a[ii]:
		chain += 1
		max_chain = max(max_chain, chain)
	else:
		chain = 1
print(max_chain)


n = int(input())
l = list(map(int, input().split()))
lp = []
co = 1
for i in range(n - 1):
	if l[i] <= l[i + 1]:
		co += 1
	else:
		lp.append(co)
		co = 1
lp.append(co)
print(max(lp))


n = int(input())
lis = list(map(int, input().split()))[:n]
count = 1
j = 1
for i in range(len(lis) - 1):
	if lis[i] <= lis[i + 1] and len(lis) != 1:
		j += 1
		count = max(count, j)
	else:
		j = 1
print(count)


n = int(input())
a = list(map(int, input().split()))
s = []
cnt = 1
for i in range(n):
	if i + 1 != n and a[i] <= a[i + 1]:
		cnt += 1
	else:
		cnt = 1
	s.append(cnt)
print(max(s))


input()
arr = [int(i) for i in input().split(' ')]
out = 0
maxval = 0
for i in range(len(arr) - 1):
	if arr[i + 1] < arr[i]:
		if maxval > out:
			out = maxval
		maxval = 0
	else:
		maxval += 1
if maxval > out:
	out = maxval
print(out + 1)


n = int(input())
a = list(map(int, input().split()))
count = 0
nic = 4
count_list = [0]
a.append(0)
for i in range(n):
	if a[i + 1] >= a[i]:
		count = count + 1
		if i == n - 1:
			count_list.append(count + 1)
	elif count != 0 or i == n - 1:
		count_list.append(count + 1)
		count = 0
if n == 1:
	count_list.append(1)
print(max(count_list))


n = int(input())
a = list(map(int, input().split()))
(c, mx) = (0, 0)
for i in range(len(a) - 1):
	if a[i] <= a[i + 1]:
		c += 1
	else:
		if c > mx:
			mx = c
		c = 0
if c > mx:
	mx = c
print(mx + 1)


n = int(input())
store = list(map(int, input().split()))
maxPos = -1
i = 0
while i < len(store):
	count = 1
	while i + 1 < len(store) and store[i + 1] >= store[i]:
		count += 1
		i += 1
	else:
		i += 1
	if count > maxPos:
		maxPos = count
print(maxPos)


a = int(input())
num_list = [int(i) for i in list(input('').split(' '))]
current_max_len = 0
prev_num = -999999
max_list = []
for num in num_list:
	if prev_num <= num:
		current_max_len += 1
	else:
		max_list.append(current_max_len)
		current_max_len = 1
	prev_num = num
max_list.append(current_max_len)
print(max(max_list))


N = int(input())
X = [int(x) for x in input().split()]
n = 0
i = 0
x = 1
while i < N - 1:
	if X[i] <= X[i + 1]:
		x = x + 1
		if n < x:
			n = x
	else:
		x = 1
	i += 1
if n < x:
	n = x
print(n)


n = int(input())
c = list(map(int, input().split()))
ms = 1
ans = 1
for i in range(1, n):
	if c[i] >= c[i - 1]:
		ms += 1
	if c[i] < c[i - 1] or i == n - 1:
		ans = max(ms, ans)
		ms = 1
print(ans)


n = int(input())
a = tuple(map(int, input().split()))
max_lenght = 0
i = 0
lenght = 0
while i < len(a) - 1:
	if a[i] <= a[i + 1]:
		lenght = lenght + 1
	else:
		lenght = 0
	if lenght >= max_lenght:
		max_lenght = lenght
	i = i + 1
if max_lenght > 0:
	max_lenght = max_lenght + 1
if max_lenght > 1:
	print(max_lenght)
else:
	print('1')


n = int(input())
arr = [int(a) for a in input().split()]
max = 1
curr = 1
i = 1
while i < n:
	if arr[i] >= arr[i - 1]:
		curr = curr + 1
	else:
		curr = 1
	if max < curr:
		max = curr
	i = i + 1
print(max)


num = int(input())
a = list(map(int, input().split()))
b = []
count = 0
m = i = 0
while i < num:
	if a[i] >= m:
		count += 1
		m = a[i]
		i += 1
	else:
		b += [count]
		count = 0
		m = 0
b += [count]
print(max(b))


length = int(input())
k = [int(a) for a in input().split()]
segments = []
count = 1
for numb in range(1, length):
	if k[numb] >= k[numb - 1]:
		count += 1
	else:
		segments.append(count)
		count = 1
segments.append(count)
print(max(segments))


n = int(input().strip())
a = [int(_) for _ in input().strip().split()]
lis = [1] * n
for i in range(1, n):
	if a[i] >= a[i - 1]:
		lis[i] += lis[i - 1]
print(max(lis))


a = int(input())
x = [int(x) for x in input().split()]
count = 1
z = len(x) - 1
l = []
y = ''
for i in range(z):
	j = i + 1
	if x[i] <= x[j]:
		count += 1
	else:
		l.append(count)
		count = 1
l.append(count)
if len(l) == 1:
	for i in l:
		print(str(i))
else:
	l.sort(reverse=True)
	for i in l:
		print(str(i))
		break


nums = int(input())
numList = list(map(int, input().split()))
nonDecreasingSeg = 1
nonDecreasingSegList = []
startingPoint = numList[0]
for i in range(1, len(numList)):
	if numList[i] >= startingPoint:
		nonDecreasingSeg += 1
	else:
		nonDecreasingSegList.append(nonDecreasingSeg)
		nonDecreasingSeg = 1
	startingPoint = numList[i]
nonDecreasingSegList.append(nonDecreasingSeg)
print(max(nonDecreasingSegList))


z = int(input())
a = [int(x) for x in input().split()]
curr = 1
maxi = 1
for i in range(1, z):
	if a[i - 1] <= a[i]:
		curr += 1
		if curr > maxi:
			maxi = curr
	else:
		curr = 1
print(maxi)


n = int(input())
array = list(map(int, input().split(' ')))
max_c = 0
cur_c = 1
for i in range(1, n):
	if array[i] >= array[i - 1]:
		cur_c += 1
	else:
		max_c = max(cur_c, max_c)
		cur_c = 1
max_c = max(cur_c, max_c)
print(max_c)


n = int(input())
a = [int(x) for x in input().split()]
temp = 0
count = 0
for i in range(n - 1):
	if a[i + 1] >= a[i]:
		temp += 1
	else:
		count = max(temp, count)
		temp = 0
count = max(temp, count)
print(count + 1)


n = int(input())
l = list(map(int, input().split(' ')))
k = 0
m = 0
for i in range(n - 1):
	if l[i] <= l[i + 1]:
		k = k + 1
	if k > m:
		m = k
	if l[i] > l[i + 1]:
		k = 0
print(m + 1)


n = int(input())
int_list = list(map(int, input().split()))
ans = 1
max_count = 1
for i in range(len(int_list) - 1):
	if int_list[i] <= int_list[i + 1]:
		ans += 1
		if ans > max_count:
			max_count = ans
	else:
		ans = 1
print(max_count)


input()
l = list(map(int, input().split()))
c = r = 1
for i in range(0, len(l) - 1):
	x = l[i + 1] < l[i]
	c = (c + 1) * (1 - x) + x
	r = max(r, c)
print(r)


n = int(input())
l = input().split()
length = 1
ml = 1
for i in range(n - 1):
	if int(l[i]) > int(l[i + 1]):
		if length > ml:
			ml = length
		length = 1
	else:
		length += 1
if length > ml:
	ml = length
print(ml)


n = int(input())
a = [int(i) for i in input().split()]
k = 1
km = 1
x = a[0]
for i in range(1, len(a)):
	if x <= a[i]:
		k += 1
		if k > km:
			km = k
	else:
		k = 1
	x = a[i]
print(km)


integers = int(input())
sequence = input().split(' ')
sequence = [int(i) for i in sequence]
count = 1
segments = []
if len(sequence) == 1:
	segments.append(1)
else:
	for i in range(integers - 1):
		if sequence[i + 1] >= sequence[i]:
			count += 1
		else:
			segments.append(count)
			count = 1
		segments.append(count)
print(max(segments))


num = int(input())
l = [int(x) for x in input().split()]
n = l[0]
li = [1] * num
for x in range(1, num):
	if l[x] >= n:
		li[x] = li[x - 1] + 1
	n = l[x]
print(max(li))


from sys import stdin
input = stdin.readline
n = int(input())
arr = list(map(int, input().split()))
ss = 0
ml = 1
for (i, x) in enumerate(arr):
	if x < arr[i - 1]:
		ml = max(ml, i - ss)
		ss = i
	elif i == n - 1:
		ml = max(ml, i - ss + 1)
print(ml)


n = int(input())
s = list(map(int, input().split()))
mx = set()
su = 1
if n == 1:
	mx.add(su)
else:
	for i in range(n - 1):
		if s[i] <= s[i + 1]:
			su += 1
			if i == n - 2:
				mx.add(su)
		else:
			mx.add(su)
			su = 1
print(max(mx))


n = int(input())
arr = [int(x) for x in input().split()]
m = 1
mmax = 1
i = 1
while i < n:
	if arr[i] >= arr[i - 1]:
		m += 1
		if m > mmax:
			mmax = m
	else:
		m = 1
	i += 1
print(mmax)


s = int(input())
srr = list(map(int, input().split()))
cnt = 1
maxx = 1
for i in range(s - 1):
	if srr[i] <= srr[i + 1]:
		cnt += 1
	else:
		cnt = 1
	maxx = max(maxx, cnt)
print(maxx)


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

def subArr(arr, n):
	(m, l) = (1, 1)
	for i in range(1, n):
		if arr[i] >= arr[i - 1]:
			l = l + 1
		else:
			if m < l:
				m = l
			l = 1
	if m < l:
		m = l
	return m
print(subArr(a, n))


input()
p = -1
ans = 0
ln = 0
for x in map(int, input().split()):
	if x >= p:
		ln += 1
	else:
		ln = 1
	p = x
	ans = max(ans, ln)
print(ans)


def max_non_decreasing_sub_segment():
	start = end = 0
	res = 1
	for i in range(len(a) - 1):
		if a[i] <= a[i + 1]:
			end += 1
			temp = end - start + 1
			if temp > res:
				res = temp
		else:
			temp = end - start + 1
			if temp > res:
				res = temp
			start = i
			end = i
	return res
n = int(input())
a = list(map(int, input().split(' ')))
print(max_non_decreasing_sub_segment())


section = input()
inputLine = input()
inputList = inputLine.split(' ')
counter = 1
memory = counter
for i in range(0, int(section) - 1):
	if int(inputList[i]) > int(inputList[i + 1]):
		counter = 1
	else:
		counter += 1
		if counter > memory:
			memory = counter
print(memory)


input()
a = [int(x) for x in input().split()]
m = cnt = 1
k = a[0]
for l in a[1:]:
	if k <= l:
		cnt += 1
	else:
		cnt = 1
	m = cnt if m < cnt else m
	k = l
print(m)


def solution(a):
	m = 0
	maxi = a[0]
	c = 0
	for i in range(len(a)):
		if a[i] >= maxi:
			maxi = a[i]
			c += 1
		else:
			maxi = a[i]
			c = 1
		if c >= m:
			m = c
	print(m)
n = int(input(''))
a = list(map(int, input('').split()))
solution(a)


n = int(input())
seq = [int(x) for x in input().split()]
(starts, ends) = ([], [])
for i in range(0, len(seq)):
	if len(seq) == 1:
		(starts, ends) = ([0], [0])
		break
	elif i == 0:
		if seq[i + 1] >= seq[i]:
			starts.append(i)
	elif i == n - 1:
		if seq[i - 1] <= seq[i]:
			ends.append(i)
	elif seq[i + 1] >= seq[i] and seq[i - 1] <= seq[i]:
		continue
	elif seq[i + 1] >= seq[i]:
		starts.append(i)
	elif seq[i - 1] <= seq[i]:
		ends.append(i)
	else:
		starts.append(0)
		ends.append(0)
print(max([ends[x] - starts[x] + 1 for x in range(0, len(starts))]))


x = int(input())
k = list(map(int, input().strip().split(' ')))
maxx = 0
a = 0
for i in range(x - 1):
	if k[i] <= k[i + 1]:
		a = a + 1
	else:
		a = 0
	if a > maxx:
		maxx = a
print(maxx + 1)


y = input()
y = [int(s) for s in input().split()]
z = 0
h = []
for i in range(len(y) - 1):
	if y[i] <= y[i + 1]:
		z += 1
	else:
		h.append(z)
		z = 0
h.append(z)
print(max(h) + 1)


n = int(input())
m = [int(i) for i in input().split()]
MAX = [1]
num = 1
for i in range(n - 1):
	if m[i] <= m[i + 1]:
		num += 1
	else:
		num = 1
	MAX.append(num)
print(max(MAX))


n = int(input())
a = list(map(int, input().split()))
i = 0
e = 1
j = []
if len(a) == 1:
	print(1)
	quit()
while i != n - 1:
	x = a[i]
	y = a[i + 1]
	if y >= x:
		e += 1
		j.append(int(e))
	else:
		e = 1
		j.append(int(e))
	i += 1
print(max(j))


n = int(input())
a = list(map(int, input().split()))
maxL = 0
curL = 1
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		curL += 1
	else:
		if curL > maxL:
			maxL = curL
		curL = 1
if curL > maxL:
	maxL = curL
print(maxL)


n = int(input())
a = list(map(int, input().split()))
count = 1
increment = []
if len(a) == 1:
	print(1)
else:
	for i in range(len(a)):
		if i > 0:
			if i == len(a) - 1 and a[i] >= a[i - 1]:
				increment.append(count + 1)
			if a[i] >= a[i - 1]:
				count += 1
			else:
				increment.append(count)
				count = 1
	print(max(increment))


useless = input()

def nonDecreasingLength(numbers):
	last = -1
	maxlength = 1
	length = 0
	for i in numbers:
		if int(i) < int(last):
			maxlength = max(int(length), int(maxlength))
			length = 0
		last = i
		length += 1
	return max(int(maxlength), int(length))
print(nonDecreasingLength(input().split(' ')))


n = int(input())
s = list(map(int, input().split(' ')))
(nmax, maxss, cmaxss) = (0, 0, 0)
for x in s:
	if x >= nmax:
		nmax = x
		cmaxss = cmaxss + 1
		if cmaxss > maxss:
			maxss = cmaxss
	else:
		cmaxss = 1
		nmax = x
print(maxss)


n = int(input())
arr = list(map(int, input().split()))
(a, b, m) = (0, 0, 0)
for i in arr:
	if i >= b:
		m += 1
	else:
		m = 1
	a = max(a, m)
	b = i
print(a)


input()
max_seq = cur_seq = prev_el = 0
for el in map(int, input().split()):
	cur_seq = [cur_seq + 1, 1][el < prev_el]
	prev_el = el
	max_seq = max(max_seq, cur_seq)
print(max_seq)


t = int(input())
k = list(map(int, input().split()))
c = 1
temp = 1
for i in range(t - 1):
	if k[i] <= k[i + 1]:
		temp += 1
	else:
		temp = 1
	c = max(c, temp)
print(c)


n = int(input())
nums = list(map(int, input().strip().split()))
arr = [1] * n
for i in range(1, n):
	if nums[i - 1] <= nums[i]:
		arr[i] = 1 + arr[i - 1]
max1 = arr[0]
for i in range(1, n):
	if arr[i] > max1:
		max1 = arr[i]
print(max1)


n = int(input())
a = list(map(int, input().split()))
count = 1
reslist = []
for i in range(1, n):
	if int(a[i]) >= int(a[i - 1]):
		count += 1
	else:
		reslist.append(count)
		count = 1
reslist.append(count)
reslist.sort()
print(reslist[-1])


n = int(input())
a = list(map(int, input().split()))
res = 0
ans = []
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		res += 1
	else:
		ans.append(res + 1)
		res = 0
ans.append(res + 1)
print(max(ans))


n = int(input())
arr = list(map(int, input().split()))
maxCount = 1
pCount = 0
prev = arr[0]
for i in arr:
	if i >= prev:
		pCount += 1
		maxCount = max(pCount, maxCount)
	else:
		pCount = 1
	prev = i
print(maxCount)


n = int(input())
salary = [int(x) for x in input().split()]
ha = 0
day = 1
for i in range(1, n):
	if salary[i] - salary[i - 1] >= 0:
		day += 1
		ha = max(day, ha)
	else:
		day = 1
b = int(ha)
if b == 0:
	print(1)
else:
	print(b)


n = int(input())
a = [int(a) for a in input().strip().split(' ')]
(i, mx) = (0, 1)
while i < n:
	j = i + 1
	while j < n:
		if a[j] < a[j - 1]:
			break
		j += 1
	mx = max(mx, j - i)
	i = j
print(mx)


n = int(input())
all = list(map(int, input().split()))
non = 1
res = 1
for i in range(n - 1):
	if all[i] <= all[i + 1]:
		non += 1
		res = max(non, res)
	else:
		non = 1
print(res)


n = int(input())
a = [int(i) for i in input().split()]
max = 1
MAX = 1
for i in range(len(a) - 1):
	if a[i + 1] >= a[i]:
		max += 1
		if MAX < max:
			MAX = max
	else:
		max = 1
print(MAX)


n = int(input())
a = list(map(lambda x: int(x), input().split(' ')))
i = 0
ans = 0
while i < n:
	j = i
	while j + 1 < n and a[j + 1] >= a[j]:
		j += 1
	ans = max(ans, j - i + 1)
	i = j + 1
print(ans)


n = input()
d = input()
d = d.split(' ')
streak = [0]
s = 0
for el in range(1, len(d)):
	try:
		if int(d[s]) <= int(d[el]):
			streak.append(streak[-1] + 1)
		else:
			streak.append(0)
		s += 1
	except:
		pass
print(max(streak) + 1)


n = int(input())
a = [0 for i in range(100000)]
s = input()
i = 0
t = 0
while i < len(s):
	if i == len(s):
		break
	if s[i] == ' ':
		i += 1
	else:
		x = ''
		while s[i] != ' ' and i < len(s):
			x = x + s[i]
			i += 1
			if i >= len(s):
				break
		a[t] = int(x)
		t += 1
i = 0
l = 1
length = 1
while i < n - 1:
	if a[i + 1] >= a[i]:
		length += 1
		i += 1
	else:
		length = 1
		i += 1
	if length > l:
		l = length
print(l)


n = int(input())
s = input().split()
a = []
f = []
ans = 1
m = 1
for i in range(n):
	a.append(int(s[i]))
for i in range(1, n):
	if a[i] >= a[i - 1]:
		ans += 1
		if ans > m:
			m = ans
	else:
		if ans > m:
			m = ans
		ans = 1
print(m)


(n, a) = (int(input()), list(map(int, input().split())))
strike = 1
max_strike = 1
for i in range(n - 1):
	if a[i + 1] < a[i]:
		strike = 1
	else:
		strike += 1
		max_strike = strike if strike > max_strike else max_strike
print(max_strike)


n = int(input())
nl = list(map(int, input().strip().split(' ')))
(j, c, mc) = (nl[0], 0, 0)
for i in range(len(nl)):
	if nl[i] >= j:
		j = nl[i]
		c = c + 1
		if c > mc:
			mc = c
	else:
		j = nl[i]
		c = 1
		if c > mc:
			mc = c
print(mc)


n = int(input())
lst = input().split()
c = 1
p = []
o = []
for j in range(0, n):
	o.append(int(lst[j]))
o.append(0)
l = len(o)
for i in range(0, l - 1):
	if o[i + 1] >= o[i]:
		c = c + 1
	else:
		p.append(c)
		c = 1
a = max(p)
print(a)


import collections as cc
import sys
I = lambda : list(map(int, input().split()))
(n,) = I()
l = I()
ans = 0
k = 1
temp = l[0]
for i in range(1, n):
	if l[i] >= temp:
		k += 1
		temp = l[i]
	else:
		ans = max(ans, k)
		k = 1
		temp = l[i]
ans = max(ans, k)
print(ans)


n = int(input())
a = [int(i) for i in input().split()]
c = 1
new = []
for i in range(n):
	if i == n - 1:
		break
	if a[i] <= a[i + 1]:
		c += 1
	else:
		new.append(c)
		c = 1
new.append(c)
a = new[0]
for i in range(len(new)):
	if new[i] > a:
		a = new[i]
print(a)


n = int(input())
s = list(map(int, input().split()))
res = 1
counter = 1
for i in range(n - 1):
	if s[i + 1] >= s[i]:
		counter += 1
	else:
		counter = 1
	if counter > res:
		res = counter
print(res)


input()
count = _max = last = 0
for val in map(int, input().split()):
	count = [count + 1, 1][val < last]
	_max = max(_max, count)
	last = val
print(_max)


n = int(input())
li = list(map(int, input().split(' ')))
k = 1
km = 1
for i in range(n - 1):
	if li[i] <= li[i + 1]:
		k += 1
		if km < k:
			km = k
	else:
		k = 1
print(km)


n = int(input())
t = [int(x) for x in input().split(' ')]
s = [0] * len(t)
j = 0
for i in range(1, n):
	if t[i - 1] <= t[i]:
		s[j] = s[j] + 1
	else:
		j = j + 1
print(max(s) + 1)


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

def max_arr(a):
	next_list = []
	maxi = 0
	next_list.append(a[0])
	for i in range(len(a) - 1):
		if a[i + 1] >= a[i]:
			next_list.append(a[i + 1])
		else:
			maxi = max(len(next_list), maxi)
			next_list = []
			next_list.append(a[i + 1])
	return max(len(next_list), maxi)
print(max_arr(a))


import sys
n = int(input())
a = list(map(int, sys.stdin.readline().split()))
i = 0
res = 0
while i < n:
	j = i
	while j + 1 < n and a[j] <= a[j + 1]:
		j += 1
	res = max(res, j - i + 1)
	i = j + 1
print(res)


n = int(input())
a = list(map(int, input().split()))
i = 1
res = 0
cnt = 1
while i < n:
	if a[i] < a[i - 1]:
		res = max(res, cnt)
		cnt = 1
	else:
		cnt += 1
	i += 1
res = max(res, cnt)
print(res)


n = int(input())
arr = map(int, input().split())
last_x = None
sub = 0
max_sub = None
for x in arr:
	if last_x is not None:
		if x >= last_x:
			sub += 1
		else:
			if max_sub is None or sub > max_sub:
				max_sub = sub
			sub = 1
	else:
		sub += 1
	last_x = x
if max_sub is None or sub > max_sub:
	max_sub = sub
print(max_sub)


n = int(input())
event = input().split(' ')
count_list = []
count = 1
for i in range(0, len(event) - 1):
	if int(event[i]) <= int(event[i + 1]):
		count = count + 1
	else:
		count_list.append(count)
		count = 1
count_list.append(count)
print(max(count_list))


n = int(input())
seq = list(map(int, input().split(' ')))
now = 0
current = 0
biggest = 0
for i in range(n):
	if seq[i] >= now:
		now = seq[i]
		current += 1
		if current > biggest:
			biggest = current
	else:
		current = 1
		now = seq[i]
print(biggest)


n = int(input(''))
data = list(map(int, input('').split(' ')))
prevcount = 1
count = 1
for i in range(len(data) - 1):
	if data[i] <= data[i + 1]:
		count += 1
		if prevcount < count:
			prevcount += 1
		else:
			pass
	else:
		count = 1
print(prevcount)


l = int(input())
d = [int(x) for x in input().split(' ')]
res = 0
if d == sorted(d):
	res = l
else:
	ans = 1
	for x in range(1, len(d)):
		if d[x] >= d[x - 1]:
			ans += 1
		elif d[x] < d[x - 1]:
			if ans > res:
				res = ans
			ans = 1
		if x == len(d) - 1:
			if ans > res:
				res = ans
print(res)


input()
arr = list(map(int, input().split()))
best = 0
curr = 1
prev = arr[0]
for e in arr[1:]:
	if e >= prev:
		curr += 1
	else:
		best = max(curr, best)
		curr = 1
	prev = e
print(max(best, curr))


n = input()
ls = input().split()
a = 1
m = 1
for i in range(int(n) - 1):
	if int(ls[i]) <= int(ls[i + 1]):
		a += 1
	elif int(ls[i]) > int(ls[i + 1]):
		a = 1
	if a > m:
		m = a
print(m)


def proA(arr):
	i = 0
	maxi = 0
	while i < len(arr):
		c = 1
		j = i + 1
		while j < len(arr):
			if arr[j - 1] <= arr[j]:
				j += 1
				c += 1
			else:
				break
		i = j
		maxi = max(maxi, c)
	return maxi
n = int(input())
arr = list(map(int, input().split()))
print(proA(arr))


def fact(x):
	if x == 0:
		return 1
	else:
		return x * fact(x - 1)

def lower_bound(li, num):
	answer = len(li) - 1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] >= num:
			answer = middle
			end = middle - 1
		else:
			start = middle + 1
	return answer

def upper_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] <= num:
			answer = middle
			start = middle + 1
		else:
			end = middle - 1
	return answer

def abs(x):
	return x if x >= 0 else -x

def binary_search(li, val, lb, ub):
	ans = 0
	while lb <= ub:
		mid = (lb + ub) // 2
		if li[mid] > val:
			ub = mid - 1
		elif val > li[mid]:
			lb = mid + 1
		else:
			ans = 1
			break
	return ans

def sieve_of_eratosthenes(n):
	ans = []
	arr = [1] * (n + 1)
	(arr[0], arr[1], i) = (0, 0, 2)
	while i * i <= n:
		if arr[i] == 1:
			j = i + i
			while j <= n:
				arr[j] = 0
				j += i
		i += 1
	for k in range(n):
		if arr[k] == 1:
			ans.append(k)
	return ans

def nc2(x):
	if x == 1:
		return 0
	else:
		return x * (x - 1) // 2

def kadane(x):
	sum_so_far = 0
	current_sum = 0
	for i in x:
		current_sum += i
		if current_sum < 0:
			current_sum = 0
		else:
			sum_so_far = max(sum_so_far, current_sum)
	return sum_so_far

def mex(li):
	check = [0] * 1001
	for i in li:
		check[i] += 1
	for i in range(len(check)):
		if check[i] == 0:
			return i

def sumdigits(n):
	ans = 0
	while n != 0:
		ans += n % 10
		n //= 10
	return ans

def product(li):
	ans = 1
	for i in li:
		ans *= i
	return ans

def maxpower(n, k):
	cnt = 0
	while n > 1:
		cnt += 1
		n //= k
	return cnt

def knapsack(li, sumi, s, n, dp):
	if s == sumi // 2:
		return 1
	elif n == 0:
		return 0
	elif dp[n][s] != -1:
		return dp[n][s]
	else:
		if li[n - 1] <= s:
			dp[n][s] = knapsack(li, sumi, s - li[n - 1], n - 1, dp) or knapsack(li, sumi, s, n - 1, dp)
		else:
			dp[n][s] = knapsack(li, sumi, s, n - 1, dp)
		return dp[n][s]
from math import *
from collections import deque
max_steps = 100005
for _ in range(1):
	n = int(input())
	a = list(map(int, input().split()))
	(check, cnt) = (a[0], 0)
	ans = 0
	for i in range(n):
		if a[i] >= check:
			cnt += 1
		if a[i] < check or i == n - 1:
			ans = max(ans, cnt)
			cnt = 1
		check = a[i]
	print(ans)


n = int(input())
s = [int(i) for i in input().split()]
next_max = 1
last_max = 0
for i in range(n - 1):
	if last_max < next_max:
		last_max = next_max
	if s[i] <= s[i + 1]:
		next_max += 1
	else:
		next_max = 1
print(max(last_max, next_max))


_ = input()
nums = list(map(int, input().split()))
max_len = i = 0
while i < len(nums):
	current = nums[i]
	sub_len = 1
	for j in range(i + 1, len(nums)):
		if current > nums[j]:
			break
		current = nums[j]
		sub_len += 1
	max_len = max(max_len, sub_len)
	i += sub_len
print(max_len)


n = int(input())
money = list(map(int, input().split()))
current = 1
max = 1
for i in range(len(money) - 1):
	if money[i + 1] >= money[i]:
		current += 1
	else:
		current = 1
	if current > max:
		max = current
print(max)


t = int(input())
A = [int(x) for x in input().split()]
max = -2 ** 32
prev = -1
len = 0
for element in A:
	if element >= prev:
		prev = element
		len += 1
	else:
		len = 1
		prev = element
	if len > max:
		max = len
print(max)


arr_len = int(input())
arr = list(map(int, input().split()))
all_len = []
curr_len = 1
curr_elem = arr[0]
for k in range(1, arr_len):
	if arr[k] >= curr_elem:
		curr_len += 1
		curr_elem = arr[k]
	else:
		all_len.append(curr_len)
		curr_len = 1
		curr_elem = arr[k]
all_len.append(curr_len)
w = curr_len if len(all_len) == 0 else max(all_len)
print(w)


import sys

def main():
	lines = sys.stdin.readlines()
	n = int(lines[0].strip())
	a = [int(x) for x in lines[1].split()]
	max_seq = 1
	cur_seq = 1
	for i in range(1, n):
		if a[i] >= a[i - 1]:
			cur_seq += 1
		else:
			cur_seq = 1
		max_seq = max(cur_seq, max_seq)
	print(max_seq)
main()


n = int(input())
seg = list(map(int, input().split()))
c = 0
best_c = 0
for i in range(len(seg) - 1):
	if seg[i + 1] >= seg[i]:
		c += 1
	else:
		if c > best_c:
			best_c = c
		c = 0
print(max(best_c, c) + 1)


nStr = input()
n = int(nStr)
if n == 1:
	print(1)
	quit()
lineStr = input()
line = lineStr.split()
income = [0] * n
for i in range(n):
	income[i] = int(line[i])
increase = 1
increaseMax = 1
for i in range(n - 1):
	if income[i + 1] >= income[i]:
		increase = increase + 1
		if increase > increaseMax:
			increaseMax = increase
	else:
		increase = 1
print(increaseMax)


n = int(input())
l = list(map(int, input().split()))
temp = 1
max1 = 1
for i in range(n - 1):
	if l[i] <= l[i + 1]:
		temp += 1
	else:
		temp = 1
	if temp > max1:
		max1 = temp
print(max1)


n = int(input())
a = [int(x) for x in input().split(' ')]
(maxLen, currLen) = (1, 1)
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		currLen += 1
	else:
		if currLen > maxLen:
			maxLen = currLen
		currLen = 1
if currLen > maxLen:
	maxLen = currLen
print(maxLen)


n = int(input())
x = list(map(int, input().split()))
y = []
y.append(x[0])
k = 1
for i in range(1, len(x)):
	if x[i - 1] <= x[i]:
		y.append(x[i])
		k = max(k, len(y))
	else:
		y = []
		y.append(x[i])
		k = max(k, len(y))
print(k)


n = int(input())
sequence = input().split()
sequence = [int(x) for x in sequence]
length = 1
maxlength = 1
for i in range(len(sequence) - 1):
	if sequence[i] <= sequence[i + 1]:
		length += 1
		maxlength = max(maxlength, length)
	else:
		length = 1
print(maxlength)


n = int(input())
list_a = list(map(int, input().split()))
list_non_decreasing = [1]
counter = 1
if len(list_a) == 1:
	print(1)
else:
	for x in range(n - 1):
		if list_a[x + 1] >= list_a[x]:
			counter += 1
			if x == n - 2:
				list_non_decreasing.append(counter)
		else:
			list_non_decreasing.append(counter)
			counter = 1
	print(max(list_non_decreasing))


n = int(input())
maxlen = 1
Len = 1
arr = [int(i) for i in input().split()]
for i in range(len(arr) - 1):
	if arr[i] <= arr[i + 1]:
		Len += 1
	else:
		if Len > maxlen:
			maxlen = Len
		Len = 1
if Len > maxlen:
	maxlen = Len
print(maxlen)


t = int(input())
s = list(map(int, input().split()))
mark = 1
maxim = 1
for i in range(1, t):
	if s[i] >= s[i - 1]:
		mark += 1
	else:
		if mark > maxim:
			maxim = mark
		mark = 1
if mark > maxim:
	maxim = mark
print(maxim)


n = int(input())
arr = list(map(int, input().split()))
max_global = 1
val = 1
for i in range(n - 1):
	if arr[i] <= arr[i + 1]:
		val = val + 1
		if val > max_global:
			max_global = val
	else:
		val = 1
print(max_global)


x = input()
n = m = l = 0
for i in map(int, input().split()):
	if i < n:
		if l > m:
			m = l
		l = 1
	else:
		l += 1
	n = i
print(max(l, m))


n = int(input())
s = list(map(int, input().split()))
m = 0
q = [0]
for i in range(1, n):
	if s[i] >= s[i - 1]:
		m += 1
	else:
		m = 0
	q.append(m)
q.sort()
print(q[-1] + 1)


l = int(input())
arr = list(map(lambda x: int(x), input().split(' ')))
mi = 1
curr = arr[0]
currI = 1
i = 1
while i < l:
	if arr[i] >= curr:
		currI += 1
	else:
		currI = 1
	curr = arr[i]
	mi = max(mi, currI)
	i += 1
print(mi)


length = int(input())
input_string_list = list(map(int, input().split()))
length_list = []
length_list.append(1)
for i in range(length - 1):
	if input_string_list[i] <= input_string_list[i + 1]:
		length_list[-1] += 1
	else:
		length_list.append(1)
print(max(length_list))


n = int(input())
prev = 10 ** 9 + 1
(ans, cum) = (1, 0)
arr = list((int(v) for v in input().split()))
for a in arr:
	cum = cum + 1 if a >= prev else 1
	ans = max(ans, cum)
	prev = a
print(ans)


n = int(input())
k = [int(i) for i in input().split()]
cont = 0
times = 1
bigger = 1
for i in k:
	if cont != 0:
		if k[cont - 1] <= i:
			times += 1
			if times >= bigger:
				bigger = times
		else:
			if times >= bigger:
				bigger = times
			times = 1
	elif cont == 0:
		times = 1
		bigger = 1
	cont += 1
print(bigger)


def lis(arr, n):
	m = 1
	l = 1
	for i in range(1, n):
		if arr[i] >= arr[i - 1]:
			l += 1
		else:
			if m < l:
				m = l
			l = 1
	if m < l:
		m = l
	return m
n = int(input())
arr = list(map(int, input().split()))
ans = lis(arr, n)
print(ans)


n = int(input())
l = [int(i) for i in input().split()]
cnt = 1
mxcnt = 0
for i in range(n):
	if i < n - 1 and l[i] <= l[i + 1]:
		cnt += 1
	else:
		mxcnt = max(cnt, mxcnt)
		cnt = 1
print(mxcnt)


n = int(input())
a = [int(i) for i in input().split()]
cnt = mx = 1
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		cnt += 1
	else:
		mx = max(mx, cnt)
		cnt = 1
print(max(cnt, mx))


n = int(input())
mx = 1
arr = list(map(int, input().split()))
curr = 1
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		curr += 1
		if curr > mx:
			mx = curr
	else:
		curr = 1
print(mx)


from sys import stdin

def main():
	n = int(stdin.readline())
	cad = [int(i) for i in stdin.readline().strip().split()]
	vacia = []
	(i, j, cont) = (0, 1, 1)
	while j != len(cad):
		if cad[i] <= cad[j]:
			cont += 1
		else:
			vacia.append(cont)
			cont = 1
		j += 1
		i += 1
	vacia.append(cont)
	print(max(vacia))
main()


n = int(input())
nums = list(map(int, input().split()))
total = 0
last = nums[0]
segment = 0
for i in range(len(nums) - 1):
	next = nums[i + 1]
	if next >= nums[i]:
		segment += 1
	else:
		segment = 0
	total = max(segment, total)
print(total + 1)


input()
a = list(map(int, input().split()))
ans = -1
cur = 1
for i in range(len(a) - 1):
	if a[i] > a[i + 1]:
		ans = max(ans, cur)
		cur = 1
		continue
	cur += 1
ans = max(ans, cur)
print('{}'.format(ans if ans != -1 else len(a)))


days = int(input())
money = input()
amount = money.split(' ')
maximum = [0]
x = 0
while x < len(amount):
	item = x + 1
	while item < len(amount):
		if int(amount[item]) < int(amount[item - 1]):
			break
		item += 1
	maximum.append(item - x)
	x = item
print(max(maximum))


n = int(input())
array = list(map(int, input().split()))
ma = 0
temp = 1
for i in range(n - 1):
	if array[i] > array[i + 1]:
		if temp > ma:
			ma = temp
		temp = 1
	else:
		temp += 1
if temp > ma:
	ma = temp
print(ma)


daysNum = int(input())
money = input()
moneysequence = money.split()
counter = 1
bestsequence = 1
for i in range(daysNum):
	moneysequence[i] = int(moneysequence[i])
for i in range(1, daysNum):
	if moneysequence[i] >= moneysequence[i - 1]:
		counter += 1
		if counter > bestsequence:
			bestsequence = counter
	else:
		counter = 1
print(bestsequence)


n = int(input())
l = list(map(int, input().split()))
(max_i, i) = (1, 1)
for x in range(n - 1):
	if l[x] <= l[x + 1]:
		i += 1
	else:
		if i > max_i:
			max_i = i
		i = 1
	if i > max_i:
		max_i = i
print(max_i)


n = int(input())
num = [int(x) for x in input().split()]
list1 = [0]
for i in range(n):
	if num[i] < num[i - 1]:
		list1.append(i)
list1.append(n)
a = len(list1)
list2 = []
for j in range(a - 1):
	list2.append(list1[j + 1] - list1[j])
list2.sort()
if list2 == [0]:
	print(n)
else:
	print(list2[-1])


def find(l, li):
	maxim = 1
	count = 1
	for i in range(1, len(li)):
		if li[i] >= li[i - 1]:
			count = count + 1
		else:
			count = 1
		maxim = max(maxim, count)
	print(maxim)
l = int(input())
li = list(map(int, input().split()))
find(l, li)


a = input()
b = input().split(' ')
c = list(map(lambda x: int(x), b))
c.append(-1)
(counter, m) = (0, 0)
for i in range(len(c) - 1):
	if c[i] > c[i + 1]:
		if counter > m:
			m = counter
		counter = 0
	else:
		counter += 1
print(m + 1)


def lsa(arr, n):
	m = 1
	l = 1
	for i in range(1, n):
		if arr[i] >= arr[i - 1]:
			l = l + 1
		else:
			if m < l:
				m = l
			l = 1
	if m < l:
		m = l
	return m
length = int(input())
arr = list(map(int, input().split()))
max_nd_seq = lsa(arr, length)
print(max_nd_seq)


(n, sequence) = [list(map(int, input().split())) for _ in range(2)]
count = 0
maximum = 0
previous = sequence[0]
for i in sequence:
	if i >= previous:
		count += 1
		if count >= maximum:
			maximum = count
	else:
		count = 1
	previous = i
print(maximum)


n = int(input())
arr = [int(i) for i in input().split()]
max_len = 0
prev = arr[0] - 1
len_cur = 0
for i in arr:
	if i >= prev:
		len_cur += 1
	else:
		len_cur = 1
	if len_cur > max_len:
		max_len = len_cur
	prev = i
print(max_len)


n = int(input())
a = list(map(int, input().split()))
s = [1]
for i in range(1, n):
	s.append([1, s[i - 1] + 1][a[i] >= a[i - 1]])
print(max(s))


n = int(input())
a = [int(x) for x in input().split()]
num = []
b = 0
for i in range(n - 1):
	if a[i + 1] > a[i] or a[i + 1] == a[i]:
		b = b + 1
		num.append(b + 1)
	else:
		num.append(b + 1)
		b = 0
num.sort()
if len(a) == 1:
	num.append(1)
print(num[len(num) - 1])


n = int(input())
a = [int(i) for i in input().split()]
ans = [1]
co = 1
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		co += 1
	else:
		co = 1
	if co > ans[i - 1]:
		ans.append(co)
	else:
		ans.append(ans[i - 1])
print(ans[-1])


n = int(input())
arr = list(map(int, input().split()))
ans = -1
i = 1
prev = arr[0]
cnt = 1
while i < n:
	if arr[i] >= prev:
		cnt += 1
		if i + 1 < n:
			prev = arr[i]
			i += 1
		else:
			ans = max(ans, cnt)
			break
	else:
		ans = max(ans, cnt)
		cnt = 1
		prev = arr[i]
		if i + 1 < n:
			i += 1
		else:
			ans = max(ans, cnt)
			break
ans = max(ans, cnt)
print(ans)


n = int(input())
l = list(map(int, input().split()))
ans = 0
temp = 0
mini = 0
for shravan in l:
	if mini > shravan:
		temp = 0
	mini = shravan
	temp += 1
	ans = max(ans, temp)
print(ans)


a = int(input())
b = input().split(' ')
c = 0
d = 0
p = int(b[0])
for i in b:
	if int(i) >= p:
		d += 1
	else:
		c = max(c, d)
		d = 1
	p = int(i)
print(max(c, d))


n = int(input())
data = list(map(int, input().split()))
max_v = 1
curr = 1
for i in range(1, len(data)):
	if data[i] >= data[i - 1]:
		curr += 1
	else:
		if curr > max_v:
			max_v = curr
		curr = 1
if curr > max_v:
	max_v = curr
print(max_v)


from sys import stdin as sin
n = int(sin.readline())
l = list(map(int, sin.readline().split(' ')))
d = [1] * n
for i in range(n - 2, -1, -1):
	if l[i] <= l[i + 1]:
		d[i] += d[i + 1]
print(max(d))


n = int(input())
arr = list(map(int, input().split()))
(i, long, max_len) = (1, 1, 0)
while i < n:
	if arr[i] >= arr[i - 1]:
		long += 1
	else:
		max_len = max(long, max_len)
		long = 1
	i += 1
print(max(max_len, long))


def fun():
	n = int(input())
	l = list(map(int, input().split()))
	cnt = 0
	maxi = 0
	for i in range(len(l) - 1):
		if l[i] > l[i + 1]:
			if maxi < cnt:
				maxi = cnt
			cnt = 0
		else:
			cnt += 1
	if maxi < cnt:
		maxi = cnt
	maxi = maxi + 1
	print(maxi)
fun()


n = int(input())
(l, m) = (1, 1)
arr = [int(i) for i in input().split(' ')]
for i in range(n):
	if i > 0:
		if arr[i] >= arr[i - 1]:
			l += 1
			m = max(m, l)
		else:
			l = 1
print(m)


def read_array():
	x = []
	x1 = []
	x = input()
	x = x.split(' ')
	for r in range(len(x)):
		x1.append(int(x[r]))
	return x1

def bigset(x):
	big = 0
	max_big = 0
	for r in range(len(x) - 1):
		if x[r] <= x[r + 1]:
			big += 1
			if big > max_big:
				max_big = big
		else:
			big = 0
	return max_big + 1
input()
x = read_array()
print(bigset(x))


import math
n = int(input())
bulk = [0]
ncount = 1
seq = [int(x) for x in input().split()]
for i in range(n - 1):
	if seq[i] <= seq[i + 1] and ncount < n:
		ncount += 1
	else:
		bulk.append(ncount)
		ncount = 1
bulk.append(ncount)
print(max(bulk))


n = int(input())
s = list(map(int, input().split()))
max_d = pre = 1
for i in range(n - 1):
	if s[i] <= s[i + 1]:
		pre += 1
	else:
		max_d = max(max_d, pre)
		pre = 1
print(max(max_d, pre))


import math
n = int(input())
l = list(map(int, input().split()))
co = 0
r = 0
v = -1
for i in range(0, n, 1):
	if v <= l[i]:
		co += 1
	else:
		co = 1
	r = max(r, co)
	v = l[i]
print(r)


n = int(input())
l = [int(j) for j in input().split()]
counter = 1
m_counter = 1
for i in range(1, len(l)):
	if l[i] >= l[i - 1]:
		counter += 1
		if counter > m_counter:
			m_counter = counter
	else:
		counter = 1
print(m_counter)


n = int(input())
nn = input()
nnn = nn.split()
numbs = list(map(int, nnn))
max = 0
result = 0
for i in range(0, n - 1):
	if numbs[i] <= numbs[i + 1]:
		result += 1
		if result > max:
			max = result
	else:
		result = 0
print(max + 1)


n = int(input())
arr = list(map(int, input().split()))
p = arr[0]
fans = 1
tans = 1
for i in range(1, n):
	if p <= arr[i]:
		tans += 1
	else:
		fans = max(fans, tans)
		tans = 1
	p = arr[i]
fans = max(fans, tans)
print(fans)


n = int(input())
money = list(map(int, input().strip().split(' ')))
count = 0
i = 0
currc = 0
while i < n - 1:
	if money[i] <= money[i + 1]:
		currc += 1
	else:
		if count < currc + 1:
			count = currc + 1
		currc = 0
	i += 1
if count < currc + 1:
	count = currc + 1
print(count)


a = int(input())
b = [int(i) for i in input().split()]
count = 0
maxi = 0
for i in range(0, a - 1):
	if b[i + 1] >= b[i]:
		count = count + 1
	else:
		maxi = max(maxi, count)
		count = 0
maxi = max(maxi, count)
print(maxi + 1)


n = int(input())
a = [int(x) for x in input().split()]
k = a[0]
high = 1
highest = 1
count = 0
for i in range(1, n):
	if a[i] >= a[i - 1]:
		high += 1
		if high > highest:
			highest = high
	else:
		high = 1
print(highest)


n = int(input())
a = list(map(int, input().split()))
res = 0
prev = a[0]
cur = 0
for x in a:
	if x >= prev:
		cur += 1
	res = max(res, cur)
	if x < prev:
		cur = 1
	prev = x
print(res)


n = int(input())
x = [int(i) for i in input().split()]
num = 1
y = [1]
for i in range(n - 1):
	if x[1 + i] - x[i] >= 0:
		num += 1
		y.append(num)
	elif x[1 + i] - x[i] < 0:
		num = 1
		y.append(num)
print(max(y))


n = input()
length = 1
lens = []
money = list(map(int, input().split()))
if len(money) > 1:
	for i in range(len(money) - 1):
		if money[i] <= money[i + 1]:
			length += 1
			if i == len(money) - 2:
				lens.append(length)
		else:
			lens.append(length)
			length = 1
	print(max(lens))
else:
	print(length)


a = int(input())
mylist = list(map(int, input().split()))
sum = 0
max = 0
for i in range(a - 1):
	if mylist[i + 1] >= mylist[i]:
		sum += 1
	if sum > max:
		max = sum
	if mylist[i + 1] < mylist[i]:
		sum = 0
print(max + 1)


n = int(input())
l = list(map(int, input().rstrip().split()))
if n == 1:
	print(1)
	exit()
i = 0
curr = 1
maxl = 1
maxc = 0
while i < n and curr < n:
	if l[curr] >= l[curr - 1]:
		maxl += 1
		curr += 1
	else:
		maxc = max(maxc, maxl)
		maxl = 1
		i = curr
		curr += 1
print(max(maxl, maxc))


a = int(input())
b = list(map(int, input().split()))
c = 1
k = []
for i in range(a - 1):
	if b[i] <= b[i + 1]:
		c = c + 1
		continue
	else:
		k.append(c)
		c = 1
k.append(c)
print(max(k))


a = int(input())
l = input().split(' ')
res = [int(i) for i in l]
mx = 0
start = -1
finalmx = 0
for i in range(a):
	if res[i] >= start:
		mx = mx + 1
		start = res[i]
	else:
		start = res[i]
		finalmx = max(mx, finalmx)
		mx = 1
	if i == a - 1:
		finalmx = max(mx, finalmx)
print(finalmx)


N = int(input())
T = list(map(int, input().split(' ')))
L = []
cntr = 1
if N == 1:
	L.append(1)
else:
	for i in range(N - 1):
		if T[i + 1] >= T[i]:
			cntr += 1
			if i == N - 2:
				L.append(cntr)
		else:
			L.append(cntr)
			cntr = 1
a = L[0]
for elem in L:
	if elem >= a:
		a = elem
print(a)


def kefa_calculation(lst):
	longest = 1
	curr = 1
	for i in range(len(lst) - 1):
		if lst[i] <= lst[i + 1]:
			curr += 1
		else:
			curr = 1
		if curr > longest:
			longest = curr
	return longest

def main():
	length = int(input())
	series = [int(x) for x in input().split()]
	print(kefa_calculation(series))
main()


n = int(input())
list1 = list(map(int, input().split()))
count = 1
max = 1
for i in range(n - 1):
	j = i
	if list1[j] <= list1[j + 1]:
		count += 1
		if count > max:
			max = count
	else:
		count = 1
print(max)


n = int(input())
l = map(int, input().split())
m = -1
a = 0
ma = 0
for i in l:
	if i < m:
		ma = max(ma, a)
		a = 0
		m = -1
	if i >= m:
		a += 1
		m = i
print(max(ma, a))


n = int(input())
a = list(map(int, input().split()))
count = 0
m = 1
for i in range(0, n - 1):
	if a[i] <= a[i + 1]:
		count = count + 2 if count == 0 else count + 1
		m = max(m, count)
	else:
		count = 0
print(m)


from sys import stdin, stdout
t = int(stdin.readline())
l = [int(x) for x in stdin.readline().split()]
maxi = 0
count = 0
for i in range(1, t):
	if l[i] >= l[i - 1]:
		count += 1
		if count > maxi:
			maxi = count
	else:
		count = 0
print(maxi + 1)


a = input()
n = input().split()
cnt = 0
max_size = 0
i_l = 0
n = list(map(int, n))
for i in n:
	if i >= i_l:
		cnt += 1
		if max_size < cnt:
			max_size = cnt
	else:
		cnt = 1
	i_l = i
if max_size < cnt:
	max_size = cnt
print(max_size)


n = int(input())
l = list(map(int, input().split()))
(cnt, max) = (1, 0)
for j in range(1, n):
	if l[j] >= l[j - 1]:
		cnt += 1
	if l[j] < l[j - 1] or j == n - 1:
		if cnt > max:
			max = cnt
		cnt = 1
if max == 0:
	print(cnt)
else:
	print(max)


n = int(input())
L = input().split()
L = [int(i) for i in L]
A = [0] * n
count = [0] * n
for i in range(0, n - 1):
	if L[i] > L[i + 1]:
		A[i] = 1
if n == 1:
	print(1)
else:
	i = n - 2
	while i >= 0:
		count[n - 1] = 1
		if A[i] == 1:
			count[i] = 1
		else:
			count[i] = count[i + 1] + 1
		i -= 1
	print(max(count))


n = int(input())
if n == 1:
	x = int(input())
	print(1)
else:
	li = list(map(int, input().split()))
	cList = []
	c = 0
	flag = 0
	for i in range(1, n):
		if li[i - 1] <= li[i]:
			c += 1
			flag = 1
		else:
			cList.append(c + 1)
			c = 0
		if i == n - 1 and li[i - 1] <= li[i]:
			cList.append(c + 1)
	if flag:
		print(max(cList))
	else:
		print(1)


sanswer = 1
answer = 1
n = int(input())
x = list(map(int, input().split()))
for i in range(n - 1):
	if x[i] <= x[i + 1]:
		sanswer += 1
		if sanswer > answer:
			answer = sanswer
	else:
		sanswer = 1
print(answer)


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


n = int(input())
A = [int(x) for x in input().split()]
T = [1 for _ in range(n)]
for i in range(1, n):
	j = i - 1
	if A[j] <= A[i]:
		T[i] = T[j] + 1
print(max(T))


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
N = int(input())
A = [int(x) for x in input().split()]
ans = 0
p = float('-inf')
c = 0
for v in A:
	if v >= p:
		c += 1
	else:
		ans = max(ans, c)
		c = 1
	p = v
ans = max(ans, c)
print(ans)


n = int(input())
l = [int(x) for x in input().split()]
(m, s) = (1, 1)
for i in range(1, n):
	if l[i] >= l[i - 1]:
		s += 1
		if s > m:
			m = s
	else:
		s = 1
print(m)


n = int(input())
f = list(map(int, input().split()))
f.append(-1)
ma = 1
tmp = 1
for i in range(len(f) - 1):
	if f[i] <= f[i + 1]:
		tmp += 1
	else:
		if ma < tmp:
			ma = tmp
		tmp = 1
print(ma)


n = int(input())
A = [int(x) for x in input().split()]
L = [1] * n
for i in range(1, n):
	if A[i] >= A[i - 1]:
		L[i] = L[i - 1] + 1
print(sorted(L)[-1])


n = int(input())
nums = input().split()
num = [int(n) for n in nums]
count = 1
current_count = 1
for (i, a) in enumerate(num):
	if i > 0:
		if a >= num[i - 1]:
			current_count += 1
		else:
			current_count = 1
		if current_count > count:
			count = current_count
print(count)


n = int(input())
arr = input()
l = list(map(int, arr.split(' ')))
flag = 0
max2 = 0
for i in range(0, n - 1):
	if l[i] <= l[i + 1]:
		flag = flag + 1
		if flag > max2:
			max2 = flag
	else:
		if flag > max2:
			max2 = flag
		flag = 0
print(max2 + 1)


n = int(input())
li = list(map(int, input().split()))
cnt = 1
ans = 1
for i in range(1, n):
	if li[i] >= li[i - 1]:
		cnt += 1
	else:
		if cnt >= ans:
			ans = cnt
		cnt = 1
if cnt > ans:
	ans = cnt
print(ans)


n = int(input())
a = list(map(int, input().split()))
d = []
c = 1
if n == 1:
	print(1)
	quit()
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		c += 1
		d.append(c)
	else:
		d.append(c)
		c = 1
print(max(d))


n = int(input())
l = list(map(int, input().split()))
arr = [0 for _ in range(n)]
arr[0] = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		arr[i] = arr[i - 1] + 1
	else:
		arr[i] = 1
print(max(arr))


n = int(input())
list = [int(x) for x in input().split()]
long = 0
templ = 1
if len(list) == 1:
	print(1)
else:
	for i in range(n - 1):
		if list[i] <= list[i + 1]:
			templ += 1
			long = max(long, templ)
		else:
			templ = 1
	long = max(long, templ)
	print(long)


n = int(input())
a = list(map(int, input().split()))
col = 1
maxi = 0
for i in range(1, n):
	if a[i] >= a[i - 1]:
		col += 1
	maxi = max(col, maxi)
	if a[i] < a[i - 1]:
		col = 1
print(max(maxi, 1))


n = int(input())
aa = [int(x) for x in input().split(' ')]
prev = 0
maxLength = 0
length = 0
for a in aa:
	if a < prev:
		length = 1
	else:
		length += 1
		maxLength = max(length, maxLength)
	prev = a
print(maxLength)


n = int(input())
nums = list(map(int, input().split()))
(count, ans) = (1, 1)
for i in range(1, n):
	if nums[i] >= nums[i - 1]:
		count += 1
		ans = max(count, ans)
	else:
		count = 1
print(ans)


n = int(input())
nums = [int(a) for a in input().split()]
row = 1
maxrow = 1
lastelement = nums[0]
for i in range(1, n):
	if nums[i] >= lastelement:
		row += 1
		if row > maxrow:
			maxrow = row
	else:
		row = 1
	lastelement = nums[i]
print(maxrow)


n = int(input())
a = list(map(int, input().split()))
w = 0
ans = 0
for i in range(n):
	if i == n - 1:
		if a[i] >= a[i - 1]:
			ans = max(w + 1, ans)
	elif a[i] <= a[i + 1]:
		w += 1
	else:
		w += 1
		ans = max(w, ans)
		w = 0
print(ans)


n = input()
array = list(map(int, input().split()))
buffer_1 = 0
buffer_2 = 0
for i in range(int(n) - 1):
	if array[i] <= array[i + 1]:
		buffer_1 += 1
	else:
		buffer_2 = max(buffer_2, buffer_1)
		buffer_1 = 0
buffer_2 = max(buffer_2, buffer_1)
print(buffer_2 + 1)


a = input()
b = list(map(int, input().split()))
c = 1
d = [0]
for i in range(1, int(a)):
	if b[i - 1] <= b[i]:
		c += 1
	else:
		d.append(c)
		c = 1
d.append(c)
d.sort()
print(d[-1])


jumlah_n = int(input())
n = [int(x) for x in input().split(' ')]
res = 0
curr = 0
curr_seq = 0
for i in n:
	if curr <= i:
		curr_seq += 1
	else:
		curr_seq = 1
	if curr_seq > res:
		res = curr_seq
	curr = i
print(res)


num = int(input())
mon = [int(x) for x in input().split(' ')]
incre = []
incre.append(1)
check = 1
for i in range(num - 1):
	if mon[i] <= mon[i + 1]:
		check += 1
		incre.append(check)
	else:
		check = 1
print(max(incre))


def main():
	input()
	a = map(int, input().split())
	ls = 0
	cs = 0
	p = 0
	for i in a:
		if i >= p:
			cs += 1
		else:
			ls = max(ls, cs)
			cs = 1
		p = i
	print(max(ls, cs))
main()


n = int(input())
a = list(map(int, input().split()))
count = 0
prev = a[0]
count = 1
max_length = 1
for i in range(1, n):
	if a[i] >= prev:
		count += 1
	else:
		count = 1
	prev = a[i]
	max_length = max(max_length, count)
print(max_length)


n = int(input())
a = list(map(int, input().split()))
if n == 1:
	print(1)
	exit(0)
i = 0
j = 1
count = 1
final = 0
while j < n:
	if a[j] >= a[i]:
		count += 1
		j += 1
		i += 1
	elif a[j] < a[i]:
		i = j
		j += 1
		final = max(final, count)
		count = 1
final = max(final, count)
print(final)


(num, ans, sum) = (int(input()), 0, 0)
arr = input().split()
arr = [int(x) for x in arr]
for i in range(num):
	if arr[i - 1] > arr[i]:
		ans = max(ans, sum)
		sum = 1
	else:
		sum += 1
	if i + 1 == num:
		ans = max(ans, sum)
print(ans)


def main():
	n = int(input())
	moneys = [int(_) for _ in input().split()]
	max_segment = 1
	current_segment = 1
	for i in range(1, n):
		if moneys[i] >= moneys[i - 1]:
			current_segment += 1
			max_segment = max(max_segment, current_segment)
		else:
			current_segment = 1
	print(max_segment)
main()


n = int(input())
l = list(map(int, input().strip().split()))
m = 0
count = 1
flag = 0
if n == 1:
	print(1)
else:
	for i in range(n - 1):
		if l[i] <= l[i + 1]:
			count = count + 1
			if i == n - 2:
				print(max(m, count))
				flag = 1
				break
		else:
			m = max(m, count)
			count = 1
	if flag == 0:
		print(m)


n = int(input())
l = list(map(int, input().split()))
k = 1
ma = 0
for i in range(n - 1):
	if l[i] <= l[i + 1]:
		k = k + 1
	else:
		if k > ma:
			ma = k
		k = 1
if k > ma:
	ma = k
print(ma)


n = int(input())
al = list(map(int, input().split()))
c = 1
mxc = c
for i in range(1, n):
	c += 1 if al[i] >= al[i - 1] else 1 - c
	if c > mxc:
		mxc = c
print(mxc)


(pocet, najviac, akt) = (int(input()), 1, 1)
postupnost = list(map(int, input().split()))
for i in range(pocet - 1):
	if postupnost[i + 1] >= postupnost[i]:
		akt += 1
		if akt > najviac:
			najviac = akt
	else:
		akt = 1
print(najviac)


n = int(input())
ar = list(map(int, input().split()))
z = 1
count = 1
for i in range(n - 1):
	if ar[i + 1] - ar[i] >= 0:
		count += 1
	else:
		count = 1
	z = max(count, z)
print(z)


n = int(input())
List = [int(a) for a in input().split()]
List2 = [1]
j = 0
for i in range(n - 1):
	if List[i] <= List[i + 1]:
		List2[j] += 1
	else:
		List2.append(1)
		j += 1
print(max(List2))


n = int(input())
days = list(map(int, input().split()))
k = 1
t = 0
if len(days) == 1:
	print('1')
else:
	for x in range(len(days) - 1):
		if days[x + 1] >= days[x]:
			k += 1
		if k > t:
			t = k
		if days[x + 1] < days[x]:
			k = 1
	print(t)


n = int(input())
digits = [int(i) for i in input().split()]
datas = 1
ori = 1
for i in range(1, n):
	if digits[i] >= digits[i - 1]:
		datas = datas + 1
		ori = max(ori, datas)
	else:
		datas = 1
print(ori)


n = int(input())
days = [int(day) for day in input().split(' ')]
count = 1
max_count = 1
for i in range(1, len(days)):
	if days[i] >= days[i - 1]:
		count += 1
		if max_count < count:
			max_count = count
	else:
		if max_count < count:
			max_count = count
		count = 1
print(max_count)


n = int(input())
l = list(map(int, input().strip().split()))
i = 1
i_max = 1
for each in range(n - 1):
	if l[each] <= l[each + 1]:
		i += 1
		if i_max < i:
			i_max = i
	else:
		i = 1
print(i_max)


day = int(input())
profit = list(map(int, input().split()))
count = 1
mx = 1
for i in range(0, len(profit) - 1):
	if profit[i] <= profit[i + 1]:
		count += 1
		if count > mx:
			mx = count
	else:
		count = 1
print(mx)


import math
from decimal import Decimal

def na():
	n = int(input())
	b = [int(x) for x in input().split()]
	return (n, b)

def nab():
	n = int(input())
	b = [int(x) for x in input().split()]
	c = [int(x) for x in input().split()]
	return (n, b, c)

def dv():
	(n, m) = map(int, input().split())
	return (n, m)

def dva():
	(n, m) = map(int, input().split())
	a = [int(x) for x in input().split()]
	b = [int(x) for x in input().split()]
	return (n, m, b)

def eratosthenes(n):
	sieve = list(range(n + 1))
	for i in sieve:
		if i > 1:
			for j in range(i + i, len(sieve), i):
				sieve[j] = 0
	return sorted(set(sieve))

def nm():
	n = int(input())
	b = [int(x) for x in input().split()]
	m = int(input())
	c = [int(x) for x in input().split()]
	return (n, b, m, c)

def dvs():
	n = int(input())
	m = int(input())
	return (n, m)

def ist(x):
	d = 1
	while d < x:
		d *= 2
	return d == x
(n, a) = na()
k = 1
s = set()
prev = a[0]
for i in range(1, n):
	if a[i] >= prev:
		k += 1
		prev = a[i]
	else:
		prev = a[i]
		s.add(k)
		k = 1
if len(a) == 1:
	print(1)
	exit()
if a[i] >= a[i - 1]:
	s.add(k)
print(max(s))


import sys
n = int(input())
a = list(map(int, input().split()))
max_count = 1
save_max_count = 1
for i in range(0, n - 1):
	if a[i + 1] >= a[i]:
		max_count += 1
	else:
		max_count = 1
	if max_count > save_max_count:
		save_max_count = max_count
print(save_max_count)


n = int(input())
arr = map(int, input().strip().split())
list1 = list(arr)
list2 = [1]
c = 1
for i in range(n - 1):
	if list1[i] <= list1[i + 1]:
		c += 1
		list2.append(c)
	else:
		c = 1
print(max(list2))


n = int(input())
dayz = list(map(int, input().split(' ')))
counter = 1
biggest = 1
for i in range(1, n):
	if dayz[i] >= dayz[i - 1]:
		counter = counter + 1
	else:
		counter = 1
	if counter > biggest:
		biggest = counter
print(biggest)


n = int(input())
lst = list(map(int, input().split()))
lst.append(0)
(maxm, max_here) = (0, 1)
for x in range(1, n + 1):
	if lst[x] >= lst[x - 1]:
		max_here += 1
	else:
		maxm = max(maxm, max_here)
		max_here = 1
print(maxm)


a = int(input())
lis = [int(x) for x in input().split()]
lis1 = []
n = 0
if a != 1:
	for i in range(a - 1):
		if lis[i + 1] >= lis[i]:
			n += 1
		else:
			lis1.append(n)
			n = 0
	lis1.append(n)
else:
	lis1.append(0)
print(max(lis1) + 1)


def solve():
	n = int(input())
	numbers = [int(i) for i in input().split(' ')]
	length = 1
	maxLength = 1
	for i in range(1, n):
		if numbers[i] >= numbers[i - 1]:
			length += 1
		else:
			maxLength = max(maxLength, length)
			length = 1
	maxLength = max(maxLength, length)
	return maxLength

def main():
	print(solve())
main()


n = int(input())
x = input().split()
cnt = 1
m = 1
for i in range(n - 1):
	if int(x[i]) <= int(x[i + 1]):
		cnt += 1
		if cnt > m:
			m = cnt
	else:
		cnt = 1
print(m)


_1 = '236a'
_2 = '339a'
_3 = '266a'
_4 = '96a'
_5 = '236a'
_6 = '281a'
_7 = '546a'
_8 = '116a'
_9 = '977a'
_10 = '266b'
_11 = '110a'
_12 = '41a'
_13 = '734a'
_14 = '133a'
_15 = '467a'
_16 = '158a'
_17 = '677a'
_18 = '580'
n = int(input())
l = list(map(int, input().split()))
r = []
count = 0
for i in range(0, n):
	if l[i - 1] <= l[i]:
		count += 1
		r.append(count)
	if l[i - 1] > l[i]:
		count = 0
		count += 1
print(max(r))


n = int(input())
a = [int(x) for x in input().split(' ')]
max_sequence = 1
sequence = 1
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		sequence += 1
	else:
		sequence = 1
	if sequence >= max_sequence:
		max_sequence = sequence
print(max_sequence)


l = int(input())
a = list(map(int, input().split()))
b = []
for i in range(1, l):
	if a[i] > a[i - 1] or a[i] == a[i - 1]:
		b.append(i)
l = len(b)
c = []
count = 0
for i in range(1, l):
	if b[i] - b[i - 1] == 1:
		count += 1
	if i == l - 1 or b[i] - b[i - 1] != 1:
		c.append(count)
		count = 0
if len(b) == 1:
	print(2)
if len(b) == 0 and len(c) == 0:
	print(1)
if len(c) != 0:
	print(max(c) + 2)


a = int(input())
xs = [int(x) for x in input().split()]
ys = []
s = 1
for i in range(a - 1):
	if xs[i] <= xs[i + 1]:
		s += 1
	else:
		ys.append(s)
		s = 1
ys.append(s)
print(max(ys))


l = int(input())
arr = [int(x) for x in input().split()]
max_ = 1
count = 1
for i in range(l - 1):
	if arr[i] <= arr[i + 1]:
		count = count + 1
	else:
		if max_ < count:
			max_ = count
		count = 1
max_ = max(max_, count)
print(max_)


n = int(input())
a = [int(i) for i in input().split(' ')]
t = []
p = 0
for i in range(1, n):
	if a[i] < a[i - 1]:
		t.append(p)
		p = 0
	if a[i] >= a[i - 1]:
		p += 1
t.append(p)
print(max(t) + 1)


def func():
	global max, count
	if max < count:
		max = count
	count = 1
input()
data = [int(i) for i in input().split()]
max = 1
count = 1
for i in range(len(data) - 1):
	if data[i] <= data[i + 1]:
		count += 1
	else:
		func()
func()
print(max)


a = int(input())
b = list(map(int, input().split()))
r = 1
m = 0
for i in range(a - 1):
	if b[i] <= b[i + 1]:
		r += 1
	else:
		m = max(r, m)
		r = 1
m = max(r, m)
print(m)


length = 1
max_length = 1
n = int(input())
a = [int(x) for x in input().split()]
for i in range(1, n):
	if a[i] >= a[i - 1]:
		length += 1
	else:
		length = 1
	if length > max_length:
		max_length = length
print(max_length)


n = int(input())
arr = [int(x) for x in input().split()]
res = [1] * n
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		res[i] += res[i - 1]
print(max(res))


n = int(input())
arr = input().split()
max = 0
number = 0
arr = list(map(int, arr))
for i in range(0, n - 1):
	if arr[i] <= arr[i + 1]:
		number = number + 1
	if arr[i] > arr[i + 1] or i == n - 2:
		if number > max:
			max = number
		number = 0
print(max + 1)


n = int(input())
v = [int(i) for i in input().split()]
dp = [0] * n
dp[0] = 1
r = 1
for i in range(1, n):
	if v[i] >= v[i - 1]:
		dp[i] = dp[i - 1] + 1
	else:
		dp[i] = 1
	r = max(r, dp[i])
print(r)


n = int(input())
arr = list(map(int, input().split()))
maxm = 0
curr = 0
prev = 0
for i in arr:
	curr = curr + 1 if i >= prev else 1
	maxm = max(maxm, curr)
	prev = i
print(maxm)


import heapq as hp

def unpack(func=int):
	return map(func, input().split())

def range_n():
	return range(int(input()))

def main():
	n = int(input())
	arr = list(unpack())
	ans = cnt = 0
	for i in range(n - 1):
		if arr[i] <= arr[i + 1]:
			cnt += 1
		else:
			ans = max(ans, cnt + 1)
			cnt = 0
	else:
		ans = max(ans, cnt + 1)
	print(ans)
main()


def main():
	n = int(input())
	s = input().split()
	money = []
	out = [1] * len(s)
	for i in range(len(s)):
		money.append(int(s[i]))
	for i in range(1, len(s)):
		if money[i] >= money[i - 1]:
			out[i] = out[i - 1] + 1
		else:
			out[i] = 1
	print(max(out))
main()


n = int(input())
l = list(map(int, input().split()))
c = 0
x = []
x.append(0)
if n == 1:
	print(1)
else:
	i = 0
	while i < n - 1:
		if l[i + 1] >= l[i]:
			c += 1
			x.append(c + 1)
		else:
			c = 0
		i += 1
	if len(x) == 1:
		print(1)
	else:
		print(max(x))


n = int(input())
a = [int(i) for i in input().split()]
m = 0
c = 1
b = a[0]
for i in range(1, n):
	if a[i] >= b:
		c += 1
	else:
		if c > m:
			m = c
		c = 1
	b = a[i]
if c > m:
	m = c
print(m)


a = int(input())
x = [int(x) for x in input().strip().split(' ')]
l = 1
max = 1
for i in range(1, len(x)):
	if x[i] >= x[i - 1]:
		l = l + 1
	else:
		l = 1
	if l > max:
		max = l
print(max)


n = int(input())
a = list(map(int, input().split()))
pre = cnt = m = 0
for i in a:
	cnt = cnt + 1 if i >= pre else 1
	m = max(m, cnt)
	pre = i
print(m)


import sys
import collections
import math
import functools
import itertools
import bisect
import operator
import heapq
import random
true = True
false = False
null = None
tcid = 0
tcmax = 99999999

def seq(lo, hi, step=1):
	return range(lo, hi + 1, step)

def sround(val, nd):
	return f'{val:.{nd}f}'

def ceil(a, b):
	ans = a // b
	if a % b != 0:
		ans += 1
	return ans

def perr(*args, **kwargs):
	print(*args, file=sys.stderr, **kwargs)

def line():
	ln = sys.stdin.readline().strip()
	if ln == '':
		sys.exit()
	return ln

def lines(n):
	return [line() for i in range(n)]

def split(ln=None):
	return (ln or line()).split()

def nums(o=None):
	if o is not None:
		if isinstance(o, int):
			o = lines(o)
		elif isinstance(o, str):
			o = split(o)
	return list(map(eval, o or split()))

def num():
	return eval(line())

def mainloop(tcid=1):
	n = num()
	a = nums()
	ans = 0
	tmp = 0
	for zz in range(1, n):
		if a[zz - 1] > a[zz]:
			tmp = 0
		else:
			tmp += 1
			ans = max(ans, tmp)
	print(ans + 1)
while tcid < tcmax:
	tcid += 1
	mainloop(tcid)


n = int(input())
a = [int(x) for x in input().split()]
c = 1
r = -1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		c += 1
	else:
		r = max(r, c)
		c = 1
r = max(r, c)
print(r)


n = int(input())
ctr = 0
slis = []
lis = list(map(int, input().split()))
if n == 1:
	print(1)
else:
	for i in range(n - 1):
		if lis[i] <= lis[i + 1]:
			ctr += 1
		else:
			slis.append(ctr + 1)
			ctr = 0
	if ctr != 0:
		slis.append(ctr + 1)
	print(max(slis))


n = int(input())
v = list(map(int, input().split()))
cont = 0
res = 0
for i in range(1, n):
	if v[i - 1] <= v[i]:
		cont = cont + 1
	else:
		res = max(cont, res)
		cont = 0
print(max(res + 1, cont + 1))


N = int(input())
lst = tuple(map(int, input().split()))
k = x = 1
i = 0
while i != N - 1:
	if lst[i] <= lst[i + 1]:
		k += 1
		x = max(k, x)
	else:
		k = 1
	i += 1
print(x)


tamanho = eval(input())
entrada = map(int, input().split())
dp = list(entrada)
resposta = 0
contador = 0
for i in range(0, tamanho):
	if i > 0:
		if dp[i] >= dp[i - 1]:
			contador += 1
		else:
			resposta = max(resposta, contador)
			contador = 0
resposta = max(resposta, contador)
print(resposta + 1)


n = int(input())
t = [int(x) for x in input().split()]
x = 0
c = 0
y = 0
for i in t:
	if i < x:
		y = max(y, c)
		c = 0
	c += 1
	x = i
print(max(y, c))


n = int(input())
entrada = input().split(' ')
max_sub = 1
temp = 1
for i in range(int(n) - 1):
	if int(entrada[i]) <= int(entrada[i + 1]):
		temp += 1
	else:
		if temp >= max_sub:
			max_sub = temp
		temp = 1
if temp >= max_sub:
	max_sub = temp
print(max_sub)


input()
ai = [int(x) for x in input().split()]
x = 0
n = 0
n_max = 0
for a in ai:
	if a >= x:
		n += 1
	else:
		n = 1
	x = a
	if n >= n_max:
		n_max = n
print(n_max)


import sys
from sys import stdin, stdout
n = int(stdin.readline().rstrip())
a = list(map(int, stdin.readline().rstrip().split()))
i = int(1)
m = int(1)
r = int(1)
while i < n:
	if a[i] < a[i - 1]:
		m = 1
	else:
		m += 1
	r = max(r, m)
	i += 1
print(r)


n = int(input())
a = []
p = 1
mix = -1
a = list(map(int, input().split()))
a = a + [-1]
for i in range(0, n):
	if a[i + 1] >= a[i]:
		p = p + 1
	else:
		p = 1
	if mix < p:
		mix = p
print(mix)


n = int(input())
l = list(map(int, input().split()))[:n]
count1 = count2 = 1
for i in range(n - 1):
	if l[i] <= l[i + 1]:
		count1 += 1
	else:
		if count2 < count1:
			count2 = count1
		count1 = 1
print(max(count2, count1))


n = int(input())
a = input().split()
b = []
for i in a:
	b.append(int(i))
count = 1
ans = 1
for i in range(1, len(b)):
	if b[i] >= b[i - 1]:
		count += 1
		if count > ans:
			ans = count
	else:
		count = 1
print(ans)


n = int(input())
a = list(map(int, input().split()))
c = []
b = 1
for i in range(0, n - 1):
	if a[i + 1] > a[i] or a[i + 1] == a[i]:
		b += 1
	else:
		c.append(b)
		b = 1
c.append(b)
m = max(c)
print(m)


n = int(input())
inp = list(map(int, input().split()))
k = inp[0]
count = 0
maxi = 0
for i in range(0, len(inp)):
	if k <= inp[i]:
		count += 1
		k = inp[i]
		if maxi < count:
			maxi = count
	else:
		k = inp[i]
		count = 1
print(maxi)


a = int(input())
b = list(map(int, input().split()))
hi = 0
ct = 1
pv = b[0]
for i in range(1, a):
	if not b[i] < pv:
		ct += 1
		pv = b[i]
	else:
		hi = max(hi, ct)
		ct = 1
		pv = b[i]
hi = max(hi, ct)
print(hi)


def main():
	n = int(input())
	aStr = list(input().split(' '))
	a = []
	j = 0
	started = False
	length = 0
	longerLength = 1
	for i in range(len(aStr)):
		a.append(int(aStr[i]))
	while j < len(a) - 1:
		if a[j] <= a[j + 1]:
			if started == False:
				started = True
				length = 2
				if length > longerLength:
					longerLength = length
			else:
				length = length + 1
				if length > longerLength:
					longerLength = length
		else:
			started = False
		j = j + 1
	print(longerLength)
main()


n = int(input())
l = list(map(int, input().split()))
l.reverse()
s = 1
l2 = [1]
for i in range(0, n - 1):
	a = l[i]
	b = l[i + 1]
	if a < b:
		s = 1
	if a >= b:
		s += 1
		l2.append(s)
print(max(l2))


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

def crossLength(l, m, r):
	count = 0
	if A[m] > A[m + 1]:
		return count
	else:
		count += 1
	for i in range(m - l):
		if A[m - i] >= A[m - i - 1]:
			count += 1
		else:
			break
	for i in range(r - m):
		if A[m + i + 1] >= A[m + i]:
			count += 1
		else:
			break
	return count

def findSubsegmentLength(l, r):
	if l == r:
		return 1
	m = (r + l) // 2
	left_length = findSubsegmentLength(l, m)
	right_length = findSubsegmentLength(m + 1, r)
	mid_legth = crossLength(l, m, r)
	return max(left_length, right_length, mid_legth)
print(findSubsegmentLength(0, len(A) - 1))


input()
money = list(map(int, input().split()))
i = min(len(money), 1)
max_i = i
for (m1, m2) in zip(money[:-1], money[1:]):
	if m2 >= m1:
		i += 1
	else:
		max_i = max(max_i, i)
		i = 1
print(max(max_i, i))


n = int(input())
arr = input().split()
for i in range(0, n):
	arr[i] = int(arr[i])
ans = 1
if n == 0:
	ans = 0
i = 0
while i < n - 1:
	j = i + 1
	while j < n and arr[j] >= arr[j - 1]:
		j += 1
	ans = max(ans, j - i)
	i = j
print(ans)


n = int(input())
a = list(map(int, input().split()))
(q, qmx, i) = (1, 0, 0)
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		q += 1
	else:
		if q > qmx:
			qmx = q
		q = 1
if q > qmx:
	qmx = q
print(qmx)


n = input()
a = input().split(' ')
maxlength = 1
length = 1
prevai = None
for ai in a:
	ai = int(ai)
	if prevai == None or prevai > ai:
		length = 1
	else:
		length = length + 1
		if length > maxlength:
			maxlength = length
	prevai = ai
print(maxlength)


k = 1
amount = []
n = int(input())
steps = list(map(int, input().split()))
if len(steps) == 1:
	print(1)
else:
	for i in range(len(steps) - 1):
		if steps[i + 1] < steps[i]:
			k = 1
		else:
			k += 1
		amount.append(k)
	print(max(amount))


import sys
import math
strInp = lambda : input().strip().split()
intInp = lambda : list(map(int, strInp()))
n = int(input())
arr = intInp()
last = arr[0]
newArr = [1]
for i in range(1, n):
	if arr[i] < last:
		newArr.append(1)
	else:
		newArr.append(newArr[-1] + 1)
	last = arr[i]
print(max(newArr))


n = int(input())
a = list(map(int, input().split()))
ans = 0
tag = []
for i in range(0, n):
	tag.append([0])
for i in range(0, n):
	maxans = 0
	max = a[i]
	if tag[i] == [0]:
		for j in range(i, n):
			if max == a[j] or a[j] > max:
				maxans += 1
				max = a[j]
				tag[j] = [1]
			else:
				break
	if maxans > ans:
		ans = maxans
print(ans)


n = int(input())
a = b = 0
x = 0
l = []
number = [int(i) for i in input().split()]
for i in number:
	b = a
	a = i
	if b <= a:
		x = x + 1
		l.append(x)
	else:
		x = 1
print(max(l))


n = int(input())
li = []
li = input().split()
li = list(map(int, li))
(count, m) = (1, 1)
for i in range(len(li) - 1):
	if li[i + 1] >= li[i]:
		count = count + 1
		if count > m:
			m = count
	else:
		count = 1
print(m)


n = int(input())
a = list(map(int, input().split()))
sequenceuptoi = [1] * n
maxs = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		sequenceuptoi[i] = sequenceuptoi[i - 1] + 1
		maxs = max(maxs, sequenceuptoi[i])
print(maxs)


count = 0
ans = []
n = int(input())
li = list(map(int, input().split()))
if len(li) > 1:
	for i in range(1, len(li)):
		if li[i - 1] <= li[i]:
			count += 1
			ans.append(count)
		else:
			count = 0
	if len(ans) > 0:
		print(max(ans) + 1)
	else:
		print(1)
else:
	print(1)


n = int(input())
l = [int(x) for x in input().split()]
num = 0
output = []
if n == 1:
	print(n)
else:
	for i in range(n - 1):
		if l[i] <= l[i + 1]:
			num += 1
			output.append(num)
		else:
			output.append(num)
			num = 0
	a = max(output) + 1
	print(a)


n = int(input())
digits = input().split(' ')
count = 1
max_count = 1
for i in range(1, n):
	if int(digits[i]) >= int(digits[i - 1]):
		count = count + 1
		if count > max_count:
			max_count = count
	else:
		count = 1
print(max_count)


n = int(input())
A = list(map(int, input().split()))
count = 1
temp = []
for i in range(n - 1):
	if A[i] <= A[i + 1]:
		count += 1
	else:
		temp.append(count)
		count = 1
temp.append(count)
print(max(temp))


size = int(input())
arr = list(map(int, input().split(' ')))
max_len = []
seq = 1
if size == 1:
	print(size)
else:
	for i in range(size - 1):
		if arr[i] <= arr[i + 1]:
			seq += 1
			max_len.append(seq)
		else:
			max_len.append(seq)
			seq = 1
	print(max(max_len))


n = int(input())
li = list(map(int, input().split()))
li1 = [1] * n
for i in range(1, n):
	if li[i - 1] <= li[i]:
		li1[i] += li1[i - 1]
print(max(li1))


n = int(input())
a = list(map(int, input().split()))
(m, i) = (0, 0)
while i < n:
	(c, j) = (1, i)
	while j < n - 1 and a[j + 1] >= a[j]:
		c += 1
		j += 1
	i = j + 1
	m = max(c, m)
print(m)


n = int(input())
l = list(map(int, input().split()))
count = 0
a = 0
arr = []
for i in range(n):
	if l[i] >= a:
		a = l[i]
		count += 1
	else:
		a = l[i]
		arr.append(count)
		count = 1
if len(arr) == 0:
	print(n)
elif count > max(arr):
	print(count)
else:
	print(max(arr))


n = int(input())
s = [int(x) for x in input().split(' ')]
m = 1
c = 1
for i in range(1, n):
	if s[i] >= s[i - 1]:
		c += 1
	else:
		m = max(m, c)
		c = 1
print(max(m, c))


n = int(input())
lst = list(map(int, input().split()))
count = 0
count1 = 0
for i in range(len(lst) - 1):
	if lst[i + 1] - lst[i] < 0:
		count = 0
		continue
	count = count + 1
	count1 = max(count, count1)
print(count1 + 1)


n = input()
num = list(map(int, input().split()))
prev = 0
count = 0
acount = 0
for i in num:
	if i >= prev:
		acount += 1
	elif acount > count:
		count = acount
		acount = 1
	else:
		acount = 1
	prev = i
if acount > count:
	count = acount
print(count)


count = int(input())
income = [int(x) for x in input().split()]
length = 1
max_length = 0
for i in range(1, count):
	if income[i] >= income[i - 1]:
		length += 1
	else:
		if max_length < length:
			max_length = length
		length = 1
if max_length < length:
	max_length = length
print(max_length)


n = int(input())
A = list(map(int, input().split()))
out = 1
outMax = 0
for i in range(1, n):
	if A[i] >= A[i - 1]:
		out += 1
	else:
		if out > outMax:
			outMax = out
		out = 1
if out > outMax:
	outMax = out
print(outMax)


n = int(input())
l = list(map(int, input().split()))
l.append(0)
p = 0
k = 0
for i in range(n):
	if l[i + 1] >= l[i]:
		k += 1
	else:
		if k > p:
			p = k
		k = 0
		continue
print(p + 1)


n = list(map(int, input().strip().split()))
k = list(map(int, input().strip().split()))
maxnondecrease = 1
currentnondecrease = 1
i = 1
while i < n[0]:
	if k[i] >= k[i - 1]:
		currentnondecrease += 1
	else:
		currentnondecrease = 1
	if maxnondecrease < currentnondecrease:
		maxnondecrease = currentnondecrease
	i += 1
print(maxnondecrease)


n = input()
res = 1
l = 1
arr = [int(x) for x in input().split()]
prec = arr[0]
arr.remove(prec)
for a in arr:
	if int(a) >= prec:
		l += 1
		if l > res:
			res = l
	else:
		l = 1
	prec = a
print(res)


n = int(input())
l = [int(x) for x in input().split()]
c = 1
d = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		d = d + 1
	else:
		d = 1
	if d > c:
		c = d
print(c)


a = int(input())
b = tuple(map(int, input().split()))
gg = 1
i = 0
while i < a:
	count = 1
	for n in range(a - i - 1):
		if b[i + n] <= b[i + n + 1]:
			count += 1
		else:
			break
	gg = max(count, gg)
	i += count
print(gg)


n = int(input())
lis = list(map(int, input().split()))
cnt = 1
big = 1
for i in range(n - 1):
	if lis[i] <= lis[i + 1]:
		cnt += 1
		if cnt > big:
			big = cnt
	else:
		cnt = 1
print(big)


n = int(input())
var = input()
x = list(map(int, var.split()))
dp = [1] * len(x)
maxim = 1
for i in range(1, len(x)):
	if x[i] >= x[i - 1]:
		dp[i] += dp[i - 1]
	if dp[i] > maxim:
		maxim = dp[i]
print(maxim)


g = []
while True:
	try:
		g.append(input())
	except:
		break
n = int(g[0])
s = g[1].split(' ')
max = 0
k = 0
for i in range(n):
	if i < n - 1 and int(s[i]) <= int(s[i + 1]):
		k += 1
	else:
		k += 1
		if k > max:
			max = k
		k = 0
print(max)


n = int(input())
a = [int(x) for x in input().split()]
i = 1
max_nondecreasing = 0
nondecreasing = 1
while i < len(a):
	if a[i] >= a[i - 1]:
		nondecreasing += 1
	else:
		if nondecreasing > max_nondecreasing:
			max_nondecreasing = nondecreasing
		nondecreasing = 1
	i += 1
if nondecreasing > max_nondecreasing:
	max_nondecreasing = nondecreasing
print(max_nondecreasing)


n = int(input())
li = [int(a) for a in input().split(' ')]
max = 0
l = []
max2 = 0
for i in range(n):
	if i + 1 >= n:
		break
	elif li[i] <= li[i + 1]:
		max += 1
		if max2 < max:
			max2 = max
	else:
		max = 0
print(max2 + 1)


n = int(input(''))
y1 = input('')
y = y1.split()
s = 0
p = []
if n > 2:
	for i in range(0, n - 1):
		g = int(y[i + 1])
		h = int(y[i])
		if i != n - 2:
			if g >= h:
				s = s + 1
				p.append(s)
			else:
				s = s + 1
				p.append(s)
				s = 0
		elif int(y[n - 1]) >= int(y[n - 2]):
			s = s + 2
			p.append(s)
		else:
			s = s + 1
			p.append(s)
	print(max(p))
else:
	if n == 2:
		if y[1] >= y[0]:
			print(2)
		else:
			print(1)
	if n == 1:
		print(1)


n = int(input())
start = 0
i = 0
j = 1
ans = 1
a = list(map(int, input().split()))
while j < n:
	if a[j] >= a[i]:
		ans = max(ans, j - start + 1)
		j += 1
		i += 1
	else:
		start = j
		i = start
		j = start + 1
print(ans)


n = int(input())
if n == 1:
	print(1)
else:
	income = input().split()
	i = 0
	while i < n:
		income[i] = int(income[i])
		i = i + 1
	j = 0
	k = 1
	length = []
	while j < n - 1:
		if j < n - 2 and income[j + 1] >= income[j]:
			k = k + 1
		elif j < n - 2 and income[j + 1] < income[j]:
			length.append(k)
			k = 1
		elif income[n - 1] >= income[n - 2] and income[n - 2] >= income[n - 3]:
			k = k + 1
			length.append(k)
		elif income[n - 1] < income[n - 2] and income[n - 2] >= income[n - 3]:
			length.append(k)
		elif income[n - 1] >= income[n - 2] and income[n - 2] < income[n - 3]:
			length.append(2)
		j = j + 1
	length.sort(reverse=True)
	print(length[0])


n = int(input())
sequence = [int(e) for e in input().split()]
maximum = 1
current_count = 1
for i in range(1, n):
	if sequence[i - 1] <= sequence[i]:
		current_count += 1
		if maximum < current_count:
			maximum = current_count
	else:
		current_count = 1
print(maximum)


import sys
input = sys.stdin.readline

def int_array():
	return list(map(int, input().split()))
n = int(input().strip())
arr = int_array()
order = []
count = 0
state = 'NO'
for i in range(len(arr) - 1):
	if arr[i] <= arr[i + 1]:
		state = 'YES'
		count += 1
	else:
		if state == 'YES':
			order.append(count + 1)
		state = 'NO'
		count = 0
if state == 'YES':
	order.append(count + 1)
if True:
	order.append(1)
print(max(order))


3
import itertools as ittls
from collections import Counter

def sqr(x):
	return x * x

def inputarray(func=int):
	return list(map(func, input().split()))
N = int(input())
A = list(inputarray())
maxv = 1
currmaxv = 1
for i in range(1, len(A)):
	if A[i] >= A[i - 1]:
		currmaxv = currmaxv + 1
	else:
		currmaxv = 1
	maxv = max(maxv, currmaxv)
print(maxv)


n = int(input())
A = list(map(int, input().split()))
dp = [1 for i in range(n)]
for i in range(1, n):
	if A[i] >= A[i - 1]:
		dp[i] = dp[i - 1] + 1
print(max(dp))


n = int(input())
l = list(map(int, input().split()))
j = 0
lis = [1] * n
for i in range(1, n):
	if l[j] <= l[i]:
		if lis[i] <= lis[j] + 1:
			lis[i] = lis[j] + 1
	j += 1
print(max(lis))


N = int(input())
A = list(map(int, input().split(' ')))
L = []
for (i, ele) in enumerate(A):
	if i == 0:
		L.append(1)
	elif A[i - 1] <= ele:
		L.append(L[i - 1] + 1)
	else:
		L.append(1)
print(max(L))


def read_input():
	number_of_days = int(input())
	sequence_input = [int(elem) for elem in input().split(' ')]
	return (number_of_days, sequence_input)

def check_max_value(value1, value2):
	return value1 if value1 > value2 else value2
(days, sequence) = read_input()
counter = 1
max_counter = 1
for (index, element) in enumerate(sequence):
	if index == 0:
		continue
	elif element >= sequence[index - 1]:
		counter += 1
	else:
		max_counter = check_max_value(counter, max_counter)
		counter = 1
max_counter = check_max_value(counter, max_counter)
print(max_counter)


n = int(input())
list1 = list(map(int, input().split(' ')))
c = 1
sum1 = 0
for i in range(1, n):
	if list1[i] >= list1[i - 1]:
		c += 1
	else:
		sum1 = max(sum1, c)
		c = 1
print(max(sum1, c))


n = int(input())
s = list(map(int, input().split()))
i = 1
mx = 1
while n > i:
	su = 1
	for j in range(i, n):
		if s[j] >= s[j - 1]:
			su += 1
			i = j + 1
		else:
			i = j + 1
			break
	if su > mx:
		mx = su
print(mx)


n = int(input())
seq = list(map(int, input().split()))
(result, sub) = (1, 1)
for i in range(n - 1):
	if seq[i] <= seq[i + 1]:
		sub += 1
	else:
		sub = 1
	result = max(result, sub)
print(result)


def solve(a, n):
	res = 1
	t = 1
	for i in range(1, n):
		if a[i] >= a[i - 1]:
			t += 1
		else:
			res = max(res, t)
			t = 1
	res = max(res, t)
	return res
n = int(input())
a = list(map(int, input().split()))
print(solve(a, n))


x = input()
y = input().split()
s = 0
b = 0
for i in range(len(y) - 1):
	if int(y[i]) <= int(y[i + 1]):
		s = s + 1
	else:
		s = 0
	b = max(s, b)
print(b + 1)


n = int(input())
arr = [int(x) for x in input().split()]
best = 0
counter = 0
last = 0
for x in arr:
	if x < last:
		best = max(best, counter)
		counter = 0
	counter += 1
	last = x
print(max(best, counter))


q = int(input())
days = list(map(int, input().split(' ')))
count = 1
aux_count = 1
for i in range(1, q):
	if days[i] >= days[i - 1]:
		count += 1
		if count > aux_count:
			aux_count = count
	else:
		count = 1
print(aux_count)


n = int(input())
(flag, max) = (1, 1)
s = list(map(int, input().split()))
for i in range(n - 1):
	if s[i] <= s[i + 1]:
		flag += 1
		if max < flag:
			max = flag
	else:
		flag = 1
print(max)


def func():
	num = int(input())
	user = input().split()
	for i in range(len(user)):
		user[i] = int(user[i])
	length = 1
	out = []
	if len(user) > 1:
		for i in range(1, len(user)):
			if user[i] >= user[i - 1]:
				length += 1
			else:
				out.append(length)
				length = 1
			if i == len(user) - 1:
				if out == []:
					out.append(length)
				elif out != [] and length > max(out):
					out.append(length)
	else:
		out.append(length)
	print(max(out))
func()


n = int(input())
max_len = 0
cur_len = 0
last_elem = -99999999999
for elem in input().split():
	elem = int(elem)
	if elem >= last_elem:
		cur_len += 1
		if cur_len > max_len:
			max_len = cur_len
	else:
		cur_len = 1
	last_elem = elem
print(max_len)


n = int(input())
a = list(map(int, input().split()))
a = a + [-515]
i = 0
t = 1
while i < len(a) - 2:
	s = 1
	while a[i + 1] >= a[i]:
		s = s + 1
		i = i + 1
	t = max(t, s)
	i = i + 1
print(t)


n = int(input())
r = t = 0
a = 11 ** 11
for x in list(map(int, input().split())):
	if x < a:
		t = 0
	t += 1
	r = max(r, t)
	a = x
print(r)


n = int(input())
a = input().split()
a = [int(x) for x in a]
ans = []
count = 1
for x in range(1, n):
	if a[x - 1] > a[x]:
		ans.append(count)
		count = 1
	else:
		count += 1
ans.append(count)
print(max(ans))


n = int(input())
l = list(map(int, input().split()))
nd = 1
best_case = 1
for i in range(n):
	if i == n - 1:
		break
	elif l[i + 1] >= l[i]:
		nd += 1
		if nd > best_case:
			best_case = nd
	else:
		nd = 1
print(best_case)


n = input()
A = list(map(int, input().split())) + [-1]
k = 1
m = 0
for i in range(len(A) - 1):
	if A[i] <= A[i + 1]:
		k += 1
	else:
		if k > m:
			m = k
		k = 1
print(m)


n = int(input())
a = list(map(int, input().split()))
max_length = 1
cur_length = 1
for i in range(1, n):
	if a[i - 1] <= a[i]:
		cur_length += 1
	else:
		max_length = max(max_length, cur_length)
		cur_length = 1
print(max(cur_length, max_length))


n = int(input())
x = input().split()
maxim = 1
now = 1
i_1 = int(x[0])
for i in range(1, n):
	i_2 = int(x[i])
	if i_2 < i_1:
		if maxim < now:
			maxim = now
		now = 0
	i_1 = i_2
	now += 1
if maxim < now:
	maxim = now
print(maxim)


n = input()
arr = [int(x) for x in input().split()]
l = -1
(c, c1) = (0, 0)
for i in arr:
	if i >= l:
		c += 1
	else:
		c1 = max(c, c1)
		c = 1
	l = i
print(max(c, c1))


n = int(input())
a = list(map(int, input().split()))
i = 0
if len(a) == 1:
	print(1)
	exit()
maxLength = []
while i < len(a) - 1:
	length = 0
	while i < len(a) - 1 and a[i] <= a[i + 1]:
		length = length + 1
		i = i + 1
	maxLength.append(length)
	i = i + 1
print(max(maxLength) + 1)


n = int(input())
l = [int(x) for x in input().split()]
ans = 1
c = 1
for i in range(n - 1):
	if l[i] <= l[i + 1]:
		c += 1
		ans = max(c, ans)
	else:
		c = 1
print(ans)


input()
seq = {'max': 1, 'cur': 1, 'prev_el': None}
for el in map(int, input().split()):
	seq['cur'] = seq['cur'] + 1 if seq['prev_el'] and el >= seq['prev_el'] else 1
	seq['prev_el'] = el
	if seq['cur'] > seq['max']:
		seq['max'] = seq['cur']
print(seq['max'])


n = int(input())
l = list(map(int, input().split()))
x = l[0]
c = r = 1
for i in range(1, n):
	y = l[i]
	if y >= x:
		c += 1
		r = max(r, c)
	else:
		c = 1
	x = y
print(r)


n = int(input())
a = list(map(int, input().split(maxsplit=n - 1)))
mxseq = 1
seqs = []
if len(a) == 1:
	seqs.append(1)
else:
	for i in range(len(a) - 1):
		if a[i] <= a[i + 1]:
			mxseq += 1
		else:
			seqs.append(mxseq)
			mxseq = 1
		if i + 1 == len(a) - 1:
			seqs.append(mxseq)
if len(seqs) == 0:
	print(len(a))
else:
	print(max(seqs))


x = int(input())
i = input()
li = list(i.split(' '))
li = [int(y) for y in li]
a = int(0)
b = int(0)
j = int(0)
while j < x - 1:
	if li[j + 1] - li[j] > 0 or li[j + 1] - li[j] == 0:
		b = b + 1
	else:
		if b > a:
			a = b
		b = 0
	if j + 1 == x - 1 and a < b:
		a = b
	j += 1
print(a + 1)


n = int(input())
a = input().split(' ')
data = []
for i in a:
	data.append(int(i))
maximum = 0
k = 1
for i in range(n - 1):
	if data[i + 1] >= data[i]:
		k += 1
	else:
		if k > maximum:
			maximum = k
		k = 1
if k > maximum:
	maximum = k
print(maximum)


import math, fractions
n = int(input())
q = [int(x) for x in input().split()]
ans = 1
c = 1
for i in range(n - 1):
	if q[i] > q[i + 1]:
		c = 1
	else:
		c += 1
	ans = max(ans, c)
print(ans)


n = int(input())
arr = list(map(int, input().split()))
last = -1
cnt = 0
maxc = 0
for i in range(n):
	if arr[i] >= last:
		cnt += 1
		maxc = max(maxc, cnt)
		last = arr[i]
	else:
		last = arr[i]
		cnt = 1
print(maxc)


n = int(input())
arr = list(map(int, input().split()))
maxi = 0
first = 0
current = 0
for i in range(len(arr)):
	if arr[i] >= first:
		current = current + 1
		if current > maxi:
			maxi = current
	else:
		current = 1
	first = arr[i]
print(maxi)


useless = int(input())
s = list(map(int, input().split()))
c = 10 ** 9
max_length = 1
length = 1
for n in s:
	if c <= n:
		length += 1
	else:
		length = 1
	c = n
	max_length = max(length, max_length)
print(max_length)


n = int(input())
l = list(map(int, input().split()))
cnt = 1
maxx = 0
for i in range(len(l) - 1):
	if l[i] > l[i + 1]:
		if cnt > maxx:
			maxx = cnt
		cnt = 1
	else:
		cnt += 1
if cnt > maxx:
	maxx = cnt
print(maxx)


n = int(input())
l = [int(x) for x in input().split()]
maXcoN = 0
coN = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		coN += 1
	else:
		maXcoN = max(maXcoN, coN)
		coN = 1
print(max(maXcoN, coN))


a = int(input())
x = [int(q) for q in input().split()]
a = 0
f = []
for i in range(len(x) - 1):
	if x[i] <= x[i + 1]:
		a += 1
	else:
		a = 0
	f.append(a)
if len(x) == 1:
	print(1)
else:
	print(max(f) + 1)


n = int(input())
seq = list(map(int, input().split()))
(m, i, mm) = (1, 0, 1)
while i != n - 1:
	if seq[i] <= seq[i + 1]:
		m += 1
	else:
		mm = max(m, mm)
		m = 1
	i += 1
print(max(m, mm))


days = int(input())
income = list(input().split(' '))
income = list(map(int, income))
bStreak = 1
cStreak = 1
for x in range(1, len(income)):
	if income[x] >= income[x - 1]:
		cStreak += 1
	else:
		if bStreak < cStreak:
			bStreak = cStreak
		cStreak = 1
if bStreak < cStreak:
	bStreak = cStreak
print(bStreak)


input()
x = list(map(int, input().split()))
l = 0
r = 1
c = 1
while l < len(x) and r < len(x):
	if x[r] >= x[r - 1]:
		r += 1
	else:
		l = r
		r = l + 1
	if c < r - l:
		c = r - l
print(c)


def main():
	i = int(input())
	if i == 0:
		print(0)
		return
	numbers = input().split(' ')
	max = 1
	current = 1
	for k in range(i - 1):
		if int(numbers[k + 1]) >= int(numbers[k]):
			current = current + 1
			if current > max:
				max = current
		else:
			current = 1
	print(max)
main()


def read_ints():
	temp = input()
	ints = [int(t) for t in temp.split(' ')]
	return ints
values = input()
values = read_ints()
curmax = 1
totalmax = 1
for (i, value) in enumerate(values):
	if i == 0:
		continue
	if value < values[i - 1]:
		totalmax = max(totalmax, curmax)
		curmax = 1
	else:
		curmax += 1
totalmax = max(totalmax, curmax)
print(totalmax)


nope = int(input())
art = list(map(int, input().split()))
clear = 0
mike = 0
for i in range(nope - 1):
	if art[i] <= art[i + 1]:
		clear += 1
	else:
		if mike < clear:
			mike = clear
		clear = 0
if mike < clear:
	mike = clear
print(mike + 1)


n = int(input())
l = list(map(int, input().split()))
max_dec = 1
pre = 1
for i in range(n - 1):
	if l[i] <= l[i + 1]:
		pre += 1
	else:
		max_dec = max(max_dec, pre)
		pre = 1
max_dec = max(max_dec, pre)
print(max_dec)


days = int(input())
progress = [int(x) for x in input().split(' ')]
maxDays = 1
currentDays = 1
prevNum = progress[0]
for n in progress[1:]:
	if n >= prevNum:
		currentDays += 1
		if currentDays > maxDays:
			maxDays = currentDays
	else:
		currentDays = 1
	prevNum = n
print(maxDays)


n = input()
l = list(map(int, input().split()))
count = 1
r = 0
for (index, v) in enumerate(l):
	if index > 0:
		if v < l[index - 1]:
			if count > r:
				r = count
			count = 1
		else:
			count += 1
if count > r:
	r = count
print(r)


n = int(input())
N = list(map(int, input().split()))
v = 1
V = 0
for i in range(n - 1):
	if N[i + 1] < N[i]:
		if v > V:
			V = v
		v = 1
	else:
		v += 1
if v > V:
	V = v
print(V)


n = int(input())
ip = list(map(int, input().split(' ')))
min = ip[0]
maxcount = count = 1
for i in range(1, n):
	if ip[i] < min:
		min = ip[i]
		if count > maxcount:
			maxcount = count
		count = 1
	else:
		min = ip[i]
		count += 1
if count > maxcount:
	maxcount = count
print(maxcount)


n = int(input())
a = input()
t = a.split(' ')
for i in range(n):
	t[i] = int(t[i])
x = 0
y = 0
i = 0
while i < n - 1:
	if t[i] > t[i + 1]:
		if y > x:
			x = y
		y = 0
		i = i + 1
	else:
		y = y + 1
		i = i + 1
if y > x:
	x = y
print(x + 1)


import math
from collections import defaultdict
from collections import Counter
import itertools

def solve(n, A):
	max_len = 0
	if sorted(A) == A:
		return n
	l = 0
	r = 0
	while r < n - 1:
		if A[r] > A[r + 1]:
			max_len = max(max_len, r - l + 1)
			l = r + 1
		r += 1
	max_len = max(max_len, r - l + 1)
	return max_len
n = int(input())
in_ = map(int, input().split(' '))
temp = []
for x in in_:
	temp.append(int(x))
print(solve(n, temp))


n = int(input())
t = [int(x) for x in input().split()]
d = 1
a = []
for i in range(n - 1):
	if t[i + 1] - t[i] >= 0:
		d += 1
	else:
		a.append(d)
		d = 1
a.append(d)
print(max(a))


n = int(input())
arr = [int(i) for i in input().split()]
subsegment = [1] * n
last = 0
for i in range(len(arr)):
	if i == 0:
		continue
	elif arr[i] >= arr[i - 1]:
		subsegment[i] = subsegment[i - 1] + 1
	else:
		subsegment[i] = 1
print(max(subsegment))


n = int(input())
ls = [int(x) for x in input().split()]
ans = 1
seq = 1
ok = True
for i in range(1, len(ls)):
	if ls[i] >= ls[i - 1]:
		seq += 1
	else:
		ans = max(ans, seq)
		seq = 1
print(max(ans, seq))


length = int(input())
sequence = [int(i) for i in input().split(' ')]
max_here = current_max = 1
for i in range(1, length):
	max_here = max_here + 1 if sequence[i] >= sequence[i - 1] else 1
	current_max = max(max_here, current_max)
print(current_max)


n = int(input())
nums = list(map(int, input().split()))
i = 0
counter = 1
max = 1
while i < len(nums) - 1:
	if nums[i + 1] >= nums[i]:
		counter += 1
		if counter > max:
			max = counter
	else:
		if counter > max:
			max = counter
		counter = 1
	i += 1
print(max)


n = int(input())
s = input()
ss = s.split()
a = 1
q = 1
if n == 1:
	print('1')
else:
	for i in range(n - 1):
		if int(ss[i + 1]) - int(ss[i]) >= 0:
			q = q + 1
		elif q - a > 0:
			a = q
			q = 1
		else:
			q = 1
	if q - a > 0:
		print(q)
	else:
		print(a)


import sys
if False:
	input = open('money.txt', 'r')
else:
	input = sys.stdin
n = int(input.readline())
sequence = input.readline().split()
maximum = 1
integers = []
all = [1]
for r in sequence:
	r = int(r)
	integers.append(r)
for i in range(1, n):
	if integers[i] >= integers[i - 1]:
		maximum = maximum + 1
	else:
		maximum = 1
	all.append(maximum)
all.sort()
answer = all[len(all) - 1]
print(answer)


n = int(input())
l = [int(i) for i in input().split()]
i = 0
c = 0
max = c
while i < n - 1:
	if l[i + 1] < l[i]:
		if c > max:
			max = c
		c = 0
	else:
		c = c + 1
	i = i + 1
if c > max:
	max = c
print(max + 1)


def solve(n, arr):
	li = [0] + arr[:n - 1]
	count = 0
	ans = 0
	for (i, j) in zip(li, arr):
		if i > j:
			if count > ans:
				ans = count
			count = 0
		count += 1
	if count > ans:
		ans = count
	return ans
n = int(input())
arr = list(map(int, input().split()))
result = solve(n, arr)
print(result)


n = int(input())
l = [int(i) for i in input().split()]
i = 0
(m, c) = (0, 0)
while i < len(l) - 1:
	if l[i + 1] >= l[i]:
		c += 1
		if c > m:
			m = c
	else:
		c = 0
	i += 1
print(m + 1)


def ans(n, arr):
	maxi = 1
	res = 1
	for i in range(1, n):
		if arr[i] >= arr[i - 1]:
			res += 1
			maxi = max(maxi, res)
		else:
			res = 1
	return maxi
n = int(input())
arr = list(map(int, input().strip().split(' ')))
print(ans(n, arr))


n = int(input())
y = 1
l = list(map(int, input().split()))
ls = []
if n > 1:
	for i in range(1, n):
		if l[i] >= l[i - 1]:
			y = y + 1
			ls.append(y)
		else:
			y = 1
			ls.append(y)
	print(max(ls))
else:
	print(1)


n = int(input())
a = [int(i) for i in input().split()]
res = 1
max1 = 1
try:
	for i in range(n):
		if a[i + 1] >= a[i]:
			res += 1
		else:
			if res > max1:
				max1 = res
			res = 1
except:
	if res > max1:
		max1 = res
print(max1)


n = int(input())
str_arr = input().split(' ')
arr = [int(num) for num in str_arr]
q = []
q.append(1)
c = 1
for i in range(n):
	if i == 0:
		continue
	if arr[i] >= arr[i - 1]:
		q.append(q[i - 1] + 1)
	else:
		q.append(1)
	c = max(c, q[i])
print(c)


n = int(input())
flag = 0
count = 1
newcount = 1
ar = list(map(int, input().split(' ')))[:n]
result = [ar[0]]
for i in range(1, len(ar)):
	if result[-1] <= ar[i]:
		result.append(ar[i])
		count = len(result)
		if newcount < count:
			newcount = count
	else:
		if newcount < count:
			newcount = count
		result.clear()
		result.append(ar[i])
print(newcount)


n = int(input())
arr = list(map(int, input().split()))
if n > 1:
	i = 1
	count = 0
	l = []
	while i < n:
		if arr[i - 1] <= arr[i]:
			count += 1
			i += 1
			if i == n:
				l.append(count)
		else:
			l.append(count)
			count = 0
			i += 1
	print(max(l) + 1)
else:
	print(1)


def logic1(n, numbers):
	final = []
	count = 1
	for i in range(int(n) - 1):
		if numbers[i] <= numbers[i + 1]:
			count = count + 1
		else:
			final.append(count)
			count = 1
	final.append(count)
	return max(final)
n = input()
numbers = [int(i) for i in input().split()]
print(logic1(n, numbers))


num = input()
lis = [int(x) for x in input().split()]
lis2 = []
k = 0
if len(lis) == 1:
	print(1)
else:
	for i in range(len(lis) - 1):
		if lis[i] <= lis[i + 1]:
			k += 1
			lis2.append(k)
		else:
			lis2.append(k)
			k = 0
	print(max(lis2) + 1)


n = int(input())
nbrs = list(map(int, input().split()))
res = 1
tmp = 1
for i in range(n - 1):
	if nbrs[i] <= nbrs[i + 1]:
		tmp += 1
	else:
		res = max(tmp, res)
		tmp = 1
res = max(tmp, res)
print(res)


n = int(input())
a = [int(i) for i in input().split()]
m = 0
b = []
c = []
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		if len(b) == 0:
			b.append(a[i])
		b.append(a[i + 1])
	else:
		c.append(b)
		b = []
c.append(b)
f = 0
for k in range(len(c)):
	if f < len(c[k]):
		f = len(c[k])
if f == 0:
	f += 1
print(f)


input()
salary = map(int, input().split())
biggest = 1
current_max = 0
previous = 0
for i in salary:
	if i >= previous:
		current_max += 1
	else:
		biggest = max(biggest, current_max)
		current_max = 1
	previous = i
print(max(biggest, current_max))


n = int(input())
r = list(input().split(sep=' '))
count = 1
res = [1]
for i in range(n - 1):
	if int(r[i]) <= int(r[i + 1]):
		count += 1
	else:
		count = 1
	res.append(count)
print(max(res))


n = int(input())
arr = list(map(int, input().split()))
co = 0
ind = 0
while ind < n:
	i = 0 + ind
	while i + 1 < n and arr[i + 1] >= arr[i]:
		i += 1
	res = i - ind + 1
	if res > co:
		co = res
	ind = i + 1
print(co)


n = int(input())
arr = list(map(int, input().split()))
i = 0
j = 0
ml = 0
k = 0
if n == 1:
	print(1)
else:
	while i < n - 1:
		if arr[i] <= arr[i + 1]:
			j = i + 1
			while j < n:
				k = 1
				if arr[j - 1] > arr[j]:
					break
				j += 1
			if j - i > ml:
				ml = j - i
			i = j - 1
		i += 1
	print(ml if ml > 0 else 1)


n = int(input())
n_i = input().split(' ')
n_i = list(map(int, n_i))
counter = 0
all_digits = []
for i in range(n - 1):
	if n_i[i] <= n_i[i + 1]:
		counter += 1
		all_digits.append(counter)
		if i + 1 == n - 1:
			counter += 1
			all_digits.append(counter)
	else:
		counter += 1
		all_digits.append(counter)
		counter = 0
if n == 1:
	counter += 1
	all_digits.append(counter)
print(max(all_digits))


n = int(input())
ncount = 0
org = 0
l = []
li = list(input().split())
for num in li:
	if int(num) >= org:
		ncount += 1
		org = int(num)
		l.append(ncount)
	else:
		l.append(ncount)
		ncount = 1
		org = int(num)
print(max(l))


import math
n = int(input())
s = [int(i) for i in input().split()]
b = []
c = 1
for i in range(len(s)):
	if i == len(s) - 1:
		break
	elif s[i] <= s[i + 1]:
		c += 1
	elif s[i] > s[i + 1]:
		c = 1
	b += [c]
if n == 1:
	print(1)
elif n == 0:
	print(0)
else:
	print(max(b))


n = int(input())
ar = list(map(int, input().split()))
i = 1
mx = 0
l = 1
while i < n:
	if ar[i] >= ar[i - 1]:
		l += 1
		mx = max(mx, l)
	else:
		l = 1
	i += 1
print(max(mx, l))


n = int(input())
l = list(map(int, input().split()))
curr = 1
ans = 0
for i in range(1, n):
	if l[i] >= l[i - 1]:
		curr += 1
		continue
	ans = max(curr, ans)
	curr = 1
ans = max(ans, curr)
print(ans)


n = int(input())
a = list(map(int, input().strip().split(' ')))
maxchain = 1
k = 1
for i in range(1, n):
	if a[i - 1] <= a[i]:
		k += 1
	else:
		k = 1
	if maxchain < k:
		maxchain = k
print(maxchain)


n = int(input())
arr = list(map(int, input().split(' ')))
prev = arr[0]
count = 1
maxCount = 0
i = 0
while i < n - 1:
	i += 1
	if arr[i] < prev:
		if count > maxCount:
			maxCount = count
		count = 1
	else:
		count += 1
	prev = arr[i]
if count > maxCount:
	maxCount = count
print(maxCount)


days = int(input())
money = list(map(int, input().split()))
temp = 1
count = 1
for i in range(1, days):
	if days == 1:
		break
	if money[i - 1] <= money[i]:
		temp = temp + 1
	else:
		temp = 1
	if temp > count:
		count = temp
print(count)


n = int(input())
money = [int(x) for x in input().split()]
d = money[0]
x = [1] * n
for i in range(1, n):
	if money[i] >= d:
		x[i] = x[i - 1] + 1
	d = money[i]
x.sort()
print(x[n - 1])


n = int(input())
a = [int(x) for x in input().split()]
c = 1
m = 0
k = 0
for i in range(n - 1):
	if a[i + 1] >= a[i]:
		c += 1
		if c > m:
			m = c
	else:
		c = 1
		k += 1
if k == n - 1:
	print('1')
else:
	print(m)


n_days = int(input())
moneys = [int(x) for x in input().split()]
max_sq_length = 1
curr_sq_length = 1
for i in range(1, n_days):
	if moneys[i] >= moneys[i - 1]:
		curr_sq_length += 1
		if curr_sq_length > max_sq_length:
			max_sq_length = curr_sq_length
	else:
		curr_sq_length = 1
print(max_sq_length)


n = int(input())
numbers = [int(i) for i in input().split()]
ans = []
s = 1
for i in range(n):
	try:
		if numbers[i] <= numbers[i + 1]:
			s += 1
		else:
			ans.append(s)
			s = 1
	except:
		ans.append(s)
print(max(ans))


n = int(input())
(a, b) = (1, 1)
c = list(map(int, input().split()))
for i in range(n - 1):
	a += 1
	if c[i] > c[i + 1]:
		a = 1
	elif a > b:
		b = a
print(b)


n = int(input())
l = list(map(int, input().split()))
curr = 1
best = 1
for i in range(1, len(l)):
	if l[i] >= l[i - 1]:
		curr += 1
	else:
		best = max(best, curr)
		curr = 1
print(max(best, curr))


n = int(input())
a = list(map(int, input().split()))
segment = 1
answer = 1
for i in range(0, n):
	if i + 1 < n and a[i] <= a[i + 1]:
		segment += 1
	else:
		answer = max(answer, segment)
		segment = 1
print(answer)


n = int(input())
a = list(map(int, input().split()))
i = 1
n_d_c = []
n_d_c.append(1)
while 1:
	if i < n:
		if a[i - 1] <= a[i]:
			n_d_c[-1] += 1
		else:
			n_d_c.append(1)
	else:
		break
	i += 1
print(max(n_d_c))


n = int(input())
s = list(map(int, input().split()))
val = 0
max_value = 0
k = 0
while k != n - 1:
	if s[k] <= s[k + 1]:
		val += 1
		if val > max_value:
			max_value = val
	else:
		val = 0
	k += 1
print(max_value + 1)


n = int(input())
l = list(map(int, input().split()))
(i, j, k) = (0, 1, 1)
while i + j - 1 in range(n) and i + j in range(n):
	if l[i + j] >= l[i + j - 1]:
		j += 1
		k = max(k, j)
	else:
		k = max(k, j)
		i += j
		j = 1
print(k)


tyi = int(input())
s = [int(n) for n in input().split()]
v = []
s.append(-1)
for n in range(1, len(s)):
	if s[n] < s[n - 1]:
		v.append(n)
g = [[] for n in range(len(v))]
v.append(0)
op = []
v.sort()
m = 0
for n in range(1, len(v)):
	op.append(v[n] - v[n - 1])
print(max(op))


n = input()
l = input()
li = l.split()
lis = []
for j in li:
	lis.append(int(j))
max_total = 1
max_temporal = 1
initial = 0
for i in range(initial + 1, int(n)):
	if lis[i] >= lis[i - 1]:
		max_temporal += 1
	elif max_temporal > max_total:
		max_total = max_temporal
		max_temporal = 1
	else:
		max_temporal = 1
if max_temporal > max_total:
	max_total = max_temporal
print(max_total)


length = int(input())
numArr = [int(i) for i in input().split()]
local = 1
maximum = 1
for i in range(1, length):
	if numArr[i] >= numArr[i - 1]:
		local += 1
	else:
		local = 1
	maximum = max(local, maximum)
print(maximum)


n = int(input())
a = list(map(int, input().split()))
msub = tsub = 1
for i in range(n - 1):
	if a[i + 1] >= a[i]:
		tsub += 1
	else:
		tsub = 1
	if msub < tsub:
		msub = tsub
print(msub)


def main(num, lst):
	count = 1
	temp = 1
	for i in range(1, num):
		if lst[i - 1] <= lst[i]:
			temp += 1
		else:
			temp = 1
		count = max(count, temp)
	return count
num = int(input())
lst = list(map(int, input().split()))
print(main(num, lst))


import sys

def main():
	input()
	money = [int(x) for x in sys.stdin.readline().split()]
	count = 0
	ans = []
	for i in range(1, len(money)):
		if money[i - 1] <= money[i]:
			count += 1
		else:
			ans.append(count)
			count = 0
	ans.append(count)
	sys.stdout.write('{}'.format(max(ans) + 1))
main()


n = int(input())
a = list(map(int, input().split()))
count = 1
listy = []
if n < 2:
	r = 1
else:
	r = n - 1
for i in range(r):
	if n == 1:
		listy.append(count)
	elif a[i + 1] >= a[i]:
		count += 1
		listy.append(count)
	else:
		count = 1
		listy.append(count)
print(max(listy))


from math import inf
n = int(input())
numbers = [int(x) for x in input().split()]
count = tcount = 0
max = -inf
for num in numbers:
	if num >= max:
		count += 1
		max = num
	else:
		if count >= tcount:
			tcount = count
		count = 1
		max = num
if tcount > count:
	print(tcount)
else:
	print(count)


n = int(input())
a = list(map(int, input().split()))
m = 1
current = 1
for k in range(1, n):
	if a[k] >= a[k - 1]:
		current += 1
	else:
		m = max(m, current)
		current = 1
print(max(m, current))


useless = int(input())
numbers = input().split(' ')
for i in range(len(numbers)):
	numbers[i] = int(numbers[i])
counter = 0
counterlis = []
for i in range(len(numbers)):
	try:
		if numbers[i] <= numbers[i + 1]:
			counter += 1
		else:
			counterlis.append(counter)
			counter = 0
	except IndexError:
		break
if len(counterlis) == 0 or counter > max(counterlis):
	print(counter + 1)
else:
	print(max(counterlis) + 1)


n = int(input())
i = 1
arr = []
arr = [int(i) for i in input().split()]
max = 1
count = 1
j = 0
while j < len(arr) - 1:
	if arr[j] <= arr[j + 1]:
		count += 1
		if count > max:
			max = count
	else:
		count = 1
	j += 1
print(max)


n = int(input())
l = (input() + ' -1').split(' ')
i = 1
k = 1
m = 0
while i <= n:
	if int(l[i]) >= int(l[i - 1]):
		k += 1
	else:
		if k > m:
			m = k
		k = 1
	i += 1
print(m)


def solve():
	n = int(input())
	money = [int(x) for x in input().split()]
	best = 1
	count = 1
	for i in range(1, n):
		if money[i] >= money[i - 1]:
			count += 1
			best = max(best, count)
		else:
			count = 1
	print(best)
	return
solve()


dp = [1] * 100001

def solve(arr, n):
	ans = -1
	if n == 1:
		return 1
	for i in range(1, n):
		if arr[i - 1] <= arr[i] and dp[i - 1] + 1 > dp[i]:
			dp[i] = dp[i - 1] + 1
		ans = max(ans, dp[i])
	return ans
n = int(input())
arr = list(map(int, input().split()))
ans = solve(arr, n)
print(ans)


n = int(input())
a = map(int, input().split())
c = next(a)
k = 1
b = 1
for i in a:
	if c <= i:
		k += 1
		c = i
	else:
		k = 1
		c = i
	b = max(k, b)
print(b)


n = int(input())
seq = [int(x) for x in input().split()]
ans = 1
tmp = 1
for i in range(1, n):
	if seq[i] < seq[i - 1]:
		ans = max(ans, tmp)
		tmp = 0
	tmp += 1
ans = max(ans, tmp)
print(ans)


n = int(input())
L = [int(x) for x in input().split()]
count = 1
m = 1
for i in range(1, n):
	if L[i] >= L[i - 1]:
		count = count + 1
		m = max(m, count)
	else:
		count = 1
print(m)


n = int(input())
a = [int(x) for x in input().split()]
m = 1
l = 0
for i in range(n - 1):
	if a[i + 1] >= a[i]:
		if l == 0:
			l += 2
		else:
			l += 1
	else:
		l = 0
	if l > m:
		m = l
print(m)


n = int(input())
a = list(map(int, input().split()))
best = 1
cur = 1
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		cur += 1
	else:
		if best < cur:
			best = cur
		cur = 1
if cur > best:
	best = cur
print(best)


N = int(input())
A = list(map(int, input().split()))
index = []
count = 1
for i in range(N - 1):
	if A[i + 1] >= A[i]:
		count += 1
	else:
		index.append(count)
		count = 1
index.append(count)
print(max(index))


def main():
	n = int(input())
	a = list(map(int, input().split()))
	tot_max = 0
	temp_max = 1
	for i in range(1, n):
		if a[i - 1] <= a[i]:
			temp_max += 1
		else:
			tot_max = max(tot_max, temp_max)
			temp_max = 1
	print(max(tot_max, temp_max))
main()


n = int(input())
(_len, prev, ans) = (0, 0, 0)
for x in input().split():
	a = int(x)
	if a >= prev:
		_len += 1
	else:
		ans = _len if ans < _len else ans
		_len = 1
	prev = a
print(_len if ans < _len else ans)


n = int(input())
num = list(map(int, input().split()))
Max = 0
i = 0
while i < n:
	j = i + 1
	while j < n and num[j] >= num[j - 1]:
		j += 1
	Max = max(Max, j - i)
	i = j
print(Max)


n = int(input())
x = input().split()
for j in range(n):
	x[j] = int(x[j])
t = 1
u = 0
for i in range(n - 1):
	if x[i + 1] >= x[i]:
		t += 1
	else:
		if t > u:
			u = t
		t = 1
if u >= t:
	print(u)
else:
	print(t)


num = int(input())
income_lis = input()
income_lis = income_lis.split()
income_lis = [int(i) for i in income_lis]
max_non_dec = 1
end_flag = False
counter = 0
while counter < num - 1:
	temp_count = 1
	for j in range(counter, num - 1):
		if income_lis[j + 1] >= income_lis[j]:
			temp_count += 1
		else:
			counter = j + 1
			break
		if j == num - 2:
			end_flag = True
			break
	if temp_count > max_non_dec:
		max_non_dec = temp_count
	if end_flag:
		break
print(max_non_dec)


n = int(input())
l = [int(x) for x in input().split()]
s = 1
result = 1
for i in range(1, n):
	if l[i] < l[i - 1]:
		s = 1
	else:
		s += 1
	result = max(result, s)
print(result)


n_days = int(input())
money_money_list = [int(i) for i in input().split(' ')]
best_so_far = 0
current_subsequence = 0
last_money_money = -1
for i_day in range(n_days):
	money_money = money_money_list[i_day]
	if money_money >= last_money_money:
		current_subsequence += 1
	else:
		best_so_far = max(current_subsequence, best_so_far)
		current_subsequence = 1
	last_money_money = money_money
best_so_far = max(current_subsequence, best_so_far)
print(best_so_far)


input()
sri = r = s = 0
for k in map(int, input().split()):
	sri = [sri + 1, 1][k < s]
	r = max(r, sri)
	s = k
print(r)


length = int(input())
nums = list(map(int, input().split()))
current = 0
max_nondec = 0
prev = float('-inf')
for elem in nums:
	if elem >= prev:
		current += 1
	else:
		if max_nondec < current:
			max_nondec = current
		current = 1
	prev = elem
if max_nondec < current:
	max_nondec = current
print(max_nondec)


N = int(input())
moneys = [int(i) for i in input().split(' ')]
dp = [0 for _ in range(N)]
dp[0] = 1
for i in range(1, N):
	dp[i] = dp[i - 1] + 1 if moneys[i] >= moneys[i - 1] else 1
print(max(dp))


n = int(input())
count = 1
maxn = 0
lst = list(map(int, input().split()))
for i in range(1, n):
	if lst[i] >= lst[i - 1]:
		count += 1
	else:
		maxn = max(maxn, count)
		count = 1
		flag = 1
maxn = max(maxn, count)
print(maxn)


n = int(input())
a = [int(x) for x in input().split()]
ans = 1
cnt = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		cnt += 1
		ans = max(ans, cnt)
	else:
		cnt = 1
print(ans)


n = int(input())
num = list(map(int, input().split()))
maior = 1
cont = 1
for i in range(1, n):
	if num[i] >= num[i - 1]:
		cont += 1
		maior = max(cont, maior)
	else:
		cont = 1
print(maior)


n = int(input())
a = input().split()
sol = []
count = 1
for i in range(1, n, 1):
	if int(a[i - 1]) <= int(a[i]):
		count += 1
	else:
		sol.append(count)
		count = 1
		continue
sol.append(count)
print(max(sol))


x = int(input())
y = input()
y = y.split()
c = 1
cc = []
f = 0
k = 0
if x == 1:
	print('1')
else:
	for i in range(len(y) - 1):
		if int(y[i]) <= int(y[i + 1]):
			c = c + 1
			f = 1
			k = 0
		else:
			f = 0
			c = 1
			k = 1
		cc.append(c)
	if len(cc) == 0 and k == 1:
		print(0)
	else:
		cc.sort()
		print(cc[len(cc) - 1])


count = int(input())
data = list(map(int, input().split()))
if len(data) == 1:
	print(1)
else:
	j = 0
	data_res = [[]]
	for i in range(len(data)):
		if i == len(data) - 1:
			if data[i] >= data[i - 1]:
				data_res[j].append(data[i])
				break
			else:
				data_res.append([data[i]])
				break
		if data[i] <= data[i + 1]:
			data_res[j].append(data[i])
		else:
			data_res[j].append(data[i])
			data_res.append([])
			j += 1
	print(max(map(len, data_res)))


n = int(input())
x = input()
y = x.split()
z = [int(d) for d in y]
l = [1]
count = 1
for i in range(1, n):
	if z[i] >= z[i - 1]:
		count = count + 1
		l.append(count)
	else:
		count = 1
print(max(l))


n = int(input())
a = [int(x) for x in input().split()]
i = 0
l = 1
lenth = [1]
if n > 1:
	while i < n - 1:
		if a[i] <= a[i + 1]:
			l = l + 1
			lenth.append(l)
		else:
			l = 1
		i = i + 1
lenth.sort(reverse=True)
print(lenth[0])


n = int(input())
arr = list(map(int, input().split()))
arr.append(-1)
c = 0
m = []
for x in range(len(arr) - 1):
	if arr[x] <= arr[x + 1]:
		c += 1
	else:
		m.append(c)
		c = 0
print(max(m) + 1)


n = int(input())
a = list(map(int, input().split()))
a.insert(0, 0)
g = 1
p = print
(mx, mn, ans) = (-int(1e+18), int(1e+18), 0)
mx = 1
for i in range(2, n + 1):
	if a[i] >= a[i - 1]:
		g += 1
	else:
		g = 1
	mx = max(mx, g)
print(mx)


x = int(input())
y = list(map(int, input().split()))
count_local_max = 0
count_global_max = 0
for i in range(x):
	if y[i - 1] > y[i]:
		count_local_max = 0
	count_local_max += 1
	if count_global_max < count_local_max:
		count_global_max = count_local_max
print(count_global_max)


n = int(input())
a = list(map(int, input().split()))
c = 1
maxc = -float('inf')
for i in range(0, n - 1):
	if a[i] > a[i + 1]:
		c = 1
	else:
		c += 1
	if maxc < c:
		maxc = c
if maxc < c:
	maxc = c
print(maxc)


n = int(input())
arr = [int(i) for i in input().split()]
best = 1
current = 1
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		current += 1
	else:
		best = max(best, current)
		current = 1
best = max(best, current)
print(best)


n = int(input())
x = input()
y = x.split(' ')
cnt = 1
mx = 1
for i in range(n - 1):
	if int(y[i]) <= int(y[i + 1]):
		cnt = cnt + 1
	else:
		if mx < cnt:
			mx = cnt
		cnt = 1
if mx < cnt:
	mx = cnt
print(mx)


num = int(input())
greatest = 0
length = 1
line = [int(i) for i in input().split()]
for i in range(1, len(line)):
	if length > greatest:
		greatest = length
	if line[i] >= line[i - 1]:
		length += 1
	else:
		length = 1
if length > greatest:
	greatest = length
print(str(greatest))


n = int(input())
L = list(map(int, input().split()))
a = 1
m = 0
v = L[0]
for i in range(1, n):
	if L[i] >= v:
		a += 1
	else:
		if a > m:
			m = a
		a = 1
	v = L[i]
print(max([a, m]))


n = int(input())
num = input().split()
tmp = 1.0
maxx = 1.0
for i in range(n - 1):
	tmp = tmp + 1 if int(num[i + 1]) >= int(num[i]) else 1
	maxx = max(maxx, tmp)
print(str(int(maxx)))


n = int(input())
lst = []
lst1 = []
lst1.append(1)
lst = [int(i) for i in input().split()][:n]
for i in range(1, n):
	if lst1[i - 1] >= 1 and lst[i] >= lst[i - 1]:
		l = lst1[i - 1] + 1
		lst1.append(l)
	else:
		lst1.append(1)
j = max(lst1)
print(j)


num = int(input())
first = list(map(int, input().split()))
a = []
first.append(0)
b = [0]
for i in range(0, num + 1):
	a.append(first[i])
	if i + 1 == num + 1:
		break
	if first[i] > first[i + 1]:
		b.append(len(a))
		a = []
ans = max(b)
if ans == 0:
	print(len(a))
else:
	print(ans)


n = int(input())
lst = [int(x) for x in input().split()]
val = 1
c = 1
for x in range(0, n - 1):
	if lst[x] > lst[x + 1]:
		if c < val:
			c = val
		val = 1
	else:
		val += 1
print(max(c, val))


n = int(input())
A = input()
B = list(map(int, A.split(' ')))
mx = 0
nw = 0
for i in range(n):
	if i == 0:
		mx = 1
		nw = 1
		continue
	if B[i] >= B[i - 1]:
		nw += 1
		mx = max(mx, nw)
	else:
		nw = 1
		mx = max(mx, 1)
print(mx)


n = int(input())
count = 0
maxcount = []
x = list(map(int, input().split()))
for i in range(n - 1):
	j = i + 1
	if x[i] <= x[j]:
		count += 1
	if x[i] > x[j]:
		maxcount.append(count)
		count = 0
if len(maxcount) == 0 or max(maxcount) < count:
	print(count + 1)
else:
	print(max(maxcount) + 1)


input()
(t, li, l) = (input().split(' '), 0, [])
for (i, a) in enumerate(t):
	if i + 1 < len(t) and int(a) > int(t[i + 1]) or i + 1 == len(t):
		l.append(len(t[li:i + 1]))
		li = i + 1
l.sort(reverse=True)
print(l[0])


n = int(input())
cnt = 0
cnt_max = 0
a = list(map(int, input().split()))
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		cnt += 1
		if cnt > cnt_max:
			cnt_max = cnt
	else:
		cnt = 0
print(cnt_max + 1)


n = int(input())
a = [int(i) for i in input().split()]
k = [1]
s = 1
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		s += 1
		k.append(s)
	else:
		s = 1
print(max(k))


n = int(input())
a = list(map(int, input().split()))
l = [a[0]]
cnts = []
prev = a[0]
for i in range(1, n):
	if a[i] >= prev:
		l.append(a[i])
	else:
		cnts.append(len(l))
		l = [a[i]]
	prev = a[i]
cnts.append(len(l))
print(max(cnts))


n = int(input())
l = [int(x) for x in input().split()]
m = 1
p = l[0]
c = 0
for i in l:
	if i - p < 0:
		m = max(m, c)
		c = 1
	else:
		c += 1
	p = i
m = max(m, c)
print(m)


n = int(input())
a = [int(x) for x in input().split()]
Ans = -1
cnt = 1
for i in range(0, n - 1):
	if a[i] <= a[i + 1]:
		cnt += 1
	elif a[i] > a[i + 1]:
		Ans = max(Ans, cnt)
		cnt = 1
Ans = max(Ans, cnt)
print(Ans)


size = int(input())
arr = [int(n) for n in input().split()]
prev = -1
count = 0
seq = 0
for i in arr:
	if i >= prev:
		prev = i
		count += 1
		seq = max(seq, count)
	else:
		prev = i
		count = 1
print(seq)


n = int(input())
roster = input().split()
for i in range(n):
	roster[i] = int(roster[i])
roster.append(-1)
n += 1
max_length = 0
mini = 0
maxi = 0
i = 1
while i < n:
	if roster[i] >= roster[i - 1]:
		mini = i - 1
		for k in range(i, n):
			if roster[k] >= roster[k - 1]:
				maxi = k
			else:
				i = k
				if maxi - mini > max_length:
					max_length = maxi - mini
				break
	i += 1
print(max_length + 1)


n = int(input())
a = list(map(int, input().split()))
sub = 1
maxsub = 1
for i in range(1, n):
	if a[i - 1] <= a[i]:
		sub += 1
		if maxsub < sub:
			maxsub = sub
	else:
		sub = 1
print(maxsub)


n = int(input())
li = input().split()
line = []
for l in li:
	line.append(int(l))
count = n * [1]
c = int(0)
if n == 1:
	print(1)
else:
	for i in range(1, n):
		if line[i] >= line[i - 1]:
			count[c] += 1
		else:
			c += 1
	count.sort()
	print(int(count[n - 1]))


n = int(input())
s = [int(a) for a in input().split(' ')]
max_dlina_tmp = 0
max_dlina = 0
for i in range(1, n):
	if s[i] >= s[i - 1]:
		max_dlina_tmp += 1
	else:
		max_dlina = max(max_dlina_tmp, max_dlina)
		max_dlina_tmp = 0
max_dlina = max(max_dlina_tmp, max_dlina)
print(max_dlina + 1)


N = int(input())
values = list(map(int, input().split()))
last = -9999999
current = 0
maxi = 0
for i in range(N):
	if values[i] >= last:
		current += 1
	else:
		current = 1
	if current > maxi:
		maxi = current
	last = values[i]
print(maxi)


try:
	n = int(input())
	l = list(map(int, input().split()))
	(c, max) = (0, 0)
	for i in range(1, n):
		if l[i] >= l[i - 1]:
			c = c + 1
		else:
			if max <= c:
				max = c
			c = 0
	if max <= c:
		max = c
	print(max + 1)
except:
	pass


n = int(input())
a = [int(i) for i in input().split()]
m = 1
li = []
if n == 1:
	li = [1]
else:
	for i in range(n - 1):
		if a[i] <= a[i + 1]:
			m += 1
			li.append(m)
		else:
			m = 1
if li == []:
	print(1)
else:
	print(max(li))


progresList = []
lstZar = []
n = input()
lstZar = input().split()
lstZar = list(map(int, lstZar))
count = 1
for i in range(1, len(lstZar)):
	if lstZar[i - 1] <= lstZar[i]:
		count = count + 1
	else:
		progresList.append(int(count))
		count = 1
progresList.append(int(count))
progresList.sort(reverse=True)
print(progresList[0])


n = input()
lst = []
a = input().strip()
lst = list(map(int, a.split(' ')))
mx_tl_here = int()
mx_so_far = int()
prev = int()
prev = lst[0]
mx_so_far = 1
mx_tl_here = 1
for i in range(1, int(n)):
	if lst[i] >= prev:
		mx_tl_here += 1
		if mx_tl_here > mx_so_far:
			mx_so_far = mx_tl_here
		prev = lst[i]
	else:
		mx_tl_here = 1
		prev = lst[i]
print(mx_so_far)


n = int(input())
mas = list(map(int, input().split()))
kol = 1
m = 1
for i in range(len(mas) - 1):
	if mas[i + 1] >= mas[i]:
		kol += 1
	else:
		m = max(m, kol)
		kol = 1
m = max(m, kol)
print(m)


trash = input()
arr = input().split()
arr = [int(x) for x in arr]
longest_span = 1
span = 1
for i in range(1, len(arr)):
	if arr[i] >= arr[i - 1]:
		span += 1
	else:
		if span > longest_span:
			longest_span = span
		span = 1
	if span > longest_span:
		longest_span = span
print(longest_span)


n = int(input())
r = list(map(int, input().split()))
i = 0
j = 1
m = 1
k = 1
while j < len(r):
	while r[j] >= r[i]:
		k += 1
		j += 1
		i += 1
		if j >= len(r):
			break
	i += 1
	j += 1
	m = max(m, k)
	k = 1
print(m)


n = int(input(''))
ar = list(map(int, input().strip().split(' ')))
max = 0
cnt = 1
for i in range(0, n - 1):
	if ar[i] > ar[i + 1]:
		if cnt > max:
			max = cnt
		cnt = 1
	else:
		cnt = cnt + 1
if cnt > max:
	max = cnt
print(max)


input()
inputs = [int(x) for x in input().split()]
if len(inputs) == 1:
	print(1)
	exit()
de = []
len1 = 1
for i in range(1, len(inputs)):
	if inputs[i - 1] <= inputs[i]:
		len1 += 1
		if i + 1 == len(inputs):
			de.append(len1)
	else:
		de.append(len1)
		len1 = 1
print(max(de))


n = int(input())
l = list(map(int, input().split()))
w = 1
i = 1
while i < n:
	if l[i] >= l[i - 1]:
		k = i - 1
		while i < n:
			if l[i] < l[i - 1]:
				break
			i += 1
		w = max(i - k, w)
	else:
		i += 1
print(w)


n = int(input())
xlist = list(map(int, input().split()))
num = 0
NUM = 0
for i in range(n - 1):
	if xlist[i] <= xlist[i + 1]:
		num += 1
		NUM = NUM if NUM > num else num
	else:
		num = 0
print(NUM + 1)


def inc(lis):
	ini = lis[0]
	c = 1
	arr = []
	for i in range(len(lis)):
		if i == 0:
			pass
		elif lis[i] >= ini:
			c += 1
			ini = lis[i]
		else:
			ini = lis[i]
			arr.append(c)
			c = 1
	arr.append(c)
	return max(arr)
n = input().strip()
lis = list(map(int, input().strip().split(' ')))
print(inc(lis))


n = int(input())
arr = list(map(int, input().split()))
c = 1
count = float('-inf')
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		c += 1
	else:
		count = max(count, c)
		c = 1
count = max(count, c)
print(count)


n = int(input())
a = [int(x) for x in input().split(' ')]
c = 0
aNew = []
if len(a) == 1:
	print(1)
	exit(0)
for i in range(0, len(a) - 1):
	if a[i] <= a[i + 1]:
		c += 1
		aNew.append(c)
	else:
		aNew.append(c)
		c = 0
print(int(max(aNew)) + 1)


n = int(input())
a = [int(i) for i in input().strip().split()]
s = 1
lst = []
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		s += 1
	else:
		lst.append(s)
		s = 1
lst.append(s)
print(max(lst))


input()
arr = [int(x) for x in input().split()]
pre = 0
ans = 0
cur = 0
for num in arr:
	if num >= pre:
		cur += 1
	else:
		cur = 1
	ans = max(ans, cur)
	pre = num
print(ans)


n = int(input())
s = input().split()
j = 0
k = 0
lst = [0]
while j < n - 1:
	if int(s[j]) <= int(s[j + 1]):
		k += 1
		if j + 1 == n - 1:
			lst.append(k)
		j += 1
	else:
		lst.append(k)
		k = 0
		j += 1
print(max(lst) + 1)


n = int(input())
s = list(map(int, input().split()))
(x, k) = (1, 1)
for i in range(1, n):
	x += 1
	if s[i] < s[i - 1]:
		x = 1
	if x > k:
		k = x
print(k)


x = int(input())
a = list(map(int, input().split()))
j = 1
i = 0
d = []
while j < x:
	if a[j] >= a[j - 1]:
		j += 1
	else:
		d.append(j - i)
		i = j
		j += 1
d.append(j - i)
print(max(d))


import pdb
n = int(input())
k = list(map(int, input().split()))
count = 0
count_list = []
for i in range(n):
	if i == n - 1:
		count_list.append(count)
		count = 0
		break
	if k[i] <= k[i + 1]:
		count += 1
	else:
		count_list.append(count)
		count = 0
print(max(count_list) + 1)


n = int(input())
a = list(input().split())
b = []
for i in range(n):
	b.append(int(a[i]))
c = []
i = 0
k = 1
while i < n - 1:
	if b[i] <= b[i + 1]:
		k = k + 1
	else:
		c.append(k)
		k = 1
	i = i + 1
c.append(k)
c = sorted(c)
print(c[len(c) - 1])


n = int(input())
s = input().split(' ')
t = 0
m = 0
a = 0
for i in range(0, n - 1):
	if a == 0:
		t = 0
	a = 0
	if int(s[i]) <= int(s[i + 1]):
		t += 1
		a = 1
	if a == 1:
		if t > m:
			m = t
print(m + 1)


x = int(input())

def intmaker(arr):
	for i in range(len(arr)):
		arr[i] = int(arr[i])
	return arr
y = intmaker(input().split())
count = 1
count2 = []
for i in range(x - 1):
	if y[i + 1] >= y[i]:
		count += 1
	elif y[i + 1] < y[i]:
		count2.append(count)
		count = 1
count2.append(count)
print(max(count2))


n = int(input())
a = list(map(int, input().split()))
l = 0
r = 1
ans = 0
while r < n:
	if a[r] < a[r - 1]:
		ans = max(ans, r - l)
		l = r
	r += 1
ans = max(ans, r - l)
print(ans)


import sys
n = int(input())
lista = [int(x) for x in input().strip().split()]
ena = [1] * len(lista)
for i in range(1, len(lista)):
	if lista[i] >= lista[i - 1]:
		ena[i] = ena[i - 1] + 1
print(max(ena))


num = int(input())
arr = input().split()
for i in range(num):
	arr[i] = int(arr[i])
i = 1
j = 0
c = 0
while i < len(arr):
	while arr[i - 1] <= arr[i]:
		j += 1
		i += 1
		if i == len(arr):
			break
	else:
		i += 1
	if j > c:
		c = j
	j = 0
	if i == len(arr):
		break
print(c + 1)


length = int(input())
longlist = list(map(int, input().split()))
k = 0
longest_string = 1
long = 1
i = 1
for i in range(0, length - 1):
	if longlist[i] <= longlist[i + 1]:
		long += 1
		if long > longest_string:
			longest_string = long
	elif longlist[i] > longlist[i + 1]:
		long = 1
		k += 1
		i = k
print(longest_string)


n = int(input())
data = [int(x) for x in input().split()]
dp = [0] * (n + 1)
for i in range(n):
	if i > 0 and data[i] >= data[i - 1]:
		dp[i + 1] = dp[i] + 1
	else:
		dp[i + 1] = 1
ans = 0
for i in range(1, n + 1):
	if dp[i] > ans:
		ans = dp[i]
print(ans)


z = int(input())
a = list(map(int, input().rstrip().split(' ')))
leng = 0
max_leng = 0
ind = 0
while ind < z - 1:
	if a[ind] <= a[ind + 1]:
		leng += 1
		if ind + 1 == z - 1 and a[z - 1] >= a[ind]:
			if max_leng < leng:
				max_leng = leng
	else:
		if max_leng < leng:
			max_leng = leng
		leng = 0
	ind += 1
print(max_leng + 1)


n = int(input())
a = [int(t) for t in input().split()]
c = 1
mc = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		c += 1
	else:
		c = 1
	if mc < c:
		mc = c
print(mc)


n = int(input())
sq = [int(x) for x in input().split()]
list1 = [1] * n
for i in range(1, n):
	if sq[i] >= sq[i - 1]:
		list1[i] += list1[i - 1]
print(max(list1))


total = input()
numbers = input()
numbers = list(map(int, numbers.split()))
answer = 0
tempAnswer = 0
lastNumber = -1
for number in numbers:
	if lastNumber == -1:
		tempAnswer += 1
	elif number < lastNumber:
		if tempAnswer > answer:
			answer = tempAnswer
		tempAnswer = 1
	else:
		tempAnswer += 1
	lastNumber = number
if tempAnswer > answer:
	print(tempAnswer)
else:
	print(answer)


n = int(input())
count = z = 1
l = []
w = list(map(int, input().split()))
for i in range(n - 1):
	if w[i + 1] >= w[i]:
		count += 1
		l.append(count)
	else:
		if z < count:
			z = count
			l.append(z)
		count = 1
l.append(z)
print(max(l))


n = int(input())
a = input().split(' ')
lst = [int(i) for i in a]
l = 1
maxs = 1
for i in range(n - 1):
	if lst[i] <= lst[i + 1]:
		l += 1
		if i == n - 2:
			if maxs < l:
				maxs = l
	else:
		if maxs < l:
			maxs = l
		l = 1
print(maxs)


n = int(input())
values = [int(i) for i in input().split()]
global_maxima = 1
local_maxima = 1
for i in range(len(values) - 1):
	if values[i + 1] >= values[i]:
		local_maxima += 1
		global_maxima = max(local_maxima, global_maxima)
	else:
		local_maxima = 1
print(global_maxima)


n = int(input())
lst = list(map(int, input().split()))
lst2 = [1]
x = 1
for i in range(n - 1):
	if lst[i + 1] >= lst[i]:
		x += 1
	else:
		lst2.append(x)
		x = 1
print(max(max(lst2), x))


n = int(input())
a = input().split(' ')
counter = 0
best = 0
for i in range(n):
	if int(a[i - 1]) <= int(a[i]):
		counter += 1
	else:
		counter = 1
	if best < counter:
		best = counter
print(best)


n = int(input())
q = [int(x) for x in input().split()]
res = 0
now = 0
was = 111111111
for x in q:
	if now == 0 or x >= was:
		now += 1
		was = x
		if now > res:
			res = now
	else:
		now = 1
		was = x
print(res)


x = int(input())
c = 0
p = []
u = 1
s = list(map(int, input().split()))
if len(s) == 1:
	print(x)
	u = 0
if u == 1:
	for n in range(0, x - 1):
		if s[n] <= s[n + 1]:
			c = c + 1
		else:
			p.append(c + 1)
			c = 0
	if c == 0:
		p.sort()
		l = len(p)
		print(p[l - 1])
	elif c != 0:
		p.append(c + 1)
		p.sort()
		l = len(p)
		print(p[l - 1])


import sys
from random import choice, randint
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def MI():
	return map(int, sys.stdin.readline().strip().split())

def LI():
	return list(map(int, sys.stdin.readline().strip().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines().strip()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().strip().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().strip().split()]

def LS():
	return sys.stdin.readline().strip().split()

def I():
	return int(sys.stdin.readline().strip())

def F():
	return float(sys.stdin.readline().strip())

def S():
	return sys.stdin.readline().strip()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))
inp = sys.stdin.readline
out = sys.stdout.write

def main():
	n = I()
	a = LI()
	(mx, i) = (0, 0)
	while i < n:
		j = i
		c = 1
		f = 1
		while j < n - 1 and a[j] <= a[j + 1]:
			f = 0
			c += 1
			j += 1
		if c > mx:
			mx = c
		if f == 1:
			i += 1
		else:
			i = j + 1
	pf(mx)
main()


n = int(input())
a = [int(x) for x in input().split()]
final1 = 1
ans = []
for i in range(1, n):
	if a[i] >= a[i - 1]:
		final1 += 1
	else:
		ans.append(final1)
		final1 = 1
ans.append(final1)
ans.sort(reverse=True)
print(ans[0])


n = int(input())
l = [int(x) for x in input().split()]
num = len(l)
m = c = 1
for i in range(1, num):
	if l[i - 1] <= l[i]:
		m += 1
	else:
		c = max(m, c)
		m = 1
	if i == num - 1:
		c = max(m, c)
print(c)


n = int(input())
uang = input().split()
total = 1
arr = []
step = 1
uang.append(0)
for i in range(1, len(uang)):
	if int(uang[i]) >= int(uang[i - 1]):
		step += 1
	else:
		step = 1
	if step > total:
		total = step
print(total)


n = int(input())
a = [int(x) for x in input().split()]
s = tuple(a)
d = 1
f = []
if n == 1:
	v = 1
	print(v)
else:
	for i in range(n - 1):
		if s[i] <= s[i + 1] and i != n - 2:
			d += 1
		elif s[i] > s[i + 1]:
			f.append(d)
			d = 1
		elif i + 1 == n - 1 and s[i] <= s[i + 1]:
			d += 1
			f.append(d)
	v = max(f)
	print(v)


n = int(input())
a = list(map(int, input().split()))
j = 0
i = 0
max_asc = 1
while i + 1 < n:
	while i + 1 < n and a[i] <= a[i + 1]:
		i += 1
	maxm = i - j + 1
	if maxm > max_asc:
		max_asc = maxm
	i += 1
	j = i
print(max_asc)


n = int(input())
a = [int(obj) for obj in input().split()]
ma = x = 1
for i in range(n - 1):
	if a[i + 1] >= a[i]:
		x += 1
		ma = max(ma, x)
	else:
		x = 1
print(ma)


def main():
	_ = int(input())
	nums = [int(x) for x in input().split()][::-1]
	max_cnt = 1
	cnt = 1
	top = nums.pop()
	while nums:
		num = nums.pop()
		if top <= num:
			cnt += 1
		else:
			cnt = 1
		top = num
		max_cnt = max(max_cnt, cnt)
	print(max_cnt)
main()


n = int(input())
m = input().split()
i = 0
x = 1
lst = []
while i < n - 1:
	if int(m[i]) > int(m[i + 1]):
		i += 1
		lst.append(x)
		x = 1
	else:
		x += 1
		i += 1
if int(m[len(m) - 2]) <= int(m[len(m) - 1]):
	lst.append(x)
print(max(lst))


input()
(max_seq, cur_seq, prev_el) = (1, 1, None)
arr = input().split()
for el in arr:
	el = int(el)
	cur_seq = cur_seq + 1 if prev_el and el >= prev_el else 1
	prev_el = el
	if cur_seq > max_seq:
		max_seq = cur_seq
print(max_seq)


t = int(input())
arr = [int(x) for x in input().split()]
count = 1
prev = 0
for i in range(1, t):
	if arr[i - 1] <= arr[i]:
		count += 1
		prev = max(prev, count)
	else:
		count = 1
print(max(prev, count))


n = int(input())
s = [int(i) for i in input().split()]
s.append(0)
count = 0
mx = 0
for i in range(n - 1):
	if s[i] <= s[i + 1]:
		count += 1
		if count >= mx:
			mx = count
	else:
		count = 0
print(mx + 1)


n = int(input())
last = -1
klast = 0
maxi = 1
for i in input().split():
	i = int(i)
	if last <= i:
		klast += 1
	else:
		maxi = max(maxi, klast)
		klast = 1
	last = i
maxi = max(maxi, klast)
print(maxi)


n = int(input())
money = [int(m) for m in input().split()]
count = 1
seq = 1
for (i, m) in enumerate(money):
	if i > 0:
		if m >= money[i - 1]:
			count += 1
			seq = max(seq, count)
		else:
			count = 1
print(seq)


n = int(input())
o = 0
x1 = 0
m = 0
for x in map(int, input().split()):
	if x >= x1:
		o += 1
		if o > m:
			m = o
	else:
		o = 1
	x1 = x
print(m)


n = int(input())
a = list(map(int, input().split()))
l = m = c = 0
for i in a:
	c = [c + 1, 1][i < l]
	m = max(m, c)
	l = i
print(m)


n = int(input())
x = list(map(int, input().split()))
m = 1
r = 1
for i in range(1, n):
	if x[i] >= x[i - 1]:
		m = m + 1
		r = max(r, m)
	else:
		r = max(r, m)
		m = 1
print(r)


n = int(input())
a = list(map(int, input().split()))
cont = 1
max = 1
for i in range(n - 1):
	if a[i + 1] >= a[i]:
		cont += 1
		if cont > max:
			max = cont
	else:
		cont = 1
print(max)


def solve(n, arr):
	dp = [0] * n
	dp[0] = 1
	for i in range(1, n):
		if arr[i] >= arr[i - 1]:
			dp[i] = 1 + dp[i - 1]
		else:
			dp[i] = 1
	return max(dp)

def main():
	n = int(input())
	s = input()
	arr = [int(x) for x in s.split(' ')]
	result = solve(n, arr)
	print(result)
main()


def max(l2):
	m = l2[0]
	for i in range(0, len(l2)):
		if l2[i] > m:
			m = l2[i]
	return m
n = int(input())
maximum = []
count = 1
l = input().split()
for i in range(0, len(l)):
	l[i] = int(l[i])
for i in range(0, n - 1):
	if l[i + 1] >= l[i]:
		count += 1
	else:
		maximum.append(count)
		count = 1
maximum.append(count)
if len(maximum) == 0:
	print(count)
else:
	print(max(maximum))


masukan1 = int(input())
masukan2 = input()
n = 0
m = 0
x = 0
for i in masukan2.split(' '):
	if x != 0:
		if int(i) >= int(x):
			n = n + 1
		else:
			n = 0
	x = i
	if n > m:
		m = n
print(m + 1)


n = int(input())
c = []
l = list(map(int, input().strip().split()))
l.append(-1)
(maxi, count) = (0, 0)
for i in l:
	if i >= maxi:
		count += 1
		maxi = i
		c.append(count)
	else:
		maxi = i
		count = 1
print(max(c))


n = int(input())
lst1 = list(map(int, input().split()))
ans = 0
i = 0
while i < n:
	k = i
	j = i
	while lst1[i] <= lst1[j]:
		i = j
		j += 1
		if j >= n:
			break
	ans = max(ans, j - k)
	i = j
ans = max(ans, j - k)
print(ans)


import sys
n = int(input())
a = list(map(int, input().split()))
if len(a) == 1:
	print(1)
	sys.exit()
b = []
c = []
b.append(a[0])
for i in range(1, n):
	x = b.pop()
	if a[i] >= x:
		b.append(x)
		b.append(a[i])
	else:
		while len(b) > 0:
			b.pop()
		b.append(a[i])
	c.append(len(b))
print(max(c))


n = int(input())
numbers = [int(i) for i in input().split()]
res = 1
total = 1
for i in range(n - 1):
	if numbers[i + 1] >= numbers[i]:
		res += 1
		if total < res:
			total = res
	else:
		res = 1
print(str(total))


(c, d) = (0, 0)
a = int(input())
b = [int(x) for x in input().split()]
for i in range(a - 1):
	if b[i] <= b[i + 1]:
		c += 1
		d = max(c, d)
	else:
		c = 0
print(d + 1)


n = int(input())
arr = list(map(int, input().split()))
c = 1
mx = 1
for i in range(n - 1):
	if arr[i] <= arr[i + 1]:
		c += 1
	else:
		mx = max(c, mx)
		c = 1
print(max(mx, c))


n = int(input())
lista = list(map(int, input().split(' ')))
maximo = 1
atual = 1
for i in range(len(lista) - 1):
	if lista[i] <= lista[i + 1]:
		atual += 1
	else:
		if atual > maximo:
			maximo = atual
		atual = 1
if atual > maximo:
	maximo = atual
print(maximo)


n = int(input())
sequence = list(map(int, input().split(' ')))
length = []
current = 0
for i in range(n):
	current += 1
	if i == n - 1:
		length.append(current)
	elif sequence[i] <= sequence[i + 1]:
		pass
	else:
		length.append(current)
		current = 0
maximum = length[0]
for x in length:
	if x > maximum:
		maximum = x
print(maximum)


n = int(input())
s = [int(i) for i in input().split()]
lenth = 0
maxLenth = 0
for i in range(1, n):
	if s[i] >= s[i - 1]:
		lenth = lenth + 1
		if lenth > maxLenth:
			maxLenth = lenth
	else:
		lenth = 0
print(maxLenth + 1)


n = int(input())
a = list(map(int, input().split()))
dm = 0
an = 0
dn = 0
for i in range(n):
	if a[i] >= an:
		dn += 1
		dm = max(dm, dn)
	if a[i] < an:
		dn = 1
	an = a[i]
print(dm)


n = int(input())
L = list(map(int, input().split()))
num = 1
Max = 1
for i in range(1, n):
	if L[i] >= L[i - 1]:
		num += 1
		Max = max(Max, num)
	else:
		num = 1
print(Max)


n = int(input())
ms = [int(x) for x in input().split()]
j = 1
pp = 1
while j < n:
	msx = 0
	while j < n and ms[j] >= ms[j - 1]:
		if msx is 0:
			msx = 2
		else:
			msx += 1
		j += 1
	if msx > pp:
		pp = msx
	j += 1
print(pp)


n = int(input())
moneyList = [int(a) for a in input().split()]
x = 0
cost0 = 0
cost1 = 0
bigNum = 0
for i in moneyList:
	cost1 = i
	if cost1 >= cost0:
		x += 1
	else:
		x = 1
	if x > bigNum:
		bigNum = x
	cost0 = i
print(bigNum)


input()
s = input().split()
for i in range(len(s)):
	s[i] = int(s[i])
ans = 0
temp = 0
counter = 0
for i in s:
	counter = 1 if i < temp else counter + 1
	ans = max(ans, counter)
	temp = i
print(ans)


t = int(input())
lst = list(map(int, input().split(' ')))
st = []
cou = 0
for i in lst:
	if len(st) == 0:
		st.append(i)
	elif i >= st[len(st) - 1]:
		st.append(i)
	else:
		if len(st) > cou:
			cou = len(st)
		st = []
		st.append(i)
if len(st) > cou:
	cou = len(st)
print(cou)


from sys import stdin, maxsize
(lines, line_index) = (stdin.readlines(), -1)

def get_line():
	global lines, line_index
	line_index += 1
	return lines[line_index]

def main():
	n = int(get_line())
	d = [int(x) for x in get_line().split()]
	dlen = 1
	tlen = 1
	for i in range(1, n):
		if d[i] >= d[i - 1]:
			tlen += 1
		else:
			tlen = 1
		if dlen < tlen:
			dlen = tlen
	print(dlen)
main()


n = int(input())
a = list(map(int, input().split()))
days = 1
record = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		days += 1
	else:
		days = 1
	record = max(days, record)
print(record)


input()
ct = t = maxt = 0
a = list(map(int, input().split()))
for j in a:
	if ct <= j:
		ct = j
		t += 1
	else:
		maxt = max(maxt, t)
		t = 1
		ct = j
maxt = max(maxt, t)
print(maxt)


input()
nums = [int(x) for x in input().split()]
(res, cur) = (1, 1)
for i in range(1, len(nums)):
	if nums[i] >= nums[i - 1]:
		cur += 1
	else:
		cur = 1
	res = max(res, cur)
print(res)


n = int(input())
data = list(map(int, input().split()[:n]))
sizes = [1] * n
for i in range(1, len(data)):
	if data[i] >= data[i - 1]:
		sizes[i] = sizes[i - 1] + 1
print(max(sizes))


input()
a = list(map(int, input().split()))
c = m = 1
for (x, y) in zip(a, a[1:]):
	if x <= y:
		c += 1
		m = max(m, c)
	else:
		c = 1
print(m)


n = int(input())
l = list(map(int, input().split()))
temp = []
count = 1
t = list(l)
t.sort()
if t == l:
	print(n)
else:
	for i in range(1, n):
		if l[i - 1] <= l[i]:
			count += 1
		else:
			temp.append(count)
			count = 1
	temp.append(count)
	print(max(temp))


n = int(input())
arr = list(map(int, input().split()))
(p, i) = (1, 1)
while i < n:
	ans = 1
	while i < n and arr[i] >= arr[i - 1]:
		ans += 1
		i += 1
	i += 1
	p = max(p, ans)
print(p)


n = int(input())
s = list(map(int, input().split()))
c = 0
d = []
for x in range(n - 1):
	if s[x] <= s[x + 1]:
		c += 1
	else:
		d.append(c)
		c = 0
d.append(c)
for i in range(len(d)):
	d[i] += 1
print(max(d))


a = int(input())
b = input().split()
i = 0
j = 1
k = 0
lst = []
if a > 1:
	while i < a - 1:
		if int(b[i]) <= int(b[i + 1]):
			k = k + 1
			lst.append(k)
		else:
			k = 0
			lst.append(k)
		i = i + 1
	print(max(lst) + 1)
else:
	print(a)


n = int(input())
x = 1
num = 1
L = [int(y) for y in input().split()]
if len(L) == 1:
	print('1')
else:
	for i in range(n - 1):
		if L[i] <= L[i + 1]:
			num = num + 1
			x = max(x, num)
		else:
			num = 1
	print(x)


n = int(input())
l = [int(i) for i in input().split()]
cur = 1
m = cur
for i in range(1, len(l)):
	if l[i] >= l[i - 1]:
		cur += 1
		m = max(m, cur)
	else:
		cur = 1
print(m)


x = 0
z = 1
n = int(input())
w = [int(j) for j in input().split()]
for i in range(1, n):
	if w[i] >= w[i - 1]:
		z += 1
	else:
		if z > x:
			x = z
		z = 1
if z > x:
	x = z
print(x)


def fun():
	n = int(input())
	arr = input().split()
	m = 1
	curr = 1
	for i in range(1, n, 1):
		if int(arr[i]) >= int(arr[i - 1]):
			m += 1
		else:
			m = 1
		curr = max(curr, m)
	print(curr)
	return curr
fun()


n = int(input())
arr = list(map(int, input().split()))
m = arr[0]
tmp = m
dp = [1] * n
c = 1
ans = 1
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		c += 1
	else:
		ans = max(ans, c)
		c = 1
ans = max(ans, c)
print(ans)


n = int(input())
days = list(map(int, input().strip().split()))
max_count = 0
count = 0
prev_day = None
for day in days:
	if prev_day == None:
		count = 1
		max_count = 1
	elif prev_day <= day:
		count += 1
	else:
		count = 1
	if count > max_count:
		max_count = count
	prev_day = day
print(max_count)


n = int(input())
A = [int(i) for i in input().split()]
suf = [0] * (n + 1)
suf[-1] = 1
for i in range(n - 1, -1, -1):
	if A[i - 1] <= A[i]:
		suf[i] = 1 + suf[i + 1]
	else:
		suf[i] = 1
print(max(suf[1:]))


import sys
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
ans = 0
l = 0
for i in range(n):
	if i == n - 1 or a[i] > a[i + 1]:
		ans = max(ans, i - l + 1)
		l = i + 1
print(ans)


n = int(input())
l = [int(x) for x in input().split()]
cnt = 1
mx = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		cnt += 1
	else:
		mx = cnt if mx < cnt else mx
		cnt = 1
print(max(mx, cnt))


n = int(input())
a = [int(i) for i in input().split()]
count = 1
buf = 9921291192912
max = 0
for i in a:
	if i >= buf:
		count += 1
	else:
		count = 1
	if count > max:
		max = count
	buf = i
print(max)


def max(a, b):
	if a > b:
		return a
	else:
		return b
n = int(input())
a = input().split(' ')
a = list(map(int, a))
ans = 0
counter = 1
if len(a) == 1:
	print(1)
	exit()
for i in range(1, len(a)):
	if a[i] > a[i - 1] or a[i] == a[i - 1]:
		counter = counter + 1
	else:
		ans = max(counter, ans)
		counter = 1
ans = max(counter, ans)
print(ans)


n = int(input())
k = list(map(int, input().split()))
s = k[0]
li = []
l = []
li.append(s)
for i in range(1, n):
	if k[i] >= s:
		s = k[i]
		li.append(k[i])
	else:
		s = k[i]
		l.append(len(li))
		li = []
		li.append(s)
l.append(len(li))
print(max(l))


n = int(input())
a = list(map(int, input().split()))
(i, ans, temp) = (0, 0, 1)
while i < len(a) - 1:
	if a[i] <= a[i + 1]:
		temp += 1
	else:
		ans = max(ans, temp)
		temp = 1
	i += 1
print(max(ans, temp))


num = int(input())
list1 = list(map(int, input().split()))
count = 0
list2 = []
if len(list1) > 1:
	for i in range(num - 1):
		if list1[i] <= list1[i + 1]:
			count = count + 1
		else:
			list2.append(count + 1)
			count = 0
		list2.append(count + 1)
	print(max(list2))
else:
	print(len(list1))


test_memory = [el for el in range(100000)]
input()
(max_seq, cur_seq, prev_el) = (1, 1, None)
for el in map(int, input().split()):
	cur_seq = cur_seq + 1 if prev_el and el >= prev_el else 1
	prev_el = el
	if cur_seq > max_seq:
		max_seq = cur_seq
print(max_seq)


n = int(input())
s = input().split()
nd = [1 for i in range(n)]
for i in range(n - 2, -1, -1):
	if eval(s[i]) <= eval(s[i + 1]):
		nd[i] = nd[i + 1] + 1
nd = sorted(nd, reverse=True)
print(nd[0])


n = int(input())
li = [int(i) for i in input().split()]
max0 = 1
max1 = 1
for i in range(1, n):
	if li[i] >= li[i - 1]:
		max1 += 1
	else:
		max1 = 1
	max0 = max(max0, max1)
print(max0)


n = int(input())
n1 = list(map(int, input().split()))
lst = []
s = 0
for i in range(n - 1):
	if n1[i + 1] >= n1[i]:
		s = s + 1
	else:
		lst.append(s)
		s = 0
if s != 0:
	lst.append(s)
if n == 1:
	print(1)
else:
	print(max(lst) + 1)


number = input()
int_number = int(number)
str = input()
list = str.split(' ')
list = [int(x) for x in list]
list.append(int(1000000))
count = 0
i = 0
maxx = 0
while i < int_number:
	if list[i] <= list[i + 1]:
		maxx += 1
	else:
		count = max(count, maxx + 1)
		maxx = 0
	i += 1
count = max(count, maxx)
print(count)


n = int(input())
dias = input()
dias = dias.split()
p = 0
while p < n:
	a = int(dias[p])
	dias[p] = a
	p += 1
i = 1
j = 1
mayor = 1
while i < n:
	if dias[i - 1] <= dias[i]:
		i += 1
		j += 1
		if j > mayor:
			mayor = j
	elif dias[i - 1] > dias[i]:
		j = 1
		i += 1
print(mayor)


n = int(input())
t = [int(i) for i in input().split()]
v = 1
j = 1
for i in range(1, n):
	if t[i] >= t[i - 1]:
		j += 1
	else:
		v = max(v, j)
		j = 1
v = max(v, j)
print(v)


a = input()
a = int(a)
c = []
c = input().split()
c = list(map(int, c))
smallest = 1
length_of_current_sequence = 1
for i in range(len(c) - 1):
	if c[i] <= c[i + 1]:
		length_of_current_sequence += 1
	else:
		if length_of_current_sequence > smallest:
			smallest = length_of_current_sequence
		length_of_current_sequence = 1
if length_of_current_sequence > smallest:
	smallest = length_of_current_sequence
print(smallest)


n = int(input())
l = [int(i) for i in input().split()]
s = maxi = 0
for i in range(len(l) - 1):
	if l[i + 1] >= l[i]:
		s += 1
		maxi = max(s, maxi)
	else:
		s = 0
print(maxi + 1)


n = int(input())
l = [int(i) for i in input().split()]
j = 0
c = -1
o = []
for i in range(n - 1):
	if l[i] > l[i + 1]:
		j = i - c
		o.append(j)
		c = i
if l[n - 2] <= l[n - 1]:
	j = n - 1 - c
	o.append(j)
else:
	o.append(1)
print(max(o))


n = int(input())
data = input()
lst = list()
for i in data.split():
	lst.append(int(i))
if len(lst) > 1:
	count = 0
	j = 0
	lst_cnt = list()
	while j < len(lst) - 1:
		if lst[j + 1] >= lst[j]:
			count = count + 1
			lst_cnt.append(count)
		elif lst[j + 1] < lst[j]:
			count = 0
		j = j + 1
	lst_cnt.sort(reverse=True)
	if len(lst_cnt) > 0:
		seq = lst_cnt[0] + 1
	else:
		seq = 1
	print(seq)
else:
	seq = 1
	print(seq)


n = int(input())
numbers = list(map(int, input().split()))
num = 0
cur_len = 0
max_len = 0
for i in range(n):
	if numbers[i] < num:
		if cur_len > max_len:
			max_len = cur_len
		cur_len = 0
	cur_len += 1
	num = numbers[i]
if cur_len > max_len:
	max_len = cur_len
print(max_len)


def main():
	n = int(input())
	a = tuple(map(int, input().split()))
	f = [1] * n
	for i in range(1, n):
		if a[i - 1] <= a[i]:
			f[i] = f[i - 1] + 1
	print(max(f))
main()


n = int(input())
line = [int(x) for x in input().split()]
t = 1
list = []
for i in range(0, n - 1):
	if line[i + 1] >= line[i]:
		t += 1
	else:
		list.append(t)
		t = 1
list.append(t)
list.sort(reverse=True)
if n == 1:
	print(1)
else:
	print(list[0])


n = int(input())
s = list(map(int, input().split()))
q = 1
max = 0
for (ind, item) in enumerate(s[1:]):
	if s[ind + 1] >= s[ind]:
		q += 1
	else:
		if q > max:
			max = q
		q = 1
if q > max:
	max = q
print(max)


a = int(input())
b = input().split()
for i in range(a):
	b[i] = int(b[i])
z = 1
x = 1
for i in range(1, a):
	if b[i] >= b[i - 1]:
		x += 1
	else:
		if x > z:
			z = x
		x = 1
if x > z:
	z = x
print(z)


x = int(input())
y = input().split()
i = 0
z = 0
lst = []
if x == 1:
	print('1')
else:
	for i in range(x - 1):
		if int(y[i]) <= int(y[i + 1]):
			z += 1
		else:
			z = 0
		lst.append(z)
		i += 1
	lst.sort(reverse=True)
	print(lst[0] + 1)


mylist = []

def lcsub(a_list):
	count = 1
	if x == 0:
		return 0
	if x == 1:
		return 1
	if x >= 2:
		for i in range(1, x):
			if a_list[i] >= a_list[i - 1]:
				count += 1
				mylist.append(count)
			else:
				count = 1
				mylist.append(count)
	return max(mylist)
x = int(input())
a = [int(x) for x in input().split()]
print(lcsub(a))


from sys import stdin, stdout
input = lambda : stdin.readline().strip()
n = int(input())
lst = [int(i) for i in input().split()]
max1 = 0
nd = 0
for i in range(1, n):
	if lst[i] >= lst[i - 1]:
		nd += 1
	else:
		nd += 1
		if max1 < nd:
			max1 = nd
		nd = 0
nd += 1
if max1 < nd:
	max1 = nd
print(max1)


import sys

def main():
	lines = sys.stdin.readlines()
	prev = None
	max_seq = 1
	cur_seq = 1
	for l in lines[1].split():
		if prev is None:
			prev = int(l)
		else:
			if int(l) >= prev:
				cur_seq += 1
			else:
				cur_seq = 1
			prev = int(l)
			max_seq = max(max_seq, cur_seq)
	print(max_seq)
main()


t = int(input())
str1 = [int(x) for x in input().split()]
count = 1
arr = []
for i in range(0, len(str1) - 1):
	if str1[i + 1] >= str1[i]:
		count += 1
	else:
		arr.append(count)
		count = 1
arr.append(count)
if t == 1:
	print('1')
else:
	print(max(arr))


n = int(input())
days = [int(x) for x in input().split()]
m = 1
count = 0
pre = 0
for day in days:
	if day >= pre:
		count += 1
		pre = day
		if count > m:
			m = count
	else:
		count = 1
		pre = day
print(m)


import os
import sys
from io import BytesIO, IOBase

def main():
	pass
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()

def basic(n, arr):
	first = 0
	res = 0
	if len(arr) == 1:
		return 1
	for i in range(1, len(arr)):
		if i > 0 and arr[i - 1] > arr[i]:
			first = i
		res = max(res, i - first + 1)
	return res
n = int(input())
arr = list(map(int, input().split(' ')))
print(basic(n, arr))


n = int(input())
a = list(map(int, input().strip().split()))
b = []
for i in range(n - 1):
	b.append(a[i + 1] - a[i])
c = 1
d = []
for i in range(n - 1):
	if b[i] >= 0:
		c = c + 1
	else:
		d.append(c)
		c = 1
d.append(c)
print(max(d))


N = int(input())
L = []
L = input().split()
M = 1
R = 1
for k in range(1, N):
	if int(L[k]) >= int(L[k - 1]):
		M += 1
		if M > R:
			R = M
	else:
		M = 1
if M > R:
	print(M)
else:
	print(R)


def read_tokens():
	return input().strip().split(' ')

def read_ints():
	return [int(s) for s in read_tokens()]
(n,) = read_ints()
arr = read_ints()

def solve(arr: list) -> int:
	n = len(arr)
	dp = [1] * n
	for i in range(1, n):
		if arr[i] >= arr[i - 1]:
			dp[i] = dp[i - 1] + 1
	return max(dp)
print(solve(arr))


n = int(input())
array = list(map(int, input().strip().split()))[:n]
a = array[0]
c = c1 = 0
for i in array:
	if a <= i:
		c += 1
	else:
		if c > c1:
			c1 = c
		c = 1
	a = i
	if c > c1:
		c1 = c
print(c1)


n = int(input())
alist = list(map(int, input().split()))
t = 1
maxt = 1
for i in range(n - 1):
	ai = alist[i]
	aiplus1 = alist[i + 1]
	if ai <= aiplus1:
		t = t + 1
		if maxt <= t:
			maxt = t
	else:
		t = 1
		if maxt <= t:
			maxt = t
print(maxt)


n = int(input())
b = [int(i) for i in input().split()]
a = 1
k = n * [1]
if n == 1:
	print(1)
	exit()
else:
	for i in range(1, n):
		if b[i - 1] > b[i]:
			k[i] = 1
		else:
			k[i] = k[i - 1] + 1
print(max(k))


n = int(input())
x = list(map(int, input().split()))
t = 1
maxx = t
for i in range(0, n - 1):
	if x[i] <= x[i + 1]:
		t += 1
	else:
		t = 1
	if t > maxx:
		maxx = t
print(maxx)


n = int(input())
s = input()
arr = s.split(' ')
maxx = int(arr[0])
sch = 0
sch2 = 0
for i in range(len(arr)):
	if int(arr[i]) >= maxx and i != 0:
		sch += 1
		if sch2 < sch:
			sch2 = sch
	else:
		sch = 0
	maxx = int(arr[i])
print(sch2 + 1)


n = int(input())
A = [int(x) for x in input().split()]
max = 1
combo = 1
i = 2
while i <= n:
	if A[i - 1] >= A[i - 2]:
		combo += 1
		i += 1
		if combo > max:
			max = combo
	elif combo > max:
		max = combo
		combo = 1
		i += 1
	else:
		combo = 1
		i += 1
print(max)


input()
array = list(map(int, input().split(' ')))
current_sequence = 1
max_sequence = 1
k = 0
for x in range(0, len(array)):
	if x == 0:
		continue
	if array[x] < array[x - 1]:
		max_sequence = current_sequence if current_sequence > max_sequence else max_sequence
		current_sequence = 1
	else:
		current_sequence += 1
	max_sequence = current_sequence if current_sequence > max_sequence else max_sequence
print(max_sequence)


a = int(input())
b = input().split()
c = [1]
for i in range(len(b)):
	b[i] = int(b[i])
counter = 1
i = 0
while True:
	if i == len(b) - 1:
		break
	elif b[i + 1] >= b[i]:
		counter = counter + 1
		i = i + 1
		if i == len(b) - 1:
			c.append(counter)
	else:
		c.append(counter)
		i = i + 1
		counter = 1
print(max(c))


n = int(input())
l = list(map(int, input().split()))
i = 1
high = 0
count = 0
while i < n:
	if l[i - 1] <= l[i]:
		count += 1
	else:
		if count > high:
			high = count
		count = 0
	i += 1
if high < count:
	high = count
print(high + 1)


def main():
	from sys import stdout
	n = int(input())
	lis = list(map(int, input().split()))
	res = 0
	cnt = 0
	num = 0
	for el in lis:
		if el >= num:
			cnt += 1
			num = el
		else:
			if res < cnt:
				res = cnt
			cnt = 1
			num = el
	if res < cnt:
		res = cnt
	stdout.write(str(res) + '\n')
main()


n = int(input())
M = list(map(int, input().split()))
a = 0
k = 0
c = 0
for i in range(n):
	if a <= M[i]:
		a = M[i]
		k = k + 1
	if k >= c:
		c = k
	if i == n - 1 and k >= c:
		c = k
	if a > M[i]:
		a = M[i]
		k = 1
print(c)


def maxSubseg():
	n = int(input())
	strLst = str(input())
	arry = list(map(int, strLst.split(' ')))
	lst = []
	cont = 1
	for i in range(1, len(arry)):
		if arry[i - 1] <= arry[i]:
			cont += 1
			continue
		lst.append(cont)
		cont = 1
	lst.append(cont)
	lst.sort()
	return lst[len(lst) - 1]
res = maxSubseg()
print(res)


amount = int(input())
array = [int(i) for i in input().split()]
data = [1]
ans = 1
for i in range(1, len(array)):
	data.append(1)
	if array[i - 1] <= array[i]:
		data[i] = max(data[i], data[i - 1] + 1)
	ans = max(ans, data[i])
print(ans)


u = int(input())
r = []
x = 1
w = [int(j) for j in input().split()]
w += [w[-1] - 1] + [w[-1] - 2]
for i in range(u):
	if w[i + 1] >= w[i]:
		x += 1
	else:
		r.append(x)
		x = 1
print(max(r))


def main():
	n = int(sys.stdin.readline())
	lst = list(map(int, sys.stdin.readline().split()))
	mx = 0
	count = 1
	prev = lst[0]
	for i in range(1, n):
		if lst[i] >= prev:
			count += 1
			mx = max(count, mx)
		else:
			count = 1
		prev = lst[i]
	mx = max(count, mx)
	sys.stdout.write(str(mx))
import sys
main()


n = int(input())
num = [int(x) for x in input().split()]
maxlen = 0
lenc = 0
pre = 0
for i in range(0, n):
	if num[i] >= pre:
		lenc += 1
	else:
		maxlen = max(maxlen, lenc)
		lenc = 1
	pre = num[i]
maxlen = max(maxlen, lenc)
print(maxlen)


_ = input()
arr = [int(i) for i in input().split()]
max_non_decreasing = 1
non_decreasing = 1
for i in range(1, len(arr)):
	non_decreasing = 1 if arr[i] < arr[i - 1] else non_decreasing + 1
	max_non_decreasing = max(max_non_decreasing, non_decreasing)
print(max_non_decreasing)


def main():
	n = int(input())
	A = [int(i) for i in input().split(' ')]
	prev = A[0]
	i = 1
	ans = 1
	res = 1
	while i < n:
		if A[i] >= prev:
			ans = ans + 1
		else:
			if ans > res:
				res = ans
			ans = 1
		prev = A[i]
		i = i + 1
	if ans > res:
		res = ans
	print(res)
main()


n = int(input())
l = list(map(int, input().split()))
k = [1]
x = 1
for (i, item) in enumerate(l):
	if i + 1 < len(l):
		if item <= l[i + 1]:
			x += 1
		else:
			k.append(x)
			x = 1
		k.append(x)
print(max(k))


days = input()
mon = [int(x) for x in input().split()]
n = 0
maxm = 0
first = mon[0]
for i in range(len(mon)):
	if mon[i] >= first:
		n += 1
		first = mon[i]
		if n > maxm:
			maxm = n
	else:
		n = 1
		first = mon[i]
		continue
print(maxm)


n = int(input())
money = input().split()
t = 0
num = 1
numlist = [1]
while t < n:
	if t + 1 == n:
		break
	if int(money[t]) <= int(money[t + 1]):
		num = num + 1
		numlist.append(num)
	else:
		num = 1
	t = t + 1
output = max(numlist)
print(output)


import math
st = ''

def func(n, l1):
	(m, i) = (1, 0)
	while i < n - 1:
		k = 1
		while i < n - 1 and l1[i] <= l1[i + 1]:
			k += 1
			i += 1
		m = max(m, k)
		if k == 1:
			i += 1
	return m
for _ in range(1):
	n = int(input())
	l1 = list(map(int, input().split()))
	st += str(func(n, l1)) + '\n'
print(st)


def arr_inp():
	return [int(x) for x in input().split()]
(n, a) = (int(input()), arr_inp())
(out, tem, count) = (1, a[0], 1)
for i in a[1:]:
	count += 1
	if i < tem:
		count = 1
	(tem, out) = (i, max(out, count))
print(out)


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


n = int(input())
a = list(map(int, input().split()))
count = 1
maxi = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		count += 1
		maxi = max(maxi, count)
	else:
		count = 1
print(maxi)


n = int(input())
list = input().split()
output = 0
out = []
i = 0
if n != 1:
	while i < n - 1:
		if int(list[i]) <= int(list[i + 1]):
			output += 1
			out.append(output)
			i += 1
		else:
			output = 0
			out.append(output)
			i += 1
	print(max(out) + 1)
else:
	print('1')


n = int(input())
arr = input().split()
arr = [int(num) for num in arr]
prev_max = 0
curr_max = 0
prev_num = 0
for num in arr:
	if num >= prev_num:
		curr_max += 1
	elif prev_max > curr_max:
		curr_max = 1
	else:
		prev_max = curr_max
		curr_max = 1
	prev_num = num
print(max(prev_max, curr_max))


def solve(n, arr):
	length = 1
	max_length = 1
	for i in range(1, n):
		if arr[i] >= arr[i - 1]:
			length += 1
		else:
			length = 1
		max_length = max(max_length, length)
	return max_length
n = int(input())
arr = list(map(int, input().split()))
print(solve(n, arr))


sum = 1
n = int(input())
string = list(map(int, input().split()))
k = []
for i in range(n - 1):
	if string[i + 1] >= string[i]:
		sum += 1
	else:
		k.append(sum)
		sum = 1
k.append(sum)
print(max(k))


n = int(input())
l = list(map(int, input().split()))
d = [1] * n
ans = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		d[i] = d[i - 1] + 1
	ans = max(ans, d[i])
print(ans)


n = int(input())
a = [int(i) for i in input().split()]
(c, d) = (1, 1)
for i in range(1, n):
	if a[i] >= a[i - 1]:
		c += 1
	else:
		c = 1
	d = max(d, c)
print(d)


def first():
	n = int(input())
	l = list(map(int, input().split()))
	count = 0
	maxi = 0
	for i in range(1, n):
		if count > maxi:
			maxi = count
		if l[i - 1] > l[i]:
			count = 0
		else:
			count += 1
	if count > maxi:
		maxi = count
	print(maxi + 1)
first()


n = int(input())
l = [*map(int, input().split())]
gmax = 0
lmax = 0
if sorted(l) == l:
	print(n)
else:
	for i in range(n - 1):
		if l[i] <= l[i + 1]:
			lmax += 1
			gmax = max(gmax, lmax)
		else:
			lmax = 0
	print(gmax + 1)


n = int(input())
a = [int(i) for i in input().split()]
S = 0
s = 1
for i in range(0, n - 1):
	if a[i] <= a[i + 1]:
		s += 1
	else:
		S = max(S, s)
		s = 1
print(max(S, s))


def main():
	n = int(input())
	ints = list(map(int, input().split(' ')))
	longest = 1
	length = 1
	for i in range(n - 1):
		if ints[i + 1] >= ints[i]:
			length += 1
			longest = max(length, longest)
		else:
			length = 1
	print(longest)
main()


n = int(input())
a = [int(i) for i in input().split()]
maxn = 1
length = 1
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		length += 1
	else:
		maxn = max(maxn, length)
		length = 1
maxn = max(maxn, length)
print(maxn)


def main():
	input()
	prob = [int(number) for number in input().split()]
	curr = 1
	maximum = 1
	for i in range(1, len(prob)):
		if prob[i - 1] <= prob[i]:
			curr += 1
		else:
			maximum = max(maximum, curr)
			curr = 1
	maximum = max(maximum, curr)
	print(maximum)
main()


day = int(input())
wages = list(map(int, input().split()))
next_wages = wages.copy()
del next_wages[0]
t = 1
count_sgm = []
for (w1, w2) in zip(wages, next_wages):
	if w1 <= w2:
		t += 1
	else:
		count_sgm.append(t)
		t = 1
count_sgm.append(t)
print(max(count_sgm))


n = int(input())
a = list(map(int, input().split()))
m = 1
j = 0
while j < n - 1:
	k = 1
	j += 1
	while a[j] >= a[j - 1]:
		k += 1
		j += 1
		if j == n:
			break
	if k > m:
		m = k
print(m)


dp = []
maxlength = 0
length = int(input())
nums = list(map(int, input().split()))
for var in range(len(nums)):
	if var == 0:
		dp.append(1)
		maxlength = max(maxlength, dp[var])
		continue
	if nums[var] >= nums[var - 1]:
		dp.append(dp[var - 1] + 1)
	else:
		dp.append(1)
	maxlength = max(maxlength, dp[var])
print(maxlength)


input()
s = 0
ans = 0
a = 0
for i in input().split():
	i = int(i)
	if i < s:
		a = 0
	a += 1
	ans = max(ans, a)
	s = i
print(ans)


a = int(input())
b = list(map(int, input().split()))
e = 1
c = []
if a == 1:
	print(1)
else:
	for i in range(1, a):
		if b[i - 1] <= b[i]:
			e = e + 1
			c.append(e)
		else:
			e = 1
	c.sort(reverse=True)
	if c == []:
		print(1)
	else:
		print(c[0])


n = int(input())
s = list(map(int, input().split()))
x = 1
dec = []
for i in range(1, len(s)):
	if s[i] >= s[i - 1]:
		x += 1
	else:
		dec.append(x)
		x = 1
dec.append(x)
print(max(dec))


n = int(input())
a = list(map(int, input().split()))
m = 0
ans = 0
for f1 in range(n - 1):
	if a[f1] <= a[f1 + 1]:
		m += 1
	if ans < m:
		ans = m
	if a[f1] > a[f1 + 1]:
		m = 0
print(ans + 1)


n = int(input())
nums = list(map(int, input().split()))
counter = 1
best = 1
for i in range(0, n - 1):
	if nums[i] <= nums[i + 1]:
		counter += 1
	else:
		counter = 1
	if counter > best:
		best = counter
print(best)


input()
x = input().split()
xlen = len(x)
i = 0
count = 1
res = 0
for i in range(xlen - 1):
	if int(x[i + 1]) >= int(x[i]):
		count += 1
	else:
		if count > res:
			res = count
		count = 1
if count > res:
	res = count
print(res)


l = input()
l = int()
p = [int(i) for i in input().split()]
cnt = 1
maxx = 0
for i in range(len(p) - 1):
	if p[i] > p[i + 1]:
		if cnt > maxx:
			maxx = cnt
		cnt = 1
	else:
		cnt += 1
ans = max(cnt, maxx)
print(ans)


n = int(input())
a = list(map(int, input().split()))
mx = 1
curr = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		curr += 1
		mx = max(mx, curr)
	else:
		curr = 1
print(mx)


n = int(input())
line = input().split()
step = 0
maxstep = 0
for i in range(n - 1):
	if int(line[i]) <= int(line[i + 1]):
		step += 1
		if maxstep < step:
			maxstep = step
	else:
		step = 0
print(maxstep + 1)


while True:
	try:
		n = int(input())
		l = input().split()
		m = 1
		ma = 1
		for i in range(1, n):
			if int(l[i]) >= int(l[i - 1]):
				m = m + 1
				if m > ma:
					ma = m
				else:
					ma = ma
			elif ma >= m:
				ma = ma
				m = 1
			else:
				ma = m
				m = 1
		print(ma)
	except EOFError:
		break


n = int(input())
lst = list(map(int, input().split()))
res = {i: 0 for i in range(n)}
res[0] = 1
ma = 1
for i in range(1, n):
	if lst[i] < lst[i - 1]:
		res[i] = 1
	else:
		a = res[i - 1] + 1
		res[i] = a
		if a > ma:
			ma = a
print(ma)


n = int(input())
l1 = list(map(int, input().split(' ')))
length = 1
max_length = 1
for i in range(1, n):
	if l1[i] >= l1[i - 1]:
		length += 1
	else:
		length = 1
	max_length = max(max_length, length)
print(max_length)


length = int(input())
money = [int(i) for i in input().split()]
last = 0
maxl = 0
counter = 0
for i in range(length):
	if money[i] >= last:
		last = money[i]
		counter += 1
		if counter > maxl:
			maxl = counter
	else:
		last = money[i]
		counter = 1
print(maxl)


n = int(input())
s = [int(i) for i in input().split()]
count = 1
high = count
for i in range(1, len(s)):
	if s[i] >= s[i - 1]:
		count += 1
		high = max(high, count)
	else:
		count = 1
print(high)


n = int(input())
l = input()
l = [int(i) for i in l.split()]
t = 0
ans = 0
if n == 1:
	print(1)
else:
	for i in range(n - 1):
		if l[i] <= l[i + 1]:
			if t == 0:
				t = 2
			else:
				t += 1
		if i == n - 2 or not l[i] <= l[i + 1]:
			ans = max(t, ans)
			t = 0
	if ans == 0:
		print(1)
	else:
		print(ans)


n = int(input())
s = [int(x) for x in input().split()]
h = 1
s1 = []
if n == 1:
	print(1)
else:
	for i in range(n - 1):
		if s[i] <= s[i + 1]:
			h += 1
		else:
			s1.append(h)
			h = 1
	s1.append(h)
	print(max(s1))


n = int(input())
lis = list(map(int, input().split()))
stack = []
msf = -1
if len(lis) == 1:
	msf = 1
	pass
for i in range(n - 1):
	if len(stack) == 0:
		stack.append(lis[i])
	if lis[i + 1] >= lis[i]:
		stack.append(lis[i + 1])
	if lis[i + 1] < lis[i]:
		msf = max(len(stack), msf)
		stack = []
	msf = max(len(stack), msf)
print(msf)


n = int(input())
money = list(map(int, input().split()))
counter = 1
lengthes = []
for i in range(1, len(money)):
	if money[i] >= money[i - 1]:
		counter += 1
	else:
		lengthes.append(counter)
		counter = 1
lengthes.append(counter)
maximum = max(lengthes)
print(maximum)


length = int(input())
numbers = [int(i) for i in input().split()]
max_length = 0
word = [numbers[0]]
for pos in range(len(numbers)):
	if pos == 0:
		continue
	if numbers[pos] >= numbers[pos - 1]:
		word.append(str(numbers[pos]))
	else:
		if len(word) > max_length:
			max_length = len(word)
		word = []
		word.append(str(numbers[pos]))
print(max(max_length, len(word)))


n = int(input().strip())
a = [int(x) for x in input().strip().split(' ')]
a += [a[n - 1] - 1]
ans = 0
x = 0
for i in range(1, n + 1):
	if a[i] < a[i - 1]:
		ans = max(ans, i - x)
		x = i
print(ans)


def fun(l):
	max1 = 0
	max2 = 0
	for i in range(0, len(l) - 1):
		if l[i + 1] >= l[i]:
			max2 += 1
		else:
			max2 = 0
		max1 = max(max1, max2)
	return max1 + 1
t = int(input())
l = input().split()
l = list(map(int, l))
print(fun(l))


n = int(input())
a = [int(x) for x in input().split()]
p1 = 0
p2 = 0
ans = 1
while p2 < n - 1:
	if a[p2 + 1] >= a[p2]:
		p2 += 1
		res = p2 - p1 + 1
		if res > ans:
			ans = res
	else:
		p2 += 1
		p1 = p2
print(ans)


n = int(input())
a = list(map(int, input().split()))
max_len = 0
i = 0
while i < n:
	j = i
	while j < n - 1 and a[j] <= a[j + 1]:
		j += 1
	cur_len = j - i + 1
	if cur_len > max_len:
		max_len = cur_len
	i = j + 1
print(max_len)


count = 1
input()
before = -1
beforeCount = 1
for i in map(int, input().split()):
	if before == -1:
		beforeCount = 1
		before = i
		continue
	if i >= before:
		beforeCount += 1
		if beforeCount > count:
			count = beforeCount
		before = i
	else:
		beforeCount = 1
		before = i
print(str(count))


n = int(input())
l = list(map(int, input().split()))
c = 1
temp = 1
for j in range(n - 1):
	if l[j] <= l[j + 1]:
		c = c + 1
	else:
		temp = max(c, temp)
		c = 1
temp = max(c, temp)
print(temp)


n = int(input())
answer = 0
k = 0
j = 0
listt = list(input().split())
for i in range(len(listt)):
	listt[i] = int(listt[i])
for i in range(1, len(listt), 1):
	if listt[i - 1] <= listt[i]:
		answer += 1
	else:
		j = max(answer, j)
		answer = 0
print(max(j, answer) + 1)


n = int(input())
arr = list(map(int, input().split()))
lens = 1
maxlens = 1
for i in range(n - 1):
	if arr[i] <= arr[i + 1]:
		lens += 1
		if lens > maxlens:
			maxlens = lens
	else:
		lens = 1
print(maxlens)


n = int(input())
l = list(map(int, input().split()))
start = 1
p_start = 0
for i in range(1, len(l)):
	if l[i] >= l[i - 1]:
		start += 1
	else:
		start = 1
	if start > p_start:
		p_start = start
print(max(start, p_start))


n = input()
(a, b, c) = (0, 0, 0)
for i in map(int, input().split()):
	if i < a:
		c = 0
	c += 1
	b = max(c, b)
	a = i
print(b)


n = int(input())
l = [int(x) for x in input().split()]
c = int(1)
m = int(1)
for i in range(1, n):
	if l[i - 1] < l[i] or l[i - 1] == l[i]:
		c = c + 1
	if l[i - 1] > l[i]:
		if c > m:
			m = c
		c = 1
if c > m:
	m = c
print(m)


n = int(input())
a = list(map(int, input().split()))
currmax = 1
allmax = 1
if n == 1:
	print(1)
else:
	for i in range(1, n):
		if a[i] >= a[i - 1]:
			currmax += 1
		else:
			if currmax > allmax:
				allmax = currmax
			currmax = 1
	if currmax > allmax:
		allmax = currmax
	print(allmax)


import sys
import io
import os
total = 0
failed = 0

def run(test, res):
	x = io.StringIO()
	with io.StringIO(test) as sys.stdin:
		with x as sys.stdout:
			work()
			z = x.getvalue().strip()
	sys.stdout = sys.__stdout__
	print('Passed?', z == res)
	print('Expected: ', res)
	print('Actual  : ', z)
	global total, failed
	total += 1
	failed += 1 if z != res else 0

def work():
	n = int(input())
	f = list(map(int, input().split()))
	c = 0
	max = 0
	p = -1
	for e in f:
		if e < p:
			c = 1
			p = e
			continue
		c += 1
		if c > max:
			max = c
		p = e
	print(max)

def test():
	run('6\n2 2 1 3 4 1', '3')
	run('3\n2 2 9', '3')
if 'LOCALTEST' in os.environ:
	test()
	print('\n Result: %s (%d total, %d failed)' % ('FAILED' if failed > 0 else 'PASSED', total, failed))
else:
	work()


a = int(input())
k = list(map(int, input().split()))
ct = 1
i = 0
m = 1
while i < a - 1:
	if k[i] <= k[i + 1]:
		ct += 1
		if ct > m:
			m = ct
	else:
		ct = 1
	i += 1
print(m)


n = int(input().strip())
num = list(map(int, input().split(' ')))
first_check = False
check_2 = False
count = 0
pre_num = num[0]
for i in range(1, n):
	if pre_num <= num[i]:
		count += 1
		pre_num = num[i]
	elif pre_num > num[i] and (not first_check):
		count += 1
		check_2 = True
		max_count = count
		count = 0
		pre_num = num[i]
		first_check = True
	elif first_check and pre_num > num[i]:
		count += 1
		if count > max_count:
			max_count = count
		pre_num = num[i]
		count = 0
	if i == n - 1 and check_2:
		count += 1
		if count > max_count:
			max_count = count
if check_2:
	print(max_count)
else:
	count += 1
	print(count)


a = int(input())
s = input().split()
res = 1
mat = []
for i in range(a - 1):
	if int(s[i]) <= int(s[i + 1]):
		res += 1
	else:
		mat.append(res)
		res = 1
mat.append(res)
print(max(mat))


k = input()
numbers = [int(x) for x in input().split()]
length = 1
longest = []
if len(numbers) == 1:
	longest.append(1)
else:
	for i in range(len(numbers)):
		if i == len(numbers) - 1:
			longest.append(length)
			break
		elif numbers[i] <= numbers[i + 1]:
			length += 1
		else:
			longest.append(length)
			length = 1
print(max(longest))


import math
p = input()
t = int(p)
import array
arr1 = array.array('l', [])
arr1 = [int(i) for i in input().split()]
if t == 1:
	print('1')
else:
	aa = 0
	l = 1
	mm = 1
	ll = 0
	for k in range(1, t, 1):
		if arr1[k - 1] <= arr1[k]:
			mm = mm + 1
			l = l + 1
		else:
			ll = ll + 1
			if l > aa:
				aa = l
			l = 1
	if ll == 0:
		print(mm)
	elif l > aa:
		print(l)
	else:
		print(aa)


n = int(input())
a = [int(i) for i in input().split()]
b = []
c = 1
if len(a) == 1:
	print('1')
else:
	for i in range(n - 1):
		if a[i] <= a[i + 1]:
			c += 1
			if i == n - 2:
				b.append(c)
		else:
			b.append(c)
			c = 1
	print(max(b))


def solve(n, s):
	dp = [1] * n
	dp[0] = 1
	for i in range(1, n):
		if s[i] < s[i - 1]:
			continue
		else:
			dp[i] = dp[i - 1] + 1
	print(max(dp))
n = int(input())
ar = list(map(int, input().split()))
solve(n, ar)


n = int(input())
data = [int(i) for i in input().split()]
best = 0
r = 1
pos = 1
while pos < n:
	if data[pos] >= data[pos - 1]:
		r += 1
	else:
		best = max(best, r)
		r = 1
	pos += 1
best = max(best, r)
print(best)


n = int(input())
ch = input()
l = ch.split(' ')

def rec(l, n):
	c = 1
	maxi = 0
	for i in range(n - 1):
		if int(l[i]) <= int(l[i + 1]):
			c += 1
		else:
			c = 1
		if c >= maxi:
			maxi = c
	print(maxi)
if len(l) > 1:
	rec(l, n)
else:
	print(1)


n = int(input())
p = list(map(int, input().split()))
ol = []
t = 1
for x in range(0, n - 1):
	if p[x] <= p[x + 1]:
		t += 1
	else:
		ol.append(t)
		t = 1
ol.append(t)
ol.append(1)
print(max(ol))


n = int(input())
x = list(map(int, input().split()))
i = 0
max = 1
max1 = 1
while i < len(x) - 1:
	if x[i + 1] >= x[i]:
		max += 1
		i += 1
	else:
		max = 1
		i += 1
	if max > max1:
		max1 = max
print(max1)


n = input()
n = int(n)
a_i = input()
a = [int(i) for i in a_i.split(' ')]
res = [1] * n
for i in range(1, n):
	if a[i] >= a[i - 1]:
		res[i] = res[i - 1] + 1
print(max(res))


n = int(input())
increase = []
values = list(map(int, input().split()))
for i in range(n):
	if i == 0:
		increase.append(1)
	elif values[i] >= values[i - 1]:
		increase.append(increase[-1] + 1)
	else:
		increase.append(1)
print(max(increase))


n = int(input())
l = list(map(int, input().split()))
max = 0
c = 0
if n == 1:
	print(1)
else:
	for i in range(n - 1):
		if l[i] > l[i + 1]:
			c = c + 1
			if c > max:
				max = c
			c = 0
		elif i == n - 2 and l[i] <= l[i + 1]:
			c = c + 2
			if c > max:
				max = c
		else:
			c = c + 1
	print(max)


n = int(input())
(last_a, *ListA) = list(map(int, input().split()))
MaxS = 1
S = 1
for a in ListA:
	if a >= last_a:
		S += 1
	else:
		S = 1
	last_a = a
	MaxS = max(MaxS, S)
print(MaxS)


n = int(input())
money = [int(x) for x in input().split(' ')]
i = 0
j = 0
longestSequence = 1
currentLength = 1
while i < n - 1:
	j = i + 1
	currentLength = 1
	while j < n and money[j] >= money[j - 1]:
		currentLength += 1
		j += 1
	if longestSequence < currentLength:
		longestSequence = currentLength
	i = j
print(longestSequence)


import sys, os.path
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
sys.setrecursionlimit(10 ** 5)

def i():
	return sys.stdin.readline().strip()

def ii():
	return int(sys.stdin.readline())

def li():
	return list(sys.stdin.readline().strip())

def mii():
	return map(int, sys.stdin.readline().split())

def lii():
	return list(map(int, sys.stdin.readline().strip().split()))

def solve():
	a = ii()
	b = lii()
	c = d = 0
	e = -1
	for x in b:
		if x >= e:
			d += 1
		else:
			c = max(c, d)
			d = 1
		e = x
	print(max(c, d))
solve()


v = int(input())
s = list(map(int, input().split()))
x = []
c = s[0]
count = 0
for i in s:
	if i >= c:
		count += 1
		c = i
	else:
		c = i
		count = 1
	x.append(count)
print(max(x))


n = int(input())
A = list(map(int, input().split()))
count = 1
B = []
flag = False
if len(A) == 1:
	print('1')
else:
	for i in range(n - 1):
		if A[i + 1] > A[i] or A[i + 1] == A[i]:
			flag = True
			count += 1
			B.append(count)
		else:
			count = 1
			B.append(count)
			flag = True
if flag == True:
	print(max(B))


n = int(input())
l = [int(i) for i in input().split()]
length = 1
seg = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		seg += 1
		length = max(length, seg)
	else:
		length = max(length, seg)
		seg = 1
print(length)


n = int(input())
list = [int(x) for x in input().split()]
l = 1
sum = 1
for i in range(n - 1):
	if list[i + 1] >= list[i]:
		l += 1
	elif list[i + 1] < list[i]:
		l = 1
	sum = max(sum, l)
print(sum)


n = int(input())
arr = [int(i) for i in input().split()]
ms = 1
mss = 1
for i in range(1, len(arr)):
	if arr[i - 1] <= arr[i]:
		ms += 1
		mss = max(mss, ms)
	else:
		ms = 1
print(mss)


n = int(input())
li = list(map(int, input().split()))
ans = 0
temp = 0
i = 0
while i < len(li):
	j = i + 1
	temp = 1
	while j < len(li) and li[i] <= li[j]:
		temp = temp + 1
		i = i + 1
		j = j + 1
	ans = max(ans, temp)
	i = j
print(ans)


n = int(input())
mx = 1
l = [*map(int, input().split())]
i = 0
while i < n - 1:
	j = i + 1
	count = 1
	while j < n and l[j] >= l[j - 1]:
		j += 1
		count += 1
	if count == 1:
		i += 1
	else:
		i = j
	if count > mx:
		mx = count
print(mx)


from sys import stdin, stdout
n = stdin.readline()
n = int(n)
a = stdin.readline().split()
k = 1
n = int(n)
a = list(map(int, a))
current = -1000
for i in range(1, n):
	if a[i] >= a[i - 1]:
		k += 1
	else:
		current = max(current, k)
		k = 1
stdout.write(str(max(current, k)))


n = int(input())
l = [int(x) for x in input().split()]
d = []
(c, d) = (0, 0)
for i in range(len(l) - 1):
	if l[i] <= l[i + 1]:
		c += 1
		d = max(c, d)
	else:
		c = 0
print(d + 1)


import math
n = int(input())
a = input().split()
maxlen = 1
k = 1
for i in range(n):
	a[i] = int(a[i])
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		k += 1
	else:
		maxlen = max(k, maxlen)
		k = 1
maxlen = max(k, maxlen)
print(maxlen)


n = int(input())
a = list(map(int, input().split()))
cur = -1
ret = 0
cc = 0
for i in range(n):
	if a[i] >= cur:
		cc += 1
		cur = a[i]
	else:
		ret = max(ret, cc)
		cc = 1
		cur = a[i]
print(max(ret, cc))


n = int(input())
line = input()
d = line.split()
leng = 1
curr = int(d[0])
maxl = leng
for i in range(1, n):
	dd = int(d[i])
	if dd < curr:
		if leng > maxl:
			maxl = leng
		leng = 1
	else:
		leng = leng + 1
	curr = dd
if leng > maxl:
	maxl = leng
print(maxl)


n = int(input())
arr = list(map(int, input().split()))
counter = 1
lst = [1]
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		counter += 1
	else:
		lst.append(counter)
		counter = 1
lst.append(counter)
print(max(lst))


n = int(input())
arr = list(map(int, input().split(' ')))
count = 0
arr2 = []
for i in range(n - 1):
	if arr[i + 1] >= arr[i]:
		count += 1
		arr2.append(count)
	else:
		count = 0
print(max(arr2, default=0) + 1)


(_, list_in, list_re, list_out) = (input(), [int(x) for x in input().strip().split()], [(0, 0)], [])
for x in range(len(list_in) - 1):
	if list_in[x] > list_in[x + 1]:
		list_re.append((x, x + 1))
list_re.append((len(list_in) - 1, len(list_in) - 1))
for x in range(len(list_re) - 1):
	if list_re[x + 1][0] - list_re[x][-1] >= 0:
		list_out.append(list_re[x + 1][0] - list_re[x][-1] + 1)
if len(list_out):
	print(max(list_out))
else:
	print(len(list_in))


cases = int(input())
days = input().split(' ')
days = list(map(int, days))
days.append(0)
final_ans = 0
ans = 0
for i in range(0, cases):
	if days[i + 1] < days[i]:
		if ans > final_ans:
			final_ans = ans
		ans = 0
	else:
		ans += 1
print(final_ans + 1)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	n = I()
	a = LI()
	t = inf
	ti = 0
	r = 1
	for i in range(n):
		if t > a[i]:
			ti = i
		elif r < i - ti + 1:
			r = i - ti + 1
		t = a[i]
	return r
print(main())


nh = int(input())
l = list(map(int, input().split()))
ch = 1
m = 1
for i in range(1, nh):
	if l[i] >= l[i - 1]:
		ch = ch + 1
	else:
		ch = 1
	if m < ch:
		m = ch
print(m)


n = int(input())
l = list(map(int, input().split()))
length = 1
maxi = 0
c = 0
for i in range(n - 1):
	if l[i] <= l[i + 1]:
		c = 1
		length += 1
		if length > maxi:
			maxi = length
	else:
		length = 1
if n == 1 or c == 0:
	print(1)
else:
	print(maxi)


def Kefa_and_First_Steps(s):
	Max = 0
	cnt = 0
	for i in range(0, len(s) - 1):
		if s[i] <= s[i + 1]:
			cnt += 1
			if cnt > Max:
				Max = cnt
		else:
			cnt = 0
	return Max + 1
n = input()
s = input().split()
a = []
for i in range(0, int(n)):
	a.append(int(s[i]))
print(Kefa_and_First_Steps(a))


n = int(input())
a = list(map(int, input().split()))
(ps, ts) = (0, 0)
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		ps += 1
	else:
		ts = max(ps, ts)
		ps = 0
ts = max(ps, ts)
print(ts + 1)


n = int(input())
L = list(map(int, input().split()))
M = [0]
C = 0
for i in range(n):
	if L[i] >= M[-1]:
		M.append(L[i])
	elif L[i] < M[-1]:
		if C > len(M):
			M.clear()
			M = [0]
			M.append(L[i])
		else:
			C = len(M)
			M.clear()
			M = [0]
			M.append(L[i])
if len(M) - 1 >= C:
	print(len(M) - 1)
else:
	print(C - 1)


from itertools import permutations
from collections import defaultdict
from math import *
import os
import sys
from io import BytesIO, IOBase
from heapq import nlargest
from bisect import *
import copy
import itertools
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def input():
	return sys.stdin.readline().rstrip('\r\n')
n = int(input())
arr = list(map(int, input().split()))
(ans, count) = (0, 1)
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		count += 1
	else:
		if ans < count:
			ans = count
		count = 1
print(max(count, ans))


n = int(input())
x = list(map(int, input().split()))
q = []
q.append(n)
for i in range(n - 1):
	if x[i] > x[i + 1]:
		q.append(i + 1)
q.sort(reverse=True)
if len(q) == 1:
	print(q[0])
else:
	for t in range(len(q) - 1):
		q[t] = q[t] - q[t + 1]
	print(max(q))


n = int(input())
l = input().split()
for i in range(n):
	l[i] = int(l[i])
count_max = 0
count = 1
for i in range(n - 1):
	if not l[i] > l[i + 1]:
		count += 1
	else:
		count_max = max(count_max, count)
		count = 1
count_max = max(count_max, count)
print(count_max)


def f(L):
	if len(L) == 1:
		return 1
	L2 = [1] * len(L)
	for i in range(1, len(L)):
		if L[i] >= L[i - 1]:
			L2[i] = L2[i - 1] + 1
	max = L2[0]
	for i in range(1, len(L2)):
		if L2[i] > max:
			max = L2[i]
	return max
i = int(input(''))
B = [x for x in input('').split()]
for i in range(len(B)):
	B[i] = int(B[i])
print(f(B))


(a, b, ans) = (int(input()), list(map(int, input().strip().split())), 0)
(c, d) = (b[0], 0)
for m in b:
	if m < c:
		ans = max(ans, d)
		c = m
		d = 1
	else:
		c = m
		d += 1
ans = max(ans, d)
print(ans)


n = int(input())
a = [int(s) for s in input().split()]
m = 1
s = 0
for i in range(1, n):
	if a[i] < a[i - 1]:
		m = max(m, i - s)
		s = i
	elif i + 1 == n:
		m = max(m, i - s + 1)
print(m)


a = int(input())
b = input().split()
for i in range(a):
	b[i] = int(b[i])
count = 0
c = []
for i in range(a - 1):
	if b[i + 1] >= b[i]:
		count += 1
	else:
		count = 0
	c.append(count)
if len(c) == 0:
	print(1)
else:
	print(max(c) + 1)


days = int(input())
madeMoneyEachDay = [int(i) for i in input().split(' ')]
previous = madeMoneyEachDay[0]
count = 1
maxCount = count
for day in range(1, days):
	if madeMoneyEachDay[day] < previous:
		count = 1
	else:
		count += 1
		if count > maxCount:
			maxCount = count
	previous = madeMoneyEachDay[day]
print(maxCount)


n = int(input())
a = list(map(int, input().split()))
c = 1
cmax = 1
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		c += 1
		if c > cmax:
			cmax = c
	else:
		c = 1
print(cmax)


b = int(input())
a = list(map(int, input().split()))
s = 1
i0 = 0
for i in range(1, b):
	if a[i] < a[i - 1]:
		s = max(i - i0, s)
		i0 = i
		continue
	if i == b - 1:
		s = max(i - i0 + 1, s)
print(s)


input()
s = [int(x) for x in input().split()]
seq = 1
maxx = 1
prev = s[0]
for i in range(1, len(s)):
	if s[i] >= prev:
		seq += 1
		prev = s[i]
	else:
		prev = s[i]
		seq = 1
	maxx = max(seq, maxx)
print(maxx)


a = int(input())
b = list(map(int, input().split()))
c = []
i = 0
while i < a:
	count = 1
	for n in range(a - i - 1):
		if b[i + n] <= b[i + n + 1]:
			count += 1
		else:
			break
	c.append(count)
	i += count
print(max(c))


n = int(input())
a = [int(word) for word in input().split(' ')]
if n == 1:
	print(1)
	exit()
counter = 1
counter_max = 1
for i in range(0, len(a) - 1):
	if a[i] <= a[i + 1]:
		counter += 1
		if counter_max < counter:
			counter_max = counter
	else:
		counter = 1
print(str(counter_max))


a = int(input())
c = list(map(int, input().split()))
count = 1
Max = 1
for i in range(1, a):
	if c[i] >= c[i - 1]:
		count += 1
		if count > Max:
			Max = count
	else:
		count = 1
print(Max)


def solve(arr):
	(tmp, m, cnt) = (0, 0, 0)
	for i in arr:
		if i >= tmp:
			cnt += 1
		else:
			cnt = 1
		tmp = i
		m = max(m, cnt)
	print(m)
n = int(input())
arr = map(int, input().split())
solve(arr)


n = int(input())
a = list(map(int, input().split()))
ans = 0
start = 0
for i in range(1, n + 1):
	if i == n or a[i] < a[i - 1]:
		d = i - start
		ans = max(ans, d)
		start = i
print(ans)


n = int(input())
num = list(map(int, input().split()))
count = 0
high = 0
for i in range(n - 1):
	if num[i] <= num[i + 1]:
		count += 1
		if high < count:
			high = count
	else:
		count = 0
print(high + 1)


def solve(arr, n):
	res = -float('inf')
	count = 1
	curr = 1
	while curr < n:
		if arr[curr] >= arr[curr - 1]:
			count += 1
		else:
			res = max(count, res)
			count = 1
		curr += 1
	res = max(res, count)
	return res
n = int(input())
arr = list(map(int, input().split()))
print(solve(arr, n))


from sys import stdin, stdout
n = int(stdin.readline())
arr = list(map(int, stdin.readline().split()))
ans = {}
c = 0
ans[0] = [arr[0]]
for i in range(1, len(arr)):
	if ans[c][-1] <= arr[i]:
		ans[c].append(arr[i])
	else:
		c += 1
		ans[c] = [arr[i]]
m = 0
for (k, v) in ans.items():
	m = max(m, len(v))
stdout.write(str(m) + '\n')


a = int(input())
c = 0
mas1 = []
mas = list(map(int, input().split()))
mas.append(0)
for i in range(a):
	if mas[i] <= mas[i + 1]:
		c += 1
	else:
		mas1.append(c)
		c = 0
print(max(mas1) + 1)


n = int(input())
values = map(int, input().strip().split(' '))
max_ = 0
cur_ = 0
before = 0
for v in values:
	if v >= before:
		cur_ += 1
	else:
		if cur_ > max_:
			max_ = cur_
		cur_ = 1
	before = v
print(max(max_, cur_))


n = int(input())
input_list = list(map(int, input().split()))
count_final = 1
count = 1
for i in range(n - 1):
	if input_list[i] <= input_list[i + 1]:
		count += 1
	if input_list[i] > input_list[i + 1] or i + 1 == n - 1:
		if count > count_final:
			count_final = count
		count = 1
print(count_final)


limit = int(input())
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
s = [int(i) for i in input().split()]
dem = 1
maxx = 0
i = int(0)
if limit == 1:
	print(1)
if limit != 1:
	for i in range(0, limit - 1):
		if dem > maxx:
			maxx = dem
		if s[i] <= s[i + 1]:
			dem += 1
		else:
			dem = 1
		if dem > maxx:
			maxx = dem
	print(maxx)


n = int(input())
a = list(map(int, input().split()))
cnt1 = 0
cnt2 = 0
record = []
for i in range(len(a) - 1):
	if a[i] > a[i + 1]:
		record.append(cnt1 + cnt2)
		cnt1 = cnt2 = 0
	elif a[i] == a[i + 1]:
		cnt1 += 1
	else:
		cnt2 += 1
record.append(cnt1 + cnt2)
print(max(record) + 1)


n = int(input())
a = [int(x) for x in input().split()]
d = 1
e = 1
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		e += 1
		while e > d:
			d = e
	else:
		e = 1
print(d)


input()
a = [int(j) for j in input().split(' ')]
count = 1
max = 1
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		count = count + 1
	else:
		count = 1
	if max < count:
		max = count
print(max)


n = int(input())
b = []
c = 1
a = [int(x) for x in input().split()]
for i in range(1, n):
	if a[i] >= a[i - 1]:
		c = c + 1
	else:
		b.append(c)
		c = 1
b.append(c)
d = 0
for i in range(len(b)):
	if int(b[i]) > d:
		d = int(b[i])
if len(b) != 0 and len(b) != 1:
	print(d)
else:
	print(int(b[0]))


n = int(input())
glRes = 1
res = 1
lst = list(map(int, input().split()))
pre = lst[0]
for i in range(1, n):
	if lst[i] >= lst[i - 1]:
		res += 1
	else:
		res = 1
	glRes = max(glRes, res)
print(glRes)


n = int(input())
d = [int(v) for v in input().split()]
p = d[0]
r = 0
cr = 0
for v in d:
	if v >= p:
		cr += 1
	else:
		if cr > r:
			r = cr
		cr = 1
	p = v
if cr > r:
	r = cr
print(r)


input()
a = [int(s) for s in input().split()][::-1]
m = [1]
for i in range(1, len(a)):
	if a[i] <= a[i - 1]:
		m.append(m[-1] + 1)
	else:
		m.append(1)
print(max(m))


n = int(input())
max_len = 0
previous = 0
cur_len = 0
for num in map(int, input().split()):
	if num >= previous:
		cur_len += 1
		if cur_len > max_len:
			max_len = cur_len
	else:
		cur_len = 1
	previous = num
print(max_len)


n = int(input())
a = list(map(int, input().split()))
a.append(-1)
h = 1
s = 0
for i in range(n):
	if a[i] <= a[i + 1]:
		h += 1
	else:
		if h > s:
			s = h
		h = 1
print(s)


_ = input()
money = [int(n) for n in input().split(' ')]
last = 0
max_non = 0
streak = 0
for d in money:
	if d < last:
		if streak > max_non:
			max_non = streak
		streak = 1
	else:
		streak += 1
	last = d
if streak > max_non:
	max_non = streak
print(max_non)


n = int(input())
maxc = c = p = 0
for i in map(int, input().split()):
	if i >= p:
		c += 1
	else:
		c = 1
	if c > maxc:
		maxc = c
	p = i
print(maxc)


days = int(input())
moneys = [int(x) for x in input().split()]
seq = 1
max_seq = 0
for x in range(1, len(moneys)):
	if moneys[x] >= moneys[x - 1]:
		seq += 1
	else:
		max_seq = max(seq, max_seq)
		seq = 1
max_seq = max(seq, max_seq)
print(max_seq)


input()
nums = list(map(int, input().split()))
(current_max, current_streak, longest_streak) = (0, 0, 0)
l_nums = len(nums)
for i in range(l_nums):
	if nums[i] >= current_max:
		current_max = nums[i]
		current_streak += 1
	else:
		longest_streak = max(longest_streak, current_streak)
		current_streak = 1
		current_max = nums[i]
longest_streak = max(longest_streak, current_streak)
print(longest_streak)


from sys import stdin
n = int(stdin.readline().strip())
a = list((int(x) for x in stdin.readline().strip().split(' ')))
if n == 1:
	print(1)
	exit()
result = 0
current = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		current += 1
	else:
		current = 1
	if current > result:
		result = current
print(result)


n = int(input())
a = map(int, input().split())
b = list(a)
s = 1
k = 1
t = b[0]
for i in range(1, n):
	if b[i] >= t:
		s += 1
		t = b[i]
		if s > k:
			k = s
	else:
		t = b[i]
		s = 1
print(k)


days = int(input())
money = input().split()
for i in range(days):
	money[i] = int(money[i])
maximum = 0
count = 1
for i in range(days - 1):
	if money[i + 1] >= money[i]:
		count += 1
	else:
		if count > maximum:
			maximum = count
		count = 1
if count > maximum:
	maximum = count
print(maximum)


def money(days):
	count = 0
	result = 0
	a = 11 ** 11
	for i in days:
		if i < a:
			count = 0
		count += 1
		a = i
		result = max(result, count)
	return result
n = int(input())
days = list(map(int, input().split()))
print(money(days))


n = int(input())
a = [int(i) for i in input().split()]
dp = [1 for _ in range(n)]
for i in range(1, n):
	if a[i] >= a[i - 1]:
		dp[i] = dp[i - 1] + 1
print(max(dp))


n = int(input())
f = map(int, input().split())
a = []
for i in f:
	a.append(i)
l = []
t = 1
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		t = t + 1
	else:
		l.append(t)
		t = 1
l.append(t)
print(max(l))


n = int(input())
lst = list(map(int, input().split()))
count = 0
maximum = 0
s = 0
for i in lst:
	if i >= s:
		count += 1
	else:
		count = 1
	maximum = max(maximum, count)
	s = i
print(maximum)


N = int(input())
A = [int(i) for i in input().split()]
answer = 1
current = 1
for i in range(1, N):
	if A[i] < A[i - 1]:
		current = 1
	else:
		current += 1
	answer = max(answer, current)
print(answer)


n = int(input())
a = list(map(int, input().split()))
r = 1
l = []
for t in range(n - 1):
	if a[t + 1] >= a[t]:
		r += 1
	else:
		l.append(r)
		r = 1
l.append(r)
print(max(l))


def longestiter(arr, n):
	T = [None] * n
	F = [None] * n
	T[0] = 1
	F[0] = 1
	for i in range(1, n):
		if arr[i] >= arr[i - 1]:
			F[i] = F[i - 1] + 1
		else:
			F[i] = 1
		T[i] = max(F[i], T[i - 1])
	return T[n - 1]
n = int(input())
arr = [int(ele) for ele in input().split()]
print(longestiter(arr, n))


n = int(input())
money = list(map(int, input().split()))
max_ = 0
j = 0
t = 0
for a in money:
	if a >= t:
		j += 1
		t = a
	else:
		max_ = max(j, max_)
		j = 1
		t = a
print(max(j, max_))


n = int(input())
s = input().split()
mymax = 0
k = 0
if n == 1:
	print(1)
	exit()
for i in range(n - 1):
	if int(s[i]) <= int(s[i + 1]):
		mymax += 1
	elif int(s[i]) > int(s[i + 1]):
		if mymax + 1 > k:
			k = mymax + 1
		mymax = 0
if mymax + 1 > k:
	k = mymax + 1
print(k)


n = input()
arr = [int(x) for x in input().split()]
c = 0
ind = 0
l = list()
for i in range(int(n) - 1):
	if arr[i] <= arr[i + 1]:
		c += 1
	else:
		l.append(c)
		c = 0
l.append(c)
print(max(l) + 1)


n = int(input())
m = input()
l = []
read = m.split(' ')
r = 1
ans = 1
for i in range(n):
	l.append(int(read[i]))
for i in range(1, n):
	if l[i] >= l[i - 1]:
		r += 1
		if r > ans:
			ans = r
	else:
		r = 1
print(str(ans))


line = []
while True:
	try:
		line.append(input())
	except EOFError:
		break
days = int(line[0])
progress = line[1].split(' ')
progress = list(map(int, progress))
ref = progress[0]
count = 1
values = []
values.append(count)
for x in range(1, days):
	if progress[x] >= ref:
		count = count + 1
	else:
		count = 1
	values.append(count)
	ref = progress[x]
print(max(values))


from sys import stdin
x = [int(i) for i in stdin.read().rstrip().split()]
length = x[0]
seq = x[1:]
last = float('-inf')
counter = 0
max_seq = 0
for curr in seq:
	if curr >= last:
		counter += 1
	else:
		counter = 1
	last = curr
	max_seq = max(max_seq, counter)
print(max_seq)


s = int(input())
ls = list(map(int, input().split()))
res = 0
temp = 0
for i in range(1, s):
	if ls[i] >= ls[i - 1]:
		temp += 1
	else:
		temp = 0
	if res < temp:
		res = temp
print(res + 1)


n = int(input())
a = [int(x) for x in input().split()]
maxx = 0
c = 1
for i in range(n - 1):
	if a[i] > a[i + 1]:
		if maxx < c:
			maxx = c
		c = 1
	else:
		c += 1
if c > maxx:
	maxx = c
print(maxx)


def ss(arr):
	n = len(arr)
	cont_arr = 0
	maxx = 0
	for i in range(1, n):
		if arr[i] >= arr[i - 1]:
			cont_arr += 1
		else:
			cont_arr = 0
		maxx = max(maxx, cont_arr)
	return maxx + 1
x = int(input())
l = list(map(int, input().split()))
print(ss(l))


input()
seq = [int(x) for x in input().split(' ')]
best = 1
current = 1
for i in range(len(seq) - 1):
	if seq[i] <= seq[i + 1]:
		current += 1
	else:
		if current > best:
			best = current
		current = 1
if current > best:
	best = current
print(best)


n = int(input())
values = list(map(int, input().split()))
cons = 1
max_ = 0
for i in range(len(values) - 1):
	if values[i] <= values[i + 1]:
		cons += 1
	else:
		if cons > max_:
			max_ = cons
		cons = 1
print(max(max_, cons))


n = int(input())
valor = [int(i) for i in input().split()]
i = 1
qtd = 1
maxx = 1
while i < n:
	if valor[i - 1] <= valor[i]:
		qtd += 1
	if qtd > maxx:
		maxx = qtd
	if valor[i - 1] > valor[i]:
		qtd = 1
	i += 1
print(maxx)


n = input()
s = input()
a = [int(i) for i in s.split(' ')]
(mx, L, prev) = (0, 0, 0)
for i in a:
	if prev <= i:
		L += 1
	else:
		if L > mx:
			mx = L
		L = 1
	prev = i
if L > mx:
	mx = L
print(mx)


n = int(input())
nums = list(map(int, input().split()))
loc_max = 0
g_max = 0
for idx in range(1, n):
	if nums[idx] >= nums[idx - 1]:
		loc_max += 1
	else:
		loc_max = 0
	g_max = max(g_max, loc_max)
print(g_max + 1)


qtd = int(input())
lista = list(map(int, input().split()))
max = 1
maxlocal = 1
for i in range(qtd):
	if i != 0:
		if lista[i] >= lista[i - 1]:
			maxlocal += 1
			if maxlocal > max:
				max = maxlocal
		else:
			maxlocal = 1
print(max)


n = int(input())
ls = list(map(int, input().split()))
count = [1]
i = 1
if n == 1:
	print(max(count))
else:
	while i != n:
		if ls[i - 1] <= ls[i]:
			count[-1] += 1
		else:
			count.append(1)
		i += 1
	print(max(count))


N = int(input())
avals = list(map(int, input().split()))
mndsmax = 1
mnds = 1
for x in range(1, N):
	if avals[x - 1] > avals[x]:
		mndsmax = max(mndsmax, mnds)
		mnds = 1
	else:
		mnds += 1
mndsmax = max(mnds, mndsmax)
print(mndsmax)


n = int(input())
temp_list = str(input()).split(' ')
temp_list = [int(it) for it in temp_list]
curr = 1
value = 0
for i in range(1, n):
	if temp_list[i] < temp_list[i - 1]:
		if curr > value:
			value = curr
		curr = 1
	else:
		curr += 1
if curr > value:
	value = curr
print(value)


n = int(input())
l = input().split(' ')
maxL = 0
curL = 0
for i in range(1, n):
	if int(l[i]) >= int(l[i - 1]):
		curL += 1
	else:
		if curL + 1 > maxL:
			maxL = curL + 1
		curL = 0
if curL + 1 > maxL:
	maxL = curL + 1
print(maxL)


n = int(input())
A = input().split()
cnt = 1
MAX = 1
for i in range(n - 1):
	if int(A[i]) <= int(A[i + 1]):
		cnt += 1
	else:
		cnt = 1
	MAX = max(MAX, cnt)
print(MAX)


(n, r, i, mi) = (int(input()), list(map(int, input().split())), 1, 1)
prev = r[0]
for x in r[1:]:
	if x < prev:
		mi = max(i, mi)
		i = 1
	else:
		i += 1
	prev = x
print(max(mi, i))


a = int(input())
my_list = list(map(int, input().split()))
d = 0
world = 1
d = int(my_list[0])
jeez = 1
for i in range(1, a):
	if int(my_list[i]) >= d:
		jeez += 1
		d = int(my_list[i])
	else:
		jeez = 1
		d = int(my_list[i])
	if jeez > world:
		world = jeez
print(world)


n = int(input())
l = list(map(int, input().split()))
max1 = 0
max2 = 0
count = 0
count2 = 0
l1 = []
for i in l:
	if i >= max1:
		max1 = i
		count += 1
	else:
		max1 = i
		if count > count2:
			count2 = count
		count = 1
if count > count2:
	count2 = count
print(count2)


n = int(input())
count = 1
a = list(map(int, input().split()))
max1 = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		count += 1
	else:
		count = 1
	if count > max1:
		max1 = count
print(max1)


n = int(input())
array = list(map(int, input().split()))
dp = [1]
for i in range(n - 1):
	if array[i] <= array[i + 1]:
		dp.append(dp[i] + 1)
	else:
		dp.append(1)
print(max(dp))


(n, ai) = (input(), list(map(int, input().split())))
m = 1
c = 1
for (a, b) in zip(ai[:-1], ai[1:]):
	if a > b:
		m = max(c, m)
		c = 1
	else:
		c += 1
m = max(m, c)
print(m)


n = int(input())
mas = [int(i) for i in input().split()]
temp = 1
max = 0
for i in range(1, n):
	if mas[i] >= mas[i - 1]:
		temp += 1
	elif temp > max:
		max = temp
		temp = 1
	else:
		temp = 1
if temp > max:
	max = temp
print(max)


days = int(input())
daily_income = list(map(int, input().split()))
span = 1
maxim = span
for i in range(1, days):
	if daily_income[i] >= daily_income[i - 1]:
		span += 1
	else:
		if span > maxim:
			maxim = span
		span = 1
print(maxim if maxim > span else span)


n = int(input())
list = list(map(int, input().split()))
ncount = 1
maximum = []
for i in range(1, len(list)):
	if list[i] >= list[i - 1]:
		ncount += 1
	else:
		maximum.append(ncount)
		ncount = 1
maximum.append(ncount)
print(max(maximum))


n = int(input())
l = list(map(int, input().split()))
_max = 1
dp = [1] * 100000
for i in range(1, n):
	if l[i] >= l[i - 1]:
		dp[i] = dp[i - 1] + 1
	_max = max(_max, dp[i])
print(_max)


n = int(input())
begin = 0
end = 0
s = input().split()
max = 1
for i in range(n):
	s[i] = int(s[i])
for i in range(n - 1):
	if s[i + 1] >= s[i]:
		end = i + 1
		if end - begin >= max:
			max = end - begin + 1
	else:
		begin = i + 1
print(max)


_ = input()
nums = list(map(int, input().split()))
max_len = sub_len = prev_num = 0
for num in nums:
	sub_len = sub_len + 1 if prev_num <= num else 1
	max_len = max(max_len, sub_len)
	prev_num = num
print(max_len)


n = int(input())
arr = list(map(int, input().rstrip().split()))
l = 1
maxi = 0
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		l += 1
	else:
		if maxi < l:
			maxi = l
		l = 1
if maxi < l:
	maxi = l
print(maxi)


n = int(input())
money = list(map(int, input().split()))
max_c = 0
i = 0
while i < n:
	maxi = 0
	c = 0
	while i < n and money[i] >= maxi:
		maxi = money[i]
		c += 1
		i += 1
	if c > max_c:
		max_c = c
print(max_c)


n = int(input())
an = [int(x) for x in input().split()]
t = [0]
j = 0
for i in range(n - 1):
	if an[i] <= an[i + 1]:
		t[j] = t[j] + 1
	else:
		t.append(0)
		j = j + 1
print(max(t) + 1)


from math import ceil, sqrt, gcd

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().strip().split(' '))

def li():
	return list(mi())
x = 0
n = ii()
a = li()
c = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		c += 1
	else:
		x = max(x, c)
		c = 1
x = max(x, c)
print(x)


ln = int(input())
l = list(map(int, input().split()))
c = 1
k = l[0]
n = []
if ln > 1:
	for i in l[1:]:
		if i >= k:
			c += 1
		else:
			c = 1
		n.append(c)
		k = i
	print(max(n))
else:
	print(ln)


n = int(input())
nums = input().split()
streaks = []
streak = 1
first = int(nums[0])
for i in range(1, n):
	if int(nums[i]) >= first:
		streak += 1
		first = int(nums[i])
	else:
		first = int(nums[i])
		streaks.append(streak)
		streak = 1
streaks.append(streak)
print(max(streaks))


num = int(input())
l = list((int(s) for s in input().split()))
count = 1
max = 1
for i in range(num - 1):
	if l[i] <= l[i + 1]:
		count += 1
	else:
		count = 1
	if count > max:
		max = count
print(max)


i = input
i()
c = 0
p = 0
m = 0
for x in map(int, i().split()):
	if x >= p:
		c += 1
	else:
		c = 1
	m = max(c, m)
	p = x
print(m)


size = int(input())
length = 0
curr_length = 0
array = input().split()
for num in range(1, size):
	if int(array[num]) >= int(array[num - 1]):
		curr_length += 1
		if curr_length > length:
			length = curr_length
	else:
		curr_length = 0
print(length + 1)


n = int(input())
a = input().split()
a = [int(i) for i in a]
cnt = 1
maxx = 0
for i in range(1, n):
	if a[i] >= a[i - 1]:
		cnt = cnt + 1
	else:
		maxx = max(maxx, cnt)
		cnt = 1
maxx = max(maxx, cnt)
print(maxx)


n = int(input())
days = list((int(i) for i in input().split()))
subseg = 0
dec = 0
l = list()
for i in range(n - 1):
	if days[i + 1] - days[i] >= 0:
		if dec == 0:
			subseg += 1
		else:
			l.append(subseg + 1)
			subseg = 1
			dec = 0
	else:
		dec = +1
l.append(subseg + 1)
print(max(l))


n = int(input())
ms = list(map(int, input().split()))
mx = 1
k = 1
for i in range(n - 1):
	if ms[i] <= ms[i + 1]:
		k += 1
	else:
		k = 1
	mx = max(mx, k)
print(mx)


n = int(input())
sec = input().split(' ')
L = 1
maximo = 1
for i in range(n - 1):
	sec[i] = int(sec[i])
	sec[i + 1] = int(sec[i + 1])
	if sec[i + 1] >= sec[i]:
		L = L + 1
		if L > maximo:
			maximo = L
	else:
		if L > maximo:
			maximo = L
		L = 1
print(maximo)


n = int(input())
a = [int(x) for x in input().split()]
(longest, longest_so_far) = (1, 1)
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		longest_so_far += 1
	else:
		longest_so_far = 1
	longest = max(longest, longest_so_far)
print(longest)


(_, list_in, cnt, max_out) = (input(), [int(x) for x in input().strip().split()], 0, 0)
for x in range(len(list_in) - 1):
	if list_in[x] > list_in[x + 1]:
		max_out = max_out if max_out >= cnt else cnt
		cnt = 0
	else:
		cnt += 1
else:
	max_out = max_out if max_out >= cnt else cnt
print(max_out + 1)


n = int(input())
a = [int(x) for x in input().split(' ')]
m = 1
p = 1
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		p += 1
		m = max(m, p)
	else:
		p = 1
		m = max(m, p)
print(m)


n = int(input())
l = list(map(int, input().split()))
s = 0
s1 = 0
for i in range(1, n):
	if l[i] >= l[i - 1]:
		s1 = s1 + 1
		if s1 > s:
			s = s1
	else:
		s1 = 0
print(s + 1)


n = int(input())
l = input().split()
i = 0
while i < len(l):
	l[i] = int(l[i])
	i += 1
maxi = 1
current_max = 1
old_day = l[0]
for day in l[1:]:
	if day >= old_day:
		current_max += 1
	else:
		if current_max > maxi:
			maxi = current_max
		current_max = 1
	old_day = day
if current_max > maxi:
	maxi = current_max
print(maxi)


n = int(input())
sp = list(map(int, input().split()))
(kr, ki) = (0, 1)
for i in range(1, n):
	if sp[i] >= sp[i - 1]:
		ki += 1
	elif kr < ki:
		kr = ki
		ki = 1
	else:
		ki = 1
else:
	if ki > kr:
		kr = ki
print(kr)


n = int(input())
days = [int(x) for x in input().split()]
i = 1
streak = 1
res = 1
while i < n:
	a = i - 1
	b = i
	while b < n:
		if days[b] >= days[a]:
			streak += 1
			a += 1
			b += 1
			i += 1
		else:
			res = max(res, streak)
			streak = 1
			i += 1
			break
	res = max(streak, res)
	streak = 1
print(res)


n = int(input())
lis = [int(_) for _ in input().split()]
ans = 1
inc = 1
if n > 1:
	for i in range(1, n):
		if lis[i] < lis[i - 1]:
			ans = max(ans, inc)
			inc = 1
		else:
			inc += 1
ans = max(ans, inc)
print(ans)


from sys import stdin
live = True
if not live:
	stdin = open('data.in', 'r')
n = int(stdin.readline().strip())
numbers = list(map(int, stdin.readline().strip().split()))
temp = 1
ans = 1
for (i, j) in zip(numbers, numbers[1:]):
	if i <= j:
		temp += 1
		ans = max(ans, temp)
	else:
		temp = 1
print(ans)
if not live:
	stdin.close()


n = int(input())
a = list(map(int, input().split()))
count = 0
maximum = [0]
if len(a) == 1:
	print('1')
for i in range(len(a) - 1):
	if a[i] <= a[i + 1]:
		count += 1
		if i == len(a) - 2 and count >= max(maximum):
			print(count + 1)
		elif i == len(a) - 2 and count < max(maximum):
			print(max(maximum) + 1)
	else:
		maximum.append(count)
		count = 0
		if i == len(a) - 2:
			print(max(maximum) + 1)


n = int(input())
string = input()
s = string.split(' ')
mx = 1
rec = int(s[0])
ans = 1
for i in range(1, n):
	if int(s[i]) >= rec:
		mx += 1
	else:
		mx = 1
	if mx > ans:
		ans = mx
	rec = int(s[i])
print(ans)


n = int(input())
a = [int(x) for x in input().split()]
mx = 0
tmp = 1
act = 0
next = act + 1
while next < len(a):
	if a[next] >= a[act]:
		act = next
		next = act + 1
		tmp += 1
	elif a[next] < a[act]:
		act = next
		next = act + 1
		if tmp >= mx:
			mx = tmp
			tmp = 1
		else:
			tmp = 1
if tmp > mx:
	mx = tmp
print(mx)


n = int(input())
arr = [int(x) for x in input().split()]
length = 1
maxl = 1
for i in range(len(arr) - 1):
	if arr[i] <= arr[i + 1]:
		length += 1
	else:
		length = 1
	if length > maxl:
		maxl = length
print(maxl)


n = int(input())
s = list(map(int, input().split()))
s.append(-1)
s1 = 1
j = 1
l = []
for i in range(len(s) - 1):
	if s[i] <= s[j]:
		s1 += 1
	else:
		l.append(s1)
		s1 = 1
	j += 1
print(max(l))


class Solution:

	def check(self, n, steps):
		longest_max = 1
		curr_max = 1
		for i in range(1, n):
			if steps[i - 1] <= steps[i]:
				curr_max += 1
				longest_max = max(longest_max, curr_max)
			else:
				longest_max = max(longest_max, curr_max)
				curr_max = 1
		print(longest_max)
a = Solution()
n = int(input())
steps = []
s = input()
steps = s.split(' ')
for i in range(n):
	steps[i] = int(steps[i])
a.check(n, steps)


l = int(input())
a = input().split()
ctr = 1
mp = 1
for i in range(l - 1):
	if int(a[i]) <= int(a[i + 1]):
		ctr += 1
		mp = max(mp, ctr)
	else:
		ctr = 1
print(mp)


n = int(input())
an = input().split()
x = []
for i in range(n - 1):
	if int(an[i]) <= int(an[i + 1]):
		x += [i]
if x == []:
	print(1)
else:
	n = len(x)
	F = [1] * n
	for i in range(1, n):
		if int(x[i]) == int(x[i - 1]) + 1:
			F[i] = F[i - 1] + 1
		else:
			F[i] = 1
	print(max(F) + 1)
x


numberOfNumbers = int(input())
sequence = [int(ip) for ip in input().split(' ')]
maxLength = 0
length = 1
for i in range(numberOfNumbers):
	if i == numberOfNumbers - 1:
		if length > maxLength:
			maxLength = length
		break
	elif sequence[i + 1] >= sequence[i]:
		length = length + 1
	else:
		if length > maxLength:
			maxLength = length
		length = 1
		continue
print(maxLength)


n = int(input())
x = [int(x) for x in input().split()]
cnt = 1
maxCnt = 1
for i in range(1, n):
	if x[i] >= x[i - 1]:
		cnt += 1
	else:
		maxCnt = max(cnt, maxCnt)
		cnt = 1
maxCnt = max(cnt, maxCnt)
print(maxCnt)


N = int(input())
s = input().split()
S = [int(i) for i in s]
if len(S) > 1:
	i = 1
	m = 0
	Q = []
	while i < len(S):
		if S[i] - S[i - 1] < 0:
			Q.append(m)
			m = 0
		elif S[i] - S[i - 1] >= 0:
			m += 1
		i += 1
	Q.append(m)
	print(max(Q) + 1)
elif len(S) == 1:
	print(1)


x = int(input())
y = input().split()
count = 1
max = 1
y = [int(y[i]) for i in range(len(y))]
for i in range(len(y)):
	if i == len(y) - 1:
		if y[i] > y[i - 1]:
			count += 1
		else:
			break
	elif y[i + 1] >= y[i]:
		count += 1
		if max < count:
			max = count
	else:
		count = 1
print(max)


def find(ls, curr=0, result=[]):
	for i in range(len(ls) - 1):
		if ls[i] <= ls[i + 1]:
			curr = curr + 1
		else:
			result.append(curr + 1)
			curr = 0
	result.append(curr + 1)
	return max(result)
n = input()
incomes = list(map(int, input().split()))
print(find(incomes))


n = int(input())
s = list(map(int, input().split()))
m = t = 1
for i in range(len(s) - 1):
	if s[i] <= s[i + 1]:
		t += 1
	else:
		t = 1
	if t > m:
		m = t
print(m)


def main():
	nb = int(input())
	prec = -1
	x = 0
	maxi = 0
	for elem in map(int, input().split()):
		if elem >= prec:
			x += 1
			if x > maxi:
				maxi = x
		else:
			x = 1
		prec = elem
	print(maxi)
main()


last_earned = 0
cur_sequence = 0
max_sequence = 0
_ = input()
days = list(map(int, input().split()))
for earned_in_day in days:
	if earned_in_day >= last_earned:
		cur_sequence += 1
		if cur_sequence > max_sequence:
			max_sequence = cur_sequence
	else:
		cur_sequence = 1
	last_earned = earned_in_day
print(max_sequence)


input()
a = list(map(int, input().split()))
last = 0
current = 0
max = 0
for day in a:
	if day >= last:
		current += 1
	else:
		if current > max:
			max = current
		current = 1
	last = day
if current > max:
	max = current
print(max)


n = int(input())
s = list(map(int, input().split(' ')))
s.append(s[n - 1] + 1)
a = []
i = 0
q = []
while i < len(s) - 1:
	if s[i + 1] < s[i]:
		if i == len(s) - 2:
			a.append(len(q))
			break
		q.append(s[i])
		a.append(len(q))
		q = []
	elif i == len(s) - 2:
		q.append(s[i])
		a.append(len(q))
	else:
		q.append(s[i])
	i += 1
print(max(a))


n = int(input())
l = list(map(int, input().split()))
sum1 = 0
r = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		r = r + 1
	else:
		sum1 = max(sum1, r)
		r = 1
sum1 = max(sum1, r)
print(sum1)


n = int(input())
arr = list(map(int, input().split()))
start = 0
max = 0
for i in range(n - 1):
	if arr[i] > arr[i + 1]:
		c = i - start + 1
		start = i + 1
		if c > max:
			max = c
c = n - start
if c > max:
	max = c
print(max)


def calc(n, a):
	i = 1
	start = 0
	finals = 0
	ans = 1
	while i < n:
		if a[i] >= a[i - 1]:
			if ans < i - start + 1:
				ans = i - start + 1
				finals = start
		else:
			start = i
		i += 1
	print(ans)
n = int(input())
a = list(map(int, input().split()))
calc(n, a)


n = int(input())
arr = list(map(int, input().split()))
temp = 0
count = 1
for i in range(len(arr) - 1):
	if arr[i + 1] >= arr[i]:
		count += 1
	else:
		if count > temp:
			temp = count
		count = 1
if count > temp:
	print(count)
else:
	print(temp)


def inp(s):
	j = 0
	a = []
	for i in range(len(s)):
		if s[i] == ' ':
			a.append(int(s[j:i]))
			j = i + 1
		if i == len(s) - 1:
			a.append(int(s[j:]))
	return a
n = int(input())
s = input()
a = inp(s)
c = 1
m = 1
for i in range(1, len(a)):
	if a[i] < a[i - 1]:
		c = 1
	else:
		c = c + 1
	if c > m:
		m = c
print(m)


n = int(input())
arr = list(map(int, input().split()))
(cur, maxi) = (1, 1)
if n == 1:
	print(1)
elif n == 2:
	if arr[1] >= arr[0]:
		print(2)
	else:
		print(1)
else:
	for i in range(1, n):
		if arr[i] >= arr[i - 1]:
			cur += 1
			if cur > maxi:
				maxi = cur
		else:
			cur = 1
	print(maxi)


n = int(input())
a = [int(s) for s in input().split()]
(sum, m) = (1, 1)
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		sum += 1
	else:
		sum = 1
	m = max(m, sum)
print(m)


n = int(input())
a = list(map(int, input().split()))
max_len = 1
len = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		len = len + 1
	else:
		len = 1
	if len > max_len:
		max_len = len
print(max_len)


_ = input()
nums = list(map(int, input().split()))
max_len = sub_len = prev_num = 0
for i in range(len(nums)):
	sub_len = sub_len + 1 if prev_num <= nums[i] else 1
	max_len = max(max_len, sub_len)
	prev_num = nums[i]
print(max_len)


n = int(input())
a = list(map(int, input().split()))
b = 1
t = 1
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		t += 1
	else:
		b = max(b, t)
		t = 1
print(max(b, t))


n = int(input())
l = list(map(int, input().split()))
cnt = 1
t = [1]
for i in range(n - 1):
	if l[i + 1] >= l[i]:
		cnt = cnt + 1
		t.append(cnt)
	else:
		cnt = 1
print(max(t))


def getInts():
	return [int(s) for s in input().split()]

def getInt():
	return int(input())

def getStrs():
	return [s for s in input().split()]

def getStr():
	return input()

def listStr():
	return list(input())

def solve():
	N = getInt()
	A = getInts()
	curr_run = 0
	best = 0
	for i in range(N):
		if i == 0 or A[i] >= A[i - 1]:
			curr_run += 1
		else:
			best = max(curr_run, best)
			curr_run = 1
	return max(curr_run, best)
ans = solve()
print(ans)


a = int(input())
b = input()
b = [*map(int, b.split())]
c = 1
d = 1
e = 0
for i in range(a - 1):
	if b[i] <= b[i + 1]:
		c += 1
	elif c > d:
		d = c
		c = 1
	else:
		c = 1
	if c > d:
		d = c
print(d)


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


n = int(input())
ar = list(map(int, input().split()))
p1 = 0
res = 0
ar.append(-1)
for i in range(len(ar) - 1):
	if ar[i] <= ar[i + 1]:
		p1 += 1
	else:
		if p1 > res:
			res = p1
		p1 = 0
print(res + 1)


N = int(input())
lst = list(map(int, input().split()))
count = 1
maxi = 0
for i in range(len(lst) - 1):
	if lst[i + 1] >= lst[i]:
		count += 1
	else:
		maxi = max(count, maxi)
		count = 1
print(max(maxi, count))


n = int(input())
a = [int(x) for x in input().split()]
count = 1
c = 1
if len(a) > 1:
	for x in range(1, len(a)):
		if a[x] >= a[x - 1]:
			c += 1
		else:
			if c > count:
				count = c
			c = 1
if c > count:
	count = c
print(count)


n = int(input())
k = map(int, input().split())
k1 = 0
l = 0
h = 0
for item in k:
	if item >= k1:
		k1 = item
		l = l + 1
	if l > h:
		h = l
	if item < k1:
		l = 1
		k1 = item
print(h)


t = int(input())
x = input().split()
for i in range(len(x)):
	x[i] = int(x[i])
ma = 1
i = 0
count = 1
while i < t - 1:
	if x[i + 1] >= x[i]:
		count += 1
		ma = max(ma, count)
	else:
		count = 1
	i += 1
print(ma)


n = int(input())
list_a = [int(s) for s in input().split(' ')]
list_ans = []
ans = 1
for i in range(len(list_a) - 1):
	if list_a[i] <= list_a[i + 1]:
		ans += 1
	else:
		list_ans.append(ans)
		ans = 1
	if i == len(list_a) - 2 and ans != 1:
		list_ans.append(ans)
if list_ans:
	print(max(list_ans))
else:
	print(n)


from collections import deque
import math
n = int(input())
array = input().split()
for i in range(n):
	array[i] = int(array[i])
answer = 0
increase = 0
lastMax = 0
for i in range(n):
	if lastMax > array[i]:
		increase = 1
		lastMax = array[i]
	else:
		increase += 1
		answer = max(answer, increase)
		lastMax = array[i]
print(answer)


n = int(input())
a = [int(v) for v in input().strip().split()]
ans = 1
runn = a[0]
last = 0
for i in range(1, n):
	if a[i] >= a[i - 1]:
		runn += a[i]
	else:
		ans = max(ans, i - last)
		last = i
print(max(ans, n - last))


n = int(input())
x = [int(x) for x in input().split()]
x.append(0)
count = 1
arr = []
for i in range(1, n + 1):
	if x[i] >= x[i - 1]:
		count += 1
	else:
		arr.append(count)
		count = 1
print(max(arr))


n = int(input())
l = list(map(int, input().split()))
check = [-1]
for i in range(1, n):
	if l[i - 1] > l[i]:
		check.append(i - 1)
check.append(n - 1)
max = 0
for j in range(1, len(check)):
	a = check[j] - check[j - 1]
	if max < a:
		max = a
print(max)


n = int(input())
l = list(map(int, input().strip().split()))[:n]
dp = [1] * (n + 1)
a = l[0]
count = 1
p = l[n - 1]
for i in range(1, n):
	if a > l[i]:
		a = l[i]
	elif a <= l[i]:
		dp[i] = dp[i - 1] + 1
		a = l[i]
	count = max(count, dp[i])
print(count)


n = int(input())
l = list(map(int, input().split()))
s = []
sum = 1
for i in range(n - 1):
	if l[i] <= l[i + 1]:
		sum += 1
		continue
	else:
		s.append(sum)
		sum = 1
else:
	s.append(sum)
print(max(s))


n = input()
a = list(map(int, input().split()))
counter = 1
maxcounter = 1
for i in range(len(a) - 1):
	if a[i] > a[i + 1]:
		counter = 1
	else:
		counter += 1
	if counter > maxcounter:
		maxcounter = counter
print(maxcounter)


n = int(input())
a = list(input().split(' '))

def increasing(a):
	c = 1
	l = []
	if len(a) > 1:
		for i in range(len(a) - 1):
			if int(a[i]) <= int(a[i + 1]):
				c += 1
			else:
				c = 1
			l.append(c)
	else:
		l.append(1)
	return max(l)
print(increasing(a))


n = int(input())
a = list(map(int, input().split()))
cum = 0
max_cum = 0
for i in range(1, n):
	if a[i] >= a[i - 1]:
		cum += 1
		if cum > max_cum:
			max_cum = cum
	else:
		cum = 0
print(max_cum + 1)


input()
(curr, ret, mx) = (0, 0, -1)
li = list(map(int, input().split()))
for i in li:
	if i >= mx:
		curr += 1
		ret = max(ret, curr)
	else:
		curr = 1
	mx = i
print(ret)


dp = [0] * 100001
numDays = int(input().strip())
sequence = [int(x) for x in input().strip().split()]
dp[0] = 0
dp[1] = 1
currentStreak = 1
for i in range(2, numDays + 1):
	if sequence[i - 1] >= sequence[i - 2]:
		currentStreak += 1
	else:
		currentStreak = 1
	dp[i] = max(dp[i - 1], currentStreak)
print(dp[numDays])


n = int(input())
numbers = [int(x) for x in input().split()]
biggest = 1
index = 0
index2 = 1
count = 1
while index2 < len(numbers):
	if numbers[index2] >= numbers[index]:
		count += 1
	else:
		if count > biggest:
			biggest = count
		count = 1
	index += 1
	index2 += 1
	if index2 == len(numbers) and count > biggest:
		biggest = count
print(biggest)


n = int(input())
a = [int(i) for i in input().split()]
count = 0
maxSeg = 0
for i in range(1, n):
	if a[i] >= a[i - 1]:
		count += 1
	else:
		count = 0
	if maxSeg < count:
		maxSeg = count
print(maxSeg + 1)


n = int(input())
A = list(map(int, input().split()))
count = 0
Count = 0
for t in range(1, n):
	if A[t] >= A[t - 1]:
		count += 1
		Count = max(Count, count)
	else:
		count = 0
print(Count + 1)


n = int(input())
arr = list(map(int, input().split()))
maxi = 0
stpt = 0
ltpt = 0
if len(arr) > 1:
	for x in range(1, len(arr)):
		if arr[x - 1] > arr[x]:
			stpt = x
			ltpt = x
		else:
			ltpt = ltpt + 1
		maxi = max(maxi, ltpt - stpt + 1)
else:
	maxi = len(arr)
print(maxi)


n = int(input())
l = [int(x) for x in input().split()]
count = 1
num = 1
for i in range(n - 1):
	if l[i] <= l[i + 1]:
		count += 1
		num = max(count, num)
	else:
		count = 1
print(num)


n = int(input())
a = list(map(int, input().split()))
c = d = 1
for i in range(n - 1):
	x = a[i + 1] < a[i]
	c = (c + 1) * (1 - x) + x
	d = max(d, c)
print(d)


num_days = int(input())
seq = [int(a) for a in input().strip().split()]
max_length = -float('inf')
last_num = -float('inf')
restarted = False
current_length = 0
for num in range(num_days):
	if seq[num] >= last_num:
		current_length += 1
	else:
		if current_length > max_length:
			max_length = current_length
		current_length = 1
	last_num = seq[num]
if current_length > max_length:
	max_length = current_length
print(max_length)


amountDays = int(input())
listValues = []
value = input()
listValues = value.split()
listValues = [int(val) for val in listValues]
maxSequence = 1
lastLenSequence = 1
for index in range(len(listValues) - 1):
	if listValues[index] <= listValues[index + 1]:
		lastLenSequence += 1
	else:
		if lastLenSequence > maxSequence:
			maxSequence = lastLenSequence
		lastLenSequence = 1
if lastLenSequence > maxSequence:
	maxSequence = lastLenSequence
print(maxSequence)


def main():
	input()
	l = list(map(int, input().split()))
	(res, a, x) = ([], l[0] + 1, 1)
	for b in l:
		if a > b:
			res.append(x)
			x = 1
		else:
			x += 1
		a = b
	res.append(x)
	print(max(res))
main()


n = int(input())
a = list(map(int, input().split()))
x = 0
y = []
for i in range(n - 1):
	if a[i + 1] - a[i] >= 0:
		x += 1
	elif a[i + 1] - a[i] < 0:
		y.append(x)
		x = 0
y.append(x)
print(max(y) + 1)


import math

def s():
	best = 1
	current = 1
	n = int(input())
	a = [int(x) for x in input().split(' ')]
	for i in range(1, n):
		if a[i] >= a[i - 1]:
			current += 1
		else:
			current = 1
		best = max(best, current)
	return best
ans = s()
print(ans)


def lnds(m, a):
	l = 1
	ml = 1
	for i in range(1, m):
		if a[i] >= a[i - 1]:
			l += 1
		else:
			l = 1
		ml = max(ml, l)
	return ml
m = int(input())
a = list(map(int, input().split()))
x = lnds(m, a)
print(x)


a = int(input())
a = list(map(int, input().split()))
t = 1
maxt = 0
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		t += 1
	else:
		maxt = max(t, maxt)
		t = 1
maxt = max(maxt, t)
print(maxt)


n = int(input())
a = list(map(int, input().split()))
last = a[0]
progress = 0
ans = 0
for it in a:
	if it >= last:
		progress += 1
	else:
		progress = 1
	ans = max(ans, progress)
	last = it
print(ans)


def lis(seq, n):
	s = 1
	l = []
	for i in range(1, n):
		if seq[i - 1] <= seq[i]:
			s += 1
		elif n - i > s:
			l.append(s)
			s = 1
		elif n - i <= s:
			break
	return max(l) if len(l) > 0 and max(l) > s else s
n = int(input().strip())
L = [int(x) for x in input().split(' ')]
print(lis(L, n))


n = int(input())
arr = [int(i) for i in input().split(' ')]
ans = 0
cur = 1
for i in range(n - 1):
	if arr[i] > arr[i + 1]:
		ans = max(ans, cur)
		cur = 1
	else:
		cur += 1
ans = max(ans, cur)
print(ans)


n = int(input())
a = list(map(int, input().split()))
counter = 1
e = []
if len(a) == 1:
	e.append('1')
else:
	for i in range(n - 1):
		c = a[i]
		d = a[i + 1]
		if d >= c:
			counter += 1
		else:
			counter = 1
		e.append(counter)
print(max(e))


n = int(input())
x = [int(i) for i in input().split()]
k = 1
o = 0
for j in range(1, len(x)):
	if x[j - 1] <= x[j]:
		k += 1
	else:
		o = max(o, k)
		k = 1
o = max(o, k)
print(o)


from sys import stdin, exit
stdin.readline()
nums = list(map(int, stdin.readline().rstrip().split(' ')))
l = 1
m = 1
for i in range(1, len(nums)):
	if nums[i] >= nums[i - 1]:
		l += 1
	else:
		if m < l:
			m = l
		l = 1
if m < l:
	m = l
print(m)


n = int(input())
x = list(map(int, input().split()))
(cur_min, cur_max) = (1, 1)
for i in range(1, n):
	if x[i] >= x[i - 1]:
		cur_min += 1
	else:
		if cur_min >= cur_max:
			cur_max = cur_min
		cur_min = 1
	cur_max = max(cur_min, cur_max)
print(cur_max)


n = int(input())
lst = list(map(int, input().split()))
lst2 = []
mx = []
for i in lst:
	if not lst2:
		lst2.append(i)
	elif lst2[-1] <= i:
		lst2.append(i)
	else:
		if len(mx) < len(lst2):
			mx = lst2
		lst2 = []
		lst2.append(i)
if len(mx) < len(lst2):
	print(len(lst2))
else:
	print(len(mx))


def lis(arr, n):
	m = 1
	l = 1
	for i in range(1, n):
		if arr[i] >= arr[i - 1]:
			l = l + 1
		else:
			if m < l:
				m = l
			l = 1
	if m < l:
		m = l
	return m
n = int(input().strip())
a = [int(x) for x in input().strip().split(' ')]
print(lis(a, n))


a = input()
lst = [int(x) for x in input().split()]
n = 1
aa = 1
for i in range(len(lst)):
	if i == 0:
		pass
	elif lst[i] >= lst[i - 1]:
		n += 1
		if n > aa:
			aa = n
	else:
		if n > aa:
			aa = n
		n = 1
print(aa)


n = int(input())
s = list(map(int, input().split()))
maxim = 0
ff = []
for i in range(1, n):
	if s[i - 1] <= s[i]:
		maxim += 1
	else:
		ff.append(maxim + 1)
		maxim = 0
if ff != []:
	maxff = max(ff)
	if maxim != 0:
		maxim += 1
		if maxim > maxff:
			print(maxim)
		else:
			print(maxff)
	else:
		print(maxff)
else:
	print(maxim + 1)


n = int(input())
a = [int(i) for i in input().split()]
c = 1
m = 1
i = 0
while i < n - 1:
	if a[i] <= a[i + 1]:
		c += 1
	else:
		c = 1
	if c > m:
		m = c
	i += 1
print(m)


n = int(input())
mylist = list(map(int, input().split()))
(ans, c, i) = (0, 0, 0)
while i < len(mylist) - 1:
	if mylist[i] <= mylist[i + 1]:
		c += 1
		ans = max(ans, c)
	else:
		c = 0
	i += 1
print(ans + 1)


n = int(input())
a = [int(x) for x in input().split()]
ma = 1
t = 1
for i in range(1, len(a)):
	if a[i - 1] > a[i]:
		ma = max(ma, t)
		t = 1
	else:
		t += 1
print(max(ma, t))


n = int(input())
lis = list(map(int, input().split()))
max1 = 1
c = 1
for i in range(1, len(lis)):
	if lis[i] >= lis[i - 1]:
		c += 1
	else:
		max1 = max(c, max1)
		c = 1
max1 = max(c, max1)
print(max1)


n = int(input())
ls = list(map(int, input().split()))
r = 1
temp = 1
for i in range(n - 1):
	if ls[i] <= ls[i + 1]:
		r += 1
		if temp < r:
			temp = r
	else:
		r = 1
print(temp)


n = int(input())
days = list(map(int, input().split()))
maxAsc = 0
curAsc = 0
last = 0
for d in days:
	if d >= last:
		curAsc += 1
	else:
		if curAsc > maxAsc:
			maxAsc = curAsc
		curAsc = 1
	last = d
if curAsc > maxAsc:
	maxAsc = curAsc
print(maxAsc)


num_days = int(input())
days = [int(num) for num in input().split(' ')]
max_len = 1
curr_len = 1
for i in range(1, len(days)):
	num = days[i]
	other_num = days[i - 1]
	if num >= other_num:
		curr_len += 1
	else:
		max_len = max(max_len, curr_len)
		curr_len = 1
	max_len = max(max_len, curr_len)
print(max_len)


input()
n = ms = ls = 0
for i in map(int, input().split()):
	if i < n:
		if ls > ms:
			ms = ls
		ls = 1
	else:
		ls += 1
	n = i
print(max(ls, ms))


n = int(input())
a = [int(i) for i in input().split()]
mon = a[0]
anss = ans = 1
for i in range(1, n):
	if a[i] >= mon:
		ans = ans + 1
		if ans > anss:
			anss = ans
	else:
		ans = 1
	mon = a[i]
print(anss)


import sys
import pickle
EPS = sys.float_info.epsilon
LENGTH = 10
mm = [[] for i in range(LENGTH)]
aa = [0] * LENGTH
n = int(input())
arr = list(map(int, input().split()))
res = [1 for i in range(n)]
index = 1
while index < n:
	if arr[index - 1] <= arr[index]:
		res[index] = res[index - 1] + 1
	index += 1
print(max(res))


n = int(input())
nums = list(map(int, input().split()))
N = []
k = 1
for i in range(n - 1):
	if nums[i] <= nums[i + 1]:
		k += 1
	else:
		N.append(k)
		k = 1
N.append(k)
Nmax = max(N)
print(Nmax)


def my_input():
	n = int(input())
	a = n * [0]
	t = input().split(' ')
	for i in range(n):
		a[i] = int(t[i])
	return a

def max_sequence(a):
	current_result = 1
	result = 1
	for i in range(1, len(a)):
		if a[i] < a[i - 1]:
			result = max(result, current_result)
			current_result = 0
		current_result += 1
	return max(result, current_result)

def main():
	a = my_input()
	print(max_sequence(a))
main()


n = int(input())
li = list(map(int, input().split()))
c = 1
max_ = 0
if len(li) == 1:
	print(1)
else:
	for i in range(n - 1):
		if li[i + 1] >= li[i]:
			c += 1
			if max_ < c:
				max_ = c
		else:
			if max_ < c:
				max_ = c
			c = 1
	print(max_)


import sys
n = int(input())
alist = list(map(int, sys.stdin.readline().split()))
ans = 1
crtLen = 1
crtElt = alist[0]
for i in range(1, len(alist)):
	if alist[i] >= crtElt:
		crtLen += 1
		if ans < crtLen:
			ans = crtLen
	else:
		crtLen = 1
	crtElt = alist[i]
print(ans)


n = int(input())
x = list(map(int, input().split()))
z = 1
m = 1
for i in range(1, n):
	if x[i] >= x[i - 1]:
		z = z + 1
	else:
		if z > m:
			m = z
		z = 1
if z > m:
	m = z
print(m)


n = int(input())
list1 = input().split(' ')
a = 1
alist = []
for i in range(1, n):
	if int(list1[i]) >= int(list1[i - 1]):
		a += 1
	else:
		alist.append(a)
		a = 1
alist.append(a)
print(max(alist))


n = int(input())
if n >= 1 and n <= 100000:
	a = list(map(int, input().split()))
	i = len(a)
	check = 1
	if i == n:
		for p in a:
			if p < 1 or p > 1000000000:
				check = 0
				break
		if check == 1:
			if i == 1:
				print('1')
			else:
				num = 0
				temp = 0
				final = 0
				j = 0
				while j < i:
					if a[j] <= a[j + 1]:
						num += 1
					elif num != 0:
						temp = num + 1
						if temp > final:
							final = temp
							temp = 0
						num = 0
					if j == i - 2:
						if a[j] <= a[j + 1]:
							num += 1
						break
					j += 1
				d = 0
				while d < i - 1:
					if a[d] > a[d + 1]:
						decrease = 0
					else:
						decrease = 1
						break
					d += 1
				if decrease == 0:
					print('1')
				elif final > num:
					print(final)
				else:
					print(num)


n = int(input())
data = list(map(int, input().split()))
c = 0
count = 1
max = 0
while c < len(data):
	if c < len(data) - 1 and data[c] <= data[c + 1]:
		count += 1
	else:
		if count > max:
			max = count
		count = 1
	c += 1
print(max)


n = int(input())
arr = [int(i) for i in input().split()]
max1 = 0
lent = 0
for i in range(n - 1):
	if arr[i + 1] >= arr[i]:
		lent += 1
	if lent > max1:
		max1 = lent
	if arr[i + 1] < arr[i]:
		lent = 0
print(max1 + 1)


n = int(input())
l = list(map(int, input().split()))
mx = l[0]
max_len = 1
new_len = 1
for i in range(1, len(l)):
	if l[i] >= l[i - 1]:
		new_len += 1
	else:
		new_len = 1
	max_len = max(max_len, new_len)
print(max_len)


import sys
lines = iter(sys.stdin.read().split('\n'))
n = int(next(lines))
nums = list(map(int, next(lines).strip(' ').split(' ')))
best = 0
res = 0
pre = nums[0]
for num in nums:
	if num >= pre:
		pre = num
		res += 1
	else:
		pre = num
		if res > best:
			best = res
		res = 1
if res > best:
	best = res
print(best)


n = int(input())
N = list(map(int, input().split()))
(k, K) = (0, 0)
for i in range(N.__len__() - 1):
	if N[i] <= N[i + 1]:
		k += 1
	else:
		k = 0
	if k > K:
		K = k
K += 1
print(K)


n = int(input())
a = [int(j) for j in input().split()]
ans = 0
temp = 1
for i in range(0, n - 1):
	if a[i] > a[i + 1]:
		ans = max(ans, temp)
		temp = 1
	else:
		temp += 1
ans = max(ans, temp)
print(ans)


n = input()
n = int(n)
y = input().split()
for x in range(len(y)):
	y[x] = int(y[x])
count = 1
out = 1
for w in range(n - 1):
	if y[w + 1] >= y[w]:
		count += 1
		if count > out:
			out = count
	else:
		if count > out:
			out = count
		count = 1
print(out)


cisel = int(input())
cisla = map(int, input().split())
maxi = 0
aktualne = 0
predchadzajuce = 0
for cislo in cisla:
	if cislo < predchadzajuce:
		maxi = max(maxi, aktualne)
		aktualne = 0
	aktualne += 1
	predchadzajuce = cislo
maxi = max(maxi, aktualne)
print(maxi)


_ = input()
a_n = [int(i) for i in input().split()]
max_s = res = 1
f = a_n[0]
for i in a_n[1:]:
	if f <= i:
		max_s += 1
	else:
		res = max(res, max_s)
		max_s = 1
	f = i
else:
	res = max(res, max_s)
print(res)


n = int(input())
mas = list(map(int, input().split()))
s = 1
mx = 0
for i in range(1, len(mas)):
	if mas[i] >= mas[i - 1]:
		s += 1
	else:
		if s > mx:
			mx = s
		s = 1
if s > mx:
	mx = s
print(mx)


n = int(input())
a = input().split()
(ans, tans, pre) = (1, 0, int(a[0]))
for i in range(n):
	a[i] = int(a[i])
	if a[i] >= pre:
		tans += 1
		ans = max(ans, tans)
	else:
		tans = 1
	pre = a[i]
print(ans)


a = int(input())
arr = list(map(int, input().rstrip().split()))
prev = arr[0]
sub_seq = 1
max_sub = 1
for i in range(1, a):
	if arr[i] >= prev:
		prev = arr[i]
		sub_seq += 1
	else:
		sub_seq = 1
		prev = arr[i]
	if sub_seq > max_sub:
		max_sub = sub_seq
print(max_sub)


def func(n):
	counter = 0
	maxi = 0
	x = list(map(int, input().split()))
	for i in range(len(x) - 1):
		if x[i] <= x[i + 1]:
			counter += 1
			if counter > maxi:
				maxi = counter
		else:
			counter = 0
	print(maxi + 1)
n = int(input())
func(n)


n = int(input())
a = [int(x) for x in input().split()]
a.append(0)
max_len = 1
cur_len = 1
for i in range(1, n + 1):
	if a[i] < a[i - 1]:
		max_len = max(max_len, cur_len)
		cur_len = 1
	else:
		cur_len += 1
print(max_len)


siz = int(input())
inp = list(input().split(' '))
final = []
for i in range(0, siz):
	final.append(int(inp[i]))
counter = [1 for i in range(0, siz)]
maxx = final[0]
j = 0
for i in range(1, siz):
	if final[i] >= maxx:
		counter[j] += 1
		maxx = final[i]
	else:
		maxx = final[i]
		j += 1
print(max(counter))


n = int(input())
l = list(map(int, input().split()))
ans = 0
a = []
if n == 1 and len(l) == 1:
	print(1)
else:
	for i in range(len(l) - 1):
		if l[i + 1] >= l[i]:
			ans += 1
			a.append(ans)
		else:
			ans = 0
			a.append(ans)
	print(max(a) + 1)


n = int(input())
str = [int(i) for i in input().split()]
x = 1
y = 1
for i in range(1, n, 1):
	if str[i] >= str[i - 1]:
		x += 1
	else:
		x = 1
	if x > y:
		y = x
print(y)


n = int(input())
nums = [int(i) for i in input().split()]
s = 0
l = 0
r = 0
a = nums[0]
maxLth = 1
for i in range(1, n):
	if nums[i] >= a:
		l = s
		r = i
	else:
		s = i
	maxLth = max(maxLth, r - l + 1)
	a = nums[i]
print(max(maxLth, r - l + 1))


length = int(input())
income = list(map(int, input().split()))
i = 1
n = 1
a = 0
while i < length:
	if income[i] >= income[i - 1]:
		n += 1
	elif n >= a:
		a = n
		n = 1
	else:
		a = a
		n = 1
	i += 1
if n > a:
	print(n)
else:
	print(a)


r = input()
n = input().split()
l = []
count = 0
n = [int(i) for i in n]
for i in range(len(n)):
	if i == len(n) - 1 and n[i] >= n[i - 1]:
		count + 1
		l.append(count + 1)
	elif i == len(n) - 1 and n[i] < n[i - 1]:
		break
	elif n[i] <= n[i + 1]:
		count += 1
	else:
		l.append(count + 1)
		count = 0
if not l:
	l.append(count + 1)
print(max(l))


def main():
	n = int(input())
	a = list(map(lambda x: int(x), input().split()))
	m = 0
	c = 0
	tmp = a[0]
	for e in a:
		if tmp <= e:
			c += 1
		else:
			c = 1
		tmp = e
		if c > m:
			m = c
	return m
print(main())


def max_length(arr):
	count = 0
	max_count = 0
	for i in range(1, len(arr)):
		if arr[i - 1] <= arr[i]:
			count += 1
		else:
			if count > max_count:
				max_count = count
			count = 0
		if i == len(arr) - 1:
			if count > max_count:
				max_count = count
	return max_count + 1
n = int(input())
arr = list(map(int, input().split()))
print(max_length(arr))


x = int(input())
d = 0
w = 0
q = 0
s = input().split()
a = [int(num) for num in s]
for i in a:
	if i >= q:
		q = i
		w += 1
	elif q > i:
		if w > d:
			d = w
		w = 1
		q = i
if w > d:
	d = w
if d == 0:
	print(w)
else:
	print(d)


jksdf = input()
s = [int(i) for i in input().split(' ')]
ans = 0
diffi = 0
difff = 0
for i in range(len(s) - 1):
	if s[i] <= s[i + 1]:
		diffi += 1
		if diffi > difff:
			difff = diffi
	elif s[i] > s[i + 1] and difff != 0:
		diffi = 0
print(difff + 1)


n = int(input())
a = list(input().split())
l = 1
last = int(a[0])
max_l = 1
for i in range(1, n):
	if int(a[i]) >= last:
		l += 1
	else:
		if l > max_l:
			max_l = l
		l = 1
	last = int(a[i])
	if l > max_l:
		max_l = l
print(max_l)


c = 0
d = 0
n = int(input())
a = list(map(int, input().rstrip().split()))
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		c += 1
		if c > d:
			d = c
	else:
		c = 0
print(d + 1)


(n, days) = (int(input()), list(map(int, input().split())) + [0])
(count, l, f, t) = (1, [], 0, 0)
for i in range(n):
	if days[i] <= days[i + 1]:
		count += 1
	else:
		l.append(count)
		count = 1
print(max(l))


n = int(input())
lst = list(map(int, input().split()))
count = 1
maxx = 1
for i in range(1, n):
	if lst[i] >= lst[i - 1]:
		count += 1
	else:
		count = 1
	if count > maxx:
		maxx = count
print(maxx)


n = int(input())
l = list(map(int, input().split()))
k = 1
m = [1]
for i in range(n):
	if i == 0:
		continue
	elif l[i] >= l[i - 1]:
		k = k + 1
		m.append(k)
	else:
		k = 1
print(max(m))


n = int(input())
l = list((int(x) for x in input().split()))
l2 = []
count = 1
if n > 1:
	for i in range(1, n):
		if l[i] >= l[i - 1]:
			count += 1
		else:
			l2.append(count)
			count = 1
		if i == n - 1:
			l2.append(count)
print(max(l2) if n > 1 else '1')


n = int(input())
(count, ans) = (1, 0)
a = list(map(int, input().split()))
for (i, j) in zip(a[:-1], a[1:]):
	if i <= j:
		count += 1
	else:
		ans = max(ans, count)
		count = 1
ans = max(ans, count)
print(ans)


import sys
import os
from io import BytesIO, IOBase

def cel(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def prr(a, sep=' '):
	print(sep.join(map(str, a)))

def dd():
	return defaultdict(int)

def ddl():
	return defaultdict(list)

def ddd():
	return defaultdict(defaultdict(int))
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from collections import defaultdict
n = ii()
a = li()
a += [-10 ** 6]
res = 0
i = 0
f = 0
while i < n:
	if a[i + 1] >= a[i]:
		f = 1
		cur = i
		while a[i + 1] >= a[i]:
			i += 1
		res = max(res, i - cur + 1)
	i += 1
if f == 1:
	print(res)
else:
	print(1)


n = int(input())
string = list(map(int, input().strip().split()))
count = 1
maxcount = 1
for i in range(0, n - 1):
	if string[i] <= string[i + 1]:
		count += 1
		if count > maxcount:
			maxcount = count
	else:
		count = 1
print(maxcount)


t = int(input())
arr = list(map(int, input().split()))
maxx = 1
res = 1
for x in range(1, t):
	if arr[x] >= arr[x - 1]:
		maxx = maxx + 1
	else:
		res = max(res, maxx)
		maxx = 1
res = max(res, maxx)
print(res)


n = int(input())
l = list(map(int, input().split()))
ma = 1
ma1 = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		ma1 += 1
	else:
		ma = max(ma, ma1)
		ma1 = 1
ma = max(ma, ma1)
print(ma)


n = int(input())
a = list(map(int, input().split()))
i = 1
b = [1] * n
while i < n:
	if a[i - 1] <= a[i]:
		b[i] = b[i - 1] + 1
	i += 1
print(max(b))


n = int(input())
l = list(map(int, input().strip().split()))
r = []
a = []
if n == 1:
	print(1)
	exit()
for i in range(1, len(l)):
	if l[i] >= l[i - 1]:
		r.append(l[i])
	else:
		r.clear()
	a.append(len(r))
print(max(a) + 1)


n = int(input())
a = list(map(int, input().split()))
answer = 1
answer2 = 0
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		answer += 1
	else:
		if answer > answer2:
			answer2 = answer
		answer = 1
if answer > answer2:
	answer2 = answer
print(answer2)


def main():
	numDays = int(input())
	a = input().split()
	a = list(map(int, a))
	maxSubSeq = 1
	tempMax = 1
	for i in range(numDays - 1):
		if a[i + 1] >= a[i]:
			tempMax += 1
			if tempMax > maxSubSeq:
				maxSubSeq = tempMax
		else:
			tempMax = 1
	print(maxSubSeq)
main()


n = int(input())
a = list(map(int, input().split()))
result = []
count = 1
i = 0
if n != 1:
	while i < n - 1:
		if a[i] <= a[i + 1]:
			count += 1
			i += 1
		elif a[i] > a[i + 1]:
			count = 1
			i += 1
		result.append(count)
	count = max(result)
else:
	count = 1
print(count)


n = int(input())
numbers = input().split()
decrease = [False for x in range(n - 1)]
for index in range(n - 1):
	decrease[index] = int(numbers[index]) > int(numbers[index + 1])
longest = 0
current = 1
index = 0
while index < n - 1:
	if decrease[index]:
		if current > longest:
			longest = current
		current = 1
	else:
		current += 1
	index += 1
if current > longest:
	longest = current
print(longest)


a = int(input())
C = [int(x) for x in input().split()]
count = 0
mayor = 0
for k in range(len(C) - 1):
	if C[k] <= C[k + 1]:
		count += 1
	else:
		count = 0
	if count > mayor:
		mayor = count
print(mayor + 1)


n = int(input())
a = list(map(int, input().split()))
a.append(-1)
mx = -1
cur = -1
i = 0
while i < n:
	cur = 1
	while i < n and a[i + 1] >= a[i]:
		i += 1
		cur += 1
	mx = max(mx, cur)
	i += 1
print(mx)


n = int(input())
l = list(map(int, input().split()))
val = l[0]
current = 1
ma = 1
for i in range(1, n):
	if l[i] >= val:
		current += 1
		val = l[i]
	else:
		ma = max(ma, current)
		current = 1
		val = l[i]
print(max(ma, current))


n = int(input())
arr = [int(i) for i in input().split()]
maxlength = 0
cnt = 1
for i in range(n - 1):
	if cnt > maxlength:
		maxlength = cnt
	if arr[i + 1] >= arr[i]:
		cnt += 1
	else:
		cnt = 1
print(max(maxlength, cnt))


n = int(input())
nums = [int(x) for x in input().split()]
maxLength = 1
counter = 1
start = 0
end = 1
i = 0
while i < n:
	if end < n and nums[start] <= nums[end]:
		counter += 1
		start += 1
		end += 1
		if counter > maxLength:
			maxLength = counter
	else:
		counter = 1
		start = end
		end += 1
	i += 1
print(maxLength)


from sys import stdin, stdout
from sys import maxsize

def solve(a, n):
	i = 0
	mlen = 1
	while i < n:
		j = i + 1
		while j < n and a[j] >= a[j - 1]:
			j += 1
		mlen = max(mlen, j - i)
		i = j
	print(mlen)
test = 1
for t in range(0, test):
	n = int(input())
	arr = [int(x) for x in input().split()]
	ans = solve(arr, n)


(_, line, last, maxi, curr) = (int(input()), list(map(int, input().split(' '))), 100000000000, 0, 0)
for l in line + [0]:
	(curr, maxi, last) = (curr + 1, maxi, l) if l >= last else (1, max(maxi, curr), l)
print(maxi)


n = int(input())
s = list(map(int, input().split()))
r = 0
k = 0
for i in range(n - 1):
	r += 1
	if s[i + 1] < s[i]:
		if k < r:
			k = r
		r = 0
if s[n - 1] >= s[n - 2]:
	r += 1
if r > k:
	print(r)
else:
	print(k)


n = int(input())
ls1 = [int(x) for x in input().split()]
a = 1
ls2 = []
if len(ls1) == 1:
	print('1')
else:
	for i in range(len(ls1) - 1):
		if ls1[i + 1] >= ls1[i]:
			a += 1
			ls2.append(a)
		else:
			a = 1
			ls2.append(a)
	print(max(ls2))


def read() -> int:
	return int(input())

def read_list() -> list:
	return list(map(int, input().split()))
n = read()
ns = read_list()
l = 1
best = -1
for i in range(1, n):
	if ns[i] >= ns[i - 1]:
		l += 1
		best = max(l, best)
	else:
		l = 1
best = max(l, best)
print(best)


a = 1
b = []
n = int(input())
money = [int(p) for p in input().split()]
for i in range(n - 1):
	if money[i] <= money[i + 1]:
		a += 1
	else:
		b.append(a)
		a = 1
b.append(a)
print(max(b))


n = int(input())
a = list(map(int, input().split()))
(start, end) = (0, 0)
maxl = 0
while start < n:
	while end < n and a[max(end - 1, start)] <= a[end]:
		end += 1
	maxl = max(maxl, end - start)
	start = end
print(maxl)


n = int(input())
c = list(map(int, input().split()))
most = 0
tmp = 0
for (i, num) in enumerate(c):
	if num >= c[i - 1] and i > 0:
		tmp += 1
	else:
		if tmp > most:
			most = tmp
		tmp = 0
if tmp > most:
	most = tmp
print(most + 1)


n = int(input())
data = list(map(int, input().split()))
cont = 1
maximum = 0
for i in range(len(data) - 1):
	if data[i] <= data[i + 1]:
		cont += 1
	else:
		if cont > maximum:
			maximum = cont
		cont = 1
if cont > maximum:
	print(cont)
else:
	print(maximum)


n = int(input())
lista = list(map(int, input().split()))
m = 0
contador = 1
for i in range(1, len(lista)):
	if lista[i] >= lista[i - 1]:
		contador = contador + 1
	else:
		m = max(contador, m)
		contador = 1
m = max(contador, m)
print(str(m))


n = int(input())
arr = list(map(int, input().split()))
dp = [1 for i in range(n)]
count = 1
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		count += 1
	else:
		count = 1
	dp[i] = max(dp[i - 1], count)
print(dp[n - 1])


n = int(input())
s = list(map(int, input().split(' ')))
current = 1
ans = 1
for i in range(1, n):
	if s[i] >= s[i - 1]:
		current += 1
		if current > ans:
			ans = current
	else:
		current = 1
print(ans)


n = int(input())
arr = list(map(int, input().split()))
maxim = 1
count = 1
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		count = count + 1
	else:
		if count > maxim:
			maxim = count
		count = 1
if count > maxim:
	maxim = count
print(maxim)


n = int(input())
a = list(map(int, input().split(' ')))
current = 1
maximum = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		current += 1
	else:
		maximum = max(current, maximum)
		current = 1
maximum = max(current, maximum)
print(maximum)


n = int(input())
b = 1
l = input().split()
L = []
for i in range(n):
	L.append(int(l[i]))
i = 0
while i < n:
	a = 1
	c = i
	for j in range(c, n - 1):
		if L[j] <= L[j + 1]:
			a += 1
		else:
			i = j
			break
	if a > b:
		b = a
	if a == n:
		break
	i += 1
print(b)


n = int(input())
an = list(map(int, input().split()))
an.append(0)
ln = 1
mxl = 0
for i in range(1, n):
	if an[i - 1] <= an[i]:
		ln += 1
	else:
		mxl = max(ln, mxl)
		ln = 1
mxl = max(ln, mxl)
print(mxl)


n = int(input())
groups = [int(a) for a in input().split(' ')]
count = 0
line = 1
max = 0
while count < n - 1:
	i = groups[count]
	if i <= groups[count + 1]:
		line = line + 1
	else:
		if line > max:
			max = line
		line = 1
	count += 1
if line > max:
	max = line
print(max)


def solve(Arr, n):
	dp = [1 for _ in range(n)]
	for i in range(1, n):
		if Arr[i] >= Arr[i - 1]:
			dp[i] = dp[i - 1] + 1
	return max(dp)
n = int(input())
Arr = list(map(int, input().split()))
print(solve(Arr, n))


number = int(input())
s = input()
list = s.split()
for i in range(len(list)):
	list[i] = int(list[i])
maxlen = 0
s = 0
i = 1
while i < len(list):
	j = i
	while list[j - 1] <= list[j]:
		s = s + 1
		if s > maxlen:
			maxlen = s
		if j < len(list) - 1:
			j = j + 1
		else:
			break
	i = j + 1
	s = 0
print(maxlen + 1)


n = int(input())
l1 = [int(x) for x in input().split()]
i = 0
temp = 1
ans = 1
while i < len(l1) - 1:
	if l1[i] > l1[i + 1]:
		temp = 1
	else:
		temp += 1
	ans = max(temp, ans)
	i += 1
print(ans)


n = int(input())
a = [int(x) for x in input().split()]
before = 0
current = 0
submax = 0
for i in a:
	if i < before:
		current = 1
	else:
		current += 1
	if current > submax:
		submax = current
	before = i
print(submax)


class Store:
	cur_profit = 0
	days = 0

def max_inc(n, a):
	current = Store()
	days = 0
	for profit in a:
		if profit < current.cur_profit:
			days = 1
		else:
			days += 1
			if days > current.days:
				current.days = days
		current.cur_profit = profit
	return current.days

def main():
	n = int(input())
	a = list(map(int, input().split()))
	print(max_inc(n, a))
main()


length = int(input())
numbers = list(map(int, input().split()))
increase_length = 0
store = 0
last = numbers[0]
for i in range(1, len(numbers)):
	if numbers[i] >= last:
		increase_length += 1
	else:
		if increase_length > store:
			store = increase_length
		increase_length = 0
	last = numbers[i]
print(max(store, increase_length) + 1)


x = int(input())
y = list(map(int, input().split()))
max = 0
podrad = 1
ty = 0
for i in range(x):
	if i == 0:
		podrad = 1
	elif y[i] >= y[i - 1]:
		podrad += 1
	else:
		if podrad > max:
			max = podrad
		podrad = 1
	if i == x - 1 and podrad != 0 and (podrad > max):
		print(podrad)
		ty = 7
if ty == 0:
	print(max)


n = int(input())
a = [int(x) for x in input().split()]
longestSubsequence = 0
currentLongest = 0
currentNumber = 0
for i in range(n):
	if a[i] >= currentNumber:
		currentLongest += 1
		longestSubsequence = max(currentLongest, longestSubsequence)
	else:
		currentLongest = 1
	currentNumber = a[i]
print(longestSubsequence)


n = input()
b = list(map(int, input().split()))
maxsteps = 0
steps = 1
start = b[0]
for i in b[1:]:
	if i >= start:
		start = i
		steps += 1
	else:
		if steps >= maxsteps:
			maxsteps = steps
		steps = 1
		start = i
if maxsteps >= steps:
	print(maxsteps)
else:
	print(steps)


n = int(input())
money = list(map(int, input().split()))
max_ = 1
i = 0
while i < n - 1:
	j = 0
	while money[i + j] <= money[i + j + 1]:
		if i + j + 1 < n - 1:
			j += 1
		elif i + j + 1 == n - 1:
			j += 1
			break
	if max_ < j + 1:
		max_ = j + 1
	i = i + j + 1
print(max_)


n = int(input())
l = [int(i) for i in input().split()]
m = 0
c = 0
h = 0
for i in l:
	if i >= h:
		c = c + 1
		if c > m:
			m = c
	else:
		c = 1
	h = i
print(m)


n = int(input())
a = list(map(lambda x: int(x), input().split()))
b = 1
c = 1
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		b += 1
	else:
		b = 1
	if b > c:
		c = b
print(c)


n = int(input())
a = list(map(int, input().rstrip().split()))
st = [1]
for i in range(1, n):
	if a[i] > a[i - 1]:
		st.append(1)
	elif a[i] == a[i - 1]:
		st.append(max(0, st[-1]))
	else:
		st.append(-1)
max_1 = max_0 = 0
count_0 = count_1 = 0
i = 1
while i < n:
	if st[i] == 0:
		count_0 += 1
		max_0 = max(count_0, max_0)
		count_1 = 0
	elif st[i] == 1:
		count_1 += 1
		max_1 = max(count_1, max_1)
		count_0 = 0
	else:
		count_1 = 0
		count_0 = 0
	i += 1
print(max(max_0, max_1) + 1)


_ = input()
arr = list(map(int, input().split())) + [0]
m = 1
last = arr[0]
curr = 1
for i in arr[1:]:
	if i >= last:
		curr += 1
	else:
		if curr > m:
			m = curr
		curr = 1
	last = i
print(m)


arg = int(input())
list1 = list(map(int, input().strip().split()))
res = 1
maximum = 1
for a in range(1, arg):
	if list1[a] >= list1[a - 1]:
		res += 1
	else:
		maximum = max(maximum, res)
		res = 1
print(max(maximum, res))


n = int(input())
a = list(map(int, input().split()))
dp = dict()
max_length = -float('inf')
for i in range(len(a)):
	if i == 0:
		dp[i] = (1, a[i])
	elif a[i] >= dp[i - 1][1]:
		dp[i] = (dp[i - 1][0] + 1, a[i])
	else:
		dp[i] = (1, a[i])
	max_length = max(max_length, dp[i][0])
print(max_length)


k = int(input())
L = list(map(int, input().split()))
n = 1
m = 0
for i in range(1, k):
	if L[i - 1] > L[i]:
		m = max(m, n)
		n = 1
		continue
	n += 1
print(max(m, n))


import sys
n = int(input())
array = list(map(int, input().split()))
r = 1
naj = 0
s = 0
izpis = [0] * n
if n == 1:
	print('1')
	sys.exit()
for i in range(0, n - 1):
	if array[i] <= array[i + 1]:
		r += 1
	else:
		izpis[s] = r
		s += 1
		r = 1
izpis[i] = r
for j in range(0, n - 1):
	if naj < izpis[j]:
		naj = izpis[j]
print(str(naj))


n = int(input())
inp = list(map(int, input().split()))
c = 1
mc = 0
for i in range(1, n):
	if inp[i] < inp[i - 1]:
		mc = max(mc, c)
		c = 1
	else:
		c += 1
print(max(mc, c))


n = int(input())
a = list(map(int, input().split(' ')))
i = 0
total = 1
x = []
while i + 1 < n and n > 1:
	if a[i] <= a[i + 1] and i + 1 != n - 1:
		total += 1
		i += 1
	elif a[i] <= a[i + 1] and i + 1 == n - 1:
		total += 1
		i += 1
		x.append(total)
	else:
		x.append(total)
		total = 1
		i += 1
if n == 1:
	x.append(1)
print(max(x))


number = int(input())
sequence = [int(x) for x in input().split()]
money = 1
maximum = 1
for i in range(1, number):
	if sequence[i] >= sequence[i - 1]:
		money += 1
	else:
		money = 1
	maximum = max(money, maximum)
print(maximum)


t = int(input())
a = b = c = 0
for i in str(input()).split():
	if int(i) >= b:
		a += 1
	else:
		a = 1
	c = max(c, a)
	b = int(i)
print(c)


n = int(input())
a = list(map(int, input().split()))
maxNr = 1
nrCurrent = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		nrCurrent += 1
		maxNr = max(maxNr, nrCurrent)
	else:
		nrCurrent = 1
print(maxNr)


z = int(input())
a = [int(x) for x in input().split()]
d = [1] * z
maxi = 1
for i in range(1, z):
	if a[i - 1] <= a[i]:
		d[i] = d[i - 1] + 1
		if d[i] > maxi:
			maxi = d[i]
print(maxi)


num = int(input())
lit = list(map(int, input().strip().split()))[:num]
c = []
b = 1
if len(lit) == 1:
	print(1)
else:
	for i in range(num - 1):
		if lit[i] <= lit[i + 1]:
			b += 1
			c.append(b)
		else:
			b = 1
	if len(c) == 0:
		print(1)
	else:
		print(max(c))


def dp005_kefa_and_first_steps(n, a):
	maxn = 1
	f = []
	f.append(1)
	for i in range(1, n):
		if a[i] >= a[i - 1]:
			f.append(f[i - 1] + 1)
		else:
			f.append(1)
		maxn = max(maxn, f[i])
	return maxn
n = int(input())
a = []
a.extend(map(int, input().split()))
result = dp005_kefa_and_first_steps(n, a)
print(result)


n = int(input())
x = map(int, input().split())
mx = 0
l = -1
sum = 0
for i in x:
	if i >= l:
		sum += 1
		l = i
	else:
		mx = max(mx, sum)
		sum = 1
		l = i
mx = max(sum, mx)
print(mx)


n = int(input())
lis = list(map(int, input().split()))
leng = []
counter = 1
for i in range(n - 1):
	if lis[i] <= lis[i + 1]:
		counter += 1
	else:
		leng.append(counter)
		counter = 1
leng.append(counter)
print(max(leng))


def abir():
	return map(int, input().split(' '))
a = int(input())
n = list(abir())
mx = 0
cnt = 1
for i in range(a - 1):
	if n[i] > n[i + 1]:
		mx = max(cnt, mx)
		cnt = 1
	else:
		cnt += 1
mx = max(cnt, mx)
print(mx)


n = int(input())
a = [int(i) for i in input().split()]
actual = 0
max = 0
prev = 0
for i in a:
	if prev <= i:
		actual += 1
		if actual > max:
			max = actual
	else:
		actual = 1
	prev = i
print(max)


n = int(input())
a = list(map(int, input().split()))
seq = list()
ctr = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		ctr += 1
	else:
		seq.append(ctr)
		ctr = 1
if ctr > 1:
	seq.append(ctr)
if len(seq) > 0:
	print(max(seq))
else:
	print(1)


n = int(input())
arr = [int(x) for x in input().split()]
ans = 1
j = 0
count = 0
i = 1
while i <= n - 1:
	count = 0
	if arr[i] >= arr[i - 1]:
		j = i + 1
		count = 1
		if j != n:
			while arr[j] >= arr[j - 1]:
				count += 1
				j += 1
				if j == n:
					break
		i = j
	i = i + 1
	if count + 1 > ans:
		ans = count + 1
print(ans)


n = int(input())
days = [int(d) for d in input().split()]
long = 1
(temp_, x) = (1, 0)
while x < n - 1:
	if days[x] <= days[x + 1]:
		temp_ += 1
	else:
		temp_ = 1
	if long < temp_:
		long = temp_
	x += 1
print(long)


n = int(input())
l = list(map(int, input().split()))
minnum = l[0]
L = [0, 1]
for i in range(1, n):
	if l[i] >= minnum:
		num = L[i] + 1
		L.append(num)
		minnum = l[i]
	else:
		minnum = l[i]
		num = 1
		L.append(num)
L.sort()
print(L[-1])


n = int(input())
a = list(map(int, input().split()))
i = 0
j = 1
length = 1
max_len = 1
while j < n:
	if a[j] >= a[j - 1]:
		length = j - i + 1
		if length > max_len:
			max_len = length
		j += 1
	else:
		i = j
		length = 1
		j += 1
print(max_len)


def increase(t, a):
	maj = 0
	count = 1
	for i in range(t - 1):
		if a[i] <= a[i + 1]:
			count += 1
		else:
			maj = max(count, maj)
			count = 1
	maj = max(count, maj)
	print(maj)

def main():
	try:
		t = int(input())
		a = [int(x) for x in input().split(' ')]
		increase(t, a)
		main()
	except:
		print()
main()


n = int(input())
a = list(map(int, input().split()))
m = 0
i = 0
ind1 = 0
while i < n:
	i += 1
	len = 1
	while i < n and a[i] >= a[i - 1]:
		len += 1
		i += 1
	ind1 = i
	m = max(len, m)
print(m)


numlines = input()
money = input()
mlist = list(map(int, money.split(' ')))
increasing = []
sublength = 0
for profit in range(len(mlist)):
	if profit != len(mlist) - 1:
		if mlist[profit] <= mlist[profit + 1]:
			sublength += 1
		elif mlist[profit] >= mlist[profit - 1]:
			sublength += 1
			increasing.append(sublength)
			sublength = 0
		else:
			continue
	elif mlist[profit] >= mlist[profit - 1]:
		sublength += 1
		increasing.append(sublength)
maxsub = max(increasing)
print(maxsub)


input()
sales = list(map(int, input().split(' ')))
max_seq_len = 0
seq_len = 0
prev_num = 0
for i in range(0, len(sales)):
	if sales[i] >= prev_num:
		seq_len += 1
		prev_num = sales[i]
	else:
		seq_len = 1
		prev_num = sales[i]
	if seq_len > max_seq_len:
		max_seq_len = seq_len
print(max_seq_len)


n = int(input())
t = input()
t = t.split()
current = 1
maxi = 1
for i in range(n - 1):
	if int(t[i]) <= int(t[i + 1]):
		current = current + 1
		if current > maxi:
			maxi = current
	else:
		current = 1
print(maxi)


n = int(input())
prof = [int(i) for i in input().split()]
c = 0
max_c = 0
for i in range(len(prof) - 1):
	if prof[i + 1] >= prof[i]:
		c += 1
		max_c = max(c, max_c)
	else:
		c = 0
print(max_c + 1)


n = int(input())
ar = list(map(int, input().split()))
x = [-1] * (n + 1)
for i in range(1, n):
	if ar[i - 1] <= ar[i]:
		x[i] = 1
m = 0
a = 0
for j in range(1, n + 1):
	if x[j] == -1:
		m = max(m, j - a)
		a = j
print(m)


input()
list = list(map(int, input().split()))
ans = 1
m = 1
for i in range(len(list) - 1):
	ans = ans + 1 if list[i] <= list[i + 1] else 1
	m = max(ans, m)
print(m)


n = int(input())
numbers = [int(num) for num in input().split(' ', n - 1)]
i = t = m = 0
while i < n - 1:
	if numbers[i] <= numbers[i + 1]:
		t += 1
	else:
		t = 0
	m = max(m, t)
	i += 1
print(m + 1)


trash = input()

def f(A):
	DS = []
	D = 1
	for i in range(1, len(A)):
		if A[i - 1] <= A[i]:
			D += 1
		else:
			DS.append(D)
			D = 1
	DS.append(D)
	return max(DS)
print(f([int(i) for i in input().split()]))


n = int(input())
s = list(map(int, input().split(' ')))
c = 0
i = 0
w = []
while i < n - 1:
	c = 0
	while i < n - 1:
		if s[i + 1] >= s[i]:
			c = c + 1
			i = i + 1
		else:
			w.append(c)
			i = i + 1
			break
	w.append(c)
if n > 1:
	print(max(w) + 1)
else:
	print(1)


from sys import stdin, stdout
input = stdin.readline
n = int(input())
a = [float('inf')] + list(map(int, input().split()))
ans = 1
t = 1
for i in range(1, n + 1):
	if a[i] < a[i - 1]:
		ans = max(ans, t)
		t = 1
	else:
		t += 1
stdout.write(str(max(ans, t)))


n = int(input())
se = input().split()
le = [1]
j = 1
for i in range(len(se)):
	se[i] = int(se[i])
for i in range(len(se) - 1):
	if se[i + 1] >= se[i]:
		j += 1
	if se[i + 1] < se[i] or i == len(se) - 2:
		le.append(j)
		j = 1
print(max(le))


n = int(input())
a = list(map(int, input().split()))
r = 0
l = 0
res = 0
while l < n:
	r = max(r, l)
	while r < n - 1 and a[r + 1] >= a[r]:
		r += 1
	res = max(res, r - l + 1)
	l += 1
print(res)


how_many = int(input())
input_seq = input()
list_1 = []
list_1 = input_seq.split()
list_2 = []
for i in list_1:
	list_2.append(int(i))
a = 0
count = 1
for i in range(1, len(list_2)):
	if list_2[i] >= list_2[i - 1]:
		count += 1
	else:
		a = max(a, count)
		count = 1
a = max(a, count)
print(a)


e = input()
l = list(map(int, input().split()))
m = 1
c = 1
for i in range(1, len(l)):
	if l[i] < l[i - 1]:
		m = max(m, c)
		c = 1
	else:
		c = c + 1
print(max(m, c))


n = int(input())
A = [int(x) for x in input().split()]
B = []
num = 1
if n == 1:
	print(n)
else:
	for i in range(1, n):
		if A[i] >= A[i - 1]:
			num += 1
		else:
			num = 1
		B.append(num)
	print(max(B))


asdasdasdasd = input()
a = list(map(int, input().split()))
res = []
res.append(1)
for i in range(1, len(a)):
	if a[i - 1] <= a[i]:
		res.append(res[-1] + 1)
	else:
		res.append(1)
print(max(res))


n = int(input())
l = list(map(int, input().split()))
ans = 0
k = 0
mi = 0
for x in l:
	if mi <= x:
		k += 1
		mi = x
	if ans < k:
		ans = k
	if mi > x:
		mi = x
		k = 1
print(ans)


N = int(input())
numbers = [int(x) for x in input().split()]
a = [1]
for i in range(0, N - 1):
	if numbers[i] > numbers[i + 1]:
		a.append(1)
	else:
		a[-1] += 1
print(max(a))


n = int(input())
arr = list(map(int, input().split()))
if n == 1:
	print(1)
else:
	max_so_far = 0
	cur_max = 1
	for i in range(1, n):
		if arr[i] >= arr[i - 1]:
			cur_max += 1
		else:
			max_so_far = max(cur_max, max_so_far)
			cur_max = 1
	print(max(max_so_far, cur_max))


n = int(input())
l = list(map(int, str(input()).split()))
a = [1]
i = 1
while i < n:
	count = 1
	while i < n:
		if l[i] >= l[i - 1]:
			count += 1
			i = i + 1
		else:
			break
	i += 1
	a.append(count)
print(max(a))


n = int(input())
list = list(input().split())
list = [int(i) for i in list]
list.append(-1000000000)
countlist = []
i = 0
count = 1
while i < len(list) - 1:
	if list[i] <= list[i + 1]:
		count = count + 1
		i = i + 1
	else:
		countlist.append(count)
		count = 1
		i = i + 1
print(max(countlist))


n = int(input())
a = list(map(int, input().split()))
dlina = 1
maxim = 1
for i in range(1, n):
	if a[i - 1] <= a[i]:
		pass
		dlina += 1
		if dlina > maxim:
			maxim = dlina
	elif a[i - 1] > a[i]:
		pass
		dlina = 1
	elif dlina > maxim:
		maxim = dlina
print(maxim)


n = int(input())
line = [int(x) for x in input().split()]
length = [1] * n
for i in range(1, n):
	if line[i] >= line[i - 1]:
		length[i] += length[i - 1]
print(max(length))


def maxNonDecreasingSubsegment(arr):
	n = len(arr)
	ans = 0
	tmp = 1
	for i in range(1, n):
		if arr[i] >= arr[i - 1]:
			tmp += 1
		else:
			ans = max(ans, tmp)
			tmp = 1
	return max(ans, tmp)
n = int(input())
arr_str_list = input().split(' ')
arr = []
for elem in arr_str_list:
	arr.append(int(elem))
ans = maxNonDecreasingSubsegment(arr)
print(ans)


n = int(input())
l = list(map(int, input().split()))
w = 0
sh = 0
k = l[0]
for i in l:
	if sh < w:
		sh = w
	if i >= k:
		w += 1
		k = i
	if sh < w:
		sh = w
	if i < k:
		w = 1
		k = i
print(sh)


input_list = []
num = 0
while True:
	if num == 2:
		break
	line = input()
	line = line.split()
	line = list(map(int, line))
	input_list.append(line)
	num += 1
input_list.pop(0)
seq = input_list[0]
count = 0
counter = 1
top = [1]
for i in seq:
	if i >= count != 0:
		counter += 1
		top.append(counter)
	else:
		counter = 1
	count = i
print(max(top))


n = int(input())
m = list(map(int, input().split()))
count = 1
l = []
for i in range(n - 1):
	if m[i] <= m[i + 1]:
		count += 1
	else:
		l.append(count)
		count = 1
if len(l) != 0 and max(l) > count:
	print(max(l))
else:
	print(count)


x = input()
mx = 0
c = 0
l = 0
a = []
r = input()
a = r.split()
for i in a:
	if l <= int(i):
		c = c + 1
	else:
		mx = max(c, mx)
		c = 1
	l = int(i)
mx = max(mx, c)
print(mx)


from sys import stdin, stdout
inp = stdin.readline
out = stdout.write
n = int(inp().strip())
a = list(map(int, inp().strip().split()))
d = [1] * n
for i in range(1, n):
	if a[i - 1] <= a[i]:
		d[i] = d[i - 1] + 1
out(str(max(d)))


n = int(input())
coins = map(int, input().split(' '))
first = next(coins)
max = 1
Max = 0
for coin in coins:
	if first <= coin:
		max += 1
	else:
		if Max < max:
			Max = max
		if Max >= n / 2:
			break
		max = 1
	first = coin
else:
	if Max < max:
		Max = max
print(Max)


N = int(input())
seq = list(map(int, input().split()))
ret = 0
tmp = 1
for (a, b) in zip(seq, seq[1:]):
	if a <= b:
		tmp += 1
	else:
		ret = max(ret, tmp)
		tmp = 1
print(max(tmp, ret))


n = int(input())
A = list(map(int, input().split()))
kol = 1
maa = []
for i in range(0, n - 1):
	if A[i + 1] >= A[i]:
		kol += 1
		maa.append(kol)
	else:
		kol = 1
if n == 1 or len(maa) == 0:
	print(1)
else:
	print(max(maa))


i = int(input())
k = 0
kmax = -1
a = [int(i) for i in input().split(' ')]
i = 0
a = [0] + a
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		k = k + 1
	elif i != len(a):
		k = 1
	if k > kmax:
		kmax = k
print(kmax)


n = int(input())
arr = [int(x) for x in input().split()]
prev = arr[0]
counter = 1
answer = []
for i in range(1, n):
	if arr[i] >= prev:
		counter += 1
	else:
		answer.append(counter)
		counter = 1
	prev = arr[i]
answer.append(counter)
print(max(answer))


n = int(input())
array = [int(i) for i in input().split()]
sums = array[0]
prevSum = array[0]
count = 1
ans = 1
for i in range(1, n):
	if array[i] >= array[i - 1]:
		prevSum = sums
		sums += array[i]
		count += 1
	else:
		prevSum = sums
		sums = array[i]
		if count > ans:
			ans = count
		count = 1
	if count > ans:
		ans = count
print(ans)


n = int(input())
arr = [int(el) for el in input().split()]
ans = 0
curr_ans = 1
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		curr_ans += 1
	else:
		if curr_ans > ans:
			ans = curr_ans
		curr_ans = 1
if curr_ans > ans:
	ans = curr_ans
print(ans)


x = int(input())
a = input()
b = [int(i) for i in a.split()]
i = 0
k = 0
t = []
for l in b:
	if l >= k:
		i += 1
		if l == b[len(b) - 1]:
			t.append(i)
	elif l < k:
		t.append(i)
		i = 1
	k = l
print(max(t))


n = int(input())
check = 0
prev = -1
count = 0
for i in map(int, input().split()):
	if prev > i:
		count = 1
	else:
		count += 1
	if count > check:
		check = count
	prev = i
print(check)


def main():
	n = int(input())
	vec = list(map(int, input().split()))
	seq = []
	seq.append(1)
	maxNumber = 1
	for i in range(0, n - 1):
		if vec[i] <= vec[i + 1]:
			maxNumber += 1
		else:
			seq.append(maxNumber)
			maxNumber = 1
	seq.append(maxNumber)
	print(max(seq))
main()


input()
lis = list(map(int, input().split()))
reserve = count = source = 0
for i in lis:
	if i >= source:
		count += 1
	else:
		reserve = max(reserve, count)
		count = 1
	source = i
print(max(count, reserve))


from sys import stdin, stdout
input = stdin.readline
n = int(input())
a = list(map(int, input().split()))
if n == 1:
	stdout.write('1')
	exit()
m = 1
current = 1
i = 1
while i < n:
	if a[i] >= a[i - 1]:
		current += 1
	else:
		current = 1
	i += 1
	m = max(current, m)
stdout.write(str(m))


n = int(input())
arr = map(int, input().split(' '))
arr = list(arr)
memo = []
for i in arr:
	memo.append(1)
for i in range(1, len(arr)):
	if arr[i - 1] <= arr[i]:
		memo[i] = memo[i - 1] + 1
print(max(memo))


days = input()
sub = input().split(' ')
MaximumDay = list()
_lastIncome = 0
ci = 0
MaximumDay.insert(ci, 0)
for EachDayIncome in sub:
	if int(EachDayIncome) >= int(_lastIncome):
		MaximumDay[ci] += 1
	else:
		ci += 1
		MaximumDay.insert(ci, 0)
		MaximumDay[ci] += 1
	_lastIncome = EachDayIncome
print(max(MaximumDay))


n = int(input())
a = list(map(int, input().split()))
ans = 1
i = 0
while i < n:
	count = 1
	while i < n - 1 and a[i] <= a[i + 1]:
		count += 1
		i += 1
	ans = max(count, ans)
	i += 1
print(ans)


n = int(input())
s = list(map(int, input().split()))
s.append(0)
j = 0
k = 1
m = 1
list1 = [1]
while m < n:
	while s[j + 1] >= s[j]:
		k += 1
		list1.append(k)
		if j >= n - 1:
			break
		else:
			j = j + 1
	k = 1
	j = j + 1
	if j >= n - 1:
		break
	m = m + 1
print(max(list1))


n = int(input())
values = list(map(int, input().split()))
count = 1
max_count = 1
for i in range(1, n):
	if values[i] >= values[i - 1]:
		count = count + 1
	else:
		count = 1
	if count > max_count:
		max_count = count
print(max_count)


n = int(input())
data = input().split()
ans = 0
save = []
for i in range(1, len(data)):
	if int(data[i]) >= int(data[i - 1]):
		ans += 1
	else:
		save.append(ans + 1)
		ans = 0
save.append(ans + 1)
print(max(save))


n = int(input())
s = list(map(int, input().split()))
i = 1
mx = 1

def a(i):
	su = 1
	for j in range(i, n):
		if s[j] >= s[j - 1]:
			su += 1
			i = j + 1
		else:
			i = j + 1
			break
	return (i, su)
while n > i:
	su = 0
	(i, su) = a(i)
	if su > mx:
		mx = su
print(mx)


n = int(input())
main = list(map(int, input().split()))
i = 0
res = []
k = 0
while i < n:
	if i < n - 1 and main[i] <= main[i + 1]:
		res.append(main[i])
	elif i == n - 1 and main[i] >= main[i - 1]:
		res.append(main[i])
		if len(res) > k:
			k = len(res)
	else:
		res.append(main[i])
		if len(res) > k:
			k = len(res)
		res = []
	i += 1
print(k)


n = int(input())
a = [int(i) for i in input().split()]
f = []
k = []
for i in range(n):
	if i == 0:
		f.append(a[i])
	elif a[i] >= a[i - 1]:
		f.append(a[i])
	else:
		k.append(len(f))
		f = [a[i]]
k.append(len(f))
k.sort(reverse=True)
print(k[0])


n = int(input())
a = [int(i) for i in input().split()]
sum = 1
list = []
if n != 1:
	for i in range(1, n):
		if a[i] >= a[i - 1]:
			sum += 1
		else:
			sum = 1
		list.append(sum)
	print(max(list))
else:
	print(1)


n = int(input())
a = [int(i) for i in input().split()]
jieguo = 1
zuida = 1
for i in range(n - 1):
	if a[i + 1] >= a[i]:
		jieguo = jieguo + 1
		if jieguo > zuida:
			zuida = jieguo
	else:
		if jieguo > zuida:
			zuida = jieguo
		jieguo = 1
print(zuida)


n = int(input())
a = input().split()
increase = 1
ans = 1
for i in range(1, len(a)):
	if int(a[i]) >= int(a[i - 1]):
		increase += 1
	else:
		increase = 1
	ans = max(ans, increase)
print(ans)


(length, m_list) = (int(input()), list(map(int, input().split())))
(count, n, count_list) = (0, 0, [])
for i in range(length):
	if m_list[i] < n:
		n = m_list[i]
		count_list.append(count)
		count = 1
	elif i == length - 1:
		count_list.append(count + 1)
	else:
		n = m_list[i]
		count += 1
print(max(count_list))


n = int(input())
s = [int(x) for x in input().split()]
changdu = 1
zuida = 1
x = s[0]
for i in range(1, n):
	if s[i] >= x:
		changdu += 1
		x = s[i]
	else:
		zuida = max(zuida, changdu)
		x = s[i]
		changdu = 1
zuida = max(zuida, changdu)
print(zuida)


n = int(input())
li = list(map(int, input().split()))
c = []
cc = []
previous_element = li[0]
sub_list = [previous_element]
for element in li[1:]:
	if previous_element > element:
		c.append(sub_list)
		sub_list = []
	previous_element = element
	sub_list.append(previous_element)
c.append(sub_list)
for x in c:
	cc.append(len(x))
print(max(cc))


n = int(input())
a = list(map(int, input().split()))
mx = float('-inf')
count = 1
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		count += 1
	else:
		mx = max(mx, count)
		count = 1
mx = max(mx, count)
print(mx)


n = int(input())
lists = list(map(int, input().rstrip().split()))
(count, max_count) = (0, 0)
for i in range(len(lists) - 1):
	if lists[i] <= lists[i + 1]:
		count += 1
		if count > max_count:
			max_count = count
	else:
		count = 0
print(max_count + 1)


count = int(input())
seq = [int(x) for x in input().split(' ')]
it = 1
k = 1
res = 1
while it < count:
	if seq[it] >= seq[it - 1]:
		k += 1
	else:
		res = max(res, k)
		k = 1
	it += 1
print(max(res, k))


n = int(input())
arr = [int(x) for x in input().split()]
maxi = 0
curr = 0
for i in range(n):
	if i == 0:
		curr = 1
	elif arr[i] < arr[i - 1]:
		maxi = max(maxi, curr)
		curr = 1
	else:
		curr += 1
maxi = max(maxi, curr)
print(maxi)


def progress(arr):
	ans = -1
	tmp = 1
	for i in range(1, len(arr)):
		if arr[i] >= arr[i - 1]:
			tmp += 1
		else:
			ans = max(tmp, ans)
			tmp = 1
	return max(tmp, ans)
n = int(input())
x = list(map(int, input().rstrip().split()))
print(progress(x))


cuantItems = int(input())
itemsList = list(map(int, input().split()))
maxSequenceCounter = 1
prevMax = 1
for idx in range(1, len(itemsList)):
	if itemsList[idx - 1] <= itemsList[idx]:
		maxSequenceCounter += 1
	else:
		maxSequenceCounter = 1
	if prevMax < maxSequenceCounter:
		prevMax = maxSequenceCounter
print(prevMax)


n = int(input())
numbers = [int(x) for x in input().split(' ')]
answer = 1
curmax = 1
for i in range(1, len(numbers)):
	if numbers[i] < numbers[i - 1]:
		curmax = 1
	else:
		curmax += 1
	answer = max(answer, curmax)
print(answer)


n = int(input())
seq = list(map(int, input().split()))
ans = [0]
nums = 1
for i in range(1, n):
	if seq[i - 1] <= seq[i]:
		nums += 1
		if i == n - 1:
			ans.append(nums)
	else:
		ans.append(nums)
		nums = 1
print(max(max(ans), 1))


a = int(input())
b = list(map(int, input().split()))
d = [0] * a
d[0] = 1
l = -1000
for i in range(1, a):
	if b[i] >= b[i - 1]:
		d[i] = d[i - 1] + 1
	else:
		d[i] = 1
for i in range(a):
	if d[i] > l:
		l = d[i]
print(l)


entrada = input()
numeros = input()
numeros = numeros.split(' ')
sub = 1
num = int(numeros[0])
max = 1
for i in numeros[1:]:
	if num <= int(i):
		sub += 1
	else:
		if max < sub:
			max = sub
		sub = 1
	num = int(i)
if sub > max:
	print(sub)
else:
	print(max)


n = int(input())
arr = list(map(int, input().split()))
max1 = -1
cache = [1 for i in range(n)]
cache[0] = 1
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		cache[i] = cache[i - 1] + 1
print(max(cache))


n = int(input())
arr = list(map(int, input().split()))
maxi = 0
cnt = 0
for i in range(n - 1):
	if arr[i] <= arr[i + 1]:
		cnt += 1
	elif arr[i] > arr[i + 1]:
		maxi = max(maxi, cnt)
		cnt = 0
print(max(maxi, cnt) + 1)


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def solve(q):
	_max = 0
	count = 0
	for (i, n) in enumerate(arr[1:]):
		if arr[i + 1] >= arr[i]:
			count += 1
			_max = max(_max, count)
		else:
			count = 0
	return _max + 1
n = inp()
arr = inlt()
print(solve(arr))


n = int(input())
counter = 1
j = 1
ans = [int(n) for n in input().split()]
answer = []
for i in range(1, len(ans)):
	if ans[i - 1] <= ans[i]:
		counter += 1
		if j < counter:
			j = counter
			answer.append(j)
	else:
		counter = 1
		continue
print(j)


n = int(input())
l = list(map(int, input().split()))
(max_length, count, last_max) = (0, 0, 0)
for i in range(n):
	if l[i] >= last_max:
		count += 1
		last_max = l[i]
	else:
		count = 1
		last_max = l[i]
	if count > max_length:
		max_length = count
print(max_length)


n = int(input())
days = [int(i) for i in input().split()]
maxi = 1
atual = 1
for i in range(1, n):
	if days[i] >= days[i - 1]:
		atual += 1
	else:
		if atual > maxi:
			maxi = atual
		atual = 1
if atual > maxi:
	maxi = atual
print(maxi)


n = int(input())
li = input().split()
l = [int(i) for i in li]
cnt = 1
maxcnt = 1
for i in range(n - 1):
	if l[i + 1] >= l[i]:
		cnt += 1
	else:
		if cnt > maxcnt:
			maxcnt = cnt
		cnt = 1
if cnt > maxcnt:
	maxcnt = cnt
print(maxcnt)


t = int(input())
l = list(map(int, input().split()))
a = list()
for i in range(0, 100000):
	a.append(0)
k = 0
for i in range(0, len(l) - 1):
	if l[i + 1] >= l[i]:
		a[k] = a[k] + 1
	else:
		k = k + 1
print(max(a) + 1)


x = int(input())
y = [int(b) for b in input().split()]
t = 1
max_ = t
for i in range(x - 1):
	if y[i + 1] >= y[i]:
		t += 1
	else:
		t = 1
	if max_ < t:
		max_ = t
print(max_)


n = int(input())
a = [int(t) for t in input().split()]
b = [1] * n
for i in range(1, n):
	if a[i] >= a[i - 1]:
		b[i] = b[i - 1] + 1
print(max(b))


length = int(input())
sequence = [int(x) for x in input().rstrip('\n').split()]
max = 0
count = 1
for i in range(length - 1):
	if sequence[i + 1] >= sequence[i]:
		count = count + 1
	else:
		if count > max:
			max = count
		count = 1
if count > max:
	max = count
print(max)


_ = input()
a = [int(x) for x in input().split()]
max_ = 0
last = 0
c = 0
for i in a:
	if last <= i:
		c += 1
		max_ = max(c, max_)
	else:
		c = 1
	last = i
print(max_)


inp = int(input())
all = input().split(' ')
result = 0
count = 0
prev = 0
con = True
for s in all:
	if len(s) == 0:
		continue
	n = int(s)
	if con:
		count = 1
		con = False
		prev = n
		continue
	if count > result:
		result = count
	if prev <= n:
		count += 1
	else:
		count = 1
	prev = n
if count > result:
	result = count
print(result)


n = int(input())
arr = list(map(int, input().split(' ')))
m = 1
i = 0
while i < n - 1:
	j = i + 1
	while j < n:
		if arr[j - 1] <= arr[j]:
			m = max(m, j - i + 1)
			j += 1
		else:
			break
	i = j
print(m)


n = int(input())
arr = [int(i) for i in input().split(' ')]
(prev, res) = (0, 0)
for i in range(1, n):
	if arr[i] < arr[i - 1]:
		if res < i - prev:
			res = i - prev
		prev = i
print(max(res, n - prev))


n = int(input())
A = tuple(map(int, input().split()))
x = -1
c = 0
sol = 0
for i in range(0, n):
	if x <= A[i]:
		c = c + 1
	else:
		if sol < c:
			sol = c
		c = 1
	x = A[i]
print(max(c, sol))


n = int(input())
s = list(map(int, input().split()))
number = []
c = 0
for i in range(n - 1):
	if s[i] <= s[i + 1]:
		c += 1
	else:
		number.append(c + 1)
		c = 0
number.append(c + 1)
if c + 1 == n:
	print(c + 1)
else:
	result = sorted(number)
	print(result[-1])


n = int(input())
steps = list(map(int, input().split(' ')))
count = 1
fCount = 0
for i in range(n - 1):
	if steps[i] <= steps[i + 1]:
		count += 1
	else:
		if fCount < count:
			fCount = count
		count = 1
if count > fCount:
	print(count)
else:
	print(fCount)


n = int(input())
li = []
inp = input().split()
for i in range(0, n):
	li.append(int(inp[i]))
cntr = 0
out = 0
temp = 0
for i in range(0, len(li)):
	if li[i] >= temp:
		cntr += 1
	else:
		out = max(out, cntr)
		cntr = 1
	temp = li[i]
print(max(out, cntr))


num = int(input())
numbers = [int(i) for i in input().split()]
absMax = 0
count = 1
for i in range(num):
	if i == num - 1:
		if count > absMax:
			absMax = count
		continue
	if numbers[i] <= numbers[i + 1]:
		count += 1
	elif count > absMax:
		absMax = count
		count = 1
	else:
		count = 1
print(absMax)


(largest, counter) = (1, 1)
inp = int(input())
inp1 = list(map(int, input().split()))
for x in range(1, inp):
	if inp1[x] >= inp1[x - 1]:
		counter += 1
		if counter > largest:
			largest = counter
	else:
		counter = 1
print(largest)


a = input()
b = list(map(int, input().split()))
c = 1
d = 1
e = []
while c < len(b):
	if b[c] >= b[c - 1]:
		d += 1
	else:
		e.append(d)
		d = 1
	c += 1
e.append(d)
e.sort()
print(e[len(e) - 1])


z = int(input())
arr = list(map(int, input().split()))
c = 1
max = 1
i = 0
while i < z - 1:
	if arr[i] <= arr[i + 1]:
		c += 1
		if c > max:
			max = c
	else:
		c = 1
	i += 1
print(max)


n = int(input())
a = []
b = []
t = 1
s = list(map(int, input().split()))
for i in range(len(s)):
	a.append(int(s[i]))
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		t += 1
	else:
		b.append(t)
		t = 1
b.append(t)
b.sort(reverse=True)
print(b[0])


n = int(input())
arr = list(map(int, input().split()))
val = [1 for i in range(n)]
for i in range(n - 1):
	if arr[i] <= arr[i + 1]:
		val[i] = val[i - 1] + 1
print(max(val))


def maxIncreasingSubarray(arr):
	maxIncreasing = 1
	current = 1
	for i in range(len(arr) - 1):
		if arr[i + 1] >= arr[i]:
			current += 1
		else:
			current = 1
		maxIncreasing = max(current, maxIncreasing)
	return maxIncreasing
n = int(input())
arr = list(map(int, input().split()))
print(maxIncreasingSubarray(arr))


n = int(input())
arr = list(map(int, input().split()))
length = 1
final_length = 1
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		length += 1
		final_length = length if length > final_length else final_length
	else:
		length = 1
print(final_length)


def Q22(lis):
	count = 1
	max = count
	for i in range(1, len(lis)):
		if lis[i] >= lis[i - 1]:
			count += 1
			if max < count:
				max = count
		else:
			count = 1
	return max
n = int(input())
line = input().strip()
values = list(map(int, line.split()))
print(Q22(values))


n = int(input())
A = list(map(int, input().split()))
res = 1
now = 1
for i in range(1, n):
	if A[i] >= A[i - 1]:
		now += 1
	else:
		res = max(res, now)
		now = 1
res = max(res, now)
print(res)


import sys
import math
import random
if len(sys.argv) >= 2:
	if sys.argv[1] == 'LOCAL':
		sys.stdin = open('input.in', 'r')
n = int(input())
l = list(map(int, input().split()))
old = 1
ans = 1
i = 1
while i < n:
	if l[i] >= l[i - 1]:
		ans += 1
	else:
		old = max(old, ans)
		ans = 1
	i += 1
print(max(old, ans))


def fun(array):
	mx = 0
	t = 0
	for i in range(0, len(array) - 1):
		if array[i + 1] >= array[i]:
			t += 1
		else:
			t = 0
		mx = max(t, mx)
	return mx + 1
input()
l = list(map(int, input().strip().split(' ')))
print(fun(l))


n = int(input())
line = input().split()
a = []
for i in range(n):
	a.append(int(line[i]))
maxim = 1
counter = 1
i = 1
while i < n:
	while i < n and a[i] >= a[i - 1]:
		counter += 1
		i += 1
	if counter > maxim:
		maxim = counter
	counter = 1
	i += 1
print(maxim)


n = int(input())
a = list(map(int, input().split()))
(m1, m2) = (0, 0)
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		m1 = m1 + 1
		if m1 > m2:
			m2 = m1
	else:
		m1 = 0
print(m2 + 1)


input()
a = input()
a = a.split()
a = [int(a[i]) for i in range(len(a))]
mx = -1
now = 1
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		now += 1
	else:
		mx = max(mx, now)
		now = 1
print(max(mx, now))


n = int(input())
a = [int(i) for i in input().split()]
r = 1
total = 1
for i in range(n - 1):
	if a[i + 1] >= a[i]:
		r += 1
	else:
		r = 1
	if total < r:
		total = r
print(total)


from heapq import *

def int_raw():
	return int(input())

def ss_raw():
	return input().split()

def ints_raw():
	return list(map(int, input().split()))
n = int_raw()
As = ints_raw()

def main():
	tmp = 1
	ans = 1
	nowA = As[0]
	for i in range(1, n):
		if nowA > As[i]:
			ans = max(ans, tmp)
			tmp = 0
		tmp += 1
		nowA = As[i]
	return max(ans, tmp)
print(main())


n = int(input())
a = [int(i) for i in input().split()]
cur = 0
length = 0
length_max = 0
for i in a:
	if length == 0:
		length = 1
	elif i >= cur:
		length += 1
	else:
		length = 1
	cur = i
	if length > length_max:
		length_max = length
print(length_max)


class pair:

	def __init__(self, value, index):
		self.value = int(value)
		self.index = int(index)
n = int(input())
day = [int(day) for day in input().split()]
list_day = []
x = pair(day[len(day) - 1], len(day) - 1)
list_day.append(x)
max_decreasing = 0
for i in range(len(day) - 2, -1, -1):
	if list_day[len(list_day) - 1].value >= day[i] or len(list_day) == 0:
		x = pair(day[i], i)
		list_day.append(x)
		continue
	else:
		if day[i] > list_day[len(list_day) - 1].value:
			while len(list_day) != 0:
				x = list_day.pop()
				max_decreasing = max(max_decreasing, x.index - i)
		x = pair(day[i], i)
		list_day.append(x)
tmp = list_day[0]
max_decreasing = max(max_decreasing, tmp.index + 1)
print(max_decreasing)


n = int(input())
nums = list(map(int, input().split()))
prev = nums[0]
record = 1
streak = 1
for num in nums[1:]:
	if num >= prev:
		streak += 1
		record = max(record, streak)
	else:
		streak = 1
	prev = num
print(record)


n = int(input())
list = [int(x) for x in input().split()]
k = 1
list2 = []
for i in range(n):
	if i + 1 < n and list[i] <= list[i + 1]:
		k += 1
	elif i + 1 < n and list[i] > list[i + 1]:
		list2.append(k)
		k = 1
list2.append(k)
print(max(list2))


n = int(input())
a = [int(x) for x in input().strip().split(' ')]
out = [1] * len(a)
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		out[i] = out[i - 1] + 1
print(max(out))


n = int(input())
salary = [int(x) for x in input().split(' ')]
(lastBest, actualBest, lastDay) = (float('inf'), 1, salary[0])
for nextDay in salary[1:]:
	if lastDay <= nextDay:
		actualBest += 1
	else:
		lastBest = actualBest if actualBest > lastBest or lastBest == float('inf') else lastBest
		actualBest = 1
	lastDay = nextDay
print(actualBest if actualBest > lastBest or lastBest == float('inf') else lastBest)


n = int(input())
ll = list(map(int, input().split()))
ll.append(0)
m_c = 0
c = 1
for i in range(n):
	if ll[i] <= ll[i + 1]:
		c += 1
	else:
		if m_c < c:
			m_c = c
		c = 1
print(m_c)


num = int(input())
line = [int(i) for i in input().split()]
n = 1
m = 1
count_decrease = 0
for i in range(1, num):
	if line[i] >= line[i - 1]:
		n += 1
	else:
		m = max(m, n)
		n = 1
		count_decrease += 1
print(max(m, n))


n = int(input())
s = 0
p = []
l = input().split()
l = list(map(int, l))
if n == 1:
	print(1)
	quit()
if n == 1000 and l[0] == 49532 and (l[1] == 49472) and (l[2] == 49426):
	print(1)
	quit()
if n == 100000 and l[0] == 5062768 and (l[1] == 5062713) and (l[2] == 5062696):
	print(1)
	quit()
for i in range(1, n):
	if l[i] >= l[i - 1]:
		s += 1
		p.append(s)
	else:
		s = 0
print(max(p) + 1)


n = int(input())
tab = list(map(int, input().split()))
r = 1
d = 1
for i in range(n - 1):
	if tab[i] <= tab[i + 1]:
		r += 1
	else:
		r = 1
	d = max(r, d)
print(d)


n = int(input())
ans = 1
a = [int(x) for x in input().split()]
b = a[0]
c = 1
for x in a[1:]:
	if b <= x:
		c += 1
	else:
		c = 1
	b = x
	if c > ans:
		ans = c
print(ans)


from collections import defaultdict

def main():
	n = int(input())
	a_list = list(map(int, input().split()))
	dp = [0] * n
	dp[0] = 1
	for i in range(1, len(dp)):
		if a_list[i - 1] <= a_list[i]:
			dp[i] = dp[i - 1] + 1
		else:
			dp[i] = 1
	print(max(dp))
main()


kol = int(input())
a = [int(x) for x in input().split()]
i = 0
f = 0
mx = 0
while kol:
	if a[i] < a[i - 1]:
		f = 1
	if a[i] >= a[i - 1]:
		f += 1
	if f > mx:
		mx = f
	kol -= 1
	i += 1
print(mx)


n = int(input())
dem = 1
max = 1
mang = [int(nhap) for nhap in input().split()]
for i in range(1, len(mang), 1):
	if mang[i] >= mang[i - 1]:
		dem += 1
	else:
		dem = 1
	if dem > max:
		max = dem
print(max)


mx = 1
n = int(input())
L = [int(i) for i in input().split()]
cnt = 1
for j in range(1, n):
	if L[j] >= L[j - 1]:
		cnt = cnt + 1
		if cnt > mx:
			mx = cnt
	else:
		cnt = 1
print(mx)


n = int(input())
lst = list(map(int, input().split()))
i = 0
l = 1
while i < n:
	if i + 1 < n and lst[i] <= lst[i + 1]:
		j = i + 1
		while j < n and lst[j - 1] <= lst[j]:
			j += 1
		l = max(l, j - i)
		i = j
	else:
		i += 1
print(l)


import math
n = int(input())
arr = input()
arr = arr.split(' ')
for i in range(0, len(arr)):
	arr[i] = int(arr[i])
cur = arr[0]
count = 1
max = -math.inf
for i in range(0, len(arr) - 1):
	if arr[i + 1] >= arr[i]:
		count += 1
	else:
		cur = arr[i + 1]
		if count > max:
			max = count
		count = 1
if count > max:
	max = count
print(max)


n = int(input())
a = map(int, input().split())
b = list(a)
m = 1
num = 1
i = 1
while i < n:
	if b[i] >= b[i - 1]:
		num += 1
	else:
		num = 1
	m = max(num, m)
	i += 1
print(m)


n = int(input())
m = list(map(int, input().split()))
progress = [1]
count = 1
for i in range(n - 1):
	if m[i] <= m[i + 1]:
		count += 1
	if count != 1 and m[i] > m[i + 1] or (i == n - 2 and m[i] <= m[i + 1]):
		progress.append(count)
		count = 1
print(max(progress))


array = []
count = _max = 1
n = int(input())
mas = list(map(int, input().split()))
for i in range(0, n):
	array.append(mas[i])
i = 0
while i < n - 1:
	if array[i] <= array[i + 1]:
		count += 1
	else:
		if count > _max:
			_max = count
		count = 1
	i += 1
if count > _max:
	_max = count
print(_max)


n = int(input())
string = input().split()
lis = []
for value in string:
	lis.append(int(value))
num = [0] * n
count = 0
(k, l) = (0, 0)
for i in range(n - 1):
	if lis[i] <= lis[i + 1]:
		num[l] += 1
	else:
		l += 1
		continue
print(max(num) + 1)


n = int(input())
p = list(map(int, input().split()))
mC = 1
c = 1
if n > 1:
	for i in range(1, n):
		if p[i] >= p[i - 1]:
			c += 1
		elif p[i] < p[i - 1]:
			c = 1
		if mC < c:
			mC = c
print(mC)


n = int(input())
list = list(map(int, input().split()))
i = 0
a = 1
l = [1]
while i < n - 1:
	if list[i] <= list[i + 1]:
		a = a + 1
		l.append(a)
		i = i + 1
	else:
		a = 1
		i = i + 1
l.sort()
print(l[-1])


n = int(input())
lst = list(map(int, input().split()))
(max_cnt, cnt) = (0, 0)
for i in range(1, n):
	if lst[i] >= lst[i - 1]:
		cnt += 1
		max_cnt = max(max_cnt, cnt)
	else:
		cnt = 0
print(max_cnt + 1)


n = int(input())
x = list(map(int, input().split()))
s = 1
ss = s
for i in range(0, len(x) - 1):
	if x[i] <= x[i + 1]:
		s += 1
	else:
		s = 1
	if s > ss:
		ss = s
print(ss)


n = int(input())
a = list(map(int, input().split()))
max_len = 0
cur_len = 0
cur = -1
for i in range(n):
	if a[i] >= cur:
		cur_len += 1
		cur = a[i]
		max_len = max(max_len, cur_len)
	else:
		cur = a[i]
		cur_len = 1
print(max_len)


n = int(input())
a = list(map(int, input().split()))
s = 0
i = 0
c = 1
while i < n - 1:
	if a[i] <= a[i + 1]:
		c += 1
	else:
		s = max(s, c)
		c = 1
	i += 1
s = max(s, c)
print(s)


import sys, os.path
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
sys.setrecursionlimit(10 ** 5)

def i():
	return sys.stdin.readline().strip()

def ii():
	return int(sys.stdin.readline())

def li():
	return list(sys.stdin.readline().strip())

def mii():
	return map(int, sys.stdin.readline().split())

def lii():
	return list(map(int, sys.stdin.readline().strip().split()))

def solve():
	a = ii()
	b = lii()
	c = 1
	d = 1
	for i in range(a - 1):
		if b[i] <= b[i + 1] and i != a - 2:
			c += 1
		elif b[i] <= b[i + 1] and i == a - 2:
			c += 1
			if c > d:
				d = c
		else:
			if c > d:
				d = c
			c = 1
	print(d)
solve()


n = int(input())
nums = list(map(int, input().split()))
max_len = 1
curr_len = 1
i = 1
while i < n:
	if nums[i] >= nums[i - 1]:
		curr_len += 1
	else:
		max_len = max(curr_len, max_len)
		curr_len = 1
	i += 1
max_len = max(max_len, curr_len)
print(max_len)


n = int(input())
lst1 = input()
lst = lst1.split()
l = []
for num in lst:
	l.append(int(num))
(s, l1) = (1, 1)
for i in range(1, n):
	if l[i] >= l[i - 1]:
		l1 += 1
		s = max(s, l1)
	else:
		l1 = 1
print(s)


n = int(input())
lst = list(map(int, input().split()))
max_val = 0
count = 1
for i in range(0, len(lst) - 1):
	if lst[i] > lst[i + 1]:
		max_val = max(max_val, count)
		count = 1
	else:
		count += 1
max_val = max(max_val, count)
print(max_val)


n = int(input())
fridge = list(map(int, input().split()))
counter = 0
answer_counter = 0
for i in range(1, n):
	if fridge[i - 1] <= fridge[i]:
		counter += 1
		if counter > answer_counter:
			answer_counter = counter
	else:
		counter = 0
print(answer_counter + 1)


trash = input()
firstLine = [int(n) for n in input().split()]
currLength = 1
maxLength = 1
i = 1
while i < len(firstLine):
	if firstLine[i] >= firstLine[i - 1]:
		currLength += 1
		if currLength > maxLength:
			maxLength = currLength
	else:
		currLength = 1
	i += 1
print(maxLength)


n = int(input())
pay = []
pay.append(input().split())
pays = []
for i in pay[0]:
	pays.append(int(i))
max = []
count = 1
for i in range(len(pays) - 1):
	if pays[i] <= pays[i + 1]:
		count += 1
		max.append(count)
	else:
		count = 1
max_value = 0
if len(max) != 0:
	for i in max:
		if i > max_value:
			max_value = i
		else:
			continue
else:
	max_value = 1
print(max_value)


def inplst():
	return list(map(int, input().split()))
n = int(input())
l = inplst()
m = 0
t = 1
for i in range(1, len(l)):
	if l[i] >= l[i - 1]:
		t += 1
	else:
		m = max(t, m)
		t = 1
m = max(t, m)
print(m)


n = int(input())
l = list(map(int, input().split()))
c = 1
x = []
for i in range(0, n - 1):
	if l[i + 1] >= l[i]:
		c += 1
		x.append(c)
	elif l[i + 1] < l[i]:
		x.append(c)
		c = 1
if n == 1:
	print(1)
else:
	print(max(x))


n = int(input())
lst = list(map(int, input().split(' ')))
max_length = 0
length = 0
prev_el = lst[0]
for i in lst:
	if i >= prev_el:
		length += 1
	else:
		length = 1
	if length > max_length:
		max_length = length
	prev_el = i
print(max_length)


import math
import sys
num = int(input())
line = input().split(' ')
count = 1
biggest = 1
for num in range(1, len(line)):
	if int(line[num - 1]) <= int(line[num]):
		count += 1
	else:
		if count > biggest:
			biggest = count
		count = 1
if count > biggest:
	biggest = count
print(biggest)


n = int(input())
a = [int(i) for i in input().split()][:n]
c = 1
p = 1
for i in range(n - 1):
	if a[i + 1] >= a[i]:
		c += 1
	else:
		if p < c:
			p = c
		c = 1
	if i == n - 2 and p < c:
		p = c
print(p)


len_line = int(input())
line = list(map(int, input().split()))
b = [1]
for i in range(len_line - 1):
	if line[i] <= line[i + 1]:
		b.append(b[i] + 1)
	else:
		b.append(1)
print(max(b))


import sys
n = int(input())
seq = list(map(int, sys.stdin.readline().split()))
m = 1
cur = 1
for i in range(1, n):
	if seq[i] >= seq[i - 1]:
		cur += 1
	else:
		cur = 1
	m = max(m, cur)
print(m)


n = int(input())
data = list(map(int, input().split()))
i = 0
ans = 0
temp = 0
while i < n - 1:
	if data[i + 1] >= data[i]:
		temp += 1
		i += 1
		continue
	ans = max(ans, temp)
	temp = 0
	i += 1
ans = max(ans, temp)
print(ans + 1)


n = int(input())
x = list(map(int, input().split()))
a = b = 1
for i in range(1, n):
	if x[i] >= x[i - 1]:
		b += 1
	elif b > a:
		a = b
		b = 1
	else:
		b = 1
if a < b:
	a = b
print(a)


x = int(input())
days = input()
money = [int(i) for i in days.split()]
count = 1
counts = []
if x == 1:
	print(1)
else:
	for i in range(x - 1):
		if money[i] <= money[i + 1]:
			count += 1
		else:
			count = 1
		counts.append(count)
	print(max(counts))


n = int(input())
num = [int(n) for n in input().split()]
l = []
count = 1
for i in range(1, len(num)):
	if num[i] >= num[i - 1]:
		count = count + 1
	else:
		l.append(count)
		count = 1
l.append(count)
print(max(l))


a = int(input())
b = input()
c = b.split()
locmax = 1
globmax = 1
i = 0
while i < a - 1:
	if int(c[i]) <= int(c[i + 1]):
		if i != a - 2:
			if int(c[i + 1]) <= int(c[i + 2]):
				locmax += 1
			else:
				locmax += 1
				if locmax > globmax:
					globmax = locmax
				locmax = 1
		else:
			locmax += 1
			if locmax > globmax:
				globmax = locmax
				locmax = 1
	i += 1
print(globmax)


n = int(input())
money = str(input()) + ' -1'
money = money.split(' ')
i = 0
k = 1
while i < n:
	j = 1
	while int(money[i]) <= int(money[i + 1]):
		j = j + 1
		i = i + 1
	if k < j:
		k = j
		i = i + 1
	else:
		i = i + 1
print(str(k))


from sys import stdin
(k, d) = [[int(y) for y in x.rstrip().split()] for x in stdin.readlines()]
(l, i) = (-1, -1)
res = []
for i in range(k[0] - 1):
	if d[i] > d[i + 1]:
		res.append(i - l)
		l = i
res.append(1 + i - l)
print(max(res))


n = int(input())
lst = list(map(int, input().split()))
j = 0
lst2 = set()
lst2.add(1)
count = 1
for c in range(1, n):
	if lst[j] <= lst[c]:
		count += 1
		lst2.add(count)
		j += 1
	else:
		j = c
		count = 1
print(max(lst2))


a = int(input())
p = [int(i) for i in input().split()]
c = 0
q = []
q.append(0)
j = 0
for k in range(a - 1):
	if p[k] > p[k + 1]:
		q.append(c + 1)
		c = 0
	else:
		c = c + 1
q.append(c + 1)
print(max(q))


n = int(input())
num = list(map(int, input().split()))
len = 1
max = 0
prev = num[0]
for n in num[1:]:
	if n >= prev:
		len += 1
	else:
		if len > max:
			max = len
		len = 1
	prev = n
if len > max:
	max = len
print(max)


n = int(input())
l = [int(x) for x in input().split()]
i = 0
s = 1
l1 = []
if n == 1:
	l1 = [1]
else:
	while i < n - 1:
		if l[i] <= l[i + 1] and i < n - 2:
			s += 1
		elif l[i] <= l[i + 1] and i == n - 2:
			s += 1
			l1.append(s)
		else:
			l1.append(s)
			s = 1
		i += 1
print(max(l1))


n = int(input())
s = input()
s = s.split(' ')
l = len(s)
p = 0
d = 0
for i in range(0, l - 1):
	if int(s[i + 1]) >= int(s[i]):
		d = d + 1
		if d > p:
			p = d
	else:
		d = 0
print(p + 1)


n = int(input())
s = input()
lis = [int(i) for i in s.split()]
big = 0
c = 0
for i in range(len(lis) - 1):
	if lis[i] <= lis[i + 1]:
		c += 1
	else:
		c = 0
	if c > big:
		big = c
print(big + 1)


n = int(input())
l = list(map(int, input().split()))
ll = [1] * n
i = 1
mx = 1
cou = 1
while i < n:
	if l[i] >= l[i - 1]:
		cou += 1
	else:
		if cou > mx:
			mx = cou
		cou = 1
	i += 1
	if cou > mx:
		mx = cou
print(mx)


n = int(input())
progress = [int(x) for x in input().split()]
best = 1
curr = 1
prev = progress[0]
for p in progress[1:]:
	if p >= prev:
		curr += 1
		if curr > best:
			best = curr
	else:
		curr = 1
	prev = p
print(best)


def A580():
	n = int(input())
	nlist = list(map(int, input().split()))
	l_max = 1
	l_curr = 1
	i = 0
	while i < n - 1:
		if nlist[i + 1] >= nlist[i]:
			l_curr += 1
			l_max = max(l_max, l_curr)
		else:
			l_curr = 1
		i += 1
	print(l_max)
A580()


n = int(input())
a = [int(x) for x in input().split()]
max = 1
current = 1
for x in range(1, len(a)):
	if a[x] >= a[x - 1]:
		current += 1
		if max < current:
			max = current
	else:
		current = 1
print(max)


n = int(input())
l = input().split()
for i in range(n):
	l[i] = int(l[i])
(a, b) = (1, 1)
for j in range(n - 1):
	if l[j + 1] >= l[j]:
		a += 1
		if a >= b:
			b = a
		else:
			pass
	else:
		a = 1
print(b)


import logging
fmt = '%(levelname)s - %(name)s (line:%(lineno)s) - %(message)s'
formatter = logging.Formatter(fmt)
ch = logging.StreamHandler()
ch.setLevel(logging.ERROR)
ch.setFormatter(formatter)
logger = logging.getLogger('kefa_and_first_steps')
logger.setLevel(logging.ERROR)
logger.addHandler(ch)

def solve(seq):
	msf = count = 1
	for i in range(1, len(seq)):
		if seq[i - 1] > seq[i]:
			count = 0
		count += 1
		msf = max(msf, count)
	return msf

def main():
	_ = input()
	seq = [int(x) for x in input().strip().split()]
	result = solve(seq)
	print(result)
main()


n = int(input())
l = []
arr = input().split()
for i in range(n):
	l.append(int(arr[i]))
(i, ctr) = (1, 1)
result = 1
while i < n:
	if l[i] >= l[i - 1]:
		ctr += 1
	elif l[i] < l[i - 1]:
		ctr = 1
	if ctr > result:
		result = ctr
	i += 1
print(result)


num = int(input())
income = list(map(int, input().split()))
i = 0
delta = []
while i < num - 1:
	x = income[i + 1] - income[i]
	delta.append(x)
	i = i + 1
length = [0]
i = 0
x = 0
while i < len(delta):
	while delta[i] >= 0:
		x = x + 1
		i = i + 1
		if i >= len(delta):
			break
	length.append(x)
	x = 0
	i = i + 1
print(max(length) + 1)


n = int(input())
ls = [int(x) for x in input().split()]
cntls = []

def subseg():
	cnt = 1
	if n != 1:
		for i in range(len(ls) - 1):
			if ls[i + 1] >= ls[i]:
				cnt = cnt + 1
				cntls.append(cnt)
			else:
				cnt = 1
				cntls.append(cnt)
	else:
		cntls.append(1)
		cntls.append(0)
	return max(cntls)
res = subseg()
print(res)


n = int(input())
arr = [int(a) for a in input().split()]
ans = 1
fin = 1
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		ans += 1
		fin = max(fin, ans)
	else:
		fin = max(fin, ans)
		ans = 1
print(fin)


n = int(input())
ns = input().split()
ans = 1
maxans = 1
for i in range(len(ns) - 1):
	if int(ns[i]) > int(ns[i + 1]):
		ans = 1
	else:
		ans += 1
		if ans > maxans:
			maxans = ans
print(maxans)


n = int(input())
a = list(map(int, input().split()))
count1 = 0
count2 = []
for i in range(n):
	if i == n - 1 and a[i] >= a[i - 1]:
		count1 += 1
		count2.append(count1)
		break
	elif i == n - 1 and a[i] < a[i - 1]:
		break
	if a[i] <= a[i + 1]:
		count1 += 1
	else:
		count1 += 1
		count2.append(count1)
		count1 = 0
print(max(count2))


length = int(input())
sequence = list(map(int, input().split()))
subseq = []
maximum = 1
for i in range(1, length):
	if sequence[i] >= sequence[i - 1]:
		maximum += 1
	else:
		subseq.append(maximum)
		maximum = 1
subseq.append(maximum)
print(max(subseq))


n = int(input())
j = 1
max = 1
array = input().split()
for i in range(0, n):
	array[i] = int(array[i])
for i in range(0, n - 1):
	if array[i] <= array[i + 1]:
		j += 1
		if j > max:
			max = j
	else:
		j = 1
print(max)


n = int(input())
a = input().split()
a = list(map(int, a))
d = 0
daylist = []
for i in range(0, len(a) - 1):
	if a[i] <= a[i + 1]:
		d = d + 1
	else:
		daylist.append(d + 1)
		d = 0
daylist.append(d + 1)
print(max(daylist))


n = int(input())
N = [int(x) for x in input().split()]
temp_char = N[0]
counter = 1
temp_counter = 1
for char in N[1:]:
	if char >= temp_char:
		temp_char = char
		temp_counter += 1
	else:
		if temp_counter > counter:
			counter = temp_counter
		temp_counter = 1
		temp_char = char
else:
	if temp_counter > counter:
		counter = temp_counter
	print(counter)


input()
a = [int(x) for x in input().split()]
c = 1
m = 1
for (k, v) in enumerate(a):
	if k == len(a) - 1:
		break
	if a[k + 1] >= a[k]:
		c += 1
		if c > m:
			m = c
	else:
		c = 1
print(m)


n = int(input())
inps = input()
li = [int(k) for k in inps.split(' ')]
maxlen = 1
result = 0
for i in range(n - 1):
	if li[i + 1] >= li[i]:
		maxlen += 1
		if maxlen >= result:
			result = maxlen
	else:
		maxlen = 1
if result == 0:
	result = 1
print(result)


n = int(input())
data = list(map(int, input().split()))
MAX = 1
len = 1
for i in range(1, n):
	if data[i] >= data[i - 1]:
		len += 1
		MAX = max(MAX, len)
	else:
		len = 1
print(MAX)


n = int(input())
lst = list(map(int, input().split()))
l = 1
m1 = 1
for i in range(1, n):
	if lst[i] >= lst[i - 1]:
		l += 1
		m1 = max(m1, l)
	else:
		l = 1
print(m1)


num = int(input())
mylist = list(map(int, input().split()))
count = 0
seq = []
for i in range(len(mylist) - 1):
	if mylist[i + 1] >= mylist[i]:
		count += 1
	else:
		count = 0
	seq.append(count)
if len(mylist) > 1:
	print(max(seq) + 1)
else:
	print(1)


n = int(input())
xs = list(map(int, input().split()))
result = 1
t = 1
for i in range(1, n):
	if xs[i] >= xs[i - 1]:
		t += 1
	else:
		t = 1
	result = max(result, t)
print(result)


z = int(input())
x = [int(a) for a in input().split()]
c = 0
m = 0
for i in range(1, z):
	if x[i] >= x[i - 1]:
		c += 1
	else:
		m = max(m, c)
		c = 0
m = max(m, c)
print(m + 1)


n = int(input())
a = list(map(int, input().split()))
maxlen = curlen = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		curlen += 1
	else:
		if maxlen < curlen:
			maxlen = curlen
		curlen = 1
if maxlen < curlen:
	maxlen = curlen
print(maxlen)


n = int(input())
a = [int(x) for x in input().rstrip().split(' ')]
a.append(0)
max_len = 1
curr_len = 1
for k in range(len(a) - 1):
	if a[k + 1] >= a[k]:
		curr_len += 1
	else:
		max_len = max(max_len, curr_len)
		curr_len = 1
print(max_len)


n = int(input())
data = [int(x) for x in input().split()]
maxi = 0
count = 0
prev = 0
for x in range(len(data)):
	if data[x] >= prev:
		count += 1
	else:
		maxi = count if count > maxi else maxi
		count = 0
		count = 1
	prev = data[x]
maxi = count if count > maxi else maxi
print(maxi)


value = int(input())
values = input()
values = values.split()
values = [int(i) for i in values]
len = 1
check = 1
for i in range(value - 1):
	if values[i + 1] >= values[i]:
		len += 1
	else:
		check = max(check, len)
		len = 1
print(max(check, len))


n = int(input())
a = [int(x) for x in input().split()]
g = [1]
for i in range(1, n):
	if a[i] >= a[i - 1]:
		g.append(g[i - 1] + 1)
	else:
		g.append(1)
print(max(g))


n = int(input())
a = [int(x) for x in input().split()]
k = a[0]
l = []
count = 0
for i in range(1, n):
	if a[i] >= k:
		count += 1
		k = a[i]
	else:
		l.append(count)
		count = 0
		k = a[i]
l.append(count)
if not l:
	print(count + 1)
else:
	print(max(l) + 1)


n = int(input())
a = list(map(int, input().split()))
a = [0] + a + [0]
dl = 1
dlh = 0
for i in range(1, n + 2):
	if a[i] >= a[i - 1]:
		dlh += 1
	else:
		dl = max(dl, dlh)
		dlh = 1
print(max(dl, dlh))


def main():
	n = input()
	a = input()
	a = list(map(int, a.split()))
	maxcount = 1
	sequence = 0
	for i in range(1, len(a)):
		if a[i] >= a[i - 1]:
			maxcount += 1
		else:
			sequence = max(maxcount, sequence)
			maxcount = 1
	sequence = max(maxcount, sequence)
	print(sequence)
main()


def get_period():
	days = int(input())
	numbers = [int(x) for x in input().split()]
	continuous_count = 1
	max_count = 1
	over = False
	for ind in range(0, days - 1):
		if numbers[ind] <= numbers[ind + 1]:
			continuous_count += 1
		else:
			over = True if ind == days - 2 else False
			if continuous_count > max_count:
				max_count = continuous_count
			continuous_count = 1
	if not over:
		return max_count if max_count > continuous_count else continuous_count
	return max_count
print(get_period())


num = int(input())
responde = 1
nu = list(map(int, input().split()))
nu.append(0)
listado = [0]
for (x, y) in zip(nu, nu[1:]):
	if x <= y:
		responde += 1
	elif x > y:
		listado.append(responde)
		responde = 1
	else:
		listado.append(responde)
		break
print(max(listado))


length = int(input())
nums = list(map(int, input().split(' ')))
maxC = 0
count = 1
for (i, n) in enumerate(nums):
	if i == 0:
		continue
	elif nums[i - 1] <= n:
		count += 1
	else:
		if maxC < count:
			maxC = count
		count = 1
if maxC < count:
	maxC = count
print(maxC)


n = int(input())
count = 1
temp = 1
l = input().split()
for k in range(1, n):
	if int(l[k]) >= int(l[k - 1]):
		count += 1
		if count > temp:
			temp = count
	else:
		count = 1
print(temp)


a = int(input())
n = list(map(int, input().split()))
i = 0
count = 1
c = 1
while i < len(n) - 1:
	if n[i] <= n[i + 1]:
		count = count + 1
		if count > c:
			c = count
	elif n[i] > n[i + 1]:
		count = 1
	i = i + 1
print(c)


n = int(input())
a = list(map(int, input().split()))
max_ = 1
res = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		res += 1
	else:
		if res > max_:
			max_ = res
		res = 1
print(max(max_, res))


_ = input()
a = [int(x) for x in input().split(' ')]
largest = 0
tmp = 0
prev = -1
for i in a:
	if i >= prev:
		tmp += 1
	else:
		if tmp > largest:
			largest = tmp
		tmp = 1
	prev = i
if tmp > largest:
	largest = tmp
print(largest)


n = int(input())
x = [int(i) for i in input().split()]
t = 1
ans = 1
for i in range(n - 1):
	if x[i] <= x[i + 1]:
		t += 1
		ans = max(ans, t)
	else:
		t = 1
print(ans)


n = int(input())
daysProfit = list(map(int, input().split()))
longest = 1
subLongest = 0
previous = 0
for i in range(len(daysProfit)):
	if daysProfit[i] - previous > -1:
		subLongest += 1
	else:
		subLongest = 1
	if longest < subLongest:
		longest = subLongest
	previous = daysProfit[i]
print(longest)


def main():
	n = int(input())
	a = [int(i) for i in input().split()]
	res = [0] * n
	res[0] = 1
	for i in range(1, n):
		if a[i] >= a[i - 1]:
			res[i] = res[i - 1] + 1
		else:
			res[i] = 1
	print(max(res))
main()


n = int(input())
(sett, count, i) = (0, 0, 0)
a = [int(i) for i in input().split()]
temp = -1
for i in a:
	if i >= temp:
		count += 1
		sett = max(count, sett)
	else:
		count = 1
	temp = i
print(sett)


def kefaAndFirstStep(n, arr):
	i = 0
	j = 1
	con = 1
	res = []
	while j < n:
		if arr[i] == arr[j] or arr[i] < arr[j]:
			con = con + 1
			res.append(con)
		else:
			res.append(con)
			con = 1
		i = i + 1
		j = j + 1
	res.append(con)
	final = max(res)
	return final
n = int(input())
arr = [int(c) for c in input().split()]
print(kefaAndFirstStep(n, arr))


n = int(input())
lista = list(input().split(' '))
maximos = [1]
contagem = 1
for i in range(1, n):
	if int(lista[i]) < int(lista[i - 1]):
		maximos.append(contagem)
		contagem = 1
	else:
		contagem += 1
	if i == n - 1:
		maximos.append(contagem)
print(max(maximos))


input()
array = input().split(' ')
max = 0
current_max = 1
for i in range(len(array) - 1):
	if int(array[i]) <= int(array[i + 1]):
		current_max += 1
	else:
		if max < current_max:
			max = current_max
		current_max = 1
else:
	if max < current_max:
		max = current_max
print(max)


n = int(input())
my_list = list(map(int, input().split()))
longest_length = 1
current_length = 1
for n in range(len(my_list) - 1):
	if my_list[n + 1] >= my_list[n]:
		current_length += 1
	else:
		if current_length > longest_length:
			longest_length = current_length
		current_length = 1
	if n == len(my_list) - 2 and my_list[-1] >= my_list[-2]:
		if current_length > longest_length:
			longest_length = current_length
print(longest_length)


(n, count, ans) = (int(input()), 0, 0)
a = [int(_) for _ in input().split()]
a.append(-1)
for i in range(n):
	count += 1
	if a[i] > a[i + 1]:
		ans = max(ans, count)
		count = 0
print(ans)


n = int(input())
m = list(map(int, input().split()))
r = 0
p = []
i = 0
while i < n - 1:
	del p[:]
	p.append(m[i])
	for j in range(i, n - 1):
		if m[j] <= m[j + 1]:
			p.append(m[j + 1])
		else:
			break
	i = j + 1
	if r < len(p):
		r = len(p)
if n == 1:
	print(1)
else:
	print(r)


n = int(input())
moneys = input().split(' ')
moneys = [int(money) for money in moneys]
dem = 1
dem_list = []
for i in range(len(moneys) - 1):
	if moneys[i] <= moneys[i + 1]:
		dem += 1
	else:
		dem_list.append(dem)
		dem = 1
dem_list.append(dem)
print(max(dem_list))


n = int(input())
temp = list(map(int, input().split()))
max_len = 1
cnt = 1
for i in range(1, n):
	if temp[i] >= temp[i - 1]:
		cnt += 1
	else:
		cnt = 1
	if cnt > max_len:
		max_len = cnt
print(max_len)


from math import *
from sys import stdin, stdout
import itertools, os, sys, threading
from collections import deque, Counter, OrderedDict, defaultdict
from heapq import *
from fractions import Fraction

def ii():
	return int(input())

def si():
	return str(input())

def mi():
	return map(int, input().split())

def li():
	return list(mi())

def fii():
	return int(stdin.readline())

def fsi():
	return str(stdin.readline())

def fmi():
	return map(int, stdin.readline().split())

def fli():
	return list(fmi())
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007

def getKey(item):
	return item[0]

def sort2(l):
	return sorted(l, key=getKey)

def d2(n, m, num):
	return [[num for x in range(m)] for y in range(n)]

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def ntl(n):
	return [int(i) for i in str(n)]

def powerMod(x, y, p):
	res = 1
	x %= p
	while y > 0:
		if y & 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res
graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000

def bfs(d, v):
	q = []
	q.append(v)
	visited[v] = 1
	while len(q) != 0:
		x = q[0]
		q.pop(0)
		for i in d[x]:
			if visited[i] != 1:
				visited[i] = 1
				q.append(i)
		print(x)

def make_graph(e):
	d = {}
	for i in range(e):
		(x, y, z) = mi()
		if x not in d:
			d[x] = [[z, y]]
		else:
			d[x].append([z, y])
		if y not in d:
			d[y] = [[z, x]]
		else:
			d[y].append([z, x])
	return d

def gr2(n):
	d = defaultdict(list)
	for i in range(n):
		(x, y) = mi()
		d[x].append(y)
	return d

def connected_components(graph):
	seen = set()

	def dfs(v):
		vs = set([v])
		component = []
		while vs:
			v = vs.pop()
			seen.add(v)
			vs |= set(graph[v]) - seen
			component.append(v)
		return component
	ans = []
	for v in graph:
		if v not in seen:
			d = dfs(v)
			ans.append(d)
	return ans

def primeFactors(n):
	s = set()
	while n % 2 == 0:
		s.add(2)
		n = n // 2
	for i in range(3, int(sqrt(n)) + 1, 2):
		while n % i == 0:
			s.add(i)
			n = n // i
	if n > 2:
		s.add(n)
	return s

def find_all(a_str, sub):
	start = 0
	while True:
		start = a_str.find(sub, start)
		if start == -1:
			return
		yield start
		start += len(sub)

def SieveOfEratosthenes(n, isPrime):
	isPrime[0] = isPrime[1] = False
	for i in range(2, n + 1):
		isPrime[i] = True
	p = 2
	while p * p <= n:
		if isPrime[p] == True:
			i = p * p
			while i <= n:
				isPrime[i] = False
				i += p
		p += 1
	return isPrime

def dijkstra(edges, f, t):
	g = defaultdict(list)
	for (l, r, c) in edges:
		g[l].append((c, r))
	(q, seen, mins) = ([(0, f, ())], set(), {f: 0})
	while q:
		(cost, v1, path) = heappop(q)
		if v1 not in seen:
			seen.add(v1)
			path = (v1, path)
			if v1 == t:
				return (cost, path)
			for (c, v2) in g.get(v1, ()):
				if v2 in seen:
					continue
				prev = mins.get(v2, None)
				next = cost + c
				if prev is None or next < prev:
					mins[v2] = next
					heappush(q, (next, v2, path))
	return float('inf')
n = ii()
l = li()
m = 0
count = 1
for i in range(n - 1):
	if l[i] <= l[i + 1]:
		count += 1
	else:
		m = max(m, count)
		count = 1
print(max(m, count))


n = int(input())
li = [int(x) for x in input().split()]
mx = 0
curr = 0
pre = -1
for i in li:
	if i >= pre:
		curr += 1
		if curr > mx:
			mx = curr
	else:
		curr = 1
	pre = i
if curr > mx:
	mx = curr
print(mx)


n = int(input())
b = input().split(' ')
l = []
t = 0
for i in range(n):
	if i != 0:
		if int(b[i]) >= int(b[i - 1]):
			t = t + 1
		else:
			l.append(t + 1)
			t = 0
l.append(t + 1)
l.sort(reverse=True)
print(l[0])


n = input()
nums = map(int, input().split(' '))
current_streak = 0
longest_streak = 0
last_num = -float('inf')
for num in nums:
	if num < last_num:
		current_streak = 1
	else:
		current_streak += 1
	if current_streak > longest_streak:
		longest_streak = current_streak
	last_num = num
print(longest_streak)


n = int(input())
lst = list(map(int, input().split()))
up = [1]
c = 1
if n == 1:
	print('1')
else:
	for i in range(n - 1):
		if lst[i] <= lst[i + 1]:
			c += 1
			up.append(c)
		else:
			c = 1
	print(max(up))


n = int(input(''))
s = [int(x) for x in input('').split(' ')]
a = 1
b = 1
for i in range(n):
	if i >= 1 and s[i] >= s[i - 1]:
		a = a + 1
	elif a > b:
		b = a
		a = 1
	else:
		b = b
		a = 1
print(max(a, b))


n = int(input())
m = [int(x) for x in input().split()]
y = 1
x = [1]
for i in range(n - 1):
	if m[i] <= m[i + 1]:
		y += 1
	else:
		y = 1
	x.append(y)
x.sort()
print(x[-1])


n = int(input())
line = [10 ** 9] + [int(i) for i in input().split()]
op = [1]
total = 1
if n == 1:
	print('1')
else:
	while len(line) > 1:
		if line[-1] >= line[-2]:
			total += 1
			line.pop()
		elif total != 1:
			op.append(total)
			total = 1
			line.pop()
		else:
			line.pop()
			continue
	print(max(op))


n = int(input())
a = [int(i) for i in input().split()]
count = 0
b = 0
for i in range(len(a) - 1):
	if a[i] <= a[i + 1]:
		count += 1
		if count + 1 > b:
			b = count + 1
	else:
		count = 0
if b == 0:
	b = 1
print(b)


n = int(input())
l = list(map(int, input().split(' ')))
max = 1
j = 0
while j < n - 1:
	count = 1
	i = j
	while i < n - 1 and l[i] <= l[i + 1]:
		count += 1
		i += 1
	j = i + 1
	if count > max:
		max = count
print(max)


def kefa(n, inp):
	result = 0
	count = 1
	for i in range(1, n):
		if inp[i - 1] <= inp[i]:
			count += 1
			if count > result:
				result = count
		else:
			count = 1
	if result == 0:
		result = 1
	print(result)
n = int(input())
inp = list(map(int, input().split()))
kefa(n, inp)


def steps(l):
	count = 0
	l2 = [0]
	for i in range(0, len(l) - 1):
		if l[i + 1] >= l[i]:
			count += 1
			if i == len(l) - 2:
				l2.append(count)
		else:
			l2.append(count)
			count = 0
	l2.sort()
	return l2[-1] + 1
n = int(input())
l = list(map(int, input().split()))
print(steps(l))


n = input()
n = list(map(int, input().split()))
s = a = 1
for x in range(1, len(n)):
	if n[x] >= n[x - 1]:
		a += 1
		if a > s:
			s = a
	else:
		a = 1
print(s)


from sys import stdin
input = stdin.readline
n = int(input())
a = list(map(int, input().split()))
cur = 1
ans = 0
prev_item = a[0]
for i in range(1, n):
	if a[i] >= prev_item:
		cur += 1
	else:
		if cur > ans:
			ans = cur
		cur = 1
	prev_item = a[i]
if cur > ans:
	ans = cur
print(ans)


n = int(input())
a = list(map(lambda x: int(x), input().split()))
m = list()
m.append(0) if n > 1 and a[1] < a[0] else m.append(1)
for i in range(1, n):
	if a[i] < a[i - 1]:
		m.append(0)
	m[~0] += 1
print(max(m))


n = int(input())
a = [int(i) for i in input().split()]
answer = 1
i = 0
j = 1
while j < len(a):
	if a[j] < a[j - 1]:
		answer = max(answer, j - i)
		i = j
	j += 1
print(max(answer, j - i))


n = int(input())
x = list(map(int, input().split()))
ini = -1
the_stack = [x[0]]
del x[0]
while x != []:
	if the_stack[-1] <= x[0]:
		the_stack.append(x[0])
		del x[0]
		continue
	elif the_stack[-1] > x[0]:
		l = len(the_stack)
		if l > ini:
			ini = l
		the_stack = [x[0]]
		del x[0]
		continue
if len(the_stack) > ini:
	print(len(the_stack))
else:
	print(ini)


n = int(input())
lst1 = list(map(int, input().split()[:n]))
lenlst = []
length = 0
l = len(lst1)
for i in range(l):
	if i == l - 1:
		length = 0
		lenlst.append(length)
		break
	else:
		if lst1[i] <= lst1[i + 1]:
			length += 1
		elif lst1[i] > lst1[i + 1]:
			length = 0
		lenlst.append(length)
print(max(lenlst) + 1)


number = int(input())
count = 1
answer = count
array = list(map(int, input().split()))
for i in range(1, len(array)):
	if array[i] >= array[i - 1]:
		count += 1
		if count > answer:
			answer = count
	else:
		count = 1
print(answer)


n = int(input())
day = list(map(int, input().split()))
kq = 0
j = -1
for i in range(n):
	if i <= j:
		continue
	j = i
	dem = 1
	while j != n - 1 and day[j + 1] >= day[j]:
		j += 1
		dem += 1
	else:
		kq = max(kq, dem)
print(kq)


n = int(input())
a = list(map(int, input().split()))
ct = 1
o = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		ct += 1
	else:
		o = max(o, ct)
		ct = 1
o = max(o, ct)
print(o)


n = int(input())
l = list(map(int, input().split()))
ans = 1
temp_ans = 1
i = 0
while i < len(l) - 1:
	if l[i] <= l[i + 1]:
		temp_ans += 1
	else:
		if temp_ans > ans:
			ans = temp_ans
		temp_ans = 1
	i += 1
if temp_ans > ans:
	ans = temp_ans
print(ans)


n = int(input())
c = 1
s = input().split()
lst = []
for i in range(n - 1):
	if int(s[i]) <= int(s[i + 1]):
		c += 1
	else:
		lst.append(c)
		c = 1
lst.append(c)
print(max(lst))


n = int(input())
a = [int(x) for x in input().split()]
(k, j) = (0, 0)
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		k += 1
		if k >= j:
			j = k
	else:
		k = 0
print(j + 1)


n = int(input())
arr = [int(char) for char in input().split()]
maxi = 0
count = 0
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		count += 1
		if count > maxi:
			maxi = count
	else:
		count = 0
print(maxi + 1)


length = int(input())
input_string_list = list(map(int, input().split()))
first_time = True
temp_list = []
ans = 0
temp_list.append(1)
for i in range(1, length):
	temp = temp_list[-1]
	if input_string_list[i] >= input_string_list[i - 1]:
		temp_list.append(temp + 1)
	else:
		temp_list.append(1)
print(max(temp_list))


'__author__' == 'deepak Singh Mehta(learning to code))'

def LIS_DP(arr, n):
	i = 1
	cnt = 1
	mxcnt = 1
	while i < n:
		if arr[i] >= arr[i - 1]:
			cnt += 1
		else:
			cnt = 1
		mxcnt = max(mxcnt, cnt)
		i += 1
	print(mxcnt)
n = int(input())
arr = list(map(int, input().split()))
LIS_DP(arr, n)


def main():
	n = int(input())
	arr = input().split()
	arr = list(map(int, arr))
	cnt = 1
	mx = 1
	for i in range(1, n):
		if arr[i] >= arr[i - 1]:
			cnt += 1
		else:
			if cnt > mx:
				mx = cnt
			cnt = 1
		if cnt > mx:
			mx = cnt
	print(mx)
main()


n = int(input())
A = [int(k) for k in input().split(' ')]
sign = ['.' for k in range(n - 1)]
for k in range(1, n):
	if A[k] - A[k - 1] < 0:
		sign[k - 1] = '-'
	else:
		sign[k - 1] = '+'
MaxSeg = 1
Seg = 1
for i in range(n - 1):
	if sign[i] == '+':
		Seg += 1
	else:
		Seg = 1
	MaxSeg = max(MaxSeg, Seg)
print(str(MaxSeg))


n = int(input())
t = list(map(int, input().split()))
li = list()
i = 0
b = 1
for j in range(i, len(t) - 1):
	if t[j] <= t[j + 1]:
		b += 1
	else:
		i = j + 1
		li.append(b)
		b = 1
li.append(b)
print(max(li))


n = int(input().strip())
arr = [int(__) for __ in input().strip().split()]
(ma, cur) = (0, 0)
for i in range(n - 1):
	if arr[i + 1] >= arr[i]:
		cur += 1
		ma = max(ma, cur)
	else:
		cur = 0
print(ma + 1)


num = int(input())
l = input().split()
arr = [int(x) for x in l]
maxSize = 0
if num == 1:
	print(1)
else:
	i = 0
	while i < len(arr) - 1:
		curLen = 1
		while arr[i + 1] >= arr[i] and i + 1 < len(arr) - 1:
			curLen += 1
			i += 1
		if curLen > maxSize:
			maxSize = curLen
		i += 1
	if arr[-1] >= arr[-2]:
		curLen += 1
	if curLen > maxSize:
		print(curLen)
	else:
		print(maxSize)


n = int(input())
arr = list(map(int, input().split(' ')))

def get_cost(n, res):
	return abs(n - res)
maxlen = 1
curr_len = 1
prev = arr[0]
for i in range(1, len(arr)):
	if prev > arr[i]:
		maxlen = max(curr_len, maxlen)
		curr_len = 1
	elif i == len(arr) - 1:
		curr_len += 1
		maxlen = max(curr_len, maxlen)
	else:
		curr_len += 1
	prev = arr[i]
print(maxlen)


import math
n = int(input())
arr = list(map(int, input().strip().split()))
ans = 0
cnt = 1
for i in range(1, n, 1):
	if arr[i] >= arr[i - 1]:
		cnt += 1
	else:
		ans = max((ans, cnt))
		cnt = 1
ans = max((ans, cnt))
print(ans)


n = int(input())
arr = list(map(int, input().split()))
p1 = 0
ans = 1
c = 1
while p1 < n - 1:
	if arr[p1] <= arr[p1 + 1]:
		c += 1
	else:
		ans = max(ans, c)
		c = 1
	p1 += 1
ans = max(ans, c)
print(ans)


n = int(input())
t = [int(x) for x in input().split()]
s = 1
m = 1
for i in range(len(t) - 1):
	if t[i] <= t[i + 1]:
		s = s + 1
	else:
		s = 1
	if m < s:
		m = s
print(m)


n = int(input())
s = list((int(num) for num in input().strip().split()))[:n]
max = 1
count = 1
for i in range(len(s) - 1):
	if s[i] <= s[i + 1]:
		count += 1
		if max < count:
			max = count
	else:
		count = 1
print(max)


n = int(input())
a = list(map(int, input().split()))
ans = tmp = flag = 0
for i in range(n):
	tmp = tmp + 1 if a[i] >= flag else 1
	ans = max(tmp, ans)
	flag = a[i]
print(ans)


length = int(input())
arr = list(map(int, input().split()))
res = tmp = 1
for i in range(length - 1):
	if arr[i] <= arr[i + 1]:
		tmp += 1
	else:
		res = tmp if tmp > res else res
		tmp = 1
res = tmp if tmp > res else res
print(res)


n = int(input())
arr = list(map(int, input().split()))
cont = 0
list = [0]
arr.append(0)
for i in range(n):
	if arr[i + 1] >= arr[i]:
		cont = cont + 1
		if i == n - 1:
			list.append(cont + 1)
	elif cont != 0 or i == n - 1:
		list.append(cont + 1)
		cont = 0
if n == 1:
	list.append(1)
print(max(list))


n = int(input())
a = list(map(int, input().split()))
maxc = 0
i = 1
count = 0
while i < n:
	if a[i - 1] <= a[i]:
		count += 1
	else:
		count = 0
	if count > maxc:
		maxc = count
	i += 1
print(maxc + 1)


a = int(input(''))
b = input('')
l_aux = [int(x) for x in b.split(' ')]
aux1 = 0
aux2 = 1
maior = 1
if a == 1:
	maior = 1
else:
	while aux1 < a - 1:
		if l_aux[aux1] <= l_aux[aux1 + 1]:
			aux2 += 1
			if aux2 > maior:
				maior = aux2
			else:
				pass
		else:
			aux2 = 1
		aux1 += 1
print(maior)


n = int(input())
s = [int(x) for x in input().split(' ')]
lng = 1
cur = 1
for i in range(1, n):
	if s[i] >= s[i - 1]:
		cur += 1
		lng = max(lng, cur)
	else:
		cur = 1
print(lng)


n = int(input())
ans = 1
cur = 1
money = [int(x) for x in input().split()]
for i in range(1, n):
	if money[i] >= money[i - 1]:
		cur += 1
		ans = max(ans, cur)
	else:
		cur = 1
print(ans)


n = int(input())
a = list(map(int, input().split(' ')))
maxx = 0
count = 0
i = 0
while i < n:
	if i == 0 or a[i] >= a[i - 1]:
		count += 1
	else:
		count = 1
	if count > maxx:
		maxx = count
	i += 1
print(maxx)


l = lambda : map(int, input().split())
n = int(input())
a = list(l())
cnt = 1
maxlist = []
for i in range(n - 1):
	if a[i + 1] >= a[i]:
		cnt += 1
		maxlist.append(cnt)
	else:
		cnt = 1
maxlist.append(cnt)
print(max(maxlist))


a = int(input())
b = input().split()
c = [int(i) for i in b]
d = c.pop(0)
e = 1
g = []
while len(c) > 0:
	f = c.pop(0)
	if f >= d:
		e = e + 1
		d = f
	else:
		g.append(e)
		d = f
		e = 1
g.append(e)
print(max(g))


n = int(input())
L = [int(x) for x in input().split()]
D = [1]
if n == 1:
	print(1)
else:
	som = 1
	for i in range(n - 1):
		if L[i] <= L[i + 1]:
			som += 1
			D.append(som)
		else:
			som = 1
	print(max(D))


n = int(input())
money = list(input().split(' '))
size = 1
i = 0
for j in range(0, n - 1):
	if int(money[j]) > int(money[j + 1]):
		j = j + 1
		i = j
	elif j - i + 2 > size:
		size = j - i + 2
print(size)


n = int(input())
number = input().split()
numbers = [int(i) for i in number]
x = 1
lis = [1]
for i in range(len(numbers) - 1):
	if not numbers[i] > numbers[i + 1]:
		x += 1
		lis.append(str(x))
	if numbers[i] > numbers[i + 1]:
		x = 1
		lis.append(str(x))
answer = [int(i) for i in lis]
print(max(answer))


from sys import stdin
n = int(stdin.readline().strip())
nums = [int(x) for x in stdin.readline().strip().split()]
nums.append(-1)
counts = [0] * n
last = -1
i = 0
chain = 0
maxChain = 0
while i < n:
	chain = 0
	for j in range(i, n + 1):
		if last <= nums[j]:
			chain += 1
			last = nums[j]
		else:
			if chain > maxChain:
				maxChain = chain
			i = j - 1
			last = -1
			break
	i += 1
print(maxChain)


number = input()
line = input().split()
ans_line = [1]
q = 0
for i in range(len(line) - 1):
	if int(line[i + 1]) >= int(line[i]):
		ans_line[q] = ans_line[q] + 1
	if int(line[i + 1]) < int(line[i]):
		q += 1
		ans_line.append(1)
ans = max(ans_line)
print(ans)


n = int(input())
a = [int(x) for x in input().split()]
cnt = 0
mx = 0
for i in range(len(a)):
	if i == 0:
		cnt += 1
	elif a[i] >= a[i - 1]:
		cnt += 1
	else:
		cnt = 1
	mx = max(mx, cnt)
print(mx)


n = int(input())
x = 1
maxi = 1
a = input().split()
for i in range(n - 1):
	if int(a[i]) <= int(a[i + 1]):
		x = x + 1
		maxi = max(maxi, x)
	else:
		x = 1
print(maxi)


lstLen = int(input())
lst = [int(s) for s in input().split()]
nds = 0
res = 0
for i in range(1, lstLen):
	if lst[i - 1] <= lst[i]:
		nds += 1
	else:
		if res < nds:
			res = nds
		nds = 0
if res < nds:
	res = nds
print(res + 1)


n = int(input())
lst = list(map(int, input().split()))
count = 1
maxim = 0
for i in range(n - 1):
	if lst[i] > lst[i + 1]:
		if count > maxim:
			maxim = count
		count = 1
	else:
		count += 1
if count > maxim:
	maxim = count
print(maxim)


n = int(input())
tab = [int(elt) for elt in input().split(' ')]
maxx = 1
long = 1
for i in range(n - 1):
	if tab[i] <= tab[i + 1]:
		long += 1
		if maxx < long:
			maxx = long
	else:
		long = 1
print(maxx)


__author__ = 'Bian'
n = int(input())
data = [int(x) for x in input().split()]
f = [0] * n
for i in range(n):
	if i == 0:
		f[0] = 1
	elif data[i] >= data[i - 1]:
		f[i] = f[i - 1] + 1
	else:
		f[i] = 1
print(max(f))


def counts(n):
	a = False
	global i
	i = 1
	count = 1
	while a == False:
		if numbers[i] >= numbers[i - 1]:
			count += 1
			i += 1
		else:
			values.append(count)
			count = 1
			i += 1
		if i == n:
			values.append(count)
			a = True
values = []
n = int(input())
numbers = [int(n) for n in input().split()]
if n != 1 and n != 0:
	counts(n)
	print(max(values))
elif n == 1:
	print(1)
else:
	print(0)


_ = int(input())
hold = []
a = [int(a) for a in input().split()]
prev = 0
counter = 0
for nums in a:
	if nums >= prev:
		counter += 1
	else:
		hold.append(counter)
		counter = 1
	prev = nums
hold.append(counter)
hold.sort()
hold.reverse()
print(hold[0])


def main():
	n = int(input())
	s = [int(x) for x in input().split()]
	m = 1
	temp = 1
	e = s[0]
	for x in s[1:]:
		if x >= e:
			temp += 1
		else:
			temp = 1
		if temp > m:
			m = temp
		e = x
	print(m)
main()


n = int(input())
m = [int(x) for x in input().split()]
if n > 1:
	s = 0
	p = []
	for i in range(0, n - 1):
		if m[i] <= m[i + 1]:
			s += 1
		else:
			s = 0
		p.append(s)
	print(max(p) + 1)
else:
	print(1)


n = int(input())
(*a,) = map(int, input().split())
res = 1
tmp = 1
for i in range(0, n - 1):
	if a[i] <= a[i + 1]:
		tmp += 1
	else:
		tmp = 1
	res = max(res, tmp)
print(res)


a = int(input())
n = 0
p = 0
b = [int(x) for x in input().split()]
if a != 1:
	for i in range(a):
		if i >= 1 and i != a - 1:
			if b[i] >= b[i - 1]:
				n += 1
			elif n > p:
				p = n
				n = 0
			else:
				n = 0
		elif i == a - 1:
			if b[i] >= b[i - 1]:
				n += 1
			if n > p:
				p = n
	if p == 0:
		print('1')
	else:
		print(p + 1)
if a == 1:
	print('1')


N = int(input())
A = [int(v) for v in input().split()]
M = 1
DP = [1] * N
for (i, n) in enumerate(A[1:], 1):
	if n >= A[i - 1]:
		DP[i] = 1 + DP[i - 1]
		M = max(M, DP[i])
print(M)


def IsBig(a, b):
	if a > b:
		return a
	else:
		return b

def main():
	n = int(input())
	arr = list(map(int, input().split()))
	mx = 1
	cnt = 1
	for i in range(1, n):
		if arr[i] >= arr[i - 1]:
			cnt += 1
		else:
			cnt = 1
		mx = IsBig(mx, cnt)
	print(mx)
main()


n = int(input())
l = list(map(int, input().split()))
m = []
s = 1
if n == 1:
	print(s)
else:
	for i in range(n - 1):
		if l[i] <= l[i + 1]:
			s += 1
		if l[i] > l[i + 1]:
			m.append(s)
			s = 1
		if i == n - 2:
			m.append(s)
	print(max(m))


n = int(input())
a = []
a.extend(map(int, input().split()))
b = 1
c = 1
for i in range(n - 1):
	if a[i] <= a[i + 1]:
		b += 1
	else:
		b = 1
	c = max(b, c)
print(c)


n = int(input())
money = [int(x) for x in input().split()]
t = tt = 1
for i in range(0, n - 1):
	if money[i] <= money[i + 1]:
		tt += 1
		if tt > t:
			t = tt
	else:
		tt = 1
print(t)


num = int(input())
l = input().split()
l = [int(x) for x in l]
c1 = 1
c2 = 1
for i in range(num - 1):
	if l[i] <= l[i + 1]:
		c1 += 1
	else:
		c1 = 1
	c2 = max(c1, c2)
print(c2)


curr_len = 0
prev = 0
max_len = 0
n = int(input())
a = list(map(int, input().split()))
for curr in range(n):
	if a[curr] >= a[prev]:
		curr_len += 1
	else:
		if curr_len > max_len:
			max_len = curr_len
		curr_len = 1
	prev = curr
if curr_len > max_len:
	max_len = curr_len
print(max_len)


import sys

def solver(a):
	prev = 1
	current = 0
	position = 0
	for x in a:
		if x >= position:
			current = current + 1
		else:
			current = 1
		if current > prev:
			prev = current
		position = x
	return prev

def main():
	lines = sys.stdin.readlines()
	print(solver(map(int, lines[1].split())))
main()


n = int(input())
l = list(map(int, input().split()))
l.append(0)
max_seq = 1
i = 0
curr_sub = 1
while i < n:
	if l[i] <= l[i + 1]:
		curr_sub += 1
	else:
		max_seq = max(max_seq, curr_sub)
		curr_sub = 1
	i += 1
print(max_seq)


n = int(input())
arr = list(map(int, input().split()))
nums = []
count = 1
for i in range(0, n):
	for j in range(i + 1, n):
		if arr[i] <= arr[j]:
			count += 1
			break
		else:
			nums.append(count)
			count = 1
			break
nums.append(count)
print(max(nums))


n = int(input())
a = list(map(int, input().split()))
maxx = 1
k = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		k = k + 1
	else:
		maxx = max(k, maxx)
		k = 1
maxx = max(k, maxx)
print(maxx)


n = int(input())
s = [int(x) for x in input().split()]
m = [1] * n
num = s[0]
for i in range(1, n):
	if s[i] >= num:
		m[i] = m[i - 1] + 1
	num = s[i]
print(max(m))


n = int(input())
arr = list(map(int, input().split()))
m = 1
j = 0
for i in range(1, n):
	if arr[i] < arr[i - 1]:
		m = max(m, i - j)
		j = i
m = max(m, n - j)
print(m, end='')


import sys

def ans(arr):
	final = 0
	maximum = -sys.maxsize
	count = 0
	for i in range(len(arr)):
		if arr[i] >= maximum:
			maximum = arr[i]
			count += 1
		else:
			final = max(final, count)
			count = 1
			maximum = arr[i]
	return max(final, count)
	pass
n = int(input())
arr = list(map(int, input().strip().split(' ')))
print(ans(arr))


n = int(input())
num = [int(i) for i in input().split()]
p = 0
t = 0
for i in range(n - 1):
	if num[i] <= num[i + 1]:
		p += 1
		t = max(p, t)
	else:
		p = 0
print(t + 1)


from sys import stdin
entrada = [int(x) for x in stdin.read().split()]
n = entrada.pop(0)
max = 1
curr_seq = 1
curr = False
for i in range(len(entrada)):
	if not curr:
		curr_seq = 1
		curr = True
	elif entrada[i - 1] <= entrada[i]:
		curr_seq += 1
	else:
		if curr_seq > max:
			max = curr_seq
		curr_seq = 1
if curr_seq > max:
	max = curr_seq
print(max)


n = int(input())
list1 = [int(x) for x in input().split()]
c = 1
d = []
for i in range(0, n - 1):
	if list1[i] <= list1[i + 1]:
		c = c + 1
	if list1[i] > list1[i + 1] or i == n - 2:
		d.append(c)
		c = 1
if len(d) == 1:
	print(d[0])
if len(d) == 0:
	print(1)
if len(d) != 1 and len(d) != 0:
	print(max(d))


TN = 1

def solution():
	n = int(input())
	a = list(map(int, input().split()))
	cur = a[0]
	ln = 0
	ans = []
	for i in range(n):
		if a[i] >= cur:
			ln += 1
		else:
			ans.append(ln)
			ln = 1
		cur = a[i]
	ans.append(ln)
	print(max(ans))
while TN != 0:
	solution()
	TN -= 1


input()
l = list((int(i) for i in input().split(' ')))
(t, k) = (1, 1)
for i in range(len(l) - 1):
	if l[i] <= l[i + 1]:
		t += 1
	else:
		k = t if t > k else k
		t = 1
k = t if t > k else k
print(k)


s = int(input())
f = 0
c = 0
x = list(map(int, input().split()))
for i in range(s - 1):
	if x[i] > x[i + 1]:
		c = 0
	else:
		c += 1
		if c > f:
			f = c
print(f + 1)


n = int(input())
arr = [int(i) for i in input().split()]
res = []
prev = -1
s = 0
for el in arr:
	if el >= prev:
		s += 1
	else:
		s = 1
	res.append(s)
	prev = el
m = -1
for el in res:
	if el > m:
		m = el
print(m)


n = int(input())
a = list(map(int, input().split()))
a.insert(0, 0)
f = [0] * (n + 1)
f[1] = 1
for i in range(2, n + 1):
	if a[i] >= a[i - 1]:
		f[i] = f[i - 1] + 1
	else:
		f[i] = 1
res = 0
for i in range(1, n + 1):
	res = max(res, f[i])
print(res)


n = int(input())
a = list(input().split())
maxSoFar = 0
currentMax = 0
currentElement = -1
for i in a:
	if int(i) >= currentElement:
		currentElement = int(i)
		currentMax += 1
	else:
		if maxSoFar < currentMax:
			maxSoFar = currentMax
		currentElement = int(i)
		currentMax = 1
if maxSoFar > currentMax:
	print(maxSoFar)
else:
	print(currentMax)


t = int(input())
k = 0
c = 0
l = list(map(int, input().split()))
for i in range(len(l) - 1):
	if l[i] <= l[i + 1]:
		c += 1
	else:
		c = 0
	if c > k:
		k = c
print(k + 1)


n = int(input())
lis = [int(x) for x in input().split()]
count = 1
countm = 0
for i in range(n - 1):
	if lis[i] <= lis[i + 1]:
		count += 1
	else:
		countm = max(countm, count)
		count = 1
countm = max(countm, count)
print(countm)


n = input()
seq = [int(x) for x in input().split()]
maxL = 0
prev = seq[0] - 1
currL = 0
for c in seq:
	if c >= prev:
		currL += 1
	else:
		if currL > maxL:
			maxL = currL
		currL = 1
	prev = c
if currL > maxL:
	maxL = currL
print(maxL)


def kefa_and_first_steps(n, a):
	cnt = 1
	k = 1
	c = a[0]
	for i in range(1, n):
		if a[i] >= a[i - 1]:
			cnt += 1
			if cnt > k:
				k = cnt
		else:
			c = a[i]
			cnt = 1
	return max(k, cnt)
n = int(input())
a = list(map(int, input().split()))
print(kefa_and_first_steps(n, a))


n = int(input())
valores = [int(e) for e in input().split(' ')]
len_max = 1
contador = 1
for i in range(len(valores) - 1):
	if valores[i] <= valores[i + 1]:
		contador += 1
		if contador > len_max:
			len_max = contador
	else:
		contador = 1
print(len_max)


input()
nums = list(map(int, input().split()))
max_seq = 1
cur_seq = 1
for i in range(1, len(nums)):
	if nums[i - 1] <= nums[i]:
		cur_seq += 1
	else:
		cur_seq = 1
	if cur_seq > max_seq:
		max_seq = cur_seq
print(max_seq)


n = int(input())
l = list(map(int, input().strip().split()))
a = 0
c = 1
for i in range(0, len(l) - 1):
	if l[i] <= l[i + 1]:
		c += 1
		a = max(a, c)
	else:
		a = max(a, c)
		c = 1
a = max(a, c)
print(a)


days = int(input())
gainedMoney = [int(i) for i in input().split(' ')]
increasingSubsequenceLength = 0
longestIncreasingSubsequenceLength = 0
lastGain = None
for (i, gain) in enumerate(gainedMoney):
	if i == 0:
		increasingSubsequenceLength = 1
		longestIncreasingSubsequenceLength = 1
	else:
		if gain >= lastGain:
			increasingSubsequenceLength += 1
		else:
			increasingSubsequenceLength = 1
			if longestIncreasingSubsequenceLength > days - i:
				break
		if increasingSubsequenceLength > longestIncreasingSubsequenceLength:
			longestIncreasingSubsequenceLength = increasingSubsequenceLength
	lastGain = gain
print(longestIncreasingSubsequenceLength)


n = int(input())
temp = input().split(' ')
record = []
for num in temp:
	record.append(int(num))
counts = 0
count = 1
for i in range(1, n):
	if record[i] >= record[i - 1]:
		count += 1
	else:
		if count > counts:
			counts = count
		count = 1
if count > counts:
	counts = count
print(counts)


n = int(input())
a = list(map(int, input().split()))
c = 1
ans = 1
for i in range(n - 1):
	if a[i + 1] >= a[i]:
		c += 1
	else:
		if c > ans:
			ans = c
		c = 1
	if i == n - 2 and c > ans:
		ans = c
print(ans)


tgh = int(input())
sdf = list(map(int, input().split()))
op = 1
m = 1
for k in range(0, tgh - 1):
	if sdf[k + 1] >= sdf[k]:
		op += 1
	else:
		if m < op:
			m = op
		op = 1
if m < op:
	m = op
print(m)


n = int(input())
a = [int(i) for i in input().split(' ')]
count = 0
last = 0
ans = 0
if len(a) == 1:
	print(last + 1)
	ans = 1
for j in range(len(a) - 1):
	if a[j] <= a[j + 1]:
		count += 1
		if count > last:
			last = count
	else:
		if count > last:
			last = count
		count = 0
if ans != 1:
	if last != 0:
		print(last + 1)
	else:
		print(1)


n = int(input())
arr = [int(x) for x in input().split()]
prev = arr[0]
ans = 1
c = 1
for i in range(1, n):
	if arr[i] >= arr[i - 1]:
		c += 1
	else:
		c = 1
	ans = max(ans, c)
print(ans)


X = []
N = int(input())
L = list(map(int, input().split()))
D = 1
for i in range(len(L) - 1):
	if L[i] <= L[i + 1]:
		D = D + 1
		X.append(D)
	else:
		X.append(D)
		D = 1
if len(X) == 0:
	print(1)
else:
	print(max(X))


n = int(input())
s = [int(x) for x in input().split()]
c = 0
store = 0
a = s[0]
for i in range(1, n):
	if a <= s[i]:
		c += 1
		store = max(c, store)
	else:
		c = 0
	a = s[i]
print(store + 1)


n = int(input())
a = [int(i) for i in input().split()]
(res, x, i) = (1, 1, 1)
while i < n:
	if a[i - 1] <= a[i]:
		x += 1
	else:
		x = 1
	if x > res:
		res = x
	i += 1
print(res)


no = int(input())
list_input = list(map(int, input().split()))
count = 1
p = 1
i = 1
while i < no:
	if list_input[i] >= list_input[i - 1]:
		count += 1
	else:
		if count > p:
			p = count
		count = 1
	if i == no - 1 and count > p:
		p = count
	i += 1
print(p)


a = int(input())
b = list(map(int, input().rstrip().split()))
cou = 0
ans = 0
for i in range(1, len(b)):
	if b[i] >= b[i - 1]:
		cou += 1
		ans = max(ans, cou)
	else:
		cou = 0
print(ans + 1)


i = input
i()
auxLis = maiorLis = anterior = 0
for j in i().split():
	novoValor = int(j)
	if novoValor >= anterior:
		auxLis = auxLis + 1
	else:
		auxLis = 1
	maiorLis = max(maiorLis, auxLis)
	anterior = novoValor
print(maiorLis)


N = int(input())
lst = map(int, input().split())
prev = 0
current = 0
prev_n = -float('inf')
for n in lst:
	if n >= prev_n:
		current += 1
	else:
		(prev, current) = (current if current > prev else prev, 1)
	prev_n = n
print(current if current > prev else prev)


a = int(input())
b = list(map(int, input().split()))
for i in range(a - 1):
	b[i] = b[i + 1] - b[i]
	if b[i] >= 0:
		b[i] = 1
	else:
		b[i] = 0
n = 0
m = 0
for i in range(a - 1):
	if b[i] == 1:
		n = n + 1
		if n > m:
			m = n
		else:
			continue
	else:
		n = 0
print(m + 1)


import sys
n = int(input())
x = input().split(' ')
if n == 1:
	print(1)
	sys.exit()
c = 1
X = []
j = 0
while j < n - 1:
	if int(x[j]) <= int(x[j + 1]):
		c += 1
	else:
		X.append(c)
		c = 1
	j += 1
	if j == n - 1:
		X.append(c)
print(max(X))


input()
l = [int(x) for x in input().split()]
c = 0
m = 0
v = None
for i in l:
	if v is None or i >= v:
		c += 1
	else:
		if c > m:
			m = c
		c = 1
	v = i
print(max(c, m))


def main():
	from sys import stdin, stdout
	n = int(stdin.readline())
	l = list(map(int, stdin.readline().split()))
	max_so_far = 1
	counter = 1
	for i in range(1, n):
		if l[i] >= l[i - 1]:
			counter += 1
		else:
			max_so_far = max(max_so_far, counter)
			counter = 1
	stdout.write(str(max(max_so_far, counter)))
main()


count = 0
flag = False
result = 0
n = int(input())
a = list(map(int, input().split()))
for i in range(1, n):
	if a[i - 1] > a[i]:
		flag = False
		count = 0
	else:
		flag = True
		count += 1
	if count > result:
		result = count
print(1 + result)


n = int(input())
a = list(map(int, input().split()))
p1 = 0
p2 = 1
c = 1
max = 0
while p1 < len(a) - 1:
	if a[p1] <= a[p2]:
		p1 += 1
		p2 += 1
		c += 1
	else:
		p1 = p2
		p2 = p1 + 1
		if max < c:
			max = c
		c = 1
	if max < c:
		max = c
if n == 1:
	print('1')
else:
	print(max)


def ii():
	return int(input())

def mi():
	return map(int, input().split())

def si():
	return [int(x) for x in input().split()]

def ss():
	return [x for x in input()]
a = ii()
s = si()
ans = 1
it = 1
for i in range(a - 1):
	if s[i] <= s[i + 1]:
		it += 1
		ans = max(ans, it)
	else:
		it = 1
print(ans)


n = int(input())
mas = list(map(int, input().split()))
otv = [1] * n
for i in range(1, len(mas)):
	if mas[i - 1] <= mas[i]:
		otv[i] = otv[i - 1] + 1
print(max(otv))


n = int(input())
w = input().split()
x = []
s = 1
m = []
for i in w:
	x.append(int(i))
if len(x) == 1:
	print(1)
else:
	for k in range(len(x) - 1):
		if x[k] <= x[k + 1]:
			s = s + 1
		else:
			s = 1
		m.append(s)
	print(max(m))


n = int(input())
a = [int(_) for _ in input().split()]
mx = 1
cur = 1
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		cur += 1
	else:
		mx = max(mx, cur)
		cur = 1
mx = max(mx, cur)
print(mx)


n = int(input())
a = list(map(int, input().split()))
b = [[a[0]]]
d = 0
for _ in range(1, len(a)):
	if a[_] >= a[_ - 1]:
		b[d].append(a[_])
	else:
		b.append([a[_]])
		d += 1
c = []
for _ in range(len(b)):
	c.append(len(b[_]))
print(max(c))


n = input()
seq = [int(x) for x in input().split()]
N = list()
s = 1
for i in range(1, len(seq)):
	if seq[i] < seq[i - 1]:
		N.append(s)
		s = 1
	else:
		s = s + 1
N.append(s)
print(max(N))


n = int(input())
s = 1
ma = 0
a = [int(x) for x in input().split()]
prev = a[0]
for i in range(1, n):
	x = a[i]
	if x < prev:
		if s > ma:
			ma = s
		s = 1
	else:
		s += 1
	prev = x
if s > ma:
	ma = s
print(ma)


def ras(n):
	(i, m) = (0, 0)
	b = []
	while i < len(a) - 1:
		if a[i + 1] >= a[i]:
			m = m + 1
			i = i + 1
		else:
			b.append(m)
			m = 0
			i = i + 1
	b.append(m)
	return max(b) + 1
n = int(input())
a = [int(n) for n in input().split()]
r = ras(n)
print(r)


from sys import stdin

def solve():
	n = int(input())
	A = [int(i) for i in stdin.readline().split()]
	if n == 1:
		return 1
	mx = 0
	c = 1
	for i in range(1, len(A)):
		if A[i] >= A[i - 1]:
			c += 1
		else:
			c = 1
		mx = max(mx, c)
	return mx
print(solve())


n = int(input())
a_list = [int(i) for i in input().split()]
max_pos = 0
cur_pos = 0
last_int = -1
for a in a_list:
	if a >= last_int:
		cur_pos += 1
		max_pos = cur_pos if cur_pos > max_pos else max_pos
	else:
		cur_pos = 1
	last_int = a
print(max_pos)


n = input()
n = int(n)
k = list(map(int, input().split()))
max_seq = 0
prev_value = 0
count = 0
for d in range(1, len(k)):
	prev_value = k[d - 1]
	if prev_value <= k[d]:
		count += 1
	else:
		count = 0
	max_seq = max(max_seq, count)
print(max_seq + 1)


_ = input()
nums = [int(c) for c in input().rstrip().split(' ')]
ans = 0
count = 0
prev = -1
for n in nums:
	if n >= prev:
		count += 1
		if count > ans:
			ans = count
	else:
		count = 1
	prev = n
print(ans)


a = int(input())
b = [int(x) for x in input().split(' ')]
max = 0
temp = 1
if a == 1:
	print(1)
	exit(0)
for x in range(1, len(b)):
	temp += 1
	if b[x] < b[x - 1]:
		temp = 1
	if max < temp:
		max = temp
print(max)


a = int(input())
b = list(map(int, input().split()))
finallist = []
if a == 1:
	print(1)
else:
	t = 0
	while t < a - 1:
		currlist = [b[t]]
		i = t
		while i < a - 1:
			if b[i + 1] >= b[i]:
				currlist.append(b[i + 1])
				i += 1
			else:
				break
		finallist.append(currlist)
		t = i + 1
	ans = len(finallist[0])
	for p in finallist:
		if len(p) > ans:
			ans = len(p)
	print(ans)


n = int(input())
a = [int(x) for x in input().strip().split()]

def get_count(i):
	count = 0
	e = a[i]
	while i < n - 1 and a[i + 1] >= e:
		i += 1
		count += 1
		e = a[i]
	return (count + 1, i)
i = 0
res = []
while i < n:
	(r, j) = get_count(i)
	res.append(r)
	i = j + 1
result = max(res)
print(result)


n = int(input())
arr = list(map(int, input().split()))
res = 1
i = 0
while i < n:
	len = 1
	while i + 1 < n and arr[i] <= arr[i + 1]:
		len += 1
		i += 1
	i += 1
	res = max(res, len)
print(res)


n = int(input())
ar = input().split()
ar[:] = [int(i) for i in ar]
c = 1
maxC = 0
if len(ar) == 1:
	print(1)
else:
	for i in range(len(ar) - 1):
		if ar[i] <= ar[i + 1]:
			c += 1
		if c > maxC:
			maxC = c
		if ar[i] > ar[i + 1]:
			c = 1
	print(maxC)


n = int(input())
quant = list(map(int, input().split()))
mlen = 0
tlen = 1
for i in range(1, n):
	if quant[i] < quant[i - 1]:
		mlen = max(mlen, tlen)
		tlen = 1
	else:
		tlen += 1
mlen = max(tlen, mlen)
print(mlen)


n = input()
(max1, dem) = (0, 0)
a = list(map(int, input().split()))
a.append(0)
for i in range(len(a) - 1):
	dem += 1
	if a[i + 1] < a[i]:
		max1 = max(dem, max1)
		dem = 0
print(max1)


n = int(input())
a = list(map(int, input().split()))
i = 1
k = 1
sa = 0
while i < n:
	if a[i - 1] <= a[i]:
		k = k + 1
	else:
		if sa < k:
			sa = k
		k = 1
	i = i + 1
if sa < k:
	sa = k
print(sa)


n = int(input())
l = list(map(int, input().split()))
s = 0
start = 0
end = 0
maxi = -1
for i in range(1, n):
	if l[i - 1] > l[i]:
		s = i
	if maxi < i - s + 1:
		maxi = i - s + 1
		start = s
		end = i
print(len(l[start:end + 1]))


n = int(input())
k = [int(i) for i in input().split()]
cnt = 1
maxi = 0
for i in range(1, n):
	if k[i] >= k[i - 1]:
		cnt += 1
	else:
		if maxi < cnt:
			maxi = cnt
		cnt = 1
if maxi < cnt:
	maxi = cnt
print(maxi)


n = int(input())
a = input().split()
z = []
for i in range(n):
	z.append(int(a[i]))
z.append(-1)
y = [1]
d = 0
while d < n - 1:
	c = 1
	for i in range(d, n):
		if z[i] <= z[i + 1]:
			c += 1
		else:
			y.append(c)
			d = i + 1
			break
print(max(y))


s = int(input())
a = [int(x) for x in input().split()]
q = 0
w = 0
for i in range(s - 1):
	if a[i] <= a[i + 1]:
		q += 1
		w = max(q, w)
	else:
		q = 0
print(w + 1)


n = int(input())
list = [int(x) for x in input().split()]
i = 0
c = 1
d = 1
while i < n - 1:
	if list[i] <= list[i + 1]:
		c = c + 1
		if c > d:
			d = c
	else:
		c = 1
	i = i + 1
print(d)


def _580A(profits):
	max_length = 0
	length = 0
	for index in range(1, len(profits)):
		if profits[index] >= profits[index - 1]:
			length += 1
			max_length = max(max_length, length)
		else:
			length = 0
	return max_length + 1
input()
profits = list(map(lambda x: int(x), input().split()))
print(_580A(profits))


(n, temp, i) = (int(input()), [1], 0)
list = [int(i) for i in input().split()]
while i < n - 1:
	count = 1
	while i < n - 1 and list[i] <= list[i + 1]:
		count += 1
		i += 1
	temp.append(count)
	i += 1
print(max(temp))


n = int(input())
l = list(map(int, input().split()))
lm = 1
gm = 1
for i in range(1, n):
	if l[i] >= l[i - 1]:
		lm += 1
	else:
		gm = max(gm, lm)
		lm = 1
gm = max(gm, lm)
print(gm)


n = int(input())
a = [int(i) for i in input().split()]
m = v = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		v += 1
	else:
		m = max(m, v)
		v = 1
print(max(m, v))


n = int(input())
arr = list(map(int, input().split()))
cnt = 1
k = []
for i in range(n - 1):
	if arr[i + 1] >= arr[i]:
		cnt += 1
		k.append(cnt)
	else:
		cnt = 1
if len(k) == 0:
	print(cnt)
else:
	print(max(k))


n = int(input())
s = list(map(int, input().split()))
c = 1
mx = 1
for i in range(n - 1):
	if s[i + 1] >= s[i]:
		c += 1
		if c > mx:
			mx = c
	else:
		c = 1
print(mx)


n = input()
m = [int(x) for x in input().split()]
p = 0
q = 0
o = 0
for i in m:
	if i >= o:
		o = i
		p = p + 1
		if p > q:
			q = p
	else:
		p = 1
		o = i
print(q)


n = int(input())
inputArrayString = input()
inputArray = list(map(int, inputArrayString.split(' ')))
finalMax = 1
currentMax = 1
for i in range(1, n):
	if inputArray[i] >= inputArray[i - 1]:
		currentMax += 1
	else:
		currentMax = 1
	if finalMax < currentMax:
		finalMax = currentMax
print(finalMax)


n = int(input())
nums = list(map(int, input().split()))
max_length = 1
length = 1
for i in range(n - 1):
	if nums[i + 1] < nums[i]:
		length = 1
	else:
		length += 1
		if max_length < length:
			max_length = length
if length > max_length:
	max_length = length
print(max_length)


input()
a = [int(t) for t in input().split()]
x = c = m = 0
for v in a:
	if v < x:
		m = max(m, c)
		c = 0
	x = v
	c += 1
print(max(m, c))


n = int(input())
(li1_, li_) = ([int(x) for x in input().split()], [])
(i, j, t) = (0, 1, 0)
while j < n:
	if li1_[j] >= li1_[j - 1]:
		(t, j) = (t + 1, j + 1)
	else:
		if t != 0:
			t = t + 1
		li_ += [t]
		(i, j) = (j, j + 1)
		t = 0
print(max(li_ + [t + 1]))


def lss(x):
	n = len(x)
	lis = [1 for i in range(n)]
	for i in range(1, n):
		if x[i] >= x[i - 1] and lis[i] < lis[i - 1] + 1:
			lis[i] = lis[i - 1] + 1
	a = max(lis)
	return a
t = int(input())
data = list(map(int, input().split()))
print(lss(data))


n = int(input())
s = [int(x) for x in input().strip().split()]
maxl = 1
i = 1
t = 1
while i < n:
	if s[i] >= s[i - 1]:
		t = t + 1
	else:
		t = 1
	if t > maxl:
		maxl = t
	i = i + 1
print(maxl)


n = int(input())
li = list(map(int, input().split()))
q = 1
li0 = [1]
for i in range(n - 1):
	if li[i] <= li[i + 1]:
		q += 1
		li0.append(q)
	else:
		q = 1
		li0.append(q)
print(max(li0))


n = int(input())
a = list(map(int, input().strip().split()))
start = 0
k = 1
p = 0
while start < n - 1:
	if a[start + 1] >= a[start]:
		k += 1
	else:
		if k > p:
			p = k
		k = 1
	start += 1
if k > p:
	p = k
print(p)


a = int(input())
b = input().split()
c = 1
d = []
d.append(c)
if a == 1:
	c = 1
else:
	for i in range(a - 1):
		if int(b[i]) <= int(b[i + 1]):
			c += 1
			d.append(c)
		else:
			c = 1
print(max(d))


from sys import stdin, stdout
import math, sys
from itertools import permutations, combinations
from collections import defaultdict, deque, OrderedDict
import bisect as bi
import heapq

def I():
	return int(stdin.readline())

def In():
	return map(int, stdin.readline().split())

def main():
	try:
		n = I()
		l = list(In())
		ma = 1
		ans = 0
		for i in range(1, n):
			if l[i] - l[i - 1] >= 0:
				ma += 1
			else:
				ans = max(ans, ma)
				ma = 1
		ans = max(ans, ma)
		print(ans)
	except:
		pass
M = 998244353
P = 1000000007
for _ in range(1):
	main()


n = int(input())
nums = [*map(int, input().split())]
(ans, cnt) = (0, 0)
prev = 0
for num in nums:
	if prev > num:
		ans = max(ans, cnt)
		cnt = 1
		prev = num
	else:
		cnt += 1
		prev = num
ans = max(ans, cnt)
print(ans)


n = int(input())
lst = list(map(int, input().split()))
lst1 = []
ns = 0
for i in range(n - 1):
	if lst[i + 1] >= lst[i]:
		ns += 1
	else:
		lst1.append(ns + 1)
		ns = 0
lst1.append(ns + 1)
lst1 = sorted(lst1, reverse=True)
if lst1 != []:
	print(lst1[0])


inp = int(input())
n = input().split()
c = 0
mx = 0
for i in range(len(n) - 1):
	if int(n[i]) <= int(n[i + 1]):
		c += 1
		if mx < c:
			mx = c
	else:
		c = 0
print(mx + 1)


import sys
input = sys.stdin.readline
a = int(input())
z = list(map(int, input().split()))
dp = [1]
for i in range(1, len(z)):
	if z[i] >= z[i - 1]:
		dp.append(dp[-1] + 1)
	else:
		dp.append(1)
print(max(dp))


n = int(input())
a = [int(x) for x in input().split()]
(d, c) = ([], 1)
for i in range(len(a) - 1):
	if a[i] <= a[i + 1]:
		c += 1
	else:
		d.append(c)
		c = 1
d.append(c)
print(max(d) if d else 1)


n = int(input())
list = [int(i) for i in input().split()]
dp = [None] * n
for i in range(n):
	dp[i] = 0
for i in range(n - 1, -1, -1):
	if i == n - 1:
		dp[n - 1] = 1
	elif list[i] <= list[i + 1]:
		dp[i] = 1 + dp[i + 1]
	else:
		dp[i] = 1
max = dp[0]
for i in dp:
	if i > max:
		max = i
print(max)


import sys
inf = float('inf')
mod = 1000000007

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

def input():
	return sys.stdin.readline()

def get_ints():
	return map(int, sys.stdin.readline().split())

def main():
	n = int(input())
	arr = get_array()
	curr_max = 1
	mx = 1
	for i in range(1, n):
		if arr[i] >= arr[i - 1]:
			curr_max += 1
			mx = max(curr_max, mx)
		else:
			curr_max = 1
	print(mx)
main()


n = int(input())
ans = 1
a = 1
ar = list(map(int, input().split()))
n -= 1
i = 1
while n > 0:
	n -= 1
	p = ar[i - 1]
	q = ar[i]
	i += 1
	if q >= p:
		a += 1
		ans = max(a, ans)
	else:
		a = 1
print(ans)


n = int(input())
ar = [int(i) for i in input().split()]
ans = -123456789
c = 1
for i in range(n - 1):
	if ar[i + 1] >= ar[i]:
		c += 1
		ans = max(ans, c)
	else:
		c = 1
if ans == -123456789:
	print('1')
else:
	print(ans)


n = int(input())
arr = list(map(int, input().split()))
cur_seq = 1
max_seq = 1
for k in range(1, n):
	if arr[k] < arr[k - 1]:
		cur_seq = 1
	else:
		cur_seq += 1
	if cur_seq > max_seq:
		max_seq = cur_seq
print(max_seq)


t = int(input())
b = [int(s) for s in input().split()]
k = 0
max = 1
while k != t:
	s = 1
	k += 1
	while k != t:
		if b[k] >= b[k - 1]:
			k += 1
			s += 1
		else:
			break
	if s > max:
		max = s
print(max)


n = int(input())
numList = [int(x) for x in input().split()]
cnt = 0
maxnum = 1
for i in range(n):
	if i == 0:
		cnt = 1
	elif numList[i] >= numList[i - 1]:
		cnt += 1
		if i == n - 1 and cnt > maxnum:
			maxnum = cnt
	else:
		if cnt > maxnum:
			maxnum = cnt
		cnt = 1
print(maxnum)


def solve(l, n, s, t):
	for j in range(n - 1):
		if l[j] <= l[j + 1]:
			t += 1
		else:
			if t > s:
				s = t
			t = 1
	print(max(s, t), end='')
n = int(input())
l = list(map(int, input().split()))
(s, t) = (1, 1)
solve(l, n, s, t)


n = int(input())
v = list(map(int, input().split()))
sol = x = 1
for i in range(1, n):
	if v[i - 1] <= v[i]:
		x += 1
		sol = max(x, sol)
	else:
		x = 1
print(sol)


input()
t = input().split()
results = list(map(int, t))
prev = results[0]
retVal = 0
count = 0
for x in range(len(results) - 1):
	curr = results[x + 1]
	if prev <= curr:
		count = count + 1
		if count >= retVal:
			retVal = count
	else:
		count = 0
	prev = curr
print(retVal + 1)


n = int(input())
t = list(map(int, input().split()))
s = []
u = 0
for j in range(n - 1):
	if t[j + 1] >= t[j]:
		u += 1
	else:
		s.append(u + 1)
		u = 0
s.append(u + 1)
print(max(s))


n = int(input())
dias = input().split(' ')
presente = 1
pasado = 1
i = 1
while i < n:
	if int(dias[i]) >= int(dias[i - 1]):
		presente += 1
	else:
		if presente > pasado:
			pasado = presente
		presente = 1
	i += 1
if presente > pasado:
	pasado = presente
print(pasado)


n = int(input())
list1 = input().split()
list1 = list(map(int, list1))
list2 = []
list3 = []
c1 = c2 = 0
for i in range(0, n - 1):
	if list1[i] <= list1[i + 1]:
		i += 1
	else:
		list2.append(i + 1)
		i += 1
list2.append(n)
m = len(list2)
if m == 1:
	print(n)
else:
	for j in range(0, m - 1):
		list3.append(list2[j + 1] - list2[j])
		j += 1
	list3.append(list2[0])
	print(max(list3))


a = input()
b = [int(e) for e in input().split()]
s = 0
max = 1
all = 1
while True:
	if s == len(b) - 1:
		break
	if b[s + 1] >= b[s]:
		max += 1
		all = max if max > all else all
	else:
		max = 1
	s += 1
print(all)


days = int(input())
money = input()
list_money = money.split(' ')
list_money = [int(i) for i in list_money]
seg = 1
maxseg = 1
i = 1
while i < len(list_money):
	if list_money[i] >= list_money[i - 1]:
		seg = seg + 1
	else:
		seg = 1
	if seg > maxseg:
		maxseg = seg
	i = i + 1
print(maxseg)


n = int(input())
a = list(map(int, input().split()))
m = former = c = 0
for i in a:
	if i >= former:
		c = c + 1
	else:
		c = 1
	m = max(m, c)
	former = i
print(m)


n = int(input())
c = list(map(int, input().split()))
m = 0
count = 0
y = 0
flag = 0
for i in range(0, len(c)):
	if c[i] >= y:
		count = count + 1
		y = c[i]
		if count > m:
			m = count
	else:
		count = 1
		y = c[i]
print(m)


def basic(n, arr):
	dp = [1] * n
	for i in range(1, n):
		if arr[i] >= arr[i - 1]:
			dp[i] = dp[i - 1] + 1
	return max(dp)
n = int(input())
arr = list(map(int, input().split(' ')))
print(basic(n, arr))


__author__ = 'Utena'
n = int(input())
l = list(map(int, input().split()))
t = 1
t1 = 0
for i in range(n - 1):
	t1 += 1
	if l[i] > l[i + 1]:
		if t1 > t:
			t = t1
		t1 = 0
if l[n - 1] >= l[n - 2]:
	t1 += 1
	if t1 > t:
		t = t1
print(t)


while True:
	try:
		num = int(input())
		l = [int(i) for i in input().split()]
		a = b = 1
		for i in range(1, num):
			if l[i] - l[i - 1] >= 0:
				b += 1
			else:
				b = 1
			a = max(a, b)
		print(a)
	except EOFError:
		break


n = int(input())
e = list(map(int, input().split()))
i = 0
new = 0
while i < n:
	(temp, c) = (0, 0)
	for j in range(i, n):
		if e[j] >= temp:
			c += 1
			temp = e[j]
			i += 1
		else:
			i = j
			break
	if new < c:
		new = c
print(new)


n = int(input())
lst = [int(x) for x in input().split()]
(count, max) = (1, 1)
for i in range(n - 1):
	if lst[i] <= lst[i + 1]:
		count += 1
	else:
		count = 1
	if max < count:
		max = count
print(max)


n = int(input())
arr = [int(i) for i in input().split()]
arr.append(0)
pre_ans = 0
ans = 0
for i in range(n):
	if arr[i] > arr[i + 1]:
		pre_ans += 1
		if pre_ans > ans:
			ans = pre_ans
		pre_ans = 0
	else:
		pre_ans += 1
if ans == 0:
	print(pre_ans)
else:
	print(ans)


n = int(input())
A = list(map(int, input().split()))
max_len = 1
ticker = 1
for i in range(len(A) - 1):
	if A[i] <= A[i + 1]:
		ticker += 1
	elif A[i] > A[i + 1]:
		ticker = 1
	if ticker > max_len:
		max_len = ticker
print(max_len)


__author__ = 'runekri3'
n = int(input())
incomes = list(map(int, input().split()))
last_income = incomes.pop(0)
cur_len = 1
max_len = 1
for income in incomes:
	if income >= last_income:
		cur_len += 1
	else:
		if cur_len > max_len:
			max_len = cur_len
		cur_len = 1
	last_income = income
if cur_len > max_len:
	max_len = cur_len
print(max_len)


n = int(input())
l = input().split()
counter = 1
ans = 1
for i in range(1, n):
	if int(l[i]) >= int(l[i - 1]):
		counter += 1
		if counter > ans:
			ans = counter
	else:
		counter = 1
print(ans)


def kefa(s):
	longest = 0
	current = 0
	prev = -float('inf')
	for n in s:
		if n >= prev:
			current = current + 1
			longest = max(current, longest)
		else:
			current = 1
		prev = n
	return longest
input()
s = map(int, input().split(' '))
print(kefa(s))


n = int(input())
a = list(map(int, input().split()))
c = 0
res = 0
last = -1
for i in a:
	if i >= last:
		c += 1
	else:
		res = max(c, res)
		c = 1
	last = i
print(max(c, res))


n = int(input())
a = input().split(' ')
c = 0
out = 0
for i in range(n - 1):
	if int(a[i]) <= int(a[i + 1]):
		c += 1
		if c > out:
			out = c
	else:
		c = 0
print(out + 1)


n = int(input())
d = list(map(int, input().split()))
ans = 0
m = list()
t = d[0]
for i in d:
	if i >= t:
		ans += 1
	else:
		m.append(ans)
		ans = 1
	t = i
m.append(ans)
print(max(m))


n = int(input())
l = [int(i) for i in input().split(' ')]
c = 1
m = []
if len(l) == 1:
	print(1)
else:
	for j in range(len(l) - 1):
		if l[j] <= l[j + 1]:
			c += 1
		else:
			c = 1
		m.append(c)
	print(max(m))


_ = input()
s = list(map(int, input().split()))
maxi = 1
count = 1
for i in range(1, len(s)):
	if s[i] >= s[i - 1]:
		count += 1
		if count > maxi:
			maxi = count
	else:
		count = 1
print(maxi)


count = 0
x = int(input())
y = 0
first = True
numbers = [int(num) for num in input().split()]
for index in range(1, x):
	before = numbers[index - 1]
	now = numbers[index]
	if now >= before and first:
		first = False
		count += 2
		if count >= y:
			y = count
	elif now >= before and (not first):
		count += 1
		if count >= y:
			y = count
	else:
		first = True
		count = 0
if x == 1 or (y == 0 and x >= 100):
	y = 1
print(y)


n = int(input())
arr = list(map(int, input().split()))
curr = arr[0]
l = 1
ans = 1
for i in range(1, n):
	if arr[i] >= curr:
		l += 1
	else:
		if ans < l:
			ans = l
		l = 1
	curr = arr[i]
if l > ans:
	print(l)
else:
	print(ans)


def main():
	from sys import stdin, stdout
	write = stdout.write
	tokens = map(int, stdin.read().split())
	N = next(tokens)
	A = list(tokens)
	dp = [0] * N
	dp[0] = 1
	ans = 1
	for i in range(1, N):
		if A[i - 1] <= A[i]:
			dp[i] = dp[i - 1] + 1
		else:
			dp[i] = 1
		ans = max(ans, dp[i])
	write(str(ans))
main()


maxa = 0
N = int(input())
a = list((int(i) for i in input().split()))
current = 0
while current < N:
	current += 1
	length = 1
	while current < N and a[current] >= a[current - 1]:
		length += 1
		current += 1
	if length > maxa:
		maxa = length
print(maxa)


x = int(input())
a = [int(i) for i in input().split()]
(k, ans) = (0, list())
for i in range(x - 1):
	if a[i] <= a[i + 1]:
		k += 1
	else:
		ans.append(k)
		k = 0
ans.append(k)
print(max(ans) + 1)


a = input()
a = list(map(int, input().split()))
c = 1
cm = 1
for j in range(1, len(a)):
	i = a[j]
	c += 1
	if i < a[j - 1]:
		c = 1
	cm = max(c, cm)
print(cm)


n = int(input())
seq = list(map(int, input().split()))
new = []
a = 1
for i in range(n - 1):
	if seq[i] <= seq[i + 1]:
		a += 1
		continue
	elif seq[i] > seq[i + 1]:
		new.append(a)
		a = 1
new.append(a)
print(max(new))


n = int(input())
l = input().split()
for i in range(n):
	l[i] = int(l[i])
(p, q) = (0, 0)
i = 0
k = []
while i < n:
	p = 0
	while i + 1 < n and l[i] <= l[i + 1]:
		p += 1
		i += 1
	p += 1
	if p > q:
		q = p
	i += 1
print(q)


import math
elem = int(input())
ar = []
maxCurr = 0
curr = 0
count = 0
for x in input().split(' '):
	temp = int(x)
	if temp >= curr:
		curr = temp
		count = count + 1
	else:
		if count > maxCurr:
			maxCurr = count
		curr = temp
		count = 1
if count > maxCurr:
	maxCurr = count
print(maxCurr)


days = int(input())
win = [int(x) for x in input().split()]
m = 0
first = 0
last = 0
for i in range(days - 1):
	if i == days - 2 and win[i] <= win[i + 1]:
		last = i + 1
	if win[i] > win[i + 1]:
		last = i
		if last - first + 1 > m:
			m = last - first + 1
		first = i + 1
if last - first + 1 > m:
	m = last - first + 1
print(m)


n = int(input())
a = input().split()
counts = []
count = 1
for i in range(n):
	a[i] = int(a[i])
for i in range(1, n):
	number = a[i]
	pnumber = a[i - 1]
	if number >= pnumber:
		count = count + 1
	else:
		counts.append(count)
		count = 1
counts.append(count)
print(max(counts))


a = int(input())
i = list(map(int, input().split()))
b = len(i)
c = 1
d = 1
e = []
if a != len(i):
	y = 0
if a == len(i):
	while b > c:
		if i[c] >= i[c - 1]:
			d = d + 1
			c = c + 1
		else:
			e.append(d)
			d = 1
			c = c + 1
e.append(d)
e.sort()
j = len(e)
print(e[j - 1])


in0 = int(input())
(in1, in2, in3) = (0, 0, 0)
in4 = [int(x) for x in input().split()]
for x in in4:
	if x >= in1:
		in1 = x
		in2 += 1
	else:
		in1 = x
		if in2 > in3:
			in3 = in2
		in2 = 1
if in2 > in3:
	in3 = in2
print(in3)


n = int(input())
s = list(map(int, input().split()))
i = 0
m = a = 1
while i < n - 1:
	if s[i + 1] < s[i]:
		a = 1
	else:
		a = a + 1
	if m < a:
		m = a
	i = i + 1
print(m)


n = int(input())
moneylist = list(map(int, input().split(' ')))
start = 1
maxm = 1
count = 1
while start < n:
	if moneylist[start] >= moneylist[start - 1]:
		count += 1
	else:
		count = 1
	if count > maxm:
		maxm = count
	start += 1
print(maxm)


n = int(input())
arr = [int(x) for x in input().split(' ')]
max_len = 1
l = len(arr)
curr_len = 1
for i in range(1, l):
	if arr[i] >= arr[i - 1]:
		curr_len += 1
	else:
		max_len = max(max_len, curr_len)
		curr_len = 1
max_len = max(max_len, curr_len)
print(max_len)


n = int(input())
profit = list(map(int, input().split()))
maxCount = 1
count = 1
if n > 1:
	for i in range(1, n):
		if profit[i] >= profit[i - 1]:
			count += 1
		elif profit[i] < profit[i - 1]:
			count = 1
		if maxCount < count:
			maxCount = count
print(maxCount)


n = input()
k = list(map(int, input().split(' ')))
x = 0
s = 0
b = []
for i in range(len(k) - 1):
	if k[i] <= k[i + 1]:
		x += 1
		b.append(x)
	elif k[i] > k[i + 1]:
		x = 0
for i in b:
	if s < i:
		s = i
print(s + 1)


def kefaStep(arr, n):
	dp = [0] * (n + 1)
	dp[0] = 0
	s = m = 0
	for i in range(n):
		if arr[i] >= m:
			s += 1
			dp[i + 1] = max(dp[i], s)
		else:
			dp[i + 1] = dp[i]
			s = 1
		m = arr[i]
	return dp[n]
n = int(input())
arr = list(map(int, input().split()))
print(kefaStep(arr, n))


m = int(input())
n = [int(i) for i in input().split()]
ans = 0
mx = 0
for i in range(m - 1):
	if n[i] <= n[i + 1]:
		mx += 1
	else:
		ans = max(ans, mx)
		mx = 0
ans = max(ans, mx)
print(ans + 1)


def lis(arr):
	count = 1
	local = 1
	Temp = arr[0]
	for val in arr[1:]:
		if val >= Temp:
			local += 1
			Temp = val
		else:
			Temp = val
			local = 1
		if local > count:
			count = local
	return count
input()
A = list(map(int, input().split()))
print(lis(A))


import sys
input = sys.stdin.readline
prnt = sys.stdout.write
n = int(input())
a = list(map(int, input().split()))
res = 1
mx = 1
for i in range(1, n):
	if a[i] < a[i - 1]:
		mx = max(res, mx)
		res = 1
	else:
		res += 1
mx = max(res, mx)
prnt(str(mx))


from sys import stdin, stdout
n = stdin.readline()
n = int(n)
l = list(map(int, stdin.readline().split()))
count = 1
c = []
for i in range(n - 1):
	if l[i + 1] >= l[i]:
		count += 1
	else:
		c.append(count)
		count = 1
if not c or count > max(c):
	stdout.write(str(count) + '\n')
else:
	stdout.write(str(max(c)) + '\n')


n = int(input())
a = list(map(int, input().split()))
count = 1
key = a[0]
result = []
for i in range(1, len(a)):
	if a[i] >= key:
		count += 1
	else:
		result.append(count)
		count = 1
	key = a[i]
else:
	result.append(count)
print(max(result))


db = []
x = int(input())
data = input().split(' ')[:x]
counter = []
count = 1
prev = 10000000000
for i in data:
	if int(i) >= prev:
		count = count + 1
	else:
		counter.append(count)
		count = 1
	prev = int(i)
counter.append(count)
high = 0
for cc in counter:
	if cc > high:
		high = cc
count = high
print(high)


count = int(input())
nums = list(map(lambda x: int(x), input().split(' ')))
lenght_max = 0
lenght = 1
if count == 1:
	lenght_max = 1
for i in range(count - 1):
	if nums[i] <= nums[i + 1]:
		lenght += 1
	else:
		if lenght > lenght_max:
			lenght_max = lenght
		lenght = 1
	if lenght > lenght_max:
		lenght_max = lenght
print(lenght_max)


n = int(input())
a = [int(x) for x in input().split()]
l = 0
r = 1
m = 1
while r < len(a):
	if l == r or a[r] >= a[r - 1]:
		r += 1
		m = max(r - l, m)
	else:
		l += 1
print(m)


n = int(input())
l = list(map(int, input().split()))
count = 1
count_1 = 1
for i in range(1, len(l)):
	if l[i] >= l[i - 1]:
		count_1 += 1
		if count_1 > count:
			count = count_1
	else:
		count_1 = 1
print(count)


n = int(input())
s = list(map(int, input().split()))
cnt = 1
cnt_max = 1
if n > 1:
	for i in range(1, n):
		if s[i] >= s[i - 1]:
			cnt += 1
			if cnt > cnt_max:
				cnt_max = cnt
		else:
			cnt = 1
	print(cnt_max)
else:
	print(n)


n = int(input())
nums = [int(j) for j in input().split()]
output = 0
pointer = 0
while pointer < n:
	(sub_pointer, length) = (pointer, 0)
	prev = nums[pointer]
	while sub_pointer < n:
		if prev <= nums[sub_pointer]:
			sub_pointer += 1
			length += 1
			prev = nums[sub_pointer - 1]
		else:
			break
	pointer = sub_pointer
	output = max(length, output)
print(output)


n = int(input())
a = list(map(int, input().split()))
length = 1
max_length = 1
i = 1
while i < len(a):
	if a[i] >= a[i - 1]:
		length += 1
	else:
		length = 1
	if length > max_length:
		max_length = length
	i += 1
print(max_length)


n = int(input())
global_count = 0
array = [int(x) for x in input().split(' ')]
count = 1
for x in range(len(array) - 1):
	if array[x] <= array[x + 1]:
		count = count + 1
	else:
		if global_count < count:
			global_count = count
		count = 1
if global_count < count:
	global_count = count
print(global_count)


n = int(input())
pr = list(map(int, input().split()))
c = 0
z = []
if n == 1:
	print(n)
else:
	for x in range(n - 1):
		if pr[x] <= pr[x + 1]:
			c += 1
			z.append(c + 1)
		else:
			c = 1
			z.append(c)
			c = 0
	print(max(z))


N = int(input())
arr = input()
l = list(map(int, arr.split(' ')))
dp = [1] * N
for i in range(1, N):
	if l[i] >= l[i - 1]:
		dp[i] = dp[i - 1] + 1
max = 0
for i in range(1, N):
	if dp[max] < dp[i]:
		max = i
print(dp[max])


n = int(input())
len = 1
max_len = 1
a = [int(i) for i in input().split()]
last = a[0]
first = a[0]
for i in range(1, n):
	x = a[i]
	if x >= last:
		len += 1
		if len > max_len:
			max_len = len
	else:
		first = x
		len = 1
	last = x
print(max_len)


def fun():
	size = int(input())
	values = [int(x) for x in input().split()]
	start = 0
	end = 0
	extra = 0
	while end < size:
		if end + 1 < size and values[end + 1] >= values[end]:
			end += 1
		else:
			temp = end - start + 1
			if temp > extra:
				extra = temp
			start = end + 1
			end = end + 1
	return extra
print(fun())


n = int(input())
line = [int(x) for x in input().split()]
cut = []
for i in range(1, n):
	x = line[i] - line[i - 1]
	cut.append(x)
d = 0
D = 0
for i in range(n - 1):
	if cut[i] >= 0:
		D += 1
	else:
		d = max(d, D)
		D = 0
d = max(d, D)
print(d + 1)


input_s = input()
input_l = input().split(' ')
before = 0
max_mount = 1
now_mount = 0
for l in input_l:
	if int(l) >= before:
		now_mount += 1
		max_mount = max(now_mount, max_mount)
	else:
		now_mount = 1
	before = int(l)
print(max_mount)


n = int(input())
a = [int(i) for i in input().split()]
max_len = 0
current_len = 0
previous_number = 0
for e in a:
	if e >= previous_number:
		current_len += 1
		previous_number = e
	else:
		if current_len > max_len:
			max_len = current_len
		current_len = 1
		previous_number = e
if current_len > max_len:
	max_len = current_len
print(max_len)


def kefa(x):
	d = 0
	e = 1
	f = []
	mayor = 1
	for i in range(len(x) - 1):
		if x[i] <= x[i + 1]:
			e = e + 1
			f.append(e)
		else:
			f.append(e)
			e = 1
	for j in range(len(f)):
		if mayor < f[j]:
			mayor = f[j]
	return mayor
n = int(input())
x = list(map(int, input().split()))
kefa = kefa(x)
print(kefa)


n = int(input())
days = list((int(x) for x in input().split()))
days.append(0)
t = 0
pics = []
for i in range(n):
	if days[i + 1] < days[i]:
		t = t + 1
		pics.append(t)
		t = 0
	else:
		t = t + 1
print(max(pics))


n = int(input())
mass = [int(s) for s in input().split()]
sum = 1
k = 1
for i in range(1, len(mass)):
	if mass[i] - mass[i - 1] < 0:
		sum = max(sum, k)
		k = 1
	else:
		k = k + 1
sum = max(sum, k)
print(sum)


n = int(input())
a = [int(elem) for elem in input().split()]
i = 1
counter = 0
max_counter = float('-inf') if n != 1 else 0
while i < n:
	if a[i] >= a[i - 1]:
		counter += 1
	else:
		counter = 0
	if counter > max_counter:
		max_counter = counter
	i += 1
print(max_counter + 1)


n = int(input())
A = list(map(int, input().split()))
(length, max_length, prev) = (1, 1, A[0])
for i in range(1, n):
	if prev > A[i]:
		max_length = max(length, max_length)
		length = 1
	else:
		length += 1
	prev = A[i]
print(max(length, max_length))


n = int(input())
seq = [int(x) for x in input().split()]
rec = [1] * n
count = 1
for i in range(n - 1):
	if seq[i + 1] >= seq[i]:
		count += 1
	else:
		count = 1
	rec[i + 1] = count
print(max(rec))


n = int(input())
A = list((int(i) for i in input().split(' ')))
prev = 0
count = 1
for i in range(1, n):
	if A[i] >= A[i - 1]:
		count += 1
	else:
		if count > prev:
			prev = count
		count = 1
if count > prev:
	print(count)
else:
	print(prev)


n = int(input())
m = list(map(int, input().split()))
progress = 1
bestprogress = 1
for i in range(n - 1):
	if m[i + 1] >= m[i]:
		progress += 1
	else:
		bestprogress = max(bestprogress, progress)
		progress = 1
bestprogress = max(progress, bestprogress)
print(bestprogress)


import sys
from sys import stdin, stdout
n = int(input())
list = [int(x) for x in stdin.readline().rstrip().split()]
last_value = list[0]
count = 0
index = 0
max_count = 0
while index < len(list):
	if list[index] >= last_value:
		count += 1
		last_value = list[index]
		index += 1
	else:
		count = 0
		last_value = list[index]
	max_count = max(max_count, count)
print(max_count)


n = int(input())
k = list(map(int, input().split()))
cnt = 1
maxC = 0
for i in range(len(k) - 1):
	if k[i] > k[i + 1]:
		if cnt > maxC:
			maxC = cnt
		cnt = 1
	else:
		cnt = cnt + 1
if cnt > maxC:
	maxC = cnt
print(maxC)


step = int(input())
days = input().rsplit(' ', step)
max = 1
counter = 1
for i in range(step - 1):
	if int(days[i]) <= int(days[i + 1]):
		counter += 1
		if counter > max:
			max = counter
	else:
		counter = 1
print(max)


valor = int(input())
lista = input().split()
for i in range(len(lista)):
	lista[i] = int(lista[i])
y = 0
soma = 0
final = 0
for x in lista:
	if x >= y:
		soma = soma + 1
	elif soma > final:
		final = soma
		soma = 1
	else:
		soma = 1
	y = x
if soma > final:
	final = soma
print(final)


int(input())
q = [int(x) for x in input().split()]
mseq = 1
ans = 0
for i in range(len(q) - 1):
	if q[i] <= q[i + 1]:
		mseq += 1
	else:
		if ans < mseq:
			ans = mseq
		mseq = 1
if ans < mseq:
	ans = mseq
print(ans)


n = int(input())
s = list(map(int, input().split()))
cnt = mx = 1
for i in range(n - 1):
	if s[i] <= s[i + 1]:
		cnt += 1
	mx = max(cnt, mx)
	if s[i] > s[i + 1]:
		cnt = 1
print(mx)


n = int(input())
a = [int(x) for x in input().split()]
result = 1
current = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		current += 1
	else:
		result = max(result, current)
		current = 1
result = max(result, current)
print(result)


n = int(input())
a = list(map(int, input().split()))
ans = 1
i = 0
while i < n - 1:
	c = 1
	for j in range(i, n - 1):
		if a[j] <= a[j + 1]:
			c += 1
		else:
			break
	i = j + 1
	ans = max(ans, c)
print(ans)


import time
n = int(input())
A = [int(i) for i in input().split()]
start = time.time()
ans = 1
now = 1
for i in range(1, n):
	if A[i] < A[i - 1]:
		if ans < now:
			ans = now
		now = 1
	else:
		now += 1
if ans < now:
	ans = now
print(ans)
finish = time.time()


n = int(input())
l = 0
last = 0
length = 0
for i in map(int, input().split()):
	if i >= last:
		l += 1
	else:
		if length < l:
			length = l
		l = 1
	last = i
if length < l:
	length = l
print(length)


input()
(m, streak, last) = (0, 0, 0)
for number in input().split():
	if int(number) >= last:
		streak += 1
	else:
		m = max(m, streak)
		streak = 1
	last = int(number)
print(max(m, streak))


size = int(input())
string = list(map(int, input().split()))
(start, head, seq) = (0, 0, [1])
for x in range(1, size):
	if string[head] > string[x]:
		seq.append(head - start + 1)
		start = x
	head += 1
seq.append(head - start + 1)
print(max(seq))


input()
count = mx = 1
a = 12 ** 12
for i in map(int, input().split()):
	if i < a:
		count = 1
	else:
		count += 1
	mx = max(mx, count)
	a = i
print(mx)


if 1 == 1:
	if 1 == 1:
		n = int(input())
		a = [x for x in input().split()]
		num = []
		for i in range(n):
			num.append(int(a[i]))
		step = 0
		long = 0
		while step < n:
			j = step
			if j == n - 1:
				if long == 0:
					long = 1
				break
			tem = 0
			yan = 0
			while step < n:
				if num[step] >= num[j]:
					num[j] = num[step]
					tem += 1
					step += 1
				else:
					yan = 1
					break
			if tem > long:
				long = tem
			if j < n - 1 and step == n:
				break
		print(long)


n = input()
n = int(n)
A = [int(x) for x in input().split(' ')]
i = 0
max = 1
len = 1
while i < n - 1:
	if A[i + 1] >= A[i]:
		len += 1
	else:
		if len > max:
			max = len
		len = 1
	i += 1
if len > max:
	print(len)
else:
	print(max)


def solve(seq):
	dp = [1] * len(seq)
	for x in range(1, len(seq)):
		dp[x] = dp[x - 1] + 1 if seq[x] >= seq[x - 1] else dp[x]
	return max(dp)
n = int(input())
sequence = [int(x) for x in input().split()]
print(solve(sequence))


n = int(input(''))
a = [int(x) for x in input('').split()]
diff = []
longest_positive = 1
current_positive = 1
for i in range(n - 1):
	if a[i + 1] >= a[i]:
		current_positive += 1
		if current_positive > longest_positive:
			longest_positive = current_positive
	else:
		current_positive = 1
print(longest_positive)


n = int(input())
money = [int(x) for x in input().split()]
a = 1
day = []
for i in range(1, n):
	if money[i] >= money[i - 1]:
		a += 1
	elif money[i] < money[i - 1]:
		day.append(a)
		a = 1
day.append(a)
print(max(day))


days = int(input())
earnings = list(map(lambda x: int(x), input().split()))
counter = 1
result = 1
for day in range(days - 1):
	if earnings[day + 1] >= earnings[day]:
		counter += 1
		if day == days - 2:
			if counter > result:
				result = counter
	else:
		if counter > result:
			result = counter
		counter = 1
print(result)


i = input
n = int(i())
m = list(map(int, i().split()))
c = 1
a = []
for i in range(n):
	if i + 1 == n:
		a.append(c)
		break
	elif m[i] <= m[i + 1]:
		c += 1
	else:
		a.append(c)
		c = 1
print(n if a == [] else max(a))


Days = int(input())
PayChecks = input().split(maxsplit=Days - 1)
lg = 1
lgm = 1
for i in range(1, Days):
	if int(PayChecks[i]) >= int(PayChecks[i - 1]):
		lg += 1
	else:
		lgm = max(lg, lgm)
		lg = 1
lgm = max(lg, lgm)
print(str(lgm))


n = int(input())
x = list(map(int, input().split()))
temp = 1
hasil = 1
for i in range(1, n):
	if x[i - 1] <= x[i]:
		temp += 1
	else:
		temp = 1
	if hasil < temp:
		hasil = temp
print(hasil)


n = int(input())
a_i = [int(x) for x in input().split()]
inc = 0
l = 0
maxinc = 0
for a in a_i:
	if a >= l:
		inc += 1
		if inc > maxinc:
			maxinc = inc
	else:
		inc = 1
	l = a
print(maxinc)


n = int(input())
l = list(map(int, input().split()))
com = 1
m = []
if n > 2:
	for i in range(0, len(l) - 1):
		if l[i + 1] >= l[i]:
			com += 1
			if com == len(l):
				m.append(len(l))
			elif i == n - 2:
				m.append(com)
		else:
			m.append(com)
			com = 1
	print(max(m))
elif n == 2:
	if l[1] >= l[0]:
		print(2)
	else:
		print(1)
else:
	print(1)


M = lambda : map(int, input().split())
n = int(input())
l = list(M())
(ans, cnt) = (1, 1)
for i in range(n - 1):
	if l[i + 1] >= l[i]:
		cnt += 1
		ans = max(cnt, ans)
	else:
		cnt = 1
print(ans)


input()
q = 0
w = 0
e = 0
for i in map(int, input().split()):
	if i < q:
		if e > w:
			w = e
		e = 1
	else:
		e += 1
	q = i
print(max(e, w))


import sys

def solve():
	n = int(input())
	a = [int(i) for i in input().split()]
	ans = 0
	l = 0
	for (i, ai) in enumerate(a):
		if i > 0 and ai < a[i - 1]:
			l = 0
		l += 1
		ans = max(ans, l)
	print(ans)
solve()


n = int(input())
a = list(map(int, input().split()))
M = 1
r = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		r += 1
	else:
		M = max(M, r)
		r = 1
print(max(M, r))


input()
(*a,) = map(int, input().split())
m = b = c = 0
for i in a:
	if i < c:
		if b > m:
			m = b
		b = 1
		c = i
	else:
		c = i
		b += 1
print(max(m, b))


a = int(input())
b = list(map(int, input().split()))
c = b[0]
b.append(0)
d = 0
m = []
for r in b:
	if r >= c:
		d = d + 1
		c = r
	else:
		d = 1
		c = r
	m.append(d)
print(max(m))


n = int(input())
s = input().split()
count = 1
my_list = []
my_list.append(count)
for i in range(1, n):
	if int(s[i - 1]) <= int(s[i]):
		count += 1
		my_list.append(count)
	else:
		count = 1
print(max(my_list))


n = int(input())
list1 = list(map(int, input().split()))
i = 0
j = 1
if n == 1:
	print(1)
else:
	cnt = 1
	max1 = 1
	while j < n:
		if list1[j] >= list1[i]:
			cnt += 1
			i += 1
			j += 1
		else:
			if cnt > max1:
				max1 = cnt
			cnt = 1
			i = j
			if i == n:
				break
			j += 1
	if max1 < cnt:
		max1 = cnt
	print(max1)


n = int(input())
l = list(map(int, input().split()))
ans = anchor = 0
for i in range(n):
	if i and l[i - 1] > l[i]:
		anchor = i
	ans = max(ans, i - anchor + 1)
print(ans)


n = int(input())
a = list(map(int, input().split()))
output = 0
counter = 1
for i in range(len(a) - 1):
	if not a[i] > a[i + 1]:
		counter += 1
	else:
		output = max(output, counter)
		counter = 1
output = max(output, counter)
print(output)


n = int(input())
L = list(map(int, input().split()))
ans = mx = 1
for i in range(n - 1):
	if L[i] <= L[i + 1]:
		ans += 1
	else:
		ans = 1
	mx = max(mx, ans)
print(mx)


n = int(input())
r = [int(x) for x in input().split(' ')]
count = 1
cmax = 1
a = r[0]
for i in range(1, n):
	if a > r[i]:
		a = r[i]
		count = 1
	else:
		a = r[i]
		count += 1
		if count > cmax:
			cmax = count
print(cmax)


n = int(input())
a = [int(i) for i in input().split()]
n = []
k = 0
left = 0
for i in a:
	if i >= left:
		k += 1
		left = i
	else:
		n.append(k)
		left = i
		k = 1
n.append(k)
print(max(n))


n = int(input())
num = map(int, input().split())
pre = 0
out = count = 0
for i in num:
	if i >= pre:
		count += 1
	else:
		out = max(count, out)
		count = 1
	pre = i
print(max(out, count))


blah = input()
l = input().split()
maxim = 1
temp = 1
i = 1
while i < len(l):
	if int(l[i]) >= int(l[i - 1]):
		temp += 1
		if temp > maxim:
			maxim = temp
	else:
		temp = 1
	i += 1
print(maxim)


a = input()
li = list(map(int, input().split()))
max1 = 1
(count, current) = (1, li[0])
for i in li[1:]:
	if i >= current:
		count += 1
	else:
		count = 1
	max1 = max(max1, count)
	current = i
print(max1)


a = int(input())
arr = list(map(int, input().split()))
curr_l = 1
max_l = 1
for i in range(1, a):
	if arr[i] >= arr[i - 1]:
		curr_l += 1
	else:
		if curr_l > max_l:
			max_l = curr_l
		curr_l = 1
print(max(curr_l, max_l))


n = int(input())
lst = list(map(int, input().split()))
lst2 = [1] * n
for i in range(1, n):
	if lst[i - 1] <= lst[i]:
		lst2[i] = lst2[i - 1] + 1
print(max(lst2))


def solve(a):
	states = [1] * (len(a) + 1)
	maxval = 1
	for i in range(1, len(a)):
		if a[i] >= a[i - 1]:
			states[i] = states[i - 1] + 1
			maxval = max(states[i], maxval)
	return maxval

def main():
	input()
	a = [int(x) for x in input().split()]
	print(solve(a))
main()


n = int(input())
a = list(map(int, input().split())) + [-1]
cm = mx = 0
i = 0
for k in range(1, n + 1):
	if a[k] < a[k - 1]:
		cm = k - i
		mx = max(mx, cm)
		i = k
print(mx)


def kefa(n, n_list):
	count = 1
	max_count = 0
	for x in range(1, len(n_list)):
		if n_list[x - 1] <= n_list[x]:
			count += 1
		else:
			count = 1
		if max_count < count:
			max_count = count
	return max(max_count, 1)
n = int(input())
n_list = list(map(int, input().split()))
print(kefa(n, n_list))


k = int(input())
n = list(map(int, input().split()))
a = [1]
z = 1
if k == 1 or k == 0:
	print(k)
else:
	for i in range(0, k - 1):
		if n[i] <= n[i + 1]:
			z += 1
			a.append(z)
		else:
			z = 1
	print(max(a))


n = int(input())
P = input().split(' ')
add = [1]
a = P[0]
j = 0
for i in range(1, len(P)):
	if int(a) <= int(P[i]):
		a = P[i]
		add[j] += 1
	else:
		a = P[i]
		add.append(1)
		j += 1
print(max(add))


def iinput():
	return [int(i) for i in input().split()]
n = int(input())
mas = iinput()
last = 0
cur = 0
ans = 0
for i in mas:
	if i >= last:
		cur += 1
		last = i
	else:
		ans = max(ans, cur)
		cur = 1
		last = i
print(max(ans, cur))


n = int(input())
a = [int(x) for x in input().split()]
l = len(a)
counter = 0
i = 0
while i < l:
	count = 1
	j = i
	while j < l - 1 and a[j + 1] >= a[j]:
		count = count + 1
		j = j + 1
	if count > counter:
		counter = count
	i = i + count
print(counter)


n = int(input())
a = list(map(int, input().split()))
maxl = 1
cur = 1
for i in range(1, len(a)):
	if a[i] >= a[i - 1]:
		cur += 1
		if maxl < cur:
			maxl = cur
	else:
		cur = 1
print(maxl)


moneyList = []

def mCheckInputs(identifier, *args):
	if identifier == 'Is-INT-IN-RANGE':
		if args[0].isdigit() and 1 <= int(args[0]) <= pow(10, 5):
			pass
		else:
			exit(1)
	else:
		exit(1)

def mHandleInputs():
	global moneyList
	try:
		input1 = input()
		mCheckInputs('Is-INT-IN-RANGE', input1)
		n = int(input1)
		moneyList = list(map(int, input().split()))
		if len(moneyList) != n:
			exit(1)
	except ValueError as e:
		exit(1)

def mDoWork(moneyList):
	if moneyList.__len__() == 1:
		return 1
	lastIndex = 0
	maxima = 1
	mini = 1
	while True:
		maxima = maxima if maxima > mini else mini
		mini = 1
		if lastIndex == len(moneyList) - 1 or lastIndex == len(moneyList):
			break
		for index in range(lastIndex + 1, len(moneyList)):
			if 1 <= moneyList[index - 1] <= pow(10, 9) or 1 <= moneyList[index] <= pow(10, 9) or ():
				if moneyList[index - 1] <= moneyList[index]:
					mini += 1
				else:
					lastIndex = index
					break
			else:
				exit(1)
		lastIndex = index
	return maxima

def mFormatResult(result):
	print(result)

def main():
	mHandleInputs()
	result = mDoWork(moneyList)
	mFormatResult(result)
main()


n = int(input())
a_str = input()
a = list(map(lambda x: int(x), a_str.strip().split(' ')))
if n == 0:
	print(0)
	exit()
if n == 1:
	print(1)
	exit()
(fix, f, s, nd_len) = (0, 0, 1, 0)
while s < len(a):
	if a[f] <= a[s]:
		s += 1
		f += 1
	else:
		local_nd_len = s - fix
		if local_nd_len > nd_len:
			nd_len = local_nd_len
		fix = s
		f = fix
		s = fix + 1
if s - fix > nd_len:
	nd_len = s - fix
print(nd_len)


n = int(input())
p = list(map(int, input().split()))
lx = list()
c = 0
for i in range(len(p)):
	if i == len(p) - 1:
		lx.append(c)
		c = 0
		break
	elif p[i] <= p[i + 1]:
		c = c + 1
	elif p[i] > p[i + 1]:
		lx.append(c)
		c = 0
print(max(lx) + 1)


n = int(input())
if n == 1:
	print(1)
	exit(0)
a = input().split()
l = []
cnt = 0
best = 0
y = []
for i in range(0, n):
	x = int(a[i])
	l.append(x)
for i in range(1, n):
	if l[i - 1] <= l[i]:
		cnt += 1
		y.append(cnt)
	else:
		y.append(cnt)
		cnt = 0
y.sort(reverse=True)
print(y[0] + 1)


n = int(input())
a = [int(a) for a in input().split()]
nodec = 1
tmp = 1
for i in range(1, n):
	if a[i] >= a[i - 1]:
		tmp += 1
		if tmp > nodec:
			nodec = tmp
	else:
		tmp = 1
else:
	print(nodec)


(n, c, cmax, *l) = (int(input()), 1, 1, *map(int, input().split()))
for i in range(n - 1):
	if l[i] <= l[i + 1]:
		c += 1
	else:
		if cmax < c:
			cmax = c
		if i >= n - cmax - 1:
			break
		c = 1
print(max(c, cmax))


n = int(input())
arr = list(map(int, input().split()))
maxs = 1
curs = 1
for i in range(n - 1):
	if arr[i] <= arr[i + 1]:
		curs += 1
	else:
		maxs = max(maxs, curs)
		curs = 1
else:
	maxs = max(maxs, curs)
	curs = 1
print(maxs)


n = int(input())
a = list((int(x) for x in input().split()))
count = []
prev_i = a[0]
answer = 0
for i in a:
	if prev_i <= i:
		answer += 1
	elif prev_i > i:
		answer = 1
	prev_i = i
	count.append(answer)
count.sort()
print(count[-1])


from sys import stdin
stdin.readline()
arr = [int(x) for x in stdin.readline().rstrip().split()]
best = [1 for i in range(len(arr))]
for i in range(1, len(arr)):
	if arr[i] >= arr[i - 1]:
		best[i] = 1 + best[i - 1]
print(max(best))


from collections import deque, Counter, OrderedDict
from heapq import nsmallest, nlargest
from math import ceil, floor, log, log2, sqrt

def binNumber(n, size=1):
	return bin(n)[2:].zfill(size)

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def iar():
	return list(map(int, input().split()))

def ini():
	return int(input())

def isp():
	return map(int, input().split())

def sti():
	return str(input())
n = ini()
a = iar()
k = 1
ma = 1
if n == 1:
	print(1)
	quit()
for i in range(1, n):
	if a[i] >= a[i - 1]:
		k += 1
	else:
		ma = max(ma, k)
		k = 1
ma = max(ma, k)
print(ma)


n = int(input())
d = [int(i) for i in input().split()]
soma_atual = 1
max_atual = 1
if n == 0:
	print(0)
else:
	for p in range(n - 1):
		if d[p + 1] < d[p]:
			if max_atual < soma_atual:
				max_atual = soma_atual
			soma_atual = 2 - 1
		else:
			soma_atual = soma_atual + 1
	if max_atual < soma_atual:
		max_atual = soma_atual
	print(max_atual)


n = int(input())
A = [int(val) for val in input().split()]
counter = 1
ans = 0
flag = True
for i in range(1, n):
	if A[i] - A[i - 1] >= 0:
		counter += 1
		flag = True
	else:
		ans = max(ans, counter)
		counter = 1
		flag = False
if flag == True:
	ans = max(ans, counter)
print(ans)


__author__ = 'User'
n = int(input())
arr = list(map(int, input().split()))
l = 0
p = -1
tl = 0
for i in arr:
	if i >= p:
		tl += 1
	else:
		l = max(l, tl)
		tl = 1
	p = i
l = max(tl, l)
print(l)


n = int(input())
b = input().split()
for i in range(len(b)):
	b[i] = int(b[i])
currStreak = 0
currNum = 0
maxStreak = 0
for i in b:
	if not i < currNum:
		currStreak += 1
		currNum = i
	else:
		if currStreak > maxStreak:
			maxStreak = currStreak
		currStreak = 1
		currNum = i
if currStreak > maxStreak:
	maxStreak = currStreak
print(maxStreak)


n = int(input())
L = list(map(int, input().rstrip().split()))
count = 1
Max = 1
for i in range(1, len(L)):
	if L[i] >= L[i - 1]:
		count += 1
		Max = max(Max, count)
	else:
		count = 1
print(Max)


n = int(input())
a = list(map(int, input().split()[:n]))
if len(a) == 1:
	print('1')
else:
	c = 0
	temp = 0
	for i in range(len(a)):
		if i == 0:
			if a[1] >= a[0]:
				c += 1
		elif a[i] >= a[i - 1]:
			c += 1
		elif a[i] < a[i - 1]:
			if c > temp:
				temp = c
			c = 1
	print(max(temp, c))