#include <bits/stdc++.h>

template<class Cap, class Cost>
struct Flow {
	struct Edge {
		int from, to;
		Cap cap, flow;
		Cost cost;
	};
	struct _Edge {
		int to, rev;
		Cap cap;
		Cost cost;
	};
	struct Graph {
		std::vector<int> head;
		std::vector<_Edge> elist;
		
		explicit Graph(int n,
			const std::vector<std::pair<int, _Edge>>& edges) {
			head.assign(n + 1, 0), elist.resize(edges.size());
			for (auto e : edges) ++ head[e.first + 1];
			for (int i = 0; i < n; i ++) head[i + 1] += head[i];
			auto cnt = head;
			for (auto e : edges) {
				elist[cnt[e.first] ++] = e.second;
			}
		}
	};
	
	int n;
	std::vector<Edge> edge;
	
	Flow(int _n): n(_n), edge{} {}
	
	void Add_Edge(int u, int v, Cap cap, Cost cost) {
		assert(0 <= u && u < n);
		assert(0 <= v && v < n);
		assert(cap >= 0), assert(0 <= cost);
		
		edge.emplace_back(u, v, cap, 0, cost);
		return;
	}
	std::pair<Cap, Cost> MCMF(int S, int T) {
		assert(0 <= S && S < n);
		assert(0 <= T && T < n);
		
		const int m = static_cast<int>(edge.size());
		std::vector<int> idx(m), rev(m), deg(n);
		std::vector<std::pair<int, _Edge>> elist(2 * m);
		
		for (int i = 0; i < m; i ++) {
			auto e = edge[i];
			idx[i] = deg[e.from] ++;
			rev[i] = deg[e.to] ++;
			elist[2 * i] = {e.from, {e.to, -1, e.cap - e.flow, e.cost}};
			elist[2 * i + 1] = {e.to, {e.from, -1, e.flow, - e.cost}};
		}
		auto G = Graph(n, elist);
		for (int i = 0; i < m; i ++) {
			auto e = edge[i];
			idx[i] += G.head[e.from];
			rev[i] += G.head[e.to];
			G.elist[idx[i]].rev = rev[i];
			G.elist[rev[i]].rev = idx[i];
		}
		
		auto ans = Slope(G, S, T).back();
		
		for (int i = 0; i < m; i ++) {
			auto e = G.elist[idx[i]];
			edge[i].flow = edge[i].cap - e.cap;
		}
		
		return ans;
	}
	std::vector<std::pair<Cap, Cost>> Slope(Graph G, int S, int T) {
		const Cap inf = std::numeric_limits<Cap>::max();
		const Cost INF = std::numeric_limits<Cost>::max();
		std::vector<int> pre(n);
		std::vector<Cost> dist(n);
		std::vector<bool> vis(n);
		
		auto SPFA = [&]() {
			std::queue<int> Q;
			fill(dist.begin(), dist.end(), INF);
			fill(vis.begin(), vis.end(), false);
			Q.emplace(S), dist[S] = 0, vis[S] = true;
			while (Q.size()) {
				int u = Q.front();
				vis[u] = false, Q.pop();
				for (int i = G.head[u]; i < G.head[u + 1]; i ++) {
					auto e = G.elist[i];
					if (e.cap && dist[u] + e.cost < dist[e.to]) {
						dist[e.to] = dist[u] + e.cost, pre[e.to] = e.rev;
						if (!vis[e.to]) Q.emplace(e.to), vis[e.to] = true;
					}
				}
			}
			return dist[T] != INF;
		};
		
		Cap flow = 0; Cost cost = 0, pre_slope = -1;
		std::vector<std::pair<Cap, Cost>> slope{{Cap(0), Cost(0)}};
		while (SPFA()) {
			Cap c = inf, d = dist[T];
			for (int u = T; u != S; u = G.elist[pre[u]].to)
				c = std::min(c, G.elist[G.elist[pre[u]].rev].cap);
			for (int u = T; u != S; u = G.elist[pre[u]].to) {
				auto &e = G.elist[pre[u]];
				e.cap += c, G.elist[e.rev].cap -= c;
			}
			flow += c, cost += c * d;
			if (pre_slope == d) slope.back() = {flow, cost};
			else slope.emplace_back(flow, cost);
			pre_slope = d;
		}
		return slope;
	}
};

int main() {
	int n, m;
	std::cin >> n >> m;
	int S = 0, T = n - 1;
	
	Flow<int, int> G(n);
	for (int i = 0; i < m; i ++) {
		int u, v, c, w;
		std::cin >> u >> v >> c >> w;
		G.Add_Edge(-- u, -- v, c, w);
	}
	
	auto [mxf, mnc] = G.MCMF(S, T);
	std::cout << mxf << ' ' << mnc << '\n';
	
	return 0;
}