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.*;//building towers
import java.util.*;

/**
 * @author master_j
 * @version 0.4
 * @since May 3, 2014
 */
public class Main {
    class Three {
        int start, end, val;

        Three(int start, int end, int val) {
            this.start = start;
            this.end = end;
            this.val = val;
        }
    }

    private void solve() throws IOException {
        int n = io.nI();
        int[] a = new int[n];
        for(int i = 0; i < n; i++)
            a[i] = io.nI();

        boolean ok = true;
        for(int i = 1; i < n && ok; i++)
            if(a[i - 1] >= a[i])
                ok = false;
        if(ok){
            io.wln(n);
            return;
        }

        List<Three> list = new ArrayList<>();
        boolean[] banned = new boolean[n];
        int last = a[0], count = 1, begin = 0;
        for(int i = 1; i < n; i++){
            int t = a[i];
            if(last >= t){
                list.add(new Three(begin, i - 1, count));
                count = 1;
                begin = i;
            }else
                count++;
            last = t;
            if(i + 1 < n && a[i + 1] - a[i - 1] < 2)
                banned[i] = true;
        }
        list.add(new Three(begin, n - 1, count));
        int ans = -1;
        for(int i = 1; i < list.size(); i++)
            if(!banned[list.get(i).start] || !banned[list.get(i - 1).end])
                ans = Math.max(ans, list.get(i - 1).val + list.get(i).val);
        for(Three t : list)
            ans = Math.max(ans, t.val + 1);
        io.wln(ans);
    }//2.2250738585072012e-308

    public static void main(String[] args) throws IOException {
        IO.launchSolution(args);
    }

    Main(IO io) throws IOException {
        this.io = io;
        solve();
    }

    private final IO io;
}

class IO {
    static final String _localArg = "master_j";
    private static final String _problemName = "";
    private static final IO.Mode _inMode = Mode.STD_;
    private static final IO.Mode _outMode = Mode.STD_;
    private static final boolean _autoFlush = false;

    static enum Mode {STD_, _PUT_TXT, PROBNAME_}

    private final StreamTokenizer st;
    private final BufferedReader br;
    private final Reader reader;

    private final PrintWriter pw;
    private final Writer writer;

    static void launchSolution(String[] args) throws IOException {
        boolean local = (args.length == 1 && args[0].equals(IO._localArg));
        IO io = new IO(local);

        long nanoTime = 0;
        if (local) {
            nanoTime -= System.nanoTime();
            io.wln("<output>");
        }

        io.flush();
        new Main(io);
        io.flush();

        if(local){
            io.wln("</output>");
            nanoTime += System.nanoTime();
            final long D9 = 1000000000, D6 = 1000000, D3 = 1000;
            if(nanoTime >= D9)
                io.wf("%d.%d seconds\n", nanoTime/D9, nanoTime%D9);
            else if(nanoTime >= D6)
                io.wf("%d.%d millis\n", nanoTime/D6, nanoTime%D6);
            else if(nanoTime >= D3)
                io.wf("%d.%d micros\n", nanoTime/D3, nanoTime%D3);
            else
                io.wf("%d nanos\n", nanoTime);
        }

        io.close();
    }

    IO(boolean local) throws IOException {
        if(_inMode == Mode.PROBNAME_ || _outMode == Mode.PROBNAME_)
            if(_problemName.length() == 0)
                throw new IllegalStateException("You imbecile. Where's my <_problemName>?");

        if(_problemName.length() > 0)
            if(_inMode != Mode.PROBNAME_ && _outMode != Mode.PROBNAME_)
                throw new IllegalStateException("You imbecile. What's the <_problemName> for?");

        Locale.setDefault(Locale.US);

        if (local) {
            reader = new FileReader("input.txt");
            writer = new OutputStreamWriter(System.out);
        } else {
            switch (_inMode) {
                case STD_:
                    reader = new InputStreamReader(System.in);
                    break;
                case PROBNAME_:
                    reader = new FileReader(_problemName + ".in");
                    break;
                case _PUT_TXT:
                    reader = new FileReader("input.txt");
                    break;
                default:
                    throw new NullPointerException("You imbecile. Gimme _inMode.");
            }
            switch (_outMode) {
                case STD_:
                    writer = new OutputStreamWriter(System.out);
                    break;
                case PROBNAME_:
                    writer = new FileWriter(_problemName + ".out");
                    break;
                case _PUT_TXT:
                    writer = new FileWriter("output.txt");
                    break;
                default:
                    throw new NullPointerException("You imbecile. Gimme _outMode.");
            }
        }

        br = new BufferedReader(reader);
        st = new StreamTokenizer(br);

        pw = new PrintWriter(writer, _autoFlush);

        if(local && _autoFlush)
            wln("Note: auto-flush is on.");
    }

    void wln()          {pw.println(); }
    void wln(boolean x) {pw.println(x);}
    void wln(char x)    {pw.println(x);}
    void wln(char x[])  {pw.println(x);}
    void wln(double x)  {pw.println(x);}
    void wln(float x)   {pw.println(x);}
    void wln(int x)     {pw.println(x);}
    void wln(long x)    {pw.println(x);}
    void wln(Object x)  {pw.println(x);}
    void wln(String x)  {pw.println(x);}

    void wf(String f, Object...o){pw.printf(f, o);}

    void w(boolean x)   {pw.print(x);}
    void w(char x)      {pw.print(x);}
    void w(char x[])    {pw.print(x);}
    void w(double x)    {pw.print(x);}
    void w(float x)     {pw.print(x);}
    void w(int x)       {pw.print(x);}
    void w(long x)      {pw.print(x);}
    void w(Object x)    {pw.print(x);}
    void w(String x)    {pw.print(x);}

    int nI() throws IOException    {st.nextToken(); return (int)st.nval;}
    double nD() throws IOException {st.nextToken(); return st.nval;}
    float nF() throws IOException  {st.nextToken(); return (float)st.nval;}
    long nL() throws IOException   {st.nextToken(); return (long)st.nval;}
    String nS() throws IOException {st.nextToken(); return st.sval;}

    void wc(String x){ wc(x.toCharArray()); }
    void wc(char c1, char c2){for(char c = c1; c<=c2; c++)wc(c);}
    void wc(char x[]){
        for(char c : x)
            wc(c);
    }
    void wc(char x){st.ordinaryChar(x); st.wordChars(x, x);}

    public boolean eof() {return st.ttype == StreamTokenizer.TT_EOF;}
    public boolean eol() {return st.ttype == StreamTokenizer.TT_EOL;}

    void flush(){pw.flush();}
    void close() throws IOException{reader.close(); br.close(); flush(); pw.close();}
}