#include <cstdio>

#include <queue>

#include <vector>

#include <algorithm>

using namespace std;

const int INF = 2000000000;

vector<int> g[355];

int cap[355][355];

int flow[355][355];

int cost[355][355];

int dist[355];

int inq[355];

int dp[355];

int distt[355];

int parcdijk[355];

queue<int> q;

struct Node

{

    int nod,cst;

};

struct Comp

{

    bool operator()(const Node &a, const Node &b)

    {

        return a.cst>b.cst;

    }

};

priority_queue<Node, vector<Node>, Comp > pq;

int n;

void belford(int s, int d)

{

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

        dist[i]=INF;

        inq[i]=0;

    }

    q.push(s);

    dist[s]=0;

    while(!q.empty()){

        int u=q.front();

        inq[u]=0;

        q.pop();

        for(int i=0; i<g[u].size(); i++)

            if(cap[u][g[u][i]]>flow[u][g[u][i]] && dist[g[u][i]]>dist[u]+cost[u][g[u][i]]){

                dist[g[u][i]]=dist[u]+cost[u][g[u][i]];

                if(inq[g[u][i]]==0){

                    inq[g[u][i]]=1;

                    q.push(g[u][i]);

                }

            }

    }

}

bool dijkstra(int s, int d)

{

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

        dp[i]=INF;

        distt[i]=INF;

    }

    pq.push({s, 0});

    dp[s]=distt[s]=0;

    while(!pq.empty()){

        Node u=pq.top();

        pq.pop();

        if(u.cst==dp[u.nod]){

            for(int i=0; i<g[u.nod].size(); i++)

                if(flow[u.nod][g[u.nod][i]]<cap[u.nod][g[u.nod][i]] && dp[g[u.nod][i]]>dp[u.nod]+cost[u.nod][g[u.nod][i]]+dist[u.nod]-dist[g[u.nod][i]]){

                    dp[g[u.nod][i]]=dp[u.nod]+cost[u.nod][g[u.nod][i]]+dist[u.nod]-dist[g[u.nod][i]];

                    distt[g[u.nod][i]]=distt[u.nod]+cost[u.nod][g[u.nod][i]];

                    parcdijk[g[u.nod][i]]=u.nod;

                    pq.push({g[u.nod][i], dp[g[u.nod][i]]});

                }

        }

    }

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

        dist[i]=distt[i];

    return dp[d]!=INF;

}

int detflow(int s, int d)

{

    int minc=0,i;

    while(dijkstra(s, d)){

        int flu=INF;

        for(i=d; i!=s; i=parcdijk[i])

            flu=min(flu, cap[parcdijk[i]][i]-flow[parcdijk[i]][i]);

        minc+=flu*dist[d];

        for(i=d; i!=s; i=parcdijk[i]){

            flow[parcdijk[i]][i]+=flu;

            flow[i][parcdijk[i]]-=flu;

        }

    }

    return minc;

}

int main()

{   freopen("fmcm.in", "r", stdin);

    freopen("fmcm.out", "w", stdout);

    int m,s,d,i,x,y,c,z;

    scanf("%d%d%d%d", &n, &m, &s, &d);

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

        scanf("%d%d%d%d", &x, &y, &c, &z);

        g[x].push_back(y);

        g[y].push_back(x);

        cap[x][y]=c;

        cost[x][y]=z;

        cost[y][x]=-z;

    }

    belford(s, d);

    printf("%d", detflow(s, d));

    return 0;

}