#include <stdio.h>
#include <vector>
#define NMAX 1024

using namespace std;

int F[NMAX][NMAX], C[NMAX][NMAX];

inline void chmin(int &A, int B) {
    if (A > B)
        A = B;
}

struct maxFlow {
    int sink, source, N;
    int fi, la;
    int vis[NMAX], father[NMAX], Q[NMAX];
    vector <int> G[NMAX];

    void init(int S, int T, int n) {
        source = S;
        sink = T;
        N = n;
    }

    void addDirected(int x0, int y0, int cap) {
        C[x0][y0] = cap;
        G[x0].push_back(y0);
        G[y0].push_back(x0);
    }

    void addUndirected(int x0, int y0, int cap) {
        C[x0][y0] = cap;
        C[y0][x0] = cap;
        G[x0].push_back(y0);
        G[y0].push_back(x0);
    }

    void initBFS() {
        int i;
        for (i = 0; i <= N; ++i) {
            vis[i] = 0;
            father[i] = 0;
        }
        father[source] = -1; vis[source] = 1;
        fi = 1; la = 0;
        Q[++la] = source;
    }

    bool BFS() {
        initBFS();
        while (fi <= la) {
            vector <int> :: iterator it;
            int node = Q[fi];
            for (it = G[node].begin(); it != G[node].end(); ++it)
                if (!vis[*it] && F[node][*it] < C[node][*it]) {
                    Q[++la] = *it;
                    vis[*it] = true;
                    father[*it] = node;
                }
            ++fi;
        }
        return vis[sink];
    }

    int augment() {
        int flow = 0;
        vector <int> :: iterator it;
        for (it = G[sink].begin(); it != G[sink].end(); ++it)
            if (F[*it][sink] < C[*it][sink] && vis[*it]) {
                int fmin = C[*it][sink] - F[*it][sink], node = *it;
                while (father[node] != -1) {
                    chmin(fmin, C[father[node]][node] - F[father[node]][node]);
                    node = father[node];
                    if (fmin == 0)
                        break;
                }
                if (fmin) {
                    F[*it][sink] += fmin; F[sink][*it] -= fmin;
                    int node = *it;
                    while (father[node] != -1) {
                        F[father[node]][node] += fmin;
                        F[node][father[node]] -= fmin;
                        node = father[node];
                    }
                }
                flow += fmin;
            }
        return flow;
    }

    int solve() {
        int flow = 0;
        while (BFS())
            flow += augment();
        return flow;
    }

};

int main() {
    freopen("maxflow.in", "r", stdin);
    freopen("maxflow.out", "w", stdout);

    int i, N, M, S, D;
    scanf("%d%d%d%d", &N, &M, &S, &D);
    maxFlow network;
    network.init(S, D, N);
    for (i = 1; i <= M; ++i) {
        int x0, y0, c, cc;
        scanf("%d%d%d%d", &x0, &y0, &c, &cc);
        network.addDirected(x0, y0, c);
    }

    printf("%d", network.solve());
    return 0;
}