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.*;
import java.util.*;
import java.math.*; // for bigInteger

public class practice {
    public static void main(String args[]) throws Exception {
        //Faster Output...
        PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        StringBuilder sb = new StringBuilder();
        //Scanner scan = new Scanner(System.in);
        //scan.useDelimiter("");  // for reading character by character

		int n = scan.nextInt();
		int[] a = new int[n];
		for(int i=0;i<n;++i)  a[i]=scan.nextInt();
		int mx = 0;
		int length = 0;
		int prev = 0;
		
		for(int i=0;i<n;++i) {
			int x = a[i];
			int next = (i+1<n)?a[i+1]:Integer.MIN_VALUE;
			if(x>prev)  {
				if(next<x && next>prev) {
					int prev2 = prev;
					int length2 = length;
					for(int j=i+1;j<n;++j) {
						if(a[j]>prev2)  ++length2;
						else  break;
						prev2 = a[j];
					}
					mx = Math.max(mx,length2);
				}
				++length;
			}  else {
				mx = Math.max(mx,length);
				if(next>prev) {
					int length2 = length;
					int prev2 = prev;
					for(int j=i+1;j<n;++j) {
						if(a[j]>prev2)  ++length2;
						else  break;
						prev2 = a[j];
					}
					mx = Math.max(mx,length2);
				}
				length = 1;
			}
			prev = x;
		}
		mx = Math.max(mx,length);
		
		out.println(mx);
			
		
        scan.close();
        out.close();
    }
    private static InputReader scan = new InputReader(System.in);
    static class InputReader {

        private InputStream stream;
        private byte[] buf = new byte[8192];
        private int curChar;
        private int snumChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int snext() {
            if (snumChars == -1)
                throw new InputMismatchException();
            if (curChar >= snumChars) {
                curChar = 0;
                try {
                    snumChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (snumChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = snext();
            while (isSpaceChar(c))
                c = snext();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = snext();
            }

            int res = 0;

            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = snext();
            } while (!isSpaceChar(c));

            return res * sgn;
        }

        public long nextLong() {
            int c = snext();
            while (isSpaceChar(c))
                c = snext();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = snext();
            }

            long res = 0;

            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = snext();
            } while (!isSpaceChar(c));

            return res * sgn;
        }

        public String next() {
            int c = snext();
            while (isSpaceChar(c))
                c = snext();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = snext();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
        
        public void close() throws IOException {
            if(stream==null) {
                return;
            }
            stream.close();
        }
    }

    public static void debug(int[] ...var) {
        for(int[] row : var) {
            debug(row);
        }
    }

    public static void debug(long[] ...var) {
        for(long[] row : var) {
            debug(row);
        }
    }

    public static void debug(String[] ...var) {
        for(String[] row : var) {
            debug(row);
        }
    }

    public static void debug(double[] ...var) {
        for(double[] row : var) {
            debug(row);
        }
    }

    public static void debug(char[] ...var) {
        for(char[] row : var) {
            debug(row);
        }
    }

    public static void debug(int ...var) {
        for(int i:var)  System.err.print(i+" ");
        System.err.println();
    }
    public static void debug(String ...var) {
        for(String i:var)  System.err.print(i+" ");
        System.err.println();
    }
    public static void debug(double ...var) {
        for(double i:var)  System.err.print(i+" ");
        System.err.println();
    }
    
    public static void debug(long ...var) {
        for(long i:var)  System.err.print(i+" ");
        System.err.println();
    }
    
    public static void debug(char ...var) {
        for(char c:var)  System.err.print(c+" ");
        System.err.println();
    }

    /*
    public static <T> void debug(T ...varargs) {
        // Warning
        // Heap Pollution might occur
        // this overrides even 1d and 2d array methods as it is an object... 
        // + i am not using object based array like Integer[]
        // I am using int[] so that is a problem as i need Wrapper class as an argument
        for(T val:varargs)  System.err.printf("%s ",val);
        System.err.println();
    }
    */
}
