DZY has a sequence a, consisting of n integers.

We'll call a sequence ai, ai + 1, ..., aj (1 ≤ i ≤ j ≤ n) a subsegment of the sequence a. The value (j - i + 1) denotes the length of the subsegment.

Your task is to find the longest subsegment of a, such that it is possible to change at most one number (change one number to any integer you want) from the subsegment to make the subsegment strictly increasing.

You only need to output the length of the subsegment you find.

Input

The first line contains integer n (1 ≤ n ≤ 105). The next line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109).

Output

In a single line print the answer to the problem — the maximum length of the required subsegment.

Examples

Input

6
7 2 3 1 5 6


Output

5

Note

You can choose subsegment a2, a3, a4, a5, a6 and change its 3rd element (that is a4) to 4.
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;

public class Main {public static void main(String[] args) throws Exception {new Solve();}}

class Solve { public Solve() throws Exception{solve();}
    void solve() throws Exception {
        int n = NI();
        int[] a = new int[n];
        int curr = NI(), max = 0, len = 1;
        a[0] = curr;
        ArrayList<Integer> l =  new ArrayList<>();
        for (int i = 1; i < n; i++) {
            a[i] = NI();
            if (a[i] > curr)
                len++;
            else {
                l.add(len);
                max = max(max, len);
                len = 1;
            }
            curr = a[i];
        }
        l.add(len);
        int preMax = max = max(max, len);
        int sum = 0;
        for (int i = 0; i < l.size() - 1; i++) {
            if (l.get(i) == 1
                    || l.get(i + 1) == 1
                    || sum + l.get(i) - 2 < sum
                    || sum + l.get(i) + 1 >= n
                    || a[sum + l.get(i) - 2] + 1 < a[sum + l.get(i)]
                    || a[sum + l.get(i) - 1] + 1 < a[sum + l.get(i) + 1]) {
                max = max(max, l.get(i) + l.get(i + 1));
            } else {
                if (l.size() > 1)
                    max = max(max, l.get(i) + 1);
            }
            sum += l.get(i);
        }
        System.out.println(max > preMax ? max : preMax + (preMax < n ? 1 : 0 ));
    }

    class Pair {
        int i, j;
        Pair(int a, int b) {
            i = a;
            j = b;
        }
    }

    static BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st=new StringTokenizer("");
    static Scanner sc = new Scanner(System.in);
    int min(int i1,int i2){return i1<i2?i1:i2;}
    long min(long i1,long i2){return i1<i2?i1:i2;}
    int max(int i1,int i2){return i1>i2?i1:i2;}
    long max(long i1,long i2){return i1>i2?i1:i2;}
    String NS()throws Exception{while(!st.hasMoreTokens())st=new StringTokenizer(stdin.readLine());return st.nextToken();}
    String NLn() throws Exception {return stdin.readLine();}
    int NI()throws Exception{return Integer.parseInt(NS());}
    long NL()throws Exception{return Long.parseLong(NS());}
    double ND()throws Exception{return Double.parseDouble(NS());}
    int abs(int x){return x<0?-x:x;}
}
class ArrayUtils{public static void mergeSort(long[]a){long[]src=a.clone();mergeSortInt(src, a, 0, a.length);}
    public static void mergeSortInt(long[]src,long[]dest,int low,int high) {
        int length = high - low;
        if(length == 1) return;
        if (length == 2) {
            if(dest[low] > dest[high-1]){
                long t = dest[low];
                dest[low] = dest[high-1];
                dest[high-1] = t;
            }
            return;
        }
        int mid=(low+high)>>>1;
        mergeSortInt(dest,src,low,mid);
        mergeSortInt(dest,src,mid,high);
        for(int i=low,p=low,q=mid;i<high;i++)
            if (q>=high||p<mid&&src[p]<=src[q])dest[i]=src[p++];
            else dest[i] = src[q++];
    }

}