#include <stdio.h>
#include <stdlib.h>

int main()
{
    int n = 3, i, G[10000] = {0}, K[10000] = {0}, Gr0 = 0, GrA = 0, GrB = 0, GrAB = 0;
    int Gr0Pot = 0, GrAPot = 0, GrBPot = 0, GrABPot = 0, Izlaz[10000][4] = {{0, 0, 0, 0}};
    char grupa[4];

    scanf("%d", &n);
    scanf("%d %d %d %d", &Gr0, &GrA, &GrB, &GrAB);
    for (i = 0; i < n; i++)
    {
        scanf("%s %d", grupa, &K[i]);
        if (grupa[1] == '\0')
        {
            switch (grupa[0])
            {
            case 'O':
                G[i] = 0;
                Gr0Pot = Gr0Pot + K[i];
                break;
            case 'A':
                G[i] = 1;
                GrAPot = GrAPot + K[i];
                break;
            case 'B':
                G[i] = 2;
                GrBPot = GrBPot + K[i];
                break;
            }
        }
        else
        {
            GrABPot = GrABPot + K[i];
            G[i] = 3;
        }

        if (Gr0Pot > Gr0)
        {
            printf("nemoguce");
            return 0;
        }
        else if ((GrAPot > GrA || GrBPot > GrB))
        {
            int raz0 = Gr0 - Gr0Pot, razA = 0, razB = 0;
            if (GrA < GrAPot)
                razA = GrAPot - GrA;
            if (GrB < GrBPot)
                razB = GrBPot - GrB;
            if (raz0 < razA + razB)
            {
                printf("nemoguce");
                return 0;
            }
        }
        //else
        if ((GrABPot > GrAB))
        {
            int dos0 = Gr0 - Gr0Pot, dosA = GrA - GrAPot, dosB = GrB - GrBPot, dos;
            dos = dos0 + dosA + dosB;

            if (GrABPot - GrAB > dos)
            {
                printf("nemoguce");
                return 0;
            }
        }
    }
    for (i = 0; i < n; i++)
    {
        switch (G[i])
        {
        case 0:
            Izlaz[i][0] = K[i];
            Gr0 = Gr0 - K[i];
            break;
        case 1:
            if (K[i] <= GrA)
            {
                Izlaz[i][1] = K[i];
                GrA = GrA - K[i];
            }
            else
            {
                Izlaz[i][1] = GrA;
                Izlaz[i][0] = K[i] - GrA;
                Gr0 = Gr0 - GrA;
                GrA = 0;
            }
            break;
        case 2:
            if (K[i] <= GrB)
            {
                Izlaz[i][2] = K[i];
                GrB = GrB - K[i];
            }
            else
            {
                Izlaz[i][2] = GrB;
                Izlaz[i][0] = K[i] - GrB;
                Gr0 = Gr0 - GrB;
                GrB = 0;
            }
        }
    }
    for (i = 0; i < n; i++)
        if (G[i] == 3)
        {
            if (K[i] <= GrAB)
            {
                Izlaz[i][3] = K[i];
                GrAB = GrAB - K[i];
            }
            else
            {
                Izlaz[i][3] = GrAB;
                int raz = K[i] - GrAB;
                if (Gr0 > 0)
                {
                    if (Gr0 >= raz)
                    {
                        Izlaz[i][0] = raz;
                        Gr0 = Gr0 - raz;
                        raz = 0;
                    }
                    else
                    {
                        Izlaz[i][0] = Gr0;
                        raz = raz - Gr0;
                        Gr0 = 0;
                    }
                }
                if (GrA > 0 && raz > 0)
                {
                    if (GrA >= raz)
                    {
                        Izlaz[i][1] = raz;
                        GrA = GrA - raz;
                        raz = 0;
                    }
                    else
                    {
                        Izlaz[i][1] = GrA;
                        raz = raz - GrA;
                        GrA = 0;
                    }
                }
                if (GrB > 0 && raz > 0)
                {
                    if (GrB >= raz)
                    {
                        Izlaz[i][2] = raz;
                        GrB = GrB - raz;
                        raz = 0;
                    }
                    else
                    {
                        Izlaz[i][2] = GrB;
                        raz = raz - GrB;
                        GrB = 0;
                    }
                }
            }
        }
    printf("moguce");
    for (i = 0; i < n; i++)
        printf("\n%2d%2d%2d%2d", Izlaz[i][0], Izlaz[i][1], Izlaz[i][2], Izlaz[i][3]);

    return 0;
}