#include <bits/stdc++.h>



const int oo=1e9;



using namespace std;



ifstream f("fmcm.in");

ofstream g("fmcm.out");



int n,m,S,D,i,j,fluxmax,C[360][360],cap[360][360],dist[360];

vector<int> v[360];



bool djikstra()

{

    priority_queue<pair<int,int> > Q;

    int d[360],real_d[360],tata[360];

    for(i=1;i<=n;i++)

        d[i]=real_d[i]=oo,tata[i]=0;

    d[S]=real_d[S]=0;Q.push({0,S});

    while(Q.size())

    {

        int x=Q.top().second,

         cost=-Q.top().first;

        Q.pop();

        if(d[x]<cost)continue;

        for(auto it:v[x])

            if(cap[x][it])

            {

                int new_d=d[x]+C[x][it]+dist[x]-dist[it];

                if(new_d<d[it])

                {

                    d[it]=new_d;

                    real_d[it]=real_d[x]+C[x][it];

                    tata[it]=x;

                    Q.push({-d[it],it});

                }

            }

    }

    for(i=1;i<=n;i++)

        dist[i]=real_d[i];

    if(dist[D]==oo)return 0;

//    for(i=1;i<=n;i++)

//        cout<<dist[i]<<' ';cout<<'\n';

    int x=D,flux=oo;

    while(tata[x]!=0)

    {

        flux=min(flux,cap[tata[x]][x]);

        x=tata[x];

    }

    x=D;

    //cout<<flux<<'\n';

    while(tata[x]!=0)

    {

        cap[tata[x]][x]-=flux;

        cap[x][tata[x]]+=flux;

        x=tata[x];

    }

    fluxmax+=flux*dist[D];

    return 1;

}



void bellman()

{

    queue<int> Q;

    bitset<360> in;

    for(i=1;i<=n;i++)

        dist[i]=oo,in[i]=0;

    dist[S]=0;in[S]=1;Q.push(S);

    while(Q.size())

    {

        int x=Q.front();

        Q.pop();in[x]=0;

        for(auto it:v[x])

            if(cap[x][it])

                if(dist[it]>dist[x]+C[x][it])

                {

                    dist[it]=dist[x]+C[x][it];

                    if(!in[it])

                    {

                        in[it]=1;

                        Q.push(it);

                    }

                }

    }

    return ;

}



int main()

{

    f>>n>>m>>S>>D;

    for(i=1;i<=m;i++)

    {

        int x,y,c,z;

        f>>x>>y>>c>>z;

        cap[x][y]=c;

        C[x][y]=z;

        C[y][x]=-z;

        v[x].push_back(y);

        v[y].push_back(x);

    }

    bellman();

//    for(i=1;i<=n;i++)

//        cout<<dist[i]<<' ';cout<<'\n';

    for(;djikstra(););

    g<<fluxmax;

    return 0;

}