stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



const int maxn = 200010;



int fa1[maxn], fa2[maxn], r1[maxn], r2[maxn];



map<pair<int, int>, int> mp;



void kexin_init() {

	for (int i=1; i<=maxn; ++i) {fa1[i] = i; fa2[i] = i;}

	memset(r1, 0, sizeof r1);

	memset(r2, 0, sizeof r2);

}



int kexin_find_road(int x) {

	if (fa1[x] == x) return x;

	return fa1[x] = kexin_find_road(fa1[x]);

}

void kexin_Union_road(int x, int y) {

	x = kexin_find_road(x);

	y = kexin_find_road(y);

	if (x == y) return ;

	if (r1[x] < r1[y]) swap(x, y);

	fa1[y] = x;

	if (r1[x] == r1[y]) r1[x]++;

}



int kexin_find_railway(int x) {

	if (fa2[x] == x) return x;

	return fa2[x] = kexin_find_railway(fa2[x]);

}

void kexin_Union_railway(int x, int y) {

	x = kexin_find_railway(x);

	y = kexin_find_railway(y);

	if (x == y) return ;

	if (r2[x] < r2[y]) swap(x, y);

	fa2[y] = x;

	if (r2[x] == r2[y]) r2[x]++;

}

int main() {

	int n, k, l;

	scanf("%d%d%d", &n, &k, &l);

	

	kexin_init();

	for (int i=1; i<=k; ++i) {

		int x, y;

		scanf("%d%d", &x, &y);

		kexin_Union_road(x, y);

	}

	for (int i=1; i<=l; ++i) {

		int x, y;

		scanf("%d%d", &x, &y);

		kexin_Union_railway(x, y);

	}

	

	mp.clear();



	for (int i=1; i<=n; ++i) mp[make_pair(kexin_find_road(i), kexin_find_railway(i))]++;

	for (int i=1; i<n; ++i) printf("%d ", mp[make_pair(kexin_find_road(i), kexin_find_railway(i))]);

	printf("%d\n", mp[make_pair(kexin_find_road(n), kexin_find_railway(n))]);



	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 4.26223117266942x):
#include <cstdio>

#include <iostream>

#include <algorithm>

#define N 200007

using namespace std;

int n,k,l,p,q,r,s,f1[N],f2[N],a[N],cnt[N],ans[N];

int find1(int x){return f1[x]==x ? x:f1[x]=find1(f1[x]);}

int find2(int x){return f2[x]==x ? x:f2[x]=find2(f2[x]);}

bool cmp(int x,int y){return f1[x]<f1[y];}

int main(){

	scanf("%d%d%d",&n,&k,&l);

	for(int i=1;i<=n;++i)f1[i]=f2[i]=i;

	for(int i=1;i<=k;++i){

		scanf("%d%d",&p,&q);

		f1[find1(p)]=find1(q);

	}

	for(int i=1;i<=l;++i){

		scanf("%d%d",&r,&s);

		f2[find2(r)]=find2(s);

	}

	for(int i=1;i<=n;++i)f1[i]=find1(i),f2[i]=find2(i);

	for(int i=1;i<=n;++i)a[i]=i;

	sort(a+1,a+n+1,cmp);

	for(int i=1;i<=n;++i){

		int j=i;

		while(j<n && f1[a[j+1]]==f1[a[j]])++j;

		for(int t=i;t<=j;++t)++cnt[f2[a[t]]];

		for(int t=i;t<=j;++t)ans[a[t]]=cnt[f2[a[t]]];

		for(int t=i;t<=j;++t)--cnt[f2[a[t]]];

		i=j;

	}

	for(int i=1;i<=n;++i)printf("%d ",ans[i]);

}
// Slower C++ solution:
#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <iostream>

#include <algorithm>

using namespace std;

typedef long long LL;

inline int read() {

	int f=1,x=0; char ch=getchar();

	while (ch<'0'||ch>'9') { if (ch=='-') f=-1; ch=getchar(); }

	while (ch>='0'&&ch<='9') { x=x*10+ch-'0'; ch=getchar(); }

	return x*f;

}



const int MAXN=200005;

int n,m,r,tot,v[MAXN],f[MAXN],ans[MAXN];

struct List{

	int l,lt[MAXN],nt[MAXN<<1],v[MAXN<<1];

