#include<cstdio>
#include<vector>
#include<queue>
#define vec G[nod][i]
#define NMAX 355
#define INF (1<<30)
#define DIJKSTRA_TYPE pair<int,int> 
#define LL long long
using namespace std;
FILE *fin,*fout;
int n,source,destination,bonus;
int DIST[NMAX],FLUX[NMAX][NMAX],CAPACITY[NMAX][NMAX],COST[NMAX][NMAX],D[NMAX],REAL[NMAX];
long long VOLMIN,sol;
short TT[NMAX];
vector<short> G[NMAX];
bool use[NMAX];
queue<short> Q;
priority_queue<DIJKSTRA_TYPE, vector<DIJKSTRA_TYPE>, greater<DIJKSTRA_TYPE> > HEAP;
inline LL min(LL a, int b)
{
	if(a<b)
		return a;
	return b;
}
void read()
{
	fin=fopen("fmcm.in","r");
	int m,z,c;
	fscanf(fin,"%d %d %d %d",&n,&m,&source,&destination);
	short x,y;
	while(m--)
	{
		fscanf(fin,"%hi %hi %d %d",&x,&y,&z,&c);
		G[x].push_back(y);
		G[y].push_back(x);
		CAPACITY[x][y]=z;
		COST[x][y]=c;
		COST[y][x]=-c;
	}
	fclose(fin);
}
void print()
{
	fout=fopen("fmcm.out","w");
	fprintf(fout,"%ld",sol);
	fclose(fout);
}
void INIT()
{
	for(int i=1;i<=n;i++)
		DIST[i]=INF;
}
void bellman_ford()
{
	int nod;
	DIST[source]=0;
	Q.push(source);
	use[source]=1;
	while(!Q.empty())
	{
		nod=Q.front();
		Q.pop();
		for(size_t i=0;i<G[nod].size();i++)
			if(CAPACITY[nod][vec]>FLUX[nod][vec] && DIST[nod]+COST[nod][vec]<DIST[vec])
			{
				DIST[vec]=DIST[nod]+COST[nod][vec];
				if(!use[vec])
				{
					use[vec]=1;
					Q.push(vec);
				}
			}
		use[nod]=0;
	}
}
void flux_update()
{
	int i;
	if(DIST[destination]!=INF)
	{
		VOLMIN=INF;
		for(i=destination;i!=source;i=TT[i])
			VOLMIN=min(VOLMIN,CAPACITY[TT[i]][i]-FLUX[TT[i]][i]);
		for(i=destination;i!=source;i=TT[i])
		{
			FLUX[TT[i]][i]+=VOLMIN;
			FLUX[i][TT[i]]-=VOLMIN;
		}
		sol+=(VOLMIN*REAL[destination]);
	}
}
void DIJKSTRA_INIT()
{
	for(int i=0;i<=n;i++)
	{
		D[i]=INF;
		use[i]=0;
		DIST[i]=REAL[i];
	}
}
bool dijkstra()
{
	DIJKSTRA_INIT();
	D[source]=0;
	REAL[source]=0;
	HEAP.push(make_pair(DIST[source],source));
	int nod,cost;
	while(!HEAP.empty())
	{
		nod=HEAP.top().second;
		HEAP.pop();
		if(use[nod])
			continue;
		use[nod]=1;
		for(size_t i=0;i<G[nod].size();i++)
			if(CAPACITY[nod][vec]>FLUX[nod][vec])
			{
				cost=DIST[nod]+COST[nod][vec]-DIST[vec];
				if(D[nod]+cost<D[vec])
				{
					D[vec]=D[nod]+cost;
					REAL[vec]=REAL[nod]+COST[nod][vec];
					TT[vec]=nod;
					HEAP.push(make_pair(-D[vec],vec));
				}
			}
	}
	return D[destination]!=INF;
}
int main()
{
	read();
	bellman_ford();
	while(dijkstra())
		flux_update();
	print();
	return 0;
}