#include <fstream>
#include <string.h>
#include <queue>
#include <vector>
#define pb push_back
#define mkp make_pair
#define INF 0x3f3f3f3f
#define nMax 355
using namespace std;
ifstream fin("fmcm.in");
ofstream fout("fmcm.out");
int old_d[nMax], d[nMax], F, Fcost, n, m, S, D, real_d[nMax], viz[nMax], C[nMax][nMax], Cost[nMax][nMax], TT[nMax];
vector<int> G[nMax];
priority_queue<pair<int, int>, vector<pair<int, int> >, greater<pair<int, int> > > H;
queue<int> Q;
void read()
{
    int x, y;
    fin>>n>>m>>S>>D;
    for(int i=1;i<=m;i++)
    {
        fin>>x>>y;
        G[x].pb(y);
        G[y].pb(x);
        fin>>C[x][y]>>Cost[x][y];
        Cost[y][x]=-Cost[x][y];
    }
}
void bellman_ford()
{
    memset(old_d, INF, sizeof(old_d));
    old_d[S]=0;
    viz[S]=1;
    Q.push(S);
    while(!Q.empty())
    {
        int node=Q.front();
        viz[node]=0;
        Q.pop();
        for(vector<int>::iterator it=G[node].begin();it!=G[node].end();it++)
        {
            if(C[node][*it])
            {
                int fiu=*it;
                if(old_d[node]+Cost[node][fiu]>=old_d[fiu])
                    continue;
                old_d[fiu]=old_d[node]+Cost[node][fiu];
                if(viz[fiu]==1)
                    continue;
                Q.push(fiu);
                viz[fiu]=1;
            }
        }
    }
}
bool dijkstra()
{
    memset(d, INF, sizeof(d));
    d[S]=0, real_d[S]=0;
    H.push(mkp(d[S], S));
    while(!H.empty())
    {
        int cost=H.top().first, node=H.top().second;
        H.pop();
        if(d[node]!=cost)
            continue;
        for(vector<int>::iterator it=G[node].begin();it!=G[node].end();it++)
        {
            if(C[node][*it])
            {
                int fiu=*it;
                int new_d=d[node]+old_d[node]+Cost[node][fiu]-old_d[fiu];
                if(new_d<d[fiu])
                {
                    d[fiu]=new_d;
                    real_d[fiu]=real_d[node]+Cost[node][fiu];
                    TT[fiu]=node;
                    H.push(mkp(d[fiu], fiu));
                }
            }
        }
    }
    memcpy(old_d, real_d, sizeof(old_d));
    if(d[D]==INF)
        return 0;
    return 1;
}
void solve()
{
    bellman_ford();
    for(F=0, Fcost=0;dijkstra();)
    {
        int Min=INF, curCost=0;
        for(int aux=D;aux!=S;aux=TT[aux])
        {
            Min=min(Min, C[TT[aux]][aux]);
            curCost+=Cost[TT[aux]][aux];
        }
        for(int aux=D;aux!=S;aux=TT[aux])
        {
            C[TT[aux]][aux]-=Min;
            C[aux][TT[aux]]+=Min;
        }
        Fcost+=Min*real_d[D];
        F+=Min;
    }
}
void write()
{
    fout<<Fcost;
}
int main()
{
    read();
    solve();
    write();
    return 0;
}