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 javax.print.DocFlavor;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.IllegalCharsetNameException;
import java.sql.SQLOutput;
import java.util.*;



public class Main {
    static LinkedList[] g;
    static int[] parent;
    static int[][] arr;
    static char[][] ans;
    static boolean[][] vis;
    static int count;
    static int r;
    static int c;
    static int k;
    static char[] chick;

    public static void main(String[] args) throws IOException{
        Reader.init(System.in);
        int n = Reader.nextInt();
        int[] arr = new int[n];
        for (int i = 0 ; i < n; i++){
            arr[i] = Reader.nextInt();
        }
        int pre[] = new int[n];
        int suf[] = new int[n];
        for (int i = 0 ;i < n ; i++){
            pre[i] = 1;
        }
        for (int i = 0 ; i < n ; i++){
            suf[i] =1;
        }
        int cnt = 1;
        int ans = -1;
        for (int i = 1 ; i < n ; i++){
            if (arr[i] > arr[i-1]){
                cnt++;
            }
            else{
                cnt = 1;
            }
            pre[i] = cnt;
            ans = Math.max(ans , cnt);
        }
        cnt = 1;
        for (int i = n-2 ; i>= 0 ; i--){
            if (arr[i] < arr[i+1]){
                cnt++;
            }
            else{
                cnt = 1;
            }
            suf[i] = cnt;
        }

        for (int i = 1 ; i <= n-2 ; i++){
            if (arr[i+1] > arr[i-1]){
                ans = Math.max(ans , pre[i-1] + suf[i+1]);
            }
        }
        //System.out.println(Arrays.toString(pre));

        System.out.println(ans);




    }

    static int find(int x) {
        return parent[x] == x ? x : (parent[x] = find(parent[x]));
    }
    static void merge(int x, int y) {
        x = find(x);
        y = find(y);
        if ( x > y ){
            parent[y] = x;
        }
        else if (y > x){
            parent[x] = y;
        }
    }

    static void solve()throws IOException{
        String s = Reader.next();
        int l = 0;
        int r = 0;
        int u = 0;
        int d = 0;
        for (int i = 0 ; i < s.length() ; i++){
            if (s.charAt(i)=='L'){
                l++;
            }
            else if (s.charAt(i)=='R'){
                r++;
            }
            else  if (s.charAt(i)=='U'){
                u++;
            }
            else if (s.charAt(i)=='D'){
                d++;
            }
        }
        /*System.out.println(l);
        System.out.println(r);
        System.out.println(u);
        System.out.println(d);*/
        if (u==0 || d==0){
            if (l>0 && r >0){
                System.out.println(2);
                System.out.println("LR");
            }
            else{
                System.out.println(0);
            }
            return;
        }
        else if (l==0 || r==0){
            if (u>0 && d>0){
                System.out.println(2);
                System.out.println("UD");
            }
            else{
                System.out.println(0);
            }
            return;
        }
        l = Math.min(l,r);
        u = Math.min(u,d);
        char[] ans = new char[2*(l+u)];
        System.out.println(ans.length);
        int i = 0;
        for (; i < l ; i++){
            ans[i] = 'L';
        }
        for (; i < l + u ; i++){
            ans[i] = 'U';
        }
        for ( ; i < l + u + l ; i++){
            ans[i] = 'R';
        }
        for ( ; i < 2*(l+u) ; i++){
            ans[i] = 'D';
        }
        System.out.println(String.valueOf(ans));
    }


    public static void sortbyColumn(int arr[][], int col)
    {
        // Using built-in sort function Arrays.sort
        Arrays.sort(arr, new Comparator<int[]>() {

            @Override
            // Compare values according to columns
            public int compare(final int[] entry1,
                               final int[] entry2) {

                // To sort in descending order revert
                // the '>' Operator
                if (entry1[col] > entry2[col])
                    return 1;
                else
                    return -1;
            }
        });  // End of function call sort().
    }


    static class Node{
        long a;
        int i;
        Node(long a, int i){
            this.a = a;
            this.i = i;
        }
    }

}


class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    /** call this method to initialize reader for InputStream */
    static void init(InputStream input) {
        reader = new BufferedReader(
                new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }
    /** get next word */
    static String next() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                    reader.readLine() );
        }
        return tokenizer.nextToken();
    }

    static int nextInt() throws IOException {
        return Integer.parseInt( next() );
    }
    static long nextLong() throws IOException {
        return Long.parseLong( next() );
    }

    static double nextDouble() throws IOException {
        return Double.parseDouble( next() );
    }
}
class MergeSort
{
    // Merges two subarrays of arr[].
    // First subarray is arr[l..m]
    // Second subarray is arr[m+1..r]
    void merge(int arr[], int l, int m, int r)
    {
        // Find sizes of two subarrays to be merged
        int n1 = m - l + 1;
        int n2 = r - m;

        /* Create temp arrays */
        int L[] = new int [n1];
        int R[] = new int [n2];

        /*Copy data to temp arrays*/
        for (int i=0; i<n1; ++i)
            L[i] = arr[l + i];
        for (int j=0; j<n2; ++j)
            R[j] = arr[m + 1+ j];


        /* Merge the temp arrays */

        // Initial indexes of first and second subarrays
        int i = 0, j = 0;

        // Initial index of merged subarry array
        int k = l;
        while (i < n1 && j < n2)
        {
            if (L[i] <= R[j])
            {
                arr[k] = L[i];
                i++;
            }
            else
            {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        /* Copy remaining elements of L[] if any */
        while (i < n1)
        {
            arr[k] = L[i];
            i++;
            k++;
        }

        /* Copy remaining elements of R[] if any */
        while (j < n2)
        {
            arr[k] = R[j];
            j++;
            k++;
        }
    }

    // Main function that sorts arr[l..r] using
    // merge()
    void sort(int arr[], int l, int r)
    {
        if (l < r)
        {
            // Find the middle point
            int m = (l+r)/2;

            // Sort first and second halves
            sort(arr, l, m);
            sort(arr , m+1, r);

            // Merge the sorted halves
            merge(arr, l, m, r);
        }
    }

    /* A utility function to print array of size n */
    static void printArray(int arr[])
    {
        int n = arr.length;
        for (int i=0; i<n; ++i)
            System.out.print(arr[i] + " ");
        System.out.println();
    }

    // Driver method

}

class Node implements Comparable<Node>{
    int a;
    int b;
    Node (int a , int b){
        this.a = a;
        this.b = b;
    }



    public int compareTo(Node o) {
        if ((this.a%2) == (o.a%2)){
            return (this.b - o.b);
        }
        else{
            return this.a - o.a;
        }
    }
}