#include <bits/stdc++.h>
using namespace std;
int n, p[(1 << 20)], root;
vector<int> chs[(1 << 20)];
vector<int>* vec[(1 << 20)];
int sz[(1 << 20)], ans[(1 << 20)];
multiset<int> outer, inner;
multiset<int> outerNeg, innerNeg;
multiset<int> parents, parentsNeg;
void getSz(int x) {
  sz[x] = 1;
  for (int i = 0; i < chs[x].size(); i++) {
    getSz(chs[x][i]);
    sz[x] += sz[chs[x][i]];
  }
}
void printSt(int x) {
  if (sz[x] < 1000) {
    return;
  }
  cout << sz[x] << " ";
  for (int i = 0; i < chs[x].size(); i++) {
    printSt(chs[x][i]);
  }
}
void dfs(int x, bool keep) {
  int bch = 0, sch = 0, szsm = n - 1, secL = 0;
  for (int i = 0; i < chs[x].size(); i++) {
    if (sz[chs[x][i]] > sz[chs[x][bch]]) {
      bch = i;
    }
    if (sz[chs[x][i]] < sz[chs[x][sch]]) {
      sch = i;
    }
  }
  for (int i = 0; i < chs[x].size(); i++) {
    if (sz[chs[x][i]] > sz[chs[x][secL]] && bch != i) {
      secL = i;
    }
  }
  if (x != root) {
    parents.insert(sz[x]);
    parentsNeg.insert(-sz[x]);
  }
  auto it = outer.find(sz[x]);
  outer.erase(it);
  it = outerNeg.find(-sz[x]);
  outerNeg.erase(it);
  for (int i = 0; i < chs[x].size(); i++) {
    if (i == bch) {
      continue;
    }
    dfs(chs[x][i], 0);
  }
  if (chs[x].size()) {
    dfs(chs[x][bch], 1);
    vec[x] = vec[chs[x][bch]];
  } else {
    vec[x] = new vector<int>();
  }
  outer.insert(sz[x]);
  outerNeg.insert(-sz[x]);
  if (x != root) {
    it = parents.find(sz[x]);
    parents.erase(it);
    it = parentsNeg.find(-sz[x]);
    parentsNeg.erase(it);
  }
  vec[x]->push_back(sz[x]);
  it = outer.find((*vec[x]).back());
  outer.erase(it);
  it = outerNeg.find(-((*vec[x]).back()));
  outerNeg.erase(it);
  for (int i = 0; i < chs[x].size(); i++) {
    if (i == bch) {
      continue;
    }
    for (int j = 0; j < vec[chs[x][i]]->size(); j++) {
      vec[x]->push_back((*vec[chs[x][i]])[j]);
      auto it = outer.find((*vec[chs[x][i]])[j]);
      outer.erase(it);
      it = outerNeg.find(-((*vec[chs[x][i]])[j]));
      outerNeg.erase(it);
    }
  }
  ans[x] = n - 1;
  if (chs[x].size()) {
    int maxSzInner = sz[chs[x][bch]], szOuter = n - sz[x];
    ans[x] = max(maxSzInner, szOuter);
    szsm = sz[chs[x][sch]];
    if (szOuter) {
      szsm = min(szsm, szOuter);
    }
    if (maxSzInner > szOuter) {
      int d = maxSzInner - szsm;
      int d1 = d / 2, d2 = (d + 1) / 2;
      int s1 = *inner.lower_bound(d1), s2 = *inner.lower_bound(d2);
      int s3 = -(*innerNeg.lower_bound(-d1)),
          s4 = -(*innerNeg.lower_bound(-d2));
      ans[x] = min(ans[x], max(maxSzInner - s1, szsm + s1));
      ans[x] = min(ans[x], max(maxSzInner - s2, szsm + s2));
      ans[x] = min(ans[x], max(maxSzInner - s3, szsm + s3));
      ans[x] = min(ans[x], max(maxSzInner - s4, szsm + s4));
      ans[x] = max(ans[x], szOuter);
    } else {
      int d = szOuter - szsm;
      int d1 = d / 2, d2 = (d + 1) / 2;
      int s1 = *outer.lower_bound(d1), s2 = *outer.lower_bound(d2);
      int s3 = -(*outerNeg.lower_bound(-d1)),
          s4 = -(*outerNeg.lower_bound(-d2));
      ans[x] = min(ans[x], max(szOuter - s1, szsm + s1));
      ans[x] = min(ans[x], max(szOuter - s2, szsm + s2));
      ans[x] = min(ans[x], max(szOuter - s3, szsm + s3));
      ans[x] = min(ans[x], max(szOuter - s4, szsm + s4));
      s1 = *parents.lower_bound(d1 + sz[x]) - sz[x];
      s2 = *parents.lower_bound(d2 + sz[x]) - sz[x];
      s3 = -(*parentsNeg.lower_bound(-d1 - sz[x])) - sz[x];
      s4 = -(*parentsNeg.lower_bound(-d2 - sz[x])) - sz[x];
      ans[x] = min(ans[x], max(szOuter - s1, szsm + s1));
      ans[x] = min(ans[x], max(szOuter - s2, szsm + s2));
      ans[x] = min(ans[x], max(szOuter - s3, szsm + s3));
      ans[x] = min(ans[x], max(szOuter - s4, szsm + s4));
      ans[x] = max(ans[x], sz[chs[x][bch]]);
    }
    for (int i = 0; i < chs[x].size(); i++) {
      if (i == bch) {
        continue;
      }
      ans[x] = max(ans[x], sz[chs[x][i]]);
    }
  }
  for (int i = 0; i < chs[x].size(); i++) {
    if (i == bch) {
      continue;
    }
    for (int j = 0; j < vec[chs[x][i]]->size(); j++) {
      inner.insert((*vec[chs[x][i]])[j]);
      innerNeg.insert(-((*vec[chs[x][i]])[j]));
    }
  }
  inner.insert(sz[x]);
  innerNeg.insert(-sz[x]);
  if (!keep) {
    for (int i = 0; i < vec[x]->size(); i++) {
      outer.insert((*vec[x])[i]);
      outerNeg.insert(-((*vec[x])[i]));
      auto it = inner.find((*vec[x])[i]);
      inner.erase(it);
      it = innerNeg.find(-((*vec[x])[i]));
      innerNeg.erase(it);
    }
  }
}
int main() {
  cin >> n;
  for (int i = 0; i < n; i++) {
    int a, b;
    cin >> a >> b;
    if (a == 0) {
      root = b;
    }
    p[b] = a;
    chs[a].push_back(b);
  }
  getSz(root);
  for (int i = 1; i <= n; i++) {
    outer.insert(sz[i]);
    outerNeg.insert(-sz[i]);
  }
  dfs(root, 1);
  for (int i = 1; i <= n; i++) {
    cout << ans[i] << "\n";
  }
  return 0;
}
