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.*;

public class practicing {
    static class tri {
        int l;
        int last;
        int beg;

        public tri(int m, int b,int ma) {
            l = m;
            last = ma;
            beg=b;
        }
    }

    static long pow(long n, int e) {
        long res = 1;
        while (e-- > 0) {
            res *= n;
        }
        return res;
    }

    static long abs(long a, long b) {
        if (a > b)
            return a - b;
        return b - a;
    }

    static boolean pairwiseEq(long a, long b, long c) {
        if (a == b || b == c || c == a)
            return true;
        return false;
    }

    public static void main(String[] args) throws IOException {
        //BufferedReader br = new BufferedReader(new FileReader("folding.in"));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;
        //PrintWriter out = new PrintWriter("folding.out");
        PrintWriter out = new PrintWriter(System.out);
        int n = Integer.parseInt(br.readLine());
        long []a=new long[n];
        st=new StringTokenizer(br.readLine());
        for (int i = 0; i <n ; i++) {
            a[i]=Long.parseLong(st.nextToken());
        }
        ArrayList<Integer>bP=new ArrayList<>();
        ArrayList<tri>sub=new ArrayList<>();
        bP.add((0));
        long last=a[0];
        int beg=0;
        for (int i = 1; i <n ; i++) {
            if(a[i]>last){
                last=a[i];
                if(i==n-1) {
                    sub.add(new tri(n - bP.get(bP.size() - 1), beg,n - 1));
                    //System.err.println(i + " " + bP.get(bP.size() - 1));
                }
            }
            else {

                last=a[i];
                sub.add(new tri(i- bP.get(bP.size()-1),beg,i-1));
               // System.err.println(i+" "+bP.get(bP.size()-1));
                bP.add(i);
                beg=i;
                if(i==n-1){
                    sub.add(new tri(1,n-1,n-1));
                }
            }
        }
        int lengthinit=sub.get(0).l;
        int max=lengthinit;
        for (int i = 1; i <sub.size() ; i++) {
            if(sub.get(i).beg<n-1&&a[sub.get(i-1).last]<a[sub.get(i).beg+1])
                max=Math.max(max,lengthinit+sub.get(i).l-1);
            else {
                if(sub.get(i-1).last-1>0&&a[sub.get(i-1).last-1]<a[sub.get(i).beg])
                    max=Math.max(max,lengthinit+sub.get(i).l-1);
            }
            max=Math.max(max,lengthinit);
            lengthinit=sub.get(i).l;

        }
        max=Math.max(max,lengthinit);
        out.println(max);

        out.flush();

    }
}
