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

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

constexpr int NMAX = 355;

struct muchie
{
    int from,to,cap,cost,flow;
};

vector<int> vecini[NMAX]; vector<muchie> muchii;
int dist[NMAX],pi[NMAX],real[NMAX],t[NMAX];
bitset<NMAX> inq;

void bf(int s,int e)
{
    memset(pi,0x3f,sizeof(pi)); pi[s] = 0;
    queue<int> q; q.push(s); inq[s] = 1;
    while(!q.empty())
        {

            int v = q.front(); q.pop(); inq[v] = 1;
            for(auto it : vecini[v])
                {
                    if((muchii[it].cap - muchii[it].flow) <= 0) continue;
                    if(inq[muchii[it].to]) continue;
                    if(pi[muchii[it].to] > pi[v] + muchii[it].cost)
                        {
                            pi[muchii[it].to] = pi[v] + muchii[it].cost;
                            if(!inq[muchii[it].to])
                                {
                                    inq[muchii[it].to] = 1;
                                    q.push(muchii[it].to);
                                }
                        }

                }
        }

}

bool dijkstra(int s,int e)
{
    memset(dist,0x3f,sizeof(dist)); dist[s] = 0; memset(t,-1,sizeof(t));
    priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> pq; 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(false_cost < dist[h.to])
                                {
                                    real[h.to] = real[v] + h.cost;
                                    dist[h.to] = false_cost;
                                    pq.push({dist[h.to],h.to}); t[h.to] = it;
                                }
                        }
                }
        }

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

int main()
{

    int n,m,s,e,a,b,c,d; cin >> n >> m >> s >> e;
    for(int i = 0; i < m ; i++)
        {
            cin >> a >> b >> c >> d;
            muchii.push_back({a,b,c,d,0}); vecini[a].emplace_back(2 * i);
            muchii.push_back({b,a,0,-d,0}); vecini[b].emplace_back(2 * i + 1);
        }

    int ans = 0,flux = 0; bf(s,e);
    while(dijkstra(s,e))
        {
            int delta = 0x3f3f3f;
            for(int v = t[e]; v != -1 ; v = t[muchii[v].from]) delta = min(delta,muchii[v].cap - muchii[v].flow);
            for(int v = t[e]; v != -1 ; v = t[muchii[v].from])
                {
                    muchii[v].flow += delta;
                    muchii[v ^ 1].flow -= delta;
                }
            ans += delta * real[e];
            for(int i = 1; i <= n ; i++) pi[i] = real[i];
        }


    cout << ans;
}