//include
//------------------------------------------
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include<queue>
using namespace std;
//conversion
//------------------------------------------
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
//math
//-------------------------------------------
template<class T> inline T sqr(T x) {return x*x;}
//typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
//container util
//------------------------------------------
#define ALL(a)  (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define VECMAX(x) *max_element(ALL(x))
#define VECMIN(x) *min_element(ALL(x))
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
//repetition
//------------------------------------------
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)
#define MULTIPLE(i,n,k) for(int i = (k) ; i<(n) ; i+=k+1)//倍数ループ
//constant
//------------------------------------------
const double EPS = 1e-10;
const double PI  = acos(-1.0);
//clear memory
#define CLR(a) memset((a), 0 ,sizeof(a))
//debug
#define dump(x)  cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
#define SIZEOF(x) sizeof(x)/sizeof(x[0])
//----------------search for specific figure----------
template <class T>
T max(T *a , LL n){
    T maxi = a[0];
    for(LL i = 0; i < n; ++i){
        if(a[i] > maxi)maxi = a[i];
    }
    return maxi;
}
template <class T>
T max_index(T *a , LL n){
    T maxi = a[0];
    T index = 0;
    for(LL i = 0; i < n; ++i){
        if(a[i] > maxi){
            maxi = a[i];
            index = i;
        }
    }
    return index;
}
template <class T>
T min(T *a , LL n){
    T mini = a[0];
    for(LL i = 0; i < n; ++i){
        if(a[i] < mini)mini = a[i];
    }
    return mini;
}
template <class T>
T min_index(T *a , LL n){
    T mini = a[0];
    T index = 0;
    for(LL i = 0; i < n; ++i){
        if(a[i] < mini){
            mini = a[i];
            index = i;
        }
    }
    return index;
}
template <class T>
T sum(T *a , LL n){
    T s=0;
    for(LL i = 0; i < n; ++i){
       s+=a[i]; 
    }
    return s;
}
#define MAX(x) max(x,SIZEOF(x))
#define MIN(x) min(x,SIZEOF(x))
#define MAX_INDEX(x) max_index(x,SIZEOF(x))
#define MIN_INDEX(x) min_index(x,SIZEOF(x))
#define SUM(x) sum(x,SIZEOF(x))



class UnionFind{
    public:
    VI par;
    UnionFind(LL N):par(N){
        REP(i,N)par[i] = i;
    }
    ~UnionFind(){}
    LL root(LL x){
        if(par[x] ==x)return x;
        else {
            par[x] = root(par[x]);
            return par[x];
        }
    }
    void unite(LL x, LL y){
        LL rx = root(x);
        LL ry = root(y);
        if(rx == ry)return;
        par[rx] = ry;
    }
    bool same(LL x, LL y){
        LL rx = root(x);
        LL ry = root(y);
        return rx == ry;
    }
};







pair<LL , LL >  operator+(pair<LL , LL> &a, pair<LL , LL > &b){
    pair<LL , LL> p;
    p.first = a.first + b.first;
    p.second = a.second + b.second;
    return p;
}
bool operator ==(pair<LL , LL> &a, pair<LL , LL > &b){
    return (a.first == b.first && a.second == b.second);
}
bool is_in_field(int h, int w, const pair<LL , LL> &point)
{
    const int c = point.second;
    const int r = point.first;
    return (0 <= c && c < w) && (0 <= r && r < h); 
}
#include<queue>
LL BFS(vector<vector <char> > &p , LL h , LL w){
    
    pair <LL , LL> c[4];
    c[0].first = 0;
    c[0].second = 1;
    c[1].first = 0;
    c[1].second = -1;
    c[2].first = 1;
    c[2].second = 0;
    c[3].first = -1;
    c[3].second = 0;
    



    vector< vector<LL> >memo;
    REP(i,h){
        vector <LL> k(w);
        REP(t,w)k[t] =  0;
        memo.push_back(k);
    }

    queue <pair<LL ,LL> >Q;
    pair<LL , LL> s;
    s.first = 0;
    s.second = 0;
    Q.push(s);
    

    while(Q.empty() == false){
        pair <LL , LL> now = Q.front();
        Q.pop();        

        for(int u = 0; u < 4 ; u++){
            pair<LL , LL > x = c[u];
            pair<LL , LL> next = now + x;
            if(is_in_field(h,w,next)){
                if(p[next.first][next.second] == '.'){

                    if(memo[next.first][next.second] == 0){
                        memo[next.first][next.second] = memo[now.first][now.second] + 1;
                        Q.push(next);
                    }
                }
            }
        }
    }
    if(memo[h-1][w-1] == 0)return -1;
    else return memo[h-1][w-1];
    
    
}







int main(){
    LL n,k;
    cin >> n >> k;
    string s;
    cin >> s;

    vector <LL> a;
    vector <LL> b;
    LL j = 0;
    LL h = 0;
    REP(i,s.size()){
        if(i == 0&&s[i]=='0'){
            j++;
            continue;
        }
        if(h==1&&s[i]=='0'){
            j++;
            h =0;
            continue;
        }
        if(s[i] == '1'){
            h = 1;
            continue;
        }

        
    }
    if(k>=j){
        cout << s.size();
        return 0;
    }
    
    LL count = 1;
    REP(i,s.size()){
        if(i==0){
            continue;
        }else{
            if(s[i] == s[i-1]){
                count++;
            }else{
                a.push_back(count);
                count = 1;
            }
            if(i==s.size()-1){
                a.push_back(count);
            }
        }
    }

    if(s[0] == '0')a.insert(a.begin() , 0);
    if(s[s.size()-1] == '0')a.push_back(0);

    vector <LL> R;
    REP(i,a.size()){
        if(i == 0){
            R.push_back(a[0]);
        }else{
            R.push_back(R[i-1]+a[i]);
        }
    }
    vector <LL>R2;
    REP(i,(a.size()-1)/2 + 1){
        R2.push_back(R[i*2]);
    }

    if(k>=R2.size()){
        cout << s.size();
        return 0;
    }
    
    LL m = 0;
    for(LL i = 0; i + k < R2.size();i++){
        if(R2[i+k] - R2[i] + a[i*2] > m)m = R2[i+k] - R2[i] + a[i*2];
    }

    cout << m;

    

    



    return 0;

}


Measured memory_bytes: 2868