#include <iostream>
#include <string>
#include <cstdlib>
#include <cstdio>
#include <queue>
#include <stack>
#include <list>
#include <utility>
#include <vector>
#include <set>
#include <algorithm>
#include <cmath>
#include <climits>
#include <map>
#include <unordered_map>
#include <string.h>
#include<iomanip>
#include <iterator>
#include <locale>

#define all(a) a.begin(),a.end()
#define VV(T) vector<vector< T > >
#define rep(i,N) for(int i = 0; i <N; i++)
#define repsg(i,s,g) for(int i = s; i <g; i++)
#define name(x) #x


using namespace std;

const int INF = INT_MAX;
const long long INFL = 1LL<<40;
const double PI = atan(1)*4;
const long long MOD = pow(10,9)+7;
int dy[]={0, 0, 1, -1, 0};
int dx[]={1, -1, 0, 0, 0};

typedef long long ll,LL;
typedef vector<int> vint;
typedef vector<vector<int> > vvint;
typedef vector<long long> vll, vLL;
typedef vector<vector<long long> > vvll, vvLL;
typedef pair<int,int> pii;
typedef pair<LL, LL> pLL;


// vector入力
template<typename T>
istream& operator >> (istream& is, vector<T>& vec){
    for(T& x: vec) is >> x;
    return is;
}
// vector出力
template<typename T>
ostream& operator << (ostream& os, vector<T>& vec){
    for(int i=0; i<vec.size(); i++){
        os << vec[i] << ( i+1 == vec.size() ? "" : " " );
    }
    return os;
}

typedef struct{
    
    int left;
    int right;

} cluster1;


int n,k;
string s;
vector<cluster1> pos;


void solve(string s){
    int l,r;
    l = -1;
    r  = -1;
    rep(i,n){
        
        if(s[i]=='1' && l == -1){
            l = i;
        }
        
        if(s[i] == '0' && l != -1){
            r = i-1;
            cluster1 temp;
            temp.left = l;
            temp.right = r;
            pos.push_back(temp);
            l = -1;
        }
        
    }
    
    if(pos.size()==0){
        cout<<n<<endl;
        return;
    }
    
    int maximum = -1;
    for(int i = 0; i<pos.size();i++){
        if(i+k <pos.size()){
            maximum = max(maximum,pos[i+k].right - pos[i].left + 1);
        }else{
            maximum = max(maximum,n-1 - pos[i].left + 1);
        }
    }
    cout<<maximum<<endl;
}

void solve2(string s){
    int l,r;
    l = -1;
    r  = -1;
    s = '1' + s;
    rep(i,n+1){
        
        if(s[i]=='1' && l == -1){
            
            if(i!=0){
                l = i;
            }else{
                l = i+1;
            }
        }
        
        if(s[i] == '0' && l != -1){
            r = i-1;
            cluster1 temp;
            temp.left = l;
            temp.right = r;
            pos.push_back(temp);
            l = -1;
        }
        
    }
    if(pos.size()==0){
        cout<<n<<endl;
        return;
    }
    
    int maximum = -1;
    for(int i = 0; i<pos.size();i++){
        if(i+k <pos.size()){
            maximum = max(maximum,pos[i+k].right - pos[i].left + 1);
        }else{
            maximum = max(maximum,n - pos[i].left + 1);
        }
    }
    cout<<maximum<<endl;
}


int main() {
    
    cin>>n>>k;
    cin>>s;
 
    
    if(s[0]=='1'){
        solve(s);
    }
    
    if(s[0]=='0'){
        solve2(s);
    }
    
    
    
    
    
    return 0;
}


/*
 
 0101のようなパターンを1111にするには2回が最小
 01010を11111にするのは3回が最小
 ....
 
 結局、連続した0, 連続した1は圧縮することができ、かつ最小必要回数は常に0のクラスタの数に等しい。
 
 最適手順においては最終的に...01111110.....となる(端の場合もあり)
 
 初期配置Sのどの位置が終状態の端になりうるかと考えると、左端も右端も、初期配置で1のクラスタのどれかの端になるのが最適。
 
 1のクラスタを番号付けし、それぞれのクラスタの左端、右端の位置を持っておく。
 あるクラスタ i の左端を左端とするような最適な終状態での人数は、クラスタiの左端位置とクラスタ i + Kの右端位置の差。
 
 これに境界の処理を加えればOKだが面倒。先頭文字で分ける。
 
 */






Measured memory_bytes: 1216