#include <bits/stdc++.h>

using namespace std;

const int N = 100'007;
const int INF = 1'000'000'007;

int A, B, C;
int limit[3];
int ans[N];

queue <tuple <int, int, int> > Q;
map <tuple <int, int, int>, int > D;

void get_edges(vector <int> vec, int d)
{
    auto update = [&](int a, int b, int c) {
        if (!D.count({a, b, c})) {
            D[{a, b, c}] = d + 1;
            Q.push({a, b, c});
        }
    };

    for (int l = 0; l < 3; ++l) {
        for (int r = 0; r < 3; ++r) {
            if (l == r) {
                continue;
            }

            int clr = min(vec[l], limit[r] - vec[r]);
            if (clr == 0) {
                continue;
            }

            vector <int> next_vec = vec;
            next_vec[l] -= clr;
            next_vec[r] += clr;
            update(next_vec[0], next_vec[1], next_vec[2]);
        }
    }
}

int main()
{
    cin >> A >> B >> C;
    limit[0] = A, limit[1] = B, limit[2] = C;

    for (int i = 0; i <= C; ++i) {
        ans[i] = INF;
    }

    int sa, sb, sc;
    cin >> sa >> sb >> sc;

    D[{sa, sb, sc}] = 0;
    Q.push({sa, sb, sc});

    while (!Q.empty()) {
        const auto [a, b, c] = Q.front();
        Q.pop();

        const int &d = D[{a, b, c}];
        ans[a] = min(ans[a], d);
        ans[b] = min(ans[b], d);
        ans[c] = min(ans[c], d);

        get_edges({a, b, c}, d);
    }

    for (int i = 0; i <= C; ++i) {
        if (ans[i] == INF) {
            ans[i] = -1;
        }

        printf("%d%c", ans[i], " \n"[i == C]);
    }
}