#include<bits/stdc++.h>
// using namespace std;


namespace IO
{
    char iobuf[1<<25],*p1=iobuf,*p2=iobuf;
    #define getchar() (p1==p2&&(p2=(p1=iobuf)+fread(iobuf,1,1<<21,stdin),p1==p2)?EOF:*p1++)
    void read(){} template <typename T,typename... other>
    inline void read(T &f,other &...y)
    {
        f=0;T fu=1;char c=getchar();
        while(c<'0'||c>'9') {if(c=='-'){fu=-1;}c=getchar();}
        while(c>='0'&&c<='9') {f=(f<<3)+(f<<1)+(c&15);c=getchar();}
        f*=fu;
        read(y...);
    }
    template <typename T> 
    void print(T x,char c=0)
    {   
        if(x<0) putchar('-'),x=-x;
        if(x<10) putchar(x+48);
        else print(x/10),putchar(x%10+48);
        if(c) putchar(c);
    }
    inline void reads(std::string &f)
    {
        std::string str="";char ch=getchar();
        while(ch<'!'||ch>'~') ch=getchar();
        while((ch>='!')&&(ch<= '~')) str+=ch,ch=getchar();
        f=str;
    }
    void prints(std::string s)
    {
        for(int i=0;s[i];++i) 
        putchar(s[i]);
    } 

#ifndef endl 
#define endl '\n'
#endif
    struct Fastiostream {
        friend Fastiostream &operator>>(Fastiostream &in,std::string &s) {reads(s); return in;}
        friend Fastiostream &operator>>(Fastiostream &in,auto &x) {read(x); return in;}
        friend Fastiostream &operator<<(Fastiostream &out,const char c) {putchar(c); return out;}
        friend Fastiostream &operator<<(Fastiostream &out,const char *c) {while(*c!=0) putchar(*(c++)); return out;}
        friend Fastiostream &operator<<(Fastiostream &out,const std::string &s) {prints(s); return out;}
        friend Fastiostream &operator<<(Fastiostream &out,const auto &x) {print(x); return out;}
    } fio;
}

template<typename T>
struct Dinic {
    int n;
    struct Edge {
        int to,nxt;
        T cap,cost;
    };

    std::vector<Edge> e;
    std::vector<int> head,now;
    std::vector<T> h,dep;
    std::vector<bool> vis;
    T inf=std::numeric_limits<T>::max()>>1;

    Dinic(int _n) : n(_n),head(n+1,-1) {}

    void add_edge(int u,int v,T cap,T cost=0) {
        e.push_back({v,head[u],cap,cost});
        head[u]=e.size()-1;
        e.push_back({u,head[v],0,-cost});
        head[v]=e.size()-1;
    }

    // Johnson algorithm
    void spfa(int s) {
        fill(h.begin(),h.end(),inf);
        std::queue<int> q;

        h[s]=0;
        q.push(0);
        vis[s]=true;
        while(!q.empty()) {
            int u=q.front();
            q.pop();
            vis[u]=false;

            for(int i=head[u];~i;i=e[i].nxt) {
                int v=e[i].to;
                if(e[i].cap>0&&h[v]>h[u]+e[i].cost) {
                    h[v]=h[u]+e[i].cost;
                    if(!vis[v]) {
                        vis[v]=true;
                        q.push(v);
                    }
                }
            }
        }
    }

    bool dij(int s,int t) {
        fill(dep.begin(),dep.end(),inf);
        fill(vis.begin(),vis.end(),false);
        
        std::priority_queue<std::pair<T,int>,std::vector<std::pair<T,int>>,std::greater<std::pair<T,int>>> pq;

        dep[s]=0;
        pq.push({0,s});
        while(!pq.empty()) {
            int u=pq.top().second;
            pq.pop();
            if(vis[u]) continue;
            vis[u]=true;

            for(int i=head[u];~i;i=e[i].nxt) if(e[i].cap>0){
                int v=e[i].to;
                auto newdep=dep[u]+e[i].cost+h[u]-h[v];
                if(dep[v]>newdep) {
                    dep[v]=newdep;
                    pq.push({dep[v],v});
                }
            }
        }

        return dep[t]!=inf;
    }

    T dfs(int u,int t,T flow) {
        if(u==t||!flow) return flow;
        T rest=flow;
        vis[u]=true;
        for(int i=now[u];~i&&rest;i=e[i].nxt) {
            now[u]=i;
            int v=e[i].to;
            if(!vis[v]&&dep[v]==dep[u]+e[i].cost+h[u]-h[v]&&e[i].cap>0) {
                T delta=dfs(v,t,std::min(rest,e[i].cap));
                if(!delta) continue;
                e[i].cap-=delta;
                e[i^1].cap+=delta;
                rest-=delta;
            }
        }
        vis[u]=false;
        return flow-rest;
    }
  
    // flag 表示初始图中是否可能存在负权边，如果存在的话需要先Johnson算法求出h函数
    auto MCMF(int s,int t,int flag=0) {
        h.assign(n+1,0); vis.assign(n+1,false); dep.resize(n+1);
        T flow=0,cost=0;
        if(flag) spfa(s);
        while(dij(s,t)) {
            fill(vis.begin(),vis.end(),false);
            now=head;
            T delta=0,tmp;

            while(tmp=dfs(s,t,inf)) 
                delta+=tmp;

            for(int i=0;i<=n;i++) 
                h[i]+=dep[i];
      
            flow+=delta,cost+=h[t]*delta;
        }
        return std::make_pair(flow,cost);
    }
  
    void resetflow(T x=0) {
        for(auto &it:e) 
            it.flow=x;
    }
};

using namespace std;
int main() {
    cin.tie(nullptr)->sync_with_stdio(false);

    int n,m; 
    IO::fio>>n>>m;

    Dinic<int> dinic(n);

    for(int i=0;i<m;i++) {
        int u,v,c,w; IO::fio>>u>>v>>c>>w;
        dinic.add_edge(u,v,c,w);
    }

    auto [flow,cost]=dinic.MCMF(1,n);
    cout<<flow<<' '<<cost<<endl;

    return 0;
}