#include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>
#include <cstring>
#include <queue>
#define inf 2147000000
using namespace std;
ifstream f("fmcm.in");
ofstream g("fmcm.out");


 struct vec
 {int nod,cost; } el;

 struct cmp
 { bool operator() (vec x,vec y)
     { return x.cost>y.cost;}
 };


 queue <int> q;
 vector <int> v[355];
 priority_queue <vec, vector<vec>, cmp> heap;

 int n,m,s,d,c[355][355],cst[355][355],dmin[355],dmin2[355],use[355],ant[355],reald[355],fol[355][355],sol=0;

 void BellmanFord()
 { int i,nod,nod2;

     for(i=1;i<=n;i++)
      dmin[i]=inf;

      q.push(s); dmin[s]=0; use[s]=1;

     while(!q.empty())
     { nod=q.front(); q.pop(); use[nod]=0;

         if (nod==d) continue;

         for(i=0;i<v[nod].size();i++)
         { nod2=v[nod][i];
           if (c[nod][nod2] && dmin[nod]+cst[nod][nod2]<dmin[nod2])
           { if (!use[nod2]) {q.push(nod2); use[nod2]=1;}
             dmin[nod2]=dmin[nod]+cst[nod][nod2];
           }
         }

     }
 }

 int Dijkstra()
 { int i,x,nod,nod2,n1,n2,cost,road,res,newc;

    memset(ant,0,sizeof(ant));
    memset(reald,0,sizeof(reald));
    for(i=1;i<=n;i++)
     dmin2[i]=inf;

     dmin2[s]=0;

    el.nod=s; el.cost=0;
    heap.push(el);

    while(!heap.empty())
    { el=heap.top(); heap.pop();
      nod=el.nod; cost=el.cost;

      if (nod==d || cost!=dmin2[nod]) continue;

       for(i=0;i<v[nod].size();i++)
       {  nod2=v[nod][i];

          if (fol[nod][nod2]==c[nod][nod2]) continue;
           newc=cost+dmin[nod]+cst[nod][nod2]-dmin[nod2];

         if (newc<dmin2[nod2])
         { el.nod=nod2; el.cost=newc;
            heap.push(el);
            reald[nod2]=reald[nod]+cst[nod][nod2];
             dmin2[nod2]=newc;
            ant[nod2]=nod;
         }

       }
    }

   memcpy(dmin,reald,sizeof(dmin));

    x=d; res=inf;

    while(ant[x])
    {  res=min(res,c[ant[x]][x]-fol[ant[x]][x]);
      x=ant[x];
    }

    sol+=res*reald[d];

    x=d;

    while(ant[x])
    {   fol[ant[x]][x]+=res;
        fol[x][ant[x]]-=res;
      x=ant[x];
    }

  return dmin[d]!=inf;
 }
int main()
{ int i,x,y,cap,ct,fin;
    f>>n>>m>>s>>d;

    for(i=1;i<=m;i++)
    { f>>x>>y>>cap>>ct;
        v[x].push_back(y);
        v[y].push_back(x);
        c[x][y]=cap;
        cst[x][y]=ct;
        cst[y][x]=-ct;
    }

    BellmanFord();

   do {fin=Dijkstra();}
   while(fin);

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