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].
//package c333;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.InputMismatchException;
import java.util.Scanner;
import java.util.StringTokenizer;



public class q2 
{

    
    public static void main(String args[])
    {
        FasterScanner s=new FasterScanner();
        int n=s.nextInt();
        int a[]=new int[n];
        for(int i=0;i<n;i++)
        {
            a[i]=s.nextInt();
        }
        
        SegMin min=new SegMin(a, Integer.MAX_VALUE);
        SegMex max=new SegMex(a, 0);
        
        int l=0;
        int r=0;
        int ans=0;
        while(l!=n && r!=n)
        {
            if(max.query(l, r+1)-min.query(l, r+1)<=1)
                {
                r++;
                ans=Math.max(ans, r-l);
                }
            else
                l++;
        }
        System.out.println(ans);
    }
    
    public static long gcd(long a, long b) 
    {

        if(a==b)
            return a;
        if(a==0)
            return b;
        if(b==0)
            return a;

        if(a>b)
            return gcd(b,a%b);
        else
            return gcd(a,b%a);
    }

    public static long modPow( long a, long b, long mod )
    {
        long res=1,pow=a;
        while( b>0 )
        {
            if( (b&1)==1 )
            {
                res = (pow*res)%mod;
            }
            pow = (pow*pow)%mod;
            b=b/2;
        }
        return res;
    }
    
    static class nck
    {
        public static long ncr[][];
        
        public nck(long z,long p)//z==maxvalue  p==mod
        {
            generateNCR(z, p);
        }
        
        private static void generateNCR( long z, long p )
        {
            ncr = new long[(int)z+1][(int)z+1];
            ncr[0][0] = 1;
            for(int i=1; i<=z; i++)
            {
                ncr[i][0] = 1;
                ncr[0][i] = 0;
            }
            for(int i=1; i<=z; i++)
            {
                for(int j=1; j<=z; j++)
                {
                    ncr[i][j] = (ncr[i-1][j] + ncr[i-1][j-1]) % p;
                }
            }
        }

        private static long lucas(long n, long k, long p) 
        {
        
            long ans = 1;
            
            while(n>0)
            {
                int N = (int)(n%p);
                int K = (int)(k%p);
                if(K>N)
                    return 0;
                ans *= (ncr[N][K] );
                n /= p;
                k /= p;
            }
            return ans % p;
        
    }
    }
    
    
    

    
    

    
    
    
    
    static class SegMin
    {
        static int seg[];
        static int dp[];
        int n;
        int d;
        public SegMin(int[] arr,int defaul)
        {
            this.dp=arr;
            n=dp.length;
            seg=new int[4*arr.length];
            build(1,0,n);
            this.d=defaul;
        }

        public void build(int id,int l,int r){
            if(r-l<2){
                seg[id]=dp[l];
                return;
            }
            int mid=(l+r)/2;
            build(2*id,l,mid);
            build(2*id+1,mid,r);
            seg[id]=merge(seg[2*id],seg[2*id+1]);
        }

        public int query(int l,int r)
        {
            return givemin(1,l,r,0,n);
        }

        public  int givemin(int id,int x,int y,int l,int r){
            if(x<=l && y>=r){
                return seg[id];
            }
            if(y<=l || r<=x){
                return d;
            }
            int mid=(l+r)/2;
            return merge(givemin(2*id, x, y, l, mid),givemin(2*id+1, x, y, mid, r));
        }

        public int upd(int id,int value)
        {
            return update(1,id,value,0,n);
        }
        public  int update(int id,int p,int value,int l,int r){
            if(r-l<2){
                dp[p]=value;
                seg[id]=value;
                return value;
            }
            int mid=(l+r)/2;
            if(p<mid){
                update(2*id, p, value, l, mid);
                seg[id]=merge(seg[2*id], seg[2*id+1]);
                return seg[id];
            }
            else{
                update(2*id+1, p, value, mid,r);
                seg[id]=merge(seg[2*id+1], seg[2*id]);
                return seg[id];

            }
        }

        public int merge(int l,int r)
        {

            //set initial value
            return Math.min(l, r);
        }
    }

    
    static class SegMex
    {
        static int seg[];
        static int dp[];
        int n;
        int d;
        public SegMex(int[] arr,int defaul)
        {
            this.dp=arr;
            n=dp.length;
            seg=new int[4*arr.length];
            build(1,0,n);
            this.d=defaul;
        }

