When Xellos was doing a practice course in university, he once had to measure the intensity of an effect that slowly approached equilibrium. A good way to determine the equilibrium intensity would be choosing a sufficiently large number of consecutive data points that seems as constant as possible and taking their average. Of course, with the usual sizes of data, it's nothing challenging — but why not make a similar programming contest problem while we're at it?

You're given a sequence of n data points a1, ..., an. There aren't any big jumps between consecutive data points — for each 1 ≤ i < n, it's guaranteed that |ai + 1 - ai| ≤ 1.

A range [l, r] of data points is said to be almost constant if the difference between the largest and the smallest value in that range is at most 1. Formally, let M be the maximum and m the minimum value of ai for l ≤ i ≤ r; the range [l, r] is almost constant if M - m ≤ 1.

Find the length of the longest almost constant range.

Input

The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of data points.

The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100 000).

Output

Print a single number — the maximum length of an almost constant range of the given sequence.

Examples

Input

5
1 2 3 3 2


Output

4


Input

11
5 4 5 5 6 7 8 8 8 7 6


Output

5

Note

In the first sample, the longest almost constant range is [2, 5]; its length (the number of data points in it) is 4.

In the second sample, there are three almost constant ranges of length 4: [1, 4], [6, 9] and [7, 10]; the only almost constant range of the maximum length 5 is [6, 10].
/**
 * Created by Артур on 24.11.2015.
 *
 * Условие:
 * http://codeforces.com/contest/602/problem/B
 */

import java.io.*;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class p2015_11_15_CFR333div2_Prog2_ApproximationOfContinuousRange implements Runnable {

    final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    void init() throws FileNotFoundException {
        if (ONLINE_JUDGE) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        } else {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            try {
                tok = new StringTokenizer(in.readLine());
            } catch (Exception e) {
                return null;
            }
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    public static void main(String[] args) {
        new Thread(null, new p2015_11_15_CFR333div2_Prog2_ApproximationOfContinuousRange(), "", 256 * (1L << 20)).start();
    }

    long timeBegin, timeEnd;

    void time() {
        timeEnd = System.currentTimeMillis();
        System.err.println("Time = " + (timeEnd - timeBegin));
    }

    public void run() {
        try {
            timeBegin = System.currentTimeMillis();
            init();
            solve();
            out.close();
            time();
        } catch (Exception e) {
            e.printStackTrace(System.err);
            System.exit(-1);
        }
    }

    void solve() throws IOException {
        int amountOfNumbers=readInt();
        ArrayList<Integer> numbers = new ArrayList<Integer>();
        for (int i=0; i<amountOfNumbers;i++){
            numbers.add(readInt());
        }
        int a=0;
        int b=0;
        int c=0;
        int minIndex = 0;
        int lengthNow;
        int maxLength=0;
        int minIndexAfter=0;
        boolean knowB;
        boolean tr=true;

        while(minIndex<amountOfNumbers){
            minIndex=minIndexAfter;
            knowB=false;
            a=numbers.get(minIndex);
            lengthNow=1;
            while (minIndex+lengthNow<amountOfNumbers){
                c=numbers.get(minIndex+lengthNow);
                if (a==c){
                    lengthNow++;
                } else {
                    if(knowB){
                        if((c==a)||(c==b)){
                            lengthNow++;
                        } else {
                            if (lengthNow>maxLength){
                                maxLength=lengthNow;
                            }
                            break;
                        }
                    } else {
                        if((c==a-1)||(c==a+1)){
                            b=c;
                            lengthNow++;
                            knowB=true;
                            minIndexAfter=minIndex+lengthNow-1;
                        }
                    }
                }
            }
            if (lengthNow>maxLength){
                maxLength=lengthNow;
            }
            if (minIndex+lengthNow>=amountOfNumbers){
                minIndex=amountOfNumbers;
            }
        }
        out.println(maxLength);

        /*while(minIndexAfter<amountOfNumbers-1){
            minIndex=minIndexAfter;
            knowB=false;
            a=numbers.get(minIndex);
            lengthNow=1;
            b=0;
            c=0;
            while (minIndex+lengthNow<amountOfNumbers){
                lengthNow=0;
                c=numbers.get(minIndex+lengthNow);
                if (a==c){
                    lengthNow++;
                } else if (a!=c){
                    if (knowB){
                        if((a==c)||(b==c)){
                            lengthNow++;
                        } else {
                            if (lengthNow>maxLength){
                                maxLength=lengthNow;
                            }
                        }
                    } else {
                        if ((c==a-1)||(c==a+1)){
                            b=c;
                            lengthNow++;
                            knowB=true;
                            minIndexAfter=maxLength+lengthNow;
                        }
                    }
                }
                if ((minIndex+lengthNow)==amountOfNumbers-1){
                    if (lengthNow>maxLength){
                        maxLength=lengthNow;
                    }
                }
            }
        }
        out.println(maxLength);*/

        /*int numberNow = 0;
        int minIndex = 0;
        int maxLength = 1;
        int lengthNow = 0;
        int numberAfter = 0;
        int minIndexAfterLoop=0;
        int a;
        boolean tr=true;
        while ((minIndex<amountOfNumbers)){
            numberNow=numbers.get(minIndex);
            if (minIndex+1<amountOfNumbers) {
                numberAfter = numbers.get(minIndex+1);
            } else
            {
                break;
            }
            lengthNow=1;
            boolean minIndexChange=false;
            if ((numberAfter==numberNow-1)||(numberAfter==numberNow)||(numberAfter==numberNow+1)){
                while (true){
                    if (((numberAfter==numberNow-1)||(numberAfter==numberNow)||(numberAfter==numberNow+1))&(minIndex+lengthNow<amountOfNumbers)){
                        numberAfter=numbers.get(minIndex+lengthNow);
                        lengthNow++;
                        if (!minIndexChange){
                            if ((numberAfter==numberNow-1)||(numberAfter==numberNow+1)){
                                minIndexChange=true;
                                minIndex=minIndex+lengthNow-1;
                            }
                        }
                    } else {
                        if (lengthNow>maxLength){
                            maxLength=lengthNow;
                        }
                        minIndex++;
                        break;
                    }
                }
            } else {
                numberNow=numberAfter;
                minIndex++;
            }
        }
        out.println(maxLength);*/


    }
}