#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <limits>

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

#define inf INT_MAX
#define dim 400

int n,m,s,d;
vector<vector<int>> adj_list;
int capacity[dim][dim];
int cost[dim][dim];
vector<int>parent;
vector <int> costBellman(dim,inf);
vector <int> costDijkstra(dim,inf);
vector <int> costuri(dim);
int minCost;

void bellmanFord()
{
    queue<int>coada;
    vector<bool>viz(dim,0);
    viz[s]=1;
    costBellman[s]=0;
    coada.push(s);
    while (!coada.empty())
    {
        int u=coada.front();
        coada.pop();
        viz[u] = 0;
        for (int i=0; i<adj_list[u].size(); i++)
        {
            int v=adj_list[u][i];
            int costV=cost[u][v];
            int fluxV=capacity[u][v];
            if (fluxV!=0)
            {
                if (costBellman[v]>costBellman[u]+costV)
                {
                    costBellman[v]=costBellman[u]+costV;
                    if (viz[v]==0)
                    {
                        coada.push(v);
                        viz[v] = 1;
                    }
                }
            }
        }
    }
}

void dijkstra ()
{
    priority_queue <pair <int, int>, vector <pair <int, int>>, greater <pair <int, int>>> coada;
    costDijkstra.assign(dim, inf);
    costDijkstra[s]=0;
    costuri[s]=0;
    coada.push({0, s});
    while(!coada.empty())
    {
        auto perecheCurenta = coada.top();
        coada.pop();
        auto costuri_extras=perecheCurenta.first;
        auto u=perecheCurenta.second;
        if (costDijkstra[u]==costuri_extras)
            for (int j=0; j<adj_list[u].size(); j++)
            {
                auto v=adj_list[u][j];
                auto costV=cost[u][v];
                auto fluxV=capacity[u][v];
                if (fluxV>0)
                    if (costDijkstra[v]>costDijkstra[u]+costV+costBellman[u]-costBellman[v])
                    {
                        costDijkstra[v] = costDijkstra[u]+costV+costBellman[u]-costBellman[v];
                        coada.push({costDijkstra[v],v});
                        costuri[v]=costuri[u]+costV;
                        parent[v]=u;
                    }
            }
    }
}
bool maxFlux()
{
    dijkstra();
    for (int i=1; i<=n; i++)
        costBellman[i]=costuri[i];
    if (costDijkstra[d]==inf)
        return 0;
    int flux_curent=inf;
    int cost_curent=0;
    int u=d;
    while (u!=s)
    {
        flux_curent=min(flux_curent,capacity[parent[u]][u]);
        cost_curent+=cost[parent[u]][u];
        u=parent[u];
    }
    u=d;
    while (u!=s)
    {
        capacity[parent[u]][u]-=flux_curent;
        capacity[u][parent[u]]+=flux_curent;
        u=parent[u];
    }
    minCost+=flux_curent*costuri[d];
    return 1;
}
void citire()
{
    fin>>n>>m>>s>>d;
    adj_list.resize(n+1);
    parent.resize(n+1);
    for(int i=1;i<=m;i++)
    {
        int x,y,c,z;
        fin>>x>>y>>c>>z;
        adj_list[x].push_back(y);
        adj_list[y].push_back(x);
        capacity[x][y]=c;
        cost[x][y]=z;
        cost[y][x]=-z;
    }
    bellmanFord();
}
int main()
{
    citire();
    while (maxFlux());
        fout<<minCost;
    return 0;
}