#include<fstream>
#include<queue>
#include<vector>
#include<cstring>
using namespace std;
ifstream fin("fmcm.in");
ofstream fout("fmcm.out");
int n,m,S,D,x,y,c,z,minim,s;
int T[351],f[351],d[351];
int C[351][351],flux[351][351],cost[351][351];
queue<int> coada;
vector<int> L[351];

int bellman(){
    memset(f,0,sizeof(f));
    for(int i=1;i<=n;i++)
        d[i]=10000000;
    d[S]=0;
    coada.push(S);

    int ok=0;

    while(!coada.empty()){
        int nod=coada.front();
        coada.pop();
        f[nod]=0;
        if(nod==D)
            ok=1;

        for(int i=0;i<L[nod].size();i++){
            int vecin=L[nod][i];
            if(C[nod][vecin]>flux[nod][vecin] && d[vecin]>d[nod]+cost[nod][vecin]){
                d[vecin]=d[nod]+cost[nod][vecin];
                T[vecin]=nod;
                if(f[vecin]==0){
                    f[vecin]=1;
                    coada.push(vecin);
                }
            }
        }
    }

    return ok;
}

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;
        cost[x][y]=z;
        cost[y][x]=-z;
    }

    while( bellman() ){
        int 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;
            nod=T[nod];
        }
        s+=minim*d[D];
    }
    fout<<s;
    return 0;
}