#include <bits/stdc++.h>

using namespace std;

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

int n, m, sursa, destinatie, a, b, c, e, u, costsol, minim, i;
int d[400], t[400];
int cost[400][400], capacitate[400][400], flux[400][400];

deque <int> q;

bitset <400> f;

vector <int> L[400];

int bellmanFord (){
    int nod, vecin, gasit = 0;
    f.reset();
    q.clear();
    for (int i=1; i<=n; i++){
        d[i] = INT_MAX;
    }
    d[sursa] = 0;
    q.push_back(sursa);
    f[sursa] = 1;
    while (!q.empty()){
        nod = q.front();
        f[nod] = 0;
        q.pop_front();
        for (int i=0; i<L[nod].size(); i++){
            vecin = L[nod][i];
            if (d[vecin] > d[nod] + cost[nod][vecin] && capacitate[nod][vecin] > flux[nod][vecin]){
                d[vecin] = d[nod] + cost[nod][vecin];
                t[vecin] = nod;
                if (f[vecin] == 0){
                    f[vecin] = 1;
                    q.push_back(vecin);
                    if (vecin == destinatie){
                        gasit = 1;
                    }
                }
            }
        }
    }
    return gasit;
}

int main(){
    fin >> n >> m >> sursa >> destinatie;
    for (i=1; i<=m; i++){
        fin >> a >> b >> c >> e;
        L[a].push_back (b);
        L[b].push_back (a);
        capacitate[a][b] = c;
        cost[a][b] = e;
        cost[b][a] = -e;
    }
    while (bellmanFord()){
        u = destinatie;
        minim = INT_MAX;
        while (u != sursa){
            minim = min (minim, capacitate[t[u]][u] - flux[t[u]][u]);
            u = t[u];
        }
        u = destinatie;
        while (u != sursa){
            flux[t[u]][u] += minim;
            flux[u][t[u]] -= minim;
            costsol += cost[t[u]][u]*minim;
            u = t[u];
        }
    }
    fout << costsol;
    return 0;
}
//recapitulare