#include <fstream>
#include <climits>
#include <cstring>
#include <vector>
#include <bitset>
#include <queue>
#include <set>
#define DIM 361
using namespace std;
ifstream f("fmcm.in");
ofstream g("fmcm.out");
int n,m,X,Y,sol;
int D[DIM],T[DIM],E[DIM],R[DIM];
int F[DIM][DIM],C[DIM][DIM],CT[DIM][DIM];

set<pair<int,int> > S;
queue<int> q;
bitset<DIM> viz;
vector<int> L[DIM];
vector<int>::iterator it;

int bellmanford(){
    int nod;
    q.push(X);
    for(int i=1;i<=n;i++) D[i]=INT_MAX,T[i]=-1;
    D[X]=0;
    viz[X]=1;

    while(!q.empty()){
        nod=q.front(),q.pop();
        viz[nod]=0;
        for(it=L[nod].begin();it!=L[nod].end();it++){
            if(C[nod][*it]>F[nod][*it] && D[nod]+CT[nod][*it]<D[*it]){
                D[*it]=D[nod]+CT[nod][*it];
                T[*it]=nod;
                if(!viz[*it]) q.push(*it),viz[*it]=1;
            }
        }
    }
}

int dijkstra(){
    int nod,ok=0;
    viz.reset();
    for(int i=1;i<=n;i++) E[i]=INT_MAX;
    E[X]=0,R[X]=0;
    memset(T,-1,sizeof(T));
    S.insert(make_pair(0,X));
    while(!S.empty()){
        nod=S.begin()->second;
        S.erase(S.begin());
        for(it=L[nod].begin();it!=L[nod].end();it++){
            if(E[*it]>E[nod]+CT[nod][*it]+D[*it]-D[nod] && C[nod][*it]>F[nod][*it]){
                E[*it]=E[nod]+CT[nod][*it]+D[*it]-D[nod];
                R[*it]=R[nod]+CT[nod][*it];
                if(*it==Y)
                    ok=1;
                S.insert(make_pair(E[*it],*it));
                T[*it]=nod;
            }
        }
        viz[nod]=1;
    }
    return ok;
}

int main(void){
    register int i,j,x,y,z,c;
    int minim;

    f>>n>>m>>X>>Y;
    for(i=1;i<=m;i++){
        f>>x>>y>>c>>z;
        C[x][y]=c;
        CT[x][y]=z;
        CT[y][x]=-z;
        L[x].push_back(y);
        L[y].push_back(x);
    }
    bellmanford();

    while(dijkstra()){
        x=Y;
        minim=INT_MAX;
        while(T[x]>0) minim=min(minim,C[T[x]][x]-F[T[x]][x]),x=T[x];
        x=Y;
        while(T[x]>0){
            F[T[x]][x]+=minim;
            F[x][T[x]]-=minim;
            x=T[x];
        }
        sol+=minim*R[Y];
    }
    g<<sol;
    f.close();
    g.close();
    return 0;
}