//https://onlinejudge.org/external/130/13015.pdf
//13015

#include<cstdio>
#include<iostream>
#include<vector>
#include<queue>
#include<set>

using namespace std;

int bfs(vector<pair<set<int>, vector<int>>>graph, vector<int>&roots, vector<int>visits, int ttl, set<int>&conj){ //pasamos una copia del grafo, y estructura de visitados, ya que los modificamos y no hacemos llamados recursivos 

    int i, ans = 0, node, auxNode, size = 0;
    queue<int>q;

    for(i = 0; i<roots.size(); i++){ //identificamos los nodos raiz
        
        if(roots[i] == 0){

            q.push(i);
            ans+=1;
            visits[i] = true;
            conj.insert(i);
        }
    }  

    if(ans > ttl){
        
        return  0;//no es posible desde el primer nivel
    }
    
    q.push(-1); //level

    while(!q.empty()){

        node = q.front();

        q.pop();

        if(node == -1){ //cada vez que encontramos un nuevo nivel, evaluamos si la cantidad de empleados ascendidos es menor o igual al limite
            
            if(ans+size > ttl){
                
                return ans; //si no es posible retornamos lo calculado en los anteriores niveles 
            }

            else if(!q.empty()){//evaluamos si aun se puede seguir, o hay otro nivel y aun hay empleados por ascender

                q.push(-1);
                ans+=size;
                size = 0;
            }
        }

        else{
        
            for(i = 0; i<graph[node].second.size(); i++){

                auxNode = graph[node].second[i];

                if(visits[auxNode] == false){

                    if(graph[auxNode].first.size() == 1){//evaluamos si tiene un solo predecesor

                        visits[auxNode] = true;
                        size++;
                        q.push(auxNode);
                        
                        if(ans + size <= ttl){//evaluamos si es imposible llegar a ese nodo

                            conj.insert(auxNode);

                        }
                    }

                    graph[auxNode].first.erase(node);//al llevar desde un predecesor, lo elimnamos, hasta que solo dependa de 1

                }
            }
        }
    }

    return ans;
}

int main(){

    int A, B, employees, precedence, employe1, employe2, ans, i;

    while(scanf("%i %i %i %i", &A, &B, &employees, &precedence) != EOF){
        
        set<int>conj;
        vector<pair<set<int>, vector<int>>>graph(employees);
        vector<int>roots(employees, 0);
        vector<int>visits(employees, false);

        while(precedence--){

            scanf("%i %i", &employe1, &employe2);

            graph[employe2].first.insert(employe1);//guardamos los predecesores
            graph[employe1].second.push_back(employe2);
            roots[employe2] = -1; //cambiamos el estado a -1, ya que al ser un nodo que se puede visitar, no es una raiz
        }

        cout<<bfs(graph, roots, visits, A, conj)<<endl;
        cout<<bfs(graph, roots, visits, B, conj)<<endl;
        cout<<employees-conj.size()<<endl;
    }

    return 0;
}