#include <bits/stdc++.h>
using namespace std;
#ifndef ONLINE_JUDGE
	#include <boost/multiprecision/cpp_int.hpp>
	#include <boost/multiprecision/cpp_dec_float.hpp>
	using bll = boost::multiprecision::cpp_int;
	using bdouble = boost::multiprecision::cpp_dec_float_100;
#endif
#ifdef LOCAL_DEV
	void debug_impl() { std::cerr << std::endl; }
	template<typename Head, typename... Tail> void debug_impl(Head head, Tail... tail) { std::cerr << " " << head << (sizeof...(tail) ? "," : ""); debug_impl(tail...); }
	#define debug(...) std::cerr << std::boolalpha << "(" << #__VA_ARGS__ << ") ="; debug_impl(__VA_ARGS__); std::cerr << std::noboolalpha;
#else
	#define debug(...)
#endif
#ifdef LOCAL_TEST
	#define BOOST_STACKTRACE_USE_ADDR2LINE
	#define BOOST_STACKTRACE_ADDR2LINE_LOCATION /usr/local/opt/binutils/bin/addr2line
	#define _GNU_SOURCE
	#include <boost/stacktrace.hpp>
	template<typename T> class dvector : public std::vector<T> {
	public:
		dvector() : std::vector<T>() {}
		explicit dvector(size_t n, const T& value = T()) : std::vector<T>(n, value) {}
		dvector(const std::vector<T>& v) : std::vector<T>(v) {}
		dvector(const std::initializer_list<T> il) : std::vector<T>(il) {}
		dvector(const typename std::vector<T>::iterator first, const typename std::vector<T>::iterator last) : std::vector<T>(first, last) {}
		dvector(const std::string::iterator first, const std::string::iterator last) : std::vector<T>(first, last) {}
		T& operator[](size_t n) {
			try { return this->at(n); } catch (const std::exception& e) {
				std::cerr << boost::stacktrace::stacktrace() << std::endl; return this->at(n);
			}
		}
		const T& operator[](size_t n) const {
			try { return this->at(n); } catch (const std::exception& e) {
				std::cerr << boost::stacktrace::stacktrace() << std::endl; return this->at(n);
			}
		}
	};
	class dbool {
	private:
		bool boolvalue;
	public:
		dbool() : boolvalue(false) {}
		dbool(bool b) : boolvalue(b) {}
		dbool(const dbool &b) : boolvalue(b.boolvalue) {}
		operator bool&() { return boolvalue; }
		operator const bool&() const { return boolvalue; }
	};
	template<typename T> std::ostream& operator<<(std::ostream& s, const dvector<T>& v) {
		for (int i = 0, len = v.size(); i < len; ++i){ s << v[i]; if (i < len - 1) s << "\t"; } return s; }
	template<typename T> std::ostream& operator<<(std::ostream& s, const dvector< dvector<T> >& vv) {
		for (int i = 0, len = vv.size(); i < len; ++i){ s << vv[i] << std::endl; } return s; }
	template<typename T> std::ostream& operator<<(std::ostream& s, const std::set<T>& se) {
		s << "{ "; for (auto itr = se.begin(); itr != se.end(); ++itr){ s << (*itr) << "\t"; } s << "}"; return s; }
	template<typename T> std::ostream& operator<<(std::ostream& s, const std::multiset<T>& se) {
		s << "{ "; for (auto itr = se.begin(); itr != se.end(); ++itr){ s << (*itr) << "\t"; } s << "}"; return s; }
	template<typename T1, typename T2> std::ostream& operator<<(std::ostream& s, const std::map<T1, T2>& m) {
		s << "{" << std::endl; for (auto itr = m.begin(); itr != m.end(); ++itr){ s << "\t" << (*itr).first << " : " << (*itr).second << std::endl; } s << "}"; return s; }
	template<typename T1, typename T2> std::ostream& operator<<(std::ostream& s, const std::pair<T1, T2>& p) { 
		return s << "(" << p.first << ", " << p.second << ")"; }
	#define vector dvector
	#define bool dbool
	class SIGFPE_exception : std::exception {};
	class SIGSEGV_exception : std::exception {};
	void catch_SIGFPE(int e) { std::cerr << boost::stacktrace::stacktrace() << std::endl; throw SIGFPE_exception();	}
	void catch_SIGSEGV(int e) { std::cerr << boost::stacktrace::stacktrace() << std::endl; throw SIGSEGV_exception(); }
	signed convertedmain();
	signed main() { signal(SIGFPE, catch_SIGFPE); signal(SIGSEGV, catch_SIGSEGV); return convertedmain(); }
	#define main() convertedmain()
#endif
//#define int long long
using ll = long long;
//constexpr int INF = 1e9;//INT_MAX=(1<<31)-1=2147483647
constexpr ll INF = (ll)1e18;//(1LL<<63)-1=9223372036854775807
constexpr ll MOD = (ll)1e9 + 7;
constexpr double EPS = 1e-9;
constexpr int dx[4] = {1, 0, -1, 0};
constexpr int dy[4] = {0, 1, 0, -1};
#define p(var) std::cout<<var<<std::endl
#define rep(i, n)   for(ll i=0, i##_length=(n); i< i##_length; ++i)
#define repeq(i, n) for(ll i=1, i##_length=(n); i<=i##_length; ++i)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define uniq(v) (v).erase(unique((v).begin(), (v).end()), (v).end());
template<typename T> inline void pv(vector<T> &v) { for(ll i=0, N=v.size(); i<N; i++) std::cout << v[i] << " \n"[i==N-1]; }
template<typename T> inline T gcd(T a, T b) { return b ? gcd(b,a%b) : a; }
template<typename T> inline T lcm(T a, T b) { return a / gcd(a,  b) * b; }
template<typename T1, typename T2> inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }
template<typename T1, typename T2> inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }

