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 form k teams for yet another new programming competition. As you know, the more students are involved in competition the more probable the victory of your university is! So you have to form no more than k (and at least one) non-empty teams so that the total number of students in them is maximized. But you also know that each team should be balanced. It means that the programming skill of each pair of students in each team should differ by no more than 5. Teams are independent from one another (it means that the difference between programming skills of two students from two different teams does not matter).

It is possible that some students not be included in any team at all.

Your task is to report the maximum possible total number of students in no more than k (and at least one) non-empty balanced teams.

If you are Python programmer, consider using PyPy instead of Python when you submit your code.

Input

The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 5000) — the number of students and the maximum number of teams, correspondingly.

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 total number of students in no more than k (and at least one) non-empty balanced teams.

Examples

Input


5 2
1 2 15 15 15


Output


5


Input


6 1
36 4 1 25 9 16


Output


2


Input


4 4
1 10 100 1000


Output


4
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
    static final long MOD = 1_000_000_007, INF = 1_000_000_000_000_000_000L;
    static final int INf = 1_000_000_000;
    static FastReader reader;
    static PrintWriter writer;
    public static void main(String[] args) {
        Thread t = new Thread(null, new O(), "Integer.MAX_VALUE", 100000000);
        t.start();
    }
    static class O implements Runnable {
        public void run() {
            try {
                magic();
            }
            catch (Exception e) {
                e.printStackTrace();
                System.exit(1);
            }
        }
    }
    static class FastReader {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public FastReader() {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public FastReader(String file_name) throws IOException {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException {
            byte[] buf = new byte[1000000];
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n') break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException {
            int ret = 0;
            byte c = read();
            while (c <= ' ') c = read();
            boolean neg = (c == '-');
            if (neg) c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg) return -ret;
            return ret;
        }

        public long nextLong() throws IOException {
            long ret = 0;
            byte c = read();
            while (c <= ' ') c = read();
            boolean neg = (c == '-');
            if (neg) c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg) return -ret;
            return ret;
        }

        public double nextDouble() throws IOException {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ') c = read();
            boolean neg = (c == '-');
            if (neg) c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (c == '.') while ((c = read()) >= '0' && c <= '9') ret += (c - '0') / (div *= 10);
            if (neg) return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1) buffer[0] = -1;
        }

        private byte read() throws IOException {
            if (bufferPointer == bytesRead) fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException {
            if (din == null) return;
            din.close();
        }
    }
    static void magic() throws IOException{
        reader = new FastReader();
        writer = new PrintWriter(System.out, true);
        int n = reader.nextInt(), k = reader.nextInt();
        int arr[] = new int[n];
        for(int i=0;i<n;++i) {
            arr[i] = reader.nextInt();
        }
        Arrays.sort(arr);
        int till[] = new int[n];
        int right = -1;
        for(int i=0;i<n;++i) {
            while(right+1<n && arr[right+1] - arr[i] <= 5) {
                right++;
            }
            till[i] = right;
        }
//        writer.println("till array : ");
//        for(int e : till) {
//            writer.print(e+" ");
//        }
//        writer.println();
        int dp[][] = new int[n+1][k+1];
        dp[n][1] = 0;
        for(int i=n-1;i>=0;--i) {
            dp[i][1] = till[i] - i + 1;
            dp[i][1] = max(dp[i][1], dp[i+1][1]);
        }
        QueueWithMaximum q = new QueueWithMaximum(n+1);
        for(int number_of_teams=2;number_of_teams<=k;++number_of_teams) {
            right = n;
            q.add(dp[n][number_of_teams - 1] + n);
            for(int i=n-1;i>=0;--i) {
                //writer.println("i: "+i);
                while(right > till[i]+1) {
                    //writer.println("Right was extra right: "+right);
                    right--;
                    q.poll();
                }
                if(q.size()>0) {
                    dp[i][number_of_teams] = max(dp[i+1][number_of_teams], (int)q.getMax() - i);
                }
                else {
                    dp[i][number_of_teams] = dp[i+1][number_of_teams];
                }
                q.add(dp[i][number_of_teams - 1] + i);
            }
            while(q.size()>0) {
                q.poll();
            }
        }
//        writer.println("DP ARRAY: ");
//        for(int number_teams = 1; number_teams <= k; ++number_teams) {
//            for(int i=0;i<n;++i) {
//                writer.print(dp[i][number_teams]+" ");
//            }
//            writer.println();
//        }
        writer.println(dp[0][k]);
    }
    static class QueueWithMaximum {
        int top1, top2;
        long stackArray1x[], stackArray1y[], stackArray2x[], stackArray2y[];
        public  QueueWithMaximum(int max_size) {
            stackArray1x = new long[max_size];
            stackArray1y = new long[max_size];
            stackArray2x = new long[max_size];
            stackArray2y = new long[max_size];
            top1 = top2 = -1;
        }
        public long getMax() {  //assumes non empty queue
            if(top2==-1) {
                return stackArray1y[top1];
            }
            else if(top1==-1) {
                return stackArray2y[top2];
            }
            else return max(stackArray1y[top1], stackArray2y[top2]);
        }
        private void add2(long val) {
            if(top2==-1) {
                top2++;
                stackArray2x[top2] = stackArray2y[top2] = val;
            }
            else {
                top2++;
                stackArray2x[top2] = val;
                stackArray2y[top2] = max(val, stackArray2y[top2-1]);
            }
        }
        private void add1(long val) {
            if(top1==-1) {
                top1++;
                stackArray1x[top1] = stackArray1y[top1] = val;
            }
            else {
                top1++;
                stackArray1x[top1] = val;
                stackArray1y[top1] = max(val, stackArray1y[top1-1]);
            }
        }
        public long poll() {
            if(top1==-1) {
                while(top2>=0) {
                    add1(stackArray2x[top2--]);
                }
            }
            return stackArray1y[top1--];
        }
        public void add(long val) {
            add2(val);
        }
        public int size() {
            return top2 + top1 + 2;
        }
    }
}