#include <bits/stdc++.h>
using namespace std;


#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("avx2,tune=native")

typedef long long LL;
typedef pair <LL, int> pii;
const int N = 4855;
const LL INF = 0x3f3f3f3f3f3f;

inline int read() {
	int ch = getchar(), a = 0;
	while (ch < '0') ch = getchar();
	while (ch >= '0') a = a * 10 + ch - '0', ch = getchar();
	return a;
}



struct edge {
	int nxt, v, w, f;
} e[N * 1000];

int n, m, S, T, ecnt = 1;
int head[N], cur[N], dep[N];

void init () {
	memset (e, 0, sizeof (edge) * (ecnt + 1));
	memset (head, 0, sizeof (int) * (T + 2));
	ecnt = 1;
}

void add (int u, int v, LL w, int f = 1) {
	e[++ecnt] = {head[u], v, w, f}; head[u] = ecnt;
	e[++ecnt] = {head[v], u, -w, 0}; head[v] = ecnt;
}

LL h[N], dis[N];
bool vis[N];
int q[N];

bool bfs() {
  memcpy(cur, head, sizeof (int) * (T + 1)); // CHECK size
  memset(dep, 0x3f, sizeof (int) * (T + 1)); // CHECK size
  dep[S] = 0;
  int he = 0, t = 1;
  q[he] = S;
  while (he < t) {
  	 int x = q[he++];
  	 if (x == T) break;
    for (int i = head[x]; i; i = e[i].nxt) {
      int d = e[i].v;
      if (e[i].f > 0 && h[d] == h[x] + e[i].w
      && dep[d] > dep[x] + 1) {
        dep[d] = dep[x] + 1, q[t++] = d;
  } } }
  return dep[T] <= T;
}
int dfs(int x, int lim) {
  if (x == T || !lim) return lim;
  int f = 0, flow = 0;
  for (int &i = cur[x]; i && lim; i = e[i].nxt) {
    int d = e[i].v;
    if ((dep[d] == dep[x] + 1) && h[e[i].v] == e[i].w + h[x] 
    && (f = dfs(d, min(lim, e[i].f)))) {
      e[i].f -= f; e[i ^ 1].f += f;
      flow += f; lim -= f;
      if (lim == 0) break;
  } } return flow;
}


void solve() { // return {flow, cost}
  int flow = 0; LL val = 0;
  for (int i = 0; i <= T; ++i) h[i] = 0;
  int first = true;
  while (flow < m) {
    for (int i = S; i <= T; i++) dis[i] = INF;
	dis[S] = 0;
	if (first) {
		queue <int> q;
		q.push(S);
		while (!q.empty()) {
			int x = q.front(); q.pop();
			vis[x] = false;
			for (int o = head[x]; o; o = e[o].nxt) {
				LL w = dis[x] + e[o].w + h[x] - h[e[o].v];
				if (e[o].f > 0 && dis[e[o].v] > w) {
					dis[e[o].v] = w;
					if (!vis[e[o].v]) {
						vis[e[o].v] = 1;
						q.push(e[o].v);
					}
				}
			}
		}

		first = false;
	} else {
		priority_queue<pii, vector<pii>, greater<pii>> q;
		q.push(pii(0ll, S));
		while (!q.empty()) {
			pii now = q.top(); q.pop(); int x = now.second;
			if (dis[x] < now.first) continue;
			for (int o = head[x]; o; o = e[o].nxt) {
				LL w = dis[x] + e[o].w + h[x] - h[e[o].v];
				if (e[o].f > 0 && dis[e[o].v] > w) {
					dis[e[o].v] = w; q.push(pii(w, e[o].v));
				}
			}
		}
	}
    if (dis[T] >= INF) break;
    for (int i = 0; i <= T; ++i) {
        assert ((double)h[i] + dis[i] < INF * (m + 1));
        h[i] += dis[i];
    }
    //cerr << "dis : " << h[T] << endl;
    int fl = 0; 

    while (bfs()) fl += dfs(S, 1e9);
    //bfs(); fl += dfs(S, 1e9);
    val += fl * h[T];
    flow += fl;
  }
  cout << flow << " " << val << endl;
 
}


int a[N], b[N];

void work () {
	n = read(); m = read();
	for (int i = 1; i <= m; i++) {
		int s, t, c, w;
		s = read(); t = read(); c = read(); w = read();
		add (s, t, w, c);
	}
	S = 1; T = n; solve();

}


int main() {
//	int test = read();
	int test = 1;
	for (int i = 1; i <= test; i++) {
//		printf("Case #%d:\n", i);
		work();
	}
}