#include <fstream>
#include <cstring>
using namespace std;

#define MAXN 1000
#define MAXM 5000
#define INF 0x3f3f3f3f

ifstream in ("flux.in");
ofstream out ("flux.out");

int n, m, S, D, flux, cost;
int C[MAXN][MAXN], dist[MAXN], T[MAXN], F[MAXN][MAXN];
struct edge { int x, y, c; } muc[MAXM];
struct list { int nod, cost; list *r; } *L[MAXN];

void push(int x, int y, int c) {
    list *p = new list;
    *p = (list) { y, c, L[x] };
    L[x] = p;
}

int bellman (int S, int D)
{
    int nr, k, ok;
    edge p;
    memset (dist, INF, sizeof (dist));
    dist[S] = 0;
    for (ok = nr = 1; ok && nr < n; ++nr) {
        for (ok = k = 0; k < m; ++k) {
            p = muc[k];
            if (C[p.x][p.y] > F[p.x][p.y] && dist[p.y] > dist[p.x] + p.c) {
                dist[p.y] = dist[p.x] + p.c;
                T[p.y] = p.x;
                ok = 1;
            }
            if (C[p.y][p.x] > F[p.y][p.x] && dist[p.x] > dist[p.y] - p.c) {
                dist[p.x] = dist[p.y] - p.c;
                T[p.x] = p.y;
                ok = 1;
            }
        }
    }
    return dist[D] != INF;
}

void fluxmax ()
{
    int i, r;
    for (flux = 0; bellman (S, D); flux += r, cost += r*dist[D]) {
        r = INF;
        for (i = D; i != S; i = T[i])
            r = min (r, C[T[i]][i] - F[T[i]][i]);
        for (i = D; i != S; i = T[i])
            F[T[i]][i] += r, F[i][T[i]] -= r;
    }

}

void citim ()
{
    int tm, x, y, c, cost;
    in >> n >> tm >> S >> D;
    m = tm;
    while (tm--) {
        in >> x >> y >> c >> cost;
        C[x][y] = c;
        muc[tm] = (edge) { x, y, cost };
    }
}

int main ()
{
    citim ();
    fluxmax ();
    return 0;
}