#include <fstream>
#include <vector>
#include <queue>
#include <algorithm>
#include <cstring>

#define INF 0x3f3f3f3f
#define NMAX 355
#define pb push_back
#define mp make_pair
#define nod first
#define cost second
#define MIN(a,b) (a<b) ? a : b

using namespace std;

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

vector< pair< int, int > > G[NMAX];
bool USED[NMAX];
int N, M, S, D, Nod, i, x, y, cap, cost, C[NMAX][NMAX], F[NMAX][NMAX], T[NMAX], Dist[NMAX], CostMin, FluxCt;

inline bool Bellman()
{
    memset( USED, false, sizeof(USED) );
    USED[S] = true;

    queue< int > Q;
    Q.push( S );

    memset( Dist, INF, sizeof(Dist) );
    Dist[S] = 0;

    while( !Q.empty() )
    {
        Nod = Q.front();
        Q.pop();
        USED[Nod] = false;

        for( vector< pair< int, int > >::iterator Vecin = G[Nod].begin(); Vecin != G[Nod].end(); Vecin++ )
            if( F[Nod][ (*Vecin).nod ] < C[Nod][ (*Vecin).nod ] && Dist[ (*Vecin).nod ] > Dist[Nod] + (*Vecin).cost )
            {
                Dist[ (*Vecin).nod ] = Dist[Nod] + (*Vecin).cost;
                T[ (*Vecin).nod ] = Nod;

                if( !USED[ (*Vecin).nod ] )
                {
                    USED[ (*Vecin).nod ] = true;
                    Q.push( (*Vecin).nod );
                }
            }
    }

    return ( Dist[D] != INF );
}

int main()
{
    memset( C, 0, sizeof(C) );
    memset( F, 0, sizeof(F) );

    in >> N >> M >> S >> D;
    for( ; M--; )
    {
        in >> x >> y >> cap >> cost;

        C[x][y] = cap;
        G[x].pb( mp( y, cost ) );
        G[y].pb( mp( x, -cost ) );
    }

    for( CostMin = 0; Bellman(); CostMin += FluxCt*Dist[D] )
    {
        FluxCt = INF;

        for( Nod = D; Nod != S; Nod = T[Nod] )
            FluxCt = MIN( FluxCt, C[ T[Nod] ][Nod] - F[ T[Nod] ][Nod] );

        for( Nod = D; Nod != S; Nod = T[Nod] )
            F[ T[Nod] ][Nod] += FluxCt, F[Nod][ T[Nod] ] -= FluxCt;
    }

    out << CostMin << '\n';

    return 0;
}