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 javax.swing.plaf.nimbus.AbstractRegionPainter;

import java.awt.FontFormatException;
import java.io.*;

public class Main {

	public static void main(String[] args) throws Exception {
	   int n=sc.nextInt();
	   int a=0;
	   int b=0;
	   int [] arr=new int[n];
	   int [] arr2=new int[n];
	  int ans =0;
	  int Z=0;
	  int c=0;
	   for(int i=0;i<n;i++) {
		   arr[i]=sc.nextInt();
		   if(arr[i]>Z) {
			   c++;
			  
		   }
		   else {
			   arr2[i-1]=c;
			   c=1;
			   
		   }
		   Z=arr[i];
		   ans=Math.max(ans, c);
	   }
	 arr2[n-1]=c;
	 ans=Math.max(ans, c);
	 for(int i=n-1;i>-1;i--) {
		 if(arr2[i]==0) {
			 arr2[i]=arr2[i+1];
		 }
	 }
	 for(int i=1;i<n-1;i++) {
		 if(arr[i+1]>arr[i-1]&&arr[i]>=arr[i+1]) {
			 ans=Math.max(ans, arr2[i-1]+arr2[i+1]-1);
		 }
		 if(arr[i+1]>arr[i-1]&&arr[i]<=arr[i-1]) {
			 if(arr2[i]==1)
			 ans=Math.max(ans, arr2[i-1]+arr2[i+1]);
			 else {
				 ans=Math.max(ans, arr2[i-1]+arr2[i+1]-1);
			 }
		 }
	 }
	 //pw.println(Arrays.toString(arr2));
	 pw.println(ans);
		
		pw.close();
	}


	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public Scanner(FileReader r) {
			br = new BufferedReader(r);
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

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

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

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public double nextDouble() throws IOException {
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-') {
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++)
				if (x.charAt(i) == '.') {
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else {
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

	}

	static class pair implements Comparable<pair> {
		int x;
		int y;

		public pair(int x, int y) {
			this.x = x;
			this.y = y;
		}

		public String toString() {
			return x + " " + y;
		}

		public int compareTo(pair other) {
			if (this.x == other.x) {
				return this.y - other.y;
			} else {
				return this.x - other.x;
			}
		}
	}

	static class tuble implements Comparable<tuble> {
		int x;
		int y;
		int z;

		public tuble(int x, int y, int z) {
			this.x = x;
			this.y = y;
			this.z = z;
		}

		public String toString() {
			return x + " " + y + " " + z;
		}

		public int compareTo(tuble other) {
			if (this.x == other.x) {
				return this.y - other.y;
			} else {
				return this.x - other.x;
			}
		}
	}

	public static long GCD(long a, long b) {
		if (b == 0)
			return a;
		if (a == 0)
			return b;
		return (a > b) ? GCD(a % b, b) : GCD(a, b % a);
	}

	public static long LCM(long a, long b) {
		return a * b / GCD(a, b);
	}

	static long Pow(long a, int e, int mod)	// O(log e)
    {
        a %= mod;
        long res = 1;
        while(e > 0)
        {
            if((e & 1) == 1)
                res = (res * a) % mod;
            a = (a * a) % mod;
            e >>= 1;
        }
        return res;
    }
    
    static long nc(int n,int r){
        if (n<r)return 0;
        long v = fac[n];
        v*=Pow(fac[r],mod-2,mod);
        v%=mod;
        v*=Pow(fac[n-r],mod-2,mod);
        v%=mod;
        return v;
    }

	public static boolean isprime(long a) {
		if (a == 0 || a == 1) {
			return false;
		}
		if (a == 2) {
			return true;
		}
		for (int i = 2; i < Math.sqrt(a) + 1; i++) {
			if (a % i == 0) {
				return false;
			}
		}
		return true;
	}
	static long fac[];
	static int mod=998244353;
	static Scanner sc = new Scanner(System.in);
	static PrintWriter pw = new PrintWriter(System.out);
}