#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
using namespace std;
using ll = long long;
using vec = vector<ll>;
using vect = vector<double>;
using Graph = vector<vector<ll>>;
#define loop(i, n) for (ll i = 0; i < n; i++)
#define Loop(i, m, n) for (ll i = m; i < n; i++)
#define pool(i, n) for (ll i = n; i >= 0; i--)
#define Pool(i, m, n) for (ll i = n; i >= m; i--)
#define mod 1000000007ll
//#define mod 998244353ll
#define flagcount __builtin_popcount
#define flag(x) (1ll << x)
#define flagadd(bit, x) bit |= flag(x)
#define flagpop(bit, x) bit &= ~flag(x)
#define flagon(bit, i) bit &flag(i)
#define flagoff(bit, i) !(bit & (1ll << i))
#define all(v) v.begin(), v.end()
#define low2way(v, x) lower_bound(all(v), x)
#define high2way(v, x) upper_bound(all(v), x)
#define idx_lower(v, x) (distance(v.begin(), low2way(v, x)))  //配列vでx未満の要素数を返す
#define idx_upper(v, x) (distance(v.begin(), high2way(v, x))) //配列vでx以下の要素数を返す
#define idx_lower2(v, x) (v.size() - idx_lower(v, x))         //配列vでx以上の要素数を返す
#define idx_upper2(v, x) (v.size() - idx_upper(v, x))         //配列vでxより大きい要素の数を返す
#define putout(a) cout << a << endl
#define Sum(v) accumulate(all(v), 0ll)
#define gcd(x, y) __gcd(x, y)
ll ctoi(char c)
{
    if (c >= '0' && c <= '9')
    {
        return c - '0';
    }
    return -1;
}
template <typename T>
T lcm(T x, T y)
{
    T z = gcd(x, y);
    return x * y / z;
}
template <typename T>
bool primejudge(T n)
{
    if (n < 2)
        return false;
    else if (n == 2)
        return true;
    else if (n % 2 == 0)
        return false;
    double sqrtn = sqrt(n);
    for (T i = 3; i < sqrtn + 1; i++)
    {
        if (n % i == 0)
        {
            return false;
        }
        i++;
    }
    return true;
}
template <typename T>
bool chmax(T &a, const T &b)
{
    if (a < b)
    {
        a = b; // aをbで更新
        return true;
    }
    return false;
}
template <typename T>
bool chmin(T &a, const T &b)
{
    if (a > b)
    {
        a = b; // aをbで更新
        return true;
    }
    return false;
}
//場合によって使い分ける
//const ll dx[4]={1,0,-1,0};
//const ll dy[4]={0,1,0,-1};
const ll dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
//2次元配列の宣言
//vector<vector<ll>> field(h, vector<ll>(w));

