#include <bits/stdc++.h>
using namespace std; 
const int N = 5e3 + 5; 

struct Graph {
    struct edge {
        int u, v, w, c;
        edge(int u = 0, int v = 0, int w = 0, int c = 0) : 
            u(u), v(v), w(w), c(c) {}
    };
 
    int n, m, s, t, cur[N], d[N];
    bool inq[N];
    vector<int> G[N];
    vector<edge> edges;
 
    inline void add(int u, int v, int w, int c) {
        edges.emplace_back(u, v, w, c);
        G[u].emplace_back(edges.size() - 1); 
        edges.emplace_back(v, u, 0, -c);
        G[v].emplace_back(edges.size() - 1); 
    }
 
    bool SPFA(void) {
        memset(cur, 0, sizeof(cur));
        memset(d, 0x3f, sizeof(d));
        queue<int> q; q.push(s); d[s] = 0; inq[s] = 1; 
        while (!q.empty()) {
            int u = q.front(); q.pop(); inq[u] = 0; 
            for (int i = 0; i < G[u].size(); ++i) {
                edge &e = edges[G[u][i]];
                if (e.w && d[e.v] > d[u] + e.c) {
                    d[e.v] = d[u] + e.c;
                    if (!inq[e.v]) q.push(e.v), inq[e.v] = 1; 
                }
            }
        }
        return d[t] < 0x3f3f3f3f;
    }
 
    int cost, vis[N]; 
    int dinic(int x, int res) {
        if (x == t) return res; 
        int flow = 0; vis[x] = 1; 
        for (int i = cur[x]; i < G[x].size() && res; ++i) {
            cur[x] = i; edge &e = edges[G[x][i]]; 
            int c = min(res, e.w); 
            if (!vis[e.v] && c && d[e.v] == d[x] + e.c) {
                int k = dinic(e.v, c); 
                flow += k; cost += k * e.c; res -= k; 
                e.w -= k; edges[G[x][i] ^ 1].w += k; 
            }
        }
        if (!flow) d[x] = 0x3f3f3f3f; vis[x] = 0; 
        return flow; 
    }
    int maxflow, flow; 
    int MCMF(int S, int T) {
        s = S; t = T; maxflow = 0; 
        while (SPFA()) while (flow = dinic(s, 1e9)) maxflow += flow;
        return cost; 
    }
} G;  

int n, m, s, t; 

main(void) {
    cin >> n >> m >> s >> t; 
    while (m--) {
        int u, v, w, c; cin >> u >> v >> w >> c; 
        G.add(u, v, w, c); 
    }
    int cost = G.MCMF(s, t); 
    cout << G.maxflow << " " << cost << "\n"; 
    return 0; 
}