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

#define INF 1000000000
#define VAL 3000
#define MAXN 500


using namespace std;
typedef int64_t var;

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



var COST[MAXN], PARENT[MAXN];
bool DONE[MAXN];
var n;
var src, sink;
vector<var> G[MAXN];
var F[MAXN][MAXN], C[MAXN][MAXN], Z[MAXN][MAXN];


class cmp {
    public:const bool operator()(int a, int b) {
        return COST[a] > COST[b];
    }
};
priority_queue<int, vector<int>, cmp> Q;
bool dijkstra() {
    while(!Q.empty()) Q.pop();
    for(var i=1; i<=n; i++) {
        COST[i] = INF;
        DONE[i] = 0;
        PARENT[i] = 0;
    }
    Q.push(src);
    COST[src] = 0;
    while(!Q.empty()) {
        var node = Q.top();
        Q.pop();

        if(DONE[node] == 1) continue;
        DONE[node] = 1;

        //if(node == sink) break;

        for(vector<var>::iterator it = G[node].begin(); it!=G[node].end(); ++it) {
            var vec = *it;
            if(F[node][vec] < C[node][vec] && COST[vec] > COST[node] + Z[node][vec]) {
                COST[vec] = Z[node][vec] + COST[node];
                Q.push(vec);
                PARENT[vec] = node;
            }
        }
    }
    return DONE[sink];
}

var fmcm() {
    var total = 0;
    while(dijkstra()) {
        var MIN = INF;
        for(var i=sink; PARENT[i]; i=PARENT[i]) {
            MIN = min(MIN, C[PARENT[i]][i] - F[PARENT[i]][i]);
        }
        for(var i=sink; PARENT[i]; i=PARENT[i]) {
            F[PARENT[i]][i] += MIN;
            F[i][PARENT[i]] -= MIN;
            total += (Z[PARENT[i]][i] - VAL)*MIN;
        }
    }
    return total;
}

void read() {
    var m, a, b;
    fin>>n>>m>>src>>sink;
    while(m--) {
        fin>>a>>b;
        G[a].push_back(b);
        G[b].push_back(a);
        fin>>C[a][b]>>Z[a][b];
        Z[b][a] = -Z[a][b];
        Z[a][b] += VAL;
        Z[b][a] += VAL;
    }
}

int main() {
    read();
    fout<<fmcm();
    return 0;
}