#include <fstream>
#include <iostream>
#include <cstring>
#include <algorithm>



using namespace std;


struct structura {
    int poz;
    int _first;
    int _second;
};

class SuffixArrays {
    int n;
    int *a[30];
    char *s;
    int log;
    structura *L;
    int *P;



public:

    static int cmp(structura a, structura b) {
        if (a._first != b._first)
            return a._first < b._first;
        else
            return a._second < b._second;
    }

    SuffixArrays(char *s) {
        this->s = new char[ strlen(s) + 1 ];
        strcpy(this->s, s);
        n = strlen(s);

        int p = 1;

        for (log = 0; p <= n; log++, p*=2);


        for (int i=0;i<log;i++) {
            a[i] = new int [n];
        }
        L = new structura [n];
        P = new int[n];
    }

    void build () {
        for (int i=0;i<n;i++) {
            L[i].poz = i;
            L[i]._first = s[i];
            L[i]._second = 0;
        }

        for (int lg=0, p = 1; p<=n; lg ++, p*=2) {
            sort(L, L+n, cmp);
            a[lg][ L[0].poz ] = 0;
            for (int i=1;i<n;i++) {
                if ( L[i]._first == L[i-1]._first && L[i]._second == L[i-1]._second ) {
                    a[lg][L[i].poz] = a[lg][L[i-1].poz];
                } else {
                    a[lg][L[i].poz] = 1 + a[lg][L[i-1].poz];
                }
            }
            for (int i=0;i<n;i++) {
                L[i].poz = i;
                L[i]._first = a[lg][i];
                if (i + p < n)
                    L[i]._second = a[lg][ i+p ];
                else
                    L[i]._second = -1;
            }
        }


    }

    int queryPrefix(int dist) {
        for (int i=0;i<n;i++)
            P[ a[log-1][i] ] = i;

        ///for (int i=0;i<n;i++) {
        ///    cout<<s + P[i] <<"\n";
        ///}

        int maxim = 0;
        for (int i=0;i+dist-1 <n; i++) {
            int x = P[i];
            int y = P[i+dist-1];
            int sol = 0;
            int lg = log-1;
            for (int L = (1<<(log-1)); L>=1; L/=2) {
                if (a[lg][x] == a[lg][y]) {
                    sol += lg;
                    x += lg/2;
                    y += lg/2;
                    sol += lg;
                    if (x >= n || y >= n)
                        break;
                }
                lg /= 2;
            }
            maxim = max(maxim, sol);
        }
        return maxim;
    }

    ~SuffixArrays() {
        for (int i=0;i<log;i++)
            delete [] a[i];
        delete L;
        delete P;
    }

} ;

int n, k;
char s[17000];

int main () {
    ifstream fin ("substr.in");
    ofstream fout("substr.out");

    fin>>n>>k;
    fin>>s;

    SuffixArrays S(s);
    S.build();
    fout<<S.queryPrefix(k);
    return 0;
}