#include <fstream>
#include <queue>
#include <cstring>
#include <vector>
#define DIMN 351
#define INF 2000000000

using namespace std;

ifstream f("fmcm.in");
ofstream g("fmcm.out");

vector<int> L[DIMN];

queue<int> q;

priority_queue< pair<int,int>, vector< pair<int,int> >, greater< pair<int,int> > > H;

int F[DIMN][DIMN], C[DIMN][DIMN], cost[DIMN][DIMN], D[DIMN], d[DIMN], dd[DIMN], T[DIMN];

bool viz[DIMN];

int n, m, s, ds, x, y, c, z, sol;

bool dijkstra () {
    for (int i=1; i<=n; ++i)
        D[i] = INF;
    D[s] = dd[s] = 0;
    H.push( make_pair(0, s) );
    while ( !H.empty() ) {
        int nod = H.top().second;
        int cst = H.top().first;
        H.pop();
        if (D[nod] != cst)
            continue;

        for (vector<int>::iterator it=L[nod].begin(); it!=L[nod].end(); ++it)
            if (C[nod][*it] - F[nod][*it] > 0) {
                int aux = D[nod] + cost[nod][*it] + d[nod] - d[*it];
                if (aux < D[*it]) {
                    D[*it] = aux;
                    dd[*it] = dd[nod] + cost[nod][*it];
                    T[*it] = nod;
                    H.push( make_pair(aux, *it) );
                }
            }
    }
    memcpy(d, dd, sizeof(D));
    if (D[ds] == INF)
        return 0;
    int Min = INF;
    for (int i=ds; i!=s; i=T[i])
        Min = min(Min, C[T[i]][i] - F[T[i]][i]);
    sol += Min * d[ds];
    for (int i=ds; i!=s; i=T[i]) {
        F[T[i]][i] += Min;
        F[i][T[i]] -= Min;
    }
    return 1;
}

void BF() {
    for (int i=1; i<=n; ++i)
        d[i] = INF, viz[i] = 0;
    d[s] = 0;
    q.push(s);
    while ( !q.empty() ) {
        int nod = q.front();
        q.pop();
        viz[nod] = 0;
        for (vector<int>::iterator it=L[nod].begin(); it!=L[nod].end(); ++it)
            if (d[*it] > d[nod] + cost[nod][*it] && C[nod][*it] - F[nod][*it] > 0) {
                d[*it] = d[nod] + cost[nod][*it];
                if (viz[*it])
                    continue;
                viz[*it] = 1;
                q.push(*it);
            }
    }
}

int main() {
    f >> n >> m >> s >> ds;
    for (int i=1; i<=m; ++i) {
        f >> x >> y >> c >> z;
        L[x].push_back(y);
        L[y].push_back(x);
        C[x][y] = c;
        cost[x][y] = z;
        cost[y][x] = -z;
    }
    BF();
    while ( dijkstra() );
    g << sol;
    return 0;
}