#include<fstream>
#include<vector>
#include<queue>

using namespace std;
typedef int var;

ifstream fin("fmcm.in");
ofstream fout("fmcm.out");

const var MAXN = 351;
const var INF = 1000001;

var H[MAXN], POS[MAXN],
    COST[MAXN], PARENT[MAXN], DIST[MAXN],
    K[MAXN][MAXN], C[MAXN][MAXN], F[MAXN][MAXN];

vector<var> G[MAXN];

bool INQ[MAXN];

var n, heapsize, src, dest;

void swapp(var node1, var node2) {
    swap(H[node1], H[node2]);
    swap(POS[H[node1]], POS[H[node2]]);
}

void heap_up(var node) {
    if(node == 1) return;
    if(COST[ H[node/2] ] > COST[ H[node] ]) {
        swapp(node, node/2);
        node /= 2;
    }
}

var next;
void heap_down(var node) {
    if(node * 2 > heapsize) return;
    if(node*2+1 <= heapsize && COST[ H[node*2] ] > COST[ H[node*2+1] ]) {
        next = node*2+1;
    } else {
        next = node*2;
    }

    if(COST[ H[node] ] > COST[ H[next] ]) {
        swapp(node, next);
        heap_down(next);
    }
}

var extract_min() {
    swapp(1, heapsize--);
    heap_down(1);

    return H[heapsize + 1];
}

bool dijkstra(var src, var dest) {
    for(var i=1; i<=n; i++) {
        H[i] = i;
        COST[i] = INF;
        PARENT[i] = 0;
        POS[i] = i;
    }

    COST[src] = 0;
    swapp(1, src);
    heapsize = n;


    while(heapsize) {
        var node = extract_min();
        for(vector<var>::iterator it = G[node].begin(); it != G[node].end(); ++it) {
            var vec = *it;
            if(COST[vec] > COST[node] + K[node][vec] && F[node][vec] < C[node][vec]) {
                COST[vec] = COST[node] + K[node][vec];
                PARENT[vec] = node;

                heap_up(vec);
            }
        }
    }

    return PARENT[dest] != 0;
}

void bellman(var src) {

    queue<var> Q;

    for(var i=1; i<=n; i++) {
        DIST[i] = INF;
        INQ[i] = 0;
    }

    DIST[src] = 0;
    Q.push(src);
    while(!Q.empty()) {
        var node = Q.front();
        Q.pop();
        INQ[node] = 0;
        for(vector<var>::iterator it = G[node].begin(); it != G[node].end(); ++it) {
            var vec = *it;
            if(DIST[vec] > DIST[node] + K[node][vec] && F[node][vec] < C[node][vec]) {
                DIST[vec] = DIST[node] + K[node][vec];

                if(!INQ[vec]) {
                    INQ[vec] = 1;
                    Q.push(vec);
                }
            }
        }
    }
}

var mfmc() {

    var total = 0;


   while(dijkstra(src, dest)) {
        var MIN = INF;

        for(var t=dest; t != src; t = PARENT[t]) {
            MIN = min(MIN, C[PARENT[t]][t] - F[PARENT[t]][t]);
        }

        for(var t=dest; t != src; t = PARENT[t]) {
            F[PARENT[t]][t] += MIN;
            F[t][PARENT[t]] -= MIN;
            total += (K[PARENT[t]][t] + DIST[t] - DIST[PARENT[t]]) * MIN;
        }
   }

   return total;
}

int main() {

    var m, a, b, c, k;
    fin>>n>>m>>src>>dest;
    while(m--) {
        fin>>a>>b>>c>>k;
        G[a].push_back(b);
        G[b].push_back(a);
        C[a][b] = c;
        K[a][b] = k;
        K[b][a] = -k;
    }

    bellman(src);
    for(var i=1; i<=n; i++) {
        for(var j=1; j<=n; j++) {
            K[i][j] = K[i][j] + DIST[i] - DIST[j];
        }
    }

    fout<<mfmc();

    return 0;
}