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

using namespace std;

class parser{
    public:
        parser() {}
        parser(const char *file_name){
            input_file.open(file_name,ios::in | ios::binary);
            input_file.sync_with_stdio(false);
            index=0;
            input_file.read(buffer,SIZE);}

        inline parser &operator >>(char n[]){
            for (;buffer[index]<'0' or buffer[index]>'z';inc());
            int it=0;
            for (;'0'<=buffer[index] and buffer[index]<='z';inc())
                n[it++]=buffer[index];
            n[it]='\0';
            return *this;}

        inline parser &operator >>(unsigned &n){
            for (;buffer[index]<'0' or buffer[index]>'9';inc());
            n&=0;
            for (;'0'<=buffer[index] and buffer[index]<='9';inc())
                n=(n<<1)+(n<<3)+buffer[index]-'0';
            return *this;}

        inline parser &operator >>(int &n){
            for (;buffer[index]<'0' or buffer[index]>'9';inc());
            n&=0;
            sign&=0;
            sign|=(buffer[index-1]=='-');
            for (;'0'<=buffer[index] and buffer[index]<='9';inc())
                n=(n<<1)+(n<<3)+buffer[index]-'0';
            n^=((n^-n)&-sign);
            return *this;}

        inline parser &operator >>(string &n) {
            if (buffer[index] == '\n')
                inc();
            for (;buffer[index] != '\n';inc())
                n.push_back(buffer[index]);
            n.push_back(0);
            return *this;
        }

        ~parser(){
            input_file.close();}

    private:
        fstream input_file;
        static const int SIZE=0x400000;
        char buffer[SIZE];
        int index=0;
        bool sign;
        inline void inc(){
            if(++index==SIZE)
                index=0,input_file.read(buffer,SIZE);}
};

class writer{
    public:
        writer() {};
        writer(const char *file_name){
            output_file.open(file_name,ios::out | ios::binary);
            output_file.sync_with_stdio(false);
            index&=0;}
        inline writer &operator <<(int target){
            aux&=0;
            n=target;
            if (!n)
                nr[aux++]='0';
            for (;n;n/=10)
                nr[aux++]=n%10+'0';
            for(;aux;inc())
                buffer[index]=nr[--aux];
            return *this;}
        inline writer &operator <<(const char *target){
            aux&=0;
            while (target[aux])
                buffer[index]=target[aux++],inc();
            return *this;}
        ~writer(){
            output_file.write(buffer,index);output_file.close();}
    private:
        fstream output_file;
        static const int SIZE=0x200000; ///2MB
        int index,aux,n;
        char buffer[SIZE],nr[24];
        inline void inc(){
            if(++index==SIZE)
                index&=0,output_file.write(buffer,SIZE);}
};


parser f("substr.in");
writer t("substr.out");
/*
unsigned int clz(unsigned int num) {
    return sizeof(unsigned)*8 - __builtin_clz(num);
}

#define MAXN 17000
#define MAXLG 16

struct entry {
    int nr[2], p;
} L[MAXN];

int A[MAXLG][MAXN], n;

int lcp(int x, int y) {
    int ret = 0;

    /// daca pozitiile sunt egale lcp e chiar lungimea
    if (x == y)
        return n - x;

    /** incepand cu pas de la log2(n) - 1, caut prefixe egale; cand gasesc unul, deplasez pozitia de cautare
     *  cu dimensiunea prefixului gasit, apoi continui sa caut prefixe mai mici de la offsetul dat
    **
    for (int k = clz(n) - 1; k >= 0 and x < n and y < n; --k)
        if (A[k][x] == A[k][y])
            x += 1 << k,
            y += 1 << k,
            ret += 1 << k;

    return ret;
}

int main()
{
    unsigned k;
    char target[MAXN];

    f >> n >> k;
    f >> target;

    /// setez A^0_i
    for (int i = 0; i < n; ++i)
        A[0][i] = target[i] - 'a';

    for (int i = 1, cnt = 1; i < clz(n); ++i, cnt <<= 1) {

        /// alcatuiesc grupurile nivelului curent, si le bordez cu -1
        for (int j = 0; j < n; ++j)
            L[j].nr[0] = A[i - 1][j],
            L[j].nr[1] = (j + cnt < n) ? A[i - 1][j + cnt] : -1,
            L[j].p = j; /// .p = index de unde incepe

        /// sortarea in functie de prima coloana, in caz de egalitate in functie de a doua
        sort(L, L + n, [](const entry &a, const entry &b) {return a.nr[0] == b.nr[0] ? (a.nr[1] < b.nr[1]) : (a.nr[0] < b.nr[0]);});

        /** in ordine alfabetica aloc fiecarui prefix pozitia j daca j > 0, sau daca indicii sunt identici
         *  fata de nivelul trecut, pozitia de la nivelul trecut
        **
        for (int j = 0; j < n; ++j)
            A[i][L[j].p] = j && L[j].nr[0] == L[j - 1].nr[0] && L[j].nr[1] == L[j - 1].nr[1] ?
                           A[j][L[j - 1].p] : j;


    }

    int max = 0;

    /// iterez de la 0 la n-k si iau maxim longest common preffix
    for (int i = 0; i < n - k; ++i)
        max = lcp(i, i  + k - 1) <= max ? max : lcp(i, i + k - 1);

    t << max;
    return 0;
}
*/

const int MAXN = 65536;
const int MAXLG = 17;

char A[MAXN];
struct entry {
    int nr[2], p;
} L[MAXN];
int P[MAXLG][MAXN], N, i, stp, cnt;

int lcp(int x, int y) {
    int k, ret = 0;
    if (x == y) return N - x;
    for (k = stp - 1; k >= 0 && x < N && y < N; --k)
        if (P[k][x] == P[k][y])
            x += 1 << k, y += 1 << k, ret += 1 << k;
    return ret;
}

bool cmp(const entry &a, const entry &b) {
    return a.nr[0] == b.nr[0] ? (a.nr[1] < b.nr[1]) : (a.nr[0] < b.nr[0]);
}

int main() {
    int k;
    f >> N >> k;
    f >> A;
    for (i = 0; i < N; ++i)
        P[0][i] = A[i] - 'a';
    for (stp = 1, cnt = 1; cnt >> 1 < N; ++stp, cnt <<= 1) {
        for (i = 0; i < N; ++i) {
            L[i].nr[0] = P[stp - 1][i];
            L[i].nr[1] = i + cnt < N ? P[stp - 1][i + cnt] : -1;
            L[i].p = i;
        }
        sort(L, L + N, cmp);
        for (i = 0; i < N; ++i)
            P[stp][L[i].p] = i > 0 && L[i].nr[0] == L[i - 1].nr[0] && L[i].nr[1] == L[i - 1].nr[1] ? P[stp][L[i - 1].p] : i;
    }

    int max = 0;

    for (int i = 0; i < N - k; ++i)
        max = lcp(i, i  + k - 1) <= max ? max : lcp(i, i + k - 1);

    t << max;

    return 0;
}