//flux maxim
/*#include<bits/stdc++.h>
#define Dim 1000000000
#define N 1024
using namespace std;
vector <int> G[N];
queue <int> q;
int n,m,C[N][N],pred[N],f[N][N];
bool viz[N];

void read()
{
    int i,x,y,z;
    freopen("maxflow.in","r",stdin);
    scanf("%d%d",&n,&m);
    for(i=1;i<=m;i++)
    {
        scanf("%d %d %d ",&x,&y,&z);
        G[x].push_back(y);
        G[y].push_back(x);
        C[x][y]=z;
    }
}

bool bfs()
{
    int i,j,nod,nod2;
    memset(viz,0,sizeof(viz));
    q.push(1);
    viz[1]=1;
    while(!q.empty())
    {
            nod=q.front();
            q.pop();
            if(nod==n) continue;
            for(j=0;j<G[nod].size();j++)
            {
                nod2=G[nod][j];
                if(viz[nod2] || f[nod][nod2]==C[nod][nod2]) continue;
                viz[nod2]=1;
                q.push(nod2);
                pred[nod2]=nod;
            }
    }
    return viz[n];

}

int ford_fulkerson()
{


    int flow,i,f_min,nod,pj;
    for(flow=0;bfs();)
        for(i=0;i<G[n].size();i++)
     {
        pj=G[n][i];
        if(!viz[pj] || f[pj][n]==C[pj][n]) continue;
        pred[n]=pj;
        nod=n;
        f_min=Dim;
        while(nod!=1)
        {
            f_min=min(f_min,C[pred[nod]][nod]-f[pred[nod]][nod]);
            nod=pred[nod];
        }
        if(!f_min) continue;

        nod=n;
        while(nod!=1)
        {
            f[pred[nod]][nod]+=f_min;
            f[nod][pred[nod]]-=f_min;
            nod=pred[nod];
        }
        flow+=f_min;
    }


    return flow;
}

int main()
{
    read();
    freopen("maxflow.out","w",stdout);
    //cout<<bfs();
    cout<<ford_fulkerson();

}*/

//flux maxim de cost minim

#include<bits/stdc++.h>
#define N 510
#define Dim 2000000000
using namespace std;
vector <int> G[N];
queue <int> q;
int Cost[N][N],C[N][N],dist[N],pred[N],f[N][N],viz[N];
int n,m,s,d;
void read()
{
    freopen("fmcm.in","r",stdin);
    int i,x,y,z,cost;
    scanf("%d%d%d%d",&n,&m,&s,&d);
    for(i=1;i<=m;i++)
    {
        scanf("%d%d%d%d",&x,&y,&z,&cost);
        G[x].push_back(y);
        G[y].push_back(x);
        Cost[x][y]=cost;
        Cost[y][x]=-cost;
        C[x][y]=z; //capacitatea
    }
}

bool still;

int Edmond()
{
    int i,j,ok=0,h=0,nod,u=1;
    for(i=1;i<=n;i++)
    {
        dist[i]=Dim;
        pred[i]=-1;
    }
    dist[s]=0;
    memset(viz,0,sizeof(viz));
q.push(s);
viz[s]=1;

        while(!q.empty())
          {
             nod=q.front();

             q.pop();
             for(j=0;j<G[nod].size();j++)
            if(C[nod][G[nod][j]]>f[nod][G[nod][j]] && dist[nod]+Cost[nod][G[nod][j]]<dist[G[nod][j]])
        {
            dist[G[nod][j]]=dist[nod]+Cost[nod][G[nod][j]];
            pred[G[nod][j]]=nod;
            if(!viz[G[nod][j]])
            {
                q.push(G[nod][j]);
                viz[G[nod][j]]=1;
            }
        }
        viz[nod]=0;

          }


    if(dist[d]!=Dim)
    {
        //cout<<dist[d]<<endl;
        still=1;
        int aleg=Dim;
        for(i=d;i!=s;i=pred[i])
            aleg=min(aleg,C[pred[i]][i]-f[pred[i]][i]);

        for(i=d;i!=s;i=pred[i])
        {
            f[pred[i]][i]+=aleg;
            f[i][pred[i]]-=aleg;
        }
        return aleg*dist[d];

    }
    return 0;

}

long long answer()
{
    long long R=0;
    still=1;
    while(still)
    {
        still=0;
        //cout<<Edmond()<<' ';
        R+=Edmond()*1ll;
        //cout<<R<<endl;
    }
    return R;
}

int main()
{
    read();
    freopen("fmcm.out","w",stdout);
    cout<<answer();
}