#include <stdio.h>
#include <vector>
#include <map>

inline void fastRead_int(int *a) {
	register int c=getchar_unlocked();
	int neg=0;
	for(;(c<48 || c>57) && c != '-';c = getchar_unlocked());
	*a=0;
	if(c=='-') {neg=1;c=getchar_unlocked();}
	for(;c>47 && c<58;c = getchar_unlocked()) {*a=(*a<<1) + (*a<<3) + c - 48;}
	if(neg) *a=-(*a);
}

class Kandydat
{
    public:
        int id;
        int koszt_kampanii_A;
        int koszt_kampanii_B;
  
        Kandydat(int idKandydata)
        {
            id = idKandydata;
            koszt_kampanii_A = 0;
            koszt_kampanii_B = 0;
        }
};

class Miasto
{
    public:
        int id;
        Kandydat* zwyciezca_wyborow_A;
        Kandydat* zwyciezca_wyborow_B;
        std::vector<Miasto*> sasiedzi;
  
        Miasto(int id_miasta)
        {
            id = id_miasta;
            zwyciezca_wyborow_A = NULL;
            zwyciezca_wyborow_B = NULL;
        }
};

class PrzyszliZwyciezcy
{
	public:
        Kandydat* zwyciezca_wyborow_A;
        Kandydat* zwyciezca_wyborow_B;
};


