#include <cstdio>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;

#define NMAX 365
#define INF 0x3f3f3f3f

bool viz[NMAX];
short int C[NMAX][NMAX], F[NMAX][NMAX], T[NMAX];
int V[NMAX], D, S, sol, n, m;
vector < pair <short int, short int> > G[NMAX];
queue <int> Q;

void citire (), flux_cmin (), afisare ();

int main () {
	
	citire ();
	
	flux_cmin ();
	
	afisare ();

	return 0;
}

bool bellman_ford () {
	
	int nod, fiu, cst;
	vector < pair <short int, short int> >::iterator it;
	
	memset (V, INF, sizeof (V)); memset (viz, 0, sizeof (viz));
	
	Q.push (S), V[S] = 0, viz[S] = 1;
	while (!Q.empty ()) {
		nod = Q.front ();
		for (it = G[nod].begin (); it != G[nod].end (); it++) {
			fiu = it -> first, cst = it -> second;
			
			if (C[nod][fiu] > F[nod][fiu] && V[nod] + cst < V[fiu]) {
				V[fiu] = V[nod] + cst;
				
				T[fiu] = nod;
				
				if (!viz[fiu]) Q.push (fiu), viz[fiu] = 1;
			}
		}
		
		Q.pop (), viz[nod] = 0;
	}
	
	if (V[D] != INF) return 1;
	return 0;
}

void flux_cmin () {
	
	int minim, nod;
	
	while (bellman_ford ()) {
		
		minim = INF;
		
		for (nod = D; T[nod]; nod = T[nod])
			minim = min (minim, C[ T[nod] ][nod] - F[ T[nod] ][nod]);
		
		for (nod = D; T[nod]; nod = T[nod]) {
			F[ T[nod] ][nod] += minim;
			F[nod][ T[nod] ] -= minim;
		}
		
		sol += V[D] * minim;
	}
}

void citire () {
	
	freopen ("fmcm.in", "r", stdin);
	
	int i, x, y, c, z;
	
	scanf ("%d %d %d %d", &n, &m, &S, &D);
	
	for (i = 1; i <= m; i++) {
		scanf ("%d %d %d %d", &x, &y, &c, &z);
		G[x].push_back (make_pair (y, z)), G[y].push_back (make_pair (x, -z));
		C[x][y] = c;
	}
}

void afisare () {
	
	freopen ("fmcm.out", "w", stdout);
	
	printf ("%d", sol);
}