#include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>
#include <string>
using namespace std;

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

const int MAX = 17000;
const int MAXLOG = 17;
int N, K;
string A;
int P[MAXLOG][MAX];
struct Entry{
    int nr[2];
    int p;

    bool operator < ( const Entry& a ) const
    {
        return nr[0] < a.nr[0] || ( nr[0] == a.nr[0] && nr[1] < a.nr[1] );
    }
} L[MAX];
int ind[MAX];
//int lcp[MAX];
int stp;

void Read();
void SuffixArrays();
int LCP( int x, int y );
void Solve();

int main()
{
    Read();
   // SuffixArrays();
    Solve();

    fin.close();
    fout.close();
    return 0;
}

void Read()
{
    fin >> N >> K;
    fin >> A;
    N = A.size();
    cout << N; cin.get();
}

void SuffixArrays()
{
    int k, i;
    int cnt;

    for ( i = 0; i < N; ++i )
        P[0][i] = A[i] - '0';

    for ( k = 1, cnt = 1; cnt >> 1 < N; cnt <<= 1, ++k )
    {
        if ( k >= MAXLOG )
            cin.get();

        for ( i = 0; i < N; ++i )
            L[i] = { {P[k - 1][i], i + cnt < N ? P[k - 1][i + cnt] : -1}, i };
        sort(L, L + N);

        for ( i = 0; i < N; ++i )
            P[k][L[i].p] = i > 0 && L[i].nr[0] == L[i - 1].nr[0] && L[i].nr[1] == L[i - 1].nr[1] ? P[k][L[i - 1].p] : i;
    }

    stp = k - 1;

    /*for ( i = 0; i < N; ++i )
        fout << P[stp][i] << ' ';*/

    for ( i = 0; i < N; ++i )
        ind[P[stp][i]] = i;
   /* for ( i = 1; i < N; ++i )
        lcp[i] = LCP(ind[i - 1], ind[i]);   */
}

int LCP( int x, int y )
{
    if ( x == y )
        return N - x;

    int ret{0}, k;
    for ( k = stp; 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;
}

void Solve()
{
    int res{0};

    for ( int i = 1; i + K - 1 < N; ++i )
        res = max( res, LCP(ind[i], ind[i + K - 1]) );
    fout << res << '\n';
}