#include <bits/stdc++.h>

using namespace std;

const int MAXN = 355;

#define nod first
#define dist second

class cmp{
    public:
    bool operator ()(pair<int, int> &a, pair<int, int> &b){
        return a.dist > b.dist;
    }
};

int flux[MAXN][MAXN], cost[MAXN][MAXN], sursa[MAXN], distBellmanFord[MAXN], distDijkstra[MAXN], distUpdate[MAXN];
vector<int> graf[MAXN];
queue<int> coada;
priority_queue<pair<int, int>, vector<pair<int, int>>, cmp> pq;

int n, m, s, d;

void BellmanFord(){
    for(int i = 1; i <= n; ++i) distBellmanFord[i] = 1e9;
    distBellmanFord[s] = 0;
    coada.push(s);
    while(!coada.empty()){
        int x = coada.front();
        coada.pop();
        for(auto y: graf[x]){
            if(distBellmanFord[y] > distBellmanFord[x] + cost[x][y] && flux[x][y] > 0){
                distBellmanFord[y] = distBellmanFord[x] + cost[x][y];
                coada.push(y);
            }
        }
    }
}

bool Dijkstra(){
    for(int i = 1; i <= n; ++i) distUpdate[i] = 1e9;
    distDijkstra[s] = distUpdate[s] = 0;
    bool ans = 0;
    pq.push({s, distDijkstra[s]});
    while(!pq.empty()){
        int x = pq.top().nod, xdist = pq.top().dist;
        pq.pop();
        if(x == d) ans = 1;
        if(xdist != distDijkstra[x]) continue;
        for(auto y: graf[x]){
            if(flux[x][y] > 0 && distDijkstra[y] > distDijkstra[x] + cost[x][y] + distBellmanFord[x] - distBellmanFord[y]){
                distDijkstra[y] = distDijkstra[x] + cost[x][y] + distBellmanFord[x] - distBellmanFord[y];
                distUpdate[y] = distUpdate[x] + cost[x][y];
                sursa[y] = x;
                pq.push({y, distDijkstra[y]});
            }
        }
    }
    for(int i = 1; i <= n; ++i) distBellmanFord[i] = distUpdate[i];
    return ans;
}

int main()
{
    ifstream fin("fmcm.in");
    ofstream fout("fmcm.out");
    fin >> n >> m >> s >> d;
    for(int i = 1; i <= m; ++i){
        int x, y;
        fin >> x >> y;
        fin >> flux[x][y] >> cost[x][y];
        cost[y][x] = -cost[x][y];
        graf[x].push_back(y);
        graf[y].push_back(x);
    }
    BellmanFord();
    for(int i = 1; i <= n; ++i) distDijkstra[i] = 1e9;
    int mncost = 0;
    while(Dijkstra()){
        int mnflux = 1e9, crt = d;
        while(crt != s){
            mnflux = min(mnflux, flux[sursa[crt]][crt]);
            crt = sursa[crt];
        }
        if(mnflux == 0) continue;
        crt = d;
        while(crt != s){
            flux[sursa[crt]][crt] -= mnflux;
            flux[crt][sursa[crt]] += mnflux;
            crt = sursa[crt];
        }
        mncost += mnflux * distUpdate[d];
        memset(sursa, 0, n);
        for(int i = 1; i <= n; ++i) distDijkstra[i] = 1e9;
    }
    fout << mncost;
    return 0;
}