#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/priority_queue.hpp>
#include <ext/rope>
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
#define int long long
using i64 = long long;
mt19937_64 rd(time(0));
template <class K, class C = less<>> using paring_heap = __gnu_pbds::priority_queue<K, C>;
template <class K> using rb_tree = tree<K, null_type, less<>, rb_tree_tag, tree_order_statistics_node_update>;
template <class T, class ... A> void debug(const T & t, const A & ... a) { cerr << "[" << t, ((cerr << ", " << a), ...), cerr << "]\n"; }
const i64 mod = [](bool n) { return n ? 998244353 : 1e9 + 7; } (1);

template<class type = int>
struct Dinic : vector<vector<int>> {    // O(n^2 * m)，二分图最大匹配 O(n^0.5 * m)
    struct Edge {
        int v;
        type c;
        Edge(int v, type c) : v(v), c(c) {}
    };

    vector<Edge> e;
    vector<int> cur, h;
    Dinic(int n) : vector(n) {}
    void add(int u, int v, type c) {
        at(u).emplace_back(e.size()), e.emplace_back(v, c);
        at(v).emplace_back(e.size()), e.emplace_back(u, 0);
    }

    int bfs(int & s, int & t) {
        h.assign(size(), numeric_limits<int>::max());
        queue<int> q;
        h[s] = 0, q.emplace(s);
        while (q.size()) {
            int u = q.front(); q.pop();
            for (auto & i : at(u)) {
                auto & [v, c] = e[i];
                if (c > 0 && h[v] > h[u] + 1) h[v] = h[u] + 1, q.emplace(v);
            }
        }
        return h[t] != numeric_limits<int>::max();
    }
    type dfs(int u, int & t, type flow) {
        if (u == t) return flow;
        type ret = flow, a;
        for (int & i = cur[u]; i < at(u).size(); i++) {
            auto & [v, c] = e[at(u)[i]];
            if (c > 0 && h[v] == h[u] + 1 && (a = dfs(v, t, min(ret, c)))) {
                ret -= a, c -= a, e[at(u)[i] ^ 1].c += a;
                if (ret == 0) return flow;
            }
        }
        return flow - ret;
    }
    type maxflow(int s, int t, type flow = 0) {
        while (bfs(s, t)) {
            cur.assign(size(), 0), flow += dfs(s, t, numeric_limits<type>::max());
        }
        return flow;
    }
};

template<class type = int>
struct ISAP : vector<vector<int>> { // O(n^2 * m)
    struct Edge {
        int v;
        type c;
        Edge(int v, type c) : v(v), c(c) {}
    };

    vector<Edge> e;
    vector<int> cur, h, gap;
    ISAP(int n) : vector(n) {}
    void add(int u, int v, type c) {
        at(u).emplace_back(e.size()), e.emplace_back(v, c);
        at(v).emplace_back(e.size()), e.emplace_back(u, 0);
    }

    void bfs(int & t) {   // 反向bfs
        h.assign(size(), numeric_limits<int>::max()), gap.assign(size() + 2, 0);
        queue<int> q;
        h[t] = 0, gap[h[t]]++, q.emplace(t);
        while (q.size()) {
            int u = q.front(); q.pop();
            for (auto & i : at(u)) {
                auto & [v, c] = e[i];
                if (e[i ^ 1].v && h[v] > h[u] + 1) h[v] = h[u] + 1, gap[h[v]]++, q.emplace(v);
            }
        }
    }
    type dfs(int u, int & s, int & t, type flow) {
        if (u == t) return flow;
        type ret = flow, a;
        for (int & i = cur[u]; i < at(u).size(); i++) {
            auto & [v, c] = e[at(u)[i]];
            if (c > 0 && h[v] + 1 == h[u] && (a = dfs(v, s, t, min(ret, c)))) {
                ret -= a, c -= a, e[at(u)[i] ^ 1].c += a;
                if (ret == 0) return flow;
            }
        }
        if (--gap[h[u]] == 0) h[s] = size();
        return gap[++h[u]]++, flow - ret;
    }
    type maxflow(int s, int t, type flow = 0) {
        for (bfs(t); h[s] < size(); ) {
            cur.assign(size(), 0), flow += dfs(s, s, t, numeric_limits<type>::max());
        }
        return flow;
    }
};

template<class type = int>
struct HLPP : vector<vector<int>> { // O(n^2 * sqrt(m))
    struct Edge {
        int v;
        type c;
        Edge(int v, type c) : v(v), c(c) {}
    };

    vector<Edge> e;
    vector<int> h, gap;
    int level = 0;
    vector<type> ex;
    vector<stack<int>> B;
    HLPP(int n) : vector(n) {}
    void add(int u, int v, type c) {
        at(u).emplace_back(e.size()), e.emplace_back(v, c);
        at(v).emplace_back(e.size()), e.emplace_back(u, 0);
    }

