#include <cstdio>
#include <bitset>
#include <queue>
#include <vector>
#include <algorithm>
#include <cstring>
using namespace std;

const int NMAX = 352, INFI = 2e9;

vector <short> G[NMAX];
queue <short> Q;
int dist[NMAX], _dist[NMAX], __dist[NMAX], ans, _size;
short node, N, source, sink, cap[NMAX][NMAX], cost[NMAX][NMAX], T[NMAX];

struct predicate {

    inline bool operator () (const short &a, const short &b) {

        return _dist[a] > _dist[b];

    }

};

priority_queue <short, vector <short>, predicate> _Q;

inline void bellman_ford () {

    vector <short> :: iterator i;
    memset (dist, 0x3f, _size);
    dist[source] = 0;
    for (Q.push (source); !Q.empty (); Q.pop ()) {
        node = Q.front ();
        for (i = G[node].begin (); i != G[node].end (); ++i)
            if (cap[node][*i] && dist[*i] > dist[node] + cost[node][*i]) {
                dist[*i] = dist[node] + cost[node][*i];
                Q.push (*i);
            }
    }

}

inline bool dijkstra () {

    vector <short> :: iterator i;
    int t;
    short _min = 32000;
    memset (_dist, 0x3f, _size);
    memset (__dist, 0x3f, _size);
    _dist[source] = 0;
    __dist[source] = 0;
    _Q.push (source);
    while (!_Q.empty ()) {
        node = _Q.top ();
        _Q.pop ();
        for (i = G[node].begin (); i != G[node].end (); ++i)
            if (cap[node][*i] && __dist[*i] > __dist[node] + cost[node][*i]) {
                _dist[*i] = _dist[node] + cost[node][*i] + dist[node] - dist[*i];
                __dist[*i] = __dist[node] + cost[node][*i];
                T[*i] = node;
                _Q.push (*i);
            }
    }
    if (_dist[sink] == 1061109567)
        return 0;
    memcpy (dist, __dist, sizeof (dist));
    for (node = sink; node != source; node = T[node])
        _min = min (_min, cap[T[node]][node]);
    for (node = sink; node != source; node = T[node]) {
        cap[T[node]][node] -= _min;
        cap[node][T[node]] += _min;
    }
    ans += _min * __dist[sink];
    return 1;

}

int main () {

    freopen ("fmcm.in", "r", stdin);
    freopen ("fmcm.out", "w", stdout);
    short M, a, b, c, z;
    scanf ("%hd%hd%hd%hd", &N, &M, &source, &sink);
    _size = (N + 1) * 4;
    while (M--) {
        scanf ("%hd%hd%hd%hd", &a, &b, &c, &z);
        G[a].push_back (b);
        G[b].push_back (a);
        cap[a][b] = c;
        cost[a][b] = z;
        cost[b][a] = -z;
    }
    bellman_ford ();
    while (dijkstra ());
    printf ("%d", ans);

}