#include <bits/stdc++.h>

#define FO(i,a,b) for (int i = (a); i < (b); i++)
#define sz(v) int(v.size())

using namespace std;

int n;
set<int> u[100005];
set<int> v[100005];
int rp[100005];

int gl(int i) {
    return i == rp[i] ? i : rp[i] = gl(rp[i]);
}

int main() {
    scanf("%d", &n);
    FO(i,0,n-1) {
        int x, y;
        scanf("%d %d", &x, &y);
        u[x].insert(y);
        u[y].insert(x);
    }
    FO(i,0,n-1) {
        int x, y;
        scanf("%d %d", &x, &y);
        v[x].insert(y);
        v[y].insert(x);
    }
    FO(i,1,n+1) rp[i] = i;
    queue<pair<int,int> > q;
    FO(i,0,n) {
        for (int j : u[i]) if (v[i].count(j)) q.emplace(i,j);
    }
    int nm = 0;
    while (sz(q)) {
        int i, j; tie(i,j) = q.front(); q.pop();
        i = gl(i); j = gl(j);
        if (i == j) continue;
        if (sz(u[i])+sz(v[i]) > sz(u[j])+sz(v[j])) swap(i,j);
        for (int k : u[i]) {
            if (k == i || k == j) continue;
            u[k].erase(i);
            u[k].insert(j);
            if (v[j].count(k)) q.emplace(j,k);
            u[j].insert(k);
        }
        for (int k : v[i]) {
            if (k == i || k == j) continue;
            v[k].erase(i);
            v[k].insert(j);
            if (u[j].count(k)) q.emplace(j,k);
            v[j].insert(k);
        }
        u[i].clear(); v[i].clear();
        rp[i] = j;
        nm++;
    }
    if (nm == n-1) puts("YES");
    else puts("NO");
}


### Prompt

Your task is to create a CPP solution to the following 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

### Response

```cpp
#include <bits/stdc++.h>

#define FO(i,a,b) for (int i = (a); i < (b); i++)
#define sz(v) int(v.size())

using namespace std;

int n;
set<int> u[100005];
set<int> v[100005];
int rp[100005];

int gl(int i) {
    return i == rp[i] ? i : rp[i] = gl(rp[i]);
}

int main() {
    scanf("%d", &n);
    FO(i,0,n-1) {
        int x, y;
        scanf("%d %d", &x, &y);
        u[x].insert(y);
        u[y].insert(x);
    }
    FO(i,0,n-1) {
        int x, y;
        scanf("%d %d", &x, &y);
        v[x].insert(y);
        v[y].insert(x);
    }
    FO(i,1,n+1) rp[i] = i;
    queue<pair<int,int> > q;
    FO(i,0,n) {
        for (int j : u[i]) if (v[i].count(j)) q.emplace(i,j);
    }
    int nm = 0;
    while (sz(q)) {
        int i, j; tie(i,j) = q.front(); q.pop();
        i = gl(i); j = gl(j);
        if (i == j) continue;
        if (sz(u[i])+sz(v[i]) > sz(u[j])+sz(v[j])) swap(i,j);
        for (int k : u[i]) {
            if (k == i || k == j) continue;
            u[k].erase(i);
            u[k].insert(j);
            if (v[j].count(k)) q.emplace(j,k);
            u[j].insert(k);
        }
        for (int k : v[i]) {
            if (k == i || k == j) continue;
            v[k].erase(i);
            v[k].insert(j);
            if (u[j].count(k)) q.emplace(j,k);
            v[j].insert(k);
        }
        u[i].clear(); v[i].clear();
        rp[i] = j;
        nm++;
    }
    if (nm == n-1) puts("YES");
    else puts("NO");
}


```