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].
import java.util.*;
import java.math.*;
import java.io.*;
public class Luck{
	public static InputReader sc;
    public static PrintWriter out;
    public static final long MOD = (long) (1e9 + 7);
    public static void main(String[] args){
    	sc=new InputReader(System.in);	
    	out=new PrintWriter(System.out);
    	int n=sc.nextInt();
    	int[] A=new int[n+1];
    	for(int i=1;i<=n;i++){
    		A[i]=sc.nextInt();
    	}
    	TreeMap<Integer,Integer> max=new TreeMap<Integer,Integer>();
    	//TreeMap<Integer,Integer> min=new TreeMap<Integer,Integer>();
    	max.put(A[1],1);
    	//min.put(A[1],1);
    	int l=1;
    	int r=1;
    	int ans=Integer.MIN_VALUE;
    	while(r<=n){
    		if(max.lastKey()-max.firstKey()<=1){
    			ans=Math.max(ans, r-l+1);
    			r+=1;
    			if(r==n+1){
    				break;
    			}
    			if(max.containsKey(A[r])){
    				max.put(A[r], max.get(A[r])+1);
    			}
    			else{
    				max.put(A[r],1);
    			}
//    			if(min.containsKey(A[r])){
//    				min.put(A[r], min.get(A[r])+1);
//    			}
//    			else{
//    				min.put(A[r], 1);
//    			}
    		}
    		else{
    				if(max.get(A[l])==1){
    					max.remove(A[l]);
    				}
    				else{
    					max.put(A[l],max.get(A[l])-1);
    				}
//    				if(min.get(A[l])==1){
//    					min.remove(A[l]);
//    				}
//    				else{
//    					min.put(A[l], min.get(A[l])-1);
//    				}
    			l+=1;
    			
    		}
    	}
    	out.println(ans);
    	out.close();
    }
    static class Pair{
    	int profit;
    	int val;
    	Pair(){
    		this.profit=-1;
    		this.val=-1;
    	}
    	Pair(int profit,int val){
    		this.profit=profit;
    		this.val=val;
    	}
    	public static Comparator<Pair> Val=new Comparator<Pair>(){
    		public int compare(Pair p1,Pair p2){
    			return (int)p1.profit-(int)p2.profit;
    		}
    	};
    	public int hashCode() {
    		final int prime = 31;
    		int result = 1;
    		result = prime * result + profit;
    		result = prime * result + val;
    		return result;
    	}
    	public boolean equals(Object obj){
    		if (this == obj)
    	        return true;
    	    if (!(obj instanceof Pair)) {
    	        return false;
    	    }
    	 
    	    Pair p = (Pair) obj;
    	    if(p.profit!=this.profit){
    	    	return false;
    	    }
    	    else if(p.val!=p.val){
    	    	return false;
    	    }
    	    return true;
    	}
    }
//    static int val;
//    static class DisjointSet{
//    	int n;
//    	int[] par;
//    	int[] rank;
//    	DisjointSet(int n){
//    		this.n=n;
//    		this.par=new int[n];
//    		this.rank=new int[n];
//    		makeSet();
//    	}
//    	void makeSet(){
//    		for(int i=1;i<n;i++){
//    			par[i]=i;
//    			rank[i]=1;
//    		}
//    	}
//    	void union(int x,int y){
//    		int parX=parent(x);
//    		int parY=parent(y);
//    		if(parX!=parY){
//    			if(rank[parX]>=rank[parY]){
//    				rank[parX]+=rank[parY];
//    				rank[parY]=0;
//    				par[parY]=parX;
//    			}
//    			else{
//    				rank[parY]+=rank[parX];
//    				rank[parX]=0;
//    				par[parX]=parY;
//    			}
//    			val-=1;
//    		}
//    	}
//    	int parent(int c){
//    		int i=c;
//    		while(i!=par[i]){
//    			i=par[i];
//    		}
//    		return i;
//    	}
//    }
    static int gcd(int a,int b){
    	if(b==0){
    		return a;
    	}
    	return gcd(b,a%b);
    	
    }
    static int lcm(int a,int b){
    	int g;
    	if(a<b){
    		g=gcd(b,a);
    	}
    	else{
    		g=gcd(a,b);
    	}
    	return (a*b)/g;
    }
    static long bigmod ( long a, long p, long m ) {
        long res = 1 % m, x = a % m;
        while ( p>0 ) {
            if ( (p & 1)==1 ) res = ( res * x ) % m;
            x = ( x * x ) % m; p >>= 1;
        }
        return res;
    }
    static boolean isPrime(int n){
    	 if (n == 2)
    	        return true;
    	    for (long i = 2; i * i <= n; i++) {
    	        if (n % i == 0)
    	            return false;
    	    }
    	    return true;
    }
    
    static void shuffle(int[] A){
    	for(int i=A.length-1;i>0;i--){
    		int j=(int)(Math.random()*(i+1));
    		int temp=A[j];
    		A[j]=A[i];
    		A[i]=temp;
    	}
    }
    
	public static class Node implements Comparable<Node>{
	    int u;
	    int v;
	    public Node(){
	    	;
	    }
	    public Node (int u, int v) {
	    	this.u = u;
	        this.v = v;
	    }
	    
	    public void print() {
	        out.println(v + " " + u + " ");
	    }
	   
	    public int compareTo(Node n1){
	    	return this.u-n1.u;
	    }
	}
	public static long pow(long base,long exp,long mod){
		if(exp==0){
			return 1;
		}
		if(exp==1){
			return base;
		}
		long temp=exp/2;
		long val=pow(base,temp,mod);
		long result=val*val;
		result=(result%mod);
		long AND=exp&1;
		if(AND==1){
			result*=base;
			result=(result%mod);
		}
		return result;
	}
	public static BigInteger pow(BigInteger base, BigInteger exp) {
	    if(exp.equals(new BigInteger(String.valueOf(0)))){
	        return new BigInteger(String.valueOf(1));
	    }    
	    if(exp.equals(new BigInteger(String.valueOf(1))))
	        return base;
	    BigInteger temp=exp.divide(new BigInteger(String.valueOf(2)));
	    BigInteger val = pow(base, temp);
	    BigInteger result = val.multiply(val);
	    result=result.remainder(new BigInteger(String.valueOf(MOD)));
	    BigInteger AND=exp.and(new BigInteger(String.valueOf(1)));
	    if(AND.equals(new BigInteger(String.valueOf(1)))){
	        result = result.multiply(base);
	        result=result.remainder(new BigInteger(String.valueOf(MOD)));
	    }    
	    return result;
	}
	    
	static class InputReader {

	    private InputStream stream;
	    private byte[] buf = new byte[8192];
	    private int curChar, snumChars;
	    private SpaceCharFilter filter;

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

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

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

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

	    public int[] nextIntArray(int n) {
	        int a[] = new int[n];
	        for (int i = 0; i < n; i++)
	            a[i] = nextInt();
	        return a;
	    }

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

	    public boolean isSpaceChar(int c) {
	        if (filter != null)
	            return filter.isSpaceChar(c);
	        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	    }

	    public interface SpaceCharFilter {
	        public boolean isSpaceChar(int ch);
	    }
	}

}

