// Include
#include <fstream>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;

// Definitii
#define pb push_back
#define mp make_pair

#define edge pair<int, int>
#define edgeCost first
#define edgeNode second

// Constante
const int sz = 351;
const int oo = (1<<30)-1;

// Functii
void bellmanFord();
bool dijkstra();

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

bool inQueue[sz];

int nodes, edges;
int source, destination;
int minFlowMaxCost;
int father[sz], dist[sz], realDist[sz], oldDist[sz];
int capacity[sz][sz], flow[sz][sz], cost[sz][sz];

vector<int> graph[sz];

// Main
int main()
{
	in >> nodes >> edges >> source >> destination;
	
	int rFrom, rTo, rCapacity, rCost;
	while(edges--)
	{
		in >> rFrom >> rTo >> rCapacity >> rCost;
		graph[rFrom].pb(rTo);
		graph[rTo].pb(rFrom);
		
		capacity[rFrom][rTo] = rCapacity;
		
		cost[rFrom][rTo] = rCost;
		cost[rTo][rFrom] = -rCost;
	}
	
	bellmanFord();
	
	while(dijkstra())
	{
		int minFlow = oo;
		
		for(int node=destination ; node!=source ; node=father[node])
			minFlow = min(minFlow, capacity[father[node]][node] - flow[father[node]][node]);
		
		for(int node=destination ; node!=source ; node=father[node])
		{
			flow[father[node]][node] += minFlow;
			flow[node][father[node]] -= minFlow;
		}
		
		minFlowMaxCost += minFlow * realDist[destination];
	}
	
	out << minFlowMaxCost << '\n';
	
	in.close();
	out.close();
	return 0;
}

void bellmanFord()
{
	for(int i=1 ; i<=nodes ; ++i)
		oldDist[i] = oo;
	
	queue<int> q;
	
	q.push(source);
	inQueue[source] = true;
	oldDist[source] = 0;
	
	while(!q.empty())
	{
		int current = q.front();
		q.pop();
		
		vector<int>::iterator it, end=graph[current].end();
		
		for(it=graph[current].begin() ; it!=end ; ++it)
		{
			if(capacity[current][*it] && oldDist[current]+cost[current][*it] < oldDist[*it])
			{
				oldDist[*it] = oldDist[current]+cost[current][*it];
				if(!inQueue[*it])
					q.push(*it), inQueue[*it] = true;
			}
		}
		inQueue[current] = false;
	}
}

bool dijkstra()
{
	for(int i=1 ; i<=nodes ; ++i)
		dist[i] = oo, father[i] = 0;
	
	priority_queue<edge, vector<edge>, greater<edge> > heap;
	
	dist[source] = 0;
	heap.push(mp(0, source));
	
	while(!heap.empty())
	{
		int current=heap.top().edgeNode;
		if(heap.top().edgeCost != dist[current])
		{
			heap.pop();
			continue;
		}
		heap.pop();
		vector<int>::iterator it, end = graph[current].end();
		for(it=graph[current].begin() ; it!=end ; ++it)
		{
			if(capacity[current][*it] != flow[current][*it] &&
			dist[current] + cost[current][*it] + oldDist[current] - oldDist[*it] < dist[*it])
			{
				dist[*it] = dist[current] + cost[current][*it] + oldDist[current] - oldDist[*it];
				father[*it] = current;
				realDist[*it] = realDist[current] + cost[current][*it];
				heap.push(mp(dist[*it], *it));
			}
		}
	}
	
	for(int i=1 ; i<=nodes ; ++i)
		oldDist[i] = realDist[i];
	
	return father[destination]? 1:0;
}