/**
 * code generated by JHelper
 * More info: https://g...content-available-to-author-only...b.com/AlexeyDmitriev/JHelper
 * @author RiaD
 */
 
#include <iostream>
#include <fstream>
 
#include <iostream>
#include <cassert>
#include <vector>
#include <algorithm>
 
 
#include <iterator>
 
 
#include <string>
#include <stdexcept>
 
#ifndef SPCPPL_ASSERT
	#ifdef SPCPPL_DEBUG
		#define SPCPPL_ASSERT(condition) \
		if(!(condition)) { \
			throw std::runtime_error(std::string() + #condition + " in line " + std::to_string(__LINE__) + " in " + __PRETTY_FUNCTION__); \
		}
	#else
		#define SPCPPL_ASSERT(condition)
	#endif
#endif
 
 
/**
* Support decrementing and multi-passing, but not declared bidirectional(or even forward) because
* it's reference type is not a reference.
*
* It doesn't return reference because
* 1. Anyway it'll not satisfy requirement [forward.iterators]/6
*   If a and b are both dereferenceable, then a == b if and only if *a and
*   b are bound to the same object.
* 2. It'll not work with reverse_iterator that returns operator * of temporary which is temporary for this iterator
*
* Note, reverse_iterator is not guaranteed to work  now too since it works only with bidirectional iterators,
* but it's seems to work at least on my implementation.
*
* It's not really useful anywhere except iterating anyway.
*/
template <typename T>
class IntegerIterator {
public:
	using value_type = T;
	using difference_type = std::ptrdiff_t;
	using pointer = T*;
	using reference = T;
	using iterator_category = std::input_iterator_tag;
 
	explicit IntegerIterator(T value): value(value) {
 
	}
 
	IntegerIterator& operator++() {
		++value;
		return *this;
	}
 
	IntegerIterator operator++(int) {
		IntegerIterator copy = *this;
		++value;
		return copy;
	}
 
	IntegerIterator& operator--() {
		--value;
		return *this;
	}
 
	IntegerIterator operator--(int) {
		IntegerIterator copy = *this;
		--value;
		return copy;
	}
 
	T operator*() const {
		return value;
	}
 
	bool operator==(IntegerIterator rhs) const {
		return value == rhs.value;
	}
 
	bool operator!=(IntegerIterator rhs) const {
		return !(*this == rhs);
	}
 
private:
	T value;
};
 
template <typename T>
class IntegerRange {
public:
	IntegerRange(T begin, T end): begin_(begin), end_(end) {
		SPCPPL_ASSERT(begin <= end);
	}
 
	IntegerIterator<T> begin() const {
		return IntegerIterator<T>(begin_);
	}
 
	IntegerIterator<T> end() const {
		return IntegerIterator<T>(end_);
	}
 
private:
	T begin_;
	T end_;
};
 
template <typename T>
class ReversedIntegerRange {
	using IteratorType = std::reverse_iterator<IntegerIterator<T>>;
public:
	ReversedIntegerRange(T begin, T end): begin_(begin), end_(end) {
		SPCPPL_ASSERT(begin >= end);
	}
 
	IteratorType begin() const {
		return IteratorType(IntegerIterator<T>(begin_));
	}
 
	IteratorType end() const {
		return IteratorType(IntegerIterator<T>(end_));
	}
 
private:
	T begin_;
	T end_;
};
 
template <typename T>
IntegerRange<T> range(T to) {
	return IntegerRange<T>(0, to);
}
 
template <typename T>
IntegerRange<T> range(T from, T to) {
	return IntegerRange<T>(from, to);
}
 
template <typename T>
IntegerRange<T> inclusiveRange(T to) {
	return IntegerRange<T>(0, to + 1);
}
 
template <typename T>
IntegerRange<T> inclusiveRange(T from, T to) {
	return IntegerRange<T>(from, to + 1);
}
 
template <typename T>
ReversedIntegerRange<T> downrange(T from) {
	return ReversedIntegerRange<T>(from, 0);
}
 
template <typename T>
ReversedIntegerRange<T> downrange(T from, T to) {
	return ReversedIntegerRange<T>(from, to);
}
 
template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from) {
	return ReversedIntegerRange<T>(from + 1, 0);
}
 
template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from, T to) {
	return ReversedIntegerRange<T>(from + 1, to);
}
 
//#define PROBLEM "problem_name.h"
//#include PROBLEM
//#include <message.h>
//#include <spcppl/dgcj.h>
 
using namespace std;
 
class E3SortirovkaSliyaniem {
public:
	static constexpr int kStressCount = 0;
 
	static void generateTest(std::ostream& test) {
	}
 
	void solve(std::istream& in, std::ostream& out) {
		//static int testnumber = 0;
		//out << "Case #" << ++testnumber << ": ";
		//cerr << "test " << testnumber << endl;
 
		string s;
		in >> s;
		int ptr = 0;
 
		auto go = [&](auto& go, int l, int r) {
			if (r - l <= 1) {
				return;
			}
			int m = (l + r) >> 1;
			go(go, l, m);
			go(go, m, r);
			int cnt0 = 0;
			int cnt1 = 0;
			while (cnt0 < m - l && cnt1 < r - m) {
				if (ptr == s.size()) {
					throw 1;
				}
				if (s[ptr++] == '0') {
					++cnt0;
				}
				else {
					++cnt1;
				}
			}
		};
 
		vector<int> a;
		vector<int> b;
		auto res = [&](auto& go, int l, int r) {
			if (r - l <= 1) {
				return;
			}
			int m = (l + r) >> 1;
			go(go, l, m);
			go(go, m, r);
			int i = l;
			int j = m;
			int k = l;
			while (i < m and j < r) {
				assert(ptr != s.size());
				if (s[ptr++] == '0') {
					b[k++] = a[i++];
				}
				else {
					b[k++] = a[j++];
				}
			}
			while (i < m) {
				b[k++] = a[i++];
			}
			while (j < r) {
				b[k++] = a[j++];
			}
 
			for (int i: range(l, r)) {
				a[i] = b[i];
			}
		};
 
		int l = 1, r = 100000;
		while (l <= r) {
			int m = (l + r) / 2;
 
			try {
				ptr = 0;
				go(go, 0, m);
			}
			catch (int) {
				r = m - 1;
				continue;
			}
			if (ptr == s.size()) {
				int i = m;
				out << i << "\n";
				a.resize(i);
				b.resize(i);
				for (int j: range(i)) {
					a[j] = j;
				}
				ptr = 0;
				res(res, 0, i);
				vector<int> c(a.size());
				for (int t: range(a.size())) {
					b[a[t]] = t;
				}
				for (int x: b) {
					out << x + 1 << " ";
				}
				return;
			}
			l = m + 1;
		}
		
	}
};
 
 
int main() {
	std::ios_base::sync_with_stdio(false);
	E3SortirovkaSliyaniem solver;
	std::istream& in(std::cin);
	std::ostream& out(std::cout);
	in.tie(nullptr);
	out << std::fixed;
	out.precision(20);
	solver.solve(in, out);
	return 0;
}