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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Random;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        EKBalancedTeams solver = new EKBalancedTeams();
        solver.solve(1, in, out);
        out.close();
    }

    static class EKBalancedTeams {
        static int n;
        static int m;
        static int[] arr;
        static int[] nxt;
        static int[][] memo;

        public void solve(int testNumber, Scanner sc, PrintWriter pw) {
            n = sc.nextInt();
            m = sc.nextInt();
            arr = new int[n];
            for (int i = 0; i < n; i++)
                arr[i] = sc.nextInt();
            B2KForThePriceOfOneHardVersion.shuffle(arr);
            Arrays.sort(arr);
            nxt = new int[n];
            for (int i = 0; i < n; i++)
                for (int j = n - 1; j >= 0; j--)
                    if (arr[j] - arr[i] <= 5) {
                        nxt[i] = j + 1;
                        break;
                    }
            memo = new int[n][m + 1];
            for (int[] x : memo)
                Arrays.fill(x, -1);
            pw.println(dp(0, m));
        }

        private int dp(int idx, int rem) {
            if (rem < 0)
                return (int) -1e9;
            if (idx == n)
                return 0;
            if (memo[idx][rem] != -1)
                return memo[idx][rem];
            int jump = nxt[idx] - idx + dp(nxt[idx], rem - 1);
            int next = dp(idx + 1, rem);
            return memo[idx][rem] = Math.max(jump, next);
        }

    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(FileReader r) {
            br = new BufferedReader(r);
        }

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

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

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

    }

    static class B2KForThePriceOfOneHardVersion {
        static void shuffle(int[] a) {
            int n = a.length;
            Random rand = new Random();
            for (int i = 0; i < n; i++) {
                int tmpIdx = rand.nextInt(n);
                int tmp = a[i];
                a[i] = a[tmpIdx];
                a[tmpIdx] = tmp;
            }
        }

    }
}