#include <fstream>
#include <queue>
#include <vector>
using namespace std;
ifstream fin("fmcm.in");
ofstream fout("fmcm.out");

int n, m, nod, sol, s, d, x, y, c, z, i, j, capacitate[360][360], cost[360][360], flux[360][360], f[360], t[360];
int v[360], dist[360];
vector <int> a[360];
deque <int> q;

int BellmanFord(){
    /// cautam drumul de cost minim de la s la d
    /// pe fiecare muchie trebuie sa avem capacitate > flux
    int nr, vecin;
    int ok=0;
    for(int ii=1; ii<=n; ii++){
        t[ii]=0;
        v[ii]=0;
        dist[ii]=1000000000;
    }
    q.clear();
    q.push_back(s);
    v[s]=1;
    dist[s]=0;
    while(!q.empty()){
        nr=q.front();
        q.pop_front();
        v[nr]=0;
        for(int ii=0; ii<a[nr].size(); ii++){
            vecin=a[nr][ii];
            if(dist[vecin]>dist[nr]+cost[nr][vecin] && flux[nr][vecin]<capacitate[nr][vecin]){
                dist[vecin]=dist[nr]+cost[nr][vecin];
                t[vecin]=nr;
                if(v[vecin]==0){
                    v[vecin]=1;
                    q.push_back(vecin);
                    if(vecin==d){
                        ok=1;
                    }
                }
            }
        }
    }
    return ok;
}


int main(){
    fin>>n>>m>>s>>d;
    for(i=1; i<=m; i++){
        fin>>x>>y>>c>>z;
        a[x].push_back(y);
        a[y].push_back(x);
        capacitate[x][y]=c;
        cost[x][y]=z;
        cost[y][x]=-z;
    }
    while(BellmanFord()){
        nod=d;
        int minim=capacitate[ t[nod] ][nod]-flux[ t[nod] ][nod];
        while(t[nod]){
            minim=min(minim, capacitate[ t[nod] ][nod]-flux[ t[nod] ][nod]);
            nod=t[nod];
        }
        nod=d;
        while(t[nod]){
            flux[ t[nod] ][nod]+=minim;
            flux[nod][ t[nod] ]-=minim;
            nod=t[nod];
        }
        int CostDrum=dist[d];
        sol+=minim*CostDrum;
    }
    fout<<sol;
}