#include <bits/stdc++.h>
#define NMAX 370
#define INF 0x3f
#define INF2 0x3f3f3f3f
using namespace std;
ifstream fin("fmcm.in");
ofstream fout("fmcm.out");
int n,m,S,D;
bool inq[NMAX];
int old_d[NMAX];
int d[NMAX];
int real_d[NMAX];
vector<int>g [NMAX];
int cost[NMAX][NMAX];
int c[NMAX][NMAX];
int flux,costflux;
struct tip
{
    int val;
};

int p[NMAX];
priority_queue < pair<int,int>, vector <pair <int, int> >, greater<pair<int,int> > >H;
void citire();

void bellman();
bool dijkstra();
int main()
{
    citire();
    bellman();
    while(dijkstra());
fout<<costflux;
    return 0;
}
void citire()
{
    int x,y,cap,cst;
    int i;
    fin>>n>>m>>S>>D;
    for(i=1; i<=m; i++)
    {
        fin>>x>>y>>cap>>cst;
        g[x].push_back(y);

        g[y].push_back(x);
        cost[x][y]=cst;
        cost[y][x]=-cst;
        c[x][y]=cap;
    }

}

void  bellman()
{
    int i;
    queue<int>Q;
    memset(old_d,INF,sizeof(old_d));
    Q.push(S);
    old_d[S]=0;
    inq[S]=1;
    while(!Q.empty())
    {
        int act=Q.front();
        Q.pop();
        inq[act]=0;
        for(int i=0; i< g[act].size(); i++)
        {
            int vec=g[act][i];
            if(c[act][vec])
            {

            if(old_d[vec]>old_d[act]+cost[act][vec])
            {
                old_d[vec]=old_d[act]+cost[act][vec];
                if(!inq[vec])
                {
                    Q.push(vec);
                    inq[vec]=1;
                }
            }
            }
        }
    }

}
bool dijkstra()
{
    memset(d,INF,sizeof(d));
    d[S]=0;
    real_d[S]=0;
    H.push({ 0,S });
    while(!H.empty())
        {
         int cost1=H.top().first;

         int act=H.top().second;
         H.pop();
         if(cost1!=d[act])
            continue;
         for(int i=0;i<g[act].size();i++)
            {
             int vec=g[act][i];
             if(c[act][vec])
                {
                 int dista=d[act]+cost[act][vec]+ old_d[act]-old_d[vec];
                 if(dista<d[vec])
                    {
                     d[vec]=dista;
                     real_d[vec]=real_d[act]+cost[act][vec];
                     p[vec]=act;
                     H.push({d[vec],vec});
                    }
                }
            }
        }

     memcpy(old_d, real_d, sizeof(old_d));
     if(d[D]==INF2)
            return 0;


     int minim= INF2;
     int costact=0;
     for(int ct=D;ct!=S;ct=p[ct])
            {minim=min(minim, c[p[ct]][ct]);
           costact+=cost[p[ct]][ct];
            }
     flux+=minim;
     costflux+= minim*real_d[D];
     for(int ct=D;ct!=S;ct=p[ct])
          {
            c[p[ct]][ct]-=minim;

            c[ct][p[ct]]+=minim;
          }
    return 1;

}