#include <fstream>
#include <vector>

using namespace std;

const char InFile[]="fmcm.in";
const char OutFile[]="fmcm.out";
const int INF=1<<30;
const int MaxN=505;
const int MaxQSize=1000111;

ifstream fin(InFile);
ofstream fout(OutFile);

int N,M,S,D,x,y,c,z,C[MaxN][MaxN],F[MaxN][MaxN],Cost[MaxN][MaxN],From[MaxN],Dist[MaxN],Q[MaxQSize];
char inQ[MaxN];
bool ok;
vector<int> G[MaxN];

inline int BellmanFord()
{
	for(register int i=1;i<=N;++i)
	{
		Dist[i]=INF;
		From[i]=0;
	}
	Dist[S]=0;
	
	int L=0;
	Q[L]=S;
	memset(inQ,0,sizeof(inQ));
	inQ[S]=1;

	for(register int i=0;i<=L;++i)
	{
		int nod=Q[i];
		for(vector<int>::iterator it=G[nod].begin();it!=G[nod].end();++it)
		{
			int nodvcn=*it;
			if(C[nod][nodvcn]-F[nod][nodvcn]>0 && Dist[nod]+Cost[nod][nodvcn]<Dist[nodvcn])
			{
				Dist[nodvcn]=Dist[nod]+Cost[nod][nodvcn];
				From[nodvcn]=nod;
				if(!inQ[nodvcn])
				{
					Q[++L]=nodvcn;
					inQ[nodvcn]=1;
				}
			}
		}
		inQ[nod]=0;
	}

	if(Dist[D]<INF)
	{
		ok=true;

		int minim=INF;
		for(int t=D;t!=S;t=From[t])
		{
			if(minim>C[From[t]][t]-F[From[t]][t])
			{
				minim=C[From[t]][t]-F[From[t]][t];
			}
		}

		for(int t=D;t!=S;t=From[t])
		{
			F[From[t]][t]+=minim;
			F[t][From[t]]-=minim;
		}
		return minim*Dist[D];
	}

	return 0;
}

inline long long MaxFlowMinCost()
{
	long long sol=0;
	ok=true;

	while(ok)
	{
		ok=false;
		sol+=BellmanFord();
	}
	return sol;
}

int main()
{
	fin>>N>>M>>S>>D;
	for(register int i=1;i<=M;++i)
	{
		fin>>x>>y>>c>>z;

		G[x].push_back(y);
		G[y].push_back(x);

		C[x][y]=c;
		Cost[x][y]=z;
		Cost[y][x]=-z;
	}
	fin.close();

	fout<<MaxFlowMinCost();
	fout.close();
	return 0;
}