#include <bits/stdc++.h>
using namespace std;

const int NMAX = 360,
           INF = 2e9;

struct DJK {
    int nod, dst;

    inline bool operator < (const DJK &arg) const { // God forgive me
        return dst > arg.dst; } };

int n, m, s, d, rcost;

vector<int> g[NMAX];
int dist[NMAX], ddist[NMAX], far[NMAX], gws[NMAX], cap[NMAX][NMAX], cst[NMAX][NMAX], flw[NMAX][NMAX];

void init() {
    deque<int> dq;
    bitset<NMAX> iq(0);
    int u;

    dq.push_back(s);
    memset(dist, 0x3f, sizeof dist);
    dist[s] = 0;

    while (!dq.empty()) {
        u = dq.front(), dq.pop_front();
        iq[u] = false;

        for (auto v: g[u]) if (dist[v] > dist[u] + cst[u][v] && cap[u][v] > 0 && !iq[v]) {
            dq.push_back(v);
            dist[v] = dist[u] + cst[u][v];
            iq[v] = true; } }

    for (int u = 1; u <= n; ++u)
    for (auto v: g[u])
        cst[u][v]+= dist[u] - dist[v];
}

bool dijkstra() {
    priority_queue<DJK> pq;
    int u;

    memset(ddist, 0x3f, sizeof dist);
    pq.push({s, 0});
    ddist[s] = 0;

    while (!pq.empty()) {
        u = pq.top().nod;
        pq.pop();
        for (auto v: g[u]) if (cst[u][v] + ddist[u] < ddist[v] && cap[u][v] - flw[u][v] > 0) {
            far[v] = u;
            ddist[v] = ddist[u] + cst[u][v];
            pq.push({v, ddist[u] + cst[u][v]}); } }

    return (ddist[d] != 0x3f3f3f3f); }

void pump() {
    int sflow, scost;

    while (dijkstra()) {
        sflow = INF;
        scost = 0;
        for (int nod = d; nod != s; nod = far[nod]) {
            sflow = min(sflow, cap[far[nod]][nod] - flw[far[nod]][nod]);
            scost+= cst[far[nod]][nod] + dist[nod] - dist[far[nod]]; }
        for (int nod = d; nod != s; nod = far[nod]) {
            flw[far[nod]][nod]+= sflow;
            flw[nod][far[nod]]-= sflow; }

        rcost+= sflow * (scost); } }

int main() {
    ifstream fi("fmcm.in");
    ofstream fo("fmcm.out");
    int cp, cs, x, y;

    fi >> n >> m >> s >> d;
    for (int i = 0; i < m; ++i) {
        fi >> x >> y >> cp >> cs;

        cap[x][y] = cp;
        cst[x][y] = cs, cst[y][x] = -cs;

        g[x].push_back(y);
        g[y].push_back(x); }

    init();
    pump();

    fo << rcost << '\n';

    return 0; }