#include <fstream>
#include <vector>
#include <list>
#define MAX 400
#define inf 2100000000
using namespace std;
ifstream fi("fmcm.in");
ofstream fo("fmcm.out");
int F[MAX][MAX],C[MAX][MAX];
vector<pair<int,int> > G[MAX],Gi[MAX];
int N,M,sursa,dest,DHeap;
int Dist[MAX],heap[MAX],poz[MAX],T[MAX];
list<int> L;


void citire(){
	fi>>N>>M>>sursa>>dest;
	int a,b,c,d;
	for (int i=1;i<=M;++i){
		fi>>a>>b>>c>>d;
		C[a][b]=c;
		G[a].push_back(make_pair(b,d));
		G[b].push_back(make_pair(a,-d));
		Gi[a].push_back(make_pair(b,d));
	}
}

int BellmanFord(){
	for (int i=1;i<=N;++i) Dist[i]=inf,T[i]=-1;
	L.push_back(sursa);
	Dist[sursa]=0;
	while (!L.empty()){
		list<int>::iterator it=L.begin();
		for (unsigned int i=0;i<G[*it].size();++i)
			if (C[*it][G[*it][i].first]-F[*it][G[*it][i].first]>0)
				if (Dist[G[*it][i].first]>(Dist[*it]+G[*it][i].second)){
					Dist[G[*it][i].first]=Dist[*it]+G[*it][i].second;
					T[G[*it][i].first]=*it;
					L.push_back(G[*it][i].first);
				}
		L.pop_front();
	}
	if (Dist[dest]<inf) return 1; else return 0;
}

void swap(int i,int j){
	int aux=heap[i];heap[i]=heap[j];heap[j]=aux;
	poz[heap[i]]=i;poz[heap[j]]=j;
}

void heap_up(int nod){
	int dad=(nod/2);
	if (dad>0 && Dist[heap[dad]]>Dist[heap[nod]]){
		swap(nod,dad);
		heap_up(dad);
	}
}

void heap_dw(int nod){
	int l=nod*2,r=l+1,minim=nod;
	if (l<=DHeap && Dist[heap[l]]<Dist[heap[minim]]) minim=l;
	if (r<=DHeap && Dist[heap[r]]<Dist[heap[minim]]) minim=r;
	if (minim!=nod){
		swap(nod,minim);
		heap_dw(minim);
	}
}


int Dijkstra(){
	for (int i=1;i<=N;++i)
		for (unsigned int j=0;j<G[i].size();++j)
			if (Dist[i]!=inf && Dist[G[i][j].first]!=inf) G[i][j].second+=(Dist[i]-Dist[G[i][j].first]);
	for (int i=1;i<=N;++i){
		T[i]=-1;
		heap[i]=i;
		poz[i]=i;
		Dist[i]=inf;
	}
	DHeap=N;
	Dist[sursa]=0;
	heap_up(poz[sursa]);
	while (DHeap && Dist[heap[1]]!=inf){
		int nod=heap[1];
		for (unsigned int i=0;i<G[nod].size();++i)
			if (C[nod][G[nod][i].first]-F[nod][G[nod][i].first]>0)
				if (Dist[G[nod][i].first]>(Dist[nod]+G[nod][i].second)){
					Dist[G[nod][i].first]=Dist[nod]+G[nod][i].second;
					T[G[nod][i].first]=nod;
					heap_up(poz[G[nod][i].first]);
				}
		swap(1,DHeap);
		--DHeap;
		heap_dw(1);
	}
	if (Dist[dest]<inf) return 1; else return 0;
}

long long flow(){
	long long rez=0;
	if (!BellmanFord()) return 0;
	while (Dijkstra()){
		int maxflow=inf;
		for (int nod=dest;nod!=sursa;nod=T[nod]) maxflow=min(maxflow,C[T[nod]][nod]-F[T[nod]][nod]);
		if (maxflow>0)
			for (int nod=dest;nod!=sursa;nod=T[nod]) { F[T[nod]][nod]+=maxflow; F[nod][T[nod]]-=maxflow; }
	}
	for (int i=1;i<=N;++i)
		for (unsigned int j=0;j<Gi[i].size();++j)
			rez+=(long long)F[i][Gi[i][j].first]*Gi[i][j].second;
	return rez;
}


int main(){
	citire();
	fo<<flow()<<"\n";
	fi.close();fo.close();
	return 0;
}