#include <bits/stdc++.h>
	
using namespace std;

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

const int INF = 1e9;

struct Edge 
{
    int x;
	int y;
	int cap;
	int cost;
};
	
struct Network
{
    vector <Edge> edges;
    vector <vector <int> > adj;
	
    vector <int> dist;
	
    int n, S, D;
	
	Network(int n, int S, int D) : n(n), S(S), D(D), adj(n + 1), dist(n + 1, INF) {}
	
	void add_edge(int x, int y, int c, int z)
    {
        adj[x].emplace_back(edges.size());
        edges.emplace_back(Edge{x, y, c, z});
	
        adj[y].emplace_back(edges.size());
        edges.emplace_back(Edge{y, x, 0, -z});
    }
	
    void bellman_ford()
    {
        vector <bool> inQ(n + 1, false);
        queue <int> q;
	
        q.push(S);
        inQ[S] = true;
	
        dist[S] = 0;
	
        while(!q.empty()) 
		{
            int nod = q.front();
            q.pop();
	
            inQ[nod] = false;
	
            for(auto i : adj[nod]) 
			{
                if(edges[i].cap && dist[edges[i].y] > dist[nod] + edges[i].cost) 
				{
                    dist[edges[i].y] = dist[nod] + edges[i].cost;
	
                    if(!inQ[edges[i].y]) 
					{
                        inQ[edges[i].y] = true;
                        q.push(edges[i].y);
                    }
                }
            }
        }
    }
	
    bool dijkstra(vector <int>& dad)
    {
        dad = vector <int> (n + 1, -1);
        vector <int> cost(n + 1, INF);
	
        priority_queue <pair <int, int> > pq;
	
        cost[S] = 0;
	
        pq.push({0, S});
	
        while(!pq.empty()) 
		{
            int nod = pq.top().second;
			int val = pq.top().first;
			
			pq.pop();
	
            if(val != -cost[nod]) 
			{
                continue;
            }
	
            for(auto i : adj[nod]) 
			{
                if(edges[i].cap && cost[edges[i].y] > cost[nod] + dist[nod] - dist[edges[i].y] + edges[i].cost) 
				{
                    cost[edges[i].y] = cost[nod] + dist[nod] - dist[edges[i].y] + edges[i].cost;
	
                    pq.push({-cost[edges[i].y], edges[i].y});
                    dad[edges[i].y] = i;
                }
            }
        }
	
        for(int i = 1; i <= n; i++)
		{
            dist[i] += cost[i];
		}
		
        return (dad[D] != -1);
    }
	
	int get_cost()
    {
        bellman_ford();
	
        int cost = 0;
	
        vector <int> dad;
	
        while(dijkstra(dad)) 
		{
            int cat = INF;
	
            for(int i = dad[D]; i != -1; i = dad[edges[i].x])
                cat = min(cat, edges[i].cap);
	
            for (int i = dad[D]; i != -1; i = dad[edges[i].x]) 
			{
                cost += cat * edges[i].cost;
                edges[i].cap -= cat;
                edges[i ^ 1].cap += cat;
            }
        }
	
        return cost;
    }
	
};
	
main()
{
    int n, m, s, d;
    fin >> n >> m >> s >> d;
	
    Network graf(n, s, d);
	
    for(int x, y, c, z; m--;)
	{
        fin >> x >> y >> c >> z;
        graf.add_edge(x, y, c, z);
    }
	
    fout << graf.get_cost() << '\n';
}