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.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;
        }
    }
}