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

bool dijkstra()
{
    for(int i = 1; i <= N; ++i)
        D[i] = INF;
    priority_queue <pair <short, short> > Q;

    Q.push(make_pair(0, P));
    D[P] = 0;

    while(!Q.empty())
    {
        short nod = Q.top().second;
        int dst = -Q.top().first;
        Q.pop();

        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;

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