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 sys, math
input = sys.stdin.readline

def getInts():
    return [int(s) for s in input().split()]

def getInt():
    return int(input())

def getStrs():
    return [s for s in input().split()]

def getStr():
    return input().strip()

def listStr():
    return list(input().strip())

import collections as col
import math,itertools

"""
Find longest subseq starting at a certain point
If N == 1, return
If len = N or N-1 return
Possible cases:
Just simulate removing the ith element
"""

def solve():
    N = getInt()
    A = getInts()
    if N == 1:
        return 1
    subsequences = []
    subs_right = []
    ind, curr_len = 0, 0
    while ind < N:
        if ind == 0:
            curr_len += 1
            subsequences.append(curr_len)
            ind += 1
            continue
        if A[ind] <= A[ind-1]:
            curr_len = 1
            subsequences.append(curr_len)
        else:
            curr_len += 1
            subsequences.append(curr_len)
        ind += 1
    ind, curr_len = N-1, 0
    while ind > -1:
        if ind == N-1:
            curr_len += 1
            subs_right.append(curr_len)
            ind -= 1
            continue
        if A[ind] >= A[ind+1]:
            curr_len = 1
            subs_right.append(curr_len)
        else:
            curr_len += 1
            subs_right.append(curr_len)
        ind -= 1
    best = 0
    subs_right.reverse()
    if subsequences[N-1] == N:

        return N
    #print(subs_right,subsequences)
    for i in range(N):
        if i == 0:
            best = max(best,subs_right[i+1])
            continue
        if i == N-1:
            best = max(best,subsequences[i-1])
            continue
        if A[i-1] < A[i+1]:
            best = max(best,subsequences[i-1]+subs_right[i+1])
        best = max(best,subsequences[i-1],subs_right[i+1])
        #print(i,best)
        #remove i
        
        
        # best = max(best,subsequences[i])
        # if i + subsequences[i] - 1 < N-2 and A[i + subsequences[i] +1] > A[i + subsequences[i] - 1]:
            # best = max(best,subsequences[i]+subsequences[i + subsequences[i] - 1])
        # if subsequences[i] > 1 and i + subsequences[i] - 1 < N-1 and A[i + subsequences[i]] > A[i + subsequences[i] - 2]:
            # best = max(best,subsequences[i]-1+subsequences[i+subsequences[i]])
        # if best >= N-1:
            # return best
    return best
print(solve())
    

