#include<fstream>
#include<vector>
#include<algorithm>
#include<queue>
#include<bitset>
using namespace std;

ifstream cin("fmcm.in");
ofstream cout("fmcm.out");

class MCMF
{
    private: int n,s,t; vector<int> pi,real,dist,p; const int INF = 1 << 28;
    struct muchie{int from,to,cap,cost,flow;};
    vector<vector<int>> vecini; vector<muchie> muchii;

    void bf()
    {
        vector<bool> inq(n + 1,false); inq[s] = 1; queue<int> q; q.push(s); fill(pi.begin(),pi.end(),INF); pi[s] = 0;
        while(!q.empty())
            {
                int v = q.front(); q.pop(); inq[v] = 0;
                for(auto it : vecini[v])
                    {
                        muchie &h = muchii[it];
                        if((h.cap - h.flow) > 0)
                            {
                                if(pi[h.to] > pi[v] + h.cost)
                                    {
                                        pi[h.to] = pi[v] + h.cost;
                                        if(!inq[h.to])
                                            {
                                                inq[h.to] = 1;
                                                q.push(h.to);
                                            }
                                    }
                            }
                    }
            }
    }

    bool dijkstra()
    {
        priority_queue<pair<int,int>,vector<pair<int,int>> ,greater<pair<int,int>>> pq;
        fill(dist.begin(),dist.end(),INF); dist[s] = 0; fill(p.begin(),p.end(),-1); pq.push({0,s}); real[s] = 0;
        while(!pq.empty())
            {
                int v = pq.top().second,cst = pq.top().first; pq.pop();
                if(dist[v] != cst) continue;
                for(auto it : vecini[v])
                    {
                        muchie &h = muchii[it];
                        if((h.cap - h.flow) > 0)
                            {
                                int false_cost = dist[v] + h.cost + pi[v] - pi[h.to];
                                if(dist[h.to] > false_cost)
                                    {
                                        dist[h.to] = false_cost;
                                        real[h.to] = real[v] + h.cost;
                                        pq.push({false_cost,h.to}); p[h.to] = it;
                                    }
                            }
                    }
            }

        return (p[t] != -1);
    }

    public: MCMF(int _n,int _s,int _t)
    {
        n = _n; s = _s; t = _t;
        pi.resize(n + 1); real.resize(n + 1); dist.resize(n + 1);
        vecini.resize(n + 1); p.resize(n + 1);
    }

    void add(int a,int b,int c,int d)
    {
        muchii.push_back({a,b,c,d,0});  vecini[a].emplace_back(muchii.size() - 1);
        muchii.push_back({b,a,0,-d,0}); vecini[b].emplace_back(muchii.size() - 1);
    }

    pair<int,int> go()
    {
        pair<int,int> ans; bf();
        while(dijkstra())
            {
                int delta = 1 << 28;
                for(int v = p[t]; v != -1 ; v = p[muchii[v].from]) delta = min(delta,muchii[v].cap - muchii[v].flow);
                for(int v = p[t]; v != -1 ; v = p[muchii[v].from])
                    {
                        muchii[v].flow     += delta;
                        muchii[v ^ 1].flow -= delta;
                    }

                ans.first += delta;
                ans.second += delta * real[t];
                pi = real;
            }

        return ans;
    }
};

int main()
{
    int n,m,s,t,a,b,c,d; cin >> n >> m >> s >> t;
    MCMF graf(n,s,t); while(m--)
    {
        cin >> a >> b >> c >> d;
        graf.add(a,b,c,d);
    }

    pair<int,int> ans = graf.go(); cout << ans.second;
}