	void clear() { l=0; memset(lt,0,sizeof(lt)); }

	void addedge(int x,int y) { nt[++l]=lt[x]; lt[x]=l; v[l]=y; }

}E;

struct Data{

	int x,y;

	bool operator <(const Data &B)const { return x<B.x; }

}A[MAXN];

int ask(int x) { if (f[x]==x) return x; f[x]=ask(f[x]); return f[x]; }

void dfs(int x) {

	v[x]=1; A[++tot].x=ask(x); A[tot].y=x;

	for (int i=E.lt[x];i;i=E.nt[i]) if (!v[E.v[i]]) dfs(E.v[i]);

}

int main() {

	int i,j,k,l;

	n=read(); m=read(); r=read();

	for (i=1;i<=n;++i) f[i]=i; E.clear();

	for (i=1;i<=m;++i) {

		j=read(); k=read();

		E.addedge(j,k); E.addedge(k,j);

	}

	for (i=1;i<=r;++i) {

		j=ask(read()); k=ask(read());

		if (j!=k) f[j]=k;

	}

	memset(v,0,sizeof(v));

	for (i=1;i<=n;++i)

	if (!v[i]) {

		tot=0; dfs(i); sort(A+1,A+1+tot);

		for (j=1;j<=tot;j=k+1) {

			for (k=j;k<tot&&A[k+1].x==A[j].x;++k);

			for (l=j;l<=k;++l) ans[A[l].y]=k-j+1;

		}

	}

	for (i=1;i<n;++i) printf("%d ",ans[i]); printf("%d\n",ans[n]);

	return 0;

}



/*

4 3 1

1 2

2 3

3 4

2 3



*/


// Faster C++ solution for the same problem (measured speedup: 2.6146000078443388x):
#include <cstdio>

#include <iostream>

#include <algorithm>

#define N 200007

using namespace std;

int n,k,l,p,q,r,s,f1[N],f2[N],a[N],cnt[N],ans[N];

int find1(int x){return f1[x]==x ? x:f1[x]=find1(f1[x]);}

int find2(int x){return f2[x]==x ? x:f2[x]=find2(f2[x]);}

bool cmp(int x,int y){return f1[x]<f1[y];}

int main(){

	scanf("%d%d%d",&n,&k,&l);

	for(int i=1;i<=n;++i)f1[i]=f2[i]=i;

	for(int i=1;i<=k;++i){

		scanf("%d%d",&p,&q);

		f1[find1(p)]=find1(q);

	}

	for(int i=1;i<=l;++i){

		scanf("%d%d",&r,&s);

		f2[find2(r)]=find2(s);

	}

	for(int i=1;i<=n;++i)f1[i]=find1(i),f2[i]=find2(i);

	for(int i=1;i<=n;++i)a[i]=i;

	sort(a+1,a+n+1,cmp);

	for(int i=1;i<=n;++i){

		int j=i;

		while(j<n && f1[a[j+1]]==f1[a[j]])++j;

		for(int t=i;t<=j;++t)++cnt[f2[a[t]]];

		for(int t=i;t<=j;++t)ans[a[t]]=cnt[f2[a[t]]];

		for(int t=i;t<=j;++t)--cnt[f2[a[t]]];

		i=j;

	}

	for(int i=1;i<=n;++i)printf("%d ",ans[i]);

}
// Slower C++ solution:
#include <cstdio>

#include <map>

#include <vector>

using namespace std;



const int N = 2e5 + 5;

int pa1[N], pa2[N];

int find(int* p, int v) { return v == p[v] ? v : p[v] = find(p, p[v]); }

void unite(int* p, int a, int b) { p[find(p, b)] = find(p, a); }



typedef long long LL;

int n, k, l;

// vector<int> e1[N], e2[N];



map<LL, int> mp;



int main() {

#ifdef D

    freopen("a.in", "r", stdin);

#endif

    for (int i = 0; i < N; i++) {

        pa1[i] = pa2[i] = i;

    }

    scanf("%d%d%d", &n, &k, &l);

    for (int i = 0; i < k; i++) {

        int a, b;

        scanf("%d%d", &a, &b);

        unite(pa1, a, b);

        // e1[a].push_back(b);

        // e1[b].push_back(a);

    }

    for (int i = 0; i < l; i++) {

        int a, b;

        scanf("%d%d", &a, &b);

        unite(pa2, a, b);

        // e2[a].push_back(b);

        // e2[b].push_back(a);

    }



    for (int i = 1; i <= n; i++) {

        mp[find(pa1, i) * (LL)(n + 1) + find(pa2, i)] += 1;

    }



    for (int i = 1; i <= n; i++) {

        printf("%d ", mp[find(pa1, i) * (LL)(n + 1) + find(pa2, i)]);

    }

    puts("");



    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.400509989129529x):
