#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

#pragma GCC optimize("Ofast")

using namespace std;
using namespace __gnu_pbds;

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

int random(int st, int dr)
{
    uniform_int_distribution<int> dist(st, dr);
    return dist(rng);
}

template <typename t>
using ordered_set = tree<t, null_type, less<t>, rb_tree_tag, tree_order_statistics_node_update>;

const int mod = 1e9 + 7;
struct Mint
{
    int val;
    Mint(int x = 0)
    {
        val = x % mod;
    }
    Mint(long long x)
    {
        val = x % mod;
    }
    Mint operator+(Mint oth)
    {
        return val + oth.val;
    }
    Mint operator-(Mint oth)
    {
        return val - oth.val + mod;
    }
    Mint operator*(Mint oth)
    {
        return 1ll * val * oth.val;
    }
    void operator+=(Mint oth)
    {
        val = (*this + oth).val;
    }
    void operator-=(Mint oth)
    {
        val = (*this - oth).val;
    }
    void operator*=(Mint oth)
    {
        val = (*this * oth).val;
    }
};

Mint powmod(int a, int b)
{
    if (b == 0)
    {
        return 1;
    }
    if (b % 2 == 1)
    {
        return powmod(a, b - 1) * a;
    }
    Mint p = powmod(a, b / 2);
    return p * p;
}

/*
                 .___                 __                 __           .__
  ____  ____   __| _/____     _______/  |______ ________/  |_  ______ |  |__   ___________   ____
_/ ___\/  _ \ / __ |/ __ \   /  ___/\   __\__  \\_  __ \   __\/  ___/ |  |  \_/ __ \_  __ \_/ __ \
\  \__(  <_> ) /_/ \  ___/   \___ \  |  |  / __ \|  | \/|  |  \___ \  |   Y  \  ___/|  | \/\  ___/
 \___  >____/\____ |\___  > /____  > |__| (____  /__|   |__| /____  > |___|  /\___  >__|    \___  >
     \/           \/    \/       \/            \/                 \/       \/     \/            \/
*/

#define cin fin
#define cout fout

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

const int inf = 1e9;

struct edge
{
    int u, v, cap, flow, cost;
};

struct MCMF
{
    vector<vector<int>> g;
    vector<edge> edg;
    vector<int> potential;
    int n, s, t;
    MCMF(int n, int s, int t) : n(n), s(s), t(t)
    {
        g.resize(n + 1);
        potential.resize(n + 1);
    }
    void add_edge(int u, int v, int cap, int cost)
    {
        int sz = edg.size();
        edg.push_back({u, v, cap, 0, cost});
        edg.push_back({v, u, 0, 0, -cost});
        g[u].push_back(sz);
        g[v].push_back(sz + 1);
    }
    void bellman()
    {
        fill(potential.begin(), potential.end(), inf);
        potential[s] = 0;
        for (int i = 1; i < n; ++i)
        {
            for (auto x : edg)
            {
                if (x.cap - x.flow == 0)
                {
                    continue;
                }
                potential[x.v] = min(potential[x.v], potential[x.u] + x.cost);
            }
        }
    }
    pair<int, int> dijkstra()
    {
        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
        vector<int> dist(n + 1, inf);
        vector<int> par(n + 1);
        dist[s] = 0;
        pq.push({0, s});
        while (!pq.empty())
        {
            auto [cost, qui] = pq.top();
            pq.pop();
            if (dist[qui] != cost)
            {
                continue;
            }
            for (auto i : g[qui])
            {
                auto e = edg[i];

                if (e.cap - e.flow == 0)
                {
                    continue;
                }

                int lying = e.cost + potential[e.u] - potential[e.v];

                assert(lying >= 0);

                if (dist[e.u] + lying < dist[e.v])
                {
                    dist[e.v] = dist[e.u] + lying;
                    par[e.v] = i;
                    pq.push({dist[e.v], e.v});
                }
            }
        }
        if (dist[t] == inf)
        {
            return {0, inf};
        }

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

        pair<int, int> ans;

        int frog = t;
        int push = inf;
        while (frog != s)
        {
            int x = par[frog];
            push = min(push, edg[x].cap - edg[x].flow);
            frog = edg[x].u;
        }

        ans.first = push;

        frog = t;
        while (frog != s)
        {
            int x = par[frog];
            edg[x].flow += push;
            edg[x ^ 1].flow -= push;
            ans.second += push * edg[x].cost;
            frog = edg[x].u;
        }

        return ans;
    }
    pair<int, int> flow()
    {
        bellman();
        pair<int, int> ans;
        while (true)
        {
            pair<int, int> add = dijkstra();
            if (add.first == 0)
            {
                return ans;
            }
            ans.first += add.first;
            ans.second += add.second;
        }
    }
};

int32_t main()
{
    cin.tie(nullptr)->sync_with_stdio(false);
    int n, m, s, d;
    cin >> n >> m >> s >> d;
    MCMF G(n, s, d);
    for (int i = 1; i <= m; ++i)
    {
        int a, b, cap, cost;
        cin >> a >> b >> cap >> cost;
        G.add_edge(a, b, cap, cost);
    }
    cout << G.flow().second << '\n';
}
/*
I cannot take this anymore
Saying everything I've said before
All these words, they make no sense
I find bliss in ignorance
Less I hear, the less you say
You'll find that out anyway
Just like before

Everything you say to me
(Takes me one step closer to the edge)
(And I'm about to break)
I need a little room to breathe
(Cause I'm one step closer to the edge)
(I'm about to break)
*/