#include<fstream>
#include<vector>
#include<queue>
using namespace std;
ifstream fin("fmcm.in");
ofstream fout("fmcm.out");
int n,m,S,D,x,y,c,z,minim;
int T[351],f[351],d[351];
int C[351][351],flux[351][351],Z[351][351];
queue<int> coada;
vector<int> L[351];
int bellman(){
    int nod;
    for(int i=2;i<=n;i++){
        f[i]=0;
        d[i]=2000000000;
    }
    coada.push(S);
    T[S]=0;
    f[S]=1;
    d[S]=0;
    int found=0;
    while(!coada.empty()){
        x=coada.front();
        coada.pop();
        f[x]=0;
        for(int i=0;i<L[x].size();i++){
            nod=L[x][i];
            if(d[nod]>d[x]+Z[x][nod] && C[x][nod]>flux[x][nod]){
                d[nod]=d[x]+Z[x][nod];
                T[nod]=x;
                if(f[nod]==0){
                    coada.push(nod);
                    f[nod]=1;
                    if(nod==D)
                        found=1;
                }
            }
        }
    }
    return found;
}

int main(){
    fin>>n>>m>>S>>D;
    for(int i=1;i<=m;i++){
        fin>>x>>y>>c>>z;
        L[x].push_back(y);
        L[y].push_back(x);
        C[x][y]=c;
        C[y][x]=0;
        Z[x][y]=z;
        Z[y][x]=-z;
    }
    int nod,cost=0;
    while(bellman()){
        nod=D;
        minim=2000000000;
        while(nod!=S){
            minim=min(minim,C[T[nod]][nod]-flux[T[nod]][nod]);
            nod=T[nod];
        }
        nod=D;
        while(nod!=S){
            flux[T[nod]][nod]+=minim;
            flux[nod][T[nod]]-=minim;
            cost+=minim*d[D];
            nod=T[nod];
        }
    }
    fout<<cost;
    return 0;
}