/* mincost-maxflow.cpp */
#include <bits/stdc++.h>

using i64 = long long;
constexpr int N = 4e2 + 5, M = 1.5e4 + 5, inf = ~0u >> 1;
struct Edge { int to, cap, cost; };

int n, m, s, t; Edge e[M << 1]; int cnt;
std::vector<int> g[N];
void addEdge(int u, int v, int w, int c) {
    g[u].push_back(cnt), e[cnt++] = {v, w, c};
    g[v].push_back(cnt), e[cnt++] = {u, 0, -c};
}

int d[N]; std::bitset<N> vis;
bool spfa() {
    static std::queue<int> q;
    std::fill(d, d + n, inf), d[s] = 0, q.push(s);
    while (!q.empty()) {
        int u = q.front(); q.pop(), vis[u] = false;
        for (auto i : g[u]) {
            auto [v, w, c] = e[i];
            if (w && d[v] > d[u] + c) {
                d[v] = d[u] + c;
                if (!vis[v]) q.push(v), vis[v] = true;
            }
        }
    }
    return d[t] != inf;
}
int cost, h[N];
int dfs(int u, int lim) {
    if (u == t) return lim;
    vis[u] = true; int f = 0;
    for (int &_ = h[u]; _ < int(g[u].size()); ++_) {
        int i = g[u][_]; auto &[v, w, c] = e[i];
        if (w && !vis[v] && d[v] == d[u] + c) {
            int x = dfs(v, std::min(lim - f, w));
            w -= x, e[i ^ 1].cap += x, f += x, cost += x * c;
            if (lim == f) break;
        }
    }
    vis[u] = false;
    return f;
}
int maxFlow() {
    int f = 0;
    while (spfa()) std::fill(h, h + n, 0), f += dfs(s, inf);
    return f;
}

int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);

    std::cin >> n >> m, s = 0, t = n - 1;
    for (int i = 0; i < m; ++i) {
        int u, v, w, c; std::cin >> u >> v >> w >> c, --u, --v;
        addEdge(u, v, w, c);
    }

    std::cout << maxFlow() << ' ' << cost << '\n';

    return 0;
}