#include <fstream>
#include <string.h>
#include <queue>

#define nMax 360
#define pb push_back
#define mkp make_pair
#define INF 0x3f3f3f3f

using namespace std;
ifstream fin("fmcm.in");
ofstream fout("fmcm.out");
int n, m, S, D, flow, flowCost;
int old_d[nMax], real_d[nMax], d[nMax], viz[nMax], TT[nMax], C[nMax][nMax], Cost[nMax][nMax];
vector<int> G[nMax];
queue<int> Q;
priority_queue<pair<int, int>, vector<pair<int, int> >, greater<pair<int, int> > > H;
void read()
{
    int a, b, c, d;
    fin>>n>>m>>S>>D;

    for(int i=1;i<=m;i++)
    {
        fin>>a>>b>>c>>d;
        G[a].pb(b);
        G[b].pb(a);
        C[a][b]=c;
        Cost[a][b]=d;
        Cost[b][a]=-d;
    }
}
int dijkstra()
{
    memset(d, INF, sizeof(d));
    d[S]=0, real_d[S]=0;

    for(H.push(mkp(d[S], S));!H.empty();)
    {
        int cost=H.top().first, node=H.top().second;
        H.pop();

        if(d[node]!=cost)
            continue;

        for(vector<int>::iterator it=G[node].begin();it!=G[node].end();it++)
        {
            int fiu=*it;
            if(!C[node][fiu])
                continue;

            int new_d=d[node]+old_d[node]-old_d[fiu]+Cost[node][fiu];
            if(new_d<d[fiu])
            {
                d[fiu]=new_d;
                real_d[fiu]=real_d[node]+Cost[node][fiu];
                TT[fiu]=node;
                H.push(mkp(d[fiu], fiu));
            }
        }
    }
    memcpy(old_d, real_d, sizeof(real_d));

    if(d[D]==INF)
        return 0;
    return 1;
}
void bellman_ford()
{
    memset(old_d, INF, sizeof(old_d));
    viz[S]=1, old_d[S]=0;

    for(Q.push(S);!Q.empty();)
    {
        int node=Q.front();
        viz[node]=0;
        Q.pop();

        for(vector<int>::iterator it=G[node].begin();it!=G[node].end();it++)
        {
            int fiu=*it;
            if(C[node][fiu]==0)
                continue;

            if(old_d[node]+Cost[node][fiu]<old_d[fiu])
            {
                old_d[fiu]=old_d[node]+Cost[node][fiu];
                if(!viz[fiu])
                {
                    viz[fiu]=1;
                    Q.push(fiu);
                }
            }
        }
    }
}
void solve()
{
    bellman_ford();
    while(dijkstra())
    {
        int Min=INF;

        for(int aux=D;aux!=S;aux=TT[aux])
            Min=min(Min, C[TT[aux]][aux]);

        for(int aux=D;aux!=S;aux=TT[aux])
        {
            C[TT[aux]][aux]-=Min;
            C[aux][TT[aux]]+=Min;
        }

        flow+=Min;
        flowCost+=Min*real_d[D];
    }
}
void write()
{
    fout<<flowCost;
}
int main()
{
    read();
    solve();
    write();
    return 0;
}