    int bfs(int & s, int & t) {   // 反向bfs
        h.assign(size(), numeric_limits<int>::max()), gap.assign(size() + 2, 0);
        queue<int> q;
        h[t] = 0, gap[h[t]]++, q.emplace(t);
        while (q.size()) {
            int u = q.front(); q.pop();
            for (auto & i : at(u)) {
                auto & [v, c] = e[i];
                if (e[i ^ 1].v && h[v] > h[u] + 1) h[v] = h[u] + 1, gap[h[v]]++, q.emplace(v);
            }
        }
        return h[s] != numeric_limits<int>::max();
    }
    int push(int u, int & s, int & t) {
        int init = u == s;
        for (auto & i : at(u)) {
            auto & [v, c] = e[i];
            if (!init && h[u] != h[v] + 1 || !c || h[v] == numeric_limits<int>::max()) continue;
            type k = init ? c : min(c, ex[u]);
            if (v != s && v != t && !ex[v]) B[h[v]].push(v), level = max(level, h[v]);
            ex[u] -= k, ex[v] += k, c -= k, e[i ^ 1].c += k;
            if (!ex[u]) return 0;
        }
        return 1;
    }
    void relabel(int u) {
        h[u] = numeric_limits<int>::max();
        for (auto & i : at(u)) {
            if (e[i].c) h[u] = min(h[u], h[e[i].v]);
        }
        if (++h[u] < size()) B[h[u]].push(u), level = max(level, h[u]), ++gap[h[u]];
    }
    int slect() {
        for ( ; level > -1 && B[level].size() == 0; level--);
        return level == -1 ? 0 : B[level].top();
    }
    type maxflow(int s, int t, type flow = 0) {
        if (!bfs(s, t)) return 0;
        ex.assign(size(), 0), B.assign(size(), stack<int>());
        h[s] = size(), push(s, s, t);
        for (int u = 0; u = slect(); ) {
            B[level].pop();
            if (push(u, s, t)) {
                if (--gap[h[u]] == 0) for (int i = 0; i < size(); i++) {
                    if (i != s && h[i] > h[u] && h[i] < size() + 1) h[i] = size() + 1;
                }
                relabel(u);
            }
        }
        return ex[t];
    }
};

template <class type = int>
struct MCMF : vector<vector<int>> {
    struct Edge {
        int v;
        type c, f;  // 容量，费用
        Edge(int v, type c, type f) : v(v), c(c), f(f) {}
    };

    vector<Edge> e;
    vector<type> h, dis;
    vector<int> pre;
    MCMF(int n) : vector(n) {}
    void add(int u, int v, type c, type f) {
        at(u).emplace_back(e.size()), e.emplace_back(v, c, f);
        at(v).emplace_back(e.size()), e.emplace_back(u, 0, -f);
    }

    int dijkstra(int & s, int & t) {
        dis.assign(size(), numeric_limits<type>::max()), pre.assign(size(), -1);
        std::priority_queue<pair<type, int>, vector<pair<type, int>>, greater<>> q;
        dis[s] = 0, q.emplace(0, s);
        while (q.size()) {
            auto [d, u] = q.top(); q.pop();
            if (dis[u] < d) continue;
            for (auto & i : at(u)) {
                auto & [v, c, f] = e[i];
                if (c > 0 && dis[v] > d + h[u] - h[v] + f) {
                    dis[v] = d + h[u] - h[v] + f, pre[v] = i;
                    q.emplace(dis[v], v);
                }
            }
        }
        return dis[t] != numeric_limits<type>::max();
    }
    void spfa(int & s, int & t) {   // 存在负权边
        h.assign(size(), numeric_limits<type>::max());
        vector<int> vis(size());
        queue<int> q;
        h[s] = 0, vis[s] = 1, q.push(s);
        while (q.size()) {
            int u = q.front(); q.pop(), vis[u] = 0;
            for (auto & i : at(u)) {
                auto & [v, c, f] = e[i];
                if (c > 0 && h[v] > h[u] + f) {
                    h[v] = h[u] + f;
                    if (!vis[v]) vis[v] = 1, q.push(v);
                }
            }
        }
    }
    array<type, 2> mncmxf(int s, int t, int flag, type flow = 0, type cost = 0) {
        if (flag) spfa(s, t);   // 若存在负权边，也可以使用消负权法
        else h.assign(size(), 0);   // 若全为正权值
        while (dijkstra(s, t)) {
            type a = numeric_limits<type>::max();
            for (int i = 0; i < size(); h[i++] += dis[i]);
            for (int i = t; i != s; a = min(a, e[pre[i]].c), i = e[pre[i] ^ 1].v);
            for (int i = t; i != s; i = e[pre[i] ^ 1].v) {
                e[pre[i]].c -= a, e[pre[i] ^ 1].c += a;
            }
            flow += a, cost += a * h[t];
        }
        return {flow, cost};
    }
};

void QAQ() {
    int n, m;
    cin >> n >> m;

    MCMF adj(n + 1);

    for (int i = 0, u, v, c, f; i < m; i++) {
        cin >> u >> v >> c >> f;
        adj.add(u, v, c, f);
    }

    auto [flow, cost] = adj.mncmxf(1, n, 0);

    cout << flow << " " << cost << "\n";
}

signed main() {
    cin.tie(0) -> sync_with_stdio(0);
    int t = 1;
    // cin >> t;
    for (cout << fixed << setprecision(12); t--; QAQ());
}