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.io.*;
    import java.util.*;
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.util.Collections;
    import java.io.InputStreamReader;
    import static java.lang.Math.*;
    import static java.lang.System.*;

    public class Main1 {


        static int  solver(int n , int cnt[] , int dp[][] , int rem){
            if (rem < 0)return -(int)1e6 ;
            if (n < 0)return 0 ;
            if (dp[n][rem] != -1 )return dp[n][rem] ;

            int ans = solver(n-1 ,cnt , dp ,rem) ;
            ans = max(ans , n - cnt[n] +  solver(cnt[n] , cnt , dp , rem-1) ) ;
            return dp[n][rem] = ans ;
        }



        public static void main(String[] args) throws IOException {

    //       try {
           // Scanner in = new Scanner(System.in) ;
             FastScanner in = new FastScanner();
           PrintWriter out = new PrintWriter(System.out);



            int n = in.nextInt();
            int k = in.nextInt() ;
            int a[] = in.readArray(n) ;
            sort(a) ;
            int cnt[] = new int[n] ;
            int r=0 , l = 0 ;

            for (int i = 0; i <n ; i++) {
                while (a[i] - a[r] > 5)r++ ;
                cnt[i] = r-1 ;
            }
          int dp[][] = new int[n][k+1] ;
            for (int i = 0; i <n ; i++) {
                for (int j = 0; j <=k ; j++) {
                    dp[i][j] = -1 ;
                }
            }

            int ans = solver(n-1 , cnt , dp , k) ;
            System.out.println(ans);



            out.flush();
            out.close();

        }
    //        catch (Exception e){
    //            return;
    //        }
    //
    //    }

        static long gcd(long a, long b) {
            return (b == 0) ? a : gcd(b, a % b);
        }

        static int gcd(int a, int b) {
            return (b == 0) ? a : gcd(b, a % b);
        }

        static void sort(int ar[]) {
            int n = ar.length;
            ArrayList<Integer> a = new ArrayList<>();
            for (int i = 0; i < n; i++)
                a.add(ar[i]);
            Collections.sort(a);
            for (int i = 0; i < n; i++)
                ar[i] = a.get(i);
        }

        static void sort1(long ar[]) {
            int n = ar.length;
            ArrayList<Long> a = new ArrayList<>();
            for (int i = 0; i < n; i++)
                a.add(ar[i]);
            Collections.sort(a);
            for (int i = 0; i < n; i++)
                ar[i] = a.get(i);
        }

        static long ncr(long n, long r, long mod) {
            if (r == 0)
                return 1;
            long val = ncr(n - 1, r - 1, mod);
            val = (n * val) % mod;
            val = (val * modInverse(r, mod)) % mod;
            return val;
        }

        static long fast_pow(long base, long n, long M) {
            if (n == 0)
                return 1;
            if (n == 1)
                return base % M;
            long halfn = fast_pow(base, n / 2, M);
            if (n % 2 == 0)
                return (halfn * halfn) % M;
            else
                return (((halfn * halfn) % M) * base) % M;
        }

        static long modInverse(long n, long M) {
            return fast_pow(n, M - 2, M);
        }

    // ======================================================================================================



        static class FastOutput implements AutoCloseable, Closeable, Appendable {
            private static final int THRESHOLD = 32 << 10;
            private final Writer os;
            private StringBuilder cache = new StringBuilder(THRESHOLD * 2);

            public FastOutput append(CharSequence csq) {
                cache.append(csq);
                return this;
            }

            public FastOutput append(CharSequence csq, int start, int end) {
                cache.append(csq, start, end);
                return this;
            }

            private void afterWrite() {
                if (cache.length() < THRESHOLD) {
                    return;
                }
                flush();
            }

            public FastOutput(Writer os) {
                this.os = os;
            }

            public FastOutput(OutputStream os) {
                this(new OutputStreamWriter(os));
            }

            public FastOutput append(char c) {
                cache.append(c);
                afterWrite();
                return this;
            }

            public FastOutput append(long c) {
                cache.append(c);
                afterWrite();
                return this;
            }

            public FastOutput append(String c) {
                cache.append(c);
                afterWrite();
                return this;
            }

            public FastOutput println() {
                return append(System.lineSeparator());
            }

            public FastOutput flush() {
                try {
                    //            boolean success = false;
                    //            if (stringBuilderValueField != null) {
                    //                try {
                    //                    char[] value = (char[]) stringBuilderValueField.get(cache);
                    //                    os.write(value, 0, cache.length());
                    //                    success = true;
                    //                } catch (Exception e) {
                    //                }
                    //            }
                    //            if (!success) {
                    os.append(cache);
                    //            }
                    os.flush();
                    cache.setLength(0);
                } catch (IOException e) {
                    throw new UncheckedIOException(e);
                }
                return this;
            }

            public void close() {
                flush();
                try {
                    os.close();
                } catch (IOException e) {
                    throw new UncheckedIOException(e);
                }
            }

            public String toString() {
                return cache.toString();
            }

        }


        static class FastScanner {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            StringTokenizer st = new StringTokenizer("");

            String next() {
                while (!st.hasMoreTokens())
                    try {
                        st = new StringTokenizer(br.readLine());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                return st.nextToken();
            }

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

            int[] readArray(int n) {
                int[] a = new int[n];
                for (int i = 0; i < n; i++) a[i] = nextInt();
                return a;
            }


            long nextLong() {
                return Long.parseLong(next());
            }
        }


    }







