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.
//package com.company;

import java.util.*;

public class Main {
	public static int ans = 0;
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int[] data = new int[n];
		Dis[] d = new Dis[n];
		int index_d = -1;
		int last_tem = 1000000000;
		for (int i = 0; i < n; i++) {
			data[i] = in.nextInt();
			if (data[i] > last_tem) {
				d[index_d].to = i;
			} else {
				d[++index_d] = new Dis(i, i);
			}
			last_tem = data[i];
		}

		if (n == 1) {
			System.out.println(1);
			return;
		}
		else if (n == 2) {
			if(data[0] < data[1]) System.out.println(2);
			else System.out.println(1);
			return;
		}
		int ans = 1;
		if (d[index_d].getLength() > ans) ans = d[index_d].getLength();
		for (int i = 0; i <= index_d-1; i++) {
			int k = d[i].to;
			//System.out.println(d[i].from + " " + d[i].to + " " + d[i].getLength());
			if (d[i].getLength() > ans) ans = d[i].getLength();
			if (i == 0 && d[i].getLength() == 1) continue;
			if (data[k-1] < data[k+1] || (d[i+1].getLength() > 1 && data[k] < data[k+2])) {
				int ans_tem = d[i].getLength() + d[i+1].getLength() - 1;
				if (ans_tem > ans) ans = ans_tem;
			}
			if (d[i+1].getLength() == 1 && i+2 <= index_d && data[k] < data[d[i+2].from]) {
				int ans_tem = d[i].getLength() + d[i+2].getLength();
				if (ans_tem > ans) ans = ans_tem;
			}
		}
		System.out.println(ans);
	}
}
class Dis {
	public int from;
	public int to;
	Dis(int a, int b) {
		from = a;
		to = b;
	}
	public int getLength() {
		return to - from + 1;
	}
}