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.Scanner;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;

public class mainClass {
	
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		HashMap<Integer, List<Integer>> map = new HashMap<Integer, List<Integer>>();	
		List<Integer> help = new ArrayList<Integer>();
		for (int a = 0; a < 100002; a++) {
			List<Integer> list = new ArrayList<Integer>();
			map.put(a, list);
		}
		for (int i = 0; i < n; i++) {
			int b = in.nextInt();
		
			help = map.get(b);		
			help.add(i);
			map.put(b, help);
		//	System.out.println(map);
			help = map.get(b + 1);
			help.add(i);
			map.put(b + 1, help);
		//	System.out.println(map);
		}
		int max = 1;
		int curr = 1;
		for (int i : map.keySet()) {
			help = map.get(i);
			for (int j = 1; j < help.size(); j++) {
				if (help.get(j) == help.get(j - 1) + 1) {
					curr++;
				} else {
					max = Math.max(max, curr);
					curr = 1;
				}
				max = Math.max(curr, max);
			}
			curr = 1;
		}
		System.out.println(max);
		
		/*
		int[][] matr = new int[n][2];
		Arrays.fill(matr, 0);
		matr[0][0] = 1;
		matr[0][1] = 1;
		for (int i = 1; i < n; i++) {
			for (int j = 0; j < 2; j++) {
				if (arr[i] == arr[i - 1]) {
					matr[i][j] = matr[i - 1][j] + 1;
				} else if (arr[i] == arr[i - 1] + 1 && j == 1) {
					matr[i][j] = matr[i - 1][0];
				} else if (arr[i] == arr[i - 1] - 1 && j == 0) {
					matr[i][j] = matr[i - 1][1];
				} else {
					matr[i][j] = 1;
				}
			}
		}
		*/
		
	
		
		
		
	}
}
