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






public class Main {
    static Scanner input = new Scanner(System.in);
    final static double EPS = 1e-8;
    //static boolean[][] vis;
    static ArrayList<ArrayList<Long>> graph;
    static boolean[] vis;
    static char grid[][];
    static int n; 
    static int m; 
    static int x; 
    static int y;
    static ArrayList<Integer> lengths;
    static int[] length;
    static Stack<Integer> s = new Stack<>();
    static ArrayList<Integer> topo;
    static int count;
    static int arr[];
    static int arrx[];
    static int arrh[];
    static Stack[] arrS;
    static char[] charArr;
    static int[] d;
    static int[] d4x = {-1, 1, 0, 0};
    static int[] d4y = {0, 0, -1, 1};
	
    
    public static class Pair implements Comparable<Pair> {
    	int id;
    	int m;
		public Pair(int nextInt, int nextInt2) {
			id = nextInt;
			m = nextInt2;
		}
		@Override
		public int compareTo(Pair o) {
			if (m > o.m)
				return -1;
			return 0;
		}
    	
		@Override
		public String toString() {
			return id + " " + m;
		}
    	
    }
	
	
    
    
	public static void main(String[] args) {
		int n = input.nextInt();
		int arr[] = new int[n];
		
		if (n < 3)
			System.out.println(n);
		else {
			for (int i = 0; i < n; i++)
				arr[i] = input.nextInt();
			
			int fmin = 0, lmin = 0, fmax = 0, lmax = 0;
				
			int first = 1;
			
		
			if (arr[0] < arr[first]) {
				fmin = 0;
				lmin = 0;
				fmax = first;
				lmax = first;
			}
			else if (arr[0] > arr[first]){
				fmin = first;
				lmin = first;
				lmax = 0;
				fmax = 0;
			}
			else {
				for (int i = 1; i < n; i++)
					if (arr[i] != arr[0]) {
						first = i;
						break;
					}
				

				if (arr[0] < arr[first]) {
					fmin = 0;
					lmin = first - 1;
					fmax = first;
					lmax = first;
				}
				else if (arr[0] > arr[first]){
					fmin = first;
					lmin = first;
					lmax = first - 1;
					lmin = 0;
				}
				
				
			}
			
			
			ArrayList<Integer> ans = new ArrayList<Integer>();
	 		int i = first + 1;
			for (; i < n; i++) {
				if (arr[i] == arr[fmin])
					lmin = i;
				else if (arr[i] == arr[fmax])
					lmax = i;
				else if (arr[i] > arr[fmax]) {
					ans.add(i - Math.min(fmin, fmax));
					fmin = lmin + 1;
					lmin = lmax;
					lmax = i;
					fmax = i;
				}
				else if (arr[i] < arr[fmin]) {
					ans.add(i - Math.min(fmin, fmax));
					fmax = lmax + 1;
					lmax = lmin;
					lmin = i;
					fmin = i;
				}
				
				//System.out.println(fmin + " " + lmin + " " + fmax + " " + lmax);

			}
			ans.add(i - Math.min(fmin, fmax));
			
			Collections.sort(ans);
			//System.out.println(ans);
			System.out.println(ans.get(ans.size() - 1));
		}
	}
	
	
	
	
	
	
	
	
	

}

