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

using namespace std;

#define Nmax 354
#define oo 0x3f3f3f

vector <long long> G[Nmax];

long long F[Nmax][Nmax];
long long C[Nmax][Nmax];
long long Cost[Nmax][Nmax];

long long tata[Nmax];
bool viz[Nmax];
long long d[Nmax];

queue <long long> Q;

long long N, M, S, D;

void read()
{
    ifstream f("fmcm.in");

    f >> N >> M >> S >> D;

    for ( long long i = 1; i <= M; ++i )
    {
        long long a, b, c, z;

        f >> a >> b >> c >> z;

        G[a].push_back( b );
        G[b].push_back( a );

        C[a][b] = c;
        C[b][a] = -c;

        Cost[a][b] = z;
        Cost[b][a] = -z;
    }

    f.close();
}

long long Bellman_Ford( long long S, long long D )
{
    memset( d, oo, sizeof( d ) );
    memset( viz, 0, sizeof( viz ) );

    Q.push( S );

    d[S] = 0;
    viz[S] = true;

    while( !Q.empty() )
    {
        long long nod = Q.front();
        Q.pop();

        for ( unsigned i = 0; i < G[nod].size(); ++i )
        {
            long long son = G[nod][i];

            if ( C[nod][son] == F[nod][son] )
                    continue;

            if ( d[son] > d[nod] + Cost[nod][son] && C[nod][son] > F[nod][son] )
            {
                d[son] = d[nod] + Cost[nod][son];
                tata[son] = nod;

                if ( !viz[son] )
                {
                    viz[son] = true;
                    Q.push( son );
                }
            }
        }

        viz[nod] = false;
    }

    return d[D];
}

long long Edmonds_Karp( long long S, long long D )
{
    long long flow = 0, fmin, nod;
    long long cost_f = 0;

    while( Bellman_Ford( S, D ) != oo )
    {
        fmin = oo;

        for ( nod = D; nod != S; nod = tata[nod] )
                fmin = min( fmin, C[ tata[nod] ][nod] - F[ tata[nod] ][nod] );

        if ( fmin == 0 )
                break;

        cost_f += d[D] * fmin;

        for ( nod = D; nod != S; nod = tata[nod] )
        {
            F[ tata[nod] ][nod] += fmin;
            F[nod][ tata[nod] ] -= fmin;
        }

        flow += fmin;
    }

    return cost_f;
}

void print()
{
    ofstream g("fmcm.out");

    g << Edmonds_Karp( S, D ) << "\n";

    g.close();
}

int main()
{
    read();
    print();

    return 0;
}