#include <bits/stdc++.h>
using namespace std;
#define debug(fmt, ...) \
  fprintf(stderr, "[%d] " fmt "\n", __LINE__, ##__VA_ARGS__)
template <class _Tx, class _Ty>
inline void chkmin(_Tx& x, const _Ty& y) {
  x = min<common_type_t<_Tx, _Ty>>(x, y);
}
template <class _Tx, class _Ty>
inline void chkmax(_Tx& x, const _Ty& y) {
  x = max<common_type_t<_Tx, _Ty>>(x, y);
}
using ll = long long;
using ull = unsigned long long;
using i128 = __int128_t;
using u128 = __uint128_t;
bool Mbe;
template <class _Tp, class _Tc = _Tp>
struct mincostflow {
  int n, s, t;
  struct edge {
    int v, rev;
    _Tp f;
    _Tc w;
  };
  vector<vector<edge>> g;
  mincostflow(int n) {
    this->s = ++n;
    this->t = ++n;
    this->n = ++n;
    g.resize(n);
  }
  mincostflow(int n, int s, int t) {
    this->s = s;
    this->t = t;
    this->n = ++n;
    g.resize(n);
  }
  void add_edge(int u, int v, _Tp f, _Tc w) {
    int idx = g[u].size(), idy = g[v].size();
    g[u].push_back({v, idy, f, w});
    g[v].push_back({u, idx, (_Tp)0, -w});
  }
  pair<_Tp, _Tc> dinic(int s, int t) {
    _Tp ret = 0;
    _Tc cost = 0;
    vector<int> pre;
    vector<_Tp> num;
    vector<_Tc> ht, dis;
    auto spfa = [&]() {
      queue<int> que;
      vector<bool> vis(n);
      ht.assign(n, numeric_limits<_Tc>::max());
      ht[s] = 0, que.emplace(s);
      while (!que.empty()) {
        int u = que.front();
        que.pop(), vis[u] = 0;
        for (auto it : g[u]) {
          if (it.f != 0 && ht[u] + it.w < ht[it.v]) {
            ht[it.v] = ht[u] + it.w;
            if (!vis[it.v]) que.emplace(it.v), vis[it.v] = 1;
          }
        }
      }
    };
    auto dijkstra = [&]() {
      using pdi = pair<_Tc, int>;
      priority_queue<pdi, vector<pdi>, greater<>> pq;
      pre.assign(n, 0);
      num.assign(n, 0);
      dis.assign(n, numeric_limits<_Tc>::max());
      dis[s] = 0;
      num[s] = numeric_limits<_Tp>::max();
      pq.emplace(dis[s], s);
      while (!pq.empty()) {
        _Tc d;
        int u;
        tie(d, u) = pq.top(), pq.pop();
        if (dis[u] < d) continue;
        if (u == t) {
          for (int i = 0; i < n; ++i)
            chkmin(dis[i], dis[t]), ht[i] += dis[i];
          return true;
        }
        for (auto it : g[u]) {
          _Tc w = it.w + ht[u] - ht[it.v];
          if (it.f != 0 && dis[u] + w < dis[it.v]) {
            dis[it.v] = dis[u] + w;
            pre[it.v] = it.rev;
            num[it.v] = min(num[u], it.f);
            pq.emplace(dis[it.v], it.v);
          }
        }
      }
      return false;
    };
    auto update = [&]() {
      ret += num[t];
      for (int u = t; u != s; u = g[u][pre[u]].v) {
        auto& it = g[u][pre[u]];
        it.f += num[t];
        g[it.v][it.rev].f -= num[t];
        cost += g[it.v][it.rev].w * num[t];
      }
    };
    spfa();
    while (dijkstra()) update();
    return make_pair(ret, cost);
  }
  pair<_Tp, _Tc> dinic() {
    return dinic(s, t);
  }
};
bool Med;
int main() {
  // debug("Mem: %.4lfMB.", fabs(&Med - &Mbe) / 1048576);
  cin.tie(0)->sync_with_stdio(0);
  int n, m;
  cin >> n >> m;
  auto flow = mincostflow<int>(n, 1, n);
  while (m--) {
    int u, v, f, w;
    cin >> u >> v >> f >> w;
    flow.add_edge(u, v, f, w);
  }
  auto ans = flow.dinic();
  cout << ans.first << ' ' << ans.second << '\n';
  return 0;
}
/*
g++ -std=c++14 -O2 -o qoj-602 qoj-602.cpp -Wall -Wextra
-Wshadow -fsanitize=address,undefined -g
*/