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 D {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        StringTokenizer st = new StringTokenizer(br.readLine());
        int[] arr = new int[n];
        for(int i = 0; i<n; i++){
            arr[i] = Integer.parseInt(st.nextToken());
        }
        ArrayList<pair> lst = new ArrayList<>();
        boolean start = true;
        int length = 1;
        for(int i = 1; i<n; i++){
            if(arr[i-1]<arr[i]){
                if(start){
                    start = false;
                }
                length++;
            }
            else{
                if(length>=1){
                    lst.add(new pair(length, i-1));
                    length = 1;
                }
            }
        }
        if(length>=1) lst.add(new pair(length, n-1));
        Collections.sort(lst);
        int maxLen = 0;
        for(int i = 1; i<lst.size(); i++){
            pair a = lst.get(i-1), b = lst.get(i);
            int a_st = (a.end- a.len+1);
            if(a_st-b.end == 2){
                if(arr[a_st]>arr[b.end]) maxLen = Math.max(maxLen, a.len+b.len);
            }
            else if(a_st-b.end == 1){
                if(a_st+1<n && b.end>=1 && (arr[a_st+1]>arr[b.end] || arr[b.end-1]<arr[a_st])){
                    maxLen = Math.max(maxLen, a.len+b.len-1);
                }
            }
        }
        for(pair p: lst){
            maxLen = Math.max(maxLen, p.len);
        }
        System.out.println(maxLen);
    }
    static class pair implements Comparable<pair>{
        int len, end;
        pair(int len, int end){
            this.len = len;
            this.end = end;
        }
        @Override
        public int compareTo(pair p){
            return p.end-this.end;
        }
    }
}