#include <bits/stdc++.h>

using namespace std;
const int N = 350 + 5;
const int INF = 1e9;
using ll = long long;
struct edge {
    int from, to, cap, cost;
};
vector <edge> e;
vector <int> g[N];
int n, m, s, t;
int d[N], from[N], dist[N];
bool inq[N];
void add_edge(int u, int v, int w, int c) {
    g[u].push_back(e.size());
    e.push_back({u, v, w, c});
    g[v].push_back(e.size());
    e.push_back({v, u, 0, -c});
}
void bellman() {
    queue <int> q;
    q.push(s);
    inq[s] = true;
    fill(d, d + n + 1, INF);
    d[s] = 0;
    while(!q.empty()) {
        int u = q.front();
        q.pop();
        inq[u] = false;
        for(int id : g[u]) {
            int v = e[id].to;
            if(e[id].cap != 0 && d[v] > d[u] + e[id].cost) {
                if(!inq[v]) {
                    q.push(v);
                    inq[v] = true;
                }
                d[v] = d[u] + e[id].cost;
            }
        }
    }
}
struct heapn { int v, d; friend bool operator <(const heapn& a, const heapn& b) { return a.d > b.d; }};
bool dijkstra() {
    fill(dist, dist + n + 1, INF);
    fill(from, from + n + 1, -1);
    dist[s] = 0;
    priority_queue <heapn> pq;
    pq.push({s, 0});
    while(!pq.empty()) {
        auto [u, dd] = pq.top();
        pq.pop();
        if(dd != dist[u]) continue;
        for(int id : g[u]) {
            int v = e[id].to;
            if(e[id].cap && dist[u] + d[u] - d[v] + e[id].cost < dist[v]) {
                from[v] = id;
                dist[v] = dist[u] + d[u] - d[v] + e[id].cost;
                pq.push({v, dist[v]});
            }
        }
    }
    for(int i = 1; i <= n; i++)
        d[i] = min(INF, d[i] + dist[i]);
    return from[t] != -1;
}

int main() {
    ifstream cin("fmcm.in");
    ofstream cout("fmcm.out");
    cin >> n >> m >> s >> t;
    for(int i = 1, u, v, w, c; i <= m; i++) {
        cin >> u >> v >> w >> c;
        add_edge(u, v, w, c);
    }
    ll flow = 0, cost = 0;
    bellman();
    while(dijkstra()) {
        int f = INF;
        for(int id = from[t]; id != -1; id = from[e[id].from])
            f = min(f, e[id].cap);
        for(int id = from[t]; id != -1; id = from[e[id].from]) {
            e[id].cap -= f;
            e[id^1].cap += f;
            cost += e[id].cost * f;
        }
        flow += f;
    }
    cout << cost;
    return 0;
}