#include <bits/stdc++.h>

using namespace std;
using ll = long long;

const int N = 1050;
const int M = 1e5 + 50;
const ll inf = 1e18;

int n, m, s, t;

struct flow_t {
	int n, m, s, t;
	int gap[N], head[N], cur[N], tot;
	ll preflow, precost, d[N], h[N];
	bool ins[N];
	struct edge_t {
		int to, nxt;
		ll w, c;
		edge_t() : to(0), nxt(0), w(0), c(0) {}
		edge_t(int to, int nxt, ll w, ll c) : to(to), nxt(nxt), w(w), c(c) {}
	} e[M];
	void init() {
		memset(head, 0, sizeof head);
		tot = 1;
		preflow = precost = 0;
	}
	flow_t() {
		init();
	}
	void add(int u, int v, ll w, ll c) {
		e[++tot] = edge_t(v, head[u], w, c); head[u] = tot;
		e[++tot] = edge_t(u, head[v], 0, -c); head[v] = tot;
	}
	void add(int u, int v, ll wl, ll wr, ll c) {
		if (c > 0) {
			gap[u] -= wl, gap[v] += wl;
			precost += wl * c;
			add(u, v, wr - wl, c);
		}
		else {
			gap[u] -= wr, gap[v] += wr;
			precost += wr * c;
			add(v, u, wr - wl, -c);
		}
	}
	void build() {
		for (int i = 1; i <= n; ++i) if (i != s && i != t) {
			if (gap[i] > 0) {
				add(s, i, gap[i], 0);
				preflow += gap[i];
			}
			else {
				add(i, t, -gap[i], 0);
			}
		}
	}
	bool spfa() {
		fill(d, d + n + 1, inf);
		fill(h, h + n + 1, 0);
		queue<int> que;
		que.emplace(s);
		d[s] = 0; ins[s] = true;
		while (!que.empty()) {
			int x = que.front(); que.pop();
			ins[x] = false;
			for (int i = head[x]; i; i = e[i].nxt) {
				int y = e[i].to;
				ll w = e[i].w, c = e[i].c;
				if (w && d[y] > d[x] + c) {
					d[y] = d[x] + c;
					if (!ins[y]) {
						ins[y] = true;
						que.emplace(y);
					}
				}
			}
		}
		return d[t] < inf;
	}
	bool dijkstra() {
		fill(d, d + n + 1, inf);
		memcpy(cur, head, sizeof head);
		priority_queue<pair<ll, int>> que;
		d[s] = 0;
		que.emplace(-d[s], s);
		while (!que.empty()) {
			auto [_d, x] = que.top(); que.pop();
			if (-d[x] != _d) continue;
			for (int i = head[x]; i; i = e[i].nxt) {
				int y = e[i].to; ll w = e[i].w, c = e[i].c + h[x] - h[y];
				if (w && d[y] > d[x] + c) {
					d[y] = d[x] + c;
					que.emplace(-d[y], y);
				}
			}
		}
		return d[t] < inf;
	}
	ll go(int x, ll flow) {
		if (x == t) return flow;
		ll rest = flow;
		ins[x] = true;
		for (int &i = cur[x]; i; i = e[i].nxt) {
			int y = e[i].to; ll w = e[i].w, c = e[i].c + h[x] - h[y];
			if (w && d[y] == d[x] + c && !ins[y]) {
				ll k = go(y, min(w, rest));
				e[i].w -= k;
				e[i ^ 1].w += k;
				rest -= k;
				if (!rest) break;
			}
		}
		ins[x] = false;
		return flow - rest;
	}
	void update() {
		for (int i = 1; i <= n; ++i)
			if (d[i] < inf)
				h[i] += d[i];
	}
	pair<ll, ll> solve() {
		if (!spfa()) return make_pair(0, 0);
		update();
		ll mincost = 0;
		ll maxflow = 0;
		while (dijkstra()) {
			ll f = go(s, inf);
			assert(f > 0);
			update();
			maxflow += f;
			mincost += h[t] * f;
		}
		return make_pair(maxflow, mincost);
	}
} G;

int main() {
	cin >> n >> m >> s >> t;
	G.n = n + 2;
	G.s = n + 1;
	G.t = G.s + 1;
	for (int i = 1; i <= m; ++i) {
		int x, y, wl, wr, c;
		cin >> x >> y >> wl >> wr >> c;
		G.add(x, y, wl, wr, c);
	}
	G.build();
	G.add(t, s, inf, 0);
	auto p = G.solve();
	if (p.first != G.preflow) {
		cout << -1 << '\n';
		return 0;
	}
	G.n -= 2;
	ll base = G.e[G.tot].w;
	for (int i = G.tot - 1; i <= G.tot; ++i)
		G.e[i].w = 0;
	G.s = s, G.t = t;
	auto q = G.solve();
	cout << q.first + base << ' ' << p.second + q.second + G.precost<< '\n';
}