#include<fstream.h>
#include<stdlib.h>
#define min(x,y) ((x)<(y)?(x):(y))
#define inf 2000000000
#define nx 355
int *A[nx],tat[nx],heap[nx],d[nx];
int C[nx][nx],Cost[nx][nx],flux[nx][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 && d[heap[x]]<d[heap[x/2]])
   {
    aux=heap[x];
    heap[x]=heap[x/2];
    heap[x/2]=aux;
    x>>=1;
   }
 }

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;
   }
 }

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;
  heap[1]=S,L=1;
  while (L && d[heap[1]]!=inf)
   {
    r=heap[1];
    for (i=1;i<=A[r][0];++i)
     {
      int j=A[r][i];
      if (C[r][j]>flux[r][j] && d[j]>d[r]+Cost[r][j])
       {
	d[j]=d[r]+Cost[r][j];
	heap[++L]=j;
	up_heap(L);
	tat[j]=r;
       }
     }
    heap[1]=heap[L--];
    down_heap(1);
   }
  if (d[D]!=inf)
   {
    drum=1;
    r=inf;
    for (i=1;i!=S;i=tat[i])
     r=min(r,C[tat[i]][i]-flux[tat[i]][i]);
    for (i=1;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;
 }