Language: C++

    // tzl ak IOI! 
     
    #include<bits/stdc++.h>
     
    #define HEAP priority_queue
    #define rep(i, n) for(int i = 0, _end_ = (n); i < _end_; ++i)
    #define per(i, n) for(int i = (n) - 1; i >= 0 ; --i)
    #define forn(i, l, r) for(int i = (l), _end_ = (r); i <= _end_; ++i)
    #define nrof(i, r, l) for(int i = (r), _end_ = (l); i >= _end_; --i)
    #define FOR(a, b) for(auto (a): (b))
    #define mp make_pair
    #define mt make_tuple
    #define pb push_back
    #define X first
    #define Y second
    #define eps 1e-6
    #define pi 3.1415926535897932384626433832795
    #define SZ(x) (int)x.size()
    #define ALL(x) x.begin(), x.end()
    #define FILL(a, b) memset((a), (b), sizeof((a)))
    #define MCPY(a, b) memcpy((a), (b), sizeof((b)))
     
    using namespace std;
     
    typedef long long LL;
    typedef double flt;
    typedef vector<int> vi;
    typedef vector<LL> vl;
    typedef pair<int,int> pii;
    typedef pair<int,LL> pil;
    typedef pair<LL,int> pli;
    typedef pair<LL,LL> pll;
    typedef vector<pil> vil;
    typedef vector<pii> vii;
    typedef vector<pli> vli;
    typedef vector<pll> vll;
     
    const int iinf = 1e9 + 7;
    const LL linf = 1ll << 60;
    const flt dinf = 1e60;
     
    template <typename T>
    inline void scf(T &x)
    {
    	bool f = 0; x = 0; char c = getchar();
    	while((c < '0' || c > '9') && c != '-') c = getchar();
    	if(c == '-') { f = 1; c = getchar(); }
    	while(c >= '0' && c <= '9') { x = x * 10 + c - '0'; c = getchar(); }
    	if(f) x = -x; return;
    }
     
    template <typename T1, typename T2>
    void scf(T1 &x, T2 &y) { scf(x); return scf(y); }
     
    template <typename T1, typename T2, typename T3>
    void scf(T1 &x, T2 &y, T3 &z) { scf(x); scf(y); return scf(z); }
     
    template <typename T1, typename T2, typename T3, typename T4>
    void scf(T1 &x, T2 &y, T3 &z, T4 &w) { scf(x); scf(y); scf(z); return scf(w); }
     
    inline char mygetchar(){ char c = getchar(); while(c == ' ' || c == '\n') c = getchar(); return c; }
     
    template <typename T>
    void chkmax(T &x, const T &y){ if(y > x) x = y; return; }
     
    template <typename T>
    void chkmin(T &x, const T &y){ if(y < x) x = y; return; }
     
    #define ONLINE_JUDGE
     
    #ifdef ONLINE_JUDGE
    #define debug(x,c) ;
    #else
    #define DEBUG
    #define debug(x,c) cerr<<#x<<"="<<x<<c;
    #endif
     
    void TZL();
     
    void RANK1();
     
    #define tzl int
    #define ak main
    #define IOI ()
    tzl ak IOI
    {
    #undef tzl
    #undef ak
    #undef IOI
     
    	TZL();
    	RANK1();
     
    #define tzl return
    #define caisi 0
    #define myy ;
    	tzl caisi myy
    #undef tzl
    #undef caisi
    #undef myy
    }
     
    //---------------------------head----------------------------
     
    const int N = 1e5 + 100;
     
    int n, tot;
    vi g[N];
    int dep[N], par[N], son[N], siz[N], hs[N], anc[N], dfn[N], End[N], M[N];
    set<pii> s1, s2;
     
    void dfs0(int u = 1, int fa = 0)
    {
    	dep[u] = dep[fa] + 1; par[u] = fa; siz[u] = 1;
    	for(int v: g[u]) if(v != fa)
    	{
    		dfs0(v, u);
    		siz[u] += siz[v];
    		if(siz[v] > hs[u]) hs[u] = siz[v], son[u] = v;
    	}
    	return;
    }
     
    void dfs1(int u = 1, int fa = 1)
    {
    	anc[u] = fa; M[dfn[u] = (++tot)] = u;
    	if(son[u]) dfs1(son[u], fa);
     
    	for(int v: g[u]) if(v != par[u] && v != son[u])
    	{
    		dfs1(v, v);
    	}
    	End[u] = tot;
    	return;
    }
     
    namespace seg
    {
    	int tag[N << 2];
    	pii num[N << 2];
     
    	int L(int i){ return i << 1; }
    	int R(int i){ return (i << 1) | 1; }
    	void pull(int i)
    	{
    		int l = L(i), r = R(i);
    		if(num[l].X == 0) num[i] = num[r];
    		else if(num[r].X == 0) num[i] = num[l];
    		else num[i] = min(num[l], num[r]);
    		return;
    	}
    	void push(int i)
    	{
    		if(tag[i])
    		{
    			int l = L(i), r = R(i);
    			tag[l] += tag[i]; tag[r] += tag[i];
    			num[l].X += tag[i]; num[r].X += tag[i];
    			tag[i] = 0;
    		}
    		return;
    	}
     
    	void M(int a, int b, int x, int l = 1, int r = n, int k = 1)
    	{
    		if(a == l && b == r)
    		{
    			num[k].X += x;
    			tag[k] += x;
    			return;
    		}
     
    		int mid = l + r >> 1; push(k);
    		if(a > mid) M(a, b, x, mid + 1, r, R(k));
    		else if(b <= mid) M(a, b, x, l, mid, L(k));
    		else M(a, mid, x, l, mid, L(k)), M(mid + 1, b, x, mid + 1, r, R(k));
    		return pull(k);
    	}
     
    	void B(int l = 1, int r = n, int k = 1)
    	{
    		if(l == r)
    		{
    			num[k].Y = l;
    			return;
    		}
     
    		int mid = l + r >> 1; push(k);
    		B(l, mid, L(k));
    		B(mid + 1, r, R(k));
    		return pull(k);
    	}
     
    	pii Q()
    	{
    		return num[1];
    	}
    }
     
    void add(int u, int v)
    {
    	s1.insert({min(dfn[u], dfn[v]), max(dfn[u], dfn[v])});
    	s2.insert({max(dfn[u], dfn[v]), min(dfn[u], dfn[v])});
     
    	while(anc[u] != anc[v])
    	{
    		if(dep[anc[u]] < dep[anc[v]]) swap(u, v);
    		if(u != anc[u]) seg::M(dfn[anc[u]] + 1, dfn[u], 1);
    		u = par[anc[u]];
    	}
     
    	if(dep[u] < dep[v]) swap(u, v);
    	if(u != v) seg::M(dfn[v] + 1, dfn[u], 1);
    	return;
    }
     
    void TZL()
    {
    	scf(n);
    	rep(i, n - 1)
    	{
    		int u, v; scf(u, v);
    		g[u].pb(v); g[v].pb(u);
    	}
    	dfs0(); dfs1();
    	rep(i, n - 1)
    	{
    		int u, v; scf(u, v);
    		add(u, v);
    	}
    	seg::B();
    	return;
    }
     
    void del(int u, int v)
    {
    	s1.erase({min(dfn[u], dfn[v]), max(dfn[u], dfn[v])});
    	s2.erase({max(dfn[u], dfn[v]), min(dfn[u], dfn[v])});
     
    	while(anc[u] != anc[v])
    	{
    		if(dep[anc[u]] < dep[anc[v]]) swap(u, v);
    		if(u != anc[u]) seg::M(dfn[anc[u]] + 1, dfn[u], -1);
    		u = par[anc[u]];
    	}
     
    	if(dep[u] < dep[v]) swap(u, v);
    	if(u != v) seg::M(dfn[v] + 1, dfn[u], -1);
    	return;
    }
     
    void RANK1()
    {
    	rep(i, n - 1)
    	{
    		pii foo = seg::Q();
assert(foo.X)
    		if(foo.X != 1)
    		{
    			puts("NO");
    			return;
    		}
     
    		int u = foo.Y;
    		int a = dfn[u], b = End[u];
    		auto i1 = s1.lower_bound({a, 0}), i2 = s2.lower_bound({a, 0});
    		int x, y;
    		if(i1 != s1.end() && i1->X >= a && i1->X <= b)
    		{
    			x = i1->X, y = i1->Y;
    		}
    		else x = i2->X, y = i2->Y;
     
    		x = M[x], y = M[y];
    		del(x, y);
    	}
    	puts("YES");
    	return;
    }

Compiler output:
a.cc: In function 'void RANK1()':
a.cc:258:17: error: expected ';' before 'if'
  258 |                 if(foo.X != 1)
      |                 ^~