#include <iostream>
#include <cstdio>
#include <algorithm>
#include <queue>
#include <utility>
using namespace std;

int S;
int pojemnosc[3];
int kombinacje[6][3]={{0,1,2},{0,2,1},{1,0,2},{1,2,0},{2,0,1},{2,1,0}};
int wynik[6][2][100022]; //i-ta kombinacja butelek,info czy zerowa jest pusta czy pelna, ile w pierwszej
int plyn[3];
int kopia_plyn[3];
//stan (1,0,3) -> butelka nr 0 jest pusta, butelka nr 1 ma 3 litry, butelka nr 2 ma S-3litry
// stan(4,1,2) -> butelka nr 2 jest pelna, butelka nr 0 ma 2 litry, butelka nr 1 ma S-2-r2 litrow

//kazdy stan(wynik) wystapi max 1 raz, dla kadego przejrzymy 6*6 krawedzi
int odp[500020];

struct stan
{
    int x;
    int y;
    int z;
};

queue< pair<stan,int> > Q;

int main()
{
    int r0,r1,r2,p0,p1,p2;
    
    scanf("%d%d%d%d%d%d",&r0,&r1,&r2,&p0,&p1,&p2);
    //pojemnosc[6][3]={{r0,r1,r2},{r0,r2,r1},{r1,r0,r2},{r1,r2,r0},{r2,r0,r1},{r2,r1,r0}};
    pojemnosc[0]=r0;
    pojemnosc[1]=r1;
    pojemnosc[2]=r2;
    S=p0+p1+p2;
    stan s;
    for (int i=0; i<=r2; i++)  //ustawiamy odp na -1, jesszce na nie czekamy
        odp[i]=-1;
    
    //ustaw stany poczatkowe i ich odleglosci od zrodla
    //mamy 6 mozliwych przelan na poczatek
    //(0->1)
    //niezaleznie od tego czy bedziemy musieli inicjujac zrobic jakies przelanie to zapisujemy wyniki
    odp[p0]=1;
    odp[p1]=1;
    odp[p2]=1;
    int ile_mam=3;
    if (p0>r2)
        ile_mam--;
    if (p1>r2)
        ile_mam--;
    if (p0==p1 && p0!=p2 && p0<=r2)
        ile_mam--;
    if (p0==p2 && p0!=p1)
        ile_mam--;
    if (p1==p2 && p1!=p0 && p0<=r2)
        ile_mam--;
    if (p0==p1 && p1==p2)
        ile_mam-=2;
    //kodowanie wyniku jest dobre odrazu, wprowadzamy dowolny z poczatkow
    if (p0==0 || p1==0 || p2==0 || p0==r0 || p1==r1 || p2==r2)
    {
        
        if (p0==0)
        {
            stan poczatek={0,0,p1};
            Q.push(make_pair(poczatek,1));
        }
        if (p1==0)
        {
            stan poczatek={3,0,p2};
            Q.push(make_pair(poczatek,1));
        }
        if (p2==0)
        {
            stan poczatek={4,0,p0};
            Q.push(make_pair(poczatek,1));
        }
        if (p0==r0)
        {
            stan poczatek={0,1,p1};
            Q.push(make_pair(poczatek,1));
        }
        if (p1==r1)
        {
            stan poczatek={3,1,p2};
            Q.push(make_pair(poczatek,1));
        }
        if (p2==r2)
        {
            stan poczatek={4,1,p0};
            Q.push(make_pair(poczatek,1));
        }
    
    }
    //musimy cos przelac aby zainicjowac starty (wszystkie opcje dorzucamy na start)
    else
    {
        //0->1 (i->j)

        if (p0<=r1-p1) //w 1 wecej miejsca => p0 bedzie puste
        {
            stan poczatek={1,0,p2};
            Q.push(make_pair(poczatek,2));
        }
        else //w 1 mniej miejsca => p1 bedzie pelne
        {
            stan poczatek={3,1,p2};
            Q.push(make_pair(poczatek,2));
        }
        //0->2
        if (p0<=r2-p2) //w 2 wecej miejsca => p0 bedzie puste
        {
            stan poczatek={0,0,p1};
            Q.push(make_pair(poczatek,2));
        }
        else//w 2 mniej miejsca => p2 bedzie pelne
        {
            stan poczatek={5,1,p1};
            Q.push(make_pair(poczatek,2));
        }
        //1->0
        if (p1<=r0-p0) //w 0 wecej miejsca => p1 bedzie puste
        {
            stan poczatek={3,0,p2};
            Q.push(make_pair(poczatek,2));
        }
        else          //w 0 mniej miejsca => p0 bedzie pelne
        {
            stan poczatek={1,1,p2};
            Q.push(make_pair(poczatek,2));
        }
        //1->2
        if (p1<=r2-p2) //w 2 wecej miejsca => p1 bedzie puste
        {
            stan poczatek={2,0,p0};
            Q.push(make_pair(poczatek,2));
        }
        else          //w 2 mniej miejsca => p2 bedzie pelne
        {
            stan poczatek={4,1,p0};
            Q.push(make_pair(poczatek,2));
        }
        //2->0
        if (p2<=r0-p0) //w 0 wecej miejsca => p2 bedzie puste
        {
            stan poczatek={5,0,p1};
            Q.push(make_pair(poczatek,2));
        }
        else          //w 0 mniej miejsca => p0 bedzie pelne
        {
            stan poczatek={0,1,p1};
            Q.push(make_pair(poczatek,2));
        }
        //2->1
        if (p2<=r1-p1) //w 1 wecej miejsca => p2 bedzie puste
        {
            stan poczatek={4,0,p0};
            Q.push(make_pair(poczatek,2));
        }
        else          //w 1 mniej miejsca => p1 bedzie pelne
        {
            stan poczatek={2,1,p0};
            Q.push(make_pair(poczatek,2));
        }
    }
    
    ///
    //cout<<Q.size()<<"\n";
    while (!Q.empty())
    {
        s=Q.front().first;
        int odl=Q.front().second;
       // cout<<"POBIERAM: "<<s.x<<" "<<s.y<<" "<<s.z<<"\n\n";
        if (wynik[s.x][s.y][s.z]>0) //jezeli ten stan odwiedzilismy wczensiej nie zaglebiaj sie
        {
          //  cout<<"USUWAM\n";
            Q.pop();
            continue;
        }
        wynik[s.x][s.y][s.z]=odl; //ustaw minimalna sciezke do stanu na aktualna odleglosc
        
        //uaktualnij odpowiedzi
        if (odp[s.z]==-1)
        {
            odp[s.z]=odl;
            ile_mam++;
        }
        if (s.y==1)
        {
            int id=kombinacje[s.x][0];
           // cout<<pojemnosc[id]<<" "<<id<<" "<<odl<<"\n";
            if (odp[pojemnosc[id]]==-1)
            {
                odp[pojemnosc[id]]=odl;
                ile_mam++;
            }
            if (odp[S-s.z-pojemnosc[id]]==-1)
            {
                odp[S-s.z-pojemnosc[id]]=odl;
                ile_mam++;
            }
        }
        if (s.y==0)
        {
            if (odp[0]==-1)
            {
                odp[0]=odl;
                ile_mam++;
            }
            if (odp[S-s.z]==-1)
            {
                odp[S-s.z]=odl;
                ile_mam++;
            }
        }
        if (ile_mam==r2+1)
            break;
        Q.pop(); //usun ten stan
        //znajdz nowe osiagalne dla niego
        int ind_0=kombinacje[s.x][0];
        int ind_1=kombinacje[s.x][1];
        int ind_2=kombinacje[s.x][2];
        if (s.y==0)
        {
            plyn[ind_0]=0;
            plyn[ind_1]=s.z;
            plyn[ind_2]=S-s.z;
        }
        if (s.y==1)
        {
            plyn[ind_0]=pojemnosc[ind_0];
            plyn[ind_1]=s.z;
            plyn[ind_2]=S-(s.z+pojemnosc[ind_0]);
        }
        kopia_plyn[0]=plyn[ind_0];
        kopia_plyn[1]=plyn[ind_1];
        kopia_plyn[2]=plyn[ind_2];
        for (int i=0; i<=2; i++) //probujemy przelac (i->j) (z kombinacje[s.x][i] -> kombinacje[s.x][j])
        {
            plyn[ind_0]=kopia_plyn[0]; //ustawiamy na wartosci poczatkowe
            plyn[ind_1]=kopia_plyn[1];
            plyn[ind_2]=kopia_plyn[2];
            if (plyn[kombinacje[s.x][i]]==0) //jezeli w stanie w ktorym i-ta butelka byla pusta, to z niej nie przelejemy nic
                continue;
            for (int j=0; j<=2; j++)
            {
                plyn[ind_0]=kopia_plyn[0]; //ustawiamy na wartosci poczatkowe
                plyn[ind_1]=kopia_plyn[1];
                plyn[ind_2]=kopia_plyn[2];
                if (i==j)   // sam do siebie nie przeleje
                    continue;
                if (pojemnosc[kombinacje[s.x][j]]==plyn[kombinacje[s.x][j]]) //jezeli ta do ktorej przelewamy pelna, to nic tam nie przelejemy
                    continue;
                //(i->j)
                int miejsce_w_j=pojemnosc[kombinacje[s.x][j]]-plyn[kombinacje[s.x][j]];
                if (plyn[kombinacje[s.x][i]]<=miejsce_w_j)
                {
                    plyn[kombinacje[s.x][j]]+=plyn[kombinacje[s.x][i]]; //przelewam wszystko
                    plyn[kombinacje[s.x][i]]=0; //zostaje 0
                }
                else
                {
                    plyn[kombinacje[s.x][i]]-=miejsce_w_j; //przelewam tylko ile w j miejsca
                    plyn[kombinacje[s.x][j]]=pojemnosc[kombinacje[s.x][j]]; // j pelne
                }
                //^ zrobilismy przelanie, teraz trzeba to zakodowac - znowu max  6mozliwosci - kolejnosci
                //int z=(3-((i+j)%3))%3; //indeks trzeciej butelki, tej co stan sie nie zmienil na liscie w kombinacje[s.x]
                
                for (int k=0;  k<6; k++)
                {
                    //nasza kolejnosc brania do sprawdzenia to kombinacje[k]
                    if (plyn[kombinacje[k][0]]==0) //jezeli mamy tam 0 plynu
                    {
                        stan nowy={k,0,plyn[kombinacje[k][1]]};
                        if (wynik[k][0][plyn[kombinacje[k][1]]]==0) //stan nieodwiedzony
                        {
                            //cout<<"dorzucam: "<<nowy.x<<" "<<nowy.y<<" "<<nowy.z<<"\n";
                            Q.push(make_pair(nowy,odl+1));
                        }
                        
                    }
                    if (plyn[kombinacje[k][0]]==pojemnosc[kombinacje[k][0]]) // jezeli mamy tam full plynu
                    {// to dobra kolejnosc do zakodowania
                        stan nowy={k,1,plyn[kombinacje[k][1]]};
                        if (wynik[k][1][plyn[kombinacje[k][1]]]==0) //stan nieodwiedzony
                        {
                            //cout<<"dorzucam: "<<nowy.x<<" "<<nowy.y<<" "<<nowy.z<<"\n";
                            Q.push(make_pair(nowy,odl+1));
                        }
                        
                    }
                    //else nie wrzucaj tej kolejnosci - to niepoprawny stan
                }
            }
        }
    }
    
    for (int i=0; i<=r2; i++)
    {
        if (odp[i]==-1)
            printf("-1 ");
        else
            printf("%d ", odp[i]-1);
    }

    return 0;
}