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

using namespace std;

#define foreach(V) for(typeof (V).begin() it = (V).begin(); it != (V).end(); ++it)

const int MAX_N = 355;
const int INF = 0x3f3f3f3f;

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

vector <short> G[MAX_N];
short C[MAX_N][MAX_N], F[MAX_N][MAX_N], T[MAX_N];
int D[MAX_N], Cost[MAX_N][MAX_N];
short N, M, P, U;

struct cmp
{
	bool operator() (const short &a, const short &b) const
	{
		return D[a] > D[b];
	}
};

void citire()
{
    fin >> N >> M >> P >> U;

    while(M--)
    {
        short a, b, c, cost;
        fin >> a >> b >> c >> cost;

        G[a].push_back(b);
        G[b].push_back(a);
        C[a][b] = c;
        Cost[a][b] = cost;
        Cost[b][a] = -cost;
    }
}

bool dijkstra()
{
	memset(D, INF, sizeof D);
    priority_queue <pair <int, short> , vector <pair <int, short> >, greater <pair <int, short> > > Q;

	bitset <MAX_N> viz;
    Q.push(make_pair(0, P));
    D[P] = 0;
	viz[P] = 1;

    while(!Q.empty())
    {
        short nod = Q.top().second;
		int dst = Q.top().first;
		Q.pop();
		viz[nod] = 0;

		if(dst != D[nod]) continue;

        foreach(G[nod])
            if(C[nod][*it] > F[nod][*it] && D[nod] + Cost[nod][*it] < D[*it])
            {
                D[*it] = D[nod] + Cost[nod][*it];
                T[*it] = nod;
                
				if(viz[*it]) continue;

                Q.push(make_pair(D[*it], *it));
            }
    }
    return (D[U] < INF);
    
}

void flux()
{
    int fmin, flow = 0;
    while(dijkstra())
    {
		fmin = INF;
        for(short i = U; i != P; i = T[i])
            fmin = min(fmin, C[T[i]][i] - F[T[i]][i]);

        for(short i = U; i != P; i = T[i])
            F[T[i]][i] += fmin,
            F[i][T[i]] -= fmin;

        flow += fmin * D[U];
    }
    fout << flow;
}

int main()
{
    citire();
    flux();
}