#include <stdio.h>
#include <string.h>
#include <algorithm>

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 = 1205;
	const int M = 120005;

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

	int n, m, s, t;

	struct edge
	{
		int from, to, nxt;
		cap flow, cost;
		bool origin;
	} e[M << 1];
	int cnt;
	int h[N];

	int add_edge(int u, int v, cap flow, cap cost, bool directed = true)
	{
		++m;
		e[++cnt].from = u, e[cnt].to = v, e[cnt].nxt = h[u], e[cnt].flow = flow, e[cnt].cost = cost, e[cnt].origin = 1;
		h[u] = cnt;
		e[++cnt].from = v, e[cnt].to = u, e[cnt].nxt = h[v], e[cnt].flow = directed ? 0 : flow, e[cnt].cost = -cost, e[cnt].origin = 0;
		h[v] = cnt;
		return cnt;
	}
	int tme;
	int vis[N], fa[N], fe[N], circle[N], mark[N];
	cap pi[N];

	void dfs(int u, int fi)
	{
		fa[u] = e[fi].from, fe[u] = fi;
		mark[u] = 1;
		for (int i = h[u]; i; i = e[i].nxt)
		{
			int v = e[i].to;
			if (e[i].origin && !mark[v])
				dfs(v, i);
		}
	}

	cap phi(int u)
	{
		if (mark[u] == tme)
			return pi[u];
		mark[u] = tme, pi[u] = phi(fa[u]) + e[fe[u]].cost;
		return pi[u];
	}

	cap pushflow(int eg)
	{
		int rt = e[eg].from, lca = e[eg].to;
		++tme;
		int circle_cnt = 0;
		while (rt)
			mark[rt] = tme, rt = fa[rt];
		while (mark[lca] ^ tme)
			mark[lca] = tme, lca = fa[lca];
		cap minflow = e[eg].flow, p = 2, del_u = 0;
		for (int u = e[eg].from; u ^ lca; u = fa[u])
		{
			circle[++circle_cnt] = fe[u];
			if (e[fe[u]].flow < minflow)
				minflow = e[fe[u]].flow, del_u = u, p = 0;
		}
		for (int u = e[eg].to; u ^ lca; u = fa[u])
		{
			int ne = fe[u] ^ 1;
			circle[++circle_cnt] = ne;
			if (e[ne].flow < minflow)
				minflow = e[ne].flow, del_u = u, p = 1;
		}
		circle[++circle_cnt] = eg;

		cap cost = 0;
		for (int i = 1; i <= circle_cnt; ++i)
		{
			cost += e[circle[i]].cost * minflow;
			e[circle[i]].flow -= minflow, e[circle[i] ^ 1].flow += minflow;
		}
		if (p == 2)
			return cost;

		int u = e[eg].from, v = e[eg].to;
		if (p == 1)
			std::swap(u, v);
		int last_e = eg ^ p, last_u = v;
		while (last_u ^ del_u)
		{
			last_e ^= 1, --mark[u], std::swap(fe[u], last_e);
			int nu = fa[u];
			fa[u] = last_u, last_u = u, u = nu;
		}
		return cost;
	}
	void init_sz(int _n) { n = _n, m = 0, cnt = 1, tme = 1; }
	std::pair<cap, cap> solve(int _s, int _t)
	{
		s = _s, t = _t;
		add_edge(t, s, flow_INF, -cost_offset);
		dfs(t, 0), mark[t] = ++tme;
		fa[t] = 0;
		cap cost = 0, flow = 0;
		bool run = 1;
		while (run)
		{
			run = 0;
			for (int i = 2; i <= cnt; ++i)
				if (e[i].flow && e[i].cost + phi(e[i].from) - phi(e[i].to) < 0)
					cost += pushflow(i), run = 1;
		}
		flow = e[cnt].flow;
		return std::make_pair(flow, cost + flow * cost_offset);
	}
}
int main()
{
	int n = rd(), m = rd(), s = 1, t = n;
	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);
}