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

const int Nmax = 355;
const int inf = 0x3f3f3f3f;

int N,M,S,D;
int Cost[Nmax][Nmax];
int flow[Nmax][Nmax];
int Capacity[Nmax][Nmax];
vector<int> Adj[Nmax];
queue<int> Q;
bool in_queue[Nmax];
int dist[Nmax];
int T[Nmax];

bool BellmanFord()
{
    memset(in_queue,0,sizeof in_queue);
    memset(dist,inf,sizeof dist);

    Q.push(S);
    in_queue[S] = 1;
    dist[S] = 0;
    T[S] = 0;

    while(!Q.empty()) {
        int u = Q.front();
        Q.pop();
        in_queue[u] = 0;

        for(auto p: Adj[u]) {
            if(Capacity[u][p] - flow[u][p] > 0 && dist[p] > dist[u] + Cost[u][p]) {
                dist[p] = dist[u] + Cost[u][p];
                T[p] = u;

                if(!in_queue[p]) {
                    Q.push(p);
                    in_queue[p] = 1;
                }
            }
        }
    }

    return dist[D] != inf;
}

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

    fin >> N >> M >> S >> D;
    for(int i = 1; i <= M; i++) {
        int a,b,c,d;
        fin >> a >> b >> c >> d;
        Adj[a].push_back(b);
        Adj[b].push_back(a);
        Cost[a][b] = d;
        Cost[b][a] = -d;
        Capacity[a][b] = c;
    }

    int mincost = 0;

    while(BellmanFord()) {
        int minflow = inf;
            
        for(int i = D; i != S; i = T[i])
            minflow = min(minflow, Capacity[T[i]][i] - flow[T[i]][i]);

        for(int i = D; i != S; i = T[i]) {
            flow[T[i]][i] += minflow;
            flow[i][T[i]] -= minflow;
        }

        mincost += minflow * dist[D];
    }

    fout << mincost << "\n";

}