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.Arrays;
import java.math.*;
public class main {

	public static void main(String[] args) throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter wr = new BufferedWriter(new OutputStreamWriter(System.out));
		int n = Integer.parseInt(br.readLine());
		long[] a = Arrays.stream(br.readLine().split(" ")).mapToLong(Long::parseLong).toArray();
		heapsort(a);
		int ans = 0;
		int j = 0;
		for (int i = 0; i < n; i++) {
			while (j < n && a[j] - a[i] <= 5) {
				++j;
				ans = Math.max(ans, j - i);
			}
		}
		wr.write(Integer.toString(ans));
		br.close();
		wr.close();
	}
	public static void heapsort(long[] a) {
        for (int i = a.length / 2 - 1; i >= 0; i--)
            // convert the array to a heap
            shiftDown(a, i, a.length);
        for (int i = a.length - 1; i > 0; i--) {
            swap(a, 0, i); /* deleteMax */
            shiftDown(a, 0, i);
        }
    } // end heapSort
  
    private static void shiftDown(long[] a, int i, int n) {
        int child;
        long tmp;
  
        for (tmp = a[i]; leftChild(i) < n; i = child) {
            child = leftChild(i);
            if (child != n - 1 && (a[child] < a[child + 1]))
                child++;
            if (tmp < a[child])
                a[i] = a[child];
            else
                break;
        }
        a[i] = tmp;
    }
  
    private static int leftChild(int i) {
        return 2 * i + 1;
    }
  
    // swap numbers
    public static void swap(long[] numbers, int i, int j) {
        long temp = numbers[i];
        numbers[i] = numbers[j];
        numbers[j] = temp;
    }
}