#include <fstream>
#include <algorithm>
#include <iomanip>
#include <vector>
#include <stack>
#include <queue>
#define nmax 360

using namespace std;

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

vector <int> v[nmax];
int i,n,m,oldd[nmax],S,D,c[nmax][nmax],cost[nmax][nmax],reald[nmax],p[nmax],d[nmax],f[nmax][nmax],maxflow,maxcost;

void bellmanford()
{
    queue <int> Q;
    bool inQ[nmax];
    for (i=1; i<=n; i++)
        inQ[i]=0,oldd[i]=1000000000;
    Q.push(S);
    inQ[S]=1;
    oldd[S]=0;
    while (!Q.empty())
    {
        int nod=Q.front();
        Q.pop();
        inQ[nod]=0;
        for (int i=0; i<v[nod].size(); i++)
        {
            int vecin=v[nod][i];
            if (c[nod][vecin]&&oldd[nod]+cost[nod][vecin]<oldd[vecin])
            {
                oldd[vecin]=oldd[nod]+cost[nod][vecin];
                if (!inQ[vecin])
                {
                    Q.push(vecin);
                    inQ[vecin]=1;
                }
            }
        }
    }
}

bool dijkstra()
{
    priority_queue <pair <int, int>, vector <pair <int,int> >, greater <pair <int, int> > > H;
    for (i=1; i<=n; i++)
        d[i]=1000000000,p[i]=-1;
    d[S]=reald[S]=0;
    H.push(make_pair(d[S],S));
    while (!H.empty())
    {
        int nod=H.top().second,cc=H.top().first;
        H.pop();
        if (cc>d[nod])
            continue;
        for (i=0; i<v[nod].size(); i++)
        {
            int vecin=v[nod][i];
            if (c[nod][vecin]>f[nod][vecin])
            {
                int aux=cost[nod][vecin]+oldd[nod]-oldd[vecin];
                if (cc+aux<d[vecin])
                {
                    d[vecin]=cc+aux;
                    p[vecin]=nod;
                    reald[vecin]=reald[nod]+cost[nod][vecin];
                    H.push(make_pair(d[vecin],vecin));
                }
            }
        }
    }
    if (p[D]==-1)
        return 0;
    int fmin=1000000000;
    for (int nod=D; nod!=S; nod=p[nod])
        fmin=min(fmin,c[p[nod]][nod]-f[p[nod]][nod]);
    for (int nod=D; nod!=S; nod=p[nod])
    {
        f[p[nod]][nod]+=fmin;
        f[nod][p[nod]]-=fmin;
    }
    maxflow+=fmin;
    maxcost=maxcost+fmin*reald[D];
    for (i=1; i<=n; i++)
        oldd[i]=reald[i];
    return 1;
}

int main()
{
    fin >> n >> m >> S >> D;
    for (i=1; i<=m; i++)
    {
        int X,Y,C,Z;
        fin >> X >> Y >> C >> Z;
        v[X].push_back(Y);
        v[Y].push_back(X);
        cost[X][Y]=Z;
        cost[Y][X]=-Z;
        c[X][Y]=C;
    }
    bellmanford();
    maxflow=maxcost=0;
    while (dijkstra());
    fout << maxcost << '\n';
}