#include <bits/stdc++.h>
#define NMAX 355
using namespace std;
ifstream fin("fmcm.in");
ofstream fout("fmcm.out");
int n,m,s,d;

int cost[NMAX][NMAX];
int flow[NMAX][NMAX];

vector<int> adj[NMAX];

void read()
{
    fin>>n>>m>>s>>d;
    for(int i=0;i<m;i++)
    {
        int x,y,c,z;
        fin>>x>>y>>c>>z;
        adj[x].push_back(y);
        adj[y].push_back(x);
        cost[x][y]=z;
        cost[y][x]=-z;
        flow[x][y]=c;
    }
}

int dist[NMAX];

long long ans=0;

bool bellman()
{
    queue<int> q;
    memset(dist,0x3f,sizeof(dist));
    dist[s]=0;
    bool inqueue[NMAX]={};
    q.push(s);
    while(!q.empty())
    {
        int v=q.front();
        q.pop();
        inqueue[v]=0;

        for(auto u:adj[v])
            if(flow[v][u]&&dist[u]>dist[v]+cost[v][u])
            {
                dist[u]=dist[v]+cost[v][u];
                if(!inqueue[u])
                {
                    q.push(u);
                    inqueue[u]=1;
                }
            }
    }
}

void setCost()
{
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            cost[i][j]=cost[i][j]+dist[i]-dist[j];
}

bool dijkstra()
{
    priority_queue<pair<int,int>> pq;
    bool vis[NMAX]={};
    pq.push({0,s});
    int pret[NMAX];
    memset(pret,0x3f,sizeof(pret));
    pret[s]=0;
    int daddy[NMAX];
    daddy[d]=0;
    daddy[s]=0;
    while(!pq.empty())
    {
        int v=pq.top().second;
        pq.pop();
        if(vis[v]) continue;
        vis[v]=1;
        for(auto u:adj[v])
        {
            if(flow[v][u]&&!vis[u]&&pret[v]+cost[v][u]+dist[v]-dist[u]<pret[u])
            {
                pret[u]=pret[v]+cost[v][u]+dist[v]-dist[u];
                daddy[u]=v;
                pq.push({-pret[u],u});
            }
        }
    }

    for(int i=1;i<=n;i++)
        dist[i]+=pret[i];
    int minEdge=0x3f3f3f3f;
    if(daddy[d]==0) return 0;

    for(int v=d;daddy[v];v=daddy[v])
        minEdge=min(minEdge,flow[daddy[v]][v]);
    for(int v=d;daddy[v];v=daddy[v])
    {
        flow[daddy[v]][v]-=minEdge;
        flow[v][daddy[v]]+=minEdge;
        ans+=minEdge*(cost[daddy[v]][v]);
    }
    return 1;
}


int main()
{
    read();
    bellman();
    //setCost();
    while(dijkstra());
    fout<<ans;
    return 0;
}