#include <bits/stdc++.h>
using namespace std;
#define repr(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) for(int i=0;i<n;i++)
#define reprrev(i,a,b) for(int i=b-1;i>=a;i--) // [a, b)
#define reprev(i,n) reprrev(i,0,n)
typedef long long ll;
typedef unsigned long long ull;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }

const ll mod = 1e9+7;

void chmod(ll &M){
    if(M >= mod) M %= mod;
    else if(M < 0){
        M += (abs(M)/mod + 1)*mod;
        M %= mod;
    }
}

ll modpow(ll x, ll n){
    if(n==0) return 1;
    ll res=modpow(x, n/2);
    if(n%2==0) return res*res%mod;
    else return res*res%mod*x%mod;
}

ll power(ll x, ll n){
    if(n == 0) return 1;

    ll res = power(x, n/2);
    if(n%2 == 0) return res*res;
    else return res*res*x;
}

int getl(int i, int N) { return i==0? N-1:i-1; };
int getr(int i, int N) { return i==N-1? 0:i+1; };

// 線分 ab の偏角 返り値は[-π, π]
double argument(const pair<double, double> &a, const pair<double, double> &b){
    double ax=a.first, ay=a.second, bx=b.first, by=b.second;
    return atan2(by-ay, bx-ax);
}

/* <-----------------------------------------------------------------------------------> */
/* <-----------------------------------------------------------------------------------> */
/* <-----------------------------------------------------------------------------------> */
/* <-----------------------------------------------------------------------------------> */


// cf https://www.creativ.xyz/segment-tree-abstraction-979/
template < class T > 
class SegTree{                      
    int n;                          // 葉の数
    vector<T> data;                 // データを格納するvector
    T def;                          // 初期値かつ単位元
    function<T(T, T)> operation;    // 区間クエリで使う処理
    function<T(T, T)> update;       // 点更新で使う処理


    // 区間[a, b)の総和。ノード k=[l, r) に着目している。
    T _query(int a, int b, int k, int l, int r){
        if(r <= a || b <= l) return def;
        if(a <= l && r <= b) return data[k];
        else{
            T c1 = _query(a, b, 2*k+1, l, (l+r)/2);
            T c2 = _query(a, b, 2*k+2, (l+r)/2, r);
            return operation(c1, c2);
        }

    }

    public:
        // _n:必要サイズ, _def:初期値かつ単位元, _operaotion:クエリ関数
    // _update:更新関数
        SegTree(size_t _n, T _def, function<T(T, T)> _operation, function<T(T, T)> _update)
            : def(_def), operation(_operation), update(_update) {
            n = 1;
            while(n < _n) n *= 2;
            data = vector<T>(2*n-1, def);
        }

        // [a, b) の区間クエリを実行
        T query(int a, int b){
            return _query(a, b, 0, 0, n);
        }

        // 場所 i(0-indexed) の値を x で更新
        void change(int i, T x){
            i += n-1;
            // 点加算なら [](T d, T x){ return d+x; }, 点更新なら [](T d, T x){ return x; }
            data[i] = update(data[i], x);
            while(i > 0){
                i = (i-1)/2;
                data[i] = operation(data[i*2+1], data[i*2+2]); 
            }
        }

        T operator[](int i){ return data[i+n-1]; }
};

// i を固定する.

// p = max( i - m, 0)として q = [ p, i ) ∩ { j | str[ j ] == '0' }
// qの最小元が存在すれば, それを r とする

// f(i) = {  j ∈ q  f( j ) に i - j  をくっつけたもの }の中で最適なもの

// であるから, f( r ) ( < f(j) | j ∈ q \ {r} ) を選ぶのが明らかに良い

int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);

    int N, M; cin >> N >> M;
    string s; cin >> s;

    const int inf = 1e5+7;
    SegTree<int> seg(N+5, inf,
                    [](auto x, auto y){ return min(x, y); },
                    [](auto x, auto y){ return y;}
                    );
    
    rep(i, s.size()) if(s[i] == '0') seg.change(i, i);

    int now = N;
    vector<int> ans;
    while(1){
        int nxt = seg.query(max(0, now-M), now);
        if(nxt == inf) { cout << -1 << endl; return 0; }
        ans.push_back(now-nxt);
        now = nxt;
        if(now == 0) break;
    }
    reverse(ans.begin(), ans.end());

    for(int i=0; i<ans.size(); ++i){
        if(i) cout << ' ';
        cout << ans[i];
    }
    cout << endl;
}


Measured memory_bytes: 2120