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

public class test {
	
	static int n;
	static ArrayList<Integer> s;
	static int[][] memo;
	
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String[] split = br.readLine().split(" ");
		n = Integer.parseInt(split[0]);
		int k = Integer.parseInt(split[1]);
		split = br.readLine().split(" ");
		s = new ArrayList();
		for(int i=0; i<n; i++) s.add(Integer.parseInt(split[i]));
		Collections.sort(s);
//		System.out.println(s);
		memo = new int[n][k+1];
		for(int j=0; j<n; j++) Arrays.fill(memo[j], -1);
		int ans = 0;
		for(int i=0; i<n; i++) ans = Math.max(ans, dp(i, k));
		System.out.println(ans);
	}
	
	static int dp(int index, int k) {
		if(index>=n || k==0) return 0;
		if(memo[index][k]!=-1) return memo[index][k];
		int ans = dp(index+1, k); // skip student[index]
		int next = index+1;
		while(next<n && s.get(next)-s.get(index)<=5) next++;
		ans = Math.max(ans, dp(next, k-1)+(next-index));
		memo[index][k] = ans;
		return ans;
	}
	
	static class Element {
		int nTerms;
		int val;
		
		Element(int a, int b){
			nTerms = a;
			val = b;
		}

		@Override
		public int hashCode() {
			final int prime = 31;
			int result = 1;
			result = prime * result + nTerms;
			result = prime * result + val;
			return result;
		}

		@Override
		public boolean equals(Object obj) {
			if (this == obj)
				return true;
			if (obj == null)
				return false;
			if (getClass() != obj.getClass())
				return false;
			Element other = (Element) obj;
			if (nTerms != other.nTerms)
				return false;
			if (val != other.val)
				return false;
			return true;
		}
		
		public String toString(){
			return nTerms+" "+val;
		}
	}
	
	static class Node {
		int val;
		Node next;
		
		public Node(int v){
			val = v;
			next = null;
		}
	}
	
	static class Queue{
		Node head;
		Node tail;
		
		public Queue(){
			head = tail = null;
		}
		
		void push(Node n){
			if(head==null) {
				head = n;
				tail = null;
			} else if(tail==null){
				tail = n;
				head.next = n;
			} else {
				tail.next = n;
				tail = n;
			}
		}
		
		Node pop(){
			if(!isEmpty()){
				Node temp = head;
				head = head.next;
				return temp;
			}
			return null;
		}
		
		boolean isEmpty(){
			return head==null;
		}
	}
}