struct Segment_Tree_Beats
{
    const long long INF = 1e18 + 9;
    long long n, n0;
    vector<long long> fmax;   //最大値
    vector<long long> smax;   //2番目に大きい値
    vector<long long> fmax_c; //最大値の個数
    vector<long long> fmin;   //最小値
    vector<long long> smin;   //2番目に小さい値
    vector<long long> fmin_c; //最小値の個数
    vector<long long> sum;    //区間和
    vector<long long> len;    //区間の長さ
    vector<long long> ladd;   //遅延加算
    vector<long long> lval;   //遅延更新
    Segment_Tree_Beats(long long N) : n(N), fmax(4 * N), smax(4 * N), fmax_c(4 * N), fmin(4 * N), smin(4 * N),
                                      fmin_c(4 * N), sum(4 * N), len(4 * N), ladd(4 * N), lval(4 * N)
    {
        n0 = 1;
        while (n0 < n)
            n0 *= 2;
        len[0] = n0;
        for (long long i = 0; i < 2 * n0; i++)
        {
            lval[i] = INF;
        }
        for (long long i = 0; i < n0 - 1; i++)
        {
            len[2 * i + 1] = len[i] / 2;
            len[2 * i + 2] = len[i] / 2;
        }

        for (long long i = 0; i < n; i++)
        {
            long long nn = n0 - 1 + i;
            smax[nn] = -INF;
            smin[nn] = INF;
            fmax_c[nn] = 1;
            fmin_c[nn] = 1;
        }
        for (long long i = n; i < n0; i++)
        {
            long long nn = n0 - 1 + i;
            fmax[nn] = -INF;
            smax[nn] = -INF;
            fmin[nn] = INF;
            smin[nn] = INF;
        }
        for (long long i = n0 - 2; i >= 0; i--)
        {
            update(i);
        }
    }
    Segment_Tree_Beats(long long N, vector<long long> &A) : n(N), fmax(4 * N), smax(4 * N), fmax_c(4 * N), fmin(4 * N), smin(4 * N),
                                                            fmin_c(4 * N), sum(4 * N), len(4 * N), ladd(4 * N), lval(4 * N)
    {
        n0 = 1;
        while (n0 < n)
            n0 *= 2;
        len[0] = n0;
        for (long long i = 0; i < 2 * n0; i++)
        {
            lval[i] = INF;
        }
        for (long long i = 0; i < n0 - 1; i++)
        {
            len[2 * i + 1] = len[i] / 2;
            len[2 * i + 2] = len[i] / 2;
        }

        for (long long i = 0; i < n; i++)
        {
            long long nn = n0 - 1 + i;
            fmax[nn] = A[i];
            fmin[nn] = A[i];
            sum[nn] = A[i];
            smax[nn] = -INF;
            smin[nn] = INF;
            fmax_c[nn] = 1;
            fmin_c[nn] = 1;
        }
        for (long long i = n; i < n0; i++)
        {
            long long nn = n0 - 1 + i;
            fmax[nn] = -INF;
            smax[nn] = -INF;
            fmin[nn] = INF;
            smin[nn] = INF;
        }
        for (long long i = n0 - 2; i >= 0; i--)
        {
            update(i);
        }
    }
    void update_node_max(long long k, long long x)
    {
        sum[k] += (x - fmax[k]) * fmax_c[k];
        if (fmax[k] == fmin[k])
        {
            fmax[k] = x;
            fmin[k] = x;
        }
        else
        {
            if (fmax[k] == smin[k])
            {
                fmax[k] = x;
                smin[k] = x;
            }
            else
                fmax[k] = x;
        }
        //遅延処理
        if (lval[k] != INF && x < lval[k])
            lval[k] = x;
    }
    void update_node_min(long long k, long long x)
    {
        sum[k] += (x - fmin[k]) * fmin_c[k];
        if (fmin[k] == fmax[k])
        {
            fmin[k] = x;
            fmax[k] = x;
        }
        else
        {
            if (fmin[k] == smax[k])
            {
                fmin[k] = x;
                smax[k] = x;
            }
            else
                fmin[k] = x;
        }
        //遅延処理
        if (lval[k] != INF && lval[k] < x)
            lval[k] = x;
    }
    //全体加算
    void addall(long long k, long long x)
    {
        fmax[k] += x;
        fmin[k] += x;
        if (smax[k] != -INF)
            smax[k] += x;
        if (smin[k] != INF)
            smin[k] += x;
        sum[k] += len[k] * x;
        if (lval[k] != INF)
            lval[k] += x;
        else
            ladd[k] += x;
    }
    //全体更新
    void updateall(long long k, long long x)
    {
        fmax[k] = x;
        fmin[k] = x;
        smax[k] = -INF;
        smin[k] = INF;
        fmax_c[k] = len[k];
        fmin_c[k] = len[k];
        sum[k] = x * len[k];
        lval[k] = x;
        ladd[k] = 0;
    }
    //親->子への伝播
    void push(long long k)
    {
        if ((k - n0 + 1) >= 0)
            return;
        //遅延伝播
        if (lval[k] != INF)
        {
            updateall(2 * k + 1, lval[k]);
            updateall(2 * k + 2, lval[k]);
            lval[k] = INF;
            return;
        }
        if (ladd[k] != 0)
        {
            addall(2 * k + 1, ladd[k]);
            addall(2 * k + 2, ladd[k]);
            ladd[k] = 0;
        }
        for (int i = 1; i <= 2; i++)
        {
            if (fmax[k] < fmax[2 * k + i])
                update_node_max(2 * k + i, fmax[k]);
            if (fmin[k] > fmin[2 * k + i])
                update_node_min(2 * k + i, fmin[k]);
        }
    }
    //子->親への伝播
    void update(long long k)
    {
        sum[k] = sum[2 * k + 1] + sum[2 * k + 2];
        //最大値関連の更新(大きい方を優先)
        if (fmax[2 * k + 1] < fmax[2 * k + 2])
        {
            fmax[k] = fmax[2 * k + 2];
            fmax_c[k] = fmax_c[2 * k + 2];
            smax[k] = max(fmax[2 * k + 1], smax[2 * k + 2]);
        }
        if (fmax[2 * k + 1] > fmax[2 * k + 2])
        {
            fmax[k] = fmax[2 * k + 1];
            fmax_c[k] = fmax_c[2 * k + 1];
            smax[k] = max(fmax[2 * k + 2], smax[2 * k + 1]);
        }
        if (fmax[2 * k + 1] == fmax[2 * k + 2])
        {
            fmax[k] = fmax[2 * k + 1];
            fmax_c[k] = fmax_c[2 * k + 1] + fmax_c[2 * k + 2];
            smax[k] = max(smax[2 * k + 1], smax[2 * k + 2]);
        }
        //最小値関連の更新(小さい方を優先)
        if (fmin[2 * k + 1] < fmin[2 * k + 2])
        {
            fmin[k] = fmin[2 * k + 1];
            fmin_c[k] = fmin_c[2 * k + 1];
            smin[k] = min(fmin[2 * k + 2], smin[2 * k + 1]);
        }
        if (fmin[2 * k + 1] > fmin[2 * k + 2])
        {
            fmin[k] = fmin[2 * k + 2];
            fmin_c[k] = fmin_c[2 * k + 2];
            smin[k] = min(fmin[2 * k + 1], smin[2 * k + 2]);
        }
        if (fmin[2 * k + 1] == fmin[2 * k + 2])
        {
            fmin[k] = fmin[2 * k + 1];
            fmin_c[k] = fmin_c[2 * k + 1] + fmin_c[2 * k + 2];
            smin[k] = max(smin[2 * k + 1], smin[2 * k + 2]);
        }
    }
    //区間[a,b)内のiについてa[i]をmax(a[i],x)に更新
    void _update_max(long long x, long long a, long long b, long long k, long long l, long long r)
    {
        //区間をはみ出すorｘが最小値以下
        if (b <= l || r <= a || fmin[k] >= x)
            return;
        //(最小値)<x<(2番目に小さい値)のとき
        if (l >= a && r <= b && smin[k] > x)
        {
            update_node_min(k, x);
            return;
        }
        //親->子->親
        push(k);
        _update_max(x, a, b, 2 * k + 1, l, (l + r) / 2);
        _update_max(x, a, b, 2 * k + 2, (l + r) / 2, r);
        update(k);
    }
    //区間[a,b)内のiについてa[i]をmin(a[i],x)に更新
    void _update_min(long long x, long long a, long long b, long long k, long long l, long long r)
    {
        //区間をはみ出すorｘが最大値以上
        if (b <= l || r <= a || fmax[k] <= x)
            return;
        //(2番目に大きい値)<x<(最大値)のとき
        if (l >= a && r <= b && smax[k] < x)
        {
            update_node_max(k, x);
            return;
        }
        //親->子->親
        push(k);
        _update_min(x, a, b, 2 * k + 1, l, (l + r) / 2);
        _update_min(x, a, b, 2 * k + 2, (l + r) / 2, r);
        update(k);
    }
    //区間[a,b)に対する最大値クエリ
    long long _query_max(long long a, long long b, long long k, long long l, long long r)
    {
        if (b <= l || a >= r)
            return 0; //区間外
        if (a <= l && r <= b)
            return fmax[k];
        push(k);
        long long L = _query_max(a, b, 2 * k + 1, l, (l + r) / 2);
        long long R = _query_max(a, b, 2 * k + 2, (l + r) / 2, r);
        return max(L, R);
    }
    //区間[a,b)に対する最小値クエリ
    long long _query_min(long long a, long long b, long long k, long long l, long long r)
    {
        if (b <= l || a >= r)
            return INF; //区間外
        if (a <= l && r <= b)
            return fmin[k];
        push(k);
        long long L = _query_min(a, b, 2 * k + 1, l, (l + r) / 2);
        long long R = _query_min(a, b, 2 * k + 2, (l + r) / 2, r);
        return min(L, R);
    }
    //区間[a,b)に対する区間和クエリ
    long long _query_sum(long long a, long long b, long long k, long long l, long long r)
    {
        if (b <= l || a >= r)
            return 0; //区間外
        if (a <= l && r <= b)
            return sum[k];
        push(k);
        long long L = _query_sum(a, b, 2 * k + 1, l, (l + r) / 2);
        long long R = _query_sum(a, b, 2 * k + 2, (l + r) / 2, r);
        return (L + R);
    }
    //区間[a,b)に対する区間加算クエリ
    void _query_add(long long x, long long a, long long b, long long k, long long l, long long r)
    {
        if (b <= l || a >= r)
            return; //区間外
        if (a <= l && r <= b)
        {
            addall(k, x);
            return;
        }
        push(k);
        _query_add(x, a, b, 2 * k + 1, l, (l + r) / 2);
        _query_add(x, a, b, 2 * k + 2, (l + r) / 2, r);
        update(k);
    }
    //区間[a,b)に対する区間更新クエリ
    void _query_val(long long x, long long a, long long b, long long k, long long l, long long r)
    {
        if (b <= l || a >= r)
            return; //区間外
        if (a <= l && r <= b)
        {
            updateall(k, x);
            return;
        }
        push(k);
        _query_val(x, a, b, 2 * k + 1, l, (l + r) / 2);
        _query_val(x, a, b, 2 * k + 2, (l + r) / 2, r);
        update(k);
    }
    //以下外から利用するメンバ関数を羅列///////////////////////////////////////
    //区間[l,r]内のiについてa[i]をmax(a[i],x)に更新
    void update_max(long long l, long long r, long long x)
    {
        _update_max(x, l, r + 1, 0, 0, n0);
    }
    //区間[l,r]内のiについてa[i]をmin(a[i],x)に更新
    void update_min(long long l, long long r, long long x)
    {
        _update_min(x, l, r + 1, 0, 0, n0);
    }
    //区間[l,r]内のiについてa[i]にxを加算
    void query_add(long long l, long long r, long long x)
    {
        _query_add(x, l, r + 1, 0, 0, n0);
    }
    //区間[l,r]内のiについてa[i]をxに更新
    void query_val(long long l, long long r, long long x)
    {
        _query_val(x, l, r + 1, 0, 0, n0);
    }
    //区間[l,r]に対する最大値クエリ
    long long query_max(long long l, long long r)
    {
        return _query_max(l, r + 1, 0, 0, n0);
    }
    //区間[l,r]に対する最小値クエリ
    long long query_min(long long l, long long r)
    {
        return _query_min(l, r + 1, 0, 0, n0);
    }
    //区間[l,r]に対する区間和クエリ
    long long query_sum(long long l, long long r)
    {
        return _query_sum(l, r + 1, 0, 0, n0);
    }
};
/*
<Segment Tree Beats>
様々なクエリに対応した万能遅延セグメント木(0-indexed)
Segment_Tree_Beats tree(N);もしくは
Segment_Tree_Beats tree(N,a);などで宣言(N:配列のサイズ,a:入れたい配列)
tree.update_max(l,r,x):区間[l,r]内のiについてa[i]をmax(a[i],x)に更新
tree.update_min(l,r,x):区間[l,r]内のiについてa[i]をmin(a[i],x)に更新
tree.query_add(l,r,x):区間[l,r]内のiについてa[i]にxを加算
tree.query_val(l,r,x):区間[l,r]内のiについてa[i]をxに更新
tree.query_max(l,r):区間[l,r]に対する最大値クエリ
tree.query_min(l,r):区間[l,r]に対する最小値クエリ
tree.query_sum(l,r):区間[l,r]に対する区間和クエリ
*/
int main()
{
    cout << fixed << setprecision(30);
    ll N, M;
    string S;
    cin >> N >> M >> S;
    //ゲームオーバーの時
    ll count = 0;
    loop(i, N + 1)
    {
        if (S[i] == '1')
            count++;
        else
        {
            if (count >= M)
            {
                putout(-1);
                return 0;
            }
            count = 0;
        }
    }
    if (count >= M)
    {
        putout(-1);
        return 0;
    }
    //後ろからdpで最短手数を求める
    //辞書順最小は、今の手数が初めて1減る所を貪欲に取っていけばよい
    Segment_Tree_Beats tree(N + 1);
    //i=(N-1)->0
    pool(i, N - 1)
    {
        if (S[i] == '1')
        {
            tree.query_val(i, i, 1e18);
            continue;
        }
        ll L = i + 1, R = min(N, i + M);
        ll minn = tree.query_min(L, R);
        tree.query_val(i, i, minn + 1);
    }
    vector<ll> ans;
    ll now = tree.query_sum(0, 0);
    ll nowi = 0;
    loop(i, N + 1)
    {
        ll x = tree.query_sum(i, i);
        if (x < now)
        {
            ans.push_back(i - nowi);
            now = x;
            nowi = i;
        }
    }
    ll siz = ans.size();
    loop(i, siz)
    {
        cout << ans[i];
        if (i != siz)
            cout << " ";
        else
            putout("");
    }
    return 0;
}

Measured memory_bytes: 35576