#include<iostream>
#include<fstream>
#include<string.h>
#include<vector>
#include<queue>
#include<bitset>
#include<set>

using namespace std;

#define NMAX 355
#define INF 0X3f3f3f3f

int fluxMax[NMAX][NMAX], costM[NMAX][NMAX], fluxSol[NMAX][NMAX], bmf[NMAX], T[NMAX], realC[NMAX];
	
priority_queue< pair<int,int>, vector< pair<int,int> >, greater< pair<int,int> > > pq;


bool dijkstra( int n, int S, int D, vector<int> *adj ){
	
	int cAux[n+2], costUntil, x, cost;
	vector<int> :: iterator it;
	
	for(int i=1; i<=n; i++){
		T[i] = -1;
		cAux[i] = INF;
	}
	
	pq.push(make_pair(0,S) );
    cAux[S] = 0;
	
	while(!pq.empty()){
		
		x = pq.top().second; 
		costUntil = pq.top().first;
		pq.pop();
		
		if( x == D || cAux[x] != costUntil ) continue;
		
		for( it = adj[x].begin(); it != adj[x].end(); it++){
		
			cost = costM[x][*it];
			if( fluxMax[x][*it] - fluxSol[x][*it] <= 0 ) continue; 
			if( costUntil + cost + bmf[x] - bmf[*it] < cAux[*it] ){
			       cAux[*it] = costUntil + cost + bmf[x] - bmf[*it];
				   pq.push( make_pair(cAux[*it],*it) );	
				   T[*it] = x; 
				   realC[*it] = realC[x] + cost;
			}
		}
	} 
	
	memcpy(bmf,realC,sizeof(realC)); 
	return !(cAux[D] == INF );
}


int main(){
	int nod, n, m, S, D, x, y, f, c, fMin, minC=0;
	FILE *in = fopen("fmcm.in","r");
	
	//citire
	fscanf(in,"%i %i %i %i", &n, &m, &S, &D);
	vector<int> adj[n+2];
	
	while(m--){
		fscanf(in,"%i %i %i %i",&x, &y, &fluxMax[x][y], &costM[x][y]);
		adj[x].push_back(y);
		adj[y].push_back(x);
		costM[y][x] = -costM[x][y];
	}	
	
	
	//bellmanFord(n, S, adj);	
	  int cost;
	  queue<int> q;
	  bitset<NMAX> inQueue(false);
   	  vector<int> :: iterator it;
   	  
   	  memset(bmf, INF, sizeof(bmf));
   	  q.push(S); inQueue[S]=true; bmf[S]=0;
   	  
   	  while(!q.empty()){
   	  	 
   	  	 int x = q.back();
         q.pop();
   	  	 inQueue[x] = false;
   	     
   	    for(it = adj[x].begin(); it != adj[x].end(); it++ ){
   	       
		   cost = costM[x][*it];
   	       if( !fluxMax[x][*it] ) continue;
   	       if( bmf[*it] > bmf[x] + cost ){
   	     	  bmf[*it] = bmf[x] + cost;
   	     	  if( !inQueue[*it] ){
   	     	   	   q.push(*it);
				   inQueue[*it] = true;	
				  }
		   }
		}	
	  }
	  
	  
	
	while (  dijkstra(n, S, D, adj) ){
		
		fMin = INF;
		
		for(nod = D; nod != S; nod = T[nod])
		    fMin = min( fMin, fluxMax[ T[nod] ][ nod ] - fluxSol[ T[nod] ][ nod ]);
		    
		for(nod = D; nod != S; nod = T[nod]){
			fluxSol[ T[nod] ][ nod ] += fMin;
			fluxSol[ nod ][ T[nod] ] -= fMin;
		}
		
		minC += fMin * realC[D]; 
			
	}
	
	
	FILE *out = fopen("fmcm.out","w");
	fprintf(out,"%i",minC);
	return 0;
}