stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <iostream>

#include <cstdio>

#include <cstring>

#include <cmath>

#include <algorithm>

#include <vector>

#include <map>

#define ms(x) memset(x, 0, sizeof(x))

#define inf 0x3f3f3f3f

using namespace std;

const int N = 200005;

vector<int >book[N];

int faf[N], fag[N];

int vis[N];

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

void init() {

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

        faf[i] = fag[i] = i;

    }

}

int Find(int *f, int x){

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

    else{

        f[x] = Find(f, f[x]);

        return f[x];

    }

}

void Merge(int *f, int x, int y){

    int a = Find(f, x) , b = Find(f, y);

    if(a!=b){

        f[b] = a;

    }

}

int main() {

    int n, k, l;

    while(cin>>n>>k>>l) {

        int u, v;

        init();

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

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

            Merge(faf, u, v);

        }

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

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

            Merge(fag, u, v);

        }

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

            ++mp[{Find(faf, i), Find(fag, i)}];        //将同一个连通块中的点 集合起来

        }

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

            printf("%d%c", mp[{Find(faf, i), Find(fag, i)}],i==n?'\n':' ');

        }

    }

    return 0;

}


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

#include <cmath>

#include <queue>

#include <stack>

#include <vector>

#include <cstdio>

#include <string>

#include <cstring>

#include <sstream>

#include <algorithm>



using namespace std;



int ro[200005], ra[200005], n, k, l;



int Find(int *r, int x) {

    return r[x]==x ? x : r[x]=Find(r, r[x]);

}



void init() {

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

        ra[i]=ro[i]=i;

    }

}



vector <int> ve[200005];

map <int, int> ma;

int ans[200005];



int main () {

    int u, v;

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

    init();

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

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

        u=Find(ro, u), v=Find(ro, v);

        if(u!=v) {

            ro[u]=v;

        }

    }



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

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

        u=Find(ra, u), v=Find(ra, v);

        if(u!=v) {

            ra[u]=v;

        }

    }



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

        ve[Find(ro, i)].push_back(i);

    }



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

        ma.clear();

        for(int j=0;j<(int)ve[i].size();j++) {

            ma[Find(ra, ve[i][j])]++;

        }



        for(int j=0;j<(int)ve[i].size();j++) {

            ans[ve[i][j]]+=ma[Find(ra, ve[i][j])];

        }

    }



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

        printf("%d%c", ans[i], i==n ? '\n' : ' ');

    }

    return 0;

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

#include <cstdio>

#include <cstring>

#include <cmath>

#include <algorithm>

#include <vector>

#include <map>

#define ms(x) memset(x, 0, sizeof(x))

#define inf 0x3f3f3f3f

using namespace std;

const int N = 200005;

vector<int >book[N];

int faf[N], fag[N];

int vis[N];

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

void init() {

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

        faf[i] = fag[i] = i;

    }

}

int Find(int *f, int x){

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

    else{

        f[x] = Find(f, f[x]);

        return f[x];

    }

}

void Merge(int *f, int x, int y){

    int a = Find(f, x) , b = Find(f, y);

    if(a!=b){

        f[b] = a;

    }

}

int main() {

    int n, k, l;

    while(cin>>n>>k>>l) {

        int u, v;

        init();

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

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

            Merge(faf, u, v);

        }

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

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

            Merge(fag, u, v);

        }

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

            ++mp[{Find(faf, i), Find(fag, i)}];        //将同一个连通块中的点 集合起来

        }

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

            printf("%d%c", mp[{Find(faf, i), Find(fag, i)}],i==n?'\n':' ');

        }

    }

    return 0;

}


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

#include<ctime>

#include<cstdio>

#include<cstring>

#include<iostream>

#include<algorithm>

#define mp make_pair

using namespace std;



map<pair<int,int>,int> m;



struct dsu

{

	int fa[200010],rank[200010];

	

	void init(int n)

	{

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

		{

			fa[i]=i;

		}

	}

	

	int find(int x)

