#include<fstream>
#include<bitset>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;

#define NMax 355
#define inf 2100000000

ifstream f("fmcm.in");
ofstream g("fmcm.out");

int n,m,S,D;
vector<int> v[NMax];
int ant[NMax];
int C[NMax][NMax],F[NMax][NMax];
int Cost[NMax][NMax];

queue<int> cd[2];
bitset<NMax> B[2];
int d[NMax];

void Bellmanford(int ind)
{
    int i,s;
    while(!cd[ind].empty())
    {
        s=cd[ind].front(); cd[ind].pop();
        B[ind][s]=0;
        for(i=0;i<(int)v[s].size();i++) if(F[s][v[s][i]]<C[s][v[s][i]]) if(d[v[s][i]]>d[s]+Cost[s][v[s][i]])
        {
            ant[v[s][i]]=s;
            d[v[s][i]]=d[s]+Cost[s][v[s][i]];
            if(!B[1-ind][v[s][i]]) cd[1-ind].push(v[s][i]),B[1-ind][v[s][i]]=1;
        }
    }
}

int Flux()
{
    for(int i=1;i<=n;i++) d[i]=inf,ant[i]=0;
    d[S]=0;

    cd[1].push(S);
    for(int i=1;i<=n;i++) Bellmanford(i%2);

    if(d[D]==inf) return 0;

    int fmin=inf;
    int nod=D;
    while(ant[nod])
    {
        fmin=min(fmin,C[ant[nod]][nod]-F[ant[nod]][nod]);
        nod=ant[nod];
    }

    nod=D;
    while(ant[nod])
    {
        F[ant[nod]][nod]+=fmin;
        F[nod][ant[nod]]-=fmin;
        nod=ant[nod];
    }

    return fmin*d[D];
}

int main()
{
    int i,a,b,c,d;

    f>>n>>m>>S>>D;

    for(i=1;i<=m;i++)
    {
        f>>a>>b>>c>>d;
        v[a].push_back(b);
        v[b].push_back(a);
        C[a][b]=c;
        Cost[a][b]=d;
        Cost[b][a]=-d;
    }

    int flux=0,cost=0;

    while(cost=Flux()) flux+=cost;

    g<<flux<<"\n";

    f.close();
    g.close();

    return 0;
}