int main()
{ 
    int ilosc_miast;
    int ilosc_kandydatow;
    int miasto_pierwsze;
    int miasto_drugie;
    fastRead_int(&ilosc_miast);
    Miasto* tablica_miast[ilosc_miast];
    for(int id_miasta = 0; id_miasta < ilosc_miast; id_miasta++)
    {
        tablica_miast[id_miasta] = new Miasto(id_miasta);
    }
    fastRead_int(&miasto_pierwsze);
    fastRead_int(&miasto_drugie);
    while(miasto_pierwsze != -1)
    {
        tablica_miast[miasto_pierwsze]->sasiedzi.push_back(tablica_miast[miasto_drugie]);
        tablica_miast[miasto_drugie]->sasiedzi.push_back(tablica_miast[miasto_pierwsze]);
        fastRead_int(&miasto_pierwsze);
        fastRead_int(&miasto_drugie);
    }
    fastRead_int(&ilosc_kandydatow);
    Kandydat* tablica_kandydatow[ilosc_kandydatow];

	std::map<Miasto*, Miasto*>* miasta_nastepna_tura = new std::map<Miasto*, Miasto*>();
    int startowe_miasto_kandydata;
    for(int id_kandydata = 0; id_kandydata < ilosc_kandydatow; id_kandydata++)
    {
        fastRead_int(&startowe_miasto_kandydata);

		for(std::vector<Miasto*>::iterator iterator_miasto = tablica_miast[startowe_miasto_kandydata]->sasiedzi.begin() ; iterator_miasto != tablica_miast[startowe_miasto_kandydata]->sasiedzi.end(); iterator_miasto++)
		{
			(*miasta_nastepna_tura)[*iterator_miasto] = *iterator_miasto;
		}

        tablica_kandydatow[id_kandydata] = new Kandydat(id_kandydata);
        tablica_miast[startowe_miasto_kandydata]->zwyciezca_wyborow_A = tablica_kandydatow[id_kandydata];
        tablica_kandydatow[id_kandydata]->koszt_kampanii_A++;

        tablica_miast[startowe_miasto_kandydata]->zwyciezca_wyborow_B = tablica_kandydatow[id_kandydata];
        tablica_kandydatow[id_kandydata]->koszt_kampanii_B++;
    }

	std::map<Miasto*, Miasto*>* miasta_aktualna_tura = new std::map<Miasto*, Miasto*>();
	std::map<Miasto*, PrzyszliZwyciezcy*> zwyciezcy_po_aktualnej_rundzie;
	std::map<Kandydat*, int> komitety_sasiedzkie_kandydaci_A;
	std::map<Kandydat*, int> komitety_sasiedzkie_kandydaci_B;
	while(!miasta_nastepna_tura->empty())
	{
		delete miasta_aktualna_tura;
		miasta_aktualna_tura = miasta_nastepna_tura;
		miasta_nastepna_tura = new std::map<Miasto*, Miasto*>();
		Miasto* aktualne_miasto;
		// przeprowadzenie jednej tury glosowan - w sasiedzkich miastach
		for(std::map<Miasto*, Miasto*>::iterator iterator_aktualne_miasto = miasta_aktualna_tura->begin(); iterator_aktualne_miasto != miasta_aktualna_tura->end(); iterator_aktualne_miasto++)
		{
			aktualne_miasto = iterator_aktualne_miasto->first;
			// po zaladowaniu kandydatow w mapie moga byc miasta w ktorych juz zostali wybrani zwyciezcy (miasta startowe)
			if(aktualne_miasto->zwyciezca_wyborow_A == NULL)
			{
				komitety_sasiedzkie_kandydaci_A.clear();
				komitety_sasiedzkie_kandydaci_B.clear();

				Miasto* aktualny_sasiad;
				for(std::vector<Miasto*>::iterator iterator_miasto_sasiedzkie = aktualne_miasto->sasiedzi.begin() ; iterator_miasto_sasiedzkie != aktualne_miasto->sasiedzi.end(); iterator_miasto_sasiedzkie++)
				{
					aktualny_sasiad = *iterator_miasto_sasiedzkie;

					// w sasiednim miescie jest wybrany zwyciezca
					if(aktualny_sasiad->zwyciezca_wyborow_A)
					{
						// dodaj glos oddany na kandydata z sasiedzkiego miasta
						komitety_sasiedzkie_kandydaci_A[aktualny_sasiad->zwyciezca_wyborow_A]++;
						komitety_sasiedzkie_kandydaci_B[aktualny_sasiad->zwyciezca_wyborow_B]++;
					}
					else
					{
						// przeprowadz w sasiedzkim miescie glosowanie w nastepnej rundzie
						(*miasta_nastepna_tura)[aktualny_sasiad] = aktualny_sasiad;
					}
				}
				
				PrzyszliZwyciezcy* zwyciezcy_w_miescie = new PrzyszliZwyciezcy();
				
				int ilosc_glosow_zwyciezajacego_kandydata = 1000000;
				Kandydat* zwyciezajacy_kandydat;
				for(std::map<Kandydat*, int>::iterator iterator_komitety_sasiedzkie_kandydata_A = komitety_sasiedzkie_kandydaci_A.begin(); iterator_komitety_sasiedzkie_kandydata_A != komitety_sasiedzkie_kandydaci_A.end(); iterator_komitety_sasiedzkie_kandydata_A++)
				{
					if(iterator_komitety_sasiedzkie_kandydata_A->second < ilosc_glosow_zwyciezajacego_kandydata || 
						(iterator_komitety_sasiedzkie_kandydata_A->second == ilosc_glosow_zwyciezajacego_kandydata && iterator_komitety_sasiedzkie_kandydata_A->first->id > zwyciezajacy_kandydat->id))
					{
						zwyciezajacy_kandydat = iterator_komitety_sasiedzkie_kandydata_A->first;
						ilosc_glosow_zwyciezajacego_kandydata = iterator_komitety_sasiedzkie_kandydata_A->second;
					}
				}
				zwyciezcy_w_miescie->zwyciezca_wyborow_A = zwyciezajacy_kandydat;
				zwyciezajacy_kandydat->koszt_kampanii_A++;
				
				ilosc_glosow_zwyciezajacego_kandydata = 0;
				for(std::map<Kandydat*, int>::iterator iterator_komitety_sasiedzkie_kandydata_B = komitety_sasiedzkie_kandydaci_B.begin(); iterator_komitety_sasiedzkie_kandydata_B != komitety_sasiedzkie_kandydaci_B.end(); iterator_komitety_sasiedzkie_kandydata_B++)
				{
					if(iterator_komitety_sasiedzkie_kandydata_B->second > ilosc_glosow_zwyciezajacego_kandydata || 
						(iterator_komitety_sasiedzkie_kandydata_B->second == ilosc_glosow_zwyciezajacego_kandydata && iterator_komitety_sasiedzkie_kandydata_B->first->id < zwyciezajacy_kandydat->id))
					{
						zwyciezajacy_kandydat = iterator_komitety_sasiedzkie_kandydata_B->first;
						ilosc_glosow_zwyciezajacego_kandydata = iterator_komitety_sasiedzkie_kandydata_B->second;
					}
				}
				zwyciezcy_w_miescie->zwyciezca_wyborow_B = zwyciezajacy_kandydat;
				zwyciezajacy_kandydat->koszt_kampanii_B++;
				
				zwyciezcy_po_aktualnej_rundzie[aktualne_miasto] = zwyciezcy_w_miescie;
			}
		}

		// zapisanie zwyciezcow danej rundy w miastach
		for(std::map<Miasto*, PrzyszliZwyciezcy*>::iterator iterator_zwyciezcy_tej_rundy = zwyciezcy_po_aktualnej_rundzie.begin(); iterator_zwyciezcy_tej_rundy != zwyciezcy_po_aktualnej_rundzie.end(); iterator_zwyciezcy_tej_rundy++)
		{
			iterator_zwyciezcy_tej_rundy->first->zwyciezca_wyborow_A = iterator_zwyciezcy_tej_rundy->second->zwyciezca_wyborow_A;
			iterator_zwyciezcy_tej_rundy->first->zwyciezca_wyborow_B = iterator_zwyciezcy_tej_rundy->second->zwyciezca_wyborow_B;
		}
	}
    for(int id_kandydata = 0; id_kandydata < ilosc_kandydatow; id_kandydata++)
    {
        printf("%d %d\n", tablica_kandydatow[id_kandydata]->koszt_kampanii_A, tablica_kandydatow[id_kandydata]->koszt_kampanii_B);
    }
    return 0;
}