        public void build(int id,int l,int r){
            if(r-l<2){
                seg[id]=dp[l];
                return;
            }
            int mid=(l+r)/2;
            build(2*id,l,mid);
            build(2*id+1,mid,r);
            seg[id]=merge(seg[2*id],seg[2*id+1]);
        }

        public int query(int l,int r)
        {
            return givemin(1,l,r,0,n);
        }

        public  int givemin(int id,int x,int y,int l,int r){
            if(x<=l && y>=r){
                return seg[id];
            }
            if(y<=l || r<=x){
                return d;
            }
            int mid=(l+r)/2;
            return merge(givemin(2*id, x, y, l, mid),givemin(2*id+1, x, y, mid, r));
        }

        public int upd(int id,int value)
        {
            return update(1,id,value,0,n);
        }
        public  int update(int id,int p,int value,int l,int r){
            if(r-l<2){
                dp[p]=value;
                seg[id]=value;
                return value;
            }
            int mid=(l+r)/2;
            if(p<mid){
                update(2*id, p, value, l, mid);
                seg[id]=merge(seg[2*id], seg[2*id+1]);
                return seg[id];
            }
            else{
                update(2*id+1, p, value, mid,r);
                seg[id]=merge(seg[2*id+1], seg[2*id]);
                return seg[id];

            }
        }

        public int merge(int l,int r)
        {

            //set initial value
            return Math.max(l,r);
        }
    }

    

    static class UF {

        private int[] parent;  // parent[i] = parent of i
        private byte[] rank;   // rank[i] = rank of subtree rooted at i (never more than 31)
        private int count;   
        int[] seg;
        int max;
        // number of components
        public UF(int N) {
            if (N < 0) throw new IllegalArgumentException();
            count = N;
            parent = new int[N];
            rank = new byte[N];
            seg=new int[N];
            for (int i = 0; i < N; i++) {
                parent[i] = i;
                rank[i] = 0;
                seg[i]=1;
            }
            max=1;
        }

        public int find(int p) {
            if (p < 0 || p >= parent.length) throw new IndexOutOfBoundsException();
            while (p != parent[p]) {
                parent[p] = parent[parent[p]];    // path compression by halving
                p = parent[p];
            }
            return p;
        }
        public int count() {
            return count;
        }

        public boolean connected(int p, int q) {
            return find(p) == find(q);
        }

        public boolean union(int p, int q) {
            //    System.out.println("uf "+p+" "+q);
            int rootP = find(p);
            int rootQ = find(q);
            if (rootP == rootQ) return false;

            // make root of smaller rank point to root of larger rank
            if      (rank[rootP] < rank[rootQ])
            {
                parent[rootP] = rootQ;
                seg[rootQ]+=seg[rootP];
                max=Math.max(seg[rootQ],max);
            }
            else if (rank[rootP] > rank[rootQ])
            {
                parent[rootQ] = rootP;
                seg[rootP]+=seg[rootQ];
                max=Math.max(seg[rootP],max);
            }
            else {
                parent[rootQ] = rootP;
                rank[rootP]++;
                seg[rootP]+=seg[rootQ];
                max=Math.max(seg[rootP],max);
            }
            count--;
            return true;
        }

    }



    static class SparseTable
    {
        int[][] st;
        public SparseTable(int[] h){
            int n=h.length;
            int MAX_LOG=(int)Math.ceil(Math.log(n)/Math.log(2))+1;
            st=new int[n][MAX_LOG];
            for (int i = 0; i < n; i++)
                st[i][0] = h[i];
            for (int j = 1; (1 << j) <= n; j++)
            {
                for (int i = 0;( i + (1 << j) - 1 )< n; i++)
                {
                    st[i][j]=Math.max(st[i][j-1],st[i+(1<<(j-1))][j-1]);
                }
            }
        }
        public int query(int l,int r)
        {
            int x=(int )Math.floor((Math.log(r-l+1)/Math.log(2)));
            int ans=Math.max(st[l][x],st[r-(1<<x)+1][x]);
            return ans;
        }

    }

    public static class FasterScanner {
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

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

        public String nextLine() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndOfLine(c));
            return res.toString();
        }

        public String nextString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public long nextLong() {
            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 int nextInt() {
            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 int[] nextIntArray(int n) {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextInt();
            }
            return arr;
        }

        public long[] nextLongArray(int n) {
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextLong();
            }
            return arr;
        }

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

        private boolean isEndOfLine(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }
    }

}
