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

using namespace std;


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 <short, vector <short>, cmp> Q;

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

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

		for(vector<short>::iterator it=G[nod].begin();it!=G[nod].end();it++)
            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(*it);
                viz[*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();
}