#include <fstream>
#include <vector>
#include <queue>
#define nmax 360
#define oo (1<<30)
#define Neighbor Graph[Node][i]
using namespace std;

vector <int> Graph[nmax];
int N, M, Source, Sink, CostMaxFlow, Distance[nmax];
int Capacity[nmax][nmax], Cost[nmax][nmax], Father[nmax];
bool inQueue[nmax];

class heap {
	
	#define hmax nmax;
	#define father(node) (node>>1)
	#define leftSon(node) (node<<1)
	#define rightSon(node) ((node<<1)|1)
	#define compare(a, b) ( Distance[H[a]] < Distance[H[b]] )
	#define compareMin(a, b) compare(a, b)
	#define comapreMax(a, b) compare(b, a)
	
	public:
		int Top,H[nmax],Index[nmax];
		
	public:
		
		heap() {
			
			Top = 0;
			
			}
		
		void precolate(int Node) {
			
			while( Node > 1 && compareMin(Node, father(Node)) ) {
				
				swap(H[Node], H[father(Node)]);
				swap(Index[H[Node]], Index[H[father(Node)]]);
				Node = father(Node);
				
				}
			
		}
		
		void sift(int Node) {
			
			int Son;
			
			do {
				
				Son = 0;
				
				if( leftSon(Node) <= this -> size() ) {
					
					Son = leftSon(Node);
					
					if( rightSon(Node) <= this -> size() && compareMin(rightSon(Node), Son) )
						Son = rightSon(Node);
					
					if( compareMin(Node, Son) )
						Son = 0;
					
					}
				
				if( Son ) {
					
					swap(H[Node], H[Son]);
					swap(Index[H[Node]], Index[H[Son]]);
					Node = Son;
					
					}
				
			} while( Son );
			
		}
		
		void push(int Node, int Value) {
			
			H[ ++Top ] = Node;
			Index[Node] = Top;
			Distance[Node] = Value;
			this -> precolate(Top);
			
			}
		
		void pop() {
			
			H[1] = H[ Top-- ];
			this -> sift(1);
			
			}
		
		void update(int Node, int Value) {
			
			int Aux = Distance[Node];
			
			Distance[Node] = Value;
			
			if( Aux > Distance[Node] )
				this -> precolate( Index[Node] );
			else
				this -> sift( Index[Node] );
			
			}
		
		int size() {
			
			return Top;
			
			}
		
		bool empty() {
			
			return ( Top == 0);
			
			}
		
		int top() {
			
			return H[1];
			
			}
	
};

void InitialiseDijkstra() {
	
	int i, Node;
	
	for(Node = 1; Node <= N; Node++)
		for(i = 0; i < Graph[Node].size(); i++)
			if( Distance[Node] != oo && Distance[Neighbor] != oo )
				Cost[Node][Neighbor] += Distance[Node] - Distance[Neighbor];
	
}
bool Dijkstra(int Source, int Sink) {
	
	int i, Node;
	heap Heap;
	
	InitialiseDijkstra();
	
	for(Node = 1; Node <= N; Node++)
		Heap.push(Node, oo);
	
	Heap.update(Source, 0);
	
	while( !Heap.empty() ) {
		
		Node = Heap.top();
		Heap.pop();
		
		for(i = 0; i < Graph[Node].size(); i++)
			if( Capacity[Node][Neighbor] > 0 && Distance[Neighbor] > Distance[Node] + Cost[Node][Neighbor] ) {
				
				Father[Neighbor] = Node;
				Heap.update(Neighbor, Distance[Node] + Cost[Node][Neighbor] );
				
				}
			
		}
	
	return ( Distance[Sink] != oo );
	
}
int BellmanFord(int Source, int Sink) {
	
	int i, Node;
	queue <int> Queue;
	
	for(i = 1; i <= N; i++)
		Distance[i] = oo;
	
	Queue.push(Source);
	Distance[Source] = 0;
	
	while(!Queue.empty()) {
		
		Node = Queue.front();
		Queue.pop();
		inQueue[Node] = false;
		
		for(i = 0; i < Graph[Node].size(); i++)
			if( Capacity[Node][Neighbor] > 0 && Distance[Neighbor] > Distance[Node] + Cost[Node][Neighbor] ) {
				
				Distance[Neighbor] = Distance[Node] + Cost[Node][Neighbor];
				
				if( !inQueue[Neighbor] ) {
					
					Queue.push(Neighbor);
					inQueue[Neighbor] = true;
					
					}
			
			}
		
		}
	
	return Distance[Sink];
	
}
void Solve() {
	
	int i, Sum, maxFlow, Node;
	
	Sum = BellmanFord(Source, Sink);
	
	while( Dijkstra(Source, Sink) ) {
		
		maxFlow = oo;
		
		for(Node = Sink; Node != Source; Node = Father[Node])
			maxFlow = min(maxFlow, Capacity[Father[Node]][Node]);
		
		for(Node = Sink; Node != Source; Node = Father[Node]) {
			
			Capacity[Father[Node]][Node] -= maxFlow;
			Capacity[Node][Father[Node]] += maxFlow;
			
			}
		
		Sum += Distance[Sink];
		
		CostMaxFlow += Sum * maxFlow;
		
		}
	
}
void Read() {
	
	int i, x, y, capacity, cost;
	ifstream in("fmcm.in");
	in>>N>>M>>Source>>Sink;
	
	for(i = 1; i <= M; i++) {
		
		in>>x>>y>>capacity>>cost;
		Graph[x].push_back(y);
		Graph[y].push_back(x);
		Cost[x][y] = cost;
		Cost[y][x] = -cost;
		Capacity[x][y] = capacity;
		
		}
	
	in.close();

}
void Write() {
	
	ofstream out("fmcm.out");
	out<<CostMaxFlow<<'\n';
	out.close();
	
}
int main() {
	
	Read();
	Solve();
	Write();
	
	return 0;
	
}