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.lang.*;
import java.math.*;
import java.util.Map.*;
 
public class codeforces {
	static int [] size,arr;
	static int inv;
	static HashSet<StringBuilder> set_1;
	static void solve(int index ,int j, int mask,char [] ch) {
		if(index==j) return;
		if(index==ch.length) {
			StringBuilder sb=new StringBuilder();
			for(int i=0;i<ch.length;i++) {
				if((mask & 1<<i)!=0) sb.append(ch[i]);
				
			}
			set_1.add(sb);
			return;
		}
		solve(index+1, j,mask | 1<<index,ch);
		solve(index+1,j ,mask,ch);
	}
	public static int find(int i) {
		if(arr[i]==i) return i;
		else {
			int result=find(arr[i]);
			arr[i]=result;
			return result;
		}
	}
public static void union(int u,int v) {
		int root_u=find(u);
		int root_v=find(v);
		if (root_u==root_v) return;
		else if(size[root_u]>size[root_v]) {
			size[root_u]+=size[root_v];
			arr[root_v]=root_u;
		}else  {
			size[root_v]+=size[root_u];
			arr[root_u]=root_v;
		}
	}
    static int search(int x,pair [] arr) {
    	int low=0,high=arr.length-1,ans=-1;
    	while(low<=high) {
    		int mid=(low+high)>>1;
    	    if(arr[mid].x>=x) {ans=mid; high=mid-1;}
    	    else low=mid+1;
    	}
    	return ans;
    }
   static  long gcd(long a, long b) 
    { 
        if (b == 0) 
            return a; 
        return gcd(b, a % b);  
          
    } 
   public static long largestDivisor(long n){
	   long divisor = 0;
	   long w=n>>1;
	   for (int i = 1; i <= w; i++)
	       if (n % i == 0) 
	           divisor = i;
 
	   return divisor; 
	}
       public static void main(String [] args) throws IOException, InterruptedException {
	    InputReader sc=new InputReader(System.in);
	    int x=sc.nextInt();
	    int [] arr=sc.nextIntArray(x);
	    int [] prefix=new int [x];
	    int [] postfix=new int [x];
	    Arrays.fill(postfix,1);
	    for(int i=1;i<x;i++) if(arr[i]>arr[i-1]) postfix[i]+=postfix[i-1];
	    Arrays.fill(prefix,1);
	    for(int i=x-2;i>=0;i--) if(arr[i]<arr[i+1]) prefix[i]+=prefix[i+1];
	    //pw.println(Arrays.toString(postfix)+"\n"+Arrays.toString(prefix));
	    int ans=Math.max(postfix[0]+prefix[0]-1,postfix[x-1]+prefix[x-1]-1);
	    for(int i=1;i<x-1;i++){
	    	ans=Math.max(ans, postfix[i]+prefix[i]-1);
	          if(arr[i+1]>arr[i-1] && (arr[i]>=arr[i+1] || arr[i]<=arr[i-1])){
	        	  ans=Math.max(ans,postfix[i-1]+prefix[i-1]+postfix[i+1]+prefix[i+1]-3);
	          }	
	    }
	    pw.print(ans);
	     pw.flush();
		pw.close();
	}
	static class pair implements Comparable<pair>{
		String  name; int x,y ;
		
		
		public pair (int x,int y) {
			this.x=x; this.y=y;
		}
		public int compareTo(pair o) {
			return o.x-x;
		}
		public String toString() {
			return x+" "+y;
		}
	}
 
	static 	PrintWriter pw=new PrintWriter(System.out);
	public static StringBuilder toString(int [] arr,int l,int r) {
		StringBuilder sb=new StringBuilder();
		for(int i=l;i<=r;i++) sb.append(arr[i]+" ");
		return sb;
	}
	public static StringBuilder toString(long [] arr,int l,int r) {
		StringBuilder sb=new StringBuilder();
		for(int i=l;i<=r;i++) sb.append(arr[i]+" ");
		return sb;
	}
	public static StringBuilder toString(char [] arr,int l,int r) {
		StringBuilder sb=new StringBuilder();
		for(int i=l;i<=r;i++) sb.append(arr[i]);
		return sb;
	}
	static class InputReader  {
		 
		private InputStream in;
		private byte[] buffer = new byte[1024];
		private int curbuf;
		private int lenbuf;
 
		public InputReader(InputStream in) {
			this.in = in;
			this.curbuf = this.lenbuf = 0;
		}
 
		public boolean hasNextByte() {
			if (curbuf >= lenbuf) {
				curbuf = 0;
				try {
					lenbuf = in.read(buffer);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (lenbuf <= 0)
					return false;
			}
			return true;
		}
 
		private int readByte() {
			if (hasNextByte())
				return buffer[curbuf++];
			else
				return -1;
		}
 
		private boolean isSpaceChar(int c) {
			return !(c >= 33 && c <= 126);
		}
 
		private void skip() {
			while (hasNextByte() && isSpaceChar(buffer[curbuf]))
				curbuf++;
		}
 
		public boolean hasNext() {
			skip();
			return hasNextByte();
		}
 
		public String next() {
			if (!hasNext())
				throw new NoSuchElementException();
			StringBuilder sb = new StringBuilder();
			int b = readByte();
			while (!isSpaceChar(b)) {
				sb.appendCodePoint(b);
				b = readByte();
			}
			return sb.toString();
		}
 
		public int nextInt() {
			if (!hasNext())
				throw new NoSuchElementException();
			int c = readByte();
			while (isSpaceChar(c))
				c = readByte();
			boolean minus = false;
			if (c == '-') {
				minus = true;
				c = readByte();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res = res * 10 + c - '0';
				c = readByte();
			} while (!isSpaceChar(c));
			return (minus) ? -res : res;
		}
 
		public long nextLong() {
			if (!hasNext())
				throw new NoSuchElementException();
			int c = readByte();
			while (isSpaceChar(c))
				c = readByte();
			boolean minus = false;
			if (c == '-') {
				minus = true;
				c = readByte();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res = res * 10 + c - '0';
				c = readByte();
			} while (!isSpaceChar(c));
			return (minus) ? -res : res;
		}
 
		public double nextDouble() {
			return Double.parseDouble(next());
		}
 
		public int[] nextIntArray(int n) {
			int[] a = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = nextInt();
			return a;
		}
 
		public long[] nextLongArray(int n) {
			long[] a = new long[n];
			for (int i = 0; i < n; i++)
				a[i] = nextLong();
			return a;
		}
 
		public char[][] nextCharMap(int n, int m) {
			char[][] map = new char[n][m];
			for (int i = 0; i < n; i++)
				map[i] = next().toCharArray();
			return map;
		}
	}
 
	}