#include <iostream>
//#include <fstream>
//#include <iomanip>
//#include <cmath>
//#include <algorithm>
//#include <string>
#include <vector>
//#include <utility>
//#include <map>
//#include <ctime>
//#include <cctype>
//#include <cstdlib>
//#include <limits>
//#include <numeric>
//#include <mycpp.h>

using namespace std;

struct Pacijent
{
	int potrebno;
	int O, A, B, AB;	
};

typedef vector<Pacijent*> vp;

vp pacijenti;
vp Op, Ap, Bp, ABp;
int O, A, B, AB;


Pacijent* UnosPacijenta();
bool Rasporedi();

int main()
{
	std::ios_base::sync_with_stdio(false);
	int n;
	cin >> n;
	cin >> O >> A >> B >> AB;
	for(int i = 0; i < n; i++)
	{
		string grupa;
		cin >> grupa;
		Pacijent* noviPacijent = UnosPacijenta();
		pacijenti.push_back(noviPacijent);
		if(grupa == "O")
			Op.push_back(noviPacijent);
		else if(grupa == "A")
			Ap.push_back(noviPacijent);
		else if(grupa == "B")
			Bp.push_back(noviPacijent);
		else
			ABp.push_back(noviPacijent);
	}
	bool moguce = Rasporedi();
	if(moguce)
	{
		cout << "moguce" << endl;
		for(int i = 0; i < pacijenti.size(); i++)
		{
			cout << pacijenti[i]->O << " "
				 << pacijenti[i]->A << " "
				 << pacijenti[i]->B << " "
				 << pacijenti[i]->AB << endl;
		}
	}
	else
		cout << "nemoguce" << endl;
}

Pacijent* UnosPacijenta()
{
	Pacijent* p = new Pacijent;
	cin >> p->potrebno;
	p->O = 0;
	p->A = 0;
	p->B = 0;
	p->AB = 0;
	return p;
}

bool Rasporedi()
{
	// O
	for(int i = 0; i < Op.size(); i++)
	{
		if(O <= 0) return false;
		if(O < Op[i]->potrebno) return false;
		Op[i]->O = Op[i]->potrebno;
		O -= Op[i]->potrebno;
	}
	// A
	for(int i = 0; i < Ap.size(); i++)
	{
		if(Ap[i]->potrebno > 0 && A > 0)
		{
			if(Ap[i]->potrebno > A)
			{
				Ap[i]->A += A;
				Ap[i]->potrebno -= A;
				A -= Ap[i]->A;
			}
			else
			{
				Ap[i]->A += Ap[i]->potrebno;
				A -= Ap[i]->potrebno;
				Ap[i]->potrebno = 0;
			}
		}
		// O 
		if(Ap[i]->potrebno > 0 && O > 0)
		{
			if(Ap[i]->potrebno > O)
			{
				Ap[i]->O += O;
				Ap[i]->potrebno -= O;
				O -= Ap[i]->O;
			}
			else
			{
				Ap[i]->O += Ap[i]->potrebno;
				O -= Ap[i]->potrebno;
				Ap[i]->potrebno = 0;
			}
		}		
		if(Ap[i]->potrebno > 0) return false;
	}
	// B
	for(int i = 0; i < Bp.size(); i++)
	{
		//B 
		if(Bp[i]->potrebno > 0 && B > 0)
		{
			if(Bp[i]->potrebno > B)
			{
				Bp[i]->B += B;
				Bp[i]->potrebno -= B;
				B -= Bp[i]->B;
			}
			else
			{
				Bp[i]->B += Bp[i]->potrebno;
				B -= Bp[i]->potrebno;
				Bp[i]->potrebno = 0;
			}
		}
		// O
		if(Bp[i]->potrebno > 0 && O > 0)
		{
			if(Bp[i]->potrebno > O)
			{
				Bp[i]->O += O;
				Bp[i]->potrebno -= O;
				O -= Bp[i]->O;
			}
			else
			{
				Bp[i]->O += Bp[i]->potrebno;
				O -= Bp[i]->potrebno;
				Bp[i]->potrebno = 0;
			}
		}
		if(Bp[i]->potrebno > 0) return false;
	}
	// AB
	for(int i = 0; i < ABp.size(); i++)
	{
		// AB
		if(ABp[i]->potrebno > 0 && AB > 0)
		{
			if(ABp[i]->potrebno > AB)
			{
				ABp[i]->AB += AB;
				ABp[i]->potrebno -= AB;
				AB -= ABp[i]->AB;
			}
			else
			{
				ABp[i]->AB += ABp[i]->potrebno;
				AB -= ABp[i]->potrebno;
				ABp[i]->potrebno = 0;
			}
		}
		// A
		if(ABp[i]->potrebno > 0 && A > 0)
		{
			if(ABp[i]->potrebno > A)
			{
				ABp[i]->A += A;
				ABp[i]->potrebno -= A;
				A -= ABp[i]->A;
			}
			else
			{
				ABp[i]->A += ABp[i]->potrebno;
				A -= ABp[i]->potrebno;
				ABp[i]->potrebno = 0;
			}
		}
		// B
		if(ABp[i]->potrebno > 0 && B > 0)
		{
			if(ABp[i]->potrebno > B)
			{
				ABp[i]->B += B;
				ABp[i]->potrebno -= B;
				B -= ABp[i]->B;
			}
			else
			{
				ABp[i]->B += ABp[i]->potrebno;
				B -= ABp[i]->potrebno;
				ABp[i]->potrebno = 0;
			}
		}
		// O
		if(ABp[i]->potrebno > 0 && O > 0)
		{
			if(ABp[i]->potrebno > O)
			{
				ABp[i]->O += O;
				ABp[i]->potrebno -= O;
				O -= ABp[i]->O;
			}
			else
			{
				ABp[i]->O += ABp[i]->potrebno;
				O -= ABp[i]->potrebno;
				ABp[i]->potrebno = 0;
			}
		}
		if(ABp[i]->potrebno > 0) return false;
	}
	return true;
}