#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <climits>
#include <utility>
#define VMAX 350

using namespace std;

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

int V, E, src, sink, x, y, co, ca, K;
vector < int > adj[VMAX];
int flow[VMAX][VMAX], capacity[VMAX][VMAX], cost[VMAX][VMAX];
int d[VMAX], parent[VMAX], flowMin[VMAX];
bool inQueue[VMAX];

bool SPFA()
{
    for (int i = 0; i < V; ++i) d[i] = INT_MAX, inQueue[i] = false, flowMin[i] = INT_MAX;

    queue <int> q;

    d[src] = 0;
    q.push(src);
    inQueue[src] = true;

    while (!q.empty())
    {
        int u = q.front();
        q.pop();
        inQueue[u] = false;
        for (auto w : adj[u])
        {
            if (capacity[u][w] > flow[u][w] && d[u] + cost[u][w] < d[w])
            {
                d[w] = d[u] + cost[u][w];
                flowMin[w] = min(flowMin[u], capacity[u][w] - flow[u][w]);
                parent[w] = u;
                if (!inQueue[w]) q.push(w), inQueue[w] = true;
            }
        }
    }

    return d[sink] != INT_MAX;
}

int main()
{
    //fin >> K;
    fin >> V >> E >> src >> sink;

    src--, sink--;

    while (E--)
    {
        fin >> x >> y >> ca >> co;
        adj[x - 1].push_back(y - 1);
        adj[y - 1].push_back(x - 1);
        capacity[x - 1][y - 1] = ca;
        cost[x - 1][y - 1] = co;
        cost[y - 1][x - 1] = -co;
    }

    int result = 0;

    while (SPFA())
    {
        for (int i = sink ; i != src; i = parent[i])
        {
            flow[parent[i]][i] += flowMin[sink];
            flow[i][parent[i]] -= flowMin[sink];
        }
        result += flowMin[sink] * d[sink];
    }

    fout << result;

    fin.close();
    fout.close();
    return 0;
}