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

#define MAX 100000000

using namespace std;
ifstream in("fmcm.in");
ofstream out("fmcm.out");

int n, m, s, t, rez;
vector<vector<int>> l;
vector<vector<int>> cc, cost; //matricea de capacitati pe muchii si cea de costuri pe muchii
vector<int>tata;
vector<bool> viz;
vector<int> val; //val[i] = costul minim pana la nodul i


int bfs()
{
    queue<int> q;

    for(int i=0; i<=n; i++)
    {
        //costurile si vectorul de vizitati de resteaza la fiecare bfs
        viz[i] = 0;
        val[i] = MAX;
    }

    tata[s] = s;
    viz[s] = 1;
    val[s] = 0;

    q.push(s);

    while(!q.empty())
    {
        int nod = q.front();
        q.pop();
        viz[nod] = 0;
        for(int i=0; i<l[nod].size(); i++)
        {
            int nodNou = l[nod][i];
            if(cc[nod][nodNou] > 0 && val[nodNou] > val[nod] + cost[nod][nodNou])
            {
                val[nodNou] = val[nod] + cost[nod][nodNou]; //actualizez costul cu cel optim
                tata[nodNou] = nod;
                if(viz[nodNou] == 0)
                {
                    q.push(nodNou);
                    viz[nodNou] = 1;
                }
            }
        }
    }

    return val[t];
}

void costMin()
{
    int costFlux = bfs(); //costul minim curent pt a ajunge in t

    while(costFlux != MAX) //cat timp se poate obtine un astfel de cost
    {
        int flux = MAX;

        int nod = t;

        //calculez fluxul parcurgand reteaua transpusa
        while(nod != s)
        {
            flux = min(flux, cc[tata[nod]][nod]);
            nod = tata[nod];
        }

        nod = t;

        //resetez fluxurile prin retea
        while(nod != s)
        {
            cc[tata[nod]][nod] -= flux;
            cc[nod][tata[nod]] += flux;
            nod = tata[nod];
        }
        rez += flux * costFlux; //cantitatea maxima de flux * costul minim

        costFlux = bfs();
    }
}

int main()
{
    in>>n>>m>>s>>t;

    tata.resize(n+1, 0);
    val.resize(n+1);
    viz.resize(n+1);
    l.resize(n+1);
    cc.resize(n+1);
    cost.resize(n+1);

    for(int i=0; i<=n; i++)
    {
        cc[i].resize(n+1);
        cost[i].resize(n+1);
    }

    int x, y, z, c;
    for(int i=0; i<m; i++)
    {
        in>>x>>y>>z>>c;
        l[x].push_back(y);
        l[y].push_back(x);
        cc[x][y] = z;
        cost[x][y] = c;
        cost[y][x] = -c;
    }

    costMin();

    out<<rez;

    return 0;
}