#include <iostream>
#include <fstream>
#include <vector>
#include <queue>

#define pii pair <int, int>

using namespace std;

string filename = "fmcm";
#ifdef LOCAL
    ifstream fin("input.in");
    ofstream fout("output.out");
#else
    ifstream fin(filename + ".in");
    ofstream fout(filename + ".out");
#endif

const int NMAX = 350;
const int INF = 1e9;

int n, m, s, d;
vector <pii> adj[NMAX + 1];

int flow[NMAX + 1][NMAX + 1];

bool inQ[NMAX + 1];
int aux[NMAX + 1];

void BF(){
    for(int i = 1; i <= n; i++){
        aux[i] = INF;
    }

    queue <int> Q;
    Q.push(s);
    aux[s] = 0;
    inQ[s] = true;

    while(!Q.empty()){
        int node = Q.front();
        Q.pop();

        inQ[node] = false;

        for(pii vec : adj[node]){
            if(flow[node][vec.first] > 0 && aux[node] + vec.second < aux[vec.first]){
                aux[vec.first] = aux[node] + vec.second;
                if(!inQ[vec.first]){
                    Q.push(vec.first);
                }
            }
        }
    }
}


int parent[NMAX + 1];
int dist[NMAX + 1];
int real[NMAX + 1];

bool DJK(){
    for(int i = 1; i <= n; i++){
        parent[i] = 0;
        dist[i] = real[i] = INF;
    }

    priority_queue <pii, vector <pii>, greater <pii>> pq;
    dist[s] = real[s] = 0;
    pq.push({dist[s], s});

    while(!pq.empty()){
        int node = pq.top().second, val = pq.top().first;
        pq.pop();

        if(dist[node] == val){
            for(pii vec : adj[node]){
                if(flow[node][vec.first] > 0 && dist[node] + vec.second + aux[node] - aux[vec.first] < dist[vec.first]){
                    dist[vec.first] = dist[node] + vec.second + aux[node] - aux[vec.first];
                    real[vec.first] = real[node] + vec.second;

                    parent[vec.first] = node;
                    pq.push({dist[vec.first], vec.first});
                }
            }
        }
    }

    return (dist[d] != INF);
}

int main(){

    fin >> n >> m >> s >> d;

    for(int i = 1; i <= m; i++){
        int a, b, c, d;
        fin >> a >> b >> c >> d;
        adj[a].push_back({b, +d});
        adj[b].push_back({a, -d});
        flow[a][b] = c;
    }

    BF();

    int maxFlow = 0;
    int minCost = 0;

    while(DJK()){
        int node = d, mini = INF;
        while(node != s){
            mini = min(mini, flow[parent[node]][node]);
            node = parent[node];
        }

        if(mini == 0){
            continue;
        }

        node = d;
        while(node != s){
            flow[parent[node]][node] -= mini;
            flow[node][parent[node]] += mini;
            node = parent[node];
        }

        maxFlow += mini;
        minCost += mini * real[d];

        for(int i = 1; i <= n; i++){
            aux[i] = dist[i];
        }
    }

    fout << minCost << '\n';

    return 0;
}