#include <bits/stdc++.h>

using namespace std;

#define INFTY 100000000

struct Graph{
	vector<vector<int>> graph;
	
	int size(){
		return graph.size();
	}
	
	void print(){
		for(const auto& value: graph){
			for(const auto& i: value){
				cout<<i<<" ";
			}
		cout<<endl;
		}
	return;
	}
	
};

void print(vector<pair<int,int>> D){
	for(const auto& value: D){
		cout<<"["<<value.first<<", "<<value.second<<"], ";
	}
	cout<<endl;
}

//Znalezienie ścieżek z użyciem algorytmu BFS
vector<pair<int,int>> bfs(Graph &C, Graph &F, int s,int t){
	int n = C.size();
	queue<int> kolejka = queue<int>();
	kolejka.push(s);
	vector<vector<pair<int,int>>> sciezki = vector<vector<pair<int,int>>>(n,vector<pair<int,int>>());
	if(s == t){
		return sciezki[s];
	}
	else{
		while(not kolejka.empty()){ 
			int u = kolejka.front();
			kolejka.pop();
			for(int v=1; v<n;v++){
					if(C.graph[u][v]-F.graph[u][v]>0 and sciezki[v].size()==0){
						sciezki[v] = sciezki[u];
						sciezki[v].push_back(make_pair(u,v));
						/*
						for(const auto& value: sciezki){
							print(value);
						}
						*/
						if(v == t){
							return sciezki[v];
						}
						kolejka.push(v);
					}
				}
			}
	}
	return vector<pair<int,int>>();
}

int minuv(Graph &C, Graph& F, vector<pair<int,int>> P){
	int X = INFTY;
	for(const auto& value: P){
		X = min(X, C.graph[value.first][value.second] - F.graph[value.first][value.second]);
	}
	return X;
}

//Algorytm Forda-Fulkersona w wersji Edmondsa-Karpa
int Edmonds_Karp(Graph &C, int s, Graph &F){
        int n = C.size();
        int t = n-1;
        vector<pair<int,int>> sciezka = bfs(C, F, s, t);
        while(sciezka.size()>0){
//			cout<<"Found\n";
            int przeplyw = minuv(C,F,sciezka);
			for(const auto& value: sciezka){
				F.graph[value.first][value.second] += przeplyw;
				F.graph[value.second][value.first] -= przeplyw;
			}
            sciezka = bfs(C, F, s, t);
		}
		int X = 0;
		for(int i = 0; i <n; i++){
			X+=F.graph[0][i];
		}
		
	return X;
}
  
Graph read_graph(int n,int m,int s){
    Graph C = Graph();
	C.graph = vector<vector<int>>(n+1,vector<int>(n+1));
	int x,y,z;
    for(int i = 1; i<m; i++){
		cin>>x>>y>>z;
        C.graph[x][y] = z;
	}
    for(int i = 1; i<s+1; i++){
        C.graph[0][i] = INFTY; 
	}
    return C;
	}

int main(){
    int n,m,s;
    cin >> n >> m >> s;
	//Wczytujemy graf do postaci macierzowej

    Graph C = read_graph(n,m,s);

	Graph F = Graph();
	F.graph = vector<vector<int>>(n+1,vector<int>(n+1));
	//Wczytujemy interesującą nas krawędź:
	int x,y;
	cin>>x>>y;
	
	//Jeżeli możemy zwiększać w nieskończoność krawędź łączącą któreś ze źródeł z wyjściem
	//to mamy problem...
	if(x<=s and y == n){
		cout<<"BAJTRYK ZWYCIEZYL HAHAHAHA\n";
		return 0;
	}
	//obliczamy max_flow bez brakującej krawędzi
	int initial_flow = Edmonds_Karp(C,0,F);
	//obliczamy max_flow z brakującą krawędzią (pozwalamy jej na dowolnie duży przepływ)
	C.graph[x][y] = INFTY;
	int after_flow = Edmonds_Karp(C, 0, F);

	if(F.graph[x][y] != after_flow-initial_flow){
		cout<<"MAMY PROBLEM\n";
	}
	cout<<initial_flow<<' '<<after_flow-initial_flow<<'\n';
    return 0;
}