	{

		if(fa[x]==x)

		{

			return x;

		}

		return fa[x]=find(fa[x]);

	}

	

	void union_(int x,int y)

	{

		int fx=find(x);

		int fy=find(y);

		if(fx==fy)

		{

			return ;

		}

		if(rank[fx]<rank[fy])

		{

			fa[fx]=fy;

		}

		else

		{

			fa[fy]=fx;

			if(rank[fx]==rank[fy])

			{

				rank[x]++;

			}

		}

	}

	

	int same(int x,int y)

	{

		return find(x)==find(y);

	}

}a,b;



int main()

{

	//give the fucking vjudge a flying fucking

	int n,x,y;

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

	a.init(n);

	b.init(n);

	int from,to;

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

	{

		scanf("%d%d",&from,&to);

		a.union_(from,to);

	}

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

	{

		scanf("%d%d",&from,&to);

		b.union_(from,to);

	}

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

	{

		m[mp(a.find(i),b.find(i))]++;

	}

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

	{

		printf("%d ",m[mp(a.find(i),b.find(i))]);

	}

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

#include <cmath>

#include <queue>

#include <stack>

#include <vector>

#include <cstdio>

#include <string>

#include <cstring>

#include <sstream>

#include <algorithm>



using namespace std;



int ro[200005], ra[200005], n, k, l;



int Find(int *r, int x) {

    return r[x]==x ? x : r[x]=Find(r, r[x]);

}



void init() {

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

        ra[i]=ro[i]=i;

    }

}



vector <int> ve[200005];

map <int, int> ma;

int ans[200005];



int main () {

    int u, v;

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

    init();

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

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

        u=Find(ro, u), v=Find(ro, v);

        if(u!=v) {

            ro[u]=v;

        }

    }



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

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

        u=Find(ra, u), v=Find(ra, v);

        if(u!=v) {

            ra[u]=v;

        }

    }



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

        ve[Find(ro, i)].push_back(i);

    }



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

        ma.clear();

        for(int j=0;j<(int)ve[i].size();j++) {

            ma[Find(ra, ve[i][j])]++;

        }



        for(int j=0;j<(int)ve[i].size();j++) {

            ans[ve[i][j]]+=ma[Find(ra, ve[i][j])];

        }

    }



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

        printf("%d%c", ans[i], i==n ? '\n' : ' ');

    }

    return 0;

}

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

#include<ctime>

#include<cstdio>

#include<cstring>

#include<iostream>

#include<algorithm>

#define mp make_pair

using namespace std;



map<pair<int,int>,int> m;



struct dsu

{

	int fa[200010],rank[200010];

	

	void init(int n)

	{

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

		{

			fa[i]=i;

		}

	}

	

	int find(int x)

	{

		if(fa[x]==x)

		{

			return x;

		}

		return fa[x]=find(fa[x]);

	}

	

	void union_(int x,int y)

	{

		int fx=find(x);

		int fy=find(y);

		if(fx==fy)

		{

			return ;

		}

		if(rank[fx]<rank[fy])

		{

			fa[fx]=fy;

		}

		else

		{

			fa[fy]=fx;

			if(rank[fx]==rank[fy])

			{

				rank[x]++;

			}

		}

	}

	

	int same(int x,int y)

	{

		return find(x)==find(y);

	}

}a,b;



int main()

{

	//give the fucking vjudge a flying fucking

	int n,x,y;

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

	a.init(n);

	b.init(n);

	int from,to;

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

	{

		scanf("%d%d",&from,&to);

		a.union_(from,to);

	}

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

	{

		scanf("%d%d",&from,&to);

		b.union_(from,to);

	}

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

	{

		m[mp(a.find(i),b.find(i))]++;

	}

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

	{

		printf("%d ",m[mp(a.find(i),b.find(i))]);

	}

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

#include <cstdio>

#include <cstring>

#include <cmath>

#include <algorithm>

#include <vector>

#include <map>

#define ms(x) memset(x, 0, sizeof(x))

#define inf 0x3f3f3f3f

using namespace std;

const int N = 200005;

vector<int >book[N];

int faf[N], fag[N];

int vis[N];

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

void init() {

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

        faf[i] = fag[i] = i;

    }

}

