#include <fstream>
#include <vector>
#include <climits>
#include <queue>
#include <cstring>

using namespace std;

const int NMAX = 350;

int n, m, start, dest;

vector<int> graf[1 + NMAX];
int capacitate[1 + NMAX][1 + NMAX];
int cost[1 + NMAX][1 + NMAX];

queue<int> q;
bool inCoada[1 + NMAX];

priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;

int distInitial[1 + NMAX];
int distDijkstra[1 + NMAX];
int distReala[1 + NMAX];

int tata[1 + NMAX];

void bellmanFord()
{
  for (int i = 1; i <= n; i++)
    distInitial[i] = INT_MAX;

  distInitial[start] = 0;
  q.emplace(start);
  inCoada[start] = true;

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

    for (auto& vecin : graf[nod])
    {
      if (capacitate[nod][vecin] > 0 && distInitial[nod] + cost[nod][vecin] < distInitial[vecin])
      {
        distInitial[vecin] = distInitial[nod] + cost[nod][vecin];

        if (!inCoada[vecin])
        {
          q.emplace(vecin);
          inCoada[vecin] = true;
        }
      }
    }
  }
}

bool dijkstra()
{
  memset(tata, 0, sizeof(tata));

  for (int i = 1; i <= n; i++)
    distDijkstra[i] = INT_MAX;

  distDijkstra[start] = 0;
  distReala[start]    = 0;
  tata[start] = start;
  pq.emplace(0, start);

  while (!pq.empty())
  {
    int nod = pq.top().second;
    int distNod = pq.top().first;
    pq.pop();

    if (distNod > distDijkstra[nod]) continue;

    for (auto& vecin : graf[nod])
    {
      if (capacitate[nod][vecin] > 0 && distNod + distInitial[nod] + cost[nod][vecin] - distInitial[vecin] < distDijkstra[vecin])
      {
        distDijkstra[vecin] = distNod + distInitial[nod] + cost[nod][vecin] - distInitial[vecin];
        distReala[vecin]    = distReala[nod] + cost[nod][vecin];
        tata[vecin] = nod;

        if (vecin != dest)
          pq.emplace(distDijkstra[vecin], vecin);
      }
    }
  }

  memcpy(distInitial, distDijkstra, sizeof(distInitial));

  return distDijkstra[dest] != INT_MAX;
}

int main()
{
  ifstream in("fmcm.in");
  ofstream out("fmcm.out");

  in >> n >> m >> start >> dest;

  for (int j = 1; j <= m; j++)
  {
    int x, y, c, z;

    in >> x >> y >> c >> z;

    graf[x].emplace_back(y);
    graf[y].emplace_back(x);

    capacitate[x][y] = c;

    cost[x][y] = z;
    cost[y][x] = -z;
  }

  bellmanFord();

  int sol = 0;

  while (dijkstra())
  {
    int capMinima = INT_MAX;

    for (int nodCrt = dest; nodCrt != tata[nodCrt]; nodCrt = tata[nodCrt])
    {
      capMinima = min(capMinima, capacitate[tata[nodCrt]][nodCrt]);
    }

    for (int nodCrt = dest; nodCrt != tata[nodCrt]; nodCrt = tata[nodCrt])
    {
      capacitate[tata[nodCrt]][nodCrt] -= capMinima;
      capacitate[nodCrt][tata[nodCrt]] += capMinima;
    }

    sol += distReala[dest] * capMinima;
  }

  out << sol << '\n';

  return 0;
}