#include <iostream>
#include <fstream>
#include <vector>
#include <queue>

using namespace std;

const int NSIZE = 350 + 10;
const int inf = 1 << 30;

int N , M , x , y , z , i , ci , fmin , flow , S , D;
int d[NSIZE] , flag[NSIZE] , nxt[NSIZE];
int p[NSIZE][NSIZE] , c[NSIZE][NSIZE] , f[NSIZE][NSIZE];
vector < int > g[NSIZE];
queue < int > inQ;

bool bellman()
{
    for (int i=1;i<=N;++i)
    d[i] = inf;

    d[S] = 0;
    inQ.push(S);
    flag[S] = 1;

    while (!inQ.empty())
    {
        int crt = inQ.front();
        inQ.pop() , flag[crt] = 0;

        for (int i = 0;i < g[crt].size();++i)
        {
            int to = g[crt][i];

            if (f[crt][to] < c[crt][to] && d[to] > d[crt] + p[crt][to])
            {
                d[to] = d[crt] + p[crt][to];
                nxt[to] = crt;

                if (flag[to] == 0)
                {
                    inQ.push(to);
                    flag[to] = 1;
                }
            }
        }
    }

    if (d[D] == inf) return false;
    return true;
}

int main()
{

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

fin >> N >> M >> S >> D;

for (i=1;i<=M;++i)
{
    fin >> x >> y >> ci >> z;

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

    c[x][y] = ci;
    p[x][y] += z;
    p[y][x] -= z;
}

while (bellman())
{
    fmin = inf;

    for (i = D ; i != S ; i = nxt[i])
    {
        int to = nxt[i];
        fmin = min(fmin , c[to][i] - f[to][i]);
    }

    flow += fmin * d[D];

    for (i = D ; i != S ; i = nxt[i])
    {
        int to = nxt[i];
        f[to][i] += fmin;
        f[i][to] -= fmin;
    }
}

fout << flow << '\n';

return 0;
}