int Find(int *f, int x){

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

    else{

        f[x] = Find(f, f[x]);

        return f[x];

    }

}

void Merge(int *f, int x, int y){

    int a = Find(f, x) , b = Find(f, y);

    if(a!=b){

        f[b] = a;

    }

}

int main() {

    int n, k, l;

    while(cin>>n>>k>>l) {

        int u, v;

        init();

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

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

            Merge(faf, u, v);

        }

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

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

            Merge(fag, u, v);

        }

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

            ++mp[{Find(faf, i), Find(fag, i)}];        //将同一个连通块中的点 集合起来

        }

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

            printf("%d%c", mp[{Find(faf, i), Find(fag, i)}],i==n?'\n':' ');

        }

    }

    return 0;

}


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

#include<map>

#define maxn 200005

using namespace std;

typedef pair<int,int> PII;

int n,k,l,fa[2][maxn],siz[maxn];

int find(int i,int x)

{

	if(fa[i][x]==x) return x;

	return fa[i][x]=find(i,fa[i][x]);

}

map<PII,int> mp;

int main()

{

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

	for(int i=1;i<=n;i++) fa[0][i]=fa[1][i]=i,siz[i]=1;

	while(k--)

	{

		int u,v;

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

		int r1=find(0,u),r2=find(0,v);

		if(r1!=r2) fa[0][r2]=r1;

	}

	while(l--)

	{

		int u,v;

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

		int r1=find(1,u),r2=find(1,v);

		if(r1!=r2) fa[1][r2]=r1;

	}

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

	{

		int r1=find(0,i),r2=find(1,i);

		mp[PII(r1,r2)]++;

	}

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

	{

		int r1=find(0,i),r2=find(1,i);

		printf("%d",mp[PII(r1,r2)]);

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

	}

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

#include <cmath>

#include <queue>

#include <stack>

#include <vector>

#include <cstdio>

#include <string>

#include <cstring>

#include <sstream>

#include <algorithm>



using namespace std;



int ro[200005], ra[200005], n, k, l;



int Find(int *r, int x) {

    return r[x]==x ? x : r[x]=Find(r, r[x]);

}



void init() {

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

        ra[i]=ro[i]=i;

    }

}



vector <int> ve[200005];

map <int, int> ma;

int ans[200005];



int main () {

    int u, v;

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

    init();

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

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

        u=Find(ro, u), v=Find(ro, v);

        if(u!=v) {

            ro[u]=v;

        }

    }



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

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

        u=Find(ra, u), v=Find(ra, v);

        if(u!=v) {

            ra[u]=v;

        }

    }



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

        ve[Find(ro, i)].push_back(i);

    }



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

        ma.clear();

        for(int j=0;j<(int)ve[i].size();j++) {

            ma[Find(ra, ve[i][j])]++;

        }



        for(int j=0;j<(int)ve[i].size();j++) {

            ans[ve[i][j]]+=ma[Find(ra, ve[i][j])];

        }

    }



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

        printf("%d%c", ans[i], i==n ? '\n' : ' ');

    }

    return 0;

}

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

#include<map>

#define maxn 200005

using namespace std;

typedef pair<int,int> PII;

int n,k,l,fa[2][maxn],siz[maxn];

int find(int i,int x)

{

	if(fa[i][x]==x) return x;

	return fa[i][x]=find(i,fa[i][x]);

}

map<PII,int> mp;

int main()

