#include <bits/stdc++.h>
#include <string>
#include <set>
#include <vector>
#include <queue>
#define REP(i,a,b) for(i=a;i<b;i++)
#define rep(i,n) REP(i,0,n)
using namespace std;
#define SQR(X) ((X)*(X))

#define NIL -1

struct Root {
  int parent,right,left,depth;
};

Root tree[100005];
queue<int> qu;
set<int> way[100005];
//               root
int distance_min = INT_MAX;
int target;

// 多分完成
void create_tree() {
  bool visited[100005] = {};
  int node = 1;
  tree[node].depth = 0;
  visited[node] = true;
  qu.push(node);
  while( ! qu.empty() ) {
	node = qu.front(); qu.pop();
	set<int>::iterator itr = way[node].begin();
	set<int>::iterator past_itr = itr;
	for(; itr != way[node].end(); itr++) {
	  if( ! visited[*itr] ) {
		tree[node].left = *itr;
		tree[*itr].depth = tree[node].depth+1;
		past_itr = itr;
	  }
	}
	for(; itr != way[node].end(); itr++) {
	  if( ! visited[*itr] ) {
		tree[*itr].depth = tree[node].depth+1;
		tree[*past_itr].right = *itr;
		past_itr = itr;
	  }
	}
	itr--;
	tree[*itr].right = NIL;
	itr = way[node].begin();
	for(; itr != way[node].end(); itr++) {
	  if( ! visited[*itr] ) {
		visited[*itr] = true;
		qu.push(*itr);
	  }
	}
  }
}

int distance_from_node_to_leef(int node) {
  if(tree[node].left == NIL) return 0;
  int distance[100005];
  bool visited[100005] = {};
  visited[node] = true;
  distance[node] = 0;
  qu.push(node);
  while( ! qu.empty() ) {
	node = qu.front(); qu.pop();
	int child = tree[node].left;
	for(; child != NIL; child = tree[child].right) {
	  if(tree[child].left == NIL) {
		return distance[node]+1;
	  }
	  else {
		distance[child] = distance[node]+1;
		qu.push(child);
	  }
	}
  }
}

int main() {
  int i,j,k;
  int N;
  cin >> N;
  rep(i,N-1) {
	int x,y;
	scanf("%d %d",&x,&y);
	way[x].insert(y);
	way[y].insert(x);
  }
  rep(i,N+1) {
	tree[i].parent = NIL;
	tree[i].right = NIL;
	tree[i].left = NIL;
  }
  create_tree();
  puts("0");
  for(i=2;i<N+1;i++) {
	int r,l;
	r = tree[i].depth;
	l = distance_from_node_to_leef(i);
	printf("%d\n",min(l,r));
  }
}

/*
void seek_distance(int current_location,int cost)
{
  int i;
  int waysize = way[current_location].size();
  queue<int> qu;
  rep(i,waysize) {
	int& next = way[current_location][i];
	if(next == target) {
	  distance_min = min(cost,distance_min);
	}
	if(cost+1 > distance_min) break;
	seek_distance(next,cost+1);
  }
}
*/