#include <bits/stdc++.h>
#define Nmax 355
#define pii pair<int, int>
#define mp make_pair
#define fr first
#define sc second

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

vector <int> v[Nmax];
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
int n, m, S, D, flux, co[Nmax][Nmax], c[Nmax][Nmax];
int t[Nmax], be[Nmax], di[Nmax], d[Nmax];
long long cost;
void bellmanford()
{
    queue <int> q;
    for(int i=1;i<=n;i++)
    {
        be[i]=INT_MAX;
        t[i]=0;
    }

    q.push(S);
    t[S]=1;
    be[S]=0;

    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        t[u]=0;

        for(auto it:v[u])
            if(c[u][it] && be[it] > be[u] + co[u][it])
            {
                if(!t[it])
                {
                    q.push(it);
                    t[it]=1;
                }
                be[it] = be[u] + co[u][it];
            }
    }
}

bool dijkstra()
{
    for(int i=1;i<=n;i++)
    {
        di[i]=INT_MAX;
        t[i]=0;
    }

    di[S]=0;
    d[S]=0;
    pq.push(mp(0, S));
    t[S]=-1;

    while(!pq.empty())
    {
        pii u=pq.top();
        pq.pop();

        if(di[u.sc]!=u.fr)
            continue;

        for(auto it:v[u.sc])
            if(c[u.sc][it])
            {
                int comuchie = co[u.sc][it] + be[u.sc] - be[it];
                if(di[it] > di[u.sc] + comuchie)
                {
                    d[it] = d[u.sc] + co[u.sc][it];

                    di[it] = di[u.sc] + comuchie;

                    t[it]=u.sc;

                    pq.push(mp(di[it], it));
                }
            }
    }

    if(!t[D])
        return 0;

    for(int i=1;i<=n;i++)
        be[i]=d[i];

    int fm=INT_MAX, drum=0;

    for(int i=D; i!=S; i=t[i])
    {
        drum=drum+co[t[i]][i];
        fm=min(fm, c[t[i]][i]);
    }

    flux += fm;
    cost = cost + (long long)fm *drum;

    for(int i=D;i!=S;i=t[i])
    {
        c[t[i]][i]-=fm;
        c[i][t[i]]+=fm;
    }

    return 1;
}
int main()
{
    fin >> n >> m >> S >> D;
    for(int i=1; i<=m; i++)
    {
        int x, y;
        fin >> x >> y;
        v[x].push_back(y);
        v[y].push_back(x);
        fin >> c[x][y] >> co[x][y];
        co[y][x]=-co[x][y];
    }
    bellmanford();
    while(dijkstra());
    fout << cost;
    return 0;
}