#include <bits/stdc++.h>
#define MAX 1001
#define INF 2e9

using namespace std;

class Cmp
{
public:

    bool operator()(const pair<int, int> &A, const pair<int, int> &B)const {
        return A.second > B.second;
    }
};

int n, m, s, d;
int cap[MAX][MAX], cost[MAX][MAX], flux[MAX][MAX];
int distBellman[MAX], auxDistBellman[MAX], dist[MAX];
int tata[MAX];
vector<int>graph[MAX];
priority_queue<pair<int, int>, vector<pair<int, int>>, Cmp>PQ;

bool Dijkstra()
{
    bool verif = 0;

    for(int i = 1; i <= n; i++)
        auxDistBellman[i] = INF;

    auxDistBellman[s] = 0;
    dist[s] = 0;
    PQ.push({s, 0});

    while(PQ.size())
    {
        int nod = PQ.top().first;
        int costCurrent = PQ.top().second;

        PQ.pop();

        if(dist[nod] != costCurrent)continue;
        if(nod == d)verif = 1;

        for(auto vecin : graph[nod])
            if(cap[nod][vecin] > flux[nod][vecin] && dist[vecin] > dist[nod] + cost[nod][vecin] + distBellman[nod] - distBellman[vecin])
            {
                tata[vecin] = nod;
                dist[vecin] = dist[nod] + cost[nod][vecin] + distBellman[nod] - distBellman[vecin];
                auxDistBellman[vecin] = auxDistBellman[nod] + cost[nod][vecin];
                PQ.push({vecin, dist[vecin]});
            }
    }

    for(int i = 1; i <= n; i++)
        distBellman[i] = auxDistBellman[i];

    return verif;
}

void BellmanFord()
{
    queue<int>Q;

    for(int i = 1; i <= n; i++)
        distBellman[i] = INF;

    distBellman[s] = 0;
    Q.push(s);

    while(Q.size())
    {
        int nod = Q.front();

        Q.pop();

        for(auto vecin : graph[nod])
            if(distBellman[vecin] > distBellman[nod] + cost[nod][vecin] && cap[nod][vecin] > 0)
            {
                distBellman[vecin] = distBellman[nod] + cost[nod][vecin];
                Q.push(vecin);
            }
    }
}

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

    ios::sync_with_stdio(false);
    fin.tie(0);
    fout.tie(0);

    fin >> n >> m >> s >> d;

    for(int i = 1; i <= m; i++)
    {
        int x, y, c, z;

        fin >> x >> y >> c >> z;

        graph[x].push_back(y);
        graph[y].push_back(x);
        cost[x][y] = z;
        cost[y][x] = -z;
        cap[x][y] = c;
    }

    BellmanFord();

    int sol = 0;
    for(int i = 1; i <= n; i++)
        dist[i] = INF;
    memset(tata, 0, sizeof(tata));

    while(Dijkstra())
    {
        int nod = d;

        int minCap = INF;

        while(nod != s)
        {
            if(minCap > cap[tata[nod]][nod] - flux[tata[nod]][nod])
                minCap = cap[tata[nod]][nod] - flux[tata[nod]][nod];

            nod = tata[nod];
        }

        if(minCap == 0)
            continue;

        sol += minCap * auxDistBellman[d];
        nod = d;

        while(nod != s)
        {
            flux[tata[nod]][nod] += minCap;
            flux[nod][tata[nod]] -= minCap;
            nod = tata[nod];
        }
        for(int i = 1; i <= n; i++)
            dist[i] = INF;
        memset(tata, 0, sizeof(tata));
    }

    fout << sol;

    fin.close();
    fout.close();

    return 0;
}