#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:32000000")
const int nil = -1;
using namespace std;
inline bool read(int& val) { return scanf("%d", &val) != -1; }
inline bool read(long long& val) { return scanf("%I64d", &val) != -1; }
inline bool read(double& val) { return scanf("%lf", &val) != -1; }
inline bool read(char* val) { return scanf("%s", val) != -1; }
template <class T1, class T2>
inline bool read(T1& a, T2& b) {
  return read(a) && read(b);
}
template <class T1, class T2, class T3>
inline bool read(T1& a, T2& b, T3& c) {
  return read(a) && read(b) && read(c);
}
template <class T1, class T2, class T3, class T4>
inline bool read(T1& a, T2& b, T3& c, T4& d) {
  return read(a) && read(b) && read(c) && read(d);
}
template <class T1, class T2, class T3, class T4, class T5>
inline bool read(T1& a, T2& b, T3& c, T4& d, T5& e) {
  return read(a) && read(b) && read(c) && read(d) && read(e);
}
const int N = 1111111;
const long long mod = 1000000007;
struct tree {
  int n;
  int head[N];
  int to[N];
  int next[N];
  long long U[N], V[N], W[N], P[N];
  void init(int n) {
    this->n = n;
    for (int i = 0, _ = (n); i < _; ++i) head[i] = nil;
  }
  void add_(int e, int u, int v, long long w, long long p) {
    W[e] = w;
    P[e] = p;
    to[e] = v;
    next[e] = head[u];
    head[u] = e;
  }
  void add(int e, int u, int v, long long w, long long p) {
    U[e] = u, V[e] = v;
    add_(e * 2 + 0, u, v, w, p);
    add_(e * 2 + 1, v, u, w, p);
  }
  long long sum[N], can[N], canE[N], dec[N], all[N];
  bool dfs(int u, int p) {
    sum[u] = can[u] = dec[u] = 0;
    for (int e = head[u], v; e != nil && (v = to[e], true); e = next[e])
      if (v != p) {
        if (!dfs(v, u)) return false;
        canE[e] = min(W[e] - 1, P[e] - (sum[v] - can[v]));
        if (canE[e] < 0) return false;
        sum[u] += sum[v] + W[e];
        can[u] += can[v] + canE[e];
        dec[v] = max(0ll, sum[v] - all[v] - P[e]);
        all[v] += dec[v];
        all[u] += all[v];
      }
    return true;
  }
  bool solve(int u, int p) {
    if (all[u] > can[u]) return false;
    for (int e = head[u], v; e != nil && (v = to[e], true); e = next[e])
      if (v != p) {
        int d = min(dec[u], can[v] - all[v]);
        all[v] += d;
        dec[v] += d;
        dec[u] -= d;
        d = min(dec[u], canE[e]);
        P[e] -= d;
        W[e] -= d;
        dec[u] -= d;
      }
    for (int e = head[u], v; e != nil && (v = to[e], true); e = next[e])
      if (v != p) {
        if (!solve(v, u)) return false;
      }
    return true;
  }
} t;
int main() {
  int n;
  read(n);
  t.init(n + 1);
  for (int i = 0, _ = (n - 1); i < _; ++i) {
    int u, v, w, p;
    read(u, v, w, p);
    t.add(i, u, v, w, p);
  }
  if (t.dfs(1, -1) && t.solve(1, -1)) {
    printf("%d\n", n);
    for (int e = 0, _ = (n - 1); e < _; ++e) {
      printf("%I64d %I64d %I64d %I64d\n", t.U[e], t.V[e], t.W[e * 2],
             t.P[e * 2]);
    }
  } else {
    printf("%d\n", -1);
  }
  return 0;
}