#include <iostream>

#include <bits/stdc++.h>



using namespace std;



int fa[200005];

int fa1[200005];

int vis[200005];



int find1(int a)

{

    if(fa[a]!=a)

        fa[a]=find1(fa[a]);

    return fa[a];

}

void union1(int a,int b)

{

    fa[find1(a)]=find1(b);

}



int find2(int a)

{

    if(fa1[a]!=a)

        fa1[a]=find2(fa1[a]);

    return fa1[a];

}

void union2(int a,int b)

{

    fa1[find2(a)]=find2(b);

}

map<long long,int> mp;

int main()

{

    int n,k,l;

    cin>>n>>k>>l;

    memset(vis,0,sizeof(vis));

    for(int i=0;i<=n;i++)

    {

        fa[i]=i;

        fa1[i]=i;

    }

    for(int i=0;i<k;i++)

    {

        int l1,r;

        scanf("%d %d",&l1,&r);

        union1(l1,r);

    }

    for(int i=0;i<l;i++)

    {

        int l1,r;

        scanf("%d %d",&l1,&r);

        //if(find1(l1)==find1(r))

        union2(l1,r);

        //cout<<find1(l1)<<' '<<find1(r);

    }

    for(int i=1;i<=n;i++)

    {

        if(mp.find((long long)((long long)find1(i)*200005+(long long)find2(i)))==mp.end())

            mp[(long long)((long long)find1(i)*200005+(long long)find2(i))]=0;

        mp[(long long)((long long)find1(i)*200005+(long long)find2(i))]++;

    }

    for(int i=1;i<n;i++)

        printf("%d ",mp[(long long)((long long)find1(i)*200005+(long long)find2(i))]);

    printf("%d\n",mp[(long long)((long long)find1(n)*200005+(long long)find2(n))]);

    return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



const int maxn = 200010;



int fa1[maxn], fa2[maxn], r1[maxn], r2[maxn];



map<pair<int, int>, int> mp;



void kexin_init() {

	for (int i=1; i<=maxn; ++i) {fa1[i] = i; fa2[i] = i;}

	memset(r1, 0, sizeof r1);

	memset(r2, 0, sizeof r2);

}



int kexin_find_road(int x) {

	if (fa1[x] == x) return x;

	return fa1[x] = kexin_find_road(fa1[x]);

}

void kexin_Union_road(int x, int y) {

	x = kexin_find_road(x);

	y = kexin_find_road(y);

	if (x == y) return ;

	if (r1[x] < r1[y]) swap(x, y);

	fa1[y] = x;

	if (r1[x] == r1[y]) r1[x]++;

}



int kexin_find_railway(int x) {

	if (fa2[x] == x) return x;

	return fa2[x] = kexin_find_railway(fa2[x]);

}

void kexin_Union_railway(int x, int y) {

	x = kexin_find_railway(x);

	y = kexin_find_railway(y);

	if (x == y) return ;

	if (r2[x] < r2[y]) swap(x, y);

	fa2[y] = x;

	if (r2[x] == r2[y]) r2[x]++;

}

int main() {

	int n, k, l;

	scanf("%d%d%d", &n, &k, &l);

	

	kexin_init();

	for (int i=1; i<=k; ++i) {

		int x, y;

		scanf("%d%d", &x, &y);

		kexin_Union_road(x, y);

	}

	for (int i=1; i<=l; ++i) {

		int x, y;

		scanf("%d%d", &x, &y);

		kexin_Union_railway(x, y);

	}

	

	mp.clear();



	for (int i=1; i<=n; ++i) mp[make_pair(kexin_find_road(i), kexin_find_railway(i))]++;

	for (int i=1; i<n; ++i) printf("%d ", mp[make_pair(kexin_find_road(i), kexin_find_railway(i))]);

	printf("%d\n", mp[make_pair(kexin_find_road(n), kexin_find_railway(n))]);



	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 2.3353754440527887x):
#include <iostream>

#include <bits/stdc++.h>



using namespace std;



int fa[200005];

int fa1[200005];

int vis[200005];



int find1(int a)

{

    if(fa[a]!=a)

        fa[a]=find1(fa[a]);

    return fa[a];

}

void union1(int a,int b)

{

    fa[find1(a)]=find1(b);

}



int find2(int a)

{

    if(fa1[a]!=a)

        fa1[a]=find2(fa1[a]);

    return fa1[a];

}

void union2(int a,int b)

{

    fa1[find2(a)]=find2(b);

}

map<long long,int> mp;

int main()

{

    int n,k,l;

    cin>>n>>k>>l;

    memset(vis,0,sizeof(vis));

    for(int i=0;i<=n;i++)

    {

        fa[i]=i;

        fa1[i]=i;

    }

    for(int i=0;i<k;i++)

    {

        int l1,r;

        scanf("%d %d",&l1,&r);

        union1(l1,r);

    }

    for(int i=0;i<l;i++)

    {

        int l1,r;

        scanf("%d %d",&l1,&r);

        //if(find1(l1)==find1(r))

        union2(l1,r);

        //cout<<find1(l1)<<' '<<find1(r);

    }

    for(int i=1;i<=n;i++)

    {

        if(mp.find((long long)((long long)find1(i)*200005+(long long)find2(i)))==mp.end())

            mp[(long long)((long long)find1(i)*200005+(long long)find2(i))]=0;

        mp[(long long)((long long)find1(i)*200005+(long long)find2(i))]++;

    }

    for(int i=1;i<n;i++)

        printf("%d ",mp[(long long)((long long)find1(i)*200005+(long long)find2(i))]);

    printf("%d\n",mp[(long long)((long long)find1(n)*200005+(long long)find2(n))]);

    return 0;

}
// Slower C++ solution:
#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <iostream>

#include <algorithm>

using namespace std;

typedef long long LL;

inline int read() {

	int f=1,x=0; char ch=getchar();

	while (ch<'0'||ch>'9') { if (ch=='-') f=-1; ch=getchar(); }

	while (ch>='0'&&ch<='9') { x=x*10+ch-'0'; ch=getchar(); }

	return x*f;

}



const int MAXN=200005;

int n,m,r,tot,v[MAXN],f[MAXN],ans[MAXN];

struct List{

	int l,lt[MAXN],nt[MAXN<<1],v[MAXN<<1];

	void clear() { l=0; memset(lt,0,sizeof(lt)); }

	void addedge(int x,int y) { nt[++l]=lt[x]; lt[x]=l; v[l]=y; }

}E;

struct Data{

	int x,y;

	bool operator <(const Data &B)const { return x<B.x; }

}A[MAXN];

int ask(int x) { if (f[x]==x) return x; f[x]=ask(f[x]); return f[x]; }

void dfs(int x) {

	v[x]=1; A[++tot].x=ask(x); A[tot].y=x;

	for (int i=E.lt[x];i;i=E.nt[i]) if (!v[E.v[i]]) dfs(E.v[i]);

}

int main() {

	int i,j,k,l;

	n=read(); m=read(); r=read();

	for (i=1;i<=n;++i) f[i]=i; E.clear();

	for (i=1;i<=m;++i) {

		j=read(); k=read();

		E.addedge(j,k); E.addedge(k,j);

	}

	for (i=1;i<=r;++i) {

		j=ask(read()); k=ask(read());

		if (j!=k) f[j]=k;

	}

	memset(v,0,sizeof(v));

	for (i=1;i<=n;++i)

	if (!v[i]) {

		tot=0; dfs(i); sort(A+1,A+1+tot);

		for (j=1;j<=tot;j=k+1) {

			for (k=j;k<tot&&A[k+1].x==A[j].x;++k);

			for (l=j;l<=k;++l) ans[A[l].y]=k-j+1;

		}

	}

	for (i=1;i<n;++i) printf("%d ",ans[i]); printf("%d\n",ans[n]);

	return 0;

}



/*

4 3 1

1 2

2 3

3 4

2 3



*/


// Faster C++ solution for the same problem (measured speedup: 1.432600064842491x):
#include <iostream>

#include <bits/stdc++.h>



using namespace std;



int fa[200005];

int fa1[200005];

int vis[200005];



int find1(int a)

{

    if(fa[a]!=a)

        fa[a]=find1(fa[a]);

    return fa[a];

}

void union1(int a,int b)

{

    fa[find1(a)]=find1(b);

}



int find2(int a)

{

    if(fa1[a]!=a)

        fa1[a]=find2(fa1[a]);

    return fa1[a];

}

void union2(int a,int b)

{

    fa1[find2(a)]=find2(b);

}

map<long long,int> mp;

int main()

{

    int n,k,l;

    cin>>n>>k>>l;

    memset(vis,0,sizeof(vis));

    for(int i=0;i<=n;i++)

    {

        fa[i]=i;

        fa1[i]=i;

    }

    for(int i=0;i<k;i++)

    {

        int l1,r;

        scanf("%d %d",&l1,&r);

        union1(l1,r);

    }

    for(int i=0;i<l;i++)

    {

        int l1,r;

        scanf("%d %d",&l1,&r);

        //if(find1(l1)==find1(r))

        union2(l1,r);

        //cout<<find1(l1)<<' '<<find1(r);

    }

    for(int i=1;i<=n;i++)

    {

        if(mp.find((long long)((long long)find1(i)*200005+(long long)find2(i)))==mp.end())

            mp[(long long)((long long)find1(i)*200005+(long long)find2(i))]=0;

        mp[(long long)((long long)find1(i)*200005+(long long)find2(i))]++;

    }

    for(int i=1;i<n;i++)

        printf("%d ",mp[(long long)((long long)find1(i)*200005+(long long)find2(i))]);

    printf("%d\n",mp[(long long)((long long)find1(n)*200005+(long long)find2(n))]);

    return 0;

}
// Slower C++ solution:
#include<cstdio>

#include<algorithm>

#include<iostream>

#include<cstring>

#include<vector>

#include<cmath>

#include<map>

#include<set>

#include<queue>

using namespace std;

typedef long long ll;

const int N=2e5+10;

int a[N],b[N];

vector<int>v[N];

map<pair<int,int>,int>mp;

queue<int>q;

int main()

{

    int n,k,l,i,j;

    cin>>n>>k>>l;

    for(i=0;i<k;i++)

    {

        int x,y;

        scanf("%d %d",&x,&y);

        v[x].push_back(y);

        v[y].push_back(x);

    }

    int cnt=0;

    for(i=1;i<=n;i++)

    if(a[i]==0)

    {

        a[i]=++cnt;

        q.push(i);

        while(!q.empty())

        {

            int x=q.front();

            for(j=0;j<v[x].size();j++)

            if(a[v[x][j]]==0)

            {

                a[v[x][j]]=cnt;

                q.push(v[x][j]);

            }

            q.pop();

        }

    }

    for(i=1;i<=n;i++)v[i].clear();

    for(i=0;i<l;i++)

    {

        int x,y;

        scanf("%d %d",&x,&y);

        v[x].push_back(y);

        v[y].push_back(x);

    }

    cnt=0;

    for(i=1;i<=n;i++)

    if(b[i]==0)

    {

        b[i]=++cnt;

        q.push(i);

        while(!q.empty())

        {

            int x=q.front();

            for(j=0;j<v[x].size();j++)

            if(b[v[x][j]]==0)

            {

                b[v[x][j]]=cnt;

                q.push(v[x][j]);

            }

            q.pop();

        }

    }

    for(i=1;i<=n;i++)

        mp[make_pair(a[i],b[i])]++;

    for(i=1;i<=n;i++)

        printf("%d ",mp[make_pair(a[i],b[i])]);

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 3.5848254656283003x):
#include <iostream>

#include <bits/stdc++.h>



using namespace std;



int fa[200005];

int fa1[200005];

int vis[200005];



int find1(int a)

{

    if(fa[a]!=a)

        fa[a]=find1(fa[a]);

    return fa[a];

}

void union1(int a,int b)

{

    fa[find1(a)]=find1(b);

}



int find2(int a)

{

    if(fa1[a]!=a)

        fa1[a]=find2(fa1[a]);

    return fa1[a];

}

void union2(int a,int b)

{

    fa1[find2(a)]=find2(b);

}

map<long long,int> mp;

int main()

{

    int n,k,l;

    cin>>n>>k>>l;

    memset(vis,0,sizeof(vis));

    for(int i=0;i<=n;i++)

    {

        fa[i]=i;

        fa1[i]=i;

    }

    for(int i=0;i<k;i++)

    {

        int l1,r;

        scanf("%d %d",&l1,&r);

        union1(l1,r);

    }

    for(int i=0;i<l;i++)

    {

        int l1,r;

        scanf("%d %d",&l1,&r);

        //if(find1(l1)==find1(r))

        union2(l1,r);

        //cout<<find1(l1)<<' '<<find1(r);

    }

    for(int i=1;i<=n;i++)

    {

        if(mp.find((long long)((long long)find1(i)*200005+(long long)find2(i)))==mp.end())

            mp[(long long)((long long)find1(i)*200005+(long long)find2(i))]=0;

        mp[(long long)((long long)find1(i)*200005+(long long)find2(i))]++;

    }

    for(int i=1;i<n;i++)

        printf("%d ",mp[(long long)((long long)find1(i)*200005+(long long)find2(i))]);

    printf("%d\n",mp[(long long)((long long)find1(n)*200005+(long long)find2(n))]);

    return 0;

}
// Slower C++ solution:
#include <cstdio>

#include <map>

#include <vector>

using namespace std;



const int N = 2e5 + 5;

int pa1[N], pa2[N];

int find(int* p, int v) { return v == p[v] ? v : p[v] = find(p, p[v]); }

void unite(int* p, int a, int b) { p[find(p, b)] = find(p, a); }



typedef long long LL;

int n, k, l;

// vector<int> e1[N], e2[N];



map<LL, int> mp;



int main() {

#ifdef D

    freopen("a.in", "r", stdin);

#endif

    for (int i = 0; i < N; i++) {

        pa1[i] = pa2[i] = i;

    }

    scanf("%d%d%d", &n, &k, &l);

    for (int i = 0; i < k; i++) {

        int a, b;

        scanf("%d%d", &a, &b);

        unite(pa1, a, b);

        // e1[a].push_back(b);

        // e1[b].push_back(a);

    }

    for (int i = 0; i < l; i++) {

        int a, b;

        scanf("%d%d", &a, &b);

        unite(pa2, a, b);

        // e2[a].push_back(b);

        // e2[b].push_back(a);

    }



    for (int i = 1; i <= n; i++) {

        mp[find(pa1, i) * (LL)(n + 1) + find(pa2, i)] += 1;

    }



    for (int i = 1; i <= n; i++) {

        printf("%d ", mp[find(pa1, i) * (LL)(n + 1) + find(pa2, i)]);

    }

    puts("");



    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 2.527199034034224x):
#include<cstdio>

#include<queue>

#include<climits>

#include<algorithm>

#include<cstdlib>

#include<cmath>

#include<cstring>

#include<string>

#include<ctype.h>

#include<set>

#include<vector>

#include<map>

#include<time.h>

#include<list>

#include<stack>

#include<iostream>

using namespace std;

#define mod 1000000007

#define mem(x,k ) memset(x, (k) ,sizeof(x))

#define mp(A, B) make_pair(A, B)

#define pb push_back

#define sca scanf

#define pri printf

#define fi first

#define se second



typedef long long LL;

typedef long double LD;

typedef pair< int , int  > pii;



const LL INFLL=0x3f3f3f3f3f3f3f3fll;

const int INF=0x7fffffff;

const double PI=acos(-1.0);

const double  eps=1e-9;

//freopen("D.in","r",stdin);

//freopen("D.out","w",stdout);

int n,m,k;

int f[200005];

int f2[200005];

map<pair<int ,int >,int> G;

int Father(int k)

{

    if (k==f[k]) return k;

	return f[k]=Father(f[k]);

}



void Union(int x,int y)

{

    if (Father(x)==Father(y)) return;

    else

    {

        f[ f[x] ]=f[y];

        return;

    }

}

int Father2(int k)

{

    if (k==f2[k]) return k;

	return f2[k]=Father2(f2[k]);

}



void Union2(int x,int y)

{

    if (Father2(x)==Father2(y)) return;

    else

    {

        f2[ f2[x] ]=f2[y];

        return;

    }

}

int main(){

    scanf("%d%d%d",&n,&k,&m);

    for (int i=1;i<=n;i++){

        f[i]=f2[i]=i;

    }

    for (int i=1;i<=k;i++){

        int u,v;

        scanf("%d%d",&u,&v);

        Union2(u,v);

    }

    for (int i=1;i<=m;i++){

        int u,v;

        scanf("%d%d",&u,&v);

        Union(u,v);

    }

    for (int i=1;i<=n;i++){

        G[make_pair(Father(i),Father2(i))]++;

    }

    for (int i=1;i<=n;i++){

        //printf("@%d@",Father(i));

        printf("%d",G[make_pair(Father(i),Father2(i))]);

        if (i!=n) printf(" ");

    }

    printf("\n");

    return 0;

}
// Slower C++ solution:
#include <cstdio>

#include <map>

#include <vector>

using namespace std;



const int N = 2e5 + 5;

int pa1[N], pa2[N];

int find(int* p, int v) { return v == p[v] ? v : p[v] = find(p, p[v]); }

void unite(int* p, int a, int b) { p[find(p, b)] = find(p, a); }



typedef long long LL;

int n, k, l;

// vector<int> e1[N], e2[N];



map<LL, int> mp;



int main() {

#ifdef D

    freopen("a.in", "r", stdin);

#endif

    for (int i = 0; i < N; i++) {

        pa1[i] = pa2[i] = i;

    }

    scanf("%d%d%d", &n, &k, &l);

    for (int i = 0; i < k; i++) {

        int a, b;

        scanf("%d%d", &a, &b);

        unite(pa1, a, b);

        // e1[a].push_back(b);

        // e1[b].push_back(a);

    }

    for (int i = 0; i < l; i++) {

        int a, b;

        scanf("%d%d", &a, &b);

        unite(pa2, a, b);

        // e2[a].push_back(b);

        // e2[b].push_back(a);

    }



    for (int i = 1; i <= n; i++) {

        mp[find(pa1, i) * (LL)(n + 1) + find(pa2, i)] += 1;

    }



    for (int i = 1; i <= n; i++) {

        printf("%d ", mp[find(pa1, i) * (LL)(n + 1) + find(pa2, i)]);

    }

    puts("");



    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 2.514329236727945x):
#include<bits/stdc++.h>

using namespace std;

int bcj1[200010],bcj2[200010];

int father1(int k)

{

    return bcj1[k]==k?k:bcj1[k]=father1(bcj1[k]);

}

void join1(int x,int y)

{

    int fa,fb;

    fa=father1(x);fb=father1(y);

    bcj1[fb]=fa;

}

int father2(int k)

{

    return bcj2[k]==k?k:bcj2[k]=father2(bcj2[k]);

}

void join2(int x,int y)

{

    int fa,fb;

    fa=father2(x);fb=father2(y);

    bcj2[fb]=fa;

}

struct haha

{

    int p,q,no,ans;

}pp[200010];

bool cmp1(haha a,haha b)

{

    if (a.p==b.p) return a.q<b.q;

    return a.p<b.p;

}

bool cmp2(haha a,haha b)

{

    return a.no<b.no;

}

int main()

{

    int n,k,l,a,b,i,j,m,cnt;

    cin>>n>>k>>l;

    for(i=1;i<=n;i++)

    {

        bcj1[i]=bcj2[i]=i;

        pp[i].ans=0;pp[i].no=i;

    }

    for(i=1;i<=k;i++)

    {

        scanf("%d%d",&a,&b);

        join1(a,b);

    }

    for(i=1;i<=l;i++)

    {

        scanf("%d%d",&a,&b);

        join2(a,b);

    }

    for(i=1;i<=n;i++)

    {

        bcj1[i]=father1(bcj1[i]);

        pp[i].p=bcj1[i];

        bcj2[i]=father2(bcj2[i]);

        pp[i].q=bcj2[i];

    }

    sort(pp+1,pp+1+n,cmp1);cnt=0;

    pp[0].p=pp[0].q=0;j=1;

    for(i=1;i<=n+1;i++)

    {

        if (i<=n && pp[i].p==pp[i-1].p && pp[i].q==pp[i-1].q) continue;

        for(m=j;m<=i-1;m++)

            pp[m].ans=i-j;

        j=i;

    }

    sort(pp+1,pp+1+n,cmp2);

    for(i=1;i<=n;i++)

        printf("%d ",pp[i].ans);

    cout<<endl;

    return 0;

}