#include<cstdio>
#include<vector>
#include<queue>
#include<algorithm>

using namespace std;

int cap[1010][1010];
int flow[1010][1010];

bool used[1010];
vector<int> G[1010];
int N;

int dfs(int v,int t,int f){
//	printf("%d %d %d\n",v,t,f);
	if(v==t) return f;
	used[v]=true;
	for(int i=0;i<G[v].size();i++){
		int u=G[v][i];
		if(used[u]) continue;
		int x=(cap[v][u]-flow[v][u])+flow[u][v];
		int nf=min(f,x);
		if(nf==0) continue;
		int ret=dfs(u,t,nf);
		if(ret>0){
			int tmp=cap[v][u]-flow[v][u];
			if(ret<=tmp){
				flow[v][u]+=ret;
			}else{
				flow[v][u]=cap[v][u];
				flow[u][v]-=(ret-tmp);
			}
			return ret;
		}
	}
	return 0;
}

bool can_reach[2][1010];

queue<int> que;
void bfs(int s,bool *res,bool rev){
	while(!que.empty()) que.pop();
	for(int i=0;i<1010;i++) res[i]=false;
	que.push(s);
	res[s]=true;
	while(!que.empty()){
		int v=que.front();
		que.pop();
		for(int i=0;i<G[v].size();i++){
			int u=G[v][i];
			if(res[u]) continue;
			if(!rev){
				int x=(cap[v][u]-flow[v][u])+flow[u][v];
				if(x<=0) continue;
			}else{
				int x=(cap[u][v]-flow[u][v])+flow[v][u];
				if(x<=0) continue;
			}
			res[u]=true;
			que.push(u);
		}
	}
}

int maxFlow(int s,int t){
	int res=0;
	while(true){
		for(int i=0;i<1010;i++) used[i]=false;
		int f=dfs(s,t,100100);
		if(f==0) return res;
		res+=f;
	}
	return -1;
}

int S,T;

int count(){
	bfs(S,can_reach[0],false);
	bfs(T,can_reach[1],true);
	int res=0;
	for(int i=0;i<N;i++) for(int j=0;j<N;j++){
		if(i==j) continue;
		if(can_reach[0][i]&&can_reach[1][j]){
			res+=cap[j][i];
		}
	}
	if(res>0) return res;
	else return -1;
}

void solve(){
	int flow=maxFlow(S,T);
	int num=count();
	if(num>0){
		printf("%d %d\n",flow+1,num);
	}else{
		printf("%d %d\n",flow,0);
	}
}

void init(){
	for(int i=0;i<N;i++) for(int j=0;j<N;j++){
		cap[i][j]=0;
		flow[i][j]=0;
	}
	for(int i=0;i<N;i++){
		G[i].clear();
	}
}

void input(){
	init();
	int M;
	scanf("%d%d",&N,&M);
	scanf("%d%d",&S,&T);
	if(S==0&&T==0) exit(0);
	S--;T--;
	for(int i=0;i<M;i++){
		int u,v;
		scanf("%d%d",&u,&v);
		u--;v--;
		G[u].push_back(v);
		G[v].push_back(u);
		cap[u][v]++;
	}
}

int main(){
	while(true){
		input();
		solve();
	}
	return 0;
}