#include <bits/stdc++.h>
#define NMAX 351
using namespace std;

int capacitate[NMAX][NMAX], cost[NMAX][NMAX], flux[NMAX][NMAX], parent[NMAX];
vector<vector<int>> graph = vector<vector<int>>(NMAX, vector<int>());
ifstream fin("fmcm.in");    ofstream fout("fmcm.out");
int n, m, s, d , cost_minim = 0, flow;

vector<int> dist;
struct comp{
    bool operator()(int a, int b){
        return dist[a] > dist[b];
    }
};

priority_queue<int, vector<int>, comp> pq;

bool Dijkstra(){
    vector<bool> inQueue = vector<bool>(n+1, false);
    dist = vector<int>(n+1, INT_MAX);   dist.at(s) = 0;
    pq.push(s);
    while(!pq.empty()){
        int p = pq.top();
        pq.pop();
        inQueue.at(p) = false;

        for(auto& kid:graph.at(p)){
            if(capacitate[p][kid] == flux[p][kid]) continue;

            int d = dist.at(p) + cost[p][kid];
            if(dist.at(kid)>d){
                dist.at(kid) = d;
                parent[kid] = p;
                if(inQueue.at(kid)==false){
                    inQueue.at(kid) = true;
                    pq.push(kid);
                }
            }
        }
    }
    if(dist.at(d)==INT_MAX) return false;
    return true;
}
int main()
{
    fin>>n>>m>>s>>d;
    int x, y, c, z;
    for(int i=1; i<=m; i++){
        fin>>x>>y>>c>>z;
        graph[x].push_back(y);
        graph[y].push_back(x);
        capacitate[x][y] = c;
        cost[x][y] = z;
        cost[y][x] = -z;
    }

    while(Dijkstra()){
        flow = INT_MAX;

        for(int i=d; i!=s; i=parent[i]) flow = min(flow, capacitate[parent[i]][i] - flux[parent[i]][i]);

        for(int i=d; i!=s; i=parent[i]){
            flux[parent[i]][i] += flow;
            flux[i][parent[i]] -= flow;
            cost_minim += flow*cost[parent[i]][i];
        }
    }

    fout<<cost_minim;
}