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

template<typename T>
struct Dinic {
    int n;
    struct edge {
        int to,nxt;
        T cap;
        T 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)) {
            std::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;
    }
};

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;
}

namespace MCMF {   
    using i64 = long long;
	using cap = i64;

	const int N = 1205;
	const int M = 120005;

	const i64 flow_INF = 1145141919810114514ll;
	const i64 cost_offset = 1145141919;

	int n, m, s, t;

	struct edge {
		int from, to, nxt;
		cap flow, cost;
		bool origin;
	} e[M << 1];
	int cnt;
	int h[N];

	int add_edge(int u, int v, cap flow, cap cost, bool directed = true) {
		++m;
        e[++cnt] = {u, v, h[u], flow, cost, 1};
        h[u] = cnt;
        e[++cnt] = {v, u, h[v], directed ? 0 : flow, -cost, 0};
        h[v] = cnt;
		return cnt;
	}
	int tme;
	int vis[N], fa[N], fe[N], circle[N], mark[N];
	cap pi[N];

	void dfs(int u, int fi) {
		fa[u] = e[fi].from, fe[u] = fi;
		mark[u] = 1;
		for (int i = h[u]; i; i = e[i].nxt) {
			int v = e[i].to;
			if (e[i].origin && !mark[v])
				dfs(v, i);
		}
	}

	cap phi(int u) {
		if (mark[u] == tme)
			return pi[u];
		mark[u] = tme, pi[u] = phi(fa[u]) + e[fe[u]].cost;
		return pi[u];
	}

	cap pushflow(int eg) {
		int rt = e[eg].from, lca = e[eg].to;
		++tme;
		int circle_cnt = 0;
		while (rt)
			mark[rt] = tme, rt = fa[rt];
		while (mark[lca] ^ tme)
			mark[lca] = tme, lca = fa[lca];
		cap minflow = e[eg].flow, p = 2, del_u = 0;
		for (int u = e[eg].from; u ^ lca; u = fa[u]) {
			circle[++circle_cnt] = fe[u];
			if (e[fe[u]].flow < minflow)
				minflow = e[fe[u]].flow, del_u = u, p = 0;
		}
		for (int u = e[eg].to; u ^ lca; u = fa[u]) {
			int ne = fe[u] ^ 1;
			circle[++circle_cnt] = ne;
			if (e[ne].flow < minflow)
				minflow = e[ne].flow, del_u = u, p = 1;
		}
		circle[++circle_cnt] = eg;

		cap cost = 0;
		for (int i = 1; i <= circle_cnt; ++i) {
			cost += e[circle[i]].cost * minflow;
			e[circle[i]].flow -= minflow, e[circle[i] ^ 1].flow += minflow;
		}
		if (p == 2) return cost;

		int u = e[eg].from, v = e[eg].to;
		if (p == 1) std::swap(u, v);

		int last_e = eg ^ p, last_u = v;
		while (last_u ^ del_u) {
			last_e ^= 1, --mark[u], std::swap(fe[u], last_e);
			int nu = fa[u];
			fa[u] = last_u, last_u = u, u = nu;
		}
		return cost;
	}
	void init_sz(int _n) { n = _n, m = 0, cnt = 1, tme = 1; }
	std::pair<cap, cap> solve(int _s, int _t) {
		s = _s, t = _t;
		add_edge(t, s, flow_INF, -cost_offset);
		dfs(t, 0), mark[t] = ++tme;
		fa[t] = 0;
		cap cost = 0, flow = 0;
		bool run = 1;
		while (run) {
			run = 0;
			for (int i = 2; i <= cnt; ++i)
				if (e[i].flow && e[i].cost + phi(e[i].from) - phi(e[i].to) < 0)
					cost += pushflow(i), run = 1;
		}
		flow = e[cnt].flow;
		return std::make_pair(flow, cost + flow * cost_offset);
	}
}

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

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

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

    auto [flow,cost]=MCMF::solve(1,n);
    cout<<flow<<" "<<cost<<endl;
    return 0;
}