#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <bitset>
using namespace std;
const int inf=2000000000;
struct heap
{
    int nod,c;
    bool operator <(const heap &aux) const
    {
        return c>aux.c;
    }
};
ifstream si("fmcm.in");
ofstream so("fmcm.out");
vector<int> v[355];
queue<int> q;
priority_queue<heap> h;
int c[355][355],dist[355],dist1[355],cap[355][355],flow[355][355],d[355],tata[355],sursa,dest,n;
bitset<355>vaz;
void bellman_ford()
{
    int i;
    for(i=1;i<=n;i++)
        dist[i]=inf;
    dist[sursa]=0;
    q.push(sursa);
    vaz[sursa]=1;
    vector<int>::iterator it;
    while(!q.empty())
    {
        int nod=q.front();
        q.pop();
        vaz[nod]=0;
        for(it=v[nod].begin();it!=v[nod].end();it++)
        {
            if(cap[nod][*it]&&dist[*it]>dist[nod]+c[nod][*it])
            {
                dist[*it]=dist[nod]+c[nod][*it];
                if(!vaz[*it]&&*it!=dest)
                {
                    vaz[*it]=1;
                    q.push(*it);
                }
            }
        }
    }
}
bool dijkstra()
{
    int i;
    for(i=1;i<=n;i++)
        d[i]=dist1[i]=inf;
    d[sursa]=dist1[sursa]=0;
    h.push({sursa,0});
    vector<int>::iterator it;
    while(!h.empty())
    {
        int nod=h.top().nod;
        int cost=h.top().c;
        h.pop();
        if(d[nod]!=cost)
            continue;
        for(it=v[nod].begin();it!=v[nod].end();it++)
            if(cap[nod][*it]>flow[nod][*it]&&d[*it]>d[nod]+c[nod][*it]+dist[nod]-dist[*it])
            {
                d[*it]=d[nod]+c[nod][*it]+dist[nod]-dist[*it];
                dist1[*it]=dist1[nod]+c[nod][*it];
                tata[*it]=nod;
                if(*it!=dest)
                    h.push({*it,d[*it]});
            }
    }
    for(i=1;i<=n;i++)
        dist[i]=dist1[i];
    return (d[dest]!=inf);
}
int main()
{
    int m,x,y,a,cost,sol=0,i;
    si>>n>>m>>sursa>>dest;
    for(i=1;i<=m;i++)
    {
        si>>x>>y>>a>>cost;
        v[x].push_back(y);
        v[y].push_back(x);
        cap[x][y]=a;
        c[x][y]=cost;
        c[y][x]=-cost;
    }
    bellman_ford();
    int dm;
    while(dijkstra())
    {
        dm=inf;
        for(i=dest;i!=sursa;i=tata[i])
            dm=min(dm,cap[tata[i]][i]-flow[tata[i]][i]);
        for(i=dest;i!=sursa;i=tata[i])
        {
            flow[tata[i]][i]+=dm;
            flow[i][tata[i]]-=dm;
        }
        sol+=dm*dist[dest];
    }
    cout<<sol;
    return 0;
}