{

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

	for(int i=1;i<=n;i++) fa[0][i]=fa[1][i]=i,siz[i]=1;

	while(k--)

	{

		int u,v;

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

		int r1=find(0,u),r2=find(0,v);

		if(r1!=r2) fa[0][r2]=r1;

	}

	while(l--)

	{

		int u,v;

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

		int r1=find(1,u),r2=find(1,v);

		if(r1!=r2) fa[1][r2]=r1;

	}

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

	{

		int r1=find(0,i),r2=find(1,i);

		mp[PII(r1,r2)]++;

	}

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

	{

		int r1=find(0,i),r2=find(1,i);

		printf("%d",mp[PII(r1,r2)]);

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

	}

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

#include <cstdio>

#include <cstring>

#include <cmath>

#include <algorithm>

#include <vector>

#include <map>

#define ms(x) memset(x, 0, sizeof(x))

#define inf 0x3f3f3f3f

using namespace std;

const int N = 200005;

vector<int >book[N];

int faf[N], fag[N];

int vis[N];

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

void init() {

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

        faf[i] = fag[i] = i;

    }

}

int Find(int *f, int x){

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

    else{

        f[x] = Find(f, f[x]);

        return f[x];

    }

}

void Merge(int *f, int x, int y){

    int a = Find(f, x) , b = Find(f, y);

    if(a!=b){

        f[b] = a;

    }

}

int main() {

    int n, k, l;

    while(cin>>n>>k>>l) {

        int u, v;

        init();

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

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

            Merge(faf, u, v);

        }

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

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

            Merge(fag, u, v);

        }

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

            ++mp[{Find(faf, i), Find(fag, i)}];        //将同一个连通块中的点 集合起来

        }

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

            printf("%d%c", mp[{Find(faf, i), Find(fag, i)}],i==n?'\n':' ');

        }

    }

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 9.092524621346012x):
/*Lucky_Glass*/

#include<cstdio>

#include<cstring>

#include<algorithm>

#include<vector>

#include<queue>

#include<map>

using namespace std;

const int MAXN=int(2e5);

int n,p,q;

int fa[2][MAXN+5];

map< pair<int,int> ,int> cnt;

int Find(int x,int y)

{

	if(fa[y][x]==x) return x;

	return fa[y][x]=Find(fa[y][x],y);

}

int main()

{

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

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

		fa[0][i]=fa[1][i]=i;

	for(int i=0,u,v;i<p;i++)

	{

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

		if(Find(u,0)!=Find(v,0))

			fa[0][fa[0][u]]=fa[0][v];

	}

	for(int i=0,u,v;i<q;i++)

	{

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

		if(Find(u,1)!=Find(v,1))

			fa[1][fa[1][u]]=fa[1][v];

	}

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

		cnt[make_pair(Find(i,0),Find(i,1))]++;

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

	{

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

		printf("%d",cnt[make_pair(fa[0][i],fa[1][i])]);

	}

	printf("\n");

	return 0;

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

#include <cmath>

#include <queue>

#include <stack>

#include <vector>

#include <cstdio>

#include <string>

#include <cstring>

#include <sstream>

#include <algorithm>



using namespace std;



int ro[200005], ra[200005], n, k, l;



int Find(int *r, int x) {

    return r[x]==x ? x : r[x]=Find(r, r[x]);

}



void init() {

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

        ra[i]=ro[i]=i;

    }

}



vector <int> ve[200005];

map <int, int> ma;

int ans[200005];



int main () {

    int u, v;

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

    init();

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

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

        u=Find(ro, u), v=Find(ro, v);

        if(u!=v) {

            ro[u]=v;

        }

    }



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

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

        u=Find(ra, u), v=Find(ra, v);

        if(u!=v) {

            ra[u]=v;

        }

    }



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

        ve[Find(ro, i)].push_back(i);

    }



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

        ma.clear();

        for(int j=0;j<(int)ve[i].size();j++) {

            ma[Find(ra, ve[i][j])]++;

        }



        for(int j=0;j<(int)ve[i].size();j++) {

            ans[ve[i][j]]+=ma[Find(ra, ve[i][j])];

        }

    }



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

        printf("%d%c", ans[i], i==n ? '\n' : ' ');

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 6.852935684946403x):
/*Lucky_Glass*/

#include<cstdio>

#include<cstring>

#include<algorithm>

#include<vector>

#include<queue>

#include<map>

using namespace std;

const int MAXN=int(2e5);

int n,p,q;

int fa[2][MAXN+5];

