#include <bits/stdc++.h>

#define pb push_back
#define mp make_pair
#define f first
#define s second
#define MAXN 352
#define DIM 8192

using namespace std;

ifstream fin("fmcm.in");
ofstream g("fmcm.out");

int n,m,c[MAXN][MAXN],f[MAXN][MAXN],old_d[MAXN],ds[MAXN],real_d[MAXN],inq[MAXN],s,d,x,y,new_d,t[MAXN],flux,ct_flux;
priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int> > > h;
queue<int> q;
vector<int> G[MAXN];
vector<int>::iterator it;

void bellman()
{
    memset(old_d,0x3f,sizeof(old_d));
    old_d[s]=0;
    q.push(s);
    inq[s]=1;
    while(!q.empty())
    {
        x=q.front();
        q.pop();
        inq[x]=0;
        for(it=G[x].begin();it!=G[x].end();it++)
            if(f[x][*it]&&old_d[*it]>old_d[x]+c[x][*it])
            {
                old_d[*it]=old_d[x]+c[x][*it];
                if(!inq[*it])
                {
                    q.push(*it);
                    inq[*it]=1;
                }
            }
    }
}

bool dijkstra()
{
    memset(ds,0x3f,sizeof(ds));
    real_d[s]=ds[s]=0;
    h.push(mp(ds[s],s));
    while(!h.empty())
    {
        y=h.top().f;
        x=h.top().s;
        h.pop();
        if(y!=ds[x])continue;
        for(it=G[x].begin();it!=G[x].end();it++)
            if(f[x][*it])
            {
                new_d=ds[x]+c[x][*it]+old_d[x]-old_d[*it];
                if(new_d<ds[*it])
                {
                    ds[*it]=new_d;
                    real_d[*it]=real_d[x]+c[x][*it];
                    t[*it]=x;
                    h.push(mp(ds[*it],*it));
                }
            }
    }
    memcpy(old_d,real_d,sizeof(ds));
    if(ds[d]==0x3f3f3f3f) return 0;
    int Min=0x3f3f3f3f;
    for(x=d;x!=s;x=t[x])
        Min=min(Min,f[t[x]][x]);
    flux+=Min;
    ct_flux+=Min*real_d[d];
    for(x=d;x!=s;x=t[x])
    {
        f[t[x]][x]-=Min;
        f[x][t[x]]+=Min;
    }
    return 1;
}

int main()
{
    ios_base::sync_with_stdio(false);
    fin>>n>>m>>s>>d;
    for(int i=1;i<=m;i++)
    {
        fin>>x>>y;
        G[x].pb(y);
        G[y].pb(x);
        fin>>f[x][y]>>c[x][y];
        c[y][x]=-c[x][y];
    }
    bellman();
    while(dijkstra());
    g<<ct_flux;
    return 0;
}