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

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

#define INFINITY (1<<30)

int N, M,S,D;
vector<int> L[360];
queue<int> Q;
bitset<360> viz;
int DIST[360];
int C[360][360],F[360][360],COST[360][360],T[360],sol;
bool BellmanFord()
{
    for (int i = 1;i <= N;++i)
        DIST[i] = INFINITY;
    viz.reset();

    Q.push(S);
    DIST[S] = 0;

    while (!Q.empty())
    {
        int node = Q.front();
        Q.pop();
        viz[node] = 0;
        for (int i = 0;i < L[node].size();++i)
        {
            if ((DIST[node] + COST[node][L[node][i]] < DIST[ L[node][i] ]) && (F[node][L[node][i]] < C[node][L[node][i]]))
            {
                DIST[L[node][i]] = DIST[node] + COST[node][L[node][i]];
                T[L[node][i]] = node;
                if (viz[L[node][i]] == 0)
                {
                    viz[L[node][i]] = 1;
                    Q.push(L[node][i]);
                }
            }
        }
    }

    if (DIST[D] != INFINITY)
        return true;
    return false;

}

int main()
{
    in >> N >> M>>S>>D;


    for (int i = 1;i <= M;++i)
    {
        int x, y, c, z;
        in >> x >> y >> c >> z;
        C[x][y] = c;
        COST[x][y] = z;
        COST[y][x] = -z;
        L[x].push_back(y);
        L[y].push_back(x);
    }

    while (BellmanFord())
    {
        int MIN = INFINITY;
        int x = D;
        while (x!=S)
        {
            MIN = min(MIN, C[T[x]][x]-F[T[x]][x]);
            x = T[x];
        }
        x = D;
        while (x!=S)
        {
            sol += MIN*COST[T[x]][x];
            F[T[x]][x] += MIN;
            F[x][T[x]] -= MIN;
            x = T[x];
        }

    }

    out << sol;

    return 0;
}