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

using namespace std;

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;
        costs[b][a] = -cost;
    }
};

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;

    queue<int> q;
    q.push(source);

    vector<bool> in_q(g.Size(), false);
    in_q[source] = true;

    while (!q.empty()) {
        auto node = q.front();
        q.pop();
        in_q[node] = false;

        for (int next = 0; next < g.Size(); next += 1) {
            if (g.capacity[node][next] <= 0) {
                continue;
            }
            if (costs[node] + g.costs[node][next] < costs[next]) {
                costs[next] = costs[node] + g.costs[node][next];
                pred[next] = node;
                if (!in_q[next]) {
                    q.push(next);
                    in_q[next] = true;
                }
            }
        }
    }
    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];
        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;
}