#include <bits/stdc++.h>

using namespace std;

ifstream fin ("fmcm.out");
ofstream fout ("fmcm.out");

int n, m, S, D;
int x, y, z, C, cost[352][352], c[352][352];
vector<int>G[352];

int in[352], mamaie[352], d[352], adevarat[352], p[352], flux, ans;

struct cmp {
  bool operator() (int x, int y) {
  return d[x] > d[y];
  }
};

priority_queue<int, vector<int>, cmp> pq;


bool dijkstra () {
  for (int i = 1; i <= n; i++)
    d[i] = 1000000000;
  d[S] = 0; adevarat[S] = 0;
  in[S] = 1;
  pq.push(S);
  memset(in, 0, sizeof(in));
  while (!pq.empty()) {
    int nod = pq.top();
    pq.pop();
    in[nod] = 1;
    for (auto it: G[nod]) {
      if (c[nod][it]) {
        int dildau = d[nod] + cost[nod][it] - mamaie[it] + mamaie[nod];
        if (dildau < d[it]) {
          d[it] = dildau;
          adevarat[it] = adevarat[nod] + cost[nod][it];
          p[it] = nod;
          if (!in[it]) {
            pq.push(it);
            in[it] = 1;
          }
        }
      }
    }
  }
  memcpy(mamaie, adevarat, sizeof(mamaie));
  if (d[D] == 1000000000)
    return 0;
  return 1;
}


void bellman_ford () {
  queue<int>q;
  for (int i = 1; i <= n; i++)
    mamaie[i] = 1000000000;
  mamaie[S] = 0;
  q.push(S);
  in[S] = 1;
  while (!q.empty()) {
    int u = q.front();
    in[u] = 0;
    q.pop();
    for (auto it: G[u]) {
      if (c[u][it]) {
        if (mamaie[u] + cost[u][it] < mamaie[it]) {
          mamaie[it] = mamaie[u] + cost[u][it];
          if (!in[it]) {
            in[it] = 1;
            q.push(it);
          }
        }
      }
    }
  }
}

int main()
{
  fin >> n >> m >> S >> D;
  for (int i = 1; i <= m; i++) {
    fin >> x >> y >> C >> z;
    cost[x][y] = z;
    cost[y][x] = -z;
    c[x][y] = C;
    G[x].push_back(y);
    G[y].push_back(x);
  }
  bellman_ford();
  while (dijkstra()) {
    int fmin = 1000000000;
    int cst = 0;
    for (int nod = D; nod != S; nod = p[nod]) {
      fmin = min (fmin, c[p[nod]][nod]);
      cst += cost[p[nod]][nod];
    }
    flux += cst;
    ans += fmin * adevarat[D];
    for (int nod = D; nod != S; nod = p[nod]) {
      c[p[nod]][nod] -= fmin;
      c[nod][p[nod]] += fmin;
    }
  }
  fout << ans;
  return 0;
}