map< pair<int,int> ,int> cnt;

int Find(int x,int y)

{

	if(fa[y][x]==x) return x;

	return fa[y][x]=Find(fa[y][x],y);

}

int main()

{

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

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

		fa[0][i]=fa[1][i]=i;

	for(int i=0,u,v;i<p;i++)

	{

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

		if(Find(u,0)!=Find(v,0))

			fa[0][fa[0][u]]=fa[0][v];

	}

	for(int i=0,u,v;i<q;i++)

	{

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

		if(Find(u,1)!=Find(v,1))

			fa[1][fa[1][u]]=fa[1][v];

	}

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

		cnt[make_pair(Find(i,0),Find(i,1))]++;

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

	{

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

		printf("%d",cnt[make_pair(fa[0][i],fa[1][i])]);

	}

	printf("\n");

	return 0;

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

#include <cstdio>

#include <cstring>

#include <cmath>

#include <algorithm>

#include <vector>

#include <map>

#define ms(x) memset(x, 0, sizeof(x))

#define inf 0x3f3f3f3f

using namespace std;

const int N = 200005;

vector<int >book[N];

int faf[N], fag[N];

int vis[N];

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

void init() {

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

        faf[i] = fag[i] = i;

    }

}

int Find(int *f, int x){

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

    else{

        f[x] = Find(f, f[x]);

        return f[x];

    }

}

void Merge(int *f, int x, int y){

    int a = Find(f, x) , b = Find(f, y);

    if(a!=b){

        f[b] = a;

    }

}

int main() {

    int n, k, l;

    while(cin>>n>>k>>l) {

        int u, v;

        init();

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

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

            Merge(faf, u, v);

        }

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

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

            Merge(fag, u, v);

        }

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

            ++mp[{Find(faf, i), Find(fag, i)}];        //将同一个连通块中的点 集合起来

        }

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

            printf("%d%c", mp[{Find(faf, i), Find(fag, i)}],i==n?'\n':' ');

        }

    }

    return 0;

}


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

#include<cstring>

#include<algorithm>

#include<set>

#include<map>

#define MAXN 200000

using namespace std;

typedef pair<int,int> PII;

map<PII,int> mp;

int setfa[2][MAXN+5];

void Init()

{

	for(int i=0;i<=MAXN+3;i++)

		setfa[0][i]=setfa[1][i]=i;

}

int Findfa(int x,int typ)

{

	if(setfa[typ][x]==x)

		return x;

	return setfa[typ][x]=Findfa(setfa[typ][x],typ);

}

void Union(int x,int y,int typ)

{

	int fx=Findfa(x,typ),fy=Findfa(y,typ);

	if(fx==fy)

		return;

	setfa[typ][fx]=fy;

}

int main()

{

	Init();

	int N,K,L;

	scanf("%d %d %d",&N,&K,&L);

	int x,y;

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

	{

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

		Union(x,y,0);

	}

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

	{

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

		Union(x,y,1);

	}

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

	{

		int a=Findfa(i,0),b=Findfa(i,1);

		mp[PII(a,b)]++;

	}

	int Ans;

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

	{

		int a=Findfa(i,0),b=Findfa(i,1);

		Ans=mp[PII(a,b)];

		if(i==1)

			printf("%d",Ans);

		else

			printf(" %d",Ans);

	}

	printf("\n");

	return 0;

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

#include <cmath>

#include <queue>

#include <stack>

#include <vector>

#include <cstdio>

#include <string>

#include <cstring>

#include <sstream>

#include <algorithm>



using namespace std;



int ro[200005], ra[200005], n, k, l;



int Find(int *r, int x) {

    return r[x]==x ? x : r[x]=Find(r, r[x]);

}



void init() {

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

        ra[i]=ro[i]=i;

    }

}



vector <int> ve[200005];

map <int, int> ma;

int ans[200005];



