Problem: 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 edge is painted blue. Takahashi will convert this blue tree into a red tree, by performing the following operation N-1 times:

* Select a simple path that consists of only blue edges, and remove one of those edges.
* Then, span a new red edge between the two endpoints of the selected path.



His objective is to obtain a tree that has a red edge connecting vertices c_i and d_i, for each i.

Determine whether this is achievable.

Constraints

* 2 ≤ N ≤ 10^5
* 1 ≤ a_i,b_i,c_i,d_i ≤ N
* a_i ≠ b_i
* c_i ≠ d_i
* Both input graphs are trees.

Input

Input is given from Standard Input in the following format:


N
a_1 b_1
:
a_{N-1} b_{N-1}
c_1 d_1
:
c_{N-1} d_{N-1}


Output

Print `YES` if the objective is achievable; print `NO` otherwise.

Examples

Input

3
1 2
2 3
1 3
3 2


Output

YES


Input

5
1 2
2 3
3 4
4 5
3 4
2 4
1 4
1 5


Output

YES


Input

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


Output

NO

Solution (in CPP):

Solution:
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <map>
#include <set>
#include <queue>
using namespace std;

const int MAX_N = 100005;
typedef pair<int, int> pii;

queue<pii> q;
map<pii, int> cnt;
multiset<int> go[MAX_N];
multiset<int>::iterator iter;

int deg[MAX_N];

void add(int x, int y) {
  if (x > y) swap(x, y);
  cnt[make_pair(x, y)]++;
  if (cnt[make_pair(x, y)] == 2) q.push(make_pair(x, y));
  go[x].insert(y), go[y].insert(x);
  deg[x]++, deg[y]++;
}

bool vis[MAX_N];

int N;

int main() {
  scanf("%d", &N);
  for (int i = 1, u, v; i < N * 2 - 1; ++i) {
    scanf("%d%d", &u, &v);
    add(u, v);
  }

  while (!q.empty()) {
    int u = q.front().first, v = q.front().second;
    q.pop();

    if (vis[u] || vis[v]) continue;

    if (deg[u] < deg[v]) swap(u, v);
    vis[v] = 1;

    for (iter = go[v].begin(); iter != go[v].end(); ++iter) {
      if (*iter != u) {
	add(u, *iter);
	go[*iter].erase(go[*iter].find(v));
      }
    }

    go[u].erase(go[u].find(v)), go[u].erase(go[u].find(v));
    go[v].erase(go[v].find(u)), go[v].erase(go[v].find(u));
  }

  int num = 0;
  for (int i = 1; i <= N; ++i)
    if (!vis[i]) num++;

  if (num == 1) puts("YES");
  else puts("NO");
  
  return 0;
}