#include <fstream>
#include <string.h>
#include <vector>
#include <queue>
#include <bitset>
#define nmax 350
#define inf 0x3f3f3f3f
using namespace std;
ifstream fin("fmcm.in");
ofstream fout("fmcm.out");
int n,m,cap[nmax+5][nmax+5],c[nmax+5][nmax+5],dist[nmax+5],d[nmax+5],real_d[nmax+5],S,D,t[nmax+5],flow;
long long maxflow;
vector<int> g[nmax+5];
queue<int> qb;
bitset<nmax+5> viz;
struct nd
{
    int nod,cost;
    bool operator < (const nd &other)const
    {
        return cost>other.cost;
    }
};
priority_queue<nd> qd;
int minv(int x,int y)
{
    return x<y?x:y;
}
void bellman()
{
    int nod;
    memset(dist,inf,sizeof(dist));
    dist[S]=0;
    qb.push(S);
    while(!qb.empty())
    {
        nod=qb.front();
        qb.pop();
        viz[nod]=0;
        for(int fiu : g[nod])
            if(cap[nod][fiu])
            if(dist[fiu]>dist[nod]+c[nod][fiu])
            {
                dist[fiu]=dist[nod]+c[nod][fiu];
                if(!viz[fiu])
                {
                    viz[fiu]=1;
                    qb.push(fiu);
                }
            }
    }
}
bool dijkstra()
{
    int cc,nn,new_d;
    memset(t,0,sizeof(t));
    memset(d,inf,sizeof(d));
    real_d[S]=0,t[S]=S,d[S]=0;
    qd.push({S,0});
    while(!qd.empty())
    {
        nn=qd.top().nod;
        cc=qd.top().cost;
        qd.pop();
        if(cc!=d[nn])
            continue;
        for(int fiu:g[nn])
            if(cap[nn][fiu])
            {
                new_d=d[nn]+(c[nn][fiu]+dist[nn]-dist[fiu]);
                if(new_d<d[fiu])
                {
                    d[fiu]=new_d;
                    real_d[fiu]=real_d[nn]+c[nn][fiu];
                    t[fiu]=nn;
                    qd.push({fiu,d[fiu]});
                }
            }
    }
    for(int i=1;i<=n;i++)
        dist[i]=real_d[i];
    if(d[D]==inf)
        return false;
    flow=inf;
    for(int i=D;i!=S;i=t[i])
        flow=minv(flow,cap[t[i]][i]);
    for(int i=D;i!=S;i=t[i])
    {
        cap[t[i]][i]-=flow;
        cap[i][t[i]]+=flow;
    }
    maxflow+=flow*dist[D];
    return true;
}
int main()
{
    fin>>n>>m>>S>>D;
    int x,y,ccc,z;
    for(int i=1;i<=m;i++)
    {
        fin>>x>>y>>ccc>>z;
        g[x].push_back(y);
        g[y].push_back(x);
        cap[x][y]=ccc;
        c[x][y]=z;
        c[y][x]=-z;
    }
    bellman();
    while(dijkstra());
    fout<<maxflow<<"\n";
    return 0;
}