#include<stdio.h>
#include<vector>
#include<algorithm>
#include<queue>
#define Nmx 355
#define INF 10001

using namespace std;

int C[Nmx][Nmx],F[Nmx][Nmx],Cst[Nmx][Nmx];
int viz[Nmx],cost[Nmx],prec[Nmx];
int n,m,s,d;
vector < int > G[Nmx];
struct cmp
{
    bool operator () (const int &a,const int &b) const
    {
        return cost[a]>cost[b];
    }
};
priority_queue <int,vector <int>,cmp> q;


void citire()
{
    scanf("%d%d%d%d",&n,&m,&s,&d);
    int x,y,c,cst;
    for(int i=1;i<=m;++i)
    {
        scanf("%d%d%d%d",&x,&y,&c,&cst);
        C[x][y]=c;
        Cst[x][y]=cst;
        Cst[y][x]=-cst;
        G[x].push_back(y);
        G[y].push_back(x);
    }
}

int dijkstra()
{
    memset(cost,INF,sizeof(cost));
    cost[s]=0;
    q.push(s);
    while(!q.empty())
    {
        int nod=q.top();q.pop();
        viz[nod]=0;
        for(int i=0;i<G[nod].size();++i)
            if(cost[G[nod][i]]>cost[nod]+Cst[nod][G[nod][i]]&&
                C[nod][G[nod][i]]-F[nod][G[nod][i]]>0)
            {
                cost[G[nod][i]]=cost[nod]+Cst[nod][G[nod][i]];
                prec[G[nod][i]]=nod;
                if(!viz[G[nod][i]])
                {
                    q.push(G[nod][i]);
                    viz[G[nod][i]]=1;
                }
            }
    }
    if(cost[d]<INF)
        return 1;
    return 0;
}

void flux()
{
    int i;
    int sol=0;

    while(dijkstra())
    {
        int Vmin=INF;
        for(i=d;i!=s;i=prec[i])
            Vmin=min(Vmin,C[prec[i]][i]-F[prec[i]][i]);
        for(i=d;i!=s;i=prec[i])
        {
            F[prec[i]][i]+=Vmin;
            F[i][prec[i]]-=Vmin;
        }
        sol+=Vmin*cost[d];
    }
    printf("%d\n",sol);
}

int main()
{
    freopen("fmcm.in","r",stdin);
    freopen("fmcm.out","w",stdout);
    citire();
    flux();
    return 0;
}