Problem:
Score : 900 points

Problem Statement

There is a tree with N vertices numbered 1 through N.
The i-th of the N-1 edges connects vertices a_i and b_i.

Initially, each vertex is uncolored.

Takahashi and Aoki is playing a game by painting the vertices. In this game, they alternately perform the following operation, starting from Takahashi:

Select a vertex that is not painted yet.

If it is Takahashi who is performing this operation, paint the vertex white; paint it black if it is Aoki.

Then, after all the vertices are colored, the following procedure takes place:

Repaint every white vertex that is adjacent to a black vertex, in black.

Note that all such white vertices are repainted simultaneously, not one at a time.

If there are still one or more white vertices remaining, Takahashi wins; if all the vertices are now black, Aoki wins.
Determine the winner of the game, assuming that both persons play optimally.

Constraints

2 ≤ N ≤ 10^5

1 ≤ a_i,b_i ≤ N

a_i ≠ b_i

The input 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

Print First if Takahashi wins; print Second if Aoki wins.

Sample Input 1

3
1 2
2 3

Sample Output 1

First

Below is a possible progress of the game:

First, Takahashi paint vertex 2 white.

Then, Aoki paint vertex 1 black.

Lastly, Takahashi paint vertex 3 white.

In this case, the colors of vertices 1, 2 and 3 after the final procedure are black, black and white, resulting in Takahashi's victory.

Sample Input 2

4
1 2
2 3
2 4

Sample Output 2

First

Sample Input 3

6
1 2
2 3
3 4
2 5
5 6

Sample Output 3

Second

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <bits/stdc++.h>

using namespace std;

vector<int> g[100005];
bool dp[100005]={}; 
int sz[100005]={};

void pre(int u, int par){
	sz[u]=1;
	int c;
	for(auto v:g[u]){
		if(v!=par){
			pre(v,u);
			sz[u]+=sz[v];
			c=v;
		}
	}
	if(g[u].size()==1){
		dp[u]=1;
	}
	if(g[u].size()==2){
		dp[u]=dp[c];
	}
}

void dfs(int u, int par, int up, int upsz){
	int paths=0;
	for(auto v:g[u]){
		if(v!=par){
			dfs(v,u,(up&&(g[u].size()==2)),upsz+sz[u]-sz[v]);
			paths+=dp[v]&&(sz[v]&1);
		}
	}
	if(par)
		paths+=up&&(upsz&1);
	
	if(paths>=2){
		cout << "First" << endl;
		exit(0);
	}
}

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	
	int n; cin >> n;
	for(int i=0;i<n-1;i++){
		int u,v; cin >> u >> v;
		g[u].push_back(v);
		g[v].push_back(u);
	}
	
	if(n==2){
		cout << "Second" << endl;
		return 0;
	}
	int root;
	for(int i=1;i<=n;i++){
		if(g[i].size()>1){
			root=i;
			break;
		}
	}
	
	pre(root,0);
	dfs(root,0,1,0);
	
	cout << "Second" << endl;
	return 0;
}