#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 = 0x3f3f;

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];
short D[MAX_N], Cost[MAX_N][MAX_N];
short N, M, P, U;

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;
    }
}

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

bool dijkstra()
{
	for(int i = 1; i <= N; ++i)
		D[i] = INF;
    priority_queue <short, vector <short>, cmp > Q;
	bitset <MAX_N> inq;

    Q.push(P);
    D[P] = 0;
	inq[P] = 1;

    while(!Q.empty())
    {
        short nod = Q.top();
		Q.pop();
		inq[nod] = 0;

        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(inq[*it]) continue;
                Q.push(*it);
				inq[*it] = 1;
            }
    }
    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();
}