#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],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;

    memset(ant,0,sizeof(ant));

    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] && cost+dmin[nod]+cst[nod][nod2]-dmin[nod2]<dmin2[nod2])
         { el.nod=nod2;
           el.cost=cost+dmin[nod]+cst[nod][nod2]-dmin[nod2];
            heap.push(el);
             dmin2[nod2]=cost+dmin[nod]+cst[nod][nod2]-dmin[nod2];
            ant[nod2]=nod;
         }

       }
    }

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

     x=d; res=inf;
    road=0;
    while(ant[x])
    { n1=ant[x]; n2=x;
        road+=cst[n1][n2];
        res=min(res,c[n1][n2]-fol[n1][n2]);
      x=ant[x];
    }

    sol+=res*road;

    x=d;

    while(ant[x])
    { n1=ant[x]; n2=x;
        fol[n1][n2]+=res;
        fol[n2][n1]-=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;
}