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 double a;static int fall[];
 public static void main(String args[]) throws IOException
{
  InputStreamReader isr=new InputStreamReader(System.in);
  BufferedReader br=new BufferedReader(isr);
// int t=Integer.parseInt(br.readLine());
     
//while(t-->0)
//{   
          
     int n=Integer.parseInt(br.readLine());
     StringTokenizer st= new StringTokenizer(br.readLine()); 
     int a[]=new int[n];
     for(int i=0;i<n;i++)
         
     
     
     a[i]=Integer.parseInt(st.nextToken());
       
   int min=a[0];int max=a[0];int currlen=1;int maxlen=-1;
   int r=0,l=0;
  
       /*min=max=a[i];
       for(int j=i+1;j<n;j++)
       { currlen=1;
           while(j<n && (a[j]==min || a[j]==max || a[j]==max-1 || a[j]==min+1 ))
           {currlen++;if(maxlen<currlen) maxlen=currlen;
           if(a[j]!=min && a[j]!=max) 
           {
             if(a[j]>max)
                 max=a[j];
             else a[j]=min;
               
           }
           j++;
           }*/int maxi=0,mini=0;
    /*  while(r<n && a[l]==a[r])
       {r++;currlen++;}
       if(r==n)
       {System.out.println(n);}
       else
       {{if(a[l]<a[r])
       {min=a[l];max=a[r];maxi=r;mini=l;}
       else {min=a[r];max=a[l];maxi=l;mini=r;}}
       */
       while(r<n-1)
       {       
           
      
        
           if(a[r+1]!=max && a[r+1]!=min)
           {
               if(a[r+1]==min-1)
               {   
                      if(min!=max)
                   l=maxi+1;
                   max=min;
                   min=a[r+1];
                   
                   
                  
                   maxi=mini;
                   mini=r+1;
                   r++;
                    if(maxlen<currlen)
                       maxlen=currlen;
                   currlen=r-l+1; 
                   
               }
               else if(a[r+1]==max+1)
               {   if(min!=max)
                   l=mini+1;
                   min=max;
                  max=a[r+1];
                  
                   mini=maxi;
                  maxi=r+1;
                   r++;
                   if(maxlen<currlen)
                       maxlen=currlen;
                   currlen=r-l+1;; 
               }
                else
               {   if(maxlen<currlen)
                       maxlen=currlen;
                   min=a[r+1];max=a[r+1];
                   l=r=mini=maxi=r+1;
                   currlen=1;
                   
               }
           } 
               else if(a[r+1]==min)
               { mini=r+1;r++;currlen++; }
               else if(a[r+1]==max)
               {
                   maxi=r+1;r++;currlen++;
               }
             
               
           
               
    //  System.out.println(l+" "+r+" "+mini+" "+min+" "+maxi+" "+max+" "+currlen);
           
           
       }
       if(maxlen<r-l+1)
           maxlen=r-l+1;
          
           
       
       
       
       
   
     
     System.out.println(maxlen);
     
    
}}
 
 class Point  {
     int i;
     int x,y;int visit=0;
    // int rdiff,ldiff;
    // int removed;
    // int left,right;
     public static  Comparator<Point> pcompx=new Comparator<Point>(){
          public int compare(Point p1, Point p2) {
        
          if(p1.x==p2.x)
                  return p1.y-p2.y;
          //ascending order
          return p1.x-p2.x;
          
          //descending order
          //return fruitName2.compareTo(fruitName1);
     
 }};
             public static  Comparator<Point> pcompy=new Comparator<Point>(){
          public int compare(Point p1, Point p2) {
        
          if(p1.y==p2.y)
                  return p1.x-p2.x;
          //ascending order
          return p1.y-p2.y;
          
          //descending order
          //return fruitName2.compareTo(fruitName1);
     
 }};
             }
        
        
        
        


