//ALEX ENACHE

#include <vector>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <unordered_map>
#include <time.h>
#include <iomanip>
#include <deque>
#include <math.h>
#include <assert.h>
#include <stack>
#include <bitset>
#include <random>

using namespace std;

//#include <iostream>
#include <fstream>
ifstream cin ("fmcm.in");ofstream cout ("fmcm.out");

const int inf = 1e9;
const int NMAX = 355;

int n , m , S , D;

vector < int > gr[NMAX];
int cap[NMAX][NMAX];
int cost[NMAX][NMAX];
int DP[NMAX][2];
int used[NMAX];

queue < int > q;

void norm(){
    for (auto &x : DP[0]){
        x = inf;
    }
    q.push(S);
    DP[S][0] = 0;
    while (!q.empty()){
        int now = q.front();
        q.pop();
        used[now] = 0;
        for (auto &x : gr[now]){
            if (cap[now][x] && DP[x][0] > DP[now][0] + cost[now][x]){
                DP[x][0] = DP[now][0] + cost[now][x];
                if (!used[x]){
                    used[x] = 1;
                    q.push(x);
                }
            }
        }
    }
}

int flow[NMAX][NMAX];
int dad[NMAX];
int dp[NMAX];

class cmp{
public:
    bool operator () (pair < int , int > a , pair < int , int > b){
        return a.second > b.second;
    }
};

priority_queue < pair < int , int > , vector < pair < int , int > > , cmp > Q;

int flux(){
    for (auto &x : dp){
        x = inf;
    }
    dp[S] = 0;
    Q.push({S , 0});
    while (!Q.empty()){
        pair < int , int > now = Q.top();
        Q.pop();
        //cerr<<now.first<<'\n';
        if (now.second != dp[now.first]){
            continue;
        }
        for (auto &x : gr[now.first]){
            int new_dp = dp[now.first] + cost[now.first][x] + DP[now.first][0] - DP[x][0];
            if (cap[now.first][x] > flow[now.first][x] && dp[x] > new_dp){
                dp[x] = new_dp;
                DP[x][1] = DP[now.first][1] + cost[now.first][x];
                dad[x] = now.first;
                Q.push({x , dp[x]});
            }
        }
    }
    for (int i=1; i<=n; i++){
        DP[i][0] = DP[i][1];
    }
    if (dp[D] != inf){
        return 1;
    }
    return 0;
}

int main() {

    //freopen("input", "r", stdin);freopen("output", "w", stdout);

    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cout << setprecision(10) << fixed;
    mt19937 rng((long long)(new char));
    srand(time(nullptr));

    cin>>n>>m>>S>>D;

    for (int i=1; i<=m; i++){
        int a , b , c , z;
        cin>>a>>b>>c>>z;
        gr[a].push_back(b);
        gr[b].push_back(a);
        cap[a][b] = c;
        cost[a][b] = z;
        cost[b][a] = -z;
    }

    norm();

    int ans = 0;

    while (flux()){
        //cerr<<"stop"<<'\n';
        int now = D;
        int MIN = inf;
        while (now != S){
            MIN = min(MIN , cap[dad[now]][now] - flow[dad[now]][now]);
            now = dad[now];
        }
        now = D;
        while (now != S){
            flow[dad[now]][now] += MIN;
            flow[now][dad[now]] -= MIN;
            ans += MIN * cost[dad[now]][now];
            now = dad[now];
        }
    }

    cout<<ans;

    return 0;
}