#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


#define NUM 100005


struct Node{
	int parent,depth,size;
	int child_max_depth,child_max_size,child_second_depth,child_second_size;
};

int num_case;
int V,B;
int root;
int out_num[NUM];
int ANS[NUM];
bool visited[NUM];
Node nodes[NUM];
vector<int> G[NUM];

void func(){

	for(int i = 0; i < NUM; i++){
		G[i].clear();
	}

	for(int i = 0; i < V; i++){
		nodes[i].parent = -1;
		out_num[i] = 0;
	}

	int from,to;

	for(int loop = 1; loop <= V-1; loop++){

		scanf("%d",&to);
		from = loop;
		to--;

		G[from].push_back(to);
		G[to].push_back(from);
	}

	for(int i = 0; i < V; i++){

		visited[i] = false;
	}

	root = 0;
	queue<int> Q;
	int node_id,child;

	visited[root] = true;

	//木構造を作る
	Q.push(root);

	while(!Q.empty()){

		node_id = Q.front();
		Q.pop();

		for(int i = 0; i < G[node_id].size(); i++){

			child = G[node_id][i];
			if(visited[child])continue;

			visited[child] = true;
			nodes[child].parent = node_id;
			out_num[node_id]++;

			Q.push(child);
		}
	}

	/*★葉からボトムアップで、必要な情報を収集する★*/

	for(int i = 0; i < V; i++){

		if(out_num[i] == 0){ //葉

			Q.push(i);
			//printf("%dが葉\n",i);
		}
	}

	while(!Q.empty()){

		node_id = Q.front();
		Q.pop();

		nodes[node_id].child_max_depth = 0; //子の中で最大の深さ
		nodes[node_id].child_max_size = 0; //最大の深さを持つ子の数

		//2番目に大きい値
		nodes[node_id].child_second_depth = 0;
		nodes[node_id].child_second_size = 0;

		for(int i = 0; i < G[node_id].size(); i++){

			child = G[node_id][i];
			if(child == nodes[node_id].parent)continue;

			if(nodes[child].depth > nodes[node_id].child_max_depth){ //最大値更新

				nodes[node_id].child_second_depth = nodes[node_id].child_max_depth;
				nodes[node_id].child_second_size = nodes[node_id].child_max_size;

				nodes[node_id].child_max_depth = nodes[child].depth;
				nodes[node_id].child_max_size = nodes[child].size;

			}else if(nodes[child].depth == nodes[node_id].child_max_depth){ //最大値と同点

				nodes[node_id].child_max_size += nodes[child].size;

			}else if(nodes[child].depth > nodes[node_id].child_second_depth){ //最大ではないが、2番目の値更新

				nodes[node_id].child_second_depth = nodes[child].depth;
				nodes[node_id].child_second_size = nodes[child].size;

			}else if(nodes[child].depth == nodes[node_id].child_second_depth){ //2番目と同点

				nodes[node_id].child_second_size += nodes[child].size;
			}
		}

		if(nodes[node_id].child_max_depth == 0){ //子がいない場合

			nodes[node_id].depth = 1;
			nodes[node_id].size = 1;

		}else if(nodes[node_id].child_max_size+1 <= B){

			nodes[node_id].depth = nodes[node_id].child_max_depth;
			nodes[node_id].size = nodes[node_id].child_max_size+1;

		}else{ //nodes[node_id].child_max_size+1 > B

			nodes[node_id].depth = nodes[node_id].child_max_depth+1;
			nodes[node_id].size = 1;
		}

		if(nodes[node_id].parent == -1)continue;

		out_num[nodes[node_id].parent] -= 1;//親の出次数を1減らす

		if(out_num[nodes[node_id].parent] == 0){

			Q.push(nodes[node_id].parent);
		}
	}


	ANS[root] = nodes[root].depth;
	for(int i = 0; i < G[root].size(); i++){
		Q.push(G[root][i]);
	}

	int parent,parent_depth,parent_size;

	while(!Q.empty()){

		node_id = Q.front();
		Q.pop();

		parent = nodes[node_id].parent;

		//★親方向をnode_idの子の1つとして見なした場合★のコスト、およびサイズを場合分けして設定

		if(nodes[node_id].depth < nodes[parent].child_max_depth){ //node_idが非最大

			//node_idにとっては、parentが最大の深さを持つ子になる
			parent_size = nodes[parent].size;
			parent_depth = nodes[parent].depth;

		}else{ //node_idが最大

			if(nodes[parent].child_max_size == nodes[node_id].size){ //node_idが単独一位

				//親の、2番目の子を見る
				if(nodes[parent].child_second_depth == 0){ //2番目の子なし:親が葉になる

					parent_depth = 1;
					parent_size = 1;

				}else{

					if(nodes[parent].child_second_size+1 <= B){

						parent_depth = nodes[parent].child_second_depth;
						parent_size = nodes[parent].child_second_size+1;

					}else{

						parent_depth = nodes[parent].child_second_depth+1;
						parent_size = 1;
					}
				}
			}else{ //node_idと同点一位が1つ以上ある

				if(nodes[parent].child_max_size-nodes[node_id].size+1 <= B){

					parent_depth = nodes[parent].child_max_depth;
					parent_size = nodes[parent].child_max_size-nodes[node_id].size+1;

				}else{

					parent_depth = nodes[parent].child_max_depth+1;
					parent_size = 1;
				}
			}
		}


		//ANSの設定<★depthとsizeを設定しなおす★>
		if(parent_depth > nodes[node_id].child_max_depth){ //親方向のコストが最大

			if(parent_size+1 <= B){

				ANS[node_id] = parent_depth;

				nodes[node_id].depth = parent_depth;
				nodes[node_id].size = parent_size+1;

			}else{

				ANS[node_id] = parent_depth+1;

				nodes[node_id].depth = parent_depth+1;
				nodes[node_id].size = 1;
			}
		}else if(parent_depth == nodes[node_id].child_max_depth){ //親方向のコストが、最大値と同じ

			if(nodes[node_id].child_max_size+parent_size+1 <= B){

				ANS[node_id] = nodes[node_id].child_max_depth;

				nodes[node_id].size += parent_size;

			}else{

				ANS[node_id] = nodes[node_id].child_max_depth+1;

				nodes[node_id].depth = nodes[node_id].child_max_depth+1;
				nodes[node_id].size = 1;
			}

		}else{ //親方向へのコストが最大でない→仮にコスト1をかけて親に渡ったとしても、最大値は更新されない

			ANS[node_id] = nodes[node_id].depth;
		}

		//secondの再設定
		if(parent_depth > nodes[node_id].child_max_depth){ //最大値更新

			nodes[node_id].child_second_depth = nodes[node_id].child_max_depth;
			nodes[node_id].child_second_size = nodes[node_id].child_max_size;

			nodes[node_id].child_max_depth = parent_depth;
			nodes[node_id].child_max_size = parent_size;

		}else if(parent_depth == nodes[node_id].child_max_depth){ //最大値と同点

			nodes[node_id].child_max_size += parent_size;

		}else if(parent_depth > nodes[node_id].child_second_depth){ //最大ではないが、2番目の値更新

			nodes[node_id].child_second_depth = parent_depth;
			nodes[node_id].child_second_size = parent_size;

		}else if(parent_depth == nodes[node_id].child_second_depth){ //2番目と同点

			nodes[node_id].child_second_size += parent_size;
		}

		for(int i = 0; i < G[node_id].size(); i++){
			if(G[node_id][i] == nodes[node_id].parent)continue;

			Q.push(G[node_id][i]);
		}
	}

	printf("Case %d:\n",num_case);

	for(int i = 0; i < V; i++){

		printf("%d\n",ANS[i]);
	}
}

int main(){

	num_case = 1;

	while(true){

		scanf("%d %d",&V,&B);
		if(V == 0 && B == 0)break;

		func();
		num_case++;
	}

	return 0;
}



Measured memory_bytes: 13768