#include <algorithm>
#include <iostream>
#include <limits>
#include <queue>
#include <vector>

using i64 = long long;
using i128 = __int128_t;
using u32 = unsigned int;
using u64 = unsigned long long;
using u128 = __uint128_t;

template <typename Cap, typename Cost>
struct MinCostMaxflow
{
  struct edge_t 
  {
    const int u, v;
    const Cap cap;
    const Cost cost;
    Cap flow;

    edge_t(int u, int v, Cap cap, Cost cost) : u(u), v(v), cap(cap), cost(cost), flow(0) {}

    Cap remain() const { return cap - flow; }
    bool empty() const { return remain() <= 0; }
  };

  int n;

  std::vector<edge_t> edges;
  std::vector<std::vector<int>> adj;
  std::vector<Cost> dis;
  std::vector<int> ptr;
  std::vector<bool> instk;

  MinCostMaxflow(int n) : n(n), adj(n), dis(n), ptr(n), instk(n) {}

  void add_edge(int u, int v, Cap cap, Cost cost)
  {
    adj[u].emplace_back(edges.size());
    edges.emplace_back(u, v, cap, cost);
    adj[v].emplace_back(edges.size());
    edges.emplace_back(v, u, 0, -cost);
  }

  bool spfa(int s, int t)
  {
    std::fill(dis.begin(), dis.end(), std::numeric_limits<Cost>::max());
    std::vector<bool> inq(n);
    std::queue<int> q;

    dis[s] = 0;
    q.emplace(s);
    inq[s] = true;

    while (!q.empty()) {
      auto u = q.front();
      q.pop();
      inq[u] = false;

      for (auto ei : adj[u]) {
        const auto &e = edges[ei];
        if (e.empty()) continue;
        if (dis[e.v] > dis[u] + e.cost) {
          dis[e.v] = dis[u] + e.cost;
          if (!inq[e.v]) {
            q.emplace(e.v);
            inq[e.v] = true;
          }
        }
      }
    }

    return dis[t] != std::numeric_limits<Cost>::max();
  }

  std::pair<Cap, Cost> dfs(int u, Cap cap, int t)
  {
    if (cap == 0) return {0, 0};
    if (u == t) return {cap, 0};

    instk[u] = true;

    Cap flow = 0;
    Cost cost = 0;
    for (int &i = ptr[u]; i < (int)adj[u].size(); i++) {
      int ei = adj[u][i];
      auto &e = edges[ei];
      auto &ie = edges[ei ^ 1];

      if (e.empty()) continue;
      if (dis[e.v] != dis[u] + e.cost) continue;
      if (instk[e.v]) continue;

      auto [retf, retc] = dfs(e.v, std::min(cap - flow, e.remain()), t);

      e.flow += retf;
      ie.flow -= retf;

      flow += retf;
      cost += retf * e.cost + retc;

      if (cap - flow == 0) break;
    }

    instk[u] = false;

    return {flow, cost};
  }

  std::pair<Cap, Cost> flow(int s, int t, Cap cap = std::numeric_limits<Cap>::max())
  {
    Cap flow = 0;
    Cost cost = 0;

    while (true) {
      if (!spfa(s, t)) break;
      std::fill(ptr.begin(), ptr.end(), 0);
      while (true) {
        auto [retf, retc] = dfs(s, cap - flow, t);
        flow += retf;
        cost += retc;
        if (retf == 0) break;
      }
    }

    return {flow, cost};
  }
};

int main()
{
  int n, m;
  std::cin >> n >> m;

  MinCostMaxflow<int, int> mcmf(n);

  for (int i = 0; i < m; i++) {
    int u, v, cap, cost;
    std::cin >> u >> v >> cap >> cost;
    u--;
    v--;
    mcmf.add_edge(u, v, cap, cost);
  }

  auto [flow, cost] = mcmf.flow(0, n - 1);

  std::cout << flow << " " << cost << std::endl;
}