Andryusha goes through a park each day. The squares and paths between them look boring to Andryusha, so he decided to decorate them.

The park consists of n squares connected with (n - 1) bidirectional paths in such a way that any square is reachable from any other using these paths. Andryusha decided to hang a colored balloon at each of the squares. The baloons' colors are described by positive integers, starting from 1

Andryusha wants to use as little different colors as possible. Help him to choose the colors!

The first line contains single integer n (3 ≤ n ≤ 2·105) — the number of squares in the park.

Each of the next (n - 1) lines contains two integers x and y (1 ≤ x, y ≤ n) — the indices of two squares directly connected by a path.

It is guaranteed that any square is reachable from any other using the paths.

In the first line print single integer k — the minimum number of colors Andryusha has to use.

In the second line print n integers, the i-th of them should be equal to the balloon color on the i-th square. Each of these numbers should be within range from 1 to k.

3
2 3
1 3

3
1 3 2 

5
2 3
5 3
4 3
1 3

5
1 3 2 5 4 

5
2 1
3 2
4 3
5 4

3
1 2 3 1 2 

In the first sample the park consists of three squares: 1 → 3 → 2. Thus, the balloon colors have to be distinct.

Illustration for the first sample.

In the second example there are following triples of consequently connected squares:

• 1 → 3 → 2
• 1 → 3 → 4
• 1 → 3 → 5
• 2 → 3 → 4
• 2 → 3 → 5
• 4 → 3 → 5

Illustration for the second sample.

In the third example there are following triples:

• 1 → 2 → 3
• 2 → 3 → 4
• 3 → 4 → 5

Illustration for the third sample.

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 2e5+10;
struct node
{
	int to,next;
}edge[2*maxn];
int head[2*maxn],ans,n,cnt,a[maxn];

void add(int u,int v)
{
	edge[cnt].to=v;
	edge[cnt].next=head[u];
	head[u]=cnt++;
}

void dfs(int x,int y)
{
	int num=1,i;
	for(i=head[x];i!=-1;i=edge[i].next)
	{
		if(edge[i].to!=y)
		{
			while(num==a[x]||num==a[y])
				num++;
			a[edge[i].to]=num++;
			ans=max(ans,num-1);
			dfs(edge[i].to,x);
		}
	}
}

int main()
{
	int u,v;
	while(scanf("%d",&n)!=EOF)
	{
		memset(head,-1,sizeof(head));
		cnt=0;
		for(int i=1;i<n;++i)
		{
			scanf("%d%d",&u,&v);
			add(u,v);
			add(v,u);
		}
		memset(a,0,sizeof(a));
		a[1]=1;
		ans=0;
		dfs(1,-1);
		printf("%d\n",ans);
		printf("%d",a[1]);
		for(int i=2;i<=n;++i)
			printf(" %d",a[i]);
		printf("\n");
	}
	return 0;
}