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

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

#define inf INT_MAX
#define dim 351

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

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

bool dijkstra ()
{
    priority_queue <pair <int, int>, vector <pair <int, int>>, greater <pair <int, int>>> coada;
    for (int i = 1; i <= n; i++)
        costDijkstra[i] = inf;
    costDijkstra[s]=0;
    costuri[s]=0;
    coada.push({0, s});
    while(!coada.empty())
    {
        pair<int,int> perecheCurenta = coada.top();
        coada.pop();
         int u=perecheCurenta.second;
        if (costDijkstra[u]==perecheCurenta.first)
            for (int j=0; j<adj_list[perecheCurenta.second].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;
                    }
            }
    }
    for (int i=1; i<=n; i++)
        costBellman[i]=costuri[i];
    if (costDijkstra[d]==inf)
        return false;
    int flux_curent=inf;
    int u=d;
    while (u!=s)
    {
        flux_curent=min(flux_curent,capacity[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 true;
}

void rezolvare()
{
    bellmanFord();
    int rez=dijkstra();
    while(rez)rez=dijkstra();
    fout<<minCost;
}
int main()
{
    fin>>n>>m>>s>>d;
    adj_list.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;
    }
    rezolvare();
    return 0;
}