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.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.InputMismatchException;

public class MainClass {
	InputReader ir ; 
	public MainClass(){
		ir = new InputReader(System.in);
		int n = ir.nextInt();
		SegTreeMAX stmax = new SegTreeMAX(n);
		SegTreeMIN stmin = new SegTreeMIN(n);

		int x ;
		for(int i=0;i<n;i++){
			x = ir.nextInt();
			stmax.update(i, x);
			stmin.update(i, x);
		}
		int s = 0 ;
		int t = 1 ;
		int ans = 1;
		 for (;;) {
		        while (t <= n) {
		            if (stmax.q(s, t) - stmin.q(s, t) <= 1) {
		                t++;
		            } else break;
		        }
		        ans = Math.max(ans, ((t>n)?n:t)-s);
		        if (t > n) break;
		        while (stmax.q(s, t) - stmin.q(s, t) > 1) s++;
		        ans = Math.max(ans, t-s);
		        
		    }
		System.out.println(ans);
		
	
	}
	
	public static void main(String[] Args){	
		new MainClass();
	}
	
	public class InputReader {
		private int lenbuf = 0;
	    private int ptrbuf = 0;
	    private InputStream in;
	    private byte[] inbuf = new byte[1024];

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

	    private int readByte() {
	        if (lenbuf == -1) throw new InputMismatchException();
	        if (ptrbuf >= lenbuf) {
	            ptrbuf = 0;
	            try {
	                lenbuf = in.read(inbuf);
	            } catch (IOException e) {
	                throw new InputMismatchException();
	            }
	            if (lenbuf <= 0) return -1;
	        }
	        return inbuf[ptrbuf++];
	    }

	    public int nextInt() {
	        int num = 0, b;
	        boolean minus = false;
	        while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
	        if (b == '-') {
	            minus = true;
	            b = readByte();
	        }

	        while (true) {
	            if (b >= '0' && b <= '9') {
	                num = num * 10 + (b - '0');
	            } else {
	                return minus ? -num : num;
	            }
	            b = readByte();
	        }
	    }

	    public int[] nextIntArray(int n) {
	        int[] a = new int[n];
	        for (int i = 0; i < n; i++) a[i] = nextInt();
	        return a;
	    }
	}
	public class SegTreeMIN {
		private int N ;
		private int treeSize ;
		int [] tree ;
		
		public SegTreeMIN(int n){
			N = 1;
	        while (N < n) N *= 2;
			tree = new int[2*N-1];
			Arrays.fill(tree, Integer.MAX_VALUE);
		}
		
		void update(int i , int x){
			i += N - 1 ;
			tree[i] = x ;
			while(i!=0){
				i = (i-1)/2;
				tree[i] = Math.min(tree[i*2+1], tree[i*2+2]);
			}
		}
		
		int q(int a ,int b){
			b++;
			return query(a,b,0,0,N);
		}
		int query(int a,int b ,int k ,int d ,int f){
			if(a >=f || b <=d)
				return Integer.MAX_VALUE;
			if(a <= d && b >= f)
				return  tree[k];
			return Math.min(query(a,b,k*2+1,d,(d+f)/2),query(a,b,k*2+2,(d+f)/2,f));
		}
		
	}
	public class SegTreeMAX {

		private int N ;
		private int treeSize ;
		int [] tree ;
		
		public SegTreeMAX(int n){
			N = 1;
	        while (N < n) N *= 2;
			tree = new int[2*N-1];
			Arrays.fill(tree, Integer.MIN_VALUE);
		}
		
		void update(int i , int x){
			i += N - 1 ;
			tree[i] = x ;
			while(i!=0){
				i = (i-1)/2;
				tree[i] = Math.max(tree[i*2+1], tree[i*2+2]);
			}
		}
		
		int q(int a ,int b){
			b++;
			return query(a,b,0,0,N);
		}
		int query(int a,int b ,int k ,int d ,int f){
			if(a >=f || b <=d)
				return Integer.MIN_VALUE;
			if(a <= d && b >= f)
				return  tree[k];
			return Math.max(query(a,b,k*2+1,d,(d+f)/2),query(a,b,k*2+2,(d+f)/2,f));
		}
		
		
	}
}
