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.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Stack;
import java.util.StringTokenizer;

public class TaskD {
	public static void main(String[] arg) {
		final FastScanner in = new FastScanner(System.in);
		final PrintWriter out = new PrintWriter(System.out);
		final int n = in.nextInt();
		final int[] a = in.readIntArr(n);
		Solution sol = new Solution(n, a);
		out.printf("%d%n", sol.sol_1());
		out.close();
		in.close();
	}

	private static class Solution {
		final int n;
		final int[] a;

		public Solution(int n, int[] a) {
			this.n = n;
			this.a = a;
		}

		public long sol() {
			long result = 1;
			int[] dp = new int[2];
			dp[0] = 1;
			dp[1] = 1;
			for (int i = 1; i < n; i++) {
				if (a[i - 1] < a[i]) {
					dp[0]++;
					dp[1]++;
				} else {
					if (i >= 2 && a[i - 2] < a[i]) {
						dp[1] = dp[0];
						dp[0] = 1;
					} else {
						dp[1] = 1;
						dp[0] = 1;
					}
				}
				result = Math.max(result, Math.max(dp[1], dp[0]));
			}
			return result;
		}

		public long sol_1() {
			int[] al = new int[n];
			Arrays.fill(al, 1);
			int result = 1;
			for (int i = n - 2; i >= 0; i--) {
				if (a[i] < a[i + 1]) {
					al[i] = al[i + 1] + 1;
					result = Math.max(al[i], result);
				}
			}
//			System.out.println(Arrays.toString(al));
			int[] ar = new int[n];
			Arrays.fill(ar, 1);
			for (int i = 1; i < n; i++) {
				if (a[i] > a[i - 1]) {
					ar[i] = ar[i - 1] + 1;
				}
			}
//			System.out.println(Arrays.toString(ar));
			for (int i = 1; i < n - 1; i++) {
				if (a[i + 1] > a[i - 1]) {
					result = Math.max(result, al[i+1] + ar[i-1]);
				}
			}

			return result;
		}

	}

	private static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		FastScanner(InputStream stream) {
			try {
				br = new BufferedReader(new InputStreamReader(stream));
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		int[] readIntArr(int n) {
			int[] result = new int[n];
			for (int i = 0; i < n; i++) {
				result[i] = Integer.parseInt(next());
			}
			return result;
		}

		void close() {
			try {
				br.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

		long nextLong() {
			return Long.parseLong(next());
		}

	}

}
