#include<fstream>
#include<cstring>
#include<vector>
#include<queue>

using namespace std;

ifstream fin("fmcm.in");
ofstream fout("fmcm.out");


#define NMAX 203
#define INF 1<<30
int N;

int D; int S;int From[NMAX];int dist[NMAX];int M;

vector<int> G[NMAX];

int C[NMAX][NMAX]; int F[NMAX][NMAX]; int Cost[NMAX][NMAX];int drum;

bool s[NMAX];

void Read() {

    fin >>N >> M>> S >> D;
    for(int i = 1; i <= M; ++i){
            int x, y, c, cap;
            fin >>x >>y >> cap >> c;
            G[x].push_back(y);
            G[y].push_back(x);
            C[x][y] = cap;
            Cost[x][y] = c;
            Cost[y][x] = -c;
        }

}

int BellmanFord(){

    memset(s, 0, sizeof(s));
    s[S] = true;
    queue<int> q;
    q.push(S);
    for(int i = 1; i <= N; ++i) dist[i] = INF, From[i] = -1;

    dist[S] = 0 ;
    while(!q.empty()){
        int nod = q.front();
        q.pop();
        for(int i = 0 ;i < G[nod].size(); ++i){
            int x = G[nod][i];
            if(C[nod][x] - F[nod][x] >0 && dist[nod] + Cost[nod][x] < dist[x]){
                dist[x] = dist[nod] + Cost[nod][x];
                From[x] = nod;
                if(s[x] == false)
                    s[x] = true, q.push(x);
            }
        }
        s[nod] = false;
    }

    if(dist[D] != INF){

        int vmin = INF;
        drum = 1;
        for(int i = D; i != S; i = From[i])
            vmin = min(vmin , C[From[i]][i] - F[From[i]][i] );

        for(int i = D; i != S; i = From[i])
            F[From[i]][i] += vmin, F[i][From[i]] -= vmin;
        return vmin * dist[D];//vmin = 1

    }
    return 0;
}

void Solve(){

    drum = 1;
    int rez = 0;

    while(drum){
        drum = 0;
        rez += BellmanFord();
    }

    fout << rez;

}


int main(){

    Read ();

    Solve ();

    return 0;

}