#include <bits/stdc++.h>
#define Dim 352
#define oo 1000000
using namespace std;
ifstream f("fmcm.in");
ofstream g("fmcm.out");
void init();
int N,M,S,Dest,ans,a,b,c,d;
int T[Dim],D[Dim];
bool viz[Dim],ok;
vector <int> V[Dim];

struct flux
{
    int wieght,pay;
}C[Dim][Dim];

struct cmp
{
    bool operator()(int x,int y)
    {
        if(D[x]>D[y]) return 1;
        else return 0;
    }
};

priority_queue < int,vector<int>,cmp > minheap;

bool Bellman_Ford()
{
    init();
    ok=0;
    D[S]=0; viz[S]=1;
    minheap.push(S);
    T[S]=S;
    while(!minheap.empty())
    {
        int nod=minheap.top();
        viz[nod]=0;
        minheap.pop();

        for(unsigned int i=0;i<V[nod].size();i++)
        {
            int vecin=V[nod][i];
            if(C[nod][vecin].wieght>0&&(D[nod]+C[nod][vecin].pay<D[vecin]))
            {
                D[vecin]=D[nod]+C[nod][vecin].pay;
                T[vecin]=nod;
                if(vecin==Dest) ok=1;
                if(!viz[vecin])
                {
                    viz[vecin]=1;
                    minheap.push(vecin);
                }
            }
        }
    }
    return ok;
}

void init()
{
    for(int i=1;i<=N;i++)
    {
        D[i]=oo;
        viz[i]=0;
        T[i]=0;
    }
}

int main()
{
    f>>N>>M>>S>>Dest;
    for(int i=1;i<=M;i++)
    {
        f>>a>>b>>c>>d;
        C[a][b].wieght=c;
        C[a][b].pay=d;
        V[a].push_back(b);
    }
    while(Bellman_Ford()==1)
    {
        int minim=INT_MAX;
        int poz=N;
        while(poz!=S)
        {
            minim=min(minim,C[T[poz]][poz].wieght);
            poz=T[poz];
        }
        poz=N;
        while(poz!=S)
        {
            C[T[poz]][poz].wieght-=minim;
            poz=T[poz];
        }

        ans+=minim*D[Dest];
    }
    g<<ans;
    return 0;
}