#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <vector>
#include <queue>
#include <cstring>
#include <set>
#include <cctype>
using namespace std;

#ifdef INFOARENA
#define ProblemName "fmcm"
#endif

#define MCONCAT(A, B) A B
#ifdef ProblemName
#define InFile MCONCAT(ProblemName, ".in")
#define OuFile MCONCAT(ProblemName, ".out")
#else
#define InFile "fis.in"
#define OuFile "fis.out"
#endif

template <class T> void readNum(T &nr) {
	nr = 0;
	T sign = 1;
	char c;
	while (!isdigit(c = getchar()))
		(c == '-') && (sign = -1);
	do {
		nr = nr * 10 + c - '0';
	} while (isdigit(c = getchar()));
	nr *= sign;
}

class graph {
private:
	vector< vector<int> > ngh;
	vector< vector<int> > F;
	vector< vector<int> > C;
	vector< vector<int> > W;
	int source, sink;
public:
	graph(int N, int _source, int _sink) {
		ngh.resize(N);
		source = _source; sink = _sink;
		F.resize(N, vector<int>(N, 0));
		C.resize(N, vector<int>(N, 0));
		W.resize(N, vector<int>(N, 0));
	}
	void insertEdge(int n1, int n2, int c, int w) {
		ngh[n1].push_back(n2);
		C[n1][n2] = c;
		W[n1][n2] = w;
		W[n2][n1] = -w;
	}
	
	void BellmanFord(vector<int> &dist) {
		int N = ngh.size();
		for (int i = 0; i < N; i++)
			dist[i] = 2000000000;
		dist[source] = 0;
		queue<int> Q;
		vector<char> inQueue(N, 0);
		inQueue[source] = 1;
		Q.push(source);
		while (!Q.empty()) {
			int t = Q.front();
			Q.pop();
			inQueue[t] = 0;
			for (auto i : ngh[t])
			if (dist[t] + W[t][i] < dist[i]) {
				dist[i] = dist[t] + W[t][i];
				if (!inQueue[i]) {
					inQueue[i] = 1;
					Q.push(i);
				}
			}
		}
	}
	void Dijkstra(vector<int> &dist, vector<int> &prev) {
		int N = ngh.size();
		memset(&prev[0], 0xFF, prev.size() * sizeof(prev[0]));
		for (int i = 0; i < N; i++)
			dist[i] = 2000000000;
		dist[source] = 0;
		priority_queue< pair<int, int> > Q;
		Q.push(make_pair(0, source));
		vector<char> visited(N, 0);
		while (!Q.empty()) {
			int t = Q.top().second;
			Q.pop();
			if (visited[t])
				continue;
			visited[t] = 1;
			for (auto i : ngh[t])
			if (C[t][i] > F[t][i] && dist[t] + W[t][i] < dist[i]) {
				Q.push(make_pair(-(dist[t] + W[t][i]), i));
				dist[i] = dist[t] + W[t][i];
				prev[i] = t;
			}
		}
	}
	int FordFulkerson() {
		int N = ngh.size();
		vector<int> auxdist(N);
		BellmanFord(auxdist);
		for (int i = 0; i < N; i++)
		for (auto j : ngh[i])
			W[i][j] += auxdist[j] - auxdist[i];

		vector<int> dist(N);
		vector<int> prev(N);
		int totalCost = 0;
		while (true) {
			Dijkstra(dist, prev);
			if (prev[sink] == -1)
				break;
			int minToSend = 2000000000;
			int curNod = sink;
			while (prev[curNod] != -1) {
				if (C[prev[curNod]][curNod] - F[prev[curNod]][curNod] < minToSend)
					minToSend = C[prev[curNod]][curNod] - F[prev[curNod]][curNod];
				curNod = prev[curNod];
			}
			curNod = sink;
			while (prev[curNod] != -1) {
				totalCost += minToSend * (W[prev[curNod]][curNod] + auxdist[prev[curNod]] - auxdist[curNod]);
				F[prev[curNod]][curNod] += minToSend;
				curNod = prev[curNod];
			}
		}
		return totalCost;
	}
};

int main() {
	assert(freopen(InFile, "r", stdin));
	assert(freopen(OuFile, "w", stdout));
	int N, M, S, D;
	readNum(N); readNum(M); readNum(S); readNum(D);
	graph G(N, S - 1, D - 1);
	while (M--) {
		int a, b, c, w;
		readNum(a); readNum(b); readNum(c); readNum(w);
		G.insertEdge(a - 1, b - 1, c, w);
	}
	printf("%d\n", G.FordFulkerson());
	return 0;
}