#include <bits/stdc++.h>

const int oo=1e9;

using namespace std;

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

int n,m,S,D,i,j,fluxmax,C[360][360],cap[360][360],dist[360];
vector<int> v[360];

bool djikstra()
{
    priority_queue<pair<int,int> > Q;
    int d[360],real_d[360],tata[360];
    for(i=1;i<=n;i++)
        d[i]=real_d[i]=oo,tata[i]=0;
    d[S]=real_d[S]=0;Q.push({0,S});
    while(Q.size())
    {
        int x=Q.top().second,
         cost=Q.top().first;
        Q.pop();
        if(d[x]<cost)continue;
        for(auto it:v[x])
            if(cap[x][it])
            {
                int new_d=d[x]+C[x][it]+dist[it]-dist[x];
                if(new_d<d[it])
                {
                    d[it]=new_d;
                    real_d[it]=real_d[x]+C[x][it];
                    tata[it]=x;
                    Q.push({d[it],it});
                }
            }
    }
    for(i=1;i<=n;i++)
        dist[i]=real_d[i];
    if(dist[D]==oo)return 0;
//    for(i=1;i<=n;i++)
//        cout<<dist[i]<<' ';cout<<'\n';
    int x=D,flux=oo;
    while(tata[x]!=0)
    {
        flux=min(flux,cap[tata[x]][x]);
        x=tata[x];
    }
    x=D;
    //cout<<flux<<'\n';
    while(tata[x]!=0)
    {
        cap[tata[x]][x]-=flux;
        cap[x][tata[x]]+=flux;
        x=tata[x];
    }
    fluxmax+=flux*dist[D];
    return 1;
}

void bellman()
{
    queue<int> Q;
    bitset<360> in;
    for(i=1;i<=n;i++)
        dist[i]=oo,in[i]=0;
    dist[S]=0;in[S]=1;Q.push(S);
    while(Q.size())
    {
        int x=Q.front();
        Q.pop();in[x]=0;
        for(auto it:v[x])
            if(cap[x][it])
                if(dist[it]>dist[x]+C[x][it])
                {
                    dist[it]=dist[x]+C[x][it];
                    if(!in[it])
                    {
                        in[it]=1;
                        Q.push(it);
                    }
                }
    }
    return ;
}

int main()
{
    f>>n>>m>>S>>D;
    for(i=1;i<=m;i++)
    {
        int x,y,c,z;
        f>>x>>y>>c>>z;
        cap[x][y]=c;
        C[x][y]=z;
        C[y][x]=-z;
        v[x].push_back(y);
        v[y].push_back(x);
    }
    bellman();
//    for(i=1;i<=n;i++)
//        cout<<dist[i]<<' ';cout<<'\n';
    for(;djikstra(););
    g<<fluxmax;
    return 0;
}