#include <fstream>
#include <vector>

struct Arc{
    int v,c,u,f;
    size_t back;
};

class Graph{
private:
    std::vector<std::vector<Arc>> adjList;
    int n;
    int m;
    int s;
    int t;

    int flow;
    int cost;

    void addOriented(int a,int b,int u,int c){
        Arc r1 = { b, u, c, 0, adjList[b].size() };
        Arc r2 = { a, 0, -c, 0, adjList[a].size() };
        adjList[a].push_back (r1);
        adjList[b].push_back (r2);
    }
public:
    Graph(int n,int m,int s,int t){
        adjList.resize(n);
        this->n=n;
        this->m=m;
        this->s=s;
        this->t=t;
        flow=0;
        cost=0;
    }
    void add(int a,int b,int u,int c){
        addOriented(a, b, u, c);
        addOriented(b, a, u, c);
    }
    int getCost(){
        return cost;
    }
    int getFlow(){
        return flow;
    }
    void countCostAndFlow(){

        int k=INT_MAX;

        while (flow < k) {
            std::vector<int> id (n, 0);
            std::vector<int> d (n, INT_MAX);
            std::vector<int> q (n);
            std::vector<int> p (n);
            std::vector<size_t> p_rib (n);
            int qh=0, qt=0;
            q[qt++] = s;
            d[s] = 0;
            while (qh != qt) {
                int v = q[qh++];
                id[v] = 2;
                if (qh == n)  qh = 0;
                for (size_t i=0; i<adjList[v].size(); ++i) {
                    Arc & r = adjList[v][i];
                    if (r.f < r.u && d[v] + r.c < d[r.v]) {
                        d[r.v] = d[v] + r.c;
                        if (id[r.v] == 0) {
                            q[qt++] = r.v;
                            if (qt == n)  qt = 0;
                        }
                        else if (id[r.v] == 2) {
                            if (--qh == -1)  qh = n-1;
                            q[qh] = r.v;
                        }
                        id[r.v] = 1;
                        p[r.v] = v;
                        p_rib[r.v] = i;
                    }
                }
            }
            if (d[t] == INT_MAX)  break;
            int addflow = k - flow;
            for (int v=t; v!=s; v=p[v]) {
                int pv = p[v];  size_t pr = p_rib[v];
                addflow = min (addflow, adjList[pv][pr].u - adjList[pv][pr].f);
            }
            for (int v=t; v!=s; v=p[v]) {
                int pv = p[v];  size_t pr = p_rib[v],  r = adjList[pv][pr].back;
                adjList[pv][pr].f += addflow;
                adjList[v][r].f -= addflow;
                cost += adjList[pv][pr].c * addflow;
            }
            flow += addflow;
        }
    }
    int min(int a,int b){
        return a<b ? a : b;
    }
};

int main(int argc, const char * argv[]) {
    std::ifstream fin("input.txt");
    std::ofstream fout("output.txt");

    int n,m,s,t;
    fin>>n>>m>>s>>t;

    s--;
    t--;

    Graph gr(n,m,s,t);

    int a,b,u,c;

    for(int i=0;i<m;i++){
        fin>>a>>b>>u>>c;
        gr.add(a-1, b-1, u, c);
    }

    gr.countCostAndFlow();

    fout<<gr.getFlow()<<"\n"<<gr.getCost()<<"\n";

    return 0;
}