#include <bits/stdc++.h>
#define DIM 355

using namespace std;

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

int n, m, i, j, k, sursa, destinatie, x, y, cap, minim, u, fluxsol, costsol, nod;
int d[DIM], t[DIM];
int cost[DIM][DIM], flux[DIM][DIM], capacitate[DIM][DIM];

deque <int> q;
vector <int> L[DIM];
bitset <DIM> f;

int bellmanford (){
    int gasit, nod, vecin;
    for (int i=1; i<=n; i++){
        d[i] = INT_MAX;
    }
    f.reset();
    d[sursa] = 0;
    f[sursa] = 1;
    gasit = 0;
    q.clear();
    q.push_back(sursa);
    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 >> x >> y >> cap >> k;
        L[x].push_back (y);
        L[y].push_back (x);
        capacitate[x][y] = cap;
        capacitate[y][x] = 0;
        cost[x][y] = k;
        cost[y][x] = -k;
    }
    while (bellmanford()){
        minim = INT_MAX;
        u = destinatie;
        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 += minim*cost[t[u]][u];
            u = t[u];
        }
    }
    fout << costsol;
    return 0;
}