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

public class A
{

    FastScanner in;
    PrintWriter out;
    int i = 0, j = 0;


    void solve()
    {
        /**************START**************/
        int n = in.nextInt();
        int[] a = new int[n];
        for (i = 0; i < n; i++)
            a[i] = in.nextInt();
        if (n < 3)
        {
            out.println(n);
            return;
        }
        int[] left = new int[n], right = new int[n];
        left[0] = 1;
        right[n-1] = 1;
        for (i = 1; i < n; i++)
        {
            if (a[i] > a[i-1])
                left[i] = left[i-1]+1;
            else
                left[i] = 1;
            if (a[n-i] > a[n-i-1])
                right[n-i-1] = right[n-i]+1;
            else
                right[n-i-1] = 1;
        }
        int high = Math.max(right[1], left[n-2])+1;
        for (i = 1; i < n-1; i++)
        {
            int amt = 1;
            if (a[i+1] - a[i-1] > 1)
                amt += (left[i-1]+right[i+1]);
            else
            {
                amt += Math.max(left[i-1], right[i+1]);
            }
            high = Math.max(high, amt);

        }
        out.println(high);


        /***************END***************/
    }

    public static void main(String[] args)
    {
        new A().runIO();
    }

    void runIO()
    {
        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);

        solve();

        out.close();
    }

    void printGrid(char[][] g)
    {
        for (int a = 0; a < g.length; a++)
        {
            out.println(new String(g[a]));
        }
    }

    class FastScanner
    {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(File f)
        {
            try
            {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e)
            {
                e.printStackTrace();
            }
        }

        public FastScanner(InputStream f)
        {
            br = new BufferedReader(new InputStreamReader(f));
        }

        String next()
        {
            while (st == null || !st.hasMoreTokens())
            {
                String s = null;
                try
                {
                    s = br.readLine();
                } catch (IOException e)
                {
                    e.printStackTrace();
                }
                if (s == null)
                    return null;
                st = new StringTokenizer(s);
            }
            return st.nextToken();
        }

        //This will empty out the current line (if non-empty) and return the next line down. If the next line is empty, will return the empty string.
        String nextLine()
        {
            st = null;
            String s = null;
            try
            {
                s = br.readLine();
            } catch (IOException e)
            {
                e.printStackTrace();
            }
            return s;
        }

        boolean hasMoreTokens()
        {
            while (st == null || !st.hasMoreTokens())
            {
                String s = null;
                try
                {
                    s = br.readLine();
                } catch (IOException e)
                {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        double[] getDoubleArray(int s)
        {
            double[] arr = new double[s];
            for (int d = 0; d < s; d++)
            {
                arr[d] = in.nextDouble();
            }
            return arr;
        }

        int[] getIntArray(int s)
        {
            int[] arr = new int[s];
            for (int d = 0; d < s; d++)
            {
                arr[d] = in.nextInt();
            }
            return arr;
        }

        char[][] getCharGrid()
        {
            ArrayList<char[]> lines = new ArrayList<char[]>();
            String line = in.nextLine();
            while (line != null && line.length() == 0)
            {
                line = in.nextLine();
            }
            if (line == null)
            {
                return null;
            }
            while (line != null && line.length() > 0)
            {
                lines.add(line.toCharArray());
                line = in.nextLine();
            }
            char[][] grid = new char[lines.size()][];
            for (int l = 0; l < grid.length; l++)
            {
                grid[l] = lines.get(l);
            }
            return grid;


        }


        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }
    }
}
