#include <iostream>
#include <fstream>
#include <queue>
#include <climits>

using namespace std;

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

int n,m,s,d;
int flow[353][12503];
int cost[353][12503];
int newC[353][12503];
int magicC[353];
int bestD[353];
vector<int> e[353];
int cmin[353];
int bef[353];
bool viz[353];

bool dijkstra(int nod) {

    for(int i = 1; i <= n; i++) {
        cmin[i] = INT_MAX/2;
        bestD[i] = INT_MAX/2;
        bef[i] = 0;
        viz[i] = false;
    }
    cmin[nod] = 0;
    bestD[nod] = 0;

    priority_queue<pair<int, int>> Q;
    Q.push({0, nod});
    int c;
    int nx;
    int w;

    while(!Q.empty()) {

        c = -Q.top().first;
        nod = Q.top().second;
        Q.pop();

        if(viz[nod])
            continue;
        viz[nod] = 1;

        for(int i = 0; i < e[nod].size(); i++) {

            nx = e[nod][i];

            if(flow[nod][nx] == 0)
                continue;

            w = cost[nod][nx] + magicC[nod] - magicC[nx];

            if(cmin[nx] > cmin[nod]+w) {

                cmin[nx] = cmin[nod]+w;
                bestD[nx] = bestD[nod] + cost[nod][nx];
                Q.push({-cmin[nx], nx});
                bef[nx] = nod;

            }

        }

    }

    for(int i = 1; i <= n; i++)
        magicC[i] = bestD[i];

    if(cmin[d] != INT_MAX/2)
        return 1;

    return 0;

}

bool bellman() {

    queue<pair<int, int>> Q;

    for(int i = 1; i <= n; i++)
        magicC[i] = INT_MAX/2;

    magicC[s] = 0;
    Q.push({s, 0});

    int c;
    int nx;
    int nod;

    while(!Q.empty()) {

        nod = Q.front().first;
        c = Q.front().second;
        Q.pop();

        if(c != magicC[nod])
            continue;

        for(int i = 0; i < e[nod].size(); i++) {

            nx = e[nod][i];

            if(flow[nod][nx] == 0)
                continue;

            if(magicC[nx] > magicC[nod]+cost[nod][nx]) {

                magicC[nx] = magicC[nod]+cost[nod][nx];
                Q.push({nx, magicC[nx]});

            }

        }

    }

    if(magicC[d] != INT_MAX/2)
        return 1;
    return 0;

}

int main() {

    in >> n >> m >> s >> d;
    int x,y,z,w;

    for(int i = 1; i <= m; i++) {
        in >> x >> y >> z >> w;

        e[x].push_back(y);
        e[y].push_back(x);

        flow[x][y] = z;
        cost[x][y] = w;
        cost[y][x] = -w;

    }

    int flmx = 0;
    int cosM = 0;
    bellman();


    while(dijkstra(s)) {

        int flmin = INT_MAX;
        int crr = d;

        while(crr != s) {
            flmin = min(flmin, flow[bef[crr]][crr]);
            crr = bef[crr];
        }

        crr = d;
        flmx += flmin;
        cosM += flmin*bestD[d];

        while(crr != s) {
            flow[bef[crr]][crr] -= flmin;
            flow[crr][bef[crr]] += flmin;
            crr = bef[crr];
        }

    }

    out << cosM << '\n';

    return 0;
}