#include <iostream>
#include <vector>
#include <fstream>
#include <algorithm>
#include <string.h>
using namespace std;
const int inf=1<<30;
const int maxn=360;
ifstream f("fmcm.in");
ofstream g("fmcm.out");
vector <pair<int,int> >h,h2;
vector <int> G[maxn];
int N,M,S,D,MaxFlow,MinC;
int old_d[maxn],d[maxn],real_d[maxn],TT[maxn],q[maxn],C[maxn][maxn],F[maxn][maxn],Cost[maxn][maxn];
void Bellman_Ford()
{
    int i,pas=0,nod,next;
    for(i=1; i<=N; i++) old_d[i]=inf;
    old_d[S]=0;

    h.push_back(make_pair(0, S));
    make_heap(h.begin(), h.end());

    while(!h.empty() && pas<=1LL*N*M)
    {
        pas++;
        nod=h[0].second;
        pop_heap(h.begin(), h.end());
        h.pop_back();
        q[nod]=0;
        for(i=0; i<G[nod].size(); i++)
        {
            next=G[nod][i];
            if (C[nod][next]!=0)
            {
                if(old_d[next]>old_d[nod]+Cost[nod][next])
                {
                    old_d[next]=old_d[nod]+Cost[nod][next];
                    if(q[next]==0)
                    {
                        q[next]=1;
                        h.push_back(make_pair(-old_d[next], next));
                        push_heap(h.begin(), h.end());
                    }
                }
            }
        }
    }
}
int dijkstra()
{
    int cst;
    for ( int i = 1; i <= N; i++)
      {d[i] = inf;TT[i]=-1;}
    d[S]=0;
    real_d[S] = 0;
    h2.push_back(make_pair(0, S));
    int nod,next,sz;
    while (!h2.empty())
    {

        nod = h2[0].second;
        cst= -h2[0].first;
        pop_heap(h2.begin(), h2.end());
        h2.pop_back();

        if (d[nod]<cst) continue;

        sz=G[nod].size();
        for(int i=0; i<sz; ++i)
        {
            next=G[nod][i];
            if(C[nod][next] - F[nod][next]>0)
            {
                int new_d = cst + Cost[nod][next] + old_d[nod] - old_d[next];
                if(new_d<d[next])
                {
                    d[next]=new_d;
                    real_d[next]=real_d[nod]+Cost[nod][next];
                    TT[next]=nod;
                    h2.push_back(make_pair(-d[next], next));
                    push_heap(h2.begin(), h2.end());
                }
            }
        }
    }
    return (d[D] != inf);
}
int main()
{
    int i,x,y,a,b;
    f>>N>>M>>S>>D;
    for (i=1;i<=M;i++)
    {
        f>>x>>y;
        f>>a>>b;

        G[x].push_back(y);
        G[y].push_back(x);
        Cost[x][y] = b;
        Cost[y][x] = -b;
        C[x][y] += a;
    }
    Bellman_Ford();

    int nr=1;
    while (dijkstra())
    {
        int Min = inf;
        for(int nod=D; nod != S; nod=TT[nod])
        {
       //     cout<<nod<<" ";
            Min = min(Min, C[ TT[nod] ][nod] - F[ TT[nod] ][nod]);
        }
        MaxFlow += Min;
        MinC += Min * real_d[D];
        for(int nod = D; nod != S; nod = TT[nod])
        {
            F[ TT[nod] ][nod] += Min;
            F[nod][ TT[nod] ] -= Min;
        }
        memcpy(old_d, real_d, sizeof(old_d));

    }
    g << MinC << "\n";
    return 0;
}