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

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

short int n,m,s,d;
short int x,y,c,z;
vector<vector<short int>>capacitate;
vector<vector<short int>>flux;
vector<short int> nod_flux;
vector<vector<pair<short int, short int>>> graf; 
vector<int> cost;
vector<bool> vizitat;
int flowCurent, nodCurent;
int total = 0;
vector<pair<short int, short int>> ::iterator it;

struct cmp{
 bool operator() (const short int &a, const short int &b) const{
  return cost[a] < cost[b];
 }
};

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

int dijkstra(){
  cost = vector<int> (n+1, INT_MAX);
  vizitat = vector<bool> (n+1, 0);
  pq.push(s);
  cost[s] = 0;

  while(!pq.empty()){
    int nodCurent = pq.top();
    pq.pop();
    vizitat[nodCurent] = 0;
    for(it = graf[nodCurent].begin(); it!= graf[nodCurent].end(); it++){
      if(cost[it->first] <= cost[nodCurent] + it->second)
        continue;
      if(capacitate[nodCurent][it->first] <= flux[nodCurent][it->first])
        continue;
      cost[it->first] = cost[nodCurent] + it->second;
      nod_flux[it->first] = nodCurent;
      if(vizitat[it->first] == 1)
        continue;
      vizitat[it->first] = 1;
      pq.push(it->first);
    }
  }
  if(cost[d] == INT_MAX)
    return 0;
  return 1;
}

void solve(){
  while(dijkstra()){
    flowCurent = INT_MAX;
    for(nodCurent = d; nodCurent != s; nodCurent = nod_flux[nodCurent]){
      if(capacitate[nod_flux[nodCurent]][nodCurent] - flux[nod_flux[nodCurent]][nodCurent] < flowCurent)
        flowCurent = capacitate[nod_flux[nodCurent]][nodCurent] - flux[nod_flux[nodCurent]][nodCurent];
    }
    for(nodCurent = d; nodCurent != s; nodCurent = nod_flux[nodCurent]){
     flux[nod_flux[nodCurent]][nodCurent] += flowCurent;
     flux[nodCurent][nod_flux[nodCurent]] -= flowCurent;
    }
    total = total + flowCurent * cost[d];
  }
  fout<<total<<endl;
  fin.close();
  fout.close();
}

void read(){
  fin>>n>>m>>s>>d;
  graf = vector<vector<pair<short int, short int>>>(n+1);
  capacitate = vector<vector<short int>> (n+1, vector<short int>(n+1, 0));
  flux = vector<vector<short int>> (n+1, vector<short int>(n+1, 0));
  nod_flux = vector<short int> (n+1, 0);
  
  for(int i=1;i<=m;i++){
    fin>>x>>y>>c>>z;
    graf[x].push_back(make_pair(y,z));
    graf[y].push_back(make_pair(x,-z));
    capacitate[x][y] = c;
  }
  solve();
}

int main() 
{
  ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
  int t = 1;

  while(t--){
    read();
  }

  return 0;
}