#include <stdio.h>
#include <string.h>
#include <algorithm>
#define getchar getchar_unlocked
#define putchar putchar_unlocked
typedef long long i64;
i64 rd()
{
	i64 k = 0, f = 1;
	char s = getchar();
	while (s < '0' || s > '9')
	{
		if (s == '-')
			f = 0;
		s = getchar();
	}
	while (s >= '0' && s <= '9')
	{
		k = (k << 1) + (k << 3) + (s ^ '0');
		s = getchar();
	}
	return f ? k : -k;
}
void wr(i64 x)
{
	if (x < 0)
		putchar('-'), x = -x;
	if (x > 9)
		wr(x / 10);
	putchar((x % 10) ^ '0');
}
// 1-indexed
namespace MCMF
{
	using cap = i64;

	const int N = 505;
	const int M = 15005;

	const i64 flow_INF = 1145141919810114514ll;
	const i64 cost_offset = 1145141919;

	int n, m, s, t;

	struct edge
	{
		int to, nxt;
		cap flow, cost;
	} e[M << 1];
	int cnt;
	int h[N];
	void init_sz(int _n) { n = _n, m = 0, cnt = 1; }
	int add_edge(int u, int v, cap flow, cap cost, bool directed = true)
	{
		++m;
		e[++cnt].to = v, e[cnt].nxt = h[u], e[cnt].flow = flow, e[cnt].cost = cost;
		h[u] = cnt;
		e[++cnt].to = u, e[cnt].nxt = h[v], e[cnt].flow = directed ? 0 : flow, e[cnt].cost = -cost;
		h[v] = cnt;
		return cnt;
	}
	int tme;
	int vis[N], fa[N], fae[N];
	void dfs(int u)
	{
		vis[u] = 1;
		for (int i = h[u], v; i; i = e[i].nxt)
			if (!vis[v = e[i].to] && e[i].flow)
				fa[v] = u, fae[v] = i, dfs(v);
	}

	int pi[N];
	int phi(int x)
	{
		if (vis[x] == tme)
			return pi[x];
		vis[x] = tme;
		return pi[x] = phi(fa[x]) - e[fae[x]].cost;
	}


	int cyc[N];

	i64 cost;

	void clr()
	{
		memset(h, 0, sizeof(h));
		tme = 0;
		memset(vis, 0, sizeof(vis)), memset(fa, 0, sizeof(fa)), memset(fae, 0, sizeof(fae));
		memset(pi, 0, sizeof(pi)), memset(cyc, 0, sizeof(cyc));
	}

	void pushflow(int id)
	{
		int pen = e[id ^ 1].to, lca = e[id].to;
		++tme;

		while (pen)
			vis[pen] = tme, pen = fa[pen];

		while (vis[lca] != tme)
			vis[lca] = tme, lca = fa[lca];

		int e2 = 0, f = e[id].flow, path = 2, clen = 0;

		for (int i = e[id ^ 1].to; i != lca; i = fa[i])
		{
			cyc[++clen] = fae[i];
			if (e[fae[i]].flow < f)
				f = e[fae[e2 = i] ^ (path = 0)].flow;
		}

		for (int i = e[id].to; i != lca; i = fa[i])
		{
			cyc[++clen] = fae[i] ^ 1;
			if (e[fae[i] ^ 1].flow < f)
				f = e[fae[e2 = i] ^ (path = 1)].flow;
		}

		cyc[++clen] = id;

		for (int i = 1; i <= clen; ++i)
		{
			e[cyc[i]].flow -= f, e[cyc[i] ^ 1].flow += f;
			cost += 1ll * f * e[cyc[i]].cost;
		}

		if (path == 2)
			return;

		int lste = id ^ path, lst = e[lste].to, now = e[lste ^ 1].to;

		while (lst != e2)
		{
			vis[now]--, lste ^= 1;
			std::swap(lste, fae[now]);
			std::swap(lst, fa[now]);
			std::swap(lst, now);
		}
	}

	std::pair<cap, cap> solve(int _s, int _t)
	{
		s = _s, t = _t;
		int lhead = h[s], rhead = h[t];
		add_edge(t, s, flow_INF, -cost_offset);
		dfs(t);
		vis[t] = tme = 2, fa[t] = cost = 0;

		for (int i = 2, pre = cnt; i != pre; i = (i == cnt ? 2 : i + 1))
			if (e[i].flow && e[i].cost < phi(e[i ^ 1].to) - phi(e[i].to))
				pushflow(pre = i);

		h[s] = lhead, h[t] = rhead;
		cnt -= 2; // extra operation if calculate minimum flow or other.
		return std::make_pair(e[cnt + 2].flow, cost + 1ll * e[cnt + 2].flow * cost_offset);
	}
}
int main()
{
	int n = rd(), m = rd(), s = rd(), t = rd();
	MCMF::init_sz(n);
	while (m--)
	{
		int u = rd(), v = rd(), flow = rd(), cost = rd();
		MCMF::add_edge(u, v, flow, cost);
	}
	std::pair<i64, i64> ans = MCMF::solve(s, t);
	wr(ans.first), putchar(' '), wr(ans.second);
}