int main () {

    int u, v;

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

    init();

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

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

        u=Find(ro, u), v=Find(ro, v);

        if(u!=v) {

            ro[u]=v;

        }

    }



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

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

        u=Find(ra, u), v=Find(ra, v);

        if(u!=v) {

            ra[u]=v;

        }

    }



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

        ve[Find(ro, i)].push_back(i);

    }



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

        ma.clear();

        for(int j=0;j<(int)ve[i].size();j++) {

            ma[Find(ra, ve[i][j])]++;

        }



        for(int j=0;j<(int)ve[i].size();j++) {

            ans[ve[i][j]]+=ma[Find(ra, ve[i][j])];

        }

    }



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

        printf("%d%c", ans[i], i==n ? '\n' : ' ');

    }

    return 0;

}

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

#include<cstring>

#include<algorithm>

#include<set>

#include<map>

#define MAXN 200000

using namespace std;

typedef pair<int,int> PII;

map<PII,int> mp;

int setfa[2][MAXN+5];

void Init()

{

	for(int i=0;i<=MAXN+3;i++)

		setfa[0][i]=setfa[1][i]=i;

}

int Findfa(int x,int typ)

{

	if(setfa[typ][x]==x)

		return x;

	return setfa[typ][x]=Findfa(setfa[typ][x],typ);

}

void Union(int x,int y,int typ)

{

	int fx=Findfa(x,typ),fy=Findfa(y,typ);

	if(fx==fy)

		return;

	setfa[typ][fx]=fy;

}

int main()

{

	Init();

	int N,K,L;

	scanf("%d %d %d",&N,&K,&L);

	int x,y;

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

	{

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

		Union(x,y,0);

	}

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

	{

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

		Union(x,y,1);

	}

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

	{

		int a=Findfa(i,0),b=Findfa(i,1);

		mp[PII(a,b)]++;

	}

	int Ans;

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

	{

		int a=Findfa(i,0),b=Findfa(i,1);

		Ans=mp[PII(a,b)];

		if(i==1)

			printf("%d",Ans);

		else

			printf(" %d",Ans);

	}

	printf("\n");

	return 0;

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

#include <cstdio>

#include <cstring>

#include <cmath>

#include <algorithm>

#include <vector>

#include <map>

#define ms(x) memset(x, 0, sizeof(x))

#define inf 0x3f3f3f3f

using namespace std;

const int N = 200005;

vector<int >book[N];

int faf[N], fag[N];

int vis[N];

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

void init() {

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

        faf[i] = fag[i] = i;

    }

}

int Find(int *f, int x){

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

    else{

        f[x] = Find(f, f[x]);

        return f[x];

    }

}

void Merge(int *f, int x, int y){

    int a = Find(f, x) , b = Find(f, y);

    if(a!=b){

        f[b] = a;

    }

}

int main() {

    int n, k, l;

    while(cin>>n>>k>>l) {

        int u, v;

        init();

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

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

            Merge(faf, u, v);

        }

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

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

            Merge(fag, u, v);

        }

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

            ++mp[{Find(faf, i), Find(fag, i)}];        //将同一个连通块中的点 集合起来

        }

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

            printf("%d%c", mp[{Find(faf, i), Find(fag, i)}],i==n?'\n':' ');

        }

    }

    return 0;

}


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

using namespace std;

const int N=200000+10;

const int INF=10000000;

int p1[N],p2[N];

map<pair<int,int>,int>m;

int find(int x,int *p)

{

    return p[x]==x?p[x]:p[x]=find(p[x],p);

}

void cha(int x,int y,int *p)

{

    int px=find(x,p);

    int py=find(y,p);

    if(px!=py)

    {

        p[px]=py;

    }

}

int main()

{

    int n,k,l;

    cin>>n>>k>>l;

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

        p1[i]=i,p2[i]=i;

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

    {

        int x,y;

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

        cha(x,y,p1);

    }

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

    {

        int x,y;

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

        cha(x,y,p2);

    }

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

    {

        find(i,p1);

        find(i,p2);

    }

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

        m[make_pair(p1[i],p2[i])]++;

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

        printf("%d ",m[make_pair(p1[i],p2[i])]);

    putchar('\n');

    return 0;

}