#include <fstream>
#include <vector>
#include <queue>
#define oo (1<<30)
#define nmax 360

using namespace std;

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

inline int _min(int a,int b){if(a<b)return a; return b;}

vector<int> V[nmax];
queue<int> Q;
bool queued[nmax];

int T[nmax],Dist[nmax];
int C[nmax][nmax],Cost[nmax][nmax];

int N,M,S,D,cost_flow;

int BellmanFord()
{
    while(!Q.empty())Q.pop();
    int i,x,y;
    for(i=1;i<=N;i++)Dist[i]=oo,T[i]=0;
    Dist[S] = 0;
    Q.push(S);
    queued[S]=1;
    while(!Q.empty())
    {
        x = Q.front();
        Q.pop();
        queued[x]=0;
        for(i=0;i<V[x].size();++i)
        {
            y = V[x][i];
            if(!C[x][y])continue;
            if(Dist[y]>Dist[x]+Cost[x][y])
            {
                Dist[y]=Dist[x]+Cost[x][y];
                T[y]=x;
                if(!queued[y])
                    Q.push(y),queued[y]=1;

            }
        }
    }
    if(Dist[D]<oo)
        return 1;
    return 0;
}

int main()
{
    int x,y,cap,cost,muchie_minima;
    in>>N>>M>>S>>D;
    while(M--)
    {
        in>>x>>y>>cap>>cost;
        C[x][y]+=cap;
        Cost[x][y]=cost,Cost[y][x]=-cost;
        V[x].push_back(y);
        V[y].push_back(x);
    }
    while(BellmanFord())
    {
        //am gasit drumul de cost minim
        x = D;
        muchie_minima = oo;
        //aflu fluxul minim pe care il pot baga
        while(x!=S)
            muchie_minima=_min(muchie_minima,C[T[x]][x]),x=T[x];
        if(!muchie_minima)continue;
        //actualizez capacitatile si costul
        x = D;
        while(x!=S)
            C[T[x]][x]-=muchie_minima,C[x][T[x]]+=muchie_minima,x=T[x];
        cost_flow+=Dist[D]*muchie_minima;
    }
    out<<cost_flow<<'\n';
    return 0;
}