#include "bits/stdc++.h"
using namespace std;
#define int long long
#define double long double
#define pii pair<int,int>
#define s second
#define f first
#define pb push_back
#define oo 1000000000000000000ll
#define all(a) (a).begin(), a.end()
#define rall(a) (a).rbegin(), a.rend()
#define ln '\n'

/* Contains: Maxflow_Mincost using Dijkstra
 * Assumptions: None
 * NOTE: change ftype, wtype to double for real-valued flow
 * Complexity: O(nm + (n+m)log(m)f) */
typedef int ftype; typedef double wtype;
const wtype EPS = 1; // 1e-9 for double
struct Edge { int from, to; ftype pushable, pushed; wtype w;};
struct MCMF{
    int n, s, t, m = 0;
    ftype flow; wtype cost;
    vector<int> vis, prv;
    vector<wtype> dist, h;
    vector<vector<int>> adj;
    vector<Edge> edges;
    MCMF(int n_): n(n_+10), vis(n), prv(n, -1), dist(n), h(n), adj(n) {}
    void add(int a, int b, ftype cap, wtype w, ftype low=0){
        edges.push_back({a, b, cap, low, w});
        edges.push_back({b, a, 0, low, -w});
        adj[a].push_back(m++);
        adj[b].push_back(m++);
    }
    bool dijkstra(){
        priority_queue<pair<wtype, int>, vector<pair<wtype, int>>, greater<pair<wtype, int>>> pq;
        fill(all(dist), oo); pq.push({dist[s]=0, s});
        while (!pq.empty()){
            int u = pq.top().s, val = pq.top().f; pq.pop();
            if (dist[u] < val) continue;
            for (auto id: adj[u]){
                Edge& e = edges[id];
                int v = e.to; wtype nc = e.w + h[u] - h[v];
                if (e.pushable < EPS || dist[v] < dist[u] + nc + EPS) continue;
                dist[v] = dist[u] + nc;
                prv[v] = id;
                pq.push({dist[v], v});
            }
        }
        return oo - dist[t] > EPS;
    }
    void spfa(){
        queue<int> q; fill(all(h), wtype(oo));
        q.push(s); h[s] = 0, vis[s] = 1;
        while (!q.empty()){
            int u = q.front(); q.pop();
            vis[u] = 0;
            for (auto id: adj[u]){
                Edge& e = edges[id];
                if (e.pushable < EPS || h[e.to] < h[u] + e.w + EPS) continue;
                h[e.to] = h[u] + e.w;
                if (!vis[e.to]) vis[e.to] = 1, q.push(e.to);
            }
        }
    }
    void calc(int S, int T){
        flow = cost = 0, s = S, t = T;
        spfa();
        while (dijkstra()){
            ftype f = oo;
            for (int i = 0; i < n; i++) h[i] = min(wtype(oo), h[i] + dist[i]);
            for (int x = prv[t]; x != -1; x = prv[edges[x].from]) f = min(f, edges[x].pushable);
            for (int x = prv[t]; x != -1; x = prv[edges[x].from]) {
                edges[x].pushable -= f, edges[x].pushed += f;
                edges[x^1].pushable += f, edges[x^1].pushed -= f;
            }
            flow += f; cost += h[t] * f;
        }
    }
};




void solve(){
    int n, m; cin >> n >> m;
    MCMF mcmf(n);
    while (m--){
        int u, v, cap, w; cin >> u >> v >> cap >> w;
        mcmf.add(u, v, cap, w);
    }
    mcmf.calc(1, n);
    cout << mcmf.flow << ' ' << mcmf.cost << ln;
}


signed main(){
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    // int TT; cin >> TT;
    // while (TT--) solve();
    // while (1) solve();
    solve();

}