You are given an array a consisting of n integers.

You can remove at most one element from this array. Thus, the final length of the array is n-1 or n.

Your task is to calculate the maximum possible length of the strictly increasing contiguous subarray of the remaining array.

Recall that the contiguous subarray a with indices from l to r is a[l ... r] = a_l, a_{l + 1}, ..., a_r. The subarray a[l ... r] is called strictly increasing if a_l < a_{l+1} < ... < a_r.

Input

The first line of the input contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.

The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of a.

Output

Print one integer — the maximum possible length of the strictly increasing contiguous subarray of the array a after removing at most one element.

Examples

Input


5
1 2 5 3 4


Output


4


Input


2
1 2


Output


2


Input


7
6 5 4 3 2 4 3


Output


2

Note

In the first example, you can delete a_3=5. Then the resulting array will be equal to [1, 2, 3, 4] and the length of its largest increasing subarray will be equal to 4.
// javac d.java && java _

import java.io.*;
import java.util.*;

public class d {
	public static void main(String[] args) { new d(); }
	FS in = new FS();
	PrintWriter out = new PrintWriter(System.out);
	
	int n;
	int[] a;
	int[] inc, dec;
	
	d() {
		n = in.nextInt();
		a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = in.nextInt();

		inc = new int[n];
		inc[0] = 1;
		for (int i = 1; i < n; i++) {
			int j = i;
			while (j < n && a[j - 1] < a[j]) {
				inc[j] = inc[j - 1] + 1;
				j++;
			}
			if (j == n)
				break;
			inc[j] = 1;
			i = j;
		}
		dec = new int[n];
		dec[n - 1] = 1;
		for (int i = n - 2; i >= 0; i--) {
			int j = i;
			while (j >= 0 && a[j + 1] > a[j]) {
				dec[j] = dec[j + 1] + 1;
				j--;
			}
			if (j == -1)
				break;
			dec[j] = 1;
			i = j;
		}

		int max = 0;
		for (int i = 0; i < n; i++)
			max = max(max, inc[i]);

		for (int i = 1; i < n - 1; i++)
			if (a[i - 1] < a[i + 1])
				max = max(max, inc[i - 1] + dec[i + 1]);

		out.println(max);
		out.close();
	}
	
	

	int min(int a, int b) { if (a < b) return a; return b; }	
	int max(int a, int b) { if (a > b) return a; return b; }	
	long min(long a, long b) { if (a < b) return a; return b; }	
	long max(long a, long b) { if (a > b) return a; return b; }	

	boolean z(int x) { if (x == 0) return true; return false; }
	boolean z(long x) { if (x == 0) return true; return false; }
	
	class FS {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer("");
		String next() {
			while (!st.hasMoreTokens()) {
				try { st = new StringTokenizer(br.readLine()); }
				catch (Exception e) {}
			} return st.nextToken();
		}
		int nextInt() { return Integer.parseInt(next()); }
		long nextLong() { return Long.parseLong(next()); }
		double nextDouble() { return Double.parseDouble(next()); }
	}
}

