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

const int NMAX = 400;
const int MMAX = 13000;
const int INF = 5e8;

int n, m, s, d;
int C[NMAX][NMAX], F[NMAX][NMAX];
int cost[NMAX][NMAX];
vector <int> G[NMAX];
int p[NMAX];
int vechi[NMAX];
int nou[NMAX];
int adev[NMAX];
bool inCoada[NMAX];

void bellmanford()
{
    for (int i = 1; i <= n; i++)
        vechi[i] = INF;

    queue <int> Q;
    Q.push(s);
    vechi[s] = 0;
    inCoada[s] = 1;

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

        for (auto v: G[nod])
            if (vechi[nod] + cost[nod][v] < vechi[v] && C[nod][v]) /// imbunatatesc si e muchie normala
            {
                vechi[v] = vechi[nod] + cost[nod][v];

                if (!inCoada[v])
                {
                    Q.push(v);
                    inCoada[v] = 1;
                }
            }
    }
}

bool dijkstra()
{
    for (int i = 1; i <= n; i++)
        nou[i] = adev[i] = INF;

    priority_queue < pair<int, int> > Q;
    Q.push({0, s});
    nou[s] = adev[s] = 0;

    while (!Q.empty())
    {
        pair <int, int> curr = Q.top();
        Q.pop();
        int nod = curr.second;
        if (nou[nod] != -curr.first)
            continue;

        for (auto v: G[nod])
        {
            if (nou[nod] + cost[nod][v] + vechi[nod] - vechi[v] < nou[v] && F[nod][v] != C[nod][v])
            {
                nou[v] = nou[nod] + cost[nod][v] + vechi[nod] - vechi[v];
                adev[v] = adev[nod] + cost[nod][v];
                p[v] = nod;
                Q.push({-nou[v], v});
            }
        }
    }
    return nou[d] != INF;
}

int main()
{
    FILE *fi, *fo;
    fi = fopen("fmcm.in", "r");
    fo = fopen("fmcm.out", "w");

    fscanf(fi, "%d%d%d%d", &n, &m, &s, &d);
    for (int i = 1; i <= m; i++)
    {
        int x, y, c, z;
        fscanf(fi, "%d%d%d%d", &x, &y, &c, &z);
        G[x].push_back(y);
        G[y].push_back(x);
        C[x][y] = c;
        C[y][x] = 0;
        cost[x][y] = z;
        cost[y][x] = -z;
    }

    bellmanford();

    int rez = 0;
    while (dijkstra())
    {
        int minim = INF;
        for (int i = d; i != s; i = p[i])
            minim = min(minim, C[p[i]][i] - F[p[i]][i]);

        for (int i = d; i != s; i = p[i])
        {
            F[p[i]][i] += minim;
            F[i][p[i]] -= minim;
        }

        rez += (nou[d] + vechi[d]) * minim;

        memcpy(vechi, adev, sizeof(adev));
    }

    fprintf(fo, "%d", rez);

    return 0;
}