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

public class Main {

    public static void main(String[] args) throws IOException{
        BufferedReader br =new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
        int n=Integer.parseInt(br.readLine());
        String[] inp=br.readLine().split(" ");
        int[] a=new int[n];
        ArrayList<Integer> al=new ArrayList<>();
        int count=1,max=0;
        for(int i=0;i<n;i++)
        {
             a[i]=Integer.parseInt(inp[i]);
             if(i>0)
             {
                 if(a[i]>a[i-1])
                 {
                     count++;
                 }
                 else{
                     al.add(count);
                     max=Math.max(max,count);
                     count=1;
                 }
             }
        }
        al.add(count);
        if(count>max)
        {
            max=count;
        }
        int x=0,y=al.get(0);
        //System.out.println(al);
        for(int i=0;i<al.size()-1;i++)
        {
            x+=al.get(i);
            y+=al.get(i+1);
            if((x<(n-1)&&(a[x-1]<a[x+1]))||((x>=2 && x<=(n-1)&&a[x-2]<a[x])))
            {
                if(al.get(i)+al.get(i+1)-1>max)
                {
                    max=al.get(i)+al.get(i+1)-1;
                }
            }
        }
     System.out.println(max);
	bw.flush();   
    }
}