#include <bits/stdc++.h>
using namespace std;
ifstream fin("fmcm.in");
ofstream fout("fmcm.out");
class Graph
{
private:
    int n, s, t;
    vector<vector<int>> ad, cap, cst;
    vector<int> pot, dst;
    void bellman()
    {
        fill(pot.begin(), pot.end(), 1e9);
        pot[s] = 0;
        vector<bool> inQueue(n + 1);
        inQueue[s] = true;
        queue<int> q;
        q.push(s);
        while (!q.empty())
        {
            int node = q.front();
            q.pop();
            inQueue[node] = false;
            for (int nghb : ad[node])
                if (cap[node][nghb] && pot[node] + cst[node][nghb] < pot[nghb])
                {
                    pot[nghb] = pot[node] + cst[node][nghb];
                    if (!inQueue[nghb])
                    {
                        q.push(nghb);
                        inQueue[nghb] = true;
                    }
                }
        }
    }
    bool dijkstra(vector<int>& dp, vector<int>& father)
    {
        fill(dp.begin(), dp.end(), 1e9);
        dp[s] = dst[s] = 0;
        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
        pq.emplace(0, s);
        vector<bool> vis(n + 1);
        while (!pq.empty())
        {
            int node = pq.top().second;
            pq.pop();
            if (node != t && !vis[node])
            {
                vis[node] = true;
                for (int nghb : ad[node])
                    if (cap[node][nghb] && dp[node] + cst[node][nghb] + pot[node] - pot[nghb] < dp[nghb])
                    {
                        dp[nghb] = dp[node] + cst[node][nghb] + pot[node] - pot[nghb];
                        father[nghb] = node;
                        dst[nghb] = dst[node] + cst[node][nghb];
                        pq.emplace(dp[nghb], nghb);
                    }
            }
        }
        pot = dst;
        return dp[t] != 1e9;
    }
public:
    Graph(int n, int s, int t) :
        n(n), s(s), t(t), ad(n + 1),
        cap(n + 1, vector<int>(n + 1)),
        cst(n + 1, vector<int>(n + 1)),
        pot(n + 1), dst(n + 1) { }
    void addEdge(int x, int y, int z, int t)
    {
        ad[x].push_back(y);
        ad[y].push_back(x);
        cap[x][y] = z;
        cst[x][y] = +t;
        cst[y][x] = -t;
    }
    int minCostMaxFlow()
    {
        int cost = 0;
        vector<int> dp(n + 1);
        vector<int> father(n + 1);
        bellman();
        while (dijkstra(dp, father))
        {
            int flow = 1e9;
            for (int i = t; i != s; i = father[i])
                flow = min(flow, cap[father[i]][i]);
            for (int i = t; i != s; i = father[i])
            {
                cost += flow * cst[father[i]][i];
                cap[father[i]][i] -= flow;
                cap[i][father[i]] += flow;
            }
        }
        return cost;
    }
};
int main()
{
    int n, m, s, t;
    fin >> n >> m >> s >> t;
    Graph graph(n, s, t);
    for (int i = 0; i < m; i++)
    {
        int x, y, z, t;
        fin >> x >> y >> z >> t;
        graph.addEdge(x, y, z, t);
    }
    fout << graph.minCostMaxFlow() << '\n';
    return 0;
}