#include <bits/stdc++.h>

using namespace std;

// #define LOCK_GETCHAR
// #define USE_INT_128

#if __cplusplus < 201400
#warning "Please use c++14 or higher."
#define CONSTEXPR_FUNC
#define ENABLE_IF_INT
#else
#define CONSTEXPR_FUNC constexpr
#define ENABLE_IF_INT , enable_if_t<_is_integer<T>, int> = 0
template <class T> constexpr bool _is_integer = numeric_limits<T>::is_integer;
template <> constexpr bool _is_integer<bool> = false;
template <> constexpr bool _is_integer<char> = false;
#ifdef USE_INT_128
template <> constexpr bool _is_integer<__int128> = true;
template <> constexpr bool _is_integer<__uint128_t> = true;
#endif
template <class T ENABLE_IF_INT>
constexpr T INF = numeric_limits<T>::max() >> 1;
#endif

#if !defined(_WIN32) && !defined(LOCK_GETCHAR)
#define getchar getchar_unlocked
#endif

#define il inline
#define mkp make_pair
#define fi first
#define se second
#define For(i, j, k) for (decltype(j - k) i = (j); i <= (k); ++i)     // NOLINT
#define ForDown(i, j, k) for (decltype(j - k) i = (j); i >= (k); --i) // NOLINT
#define pb push_back
#define eb emplace_back
#ifndef ONLINE_JUDGE
#define FileIO(filename)                                                       \
  freopen(filename ".in", "r", stdin);                                         \
  freopen(filename ".out", "w", stdout)
#else
#define FileIO(filename) void(0)
#endif

using ll = long long;
using uint = unsigned int;
using ull = unsigned long long;
using db = double;
using ldb = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#ifdef USE_INT_128
using lll = __int128_t;
using ulll = __uint128_t;
#endif

// clang-format off
template<typename T> constexpr il T sq(const T &x) {
    return x * x;
}
template<typename T> CONSTEXPR_FUNC il void cmin(T &x, const T &y) {
    x = min(x, y);
}
template<typename T> CONSTEXPR_FUNC il void cmax(T &x, const T &y) {
    x = max(x, y);
}
template<typename T> CONSTEXPR_FUNC il T qpow(T x, ull y, T mod) {
    T ans = 1;
    x %= mod;

    while (y) {
        if (y & 1)
            (ans *= x) %= mod;

        (x *= x) %= mod;
        y >>= 1;
    }

    return ans;
}
template<typename T> CONSTEXPR_FUNC il T qpow(T x, ull y) {
    T ans = 1;

    while (y) {
        if (y & 1)
            ans *= x;

        x *= x;
        y >>= 1;
    }

    return ans;
}
template<typename T ENABLE_IF_INT> il void read(T &x) {
    x = 0;
    int f = 1;
    int c = getchar();

    while (!isdigit(c)) {
        if (c == '-')
            f = -1;

        c = getchar();
    }

    while (isdigit(c)) {
        x = x * 10 + c - '0';
        c = getchar();
    }

    x *= f;
}
template<typename T, typename ... Args> il void read(T &x, Args &... y) {
    read(x);
    read(y...);
}
// clang-format on

// File head end

class MCMF {
    struct Edge {
        int v, cap, flow, wi;
        Edge() : v(0), cap(0), flow(0), wi(0) {}
        Edge(int _v, int _c, int _f, int _w) : v(_v), cap(_c), flow(_f), wi(_w) {}
    };
    vector<int> H, dis, dep, cur;
    vector<vector<int>> G;
    vector<Edge> E;
    int s, t;

