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

using namespace std;

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

const int NMax = 350, oo = 2e9;

int N, M, S, Dest, Ans, C[NMax + 5][NMax + 5], D[NMax + 5][NMax + 5], TT[NMax + 5], F[NMax + 5][NMax + 5], DP[NMax + 5];

bool InQ[NMax + 5];

vector <int> G[NMax + 5]; queue <int> Q;

void Read()
{
    fin >> N >> M >> S >> Dest;

    for(int i = 1, x, y, d, c; i <= M; i++) {
        fin >> x >> y >> d >> c;

        G[x].push_back(y);
        G[y].push_back(x);
        C[x][y] = c, C[y][x] = -c, D[x][y] = d;
    }
}

bool BellmanFord()
{
    for(int i = 1; i <= N; i++)
        DP[i] = oo, TT[i] = 0, InQ[i] = 0;

    Q.push(S); InQ[S] = 1, DP[S] = 0;

    while(!Q.empty()) {
        int Nod = Q.front(); InQ[Nod] = 0; Q.pop();

        for(auto Vecin : G[Nod])
            if(DP[Nod] + C[Nod][Vecin] < DP[Vecin] && F[Nod][Vecin] != D[Nod][Vecin])
            {
                DP[Vecin] = DP[Nod] + C[Nod][Vecin], TT[Vecin] = Nod;

                if(InQ[Vecin] == 0)
                    Q.push(Vecin), InQ[Vecin] = 1;
            }
    }
    return (DP[Dest] != oo);
}

void SolveP()
{
    while(BellmanFord())
    {
        int Fmin = oo;

        for(int i = Dest; i != S; i = TT[i])
            Fmin = min(Fmin, D[TT[i]][i] - F[TT[i]][i]);

        for(int i = Dest; i != S; i = TT[i])
            F[TT[i]][i] += Fmin, F[i][TT[i]] -= Fmin;

         Ans += Fmin * DP[Dest];
    }
    fout << Ans << '\n';
}

int main()
{
    Read();
    SolveP();

    return 0;
}