#include <cassert>
#include <limits>
#include <vector>

#include <vector>

namespace exodus{
	namespace internal{
		template <class T> struct simple_queue{
			std::vector<T>q;
			int pos;
			simple_queue():pos(0){}
			void reserve(int n){q.reserve(n);}
			int size()const{return (int)q.size()-pos;}
			bool empty()const{return pos==(int)q.size();}
			void push(const T& t){q.push_back(t);}
			void emplace(const T& t){q.emplace_back(t);}
			T &front(){return q[pos];}
			void clear(){q.clear();pos=0;}
			void pop(){pos++;}
		};
	}
}


namespace exodus{
	template<typename T,typename U>
	struct mcf_graph{
	public:
		mcf_graph(){n=0;}
		explicit mcf_graph(int _n){n=_n;g.resize(n);}
		struct edge{
			int from,to;
			T cap,flow;
			U cost;
			edge(){from=to=cap=flow=cost=0;}
			edge(int _from,int _to,T _cap,T _flow,T _cost):
				from(_from),to(_to),cap(_cap),flow(_flow),cost(_cost){}
		};
		void add_edge(int u,int v,T c,U w){
			int pu=g[u].size(),pv=g[v].size();
			g[u].emplace_back(v,pv,c,w);
			g[v].emplace_back(u,pu,0,-w);
			pos.emplace_back(u,pu);
		}
		edge get_edge(int i){
			auto &e=g[pos[i].first][pos[i].second];
			auto &re=g[e.to][e.rev];
			return edge(pos[i].first,e.to,e.cap+re.cap,re.cap,e.cost);
		}
		std::vector<edge> edges(){
			std::vector<edge>res;
			for(int i=0;i<(int)pos.size();i++)
				res.emplace_back(get_edge(i));
			return res;
		}
		void change_edge(int i,T cap,T flow,U cost){
			auto &e=g[pos[i].first][pos[i].second];
			auto &re=g[e.to][e.rev];
			e.cap=cap-flow,re.cap=flow;e.cost=cost,re.cost=-cost;
		}
		std::pair<T,U> simple_flow(int s,int t){
			return simple_flow(s,t,std::numeric_limits<T>::max());
		}
		std::pair<T,U> simple_flow(int s,int t,T flow_limit){
			std::vector<U> dis(n);
			std::vector<int> pre(n),inq(n);
			std::vector<int> lse(n);
			std::vector<T> lim(n);
			auto spfa=[&](){
				fill(dis.begin(),dis.end(),std::numeric_limits<T>::max());
				fill(pre.begin(),pre.end(),-1);
				fill(inq.begin(),inq.end(),0);
				fill(lse.begin(),lse.end(),0);
				fill(lim.begin(),lim.end(),std::numeric_limits<T>::max());
				dis[s]=0,pre[t]=-1;
				internal::simple_queue<int> q;
				q.emplace(s);inq[s]=1;
				while(!q.empty()){
					int u=q.front();q.pop();
					inq[u]=0;
					for(auto &e:g[u]){
						if(e.cap&&dis[e.to]>dis[u]+e.cost){
							dis[e.to]=dis[u]+e.cost;
							pre[e.to]=u;
							lse[e.to]=e.rev;
							lim[e.to]=std::min(lim[u],e.cap);
							if(!inq[e.to])
								inq[e.to]=1,q.emplace(e.to);
						}
					}
				}
				return pre[t]!=-1;
			};
			std::pair<T,U> res(0,0);
			while(flow_limit!=T()&&spfa()){
				int u=t;
				T f=std::min(lim[t],flow_limit);
				res.first+=f;
				res.second+=f*dis[t];
				while(u!=s){
					g[u][lse[u]].cap+=f;
					g[g[u][lse[u]].to][g[u][lse[u]].rev].cap-=f;
					u=pre[u];
				}
			}
			return res;
		}
	private:
		struct edge_info{
			int to,rev;
			T cap;
			U cost;
			edge_info(){to=rev=cap=cost=0;}
			edge_info(int _to,int _rev,T _cap,T _cost):
				to(_to),rev(_rev),cap(_cap),cost(_cost){}
		};
		int n;
		std::vector<std::pair<int,int>> pos;
		std::vector<std::vector<edge_info>> g;
	};
}

#include<bits/stdc++.h>
using namespace std;
int main(){
	cin.tie(nullptr)->sync_with_stdio(false);
	vector<vector<int>::iterator>vec;
	int n,m,s,t;
	cin>>n>>m;
	s=1,t=n;
	exodus::mcf_graph<int,int> G(n);
	for(int i=0,u,v,c,w;i<m;i++){
		cin>>u>>v>>c>>w;
		G.add_edge(u-1,v-1,c,w);
	}
	auto res=G.simple_flow(s-1,t-1);
	cout<<res.first<<' '<<res.second<<'\n';
	return 0;
}