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 com.company;
        import java.io.BufferedReader;
        import java.io.IOException;
        import java.util.*;import java.io.InputStreamReader;

        public class Main{
            static class FastReader
            {
                BufferedReader br;
                StringTokenizer st;

                public FastReader()
                {
                    br = new BufferedReader(new
                            InputStreamReader(System.in));
                }

                String next()
                {
                    while (st == null || !st.hasMoreElements())
                    {
                        try
                        {
                            st = new StringTokenizer(br.readLine());
                        }
                        catch (IOException  e)
                        {
                            e.printStackTrace();
                        }
                    }
                    return st.nextToken();
                }

                int nextInt()
                {
                    return Integer.parseInt(next());
                }

                long nextLong()
                {
                    return Long.parseLong(next());
                }

              double  doublenextDouble()
                {
                    return Double.parseDouble(next());
                }

                String nextLine()
                {
                    String str = "";
                    try
                    {
                        str = br.readLine();
                    }
                    catch (IOException e)
                    {
                        e.printStackTrace();
                    }
                    return str;
                }
            }
            static int n;static int x=0;static int m;
            private static int max=Integer.MIN_VALUE;static long ans=Integer.MIN_VALUE;
            private static  LinkedList<Integer> adj[];private static LinkedList<Integer> g1=new LinkedList<Integer>();private static LinkedList<Integer> l=new LinkedList<Integer>();
            public static void main(String[] args){
                FastReader s=new FastReader();StringBuilder sb=new StringBuilder();
    //    int n=s.nextInt();//Queue<Integer>[] q=new LinkedList[1000000];
      //int n=s.nextInt();//char[]a=s.next().toCharArray();char[] b=s.next().toCharArray();
//      Stack<Integer> qa=new Stack<Integer>();Stack<Integer> qb=new Stack<Integer>();
        HashMap<Integer,Integer> h=new HashMap<Integer, Integer>();
                int n=s.nextInt();
        int[] a=new int[n];int st=n-1;int end=0;
        for(int i=0;i<n;i++) {
            a[i] = s.nextInt();
        }
            int j=0;int len=0;int min=a[0];int max=a[0];
        for(int i=0;i<n;i++){//len++;
            if(h.containsKey(a[i])){
                h.put(a[i],h.get(a[i])+1);
            }else h.put(a[i],1);
            if(a[i]<min){
                if(max-a[i]>1){if(len>ans) ans=len;
                    while(h.get(max)!=0){
                        len--;h.put(a[j],h.get(a[j])-1);j++;
                    }if(h.containsKey(a[i]+1)&&h.get(a[i]+1)>0){
                        max=a[i]+1;min=a[i];
                    }else{
                        max=a[i];min=a[i];
                    }
                }min=a[i];
            }else if(a[i]>max){
                if(a[i]-min>1){
                    if(len>ans) ans=len;
                    while(h.get(min)!=0){
                        len--;h.put(a[j],h.get(a[j])-1);j++;
                    }if(h.containsKey(a[i]-1)&&h.get(a[i]-1)>0){
                        max=a[i];min=a[i]-1;
                    }else min=a[i];
                }max=a[i];
            }len++;if(len>ans) ans=len;
        }if(len >ans) ans=len;
                System.out.println(ans);
            }
      }



