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

using namespace std;

const int NMAX = 350;

int n, m, start, dest;

int capacitate[1 + NMAX][1 + NMAX];
int cost[1 + NMAX][1 + NMAX];
int tata[1 + NMAX];

vector<int> graf[1 + NMAX];

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

int costMin[1 + NMAX];

bool bellmanFord()
{
  memset(tata, 0, sizeof(tata));
  memset(inCoada, false, sizeof(inCoada));

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

  costMin[start] = 0;
  tata[start] = start;

  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 && costMin[nod] + cost[nod][vecin] < costMin[vecin])
      {
        costMin[vecin] = costMin[nod] + cost[nod][vecin];
        tata[vecin] = nod;

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

  return costMin[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;
  }

  int costMinim = 0;

  while (bellmanFord())
  {
    int capMin = INT_MAX;

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

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

    costMinim += costMin[dest] * capMin;
  }

  out << costMinim << '\n';

  return 0;
}