#include <bits/stdc++.h>
using std::make_pair;
using std::pair;
const int N = 1000 + 10;
std::vector<std::tuple<int, int, int>> edges;
std::vector<int> neighbors[N];
int weights[N], size[N], father[N], n;
namespace union_set {
int ancestor[N], size[N];
void init(int n) {
  for (int i = 1; i <= n; ++i) {
    ancestor[i] = i;
    size[i] = 1;
  }
}
int get_ancestor(int u) {
  return ancestor[u] == u ? u : ancestor[u] = get_ancestor(ancestor[u]);
}
void merge(int u, int v) {
  u = get_ancestor(u);
  v = get_ancestor(v);
  if (size[u] < size[v]) {
    std::swap(u, v);
  }
  size[u] += size[v];
  ancestor[v] = u;
}
}  // namespace union_set
void dfs(int u, int f) {
  size[u] = 1;
  father[u] = f;
  for (auto v : neighbors[u]) {
    if (v == f) continue;
    dfs(v, u);
    size[u] += size[v];
  }
}
void paint(int u, int f, int set_root, int coeff) {
  int s = 0;
  for (auto v : neighbors[u]) {
    if (v == f) continue;
    if (set_root == -1 || union_set::get_ancestor(v) == set_root) {
      edges.push_back(std::make_tuple(u, v, (s + 1) * coeff));
      paint(v, u, -1, coeff);
      s += size[v];
    }
  }
}
void run(int case_id = 0) {
  std::cin >> n;
  for (int i = 1; i < n; ++i) {
    int u, v;
    std::cin >> u >> v;
    neighbors[u].push_back(v);
    neighbors[v].push_back(u);
  }
  if (n == 1) return;
  if (n == 2) {
    std::cout << "1 2 1" << std::endl;
    return;
  }
  dfs(1, -1);
  int root = 0, max_size = 0;
  for (int u = 1; u <= n; ++u) {
    int temp = n - size[u];
    for (auto v : neighbors[u]) {
      if (v == father[u]) continue;
      if ((temp) < (size[v])) (temp) = (size[v]);
    }
    if (root == 0 || temp < max_size) {
      root = u;
      max_size = temp;
    }
  }
  dfs(root, -1);
  union_set::init(n);
  std::priority_queue<pair<int, int>, std::vector<pair<int, int>>,
                      std::greater<pair<int, int>>>
      heap;
  for (auto v : neighbors[root]) {
    heap.push(make_pair(size[v], v));
  }
  while (heap.size() > 2) {
    auto p = heap.top();
    heap.pop();
    auto q = heap.top();
    heap.pop();
    union_set::merge(p.second, q.second);
    heap.push(make_pair(p.first + q.first, p.second));
  }
  int root_u = union_set::get_ancestor(heap.top().second);
  heap.pop();
  int root_v = union_set::get_ancestor(heap.top().second);
  heap.pop();
  int size_u = 0;
  for (auto v : neighbors[root]) {
    if (union_set::get_ancestor(v) == root_u) {
      size_u += size[v];
    }
  }
  paint(root, -1, root_u, 1);
  paint(root, -1, root_v, 1 + size_u);
  for (auto e : edges) {
    int u = std::get<0>(e);
    int v = std::get<1>(e);
    int w = std::get<2>(e);
    std::cout << u << " " << v << " " << w << "\n";
  }
}
int main() {
  std::ios::sync_with_stdio(false);
  run();
  return 0;
}
