#include<stdio.h>   
#define MAX 500000   
#define Maxdist 25000000   
struct Nod {   
    int v;   
    Nod *next;   
};   
struct NHeap {   
    int val;   
    int nod;   
};   
int n;   
int nrHeap;   
int m;   
int fSs;   
int ok;   
int fDt;   
int C[355][355];   
int UZ;   
int x;   
int min;   
NHeap Heap[800];   
int PozInHeap[355];   
int y;   
int Parent[355];   
int q1;   
int q2;   
int dist[355];   
Nod *a[355];   
long long val;   
int P[355][355];   
void insert(Nod *&k, int val)   
{   
    Nod *u = new Nod;   
    u -> v = val;   
    u -> next = k;   
    k = u;   
}   
int GoDown(int i)   
{   
    int min = 2 * i;   
    NHeap aux;   
    int aux2;   
    if (2 * i > nrHeap) return 0;   
    if (2 * i + 1 <= nrHeap)   
    if (Heap[2 * i].val < Heap[2 * i + 1].val) min = 2 * i;   
                                  else min = 2 * i + 1;   
    if (Heap[min].val >= Heap[i].val) min = i;   
    if (min == i) return 0;   
    aux2 = PozInHeap[Heap[min].nod];   
    PozInHeap[Heap[min].nod] = PozInHeap[Heap[i].nod];   
    PozInHeap[Heap[i].nod] = aux2;   
  
    aux = Heap[min];   
    Heap[min] = Heap[i];   
    Heap[i] = aux;   
    GoDown(min);   
    return 0;   
}   
int GoUp(int i)   
{   
    while (Heap[i].val < Heap[i / 2].val && i > 1)   
     {   
  
         int aux2;   
         aux2 = PozInHeap[Heap[i].nod];   
         PozInHeap[Heap[i].nod] = PozInHeap[Heap[i/2].nod];   
         PozInHeap[Heap[i/2].nod] = aux2;   
  
         NHeap aux;   
         aux = Heap[i];   
         Heap[i] = Heap[i / 2];   
         Heap[i / 2] = aux;   
  
         i /= 2;   
     }   
  
}   
NHeap ExtractMin()   
{   
    NHeap aux;   
    PozInHeap[Heap[1].nod] = nrHeap;   
    PozInHeap[Heap[nrHeap].nod] = 1;   
    aux = Heap[1];   
    Heap[1] = Heap[nrHeap];   
    Heap[nrHeap] = aux;   
    nrHeap--;   
    GoDown(1);   
    return Heap[nrHeap + 1];   
}   
int BellmanFord()   
{   
    Nod *j;   
    for(int i = 1; i <= n; i++)   
     if (i != fSs) dist[i] = MAX;   
   for(int k = 1; k <= n - 1; k++)   
    for(int i = 1; i <= n; i++)   
     for(j = a[i]; j != NULL; j = j -> next)   
      if (C[i][j->v])   
      if (dist[j -> v] > dist[i] + P[i][j -> v])   
       dist[j -> v] = dist[i] + P[i][j -> v];   
  
    for(int i = 1; i <= n; i++)   
    {   
      Heap[i].val = dist[i];   
      Heap[i].nod = i;   
      PozInHeap[i] = i;   
    }   
  
  
    UZ = dist[fDt];   
  
    return 0;   
}   
long long Dijkstra()   
{   
    nrHeap = 1;   
  
    for(int i = 1; i <= n; i++)   
     for(Nod *j = a[i]; j != NULL; j = j -> next)   
      if (Heap[PozInHeap[i]].val != Maxdist && Heap[PozInHeap[j -> v]].val != Maxdist)   
       P[i][j -> v] += Heap[PozInHeap[i]].val - Heap[PozInHeap[j -> v]].val;   
  
    for(int i = 1; i <= n; i++)   
     if (i != fSs)   
     {   
      Heap[++nrHeap].val = Maxdist;   
      PozInHeap[i] = nrHeap;   
      Heap[nrHeap].nod = i;   
     }   
    Heap[1].nod = fSs;   
    Heap[1].val = 0;   
    PozInHeap[fSs] = 1;   
    for(int i = 1; i <= n; i++)   
     Parent[i] = 0;   
    nrHeap = n;   
  
  
    while (nrHeap)   
      {   
          NHeap aux;   
          aux = ExtractMin();   
          if (aux.nod == fDt) break;   
          for(Nod *it = a[aux.nod]; it; it = it -> next)   
           if (Heap[PozInHeap[it->v]].val > aux.val + P[aux. nod][it -> v] && C[aux.nod][it -> v] > 0)   
            {   
             Heap[PozInHeap[it->v]].val = aux.val + P[aux.nod][it -> v];   
             Parent[it->v] = aux.nod;   
             GoUp(PozInHeap[it->v]);   
            }   
      }   
    if (Parent[fDt] != 0)   
    {   
     ok = 1;   
     min = C[Parent[fDt]][fDt];   
     for(int i = Parent[fDt]; i != fSs; i = Parent[i])   
      if (min > C[Parent[i]][i]) min = C[Parent[i]][i];   
  
     for(int i = fDt; i != fSs; i = Parent[i])   
     {   
       C[Parent[i]][i] -= min;   
       C[i][Parent[i]] += min;   
     }   
     UZ += Heap[PozInHeap[fDt]].val;   
     return min * UZ;   
    }   
    return 0;   
  
  
}   
int Flux()   
{   
    ok = 1;   
    while (ok)   
     {   
         ok = 0;   
         val += Dijkstra();   
     }   
  
    return 0;   
}   
int main()   
{   
    freopen("fmcm.in","r",stdin);   
    freopen("fmcm.out","w",stdout);   
    scanf("%d %d %d %d", &n, &m, &fSs, & fDt);   
    for(int i = 1; i <= m; i++)   
     {   
       scanf("%d %d %d %d", &x, &y, &q1, &q2);   
       P[x][y] = q2;   
       P[y][x] = -q2;   
       C[x][y] = q1;   
       insert(a[x],y);   
       insert(a[y],x);   
     }   
     BellmanFord();   
     Flux();   
     printf("%lld\n",val);   
}