    il bool dijkstra() {
        static priority_queue<pii, vector<pii>, greater<>> pq;

        while (!pq.empty())
            pq.pop();

        fill(dis.begin(), dis.end(), INF<int>);
        pq.emplace(0, s), dis[s] = 0;

        while (!pq.empty()) {
            auto [di, u] = pq.top();
            pq.pop();

            if (di != dis[u])
                continue;

            // cerr << u << '\n';
            for (auto i : G[u]) {
                int v = E[i].v, w = E[i].wi + H[u] - H[v];

                if (E[i].cap > E[i].flow && dis[v] > dis[u] + w) {
                    dis[v] = dis[u] + w;
                    pq.emplace(dis[v], v);
                }
            }
        }

        for (int i = 0; i < H.size(); i++)
            H[i] += dis[i];

        // cerr << "> " << H[s] << ' ' << H[t] << '\n';
        return dis[t] < INF<int>;
    }
    il bool BFS() {
        static queue<int> q;

        while (!q.empty())
            q.pop();

        fill(dep.begin(), dep.end(), -1);
        q.emplace(s), dep[s] = 0;

        while (!q.empty()) {
            int u = q.front();
            q.pop();

            // cerr << "? " << u << '\n';
            for (int i : G[u]) {
                int v = E[i].v;

                if (E[i].cap > E[i].flow && H[v] == H[u] + E[i].wi && !(~dep[v])) {
                    dep[v] = dep[u] + 1;
                    q.emplace(v);
                }
            }
        }

        fill(cur.begin(), cur.end(), 0);
        return ~dep[t];
    }
    int DFS(int x, int flow) {
        if (x == t || !flow)
            return flow;

        // cerr << "D " << x << '\n';
        int ans = 0;

        for (int &i = cur[x]; i < G[x].size(); i++) {
            int e = G[x][i], v = E[e].v;

            if (E[e].cap > E[e].flow && H[v] == H[x] + E[e].wi &&
                    dep[v] == dep[x] + 1) {
                int fl = DFS(v, min(flow, E[e].cap - E[e].flow));
                ans += fl, flow -= fl;
                E[e].flow += fl, E[e ^ 1].flow -= fl;

                if (!flow)
                    break;
            }
        }

        return ans;
    }

public:
    MCMF() = default;
    MCMF(int __n) {
        resize(__n);
    }
    il void clear() {
        fill(H.begin(), H.end(), 0);
        fill(dis.begin(), dis.end(), 0);
        fill(dep.begin(), dep.end(), 0);
        fill(cur.begin(), cur.end(), 0);
        for_each(G.begin(), G.end(), [&](auto & x) {
            x.clear();
        });
        E.clear();
    }
    il void resize(int __n) {
        H.resize(__n), dis.resize(__n), dep.resize(__n), cur.resize(__n),
                 G.resize(__n);
        clear();
    }
    il void addEdge(int u, int v, int cap, int wi) {
        assert(u >= 0 && u < G.size());
        assert(v >= 0 && v < G.size());
        G[u].eb(E.size()), E.eb(v, cap, 0, wi);
        G[v].eb(E.size()), E.eb(u, 0, 0, -wi);
    }
    il void set_initial_H(int L, int R, int val) {
        fill(H.begin() + L, H.begin() + R, val);
    }
    il vector<int> solve(int __s, int __t, int val_range) {
        // cerr << "S " << __s << ' ' << __t << '\n';
        s = __s, t = __t;
        assert(s >= 0 && s < G.size());
        assert(t >= 0 && t < G.size());
        vector<int> ans(val_range + 1);
        dijkstra();

        while (dijkstra()) {
            int res = 0;

            while (BFS())
                res += DFS(s, INF<int>);

            ans[H[s] - H[t]] += res;
        }

        return ans;
    }
    il pii solve2(int __s, int __t) {
        s = __s, t = __t;
        assert(s >= 0 && s < G.size());
        assert(t >= 0 && t < G.size());
        bool qwq = dijkstra();
        int flow = 0, cost = 0;

        while (dijkstra()) {
            int res = 0;

            while (BFS())
                res += DFS(s, INF<int>);

            flow += res, cost += (H[t] - H[s]) * res;
        }

        return {flow, cost};
    }
};

namespace {
int n, m, s, t;
il void Main2() {
    read(n, m), s = 2 * n, t = 2 * n + 1;
    MCMF solver(2 * n + 2);
    For(i, 0, m - 1) {
        int u, v, w;
        read(u, v, w);
        solver.addEdge(u - 1, n + v - 1, 1, -w);
    }
    For(i, 0, n - 1) solver.addEdge(s, i, 1, 0), solver.addEdge(i + n, t, 1, 0);
    auto ans = solver.solve(s, t, 5);
    int res = n, tmp = 0;

    ForDown(i, 5, 1) while (ans[i]--)
        printf("%d\n", (tmp += i)), res--;

    while (res--)
        printf("%d\n", tmp);
}
il void Main() {
    read(n, m), s = 0, t = n - 1;
    MCMF solver(n);
    For(i, 0, m - 1) {
        int u, v, w, c;
        read(u, v, c, w);
        solver.addEdge(u - 1, v - 1, c, w);
    }
    auto ans = solver.solve2(s, t);
    cout << ans.fi << ' ' << ans.se << '\n';
}
} // namespace

signed main() {
    return Main(), 0;
}