#include "dungeon2.h"
#include "bits/stdc++.h"

/*
逆辺は見える！
最初に dfs, 2色あれば初到時刻でラベル付けできる
ラベル付きグラフとしてよい

2M 回で分かる
- 頂点ラベル
- DFS 木の辺

3色目をつかえば、DFS木の頂点 mod 2 とかも分かるかも

あれ、できてる？
dfs しながら、3 色で塗る (3-adic の k-th bit)
全部で 6 DFS
12回

うそ！
どこからの逆辺かはわからないので初回+2
これで14回、いいね

初回
未到達 1
先祖 2
dfs 済 3
*/

using namespace std;
template <typename T>
using vc = vector<T>;
template <typename T>
using vvc = vc<vc<T>>;

enum etype { TREE_UP, TREE_DOWN, BACK_UP, BACK_DOWN };

struct Data {
  etype tp;
  int to = 0;
};
vvc<Data> dat;

int color_memo;

void change_color(int i) { color_memo = i; }
void GO(int i) {
  Move(1 + i, color_memo);
  color_memo = Color();
}
int LAST() { return LastRoad() - 1; }

void Inspect(int R) {
  int n = 0;
  auto new_v = [&](int p) -> int {
    int d = NumberOfRoads();
    int k = LAST();
    dat.resize(n + 1);
    dat[n].resize(d);
    if (k != -1) {
      dat[n][k].tp = TREE_UP;
      dat[n][k].to = p;
    }
    return n++;
  };

  int v = new_v(-1);
  {
    auto dfs = [&](auto& dfs, int v) -> void {
      int d = dat[v].size();
      int last = LAST();
      change_color(2);
      for (int i = 0; i < d; ++i) {
        if (last == i) {
          assert(dat[v][i].tp == TREE_UP);
          continue;
        }
        GO(i);
        if (Color() == 2) {
          // 後退辺でした
          // どこからの後退辺かは分からないのでそのまま戻ってくる
          dat[v][i].tp = BACK_UP;
          GO(LAST());
          continue;
        }
        if (Color() == 1) {
          // 新しい頂点発見
          dat[v][i].tp = TREE_DOWN;
          dat[v][i].to = new_v(v);
          dfs(dfs, dat[v][i].to);
        }
        if (Color() == 3) {
          dat[v][i].tp = BACK_DOWN;
          GO(LAST());
          continue;
        }
      }
      change_color(3);
      if (v > 0) GO(last);
    };
    dfs(dfs, 0);
  }

  int N = n;
  vvc<int> digit(N);
  for (int i = 0; i < N; ++i) {
    int x = i;
    for (int j = 0; j < 5; ++j) digit[i].emplace_back(x % 3), x /= 3;
  }

  vc<int> POW = {1, 3, 9, 27, 81};

  for (int keta = 0; keta < 5; ++keta) {
    auto dfs = [&](auto& dfs, int v) -> void {
      int d = dat[v].size();
      int last = LAST();
      change_color(digit[v][keta] + 1);
      for (int i = 0; i < d; ++i) {
        if (dat[v][i].tp == TREE_UP) continue;
        if (dat[v][i].tp == BACK_DOWN) continue;
        if (dat[v][i].tp == TREE_DOWN) {
          GO(i);
          dfs(dfs, dat[v][i].to);
          continue;
        }
        if (dat[v][i].tp == BACK_UP) {
          GO(i);
          int k = Color();
          GO(LAST());
          dat[v][i].to += POW[keta] * (k - 1);
        }
      }
      if (v > 0) GO(last);
    };
    dfs(dfs, 0);
  }

  // 全部わかったはず
  vvc<int> D(N, vc<int>(N));
  for (int i = 0; i < N; ++i)
    for (int j = 0; j < N; ++j) D[i][j] = (i == j ? 0 : 1 << 20);

  vvc<int> G(N);
  for (int v = 0; v < N; ++v) {
    for (auto& X: dat[v]) {
      if (X.tp == BACK_DOWN) continue;
      int w = X.to;
      D[v][w] = D[w][v] = 1;
    }
  }
  for (int t = 0; t < 3; ++t) {
    for (int i = 0; i < N; ++i) {
      for (int j = 0; j < N; ++j) {
        for (int k = 0; k < N; ++k) { D[i][k] = min(D[i][k], D[i][j] + D[j][k]); }
      }
    }
  }
  vc<int> ANS(N + 1);
  for (int i = 0; i < N; ++i) {
    for (int j = i + 1; j < N; ++j) ANS[D[i][j]]++;
  }
  for (int i = 1; i <= R; ++i) Answer(i, ANS[i]);
}