#include <fstream>
#include <queue>
#include <vector>
#include <cstring>

#define oo 0x3f3f3f3f

using namespace std;
ifstream fin("fmcm.in");
ofstream fout("fmcm.out");

vector<pair<int,int> >g[355];
queue<int>q;
priority_queue<pair<int,int> >H;
int dst[355], ci[355], cr[355], t[355], cap[355][355], f[355][355], n, m, s, d, c, z, x, y, sol;
bool vis[355];
void BellmanFord()
{
    memset(vis,0,sizeof(vis));
    memset(dst,oo,sizeof(dst));
    q.push(s);
    vis[s]=1;
    dst[s]=0;
    while(!q.empty())
    {
        int x=q.front(); q.pop();
        for(vector<pair<int,int> >::iterator it=g[x].begin(); it<g[x].end(); it++ )
        {
            if(dst[it->first]>dst[x]+it->second && cap[x][it->first]-f[x][it->first]>0)
            {
                dst[it->first]=dst[x]+it->second;
                if(!vis[it->first])
                {
                    vis[it->first]=1;
                    q.push(it->first);
                }
            }
        }
    }
}

inline bool Dijkstra()
{
    H.push(make_pair(0,s));
    memset(ci,oo,sizeof(ci));
    ci[s]=cr[s]=0;
    while(!H.empty())
    {
        pair<int,int> x=H.top(); H.pop();
        for(vector<pair<int,int> >::iterator it=g[x.second].begin(); it<g[x.second].end(); it++ )
        {
            int opt=ci[x.second]+it->second+dst[x.second]-dst[it->first];
            if(ci[it->first]>opt && cap[x.second][it->first]-f[x.second][it->first]>0)
            {
                ci[it->first]=opt;
                cr[it->first]=cr[x.second]+it->second;
                t[it->first]=x.second;
                H.push(make_pair(-ci[it->first],it->first));
            }
        }
    }
    return (ci[d]!=oo);
}

int main()
{
    fin>>n>>m>>s>>d;
    for(int i = 1; i<= m; i++ )
    {
        fin>>x>>y>>c>>z;
        g[x].push_back(make_pair(y,z));
        g[y].push_back(make_pair(x,-z));
        cap[x][y]=c;
    }
    BellmanFord();
    while(Dijkstra())
    {
        memcpy(dst,cr, sizeof(cr));
        int flux=oo;
        for(int x = d; x!=s; x=t[x])
            flux=min(flux,cap[t[x]][x]-f[t[x]][x]);
        sol+=cr[d]*flux;
        for(int x = d; x!=s; x=t[x])
        {
            f[t[x]][x]+=flux;
            f[x][t[x]]-=flux;
        }
    }
    fout<<sol;
    fin.close();
    fout.close();
    return 0;
}