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

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

#define dim 351

int n,m,sursa,dest;
vector<vector<int>> la;
int capacitate[dim][dim], pret[dim][dim];
int parinte[dim], pretBellman[dim], pretDijs[dim], cost[dim];
int flux_min;

void bellmanFord()
{
    queue<int>coada;
    vector<bool>viz(dim, false);
    viz[sursa]=true;
    pretBellman[sursa]=0;
    coada.push(sursa);
    while (!coada.empty())
    {
        int u=coada.front();
        coada.pop();
        viz[u] = false;
        for (int i=0; i < la[u].size(); i++)
        {
            int v=la[u][i];
            int pretV=pret[u][v];
            if (capacitate[u][v] != 0)
            {
                if (pretBellman[v] > pretBellman[u] + pretV)
                {
                    pretBellman[v]= pretBellman[u] + pretV;
                    if (viz[v]==0)
                    {
                        coada.push(v);
                        viz[v] = true;
                    }
                }
            }
        }
    }
}

bool dijkstra ()
{
    priority_queue <pair <int, int>, vector <pair <int, int>>, greater <pair <int, int>>> coada;
    for (int i = 1; i <= n; i++)
        pretDijs[i] = INT_MAX;
    pretDijs[sursa]=0;
    cost[sursa]=0;
    coada.push({0, sursa});
    while(!coada.empty())
    {
        pair<int,int> perecheCurenta = coada.top();
        coada.pop();
        int curr=perecheCurenta.second;
        if (pretDijs[curr] == perecheCurenta.first)
            for (int j=0; j < la[perecheCurenta.second].size(); j++)
            {
                auto v=la[curr][j];
                auto pretV=pret[curr][v];
                auto capacitateV=capacitate[curr][v];
                if (capacitateV > 0)
                    if (pretDijs[v] > pretDijs[curr] + pretV + pretBellman[curr] - pretBellman[v])
                    {
                        pretDijs[v] = pretDijs[curr] + pretV + pretBellman[curr] - pretBellman[v];
                        coada.push({pretDijs[v], v});
                        cost[v]= cost[curr] + pretV;
                        parinte[v]=curr;
                    }
            }
    }
    for (int i=1; i<=n; i++)
        pretBellman[i]=cost[i];
    if (pretDijs[dest] == INT_MAX)
        return false;
    int flux_curent=INT_MAX;
    int temp=dest;
    while (temp != sursa)
    {
        flux_curent=min(flux_curent, capacitate[parinte[temp]][temp]);
        temp=parinte[temp];
    }
    temp=dest;
    while (temp != sursa)
    {
        capacitate[parinte[temp]][temp]-=flux_curent;
        capacitate[temp][parinte[temp]]+=flux_curent;
        temp=parinte[temp];
    }
    flux_min+= flux_curent * cost[dest];
    return true;
}

void rezolvare()
{
    bellmanFord();
    int rez=dijkstra();
    while(rez)rez=dijkstra();
    fout << flux_min;
}
int main()
{
    fin >> n >> m >> sursa >> dest;
    la.resize(n + 1);
    for(int i=1;i<=m;i++)
    {
        int x,y,c,z;
        fin>>x>>y>>c>>z;
        la[x].push_back(y);
        la[y].push_back(x);
        capacitate[x][y]=c;
        pret[x][y]=z;
        pret[y][x]=-z;
    }
    rezolvare();
    return 0;
}