#include <bits/stdc++.h>

using namespace std;

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

const int maxN = 355, INF = 2e9;
int F[maxN][maxN], C[maxN][maxN], Cst[maxN][maxN], n, m, s, t, a, b, c, d, minn_cost;
vector<int> old_d, real_d, G[maxN], D, parent;

void BellmanFord()
{
    old_d.assign(n + 1, INF);
    old_d[s] = 0;

    queue<int> Q; vector<bool> inQ(n + 1);
    Q.push(s); inQ[s] = 1;

    while ( !Q.empty() )
    {
        int x = Q.front(); Q.pop(); inQ[x] = false;

        for ( int a : G[x] )
            if ( C[x][a] && old_d[x] + Cst[x][a] < old_d[a] )
            {
                old_d[a] = old_d[x] + Cst[x][a];
                if ( !inQ[a] )
                {
                    Q.push(a);
                    inQ[a] = 1;
                }
            }
    }
}

bool Dijkstra()
{
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> Q;
    D.assign(n + 1, INF);
    D[s] = 0;

    Q.push({ 0,s });

    while ( !Q.empty() )
    {
        int cost = Q.top().first, x = Q.top().second; Q.pop();
        if ( D[x] != cost )
            continue;

        // cout << x << "   " << cost << "\n";
        for ( int a : G[x] )
            if ( C[x][a] - F[x][a] > 0 && D[x] + Cst[x][a] < D[a] )
            {
                D[a] = D[x] + Cst[x][a];
                parent[a] = x;
                Q.push({ D[a], a });
            }
    }

    if ( D[t] == INF )
        return false;

    int minn = INF;

    for ( int i = t; i != s; i = parent[i] )
        minn = min(minn, C[parent[i]][i] - F[parent[i]][i]);

    // cout << D[t] << " " << minn << "\n";
    if ( minn == 0 )
        return false;

    minn_cost += minn * D[t];

    for ( int i = t; i != s; i = parent[i] )
    {
        F[parent[i]][i] += minn;
        F[i][parent[i]] -= minn;
    }

    return true;
}

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

    parent.resize(n + 1);

    while ( m-- )
    {
        fin >> a >> b >> c >> d;
        G[a].push_back(b);
        G[b].push_back(a);

        C[a][b] = c;
        Cst[a][b] = d;
        Cst[b][a] = -d;
    }

    while ( Dijkstra() );

    fout << minn_cost;
}