#include <iostream>
#include <fstream>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;

ifstream fin("fmcm.in");
ofstream fout("fmcm.out");

const int MAXN = 355;
const int Inf = 0x3f3f3f3f;
struct Nod{
	int cost, nod;

	bool operator < ( const Nod& a ) const
	{
		return cost > a.cost;
	}
};
int N, M, S, D;
vector< vector<int> > G;
int F[MAXN][MAXN];
int m[MAXN][MAXN];
int c[MAXN];
int t[MAXN];
int RealCost[MAXN];
int P[MAXN];
int cmin;

void Read();
void Bellman_Ford();
bool Dijkstra();

int main()
{
	Read();
	Bellman_Ford();

	while ( Dijkstra() );

	fout << cmin << '\n';

	fin.close();
	fout.close();
	return 0;
}


void Read()
{
	fin >> N >> M >> S >> D;
	G = vector< vector<int> >(N + 1);
	int x, y, c, z;
	while ( M-- )
	{
		fin >> x >> y >> c >> z;

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

		F[x][y] = c;

		m[x][y] = z;
		m[y][x] = -z;
	}
}

void Bellman_Ford()
{
	queue<int> Q;

	P[S] = 0;
	Q.push(S);

	while ( !Q.empty() )
	{
		int node = Q.front();
		Q.pop();

		for ( const int& v : G[node] )
		{
			//cout << node << ' ' << v; cin.get();
			if ( P[v] > P[node] + 1 )
			{
				//cout << v; cin.get();
				P[v] = P[node] + 1;
				Q.push(v);
			}
		}
	}
}

bool Dijkstra()
{
	memset(c, Inf, sizeof(c));
	c[S] = RealCost[S] = 0;
	priority_queue<Nod> Q;
	Q.push({0, S});

	while ( !Q.empty() )
	{
		int node = Q.top().nod;
		int cc = Q.top().cost;
		Q.pop();

		if ( cc != c[node] ) continue;
		for ( const int& v : G[node] )
			if ( F[node][v] )
			{
				int c_nou = c[node] + P[node] - P[v] + m[node][v];

				if ( c_nou < c[v] )
				{
					c[v] = c_nou;
					RealCost[v] = RealCost[node] + m[node][v];
					t[v] = node;

					Q.push({c[v], v});
				}
			}
	}
	for ( int i = 1; i <= N; ++i )
		P[i] = c[i];

	if ( c[D] >= Inf )
		return false;

	int fc{Inf};
	for ( int i = D; i != S; i = t[i] )
		fc = min( F[t[i]][i], fc );

	cmin += fc*RealCost[D];

	for ( int i = D; i != S; i = t[i] )
	{
		F[t[i]][i] -= fc;
		F[i][t[i]] += fc;
	}

	return true;
}