#include <iostream>
#include <bits/stdc++.h>


using namespace std;

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


vector<int> adjList[352];
int bfDist[351];
int cap[352][352],cFlux[352][352], cost[352][352];
int n,m, source, dest;
void BellmanFord()
{
    for(int i = 1; i <= n;i ++)
        bfDist[i] = INT_MAX;
    queue <int> q;

    bfDist[source]  = 0;
    q.push(source);

    while(!q.empty())
    {
        int node = q.front();
        q.pop();

        for(int nNode : adjList[node])
            if(cap[node][nNode] > 0)
            {
                if(bfDist[node] + cost[node][nNode] < bfDist[nNode])
                {
                    bfDist[nNode] = bfDist[node] + cost[node][nNode];
                    q.push(nNode);
                }
            }
    }
}

int dist[352];
int realCost[352];

int parent[352];
bool visited[352];

bool Dijkstra()
{
    for(int u = 1; u<=n; u++)
    {
        parent[u] = -1;
        dist[u] = INT_MAX;
        visited[u] = false;
    }

    priority_queue<pair<int,int>> q;

    dist[source] = 0;
    realCost[source] = 0;
    parent[source] = 0;
    q.push(make_pair(-dist[source], source));

    while(!q.empty())
    {
        int u = q.top().second;
        visited[u] = true;
        q.pop();

        for(int v: adjList[u])
            if(cFlux[u][v] < cap[u][v])
            {
                if(dist[u] + ((bfDist[u] - bfDist[v]) + cost[u][v]) < dist[v])
                {
                    parent[v] = u;
                    dist[v] = dist[u] + ((bfDist[u] - bfDist[v]) + cost[u][v]);
                    realCost[v] = realCost[u] + cost[u][v];
                    q.push(make_pair(-dist[v],v));
                }
            }
    }
    for(int u = 1; u<= n; u++)
        bfDist[u] = realCost[u];

    return parent[dest]!= -1;

}

int FordFulkerson ()
{
    int mxFlow = 0;
    while(Dijkstra())
    {
        int mnCap = INT_MAX,sCost = 0;
        int u = dest;
        while(u != source)
        {
            int v = parent[u];
            mnCap = min(mnCap, cap[v][u] - cFlux[v][u]);
            sCost += cost[v][u];
            u = v;
        }
        u = dest;
        while(u != source)
        {
            int v = parent[u];

            cFlux[v][u] += mnCap;
            cFlux[u][v] -= mnCap;

            u = v;
        }
        mxFlow += sCost * mnCap;
    }
    return mxFlow;
}

int main()
{

    in >> n >> m >> source >> dest;

    for(int i = 1; i <= m ;i++)
    {
        int u,v,capacitate,vcost;
        in>>u>>v>>capacitate>>vcost;

        adjList[u].push_back(v);
        adjList[v].push_back(u);

        cost[u][v] = vcost;
        cost[v][u] = -vcost;

        cap[u][v] = capacitate;
        cap[v][u] = 0;

        cFlux[u][v] = 0;
        cFlux[v][u] = 0;


    }

    BellmanFord();

    out<<FordFulkerson()<<"\n";

    return 0;
}