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 com.sun.org.apache.xpath.internal.SourceTree;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.List;
import java.util.Scanner;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.util.InputMismatchException;
import java.util.Vector;

/**
 * Ashesh Vidyut (Drift King) *
 */
public class C {
    public static void main(String[] args) {
        try {
            InputReader in = new InputReader(System.in);
            int n = in.readInt();
            int ar[] = new int[n];
            for (int i = 0; i < n; i++) {
                ar[i] = in.readInt();
            }
            List<Group> vec = new Vector<Group>();
            int ind = 0;
            while(ind < n){
                int prevind = ind;
                while(ind + 1 < n && ar[ind + 1] > ar[ind]){
                    ind++;
                }
                Group newg = new Group(ind - prevind + 1, prevind, ind, ar[prevind], ar[ind]);
                vec.add(newg);
                ind++;
            }
            int ans = vec.get(0).len;
            for (int i = 0; i < vec.size(); i++) {
                Group process = vec.get(i);
                if(process.len == 1){
                    if(i - 1 >= 0 && i + 1 < vec.size()){
                        Group prev = vec.get(i-1);
                        Group next = vec.get(i+1);
                        if(prev.endnum < next.stnum && next.stnum - prev.endnum > 1){
                            int localans = prev.len + 1 + next.len;
                            ans = Math.max(ans, localans);
                        }
                        else{
                            int localans = prev.len + 1;
                            ans = Math.max(ans, localans);
                            localans = next.len + 1;
                            ans = Math.max(ans, localans);
                        }
                    }
                    else if( i - 1 >= 0 && i + 1 >= vec.size()){
                        Group prev = vec.get(i-1);
                        int localans = prev.len + 1;
                        ans = Math.max(ans, localans);
                    }
                    else if(i -1 < 0 && i + 1 < vec.size()){
                        Group next = vec.get(i+1);
                        int localans = next.len + 1;
                        ans = Math.max(ans, localans);
                    }
                }
                else{
                    if(i - 1 >= 0){
                        Group prev = vec.get(i - 1);
                        int lprev = prev.endnum;
                        int newfp = lprev + 1;
                        if(process.stind + 1 < n && newfp < ar[process.stind + 1]){
                            int localans = prev.len + process.len;
                            ans = Math.max(ans, localans);
                        }
                        ans = Math.max(ans, process.len + 1);
                    }
                    if(i + 1 < vec.size()){
                        Group next = vec.get(i + 1);
                        int fnext = next.stnum;
                        int newlp = fnext - 1;
                        if(process.endind - 1 >= 0 && newlp > ar[process.endind-1]){
                            int localans = next.len + process.len;
                            ans = Math.max(ans, localans);
                        }
                        ans = Math.max(ans, process.len + 1);
                    }
                }
                ans = Math.max(ans, process.len);
            }
            System.out.println(ans);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class Group{
    int len;
    int stind;
    int endind;
    int stnum;
    int endnum;
    public Group(int l, int si, int ei, int sn, int en){
        this.len = l;
        this.stind = si;
        this.endind = ei;
        this.stnum = sn;
        this.endnum = en;
    }
    public String toString(){
        return this.len+" "+this.stind+" "+this.endind+" "+this.stnum+" "+this.endnum;
    }
}

class InputReader {
    private boolean finished = false;

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int peek() {
        if (numChars == -1)
            return -1;
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                return -1;
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar];
    }

    public int readInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public long readLong() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public String readString() {
        int length = readInt();
        if (length < 0)
            return null;
        byte[] bytes = new byte[length];
        for (int i = 0; i < length; i++)
            bytes[i] = (byte) read();
        try {
            return new String(bytes, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            return new String(bytes);
        }
    }

    public static boolean isSpaceChar(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    private String readLine0() {
        StringBuffer buf = new StringBuffer();
        int c = read();
        while (c != '\n' && c != -1) {
            if (c != '\r')
                buf.appendCodePoint(c);
            c = read();
        }
        return buf.toString();
    }

    public String readLine() {
        String s = readLine0();
        while (s.trim().length() == 0)
            s = readLine0();
        return s;
    }

    public String readLine(boolean ignoreEmptyLines) {
        if (ignoreEmptyLines)
            return readLine();
        else
            return readLine0();
    }

    public BigInteger readBigInteger() {
        try {
            return new BigInteger(readString());
        } catch (NumberFormatException e) {
            throw new InputMismatchException();
        }
    }

    public char readCharacter() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        return (char) c;
    }

    public double readDouble() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        double res = 0;
        while (!isSpaceChar(c) && c != '.') {
            if (c == 'e' || c == 'E')
                return res * Math.pow(10, readInt());
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        }
        if (c == '.') {
            c = read();
            double m = 1;
            while (!isSpaceChar(c)) {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, readInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                m /= 10;
                res += (c - '0') * m;
                c = read();
            }
        }
        return res * sgn;
    }

    public boolean isExhausted() {
        int value;
        while (isSpaceChar(value = peek()) && value != -1)
            read();
        return value == -1;
    }

    public String next() {
        return readString();
    }

    public boolean readBoolean() {
        return readInt() == 1;
    }
}
