#include <bits/stdc++.h>
#define maxN 352
#define inf 2000000002
#define pii pair <int, int>

FILE *fin  = freopen("fmcm.in", "r", stdin);
FILE *fout = freopen("fmcm.out", "w", stdout);

using namespace std;
int N, M, S, D, ans;
struct Node{
    int dp1, dp2, dad;
    vector <pii> adj;
} G[maxN];
bitset <maxN> vis;
queue <int> Q;
struct comp{
    bool operator () (const pii &a, const pii &b){
        return a.second > b.second;
    }
};
priority_queue <pii, vector <pii>, comp> q;
int r[maxN][maxN]; /// edge rezidual cost

void read(){
    int u, v, capacity, cost;
    scanf("%d %d %d %d", &N, &M, &S, &D);
    for(int i = 0; i < M; ++ i){
        scanf("%d %d %d %d", &u, &v, &capacity, &cost);
        G[u].adj.push_back(make_pair(v, cost));
        G[v].adj.push_back(make_pair(u, -cost));
        r[u][v] = capacity;
        // r[v][u] = 0; residual
    }
}

void initdp1(){
    for(int i = 1; i <= N; ++ i)
        G[i].dp1 = inf;
}

void Bellman_Ford(){
    initdp1();
    G[S].dp1 = 0, vis.set(S);

    for(Q.push(S); Q.empty() == false; Q.pop()){
        int u = Q.front(); vis.reset(u);
        for(pii next : G[u].adj){
             int v = next.first, cost = next.second;
             if(r[u][v] != 0 && G[v].dp1 > G[u].dp1 + cost){
                G[v].dp1 = G[u].dp1 + cost;
                if(v != D && !vis.test(v)){
                    vis.set(v);
                    Q.push(v);
                }
            }
        }
    }
}

void init(){
    for(int i = 1; i <= N; ++ i){
        //G[i].dad = 0;
        G[i].dp2 = inf;
    }
}

bool Dijkstra() {
    init();
    G[S].dp2 = 0;

    for(q.push(make_pair(S, 0)); q.empty() == false;) {
        pii u = q.top(); q.pop();
        if(G[u.first].dp2 != u.second)
            continue;

        for(pii next : G[u.first].adj){
            int v = next.first, c = next.second + G[u.first].dp1 - G[v].dp1;
            if(r[u.first][v] != 0 && G[v].dp2 > G[u.first].dp2 + c){
                G[v].dp2 = G[u.first].dp2 + c;
                G[v].dad = u.first;
                if(v != D)
                    q.push(make_pair(v, G[v].dp2));
            }
        }
    }
    return (G[D].dp2 != inf);
}

void solve(){
    Bellman_Ford();
    while(Dijkstra()){
        int pathFlow = inf;
        int u = D;
        while(u != S){
            int d = G[u].dad;
            pathFlow = min(pathFlow, r[d][u]);
            u = d;
        }
        u = D;
        while(u != S){
            int d = G[u].dad;
            r[d][u] -= pathFlow;
            r[u][d] += pathFlow;
            u = d;
        }
        ans += (G[D].dp2 - G[S].dp1 + G[D].dp1) * pathFlow;
    }
}

void write(){
    printf("%d\n", ans);
}

int main()
{
    read();
    solve();
    write();
    return 0;
}