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.util.*;
import java.io.*;
import java.math.*;
public class Main{
	static int mod = (int)1e9+7;
	public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
	public static void main(String sp[])throws IOException{
		FastReader sc = new FastReader();
		int n = sc.nextInt();
		int arr[] =  new int[n+1];
		for(int i=1;i<=n;i++)
			arr[i]  = sc.nextInt();
		int pre[] =  new int[n+1];
		int suf[] = new int[n+1];
		if(n==1){
			System.out.println("1");
			return;
		}
		int max = Integer.MIN_VALUE;
		for(int i=1;i<=n;i++){
			if(i==1){
				pre[i]=1;
				continue;
			}
			if(arr[i]>arr[i-1]){
				pre[i] = pre[i-1];
			}else{
				pre[i] = i;
			}
		}
		for(int i=n;i>=1;i--){
			if(i==n){
				suf[i]=n;
				continue;
			}
			if(arr[i]<arr[i+1]){
				suf[i] = suf[i+1];
			}else suf[i] = i;
		}
		
		for(int i=1;i<=n;i++){
			max = Math.max(i-pre[i]+1, max);
		}
		for(int i=1;i<=n;i++){
			if(i==1){
				if(arr[i+1]>arr[i])
				max = Math.max(suf[i+1]-i+1, max);
			}else if(i==n){
				if(arr[i-1]<arr[i])
				max = Math.max(i-pre[i-1]+1, max);
			}else{
				if(arr[i+1]>arr[i-1]){
				max = Math.max(((i-1)-pre[i-1]+1) + (suf[i+1]-(i+1)+1) , max);
				}
			}
		}
		System.out.println(max);
	}
	
	public static boolean ok(long count, long diff){
		long m = (count * (count+1))/2l;
		if(m<diff)
			return false;
		return diff%2 == m%2;	
	}
	
	
	public static class pair{
		int a;
		int b;
	}
	
	public static class comp implements Comparator<pair>{
		public int compare(pair o1, pair o2){
			return o1.a-o2.a;
		}
	}
	
	static int parent[];
	public static int find(int a){
		if(parent[a]==a)
			return a;
		int rep = find(parent[a]);
		parent[a]=rep;
		return rep;
	}
	public static void join(int a, int b){
		int f1 = find(a);
		int f2 = find(b);
		if(f1==f2)
			return;
		
		if(f1<f2)
			parent[f2] = f1;
		else parent[f1] = f2;
	}
	
	
	public static class FastReader {
		BufferedReader br;
		StringTokenizer st;
	
 
		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}
 
		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (Exception r) {
					r.printStackTrace();
				}
			}
			return st.nextToken();
		}
 
		int nextInt() {
			return Integer.parseInt(next());//converts string to integer
		}
 
		double nextDouble() {
			return Double.parseDouble(next());
		}
 
		long nextLong() {
			return Long.parseLong(next());
		}
 
		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (Exception r) {
				r.printStackTrace();
			}
			return str;
		}
	}
}
