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

class Task {
 public:
    void solve() {
        read_input();
        print_output(get_result());
    }

 private:
    int n, m, s, d;

    vector<vector<int>> adj;
    vector<vector<int>> cap;

    vector<vector<int>> cost;
    vector<vector<int>> flow;

    void read_input() {
        ifstream fin("fmcm.in");
        fin >> n >> m >> s >> d;

        adj.resize(n + 1);
        cap.resize(n + 1, vector<int>(n + 1, 0));

        cost.resize(n + 1, vector<int>(n + 1, 0));
        flow.resize(n + 1, vector<int>(n + 1, 0));

        for (int i = 0; i < m; ++i) {
            int x, y, c, z;
            fin >> x >> y >> cap[x][y] >> cost[x][y];

            adj[x].push_back(y);
            adj[y].push_back(x);

            cost[y][x] = -cost[x][y];
        }

        fin.close();
    }

    bool dijkstra(vector<int>& parent, vector<int>& dist, vector<int>& potential) {
        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
        dist.assign(n + 1, INT32_MAX);

        parent.assign(n + 1, -1);
        dist[s] = 0;

        pq.push({0, s});

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

            if (distNode > dist[node]) {
                continue;
            }

            for (int next : adj[node]) {
                int newDist = dist[node] + cost[node][next] + potential[node] - potential[next];
                if (cap[node][next] > flow[node][next] && newDist < dist[next]) {
                    dist[next] = newDist;
                    parent[next] = node;
                    pq.push({newDist, next});
                }
            }
        }

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

        return dist[d] < INT32_MAX;
    }

    int get_result() {
        vector<int> parent(n + 1);
        vector<int> dist(n + 1);

        vector<int> potential(n + 1, 0);
        int max_flow = 0, min_cost = 0;

        while (dijkstra(parent, dist, potential)) {
            int path_flow = INT32_MAX;
            for (int v = d; v != s; v = parent[v]) {
                int u = parent[v];
                path_flow = min(path_flow, cap[u][v] - flow[u][v]);
            }

            for (int v = d; v != s; v = parent[v]) {
                int u = parent[v];
                flow[u][v] += path_flow;

                flow[v][u] -= path_flow;
                min_cost += path_flow * cost[u][v];
            }

            max_flow += path_flow;
        }

        return min_cost;
    }

    void print_output(int result) {
        ofstream fout("fmcm.out");
        fout << result << "\n";
        fout.close();
    }
};

int main() {
    ios::sync_with_stdio(false);
    auto* task = new (nothrow) Task();

    if (!task) {
        cerr << "new failed\n";
        return -1;
    }

    task->solve();
    delete task;

    return 0;
}