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*<sub class="lower-index">*i*</sub> money. Kefa loves progress, that's why he wants to know the length of the maximum non-decreasing subsegment in sequence *a*<sub class="lower-index">*i*</sub>. 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!
The first line contains integer *n* (1 ≤ *n* ≤ 10<sup class="upper-index">5</sup>).

The second line contains *n* integers *a*<sub class="lower-index">1</sub>,  *a*<sub class="lower-index">2</sub>,  ...,  *a*<sub class="lower-index">*n*</sub> (1 ≤ *a*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">9</sup>).
from typing import List, Union
from collections import namedtuple
import sys
import traceback
from datetime import datetime
from time import perf_counter


# Two Pointers Solution
class Solution:
    def kefa_steps(self, nums):
        result = 0
        if len(nums) == 1:
            result = 1
        left, right = 0, 1
        while left < len(nums):
            count = 1
            while right < len(nums) and nums[right] >= nums[right - 1]:
                right += 1
                count += 1
            result = max(result, count)
            left, right = right, right + 1
        print(result)
        return result


TestCase = namedtuple('TestCase', 'nums correct')


def read_test_cases(input_file, output_file):
    test_cases: List[TestCase] = []
    try:
        with open(input_file) as in_f:
            with open(output_file) as out_f:
                while True:
                    line = in_f.readline().strip()
                    if not line or len(line) == 0:
                        break
                    line = line.strip()
                    arr_len = int(line)
                    nums = in_f.readline().strip().split()
                    nums = [int(n) for n in nums]
                    correct = int(out_f.readline().strip())
                    test_cases.append(TestCase(nums, correct))
        # raise Exception('My Test Exception')
    except Exception as exc:
        exc_name = exc.__class__.__name__
        exc_msg = str(exc)
        exc_info = sys.exc_info()
        print('EXCEPTION:', exc_name, exc_msg)
        traceback.print_exception(*exc_info)
    return test_cases


def run_test_cases(test_cases: List[TestCase]):
    for t in test_cases:
        result = Solution().kefa_steps(t.nums)
        print('NUMS:', t.nums, 'CORRECT:', t.correct, 'RESULT:', result, 'CHECK:', result == t.correct)


if __name__ == '__main__':
    if len(sys.argv) > 1 and '--debug' in sys.argv:
        date_str = datetime.utcnow().strftime('%Y.%m.%d %H:%M:%S')
        print('STARTING:', date_str)
        test_cases = read_test_cases('data/input.txt', 'data/output.txt')
        start_counter = perf_counter()
        run_test_cases(test_cases)
        stop_counter = perf_counter()
        print('COUNTER:', stop_counter - start_counter)
    else:
        arr_len = int(input())
        nums = []
        for _ in range(arr_len):
            items = []
            while True:
                ch = sys.stdin.read(1)
                if ch == ' ' or ch == '\n':
                    break
                items.append(ch)
            n = int(''.join(items))
            nums.append(n)
        # print(nums)
        Solution().kefa_steps(nums)
