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

using namespace std;

constexpr int kCostOffset = 2000;

struct Graph
{
    vector<vector<int>> capacity;
    vector<vector<int>> costs;

    Graph(int nodes)
        : capacity(nodes, vector<int>(nodes, 0)),
          costs(nodes, vector<int>(nodes, 0)) {}

    int Size() const { return capacity.size(); }

    void AddEdge(int a, int b, int cap, int cost)
    {
        capacity[a][b] = cap;
        costs[a][b] = cost + kCostOffset;
        costs[b][a] = -cost + kCostOffset;
    }
};

template <typename T>
using MinHeap = priority_queue<T, vector<T>, greater<T>>;

bool FindPaths(const Graph &g, int source, int dest, vector<int> &pred)
{
    pred.assign(g.Size(), -1);

    vector<int> costs(g.Size(), (1 << 30));
    costs[source] = 0;

    MinHeap<pair<int, int>> q;
    q.push({0, source});

    while (!q.empty()) {
        auto cost = q.top().first;
        auto node = q.top().second;
        q.pop();

        if (cost > costs[node]) {
            continue;
        }

        for (int next = 0; next < g.Size(); next += 1) {
            if (g.capacity[node][next] <= 0) {
                continue;
            }
            if (cost + g.costs[node][next] < costs[next]) {
                costs[next] = cost + g.costs[node][next];
                pred[next] = node;
                q.push({costs[next], next});
            }
        }
    }
    return pred[dest] != -1;
}

int MinCapacity(const Graph &g, int dest, const vector<int> &pred)
{
    int node = pred[dest];
    int cap = g.capacity[node][dest];

    while (node >= 0) {
        cap = min(cap, g.capacity[node][dest]);
        dest = node;
        node = pred[node];
    }
    return cap;
}

int FlowCost(Graph &g, int dest, const vector<int> &pred)
{
    int cap = MinCapacity(g, dest, pred);
    int node = pred[dest];
    int cost = 0;

    while (node >= 0) {
        cost += cap * (g.costs[node][dest] - kCostOffset);
        g.capacity[node][dest] -= cap;
        g.capacity[dest][node] += cap;

        dest = node;
        node = pred[node];
    }
    return cost;
}

int MinCostFlow(Graph &g, int source, int dest)
{
    int cost = 0;
    vector<int> pred;

    while (FindPaths(g, source, dest, pred)) {
        cost += FlowCost(g, dest, pred);
    }
    return cost;
}

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

    int nodes, edges, source, dest;
    fin >> nodes >> edges >> source >> dest;

    Graph graph(nodes);
    for (int i = 0; i < edges; i += 1) {
        int a, b, cap, cost;
        fin >> a >> b >> cap >> cost;
        graph.AddEdge(a - 1, b - 1, cap, cost);
    }

    auto cost = MinCostFlow(graph, source - 1, dest - 1);
    fout << cost << "\n";

    return 0;
}