/*-----8<-----template-----8<-----*/

/*
https://scrapbox.io/data-structures/Sliding_Window_Aggregation
半群の列 (a0, a1, ... , aN-1) を扱う
空間計算量 O(N)
new()
	空の状態でデータ構造を作成する
	時間計算量 O(1)
fold_all()
	op(a0, a1, ... , aN-1) を計算する
	時間計算量 O(1)
push_front/back()
	x を先頭 / 末尾に追加する
	時間計算量 O(1) amortized
pop_front/back()
	先頭要素 a0/末尾要素 aN-1 を削除する
	時間計算量 O(1) amortized
*/
template <class T, class Op> class DequeAggregation {
private:
	class node {
	public:
		T val, sum;
		node(const T &val, const T &sum) : val(val), sum(sum) {}
	};

	Op op;
	std::stack<node> front_stack, back_stack;

public:
	DequeAggregation(const Op &op = Op())
			: op(op), front_stack(), back_stack() {}

	bool empty() const { return front_stack.empty() && back_stack.empty(); }

	std::size_t size() const { return front_stack.size() + back_stack.size(); }

	T fold_all() const {
		assert(!empty());
		if (front_stack.empty()) {
			return back_stack.top().sum;
		} else if (back_stack.empty()) {
			return front_stack.top().sum;
		} else {
			return op(front_stack.top().sum, back_stack.top().sum);
		}
	}

	void _push_core(const T &x, std::stack<node> &first_stack){
		if (first_stack.empty()) {
			first_stack.emplace(x, x);
		} else {
			T s{op(first_stack.top().sum, x)};
			first_stack.emplace(x, s);
		}
	}
	
	void push_front(const T &x) {
		_push_core(x, front_stack);
	}

	void push_back(const T &x) {
		_push_core(x, back_stack);
	}

	void flatten(std::stack<node> &first_stack, std::stack<node> &second_stack) {
		assert(!empty());
		if (first_stack.empty()) {
			std::size_t firstsize = second_stack.size() / 2 + 1;
			std::size_t secondsize = second_stack.size() - firstsize;
			std::queue<T> tmp_first_queue;
			std::stack<T> tmp_second_stack;
			for(std::size_t i = 0; i < secondsize; i++) {
				tmp_second_stack.emplace(second_stack.top().val);
				second_stack.pop();
			}
			for(std::size_t i = 0; i < firstsize; i++) {
				tmp_first_queue.emplace(second_stack.top().val);
				second_stack.pop();
			}

			if(firstsize > 0) {
				first_stack.emplace(tmp_first_queue.front(), tmp_first_queue.front());
				tmp_first_queue.pop();
				while (!tmp_first_queue.empty()) {
					T s{op(tmp_first_queue.front(), first_stack.top().sum)};
					first_stack.emplace(tmp_first_queue.front(), s);
					tmp_first_queue.pop();
				}
			}
			if(secondsize > 0) {
				second_stack.emplace(tmp_second_stack.top(), tmp_second_stack.top());
				tmp_second_stack.pop();
				while (!tmp_second_stack.empty()) {
					T s{op(tmp_second_stack.top(), second_stack.top().sum)};
					second_stack.emplace(tmp_second_stack.top(), s);
					tmp_second_stack.pop();
				}
			}
		}
	}

	T _pop_core(std::stack<node> &first_stack, std::stack<node> &second_stack) {
		flatten(first_stack, second_stack);
		T val = first_stack.top().val;
		first_stack.pop();
		return val;
	}

	T pop_front() {
		return _pop_core(front_stack, back_stack);
	}

	T pop_back() {
		return _pop_core(back_stack, front_stack);
	}

	T _peek_core(std::stack<node> &first_stack, std::stack<node> &second_stack) {
		flatten(first_stack, second_stack);
		return first_stack.top().x;
	}

	T front() {
		return _peek_core(front_stack, back_stack);
	}
	
	T back() {
		return _peek_core(back_stack, front_stack);
	}
};

/*-----8<-----library-----8<-----*/

void solve() {
	ll N,M;
	string S;
	cin>>N>>M>>S;

	//各マス目に最短何手目で到達できるか
	//x,yの型は、DequeAggregationに格納する型と合わせること
	auto F = [](const ll x, const ll y) {
		return min(x,y);
	};
	DequeAggregation<ll, decltype(F)> qa(F);
	qa.push_back(0);

	vector<ll> step(N+1,INF);
	step[N]=0;
	rep(i,N){
		ll j=N-1-i;
		if(qa.size()>M)qa.pop_front();
		ll t=INF;
		if(S[j]=='0')t=qa.fold_all();
		step[j]=t+1;
		qa.push_back(t+1);
	}

	debug(step);
	if(step[0]>=INF){
		p(-1);return;
	}

	ll stepval=step[0]+1;
	vector<ll> ans;
	rep(i,N+1){
		if(stepval-1 == step[i]){
			stepval--;
			ans.push_back(i);
		}
	}
	debug(ans);

	rep(i,ans.size()-1){
		cout << ans[i+1]-ans[i] << (" \n"[i==ans.size()-2]);
	}
}

// https://atcoder.jp/contests/abc146/tasks/abc146_f
signed main() {
	solve();
	return 0;
}


Measured memory_bytes: 2688