#include <fstream>
#include <vector>
#include <deque>
#define DIM 353
#define INF 1000000000
using namespace std;

int C[DIM][DIM], F[DIM][DIM], Z[DIM][DIM];
int T[DIM], V[DIM], D[DIM];

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

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

int n, m, cost, flux, x, y, z, c, d, s, minim, u;

int bf() {
    int nod, vecin;

    for (int i = 1; i<=n; i++) {
        V[i] = 0;
        D[i] = INF;
    }
    q.clear();
    q.push_back(s);
    V[s] = 1;
    D[s] = 0;
    int gasit = 0;
    while (!q.empty()) {
        nod = q.front();
        V[nod] = 0;
        q.pop_front();

        for (int i=0;i<L[nod].size(); i++) {
            vecin = L[nod][i];
            if (D[vecin] > D[nod] + Z[nod][vecin] && C[nod][vecin] > F[nod][vecin]) {
                D[vecin] = D[nod] + Z[nod][vecin];
                T[vecin] = nod;
                if (V[vecin] == 0) {
                    q.push_back(vecin);
                    V[vecin] = 1;
                    if (vecin == d)
                        gasit = 1;
                }
            }
        }
    }

    return gasit;
}


int main () {
    fin>>n>>m>>s>>d;
    for (int i=1;i<=m;i++) {
        fin>>x>>y>>c>>z;
        C[x][y] = c;
        C[y][x] = 0;
        Z[x][y] = z;
        Z[y][x] = -z;
        L[x].push_back(y);
        L[y].push_back(x);
    }

    while (bf()) {
        minim = INF;
        for (u = d; u!=s; u = T[u])
            minim = min(minim, C[ T[u] ][u] - F[ T[u] ][u]);
        flux += minim;
        for (u = d; u!=s; u = T[u]) {
            F[ T[u] ][u] += minim;
            F[u][ T[u] ] -= minim;
            cost += minim*Z[ T[u] ][u];
        }
    }

    fout<<cost;

    return 0;
}