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 ai money. Kefa loves progress, that's why he wants to know the length of the maximum non-decreasing subsegment in sequence ai. 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 ≤ 105).

The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109).

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.
import java.io.IOException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

public class P580A {

	private void run() {
		int n = nextInt();
		int max = -1;
		int prev = Integer.MIN_VALUE;
		int currentLength = 0;
		
		for (int i = 0; i < n; i++) {
			int m = nextInt();
			
			if (m >= prev) {
				currentLength++;
			} else {
				max = Math.max(max, currentLength);
				currentLength = 1;
			}
			
			prev = m;
		}

		max = Math.max(max, currentLength);

		System.out.println(max);
	}

	public boolean isTriangle(int a, int b, int c) {
		return
				(a + b > c)
				&& (a + c > b)
				&& (b + c > a);
	}

	private char nextChar() {
		try {
			return (char) System.in.read();
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}

	private char[] incrementWord(char[] input, char maxLetter) {
		int currentIndex = input.length - 1;
		
		while (currentIndex >= 0 && input[currentIndex] == maxLetter) {
			currentIndex--;
		}
		
		if (currentIndex < 0) {
			return input;
		}
		
		input[currentIndex] = (char) (input[currentIndex] + 1);

		for (int i = currentIndex + 1; i < input.length; i++) {
			input[i] = 'a';
		}

		return input;
	}


	private int getFree(Integer currentFree, Map<Integer, Integer> count) {
		while (count.containsKey(currentFree)) {
			currentFree = currentFree + 1;
		}
		return currentFree;
	}


	private double computeArea(double side1, double side2, double side3) {
		double p = (side1 + side2 + side3) / 2d;
		
		return Math.sqrt(p * (p - side1) * (p - side2) * (p - side3));
	}

	private int greaterThan(List<Integer> indexesP2, Integer j) {
		for (int i = 0; i < indexesP2.size(); i++) {
			Integer number = indexesP2.get(i);
			
			if (number > j) {
				return indexesP2.size() - i;
			}
		}
		return 0;
	}

	public static void main(String[] args) {
		P580A notes = new P580A();
		notes.run();
		notes.close();
	}

	private Scanner sc;
	
	private P580A() {
		this.sc = new Scanner(System.in);
	}
	
	private int[] asInteger(String[] values) {
		int[] ret = new int[values.length];
		
		for (int i = 0; i < values.length; i++) {
			String val = values[i];
			ret[i] = Integer.valueOf(val).intValue();
		}
		
		return ret;
	}
	
	private String nextLine() {
		return sc.nextLine();
	}
	
	private int nextInt() {
		return sc.nextInt();
	}

	private String readLine() {
		if (sc.hasNextLine()) {
			return (sc.nextLine());
		} else {
			return null;
		}
	}
	
	private void close() {
		try {
			sc.close();
		} catch (Exception e) {
			//log
		}
	}
}
