#include <cstdio>
#include <vector>
#include <queue>
#define Nmax 360
#define INF 2000000000

using namespace std;

int C[Nmax][Nmax],Cost[Nmax][Nmax],F[Nmax][Nmax],OldC[Nmax],NewC[Nmax],Sursa,Dest,n,Tata[Nmax],Dist[Nmax];
bool viz[Nmax];
vector <int> L[Nmax];

struct el
{
    int nod,cost;
    bool operator <(const el A) const
    {
        return cost>A.cost;
    }
};
queue <el> Q;
priority_queue <el> Q1;

inline void Bellman_Ford()
{
    int i;
    vector <int> ::iterator it;
    for(i=1;i<=n;++i) OldC[i]=INF;
    el w,w1;
    OldC[Sursa]=0; w.nod=Sursa; w.cost=0; Q.push(w); viz[w.nod]=true;
    while(!Q.empty())
    {
        w=Q.front(); Q.pop(); viz[w.nod]=false;
        for(it=L[w.nod].begin();it!=L[w.nod].end();++it)
        {
            if(C[w.nod][*it]==0) continue;
            if(OldC[*it]>OldC[w.nod]+Cost[w.nod][*it])
            {
                OldC[*it]=OldC[w.nod]+Cost[w.nod][*it];
                if(!viz[*it])
                {
                    w1.nod=*it; w1.cost=OldC[*it]; Q.push(w1); viz[w1.nod]=true;
                }
            }
        }
    }
}

inline bool Dijkstra()
{
    int i;
    vector <int> ::iterator it;
    for(i=1;i<=n;++i) Dist[i]=INF;
    el w,w1;
    Dist[Sursa]=0; w.nod=Sursa; w.cost=0; Q1.push(w);
    while(!Q1.empty())
    {
        w=Q1.top(); Q1.pop();
        if(Dist[w.nod]!=w.cost) continue;
        for(it=L[w.nod].begin();it!=L[w.nod].end();++it)
            if(Dist[*it]>Dist[w.nod]+OldC[w.nod]-OldC[*it]+Cost[w.nod][*it] && F[w.nod][*it]<C[w.nod][*it])
            {
                NewC[*it]=NewC[w.nod]+Cost[w.nod][*it];
                Dist[*it]=Dist[w.nod]+OldC[w.nod]-OldC[*it]+Cost[w.nod][*it];
                w1.nod=*it; w1.cost=Dist[*it];
                Tata[*it]=w.nod;
                Q1.push(w1);
            }
    }
    for(i=1;i<=n;++i) OldC[i]=NewC[i];
    return (Dist[Dest]!=INF);
}

int main()
{
    int m,x,y,z,c,min_flow=0,minim,Suma,i;
    freopen ("fmcm.in","r",stdin);
    freopen ("fmcm.out","w",stdout);
    scanf("%d%d%d%d", &n,&m,&Sursa,&Dest);
    while(m--)
    {
        scanf("%d%d%d%d", &x,&y,&c,&z);
        L[x].push_back(y);
        L[y].push_back(x);
        C[x][y]=c; Cost[x][y]=z; Cost[y][x]=-z;
    }
    Bellman_Ford();
    while(Dijkstra())
    {
        minim=INF; Suma=0;
        for(i=Dest;Tata[i]>0;i=Tata[i])
        {
            minim=min(minim,C[Tata[i]][i]-F[Tata[i]][i]);
            Suma+=Cost[Tata[i]][i];
        }
        min_flow+=Suma*minim;
        for(i=Dest;Tata[i]>0;i=Tata[i])
        {
            F[Tata[i]][i]+=minim;
            F[i][Tata[i]]-=minim;
        }
    }
    printf("%d\n", min_flow);
    return 0;
}