Problem: You are a coach at your local university. There are n students under your supervision, the programming skill of the i-th student is a_i.

You have to create a team for a new programming competition. As you know, the more students some team has the more probable its victory is! So you have to create a team with the maximum number of students. But you also know that a team should be balanced. It means that the programming skill of each pair of students in a created team should differ by no more than 5.

Your task is to report the maximum possible number of students in a balanced team.

Input

The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of students.

The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is a programming skill of the i-th student.

Output

Print one integer — the maximum possible number of students in a balanced team.

Examples

Input


6
1 10 17 12 15 2


Output


3


Input


10
1337 1337 1337 1337 1337 1337 1337 1337 1337 1337


Output


10


Input


6
1 1000 10000 10 100 1000000000


Output


1

Note

In the first example you can create a team with skills [12, 17, 15].

In the second example you can take all students in a team because their programming skills are equal.

In the third example you can create a team consisting of a single student (and you cannot create a team consisting of at least two students).

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;

public class Main {

    private 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 nextDouble() 
        { 
   return Double.parseDouble(next()); 
        } 
  
        String nextLine() 
        { 
            String str = ""; 
            try
            { 
                str = br.readLine(); 
            } 
            catch (IOException e) 
            { 
                e.printStackTrace(); 
            } 
            return str; 
        } 
    } 

    private static class FastWriter
    {
        private final PrintWriter writer;
 
        public FastWriter() {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        }
 
        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }
 
        public void println(Object... objects) {
            print(objects);
            writer.println();
        }
 
        public void close() {
            writer.close();
        }
 
        public void flush() {
            writer.flush();
        }
    }
    
    public static void main(String[] args) {
        FastReader s=new FastReader();
        FastWriter out=new FastWriter();
        int n=s.nextInt();
        HashMap<Integer,Integer> tm=new HashMap<Integer,Integer>();
        TreeSet<Integer> t=new TreeSet<Integer>();
        int[] a=new int[n];
        for(int i=0;i<n;i++)
        {
        	int temp=s.nextInt();
        	t.add(temp);
        	if(tm.containsKey(temp))
        		tm.put(temp, tm.get(temp)+1);
        	else
        		tm.put(temp, 1);
        }
        Arrays.sort(a);
        int count=0;
        Iterator<Integer> tempIntr=t.iterator();
        while(tempIntr.hasNext())
        {
        	int tcount=0;
        	int tmp=tempIntr.next();
        	int p=6;
        	while(p-->0)
        	{
        		if(!tm.containsKey(tmp+p))
        			continue;
        		tcount+=tm.get(tmp+p);
        	}
        		
        	count=Math.max(count, tcount);
        }
        out.println(count);
        out.flush();
    }
}