Takahashi has decided to make a Christmas Tree for the Christmas party in AtCoder, Inc.

A Christmas Tree is a tree with N vertices numbered 1 through N and N-1 edges, whose i-th edge (1\leq i\leq N-1) connects Vertex a_i and b_i.

He would like to make one as follows:

* Specify two non-negative integers A and B.
* Prepare A Christmas Paths whose lengths are at most B. Here, a Christmas Path of length X is a graph with X+1 vertices and X edges such that, if we properly number the vertices 1 through X+1, the i-th edge (1\leq i\leq X) will connect Vertex i and i+1.
* Repeat the following operation until he has one connected tree:
* Select two vertices x and y that belong to different connected components. Combine x and y into one vertex. More precisely, for each edge (p,y) incident to the vertex y, add the edge (p,x). Then, delete the vertex y and all the edges incident to y.
* Properly number the vertices in the tree.



Takahashi would like to find the lexicographically smallest pair (A,B) such that he can make a Christmas Tree, that is, find the smallest A, and find the smallest B under the condition that A is minimized.

Solve this problem for him.

Constraints

* 2 \leq N \leq 10^5
* 1 \leq a_i,b_i \leq N
* The given graph is a tree.

Input

Input is given from Standard Input in the following format:


N
a_1 b_1
:
a_{N-1} b_{N-1}


Output

For the lexicographically smallest (A,B), print A and B with a space in between.

Examples

Input

7
1 2
2 3
2 4
4 5
4 6
6 7


Output

3 2


Input

8
1 2
2 3
3 4
4 5
5 6
5 7
5 8


Output

2 5


Input

10
1 2
2 3
3 4
2 5
6 5
6 7
7 8
5 9
10 5


Output

3 4
#include<iostream>
#include<cstdio>
#include<cstring>
#include<set>
#include<map>

namespace fuck
{
	const int N=100100,M=N*2;
	int begin[N],next[M],to[M];
	int n,e;
	void add(int x,int y,bool k=1)
	{
		to[++e]=y;
		next[e]=begin[x];
		begin[x]=e;
		if(k)add(y,x,0);
	}
	void initialize()
	{
		scanf("%d",&n);
		for(int i=1,u,v;i<n;i++)
			scanf("%d%d",&u,&v),add(u,v);
	}
	typedef std::map<int,int>::iterator mit;
	int f[N],g[N],lim;
	std::map<int,int> S;

	mit it;
	int w,dw,cnt;

	void dfs(int p=1,int h=0)
	{
		f[p]=g[p]=0;
		for(int i=begin[p],q;i;i=next[i])
			if((q=to[i])!=h)dfs(q,p);

		S.clear();
		cnt=0;
		for(int i=begin[p],q;i;i=next[i])
			if((q=to[i])!=h)
			{
				f[p]+=f[q];
				S[g[q]+1]++;
				cnt++;
			}

		int maxw=-1;

		while(cnt>1)
		{
			it=S.end();it--;
			w=it->first,dw=lim-w;

			(it->second)--;
			if((it->second)==0)S.erase(it);
			cnt--;

			f[p]++;


			it=S.upper_bound(dw);
			if(it==S.begin())
			{
				maxw=w;
				continue;
			}
			else it--;

			(it->second)--;
			if((it->second)==0)S.erase(it);
			cnt--;
		}

		if(!cnt)
		{
			if(maxw>0)
			{
				f[p]--;
				g[p]=maxw;
			}
			else g[p]=0;
		}
		else g[p]=S.begin()->first;

		if(g[p]==lim)f[p]++,g[p]=0;
		if(p==1 && g[p]!=0)f[p]++,g[p]=0;
	}
	int c[N];
	void solve()
	{
		initialize();

		lim=n+10,dfs();
		int A=f[1],u=n,d=0;

		while(u>d)
		{
			lim=(u+d)>>1;
			dfs();
			if(f[1]==A)u=lim;
			else d=lim+1;
		}

		printf("%d %d\n",A,d);
	}
}

int main()
{
//	freopen("D.in","r",stdin);
//	freopen("D.out","w",stdout);

	fuck::solve();
	return 0;
}
