#include <bits/stdc++.h>
using namespace std;

string C;
int L, N, M;

vector<int> ans;
vector<unsigned char> used;
vector<int> lastPos;

const int INF = 1e9;

long long total_len(long long n) {
    long long res = 0;

    for (long long len = 1, l = 1; l <= n; len++, l <<= 1) {
        long long r = min(n, (1LL << len) - 1);
        res += len * (r - l + 1);

        if (l > n / 2) break;
    }

    return res;
}

int bit_len(int x) {
    return 32 - __builtin_clz((unsigned)x);
}

struct SegTree {
    int n;
    vector<pair<int, int>> seg;

    void init(const vector<int>& a) {
        int sz = (int)a.size() - 1;
        n = 1;
        while (n < sz) n <<= 1;

        seg.assign(2 * n, {INF, INF});

        for (int i = 1; i <= sz; i++) {
            seg[n + i - 1] = {a[i], i};
        }

        for (int i = n - 1; i >= 1; i--) {
            seg[i] = min(seg[i << 1], seg[i << 1 | 1]);
        }
    }

    void set_val(int idx, int value) {
        int p = n + idx - 1;
        seg[p] = {value, idx};

        while (p >>= 1) {
            seg[p] = min(seg[p << 1], seg[p << 1 | 1]);
        }
    }

    pair<int, int> min_all() const {
        return seg[1];
    }
};

SegTree st;

bool dfs(int pos) {
    if (pos == L) {
        return (int)ans.size() == N;
    }

    if (C[pos] != '1') return false;

    auto [mnLast, forcedValue] = st.min_all();

    if (mnLast < pos) return false;

    int required = 0;

    if (mnLast == pos) {
        required = forcedValue;
    }

    struct Cand {
        int deadline;
        int len;
        int value;
    };

    vector<Cand> cand;

    int v = 0;

    for (int len = 1; len <= M && pos + len <= L; len++) {
        v = (v << 1) + (C[pos + len - 1] - '0');

        if (v > N) break;
        if (used[v]) continue;
        if (required && v != required) continue;

        int nxt = pos + len;

        if (nxt < L && C[nxt] != '1') continue;

        used[v] = 1;
        st.set_val(v, INF);

        bool ok = true;

        if (st.min_all().first < nxt) {
            ok = false;
        }

        if (ok) {
            cand.push_back({lastPos[v], len, v});
        }

        st.set_val(v, lastPos[v]);
        used[v] = 0;
    }

    sort(cand.begin(), cand.end(), [](const Cand& a, const Cand& b) {
        if (a.deadline != b.deadline) return a.deadline < b.deadline;
        return a.len > b.len;
    });

    for (auto [_, len, v] : cand) {
        int nxt = pos + len;

        used[v] = 1;
        st.set_val(v, INF);
        ans.push_back(v);

        if (dfs(nxt)) return true;

        ans.pop_back();
        st.set_val(v, lastPos[v]);
        used[v] = 0;
    }

    return false;
}

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

    cin >> C;
    L = (int)C.size();

    long long lo = 1, hi = 65535;

    while (lo < hi) {
        long long mid = (lo + hi) / 2;

        if (total_len(mid) >= L) hi = mid;
        else lo = mid + 1;
    }

    if (total_len(lo) != L) {
        return 0;
    }

    N = (int)lo;
    M = bit_len(N);

    used.assign(N + 1, 0);
    lastPos.assign(N + 1, -1);

    for (int s = 0; s < L; s++) {
        if (C[s] != '1') continue;

        int v = 0;

        for (int len = 1; len <= M && s + len <= L; len++) {
            v = (v << 1) + (C[s + len - 1] - '0');

            if (v > N) break;

            int t = s + len;

            if (t == L || C[t] == '1') {
                lastPos[v] = s;
            }
        }
    }

    for (int v = 1; v <= N; v++) {
        if (lastPos[v] == -1) return 0;
    }

    st.init(lastPos);

    dfs(0);

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

    cout << '\n';

    return 0;
}