#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
#include <utility>


using namespace std;

long int Sum (vector<long int> vec)
{
    long int sum = 0;
    for(unsigned int i = 0; i < vec.size(); i++)
    {
        sum += vec[i];
    }
    return sum;
}

long int SumTwo (unordered_map<string, long int> mymap)
{
    long int sum = 0;
    for(auto it : mymap)
        sum += it.second;

    return sum;
}



int main()
{
    cin.tie(0);
    std::ios_base::sync_with_stdio(false);

    long int n , o, a, b, ab;

    cin >> n;
    cin >> o >> a >> b >> ab;
    unordered_map<string , long int> StorageMap;
    unordered_map<string , vector<long int>> PatientMap;
    vector<string> Order;


    StorageMap.insert(pair<string, long int>("AB", ab));
    StorageMap.insert(pair<string, long int>("B", b));
    StorageMap.insert(pair<string, long int>("A", a));
    StorageMap.insert(pair<string, long int>("O", o));

    string PatientType;
    long int PatientNeed;
    for(int i = 0; i < n; i++)
    {
        cin >> PatientType >> PatientNeed;
        PatientMap[PatientType].push_back(PatientNeed);
        Order.push_back(PatientType);
    }

    if(Sum(PatientMap["O"]) > StorageMap["O"])
    {
        cout << "nemoguce\n";
    }
    else if((Sum(PatientMap["O"]) + Sum(PatientMap["A"])) > (StorageMap["O"] + StorageMap["A"]))
        {
            cout << "nemoguce\n";
        }
        else if((Sum(PatientMap["O"]) + Sum(PatientMap["B"])) > (StorageMap["O"] + StorageMap["B"]))
            {
                cout << "nemoguce\n";
            }
            else if((Sum(PatientMap["O"]) + Sum(PatientMap["B"]) + Sum(PatientMap["A"]) + Sum(PatientMap["AB"])) > (StorageMap["O"] + StorageMap["B"] + StorageMap["A"] + StorageMap["AB"]))
                {
                    cout << "nemoguce\n";
                }
                else
                {
                    cout << "moguce\n";
                   /* for(auto it : PatientMap)
                    {
                        cout << it.first << ":";
                        for(auto t : it.second)
                        {
                            cout << t << " ";
                        }
                        cout << "\n";
                    }*/
                    unordered_map<string, long int> SolMap;



                    SolMap.insert(pair<string, long int>("AB", 0));
                    SolMap.insert(pair<string, long int>("B", 0));
                    SolMap.insert(pair<string, long int>("A", 0));
                    SolMap.insert(pair<string, long int>("O", 0));


                    for(auto a : Order)
                    {


                        if(a == "AB")
                        {

                            // while(SumTwo(SolMap) < PatientMap["AB"][0])
                                    long int konst = PatientMap["AB"][0];

                                   if((PatientMap["AB"][0] - StorageMap["AB"]) >= 0) //check if there is AB available
                                    {
                                        SolMap["AB"] = StorageMap["AB"];

                                        PatientMap["AB"][0] -= SolMap["AB"];
                                        StorageMap["AB"] -= SolMap["AB"];
                                          if(PatientMap["AB"][0] == 0)
                                            {
                                                PatientMap["AB"].erase(PatientMap["AB"].begin() + 0);

                                            }


                                    }
                                     if(((PatientMap["AB"][0] - StorageMap["O"]) >= 0) && (SumTwo(SolMap)!=konst))
                                                    {
                                                        SolMap["O"] = StorageMap["O"];
                                                        PatientMap["AB"][0] -= SolMap["O"];
                                                        StorageMap["O"] -= SolMap["O"];
                                                        if(PatientMap["AB"][0] == 0)
                                                        {
                                                            PatientMap["AB"].erase(PatientMap["AB"].begin() + 0);

                                                        }
                                                    }


                                    if(((PatientMap["AB"][0] - StorageMap["B"]) >= 0) && (SumTwo(SolMap)!=konst)) //Check if B is available if AB isn't
                                        {
                                            SolMap["B"] = StorageMap["B"];
                                            PatientMap["AB"][0] -= SolMap["B"];
                                            StorageMap["B"] -= SolMap["B"];
                                            if(PatientMap["AB"][0] == 0)
                                            {
                                                PatientMap["AB"].erase(PatientMap["AB"].begin() + 0);

                                            }



                                        }
                                        if(((PatientMap["AB"][0] - StorageMap["A"]) >= 0) && (SumTwo(SolMap)!=konst)) //Check if A is available if AB isn't
                                                {
                                                    SolMap["A"] = StorageMap["A"];
                                                    PatientMap["AB"][0] -= SolMap["A"];
                                                    StorageMap["A"] -= SolMap["A"];
                                                    if(PatientMap["AB"][0] == 0)
                                                    {
                                                        PatientMap["AB"].erase(PatientMap["AB"].begin() + 0);

                                                    }
                                                }




                            }

                        else if(StorageMap[a] >= Sum(PatientMap[a]))
                        {
                            SolMap[a] = PatientMap[a][0];
                            PatientMap[a].erase(PatientMap[a].begin() + 0);
                            StorageMap[a] -= SolMap[a];
                            if(SolMap[a] < Sum(PatientMap[a]))
                            {
                                if((StorageMap["O"] - PatientMap["O"][0])> 0)
                                {
                                    SolMap["O"] = StorageMap["O"] - PatientMap["O"][0];
                                    PatientMap["O"].erase(PatientMap["O"].begin() + 0);
                                    StorageMap["O"] -= SolMap["O"];
                                }


                            }
                        }
                        else
                        {
                            SolMap["O"] = PatientMap[a][0];
                            PatientMap[a].erase(PatientMap[a].begin() + 0);
                            StorageMap["O"] -= SolMap["O"];
                        }
                        for(auto it : SolMap)
                        {
                            cout << it.second << " ";
                        }

                        cout << "\n";
                        SolMap["O"] = 0;
                        SolMap["A"] = 0;
                        SolMap["B"] = 0;
                        SolMap["AB"] = 0;
                    }
                }


    return 0;
}