#include <fstream>

#include <vector>

#include <cstring>

#include <queue>

#include <iostream>

using namespace std;



#define maxn  360



ifstream be("fmcm.in");

ofstream ki("fmcm.out");

int cap[maxn][maxn];

int c[maxn][maxn];

vector<int>adj[maxn];

int new_d[maxn],old_d[maxn],real_d[maxn], d[maxn],l[maxn],in[maxn];

queue<int>q;

int n,m,fin,start;

int flow,flow_cost;

bool in_queue[maxn];

bool dijkstra()

{

    memset(d,0x3f,sizeof(d));

    d[start]=0;

    real_d[start]=0;

    priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int>> >q;

    q.push({d[start],start});

    while(!q.empty())

    {

        auto best=q.top();

        int du=best.first;

        int u=best.second;



        q.pop();



        if(du!=d[u])continue;



        for(auto p :adj[u])

        {

            if(cap[u][p]){

                int new_d = d[u] + c[u][p] + old_d[u] - old_d[p];

                if (new_d < d[p])

                {

                    d[p] = new_d;

                    real_d[p] = real_d[u] + c[u][p];

                    l[p] = u;

                    //cout<<p<<endl;

                    q.push({d[p], p});

                }

            }

        }

    }

    memcpy(old_d,real_d,sizeof(d));

    if(d[fin]==0x3f3f3f3f)

        return false;

    int minim=0x3f3f3f3f,curcs=0;

    for(int i=fin;i!=start;i=l[i]){

        minim=min(minim,cap[l[i]][i]);

        curcs+=c[l[i]][i];

    }

    flow+=minim;

    flow_cost+=minim*real_d[fin];

    for(int i=fin;i!=start;i=l[i])

    {

        cap[l[i]][i]-=minim;

        cap[i][l[i]]+=minim;

    }

    return true;

}





bool bellmanford()

{

    memset(old_d,0x3f,sizeof(old_d));

    old_d[start]=0;

    //q.push(start);

    for(q.push(start),in[start]=1;!q.empty();q.pop())

    {

        int i=q.front();

        in_queue[i]=false;

        for(auto p:adj[i])

        {

            if(cap[i][p])

            {

                if(old_d[i]+c[i][p]>=old_d[p])

                    continue;

                old_d[p]=old_d[i]+c[i][p];

                if(in_queue[p])

                    continue;

                in_queue[p]=true;

                q.push(p);



            }

        }

    }

    if(old_d[fin]==0x3f3f3f3f)

        return false;

    return true;



}



int main()

{

    be>>n>>m>>start>>fin;

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

    {

        int x,y,capa,z;

        be>>x>>y>>capa>>z;

        adj[x].push_back(y);

        adj[y].push_back(x);

        cap[x][y]=capa;

        c[x][y]=z;

        c[y][x]=-z;

    }

    flow=flow_cost=0;

    bellmanford();

    while(dijkstra());

    ki<<flow_cost;



    return 0;

}