#include<fstream.h>
#include<stdlib.h>
#define min(x,y) ((x)<(y)?(x):(y))
#define inf 2000000000
#define nx 360
int *A[nx],tat[nx],heap[nx],d[nx];
int C[nx][nx],Cost[nx][nx],flux[nx][nx],P[nx];
int N,M,S,D,drum,L,sum;

void bellmanford()
 {
  int i,j,k,ok=1;
  for (i=1;i<=N;++i) d[i]=inf;
  d[S]=0;
  for (k=1;k<=N && ok;++k)
   {
    ok=0;
    for (i=1;i<=N;++i)
     for (j=1;j<=A[i][0];++j)
      if (C[i][A[i][j]]>flux[i][A[i][j]] && d[A[i][j]]>d[i]+Cost[i][A[i][j]])
	{
	 d[A[i][j]]=d[i]+Cost[i][A[i][j]];
	 ok=1;
	}
   }
  sum+=d[D];
 }

void up_heap(int x)
 {
  int aux;
  while (x/2>1 && d[heap[x]]<d[heap[x/2]])
   {
    aux=heap[x];
    heap[x]=heap[x/2];
    heap[x/2]=aux;
    P[heap[x]]=x;
    P[heap[x/2]]=x/2;
    x/=2;
   }
 }

void down_heap(int x)
 {
  int y=0,aux;
  while (x!=y)
   {
    y=x;
    if (y*2<=L && d[heap[x]]>d[heap[y*2]]) x = y*2;
	if (y*2+1 <= L && d[heap[x]]>d[heap[y*2+1]]) x = y*2+1;

    aux = heap[x], heap[x] = heap[y], heap[y] = aux;
    P[heap[x]]=x;
    P[heap[y]]=y;
   }
 }

int dijkstra()
 {
  int i,j,r;
  for (i=1;i<=N;++i)
   for (j=1;j<=A[i][0];++j)
    if (d[i]!=inf && d[A[i][j]]!=inf)
       Cost[i][A[i][j]]+=d[i]-d[A[i][j]];

  for (i=1;i<=N;++i)
   {
    d[i]=inf;tat[i]=-1;
    P[i]=i;heap[i]=i;
   }
  P[1]=S;
  heap[S]=1;P[S]=1;
  heap[1]=S,L=N,d[S]=0;
  while (L>1 && d[heap[1]]!=inf)
   {
    for (i=1;i<=A[heap[1]][0];++i)
     {
      int v=A[heap[1]][i];
      if (C[heap[1]][v]>flux[heap[1]][v] && d[v]>d[heap[1]]+Cost[heap[1]][v])
       {
	d[v]=d[heap[1]]+Cost[heap[1]][v];
	tat[v]=heap[1];
	up_heap(P[v]);
       }
     }
    heap[1]=heap[L--];
    P[heap[1]]=1;
    if (L>1)
      down_heap(1);
   }
  if (d[D]!=inf)
   {
    drum=1;
    r=inf;
    for (i=D;i!=S;i=tat[i])
     r=min(r,C[tat[i]][i]-flux[tat[i]][i]);
    for (i=D;i!=S;i=tat[i])
     {
      flux[tat[i]][i]+=r;
      flux[i][tat[i]]-=r;
     }
    sum+=d[D];
    return sum*r;
   }
  return 0;
 }

long long Flux()
 {
  drum=1;
  long long sol=0;
  while (drum)
   {
    drum=0;
    sol+=dijkstra();
   }
  return sol;
 }

int main()
 {
  ifstream be ("fmcm.in");
  ofstream ki ("fmcm.out");
  int i, x, y, z, cap;
  be>>N>>M>>S>>D;
  for (i=1;i<=N;++i)
     {
      A[i]=(int*)realloc(A[i],sizeof(int));
      A[i][0]=0;
     }
  for (i = 1; i <= M; i++)
    {   
     be>>x>>y>>cap>>z;
	A[x][0]++;
	A[x]=(int *)realloc(A[x],(A[x][0]+1)*sizeof(int));
	A[x][A[x][0]]=y;
	A[y][0]++;
	A[y]=(int *)realloc(A[y],(A[y][0]+1)*sizeof(int));
	A[y][A[y][0]]=x;
	C[x][y] = cap;
	Cost[x][y] = z;
	Cost[y][x] = -z;
    }
  be.close();
  bellmanford();
  ki<<Flux()<<'\n';
  ki.close();
  return 0;
 }