#include<cstdio>
#include<queue>
#include<cstdlib>
#define MAX_N 350
#define oo 2000000000
using namespace std;

int C[MAX_N+1][MAX_N+1], Cost[MAX_N+1][MAX_N+1], dist[MAX_N+1], T[MAX_N+1], n, m, S, D, costmin;
int f[MAX_N+1][MAX_N+1];
bool used[MAX_N+1];

struct Node
{
    int val;
    Node* next;
};

Node* L[MAX_N+1];

inline int minim(int x, int y)
{
    if(x < y) return x;
    return y;
}

inline void insertBack(int x, int y)
{
    Node* elem = (Node*)malloc(sizeof(Node));
    elem->val = y;
    elem->next = L[x];
    L[x] = elem;
}

int BellmanFord(int x)
{
    queue<int>Q;
    int i, node;
    Node* p;
    for(i=1; i<=n; i++)
    {
        dist[i] = oo;
        used[i] = false;
        T[i] = 0;
    }
    dist[x] = 0;
    Q.push(x);
    used[x] = true;
    while(!Q.empty())
    {
        node = Q.front();
        Q.pop();
        used[node] = false;
        p = L[node];
        while(p != NULL)
        {
            if(f[node][p->val] < C[node][p->val] && dist[p->val] > dist[node] + Cost[node][p->val])
            {
                dist[p->val] = dist[node] + Cost[node][p->val];
                T[p->val] = node;
                if(!used[p->val])
                {
                    Q.push(p->val);
                    used[p->val] = true;
                }
            }
            p = p->next;
        }
    }
    if(dist[D] == oo) return 0;
    return 1;
}

int main()
{
    int i, x, cap, cost, flux, node, y, ok;
    FILE *fin, *fout;
    fin = fopen("fmcm.in","r");
    fout = fopen("fmcm.out","w");
    fscanf(fin,"%d%d%d%d",&n,&m,&S,&D);
    for(i=1; i<=m; i++)
    {
        fscanf(fin,"%d%d%d%d",&x,&y,&cap,&cost);
        insertBack(x,y);
        insertBack(y,x);
        C[x][y] = cap;
        Cost[x][y] = cost;
        Cost[y][x] = -cost;
    }
    ok = 1;
    BellmanFord(S);
    while(ok)
    {
        flux = oo;
        for(node = D; node != S; node = T[node])
           flux = minim(flux,C[T[node]][node] - f[T[node]][node]);

        for(node = D; node != S; node = T[node])
        {
            f[T[node]][node] += flux;
            f[node][T[node]] -= flux;
        }
        costmin += flux * dist[D];
        ok = BellmanFord(S);
    }
    fprintf(fout,"%d\n",costmin);
    fclose(fin);
    fclose(fout);
    return 0;
}