#include <cstdio>
        #include <cstring>
        #include <vector>
        #include <queue>
        #define INF 1000000
        using namespace std;
        struct bellman_ford
        {
            vector <int> nod;
            vector <int> cost;
        };
        bellman_ford g[50001];
        queue <int> q;
        int flux[1001][1001], capacitate[1001][1001], tata[1001], Cost[1001], nrit[1001], n, sursa, destinatie, sol=0;
        bool used[1001];
        int min (int x, int y)
        {
            if (x<y) return x;
            return y;
        }
        int bellmanford (void)
        {
            int nod, i;
            while (!q.empty()) q.pop(); q.push(sursa);
            memset(used,false,sizeof(used)); memset(Cost,INF,sizeof(Cost)); memset(nrit,0,sizeof(nrit)); memset(tata,0,sizeof(tata));
            used[sursa]=false; Cost[sursa]=0;
            while (!q.empty())
            {
                nod=q.front();
                q.pop();
                used[nod]=false;
                for (i=0; i<g[nod].nod.size(); i++)
                {
                    if (Cost[nod]+g[nod].cost[i]<Cost[g[nod].nod[i]] && flux[nod][g[nod].nod[i]]<capacitate[nod][g[nod].nod[i]])
                    {
                        Cost[g[nod].nod[i]]=Cost[nod]+g[nod].cost[i];
                        if (!used[g[nod].nod[i]])
                        {
                            used[g[nod].nod[i]]=true;
                            q.push(g[nod].nod[i]);
                            nrit[g[nod].nod[i]]++;
                            tata[g[nod].nod[i]]=nod;
                            if (g[nod].nod[i]==destinatie)
                            {
                                return 1;
                            }
                        }
                    }
                }
            }
            return 0;
        }
        void flux_maxim (void)
        {
            int i, j, r;
            while (bellmanford())
            {
                for (i=0; i<g[n].nod.size(); i++)
                {
                    if (tata[g[n].nod[i]]==-1 || capacitate[g[n].nod[i]][n]<=flux[g[n].nod[i]][n]) continue;
                    r=INF; tata[destinatie]=g[n].nod[i];
                    for (j=destinatie; j!=sursa; j=tata[j])
                    {
                        r=min(r,capacitate[tata[j]][j]-flux[tata[j]][j]);
                    }
                    if (r<=0) continue;
                    for (j=destinatie; j!=sursa; j=tata[j])
                    {
                        flux[tata[j]][j]+=r;
                        flux[j][tata[j]]-=r;
                    }
                    sol+=r;
                }
            }
        }
        int main()
        {
            int m, i, x, y, z, t;
            freopen("fmcm.in","r",stdin);
            freopen("fmcm.out","w",stdout);
            scanf("%d%d%d%d",&n,&m,&sursa,&destinatie);
            for (i=1; i<=m; i++)
            {
                scanf("%d%d%d%d",&x,&y,&z,&t);
                capacitate[x][y]=z;
                g[x].nod.push_back(y);
                g[y].nod.push_back(x);
                g[x].cost.push_back(t);
                g[y].cost.push_back(t);
            }
            flux_maxim();
            printf("%d",sol);
            fclose(stdin);
            fclose(stdout);
            return 0;
        }