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

using namespace std;

using ll = long long;

#define rep(i, n) for (int i = 0; i < (int)(n); i++)

#define P pair<ll,ll>



vector<int> to[200010];



void dfs(int i, int &gr, vector<int> &group){

  if(group[i]!=-1) return;

  group[i]=gr;

  for(auto x : to[i]){

    dfs(x,gr,group);

  }

}



int main(){

  int n,m;

  cin>>n>>m;

  rep(i,m){

    int a,b;

    cin>>a>>b;

    a--;b--;

    to[a].push_back(b);

    to[b].push_back(a);

  }

  vector<int> group(n);

  rep(i,n) group[i]=-1;

  int tmp=0;

  rep(i,n){

    if(group[i]==-1){

      dfs(i,tmp,group);

      tmp++;

    }

  }

  map<int,int> mp;

  rep(i,n){

    mp[group[i]]++;

  }

  int ans=0;

  for(auto x : mp){

    ans=max(ans,x.second);

  }

  cout<<ans<<endl;

}

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

using namespace std;

using ll = long long;

#define rep(i, n) for (int i = 0; i < (int)(n); i++)

#define P pair<ll,ll>



class UnionFind {

    vector<int> data;

    ll num;

public:

    UnionFind(int size) : data(size, -1), num(size) { }

    bool unite(int x, int y) {//xとyの集合を統合する

        x = root(x); y = root(y);

        if (x != y) {

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

            data[x] += data[y]; data[y] = x;

        }

        num -= (x != y);

        return x != y;

    }

    bool findSet(int x, int y) {//xとyが同じ集合か返す

        return root(x) == root(y);

    }

    int root(int x) {//xのルートを返す

        return data[x] < 0 ? x : data[x] = root(data[x]);

    }

    ll size(int x) {//xの集合のサイズを返す

        return -data[root(x)];

    }

    ll numSet() {//集合の数を返す

        return num;

    }

};





int main(){

  int n,m;

  cin>>n>>m;

  UnionFind uf(n);

  rep(i,m){

    int a,b;

    cin>>a>>b;

    a--;b--;

    uf.unite(a,b);

  }

  ll ans=0;

  rep(i,n) ans=max(ans,uf.size(i));

  cout<<ans<<endl;



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



#define pb push_back

#define mp make_pair

#define ff first

#define ss second

#define all(x) (x).begin(), (x).end()

#define ll long long

#define ii pair<int,int>

#define vi vector<int>

#define vll vector<ll>

#define vii vector<ii>



const int INF = 0x3f3f3f3f;

const ll  LINF = 0x3f3f3f3f3f3f3f3fLL;

const int maxn = 2e5+10;

const int mod = 1e9+7;



using namespace std;



int p[maxn],sz[maxn],qtd;



void start(){

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

        p[i] = i;

        sz[i] = 1;

    }

}



int find_set(int x){

    return p[x] = (p[x] == x ? x : find_set(p[x])); 

}



int same_set(int x,int y){

    return find_set(x) == find_set(y);

}



void union_set(int a,int b){

    a = find_set(a);

    b = find_set(b);

    if(a==b) return;

    if(sz[a] > sz[b]) swap(a,b);

    p[a] = b;

    sz[b]+=sz[a];

}



void solve(){

    int n,m;

    cin >> n >> m;

    while(m--){

        int x,y;

        cin >> x >> y;

        union_set(x,y);

    }

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

        if(p[i] == i){

            qtd=max(qtd,sz[i]);

        }

    }

    cout << qtd << endl;

}



int32_t main(){

    ios_base::sync_with_stdio(false);

    cin.tie(0);

    cout.tie(0);



    start();



    int t = 1;



    // cin >> t;



    while(t--){

        solve();

    }



    return 0;

}

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

#include <map>

#include <numeric>

#include <vector>

#include <set>

#include <algorithm>



using namespace std;

using ll = long long;



class UFDS {

public:

    std::vector<ll> size, ps;

    ll ans;

    UFDS(ll N) : size(N + 1, 1), ps(N + 1), ans(1) {

        iota(ps.begin(), ps.end(), 0);

    }



    ll find_set(ll x) const {

        return x == ps[x] ? x : find_set(ps[x]);

    }



    bool same_set(ll x, ll y) {

        return find_set(x) == find_set(y);

    }



    void union_set(ll x, ll y)

    {

        if (same_set(x, y)) return;



        ll p = find_set(x);

        ll q = find_set(y);



        if (size[p] < size[q])

            std::swap(p, q);



        ps[q] = p;

        size[p] += size[q];



        ans = max(ans, size[p]);

    }

};



int main()

{

    ll n, m;

    cin >> n >> m;



    UFDS union_find(n);



    while(m--)

    {

        ll a, b;

        cin >> a >> b;



        union_find.union_set(a, b);

    }



    cout << union_find.ans << '\n';





    return 0;

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



#define pb push_back

#define mp make_pair

#define ff first

#define ss second

#define all(x) (x).begin(), (x).end()

#define ll long long

#define ii pair<int,int>

#define vi vector<int>

#define vll vector<ll>

#define vii vector<ii>



const int INF = 0x3f3f3f3f;

const ll  LINF = 0x3f3f3f3f3f3f3f3fLL;

const int maxn = 2e5+10;

const int mod = 1e9+7;



using namespace std;



int p[maxn],sz[maxn],qtd;



void start(){

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

        p[i] = i;

        sz[i] = 1;

    }

}



int find_set(int x){

    return p[x] = (p[x] == x ? x : find_set(p[x])); 

}



int same_set(int x,int y){

    return find_set(x) == find_set(y);

}



void union_set(int a,int b){

    a = find_set(a);

    b = find_set(b);

    if(a==b) return;

    if(sz[a] > sz[b]) swap(a,b);

    p[a] = b;

    sz[b]+=sz[a];

}



void solve(){

    int n,m;

    cin >> n >> m;

    while(m--){

        int x,y;

        cin >> x >> y;

        union_set(x,y);

    }

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

        if(p[i] == i){

            qtd=max(qtd,sz[i]);

        }

    }

    cout << qtd << endl;

}



int32_t main(){

    ios_base::sync_with_stdio(false);

    cin.tie(0);

    cout.tie(0);



    start();



    int t = 1;



    // cin >> t;



    while(t--){

        solve();

    }



    return 0;

}

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

using namespace std;

const int N = 2e5 + 5;

const int maxn = 2e5 + 5;

typedef long long ll;

typedef uint64_t HT;

const int mod = 1e9 + 7;

int pre[N], sum[N];

int find(const int &x) {

    return x == pre[x] ? x : pre[x] = find(pre[x]);

}

int main() {

    int n, m;

    cin >> n >> m;

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

        pre[i] = i;

        sum[i] = 1;

    }

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

        int x, y;

        cin >> x >> y;

        int xx = find(x);

        int yy = find(y);

        if (xx != yy) {

            pre[xx] = yy;

            sum[yy] = sum[yy] + sum[xx];

        }

    }

    int ans = 0;

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

        if (find(i) == i) ans = max(ans, sum[i]);

    }

    cout << ans << "\n";

    return 0;

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

#define ss second

#define ff first

#define all(x) x.begin(), x.end()



using namespace std;

using ll = long long;

using pii = pair<ll, ll>;



const ll oo = 1e18 + 7;

const ll mod = 1e9 + 7, maxn = 2e5 + 10;  

const long double PI = acos(-1);

int cnt = 1, ps[maxn], sz[maxn];



int find(int x){

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

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

}



void uni(int a, int b){

    a = find(a);

    b = find(b);



    if (a == b) return;



    ps[a] = b;

    sz[b] += sz[a];

    cnt = max(cnt, sz[b]);

}



void init(){

    iota(ps, ps+maxn, 0);

    for (int i=0; i<maxn; i++) sz[i] = 1;

}



int main (){

    ios_base::sync_with_stdio(false);

    cin.tie(0);

    int n,m;

    cin >> n >> m;

    init();



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

        int a, b;

        cin >> a >> b;

        uni(--a, --b);

    }



    cout << cnt << endl;

    return 0;   

}

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

using namespace std;

const int N = 2e5 + 5;

const int maxn = 2e5 + 5;

typedef long long ll;

typedef uint64_t HT;

const int mod = 1e9 + 7;

int pre[N], sum[N];

int find(const int &x) {

    return x == pre[x] ? x : pre[x] = find(pre[x]);

}

int main() {

    int n, m;

    cin >> n >> m;

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

        pre[i] = i;

        sum[i] = 1;

    }

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

        int x, y;

        cin >> x >> y;

        int xx = find(x);

        int yy = find(y);

        if (xx != yy) {

            pre[xx] = yy;

            sum[yy] = sum[yy] + sum[xx];

        }

    }

    int ans = 0;

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

        if (find(i) == i) ans = max(ans, sum[i]);

    }

    cout << ans << "\n";

    return 0;

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



#define pb push_back

#define mp make_pair

#define ff first

#define ss second

#define all(x) (x).begin(), (x).end()

#define ll long long

#define ii pair<int,int>

#define vi vector<int>

#define vll vector<ll>

#define vii vector<ii>



const int INF = 0x3f3f3f3f;

const ll  LINF = 0x3f3f3f3f3f3f3f3fLL;

const int maxn = 2e5+10;

const int mod = 1e9+7;



using namespace std;



int p[maxn],sz[maxn],qtd;



void start(){

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

        p[i] = i;

        sz[i] = 1;

    }

}



int find_set(int x){

    return p[x] = (p[x] == x ? x : find_set(p[x])); 

}



int same_set(int x,int y){

    return find_set(x) == find_set(y);

}



void union_set(int a,int b){

    a = find_set(a);

    b = find_set(b);

    if(a==b) return;

    if(sz[a] > sz[b]) swap(a,b);

    p[a] = b;

    sz[b]+=sz[a];

}



void solve(){

    int n,m;

    cin >> n >> m;

    while(m--){

        int x,y;

        cin >> x >> y;

        union_set(x,y);

    }

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

        if(p[i] == i){

            qtd=max(qtd,sz[i]);

        }

    }

    cout << qtd << endl;

}



int32_t main(){

    ios_base::sync_with_stdio(false);

    cin.tie(0);

    cout.tie(0);



    start();



    int t = 1;



    // cin >> t;



    while(t--){

        solve();

    }



    return 0;

}

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

#define ll long long

using namespace std;

const ll mod=1e9+7;

int f[200005]={0};

int sz[200005]={0};

int n,m;

int ans=1;

int get(int x)

{

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

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

}

void merge(int x,int y)

{

	int xx=get(x);

	int yy=get(y);

	if(xx!=yy){

		f[xx]=yy;

		sz[yy]+=sz[xx];

		ans=max(ans,sz[yy]);

	}

	

}

void init()

{

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

		f[i]=i;

		sz[i]=1;

	}

}

int main(){

    cin>>n>>m;

    init();

    while(m--){

    	int x,y;

    	cin>>x>>y;

    	merge(x,y);

	}

	cout<<ans<<endl;

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

#define ss second

#define ff first

#define all(x) x.begin(), x.end()



using namespace std;

using ll = long long;

using pii = pair<ll, ll>;



const ll oo = 1e18 + 7;

const ll mod = 1e9 + 7, maxn = 2e5 + 10;  

const long double PI = acos(-1);

int cnt = 1, ps[maxn], sz[maxn];



int find(int x){

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

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

}



void uni(int a, int b){

    a = find(a);

    b = find(b);



    if (a == b) return;



    ps[a] = b;

    sz[b] += sz[a];

    cnt = max(cnt, sz[b]);

}



void init(){

    iota(ps, ps+maxn, 0);

    for (int i=0; i<maxn; i++) sz[i] = 1;

}



int main (){

    ios_base::sync_with_stdio(false);

    cin.tie(0);

    int n,m;

    cin >> n >> m;

    init();



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

        int a, b;

        cin >> a >> b;

        uni(--a, --b);

    }



    cout << cnt << endl;

    return 0;   

}

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

#define ll long long

using namespace std;

const ll mod=1e9+7;

int f[200005]={0};

int sz[200005]={0};

int n,m;

int ans=1;

int get(int x)

{

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

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

}

void merge(int x,int y)

{

	int xx=get(x);

	int yy=get(y);

	if(xx!=yy){

		f[xx]=yy;

		sz[yy]+=sz[xx];

		ans=max(ans,sz[yy]);

	}

	

}

void init()

{

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

		f[i]=i;

		sz[i]=1;

	}

}

int main(){

    cin>>n>>m;

    init();

    while(m--){

    	int x,y;

    	cin>>x>>y;

    	merge(x,y);

	}

	cout<<ans<<endl;

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

using namespace std;

class UF {

public:

    vector<int> fa;

    vector<int> sz;

    int n;

    int comp_cnt;



public:

    UF(int _n) : n(_n), comp_cnt(_n), fa(_n), sz(_n, 1) {

        iota(fa.begin(), fa.end(), 0);

    }



    int findset(int x) {

        return fa[x] == x ? x : fa[x] = findset(fa[x]);

    }



    void unite(int x, int y) {

        if (sz[x] < sz[y]) {

            swap(x, y);

        }

        fa[y] = x;

        sz[x] += sz[y];

        --comp_cnt;

    }



    bool findAndUnite(int x, int y) {

        int x0 = findset(x);

        int y0 = findset(y);

        if (x0 != y0) {

            unite(x0, y0);

            return true;

        }

        return false;

    }

};

int main() {

    int n, m;

    cin >> n >> m;

    UF uf(2e5 + 100);

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

        int a, b;

        cin >> a >> b;

        uf.findAndUnite(a, b);

    }

    int ans = 0;

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

        ans = max(ans, uf.sz[i]);

    }

    cout << ans << endl;

	return 0;

}

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

	

using namespace std;

inline void FAST_IO(){ ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);}



template<class F, class S> ostream& operator<<(ostream& os, pair<F, S> &p) {

	os << "(" << p.first << "," << p.second << ")";

	return os;

}



template<class T, class S> ostream& operator<<(ostream& os, map<T, S> &v) {

	os << "{";

	for(auto &i : v) cout << "{" << i.first << "," << i.second << "}";

	os << "}";

	return os;

}



template<class T> ostream& operator<<(ostream& os, set<T> &v) {

	os << "{";

	for(auto &i : v) cout << i << ",";

	os << "}";

	return os;

}

 

template<class T> ostream& operator<<(ostream& os, vector<T> &v) {

	os << "[";

	if(v.size()) os << v[0];

	for(int i = 1; i < v.size(); ++i) os << "," << v[i];

	os << "]";

	return os;

}



/*----------------------------------------------------------------------------*/



class UF{

public:

	int *a, *sz;

	int n;



	UF(int n){

		sz = new int[n];

		a = new int[n];

		this->n = n;

		

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

			a[i] = i, sz[i] = 1;

	}

	

	~UF(){

		delete sz;

		delete a;

	}

	

	int root(int p){

		while(a[p] != p) {

			a[p] = a[a[p]];

			p = a[p];

		}

		return p;

	}

	

	void merge(int p, int q){

		int i = root(p);

		int j = root(q);

		

		if(i == j) return;

		

		if(sz[i] > sz[j]) a[j] = i, sz[i] += sz[j];

		else a[i] = j, sz[j] += sz[i];

	}

	

	bool find(int p, int q){

		return root(p) == root(q);

	}	

};



int main (){

	// FAST_IO();



	int n,m;

	cin >> n >> m;

	UF uf(n+1);



	int resp = 1;

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

		int a, b;

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



		if (!uf.find(a,b)) {

			uf.merge(a,b);

			resp = max(resp, uf.sz[uf.root(a)]);

		}

	}



	cout << resp << endl;



	return 0;

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

#include <set>

#include <vector>

#include <string>

#include <algorithm>

#include <cmath>

using namespace std;

using ll=long long;

#define rep(i,a,b) for(ll i=a;i<ll(b);i++)

#define repr(i,a,b) for(ll i=a;i>=ll(b);i--)

#define endl "\n"

#define ALL(x) x.begin(),x.end()

#define ALLR(x) x.rbegin(),x.rend()

#define INF 1e9

#define DEBUG(x) cout<<"debug: "<<x<<endl



vector<bool> seen(200001);

set<int> graph[200001];



int surch(const set<int> g){

    int succ = 0;

    for(auto x : g){

        if(seen[x]) continue;

        seen[x] = true;

        succ++;

        succ += surch(graph[x]);

    }

    return succ;

}



int n, m;

int main() {

    cin >> n >> m;



    rep(_, 0, m){

        int a, b; cin >> a >> b;

        a--;b--;

        graph[a].insert(b);

        graph[b].insert(a);

    }



    int ans = 1;

    rep(i, 0, n){

        if(seen[i]) continue;

        int tmp = surch(graph[i]);

        ans = max(ans, tmp);

    }



    cout << ans << endl;

    return 0;

}


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

#include <vector>

using namespace std;

using ll=long long;

#define rep(i,a,b) for(ll i=a;i<ll(b);i++)

#define endl "\n"



struct UnionFind {

    // 自身が根: その集合の要素数に-1を掛けたもの

    // 自身が葉: 根のID

    // -> 根であれは負の数、葉であれば正の数

    vector<int> data;



    // 全てを根として初期化

    UnionFind(int size = 0) : data(size, -1) {}



    // 根の検索

    int root(int x) {

        if(data[x] < 0) return x;

        return x = root(data[x]); // 経路圧縮

    }



    // 集合の結合

    bool unite(int x, int y) {

        x = root(x); y = root(y);

        if(x == y) return false;



        // 要素数が小さい方を大きい方に結合する

        if(data[x] > data[y]) swap(x, y); // -data[x] > -data[y] となるようにしたい

        data[x] += data[y]; // 要素数の加算

        data[y] = x; // 集合の結合

        return true;

    }



    // 要素xと要素yが同じ集合に属しているか

    bool same(int x, int y) { return root(x) == root(y); }



    // 要素xが属している集合の大きさ(サイズ)

    int size(int x) { return -data[root(x)]; }

};





int n, m;

int main() {

    cin >> n >> m;



    UnionFind UF(n);



    rep(i, 0, m){

        int a, b; cin >> a >> b;

        a--;b--;

        UF.unite(a, b);

    }



    int ans = 0;

    rep(i, 0, n){

        ans = max(ans, UF.size(i));

    }



    cout << ans << endl;



    return 0;

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

 

#define ll long long

#define X first

#define Y second

#define MP make_pair

 

using namespace std;



const int N = 3e5 + 123;

const ll mod = 1e9 + 7;             



int n, h, w;

pair<int, int> a[N];

ll f[N], dp[N];

vector<int> srt;



ll bin_pow(ll x, ll y){

	ll res = 1;

	while(y){

		if(y & 1ll)

			res = res * x % mod;

		x = x * x % mod;

		y >>= 1LL;

	}

	return res;

}



ll calc(ll x, ll y){

	if(x < 0 || y < 0) return 0;

	return f[x + y - 2] * bin_pow(f[x - 1], mod - 2) % mod * bin_pow(f[y - 1], mod - 2) % mod;	

}



int main () {

	ios::sync_with_stdio(0);

	cin.tie(0);

	cout.tie(0);	



	f[0] = 1;

	for(ll i = 1;i <= 300000;i++){

		f[i] = f[i - 1] * i % mod;

	}



	cin >> h >> w >> n;

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

		int x, y;

		cin >> x >> y;

		a[i] = MP(x, y);

	}

	a[++n] = MP(h, w);



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

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

		ll all = calc(a[i].X, a[i].Y);

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

			all = (all - (dp[j] * calc(a[i].X - a[j].X + 1, a[i].Y - a[j].Y + 1) % mod) + mod) % mod;

		}

		dp[i] = all;

	}

	cout << dp[n];

	return 0;

}


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

#include<iostream>

#include<algorithm>

using namespace std;

const int MAXN = 3010;

const int MAXH = 100010, MAXW = 100010;

const int MOD = 1000000007;

int h, w, n;

struct node{

	int x, y;

}a[MAXN];

int fac[MAXH+MAXW], inv[MAXH+MAXW], f[MAXN+1];

inline int mul(int a, int b){return 1ll*a*b%MOD;}

inline int add(int a, int b){return (a+=b)>=MOD?a-MOD:a;}

inline int sub(int a, int b){return (a-=b)<0?a+MOD:a;}

inline int pw(int x, int p){int res=1;for(;p;p>>=1,x=mul(x,x))if(p&1)res=mul(res,x);return res;}

inline int C(int n, int m){return mul(fac[n], mul(inv[m], inv[n-m]));}

inline void prepare()

{

	fac[0] = 1;

	for(int i=1;i<=h+w;i++)

		fac[i] = mul(fac[i-1], i);

	inv[h+w] = pw(fac[h+w], MOD-2);

	for(int i=h+w;i>=1;i--)

		inv[i-1] = mul(inv[i], i);

}

inline bool cmp(node p, node q){return p.x!=q.x?p.x<q.x:p.y<q.y;}

int main()

{

	scanf("%d%d%d",&h,&w,&n);

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

		scanf("%d%d",&a[i].x,&a[i].y);

	a[++n].x = h; a[n].y = w;

	prepare();

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

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

	{

		f[i] = C(a[i].x+a[i].y-2, a[i].x-1);

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

			if(a[j].x<=a[i].x&&a[j].y<=a[i].y)

				f[i] = sub(f[i], mul(f[j], C(a[i].x+a[i].y-a[j].x-a[j].y, a[i].x-a[j].x)));

	}

	printf("%d\n",f[n]);

	return 0;

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

using namespace std;

int main()

{

    int i,c=0,n,j,p=0;

    string a,b;

    cin>>a>>b;

    cout<<b+a<<endl;





    }


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

//parshant

char S[110];

char T[110];



int main(){

scanf("%s%s",S,T);

printf("%s%s\n",T,S);

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

using namespace std;

int main()

{

    int i,c=0,n,j,p=0;

    string a,b;

    cin>>a>>b;

    cout<<b+a<<endl;





    }


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



int main(){

    char strs[103];

    char strt[103];

    scanf("%s %s", strs, strt);

    printf("%s%s\n", strt,strs);



    return 0;

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

using namespace std;

int main()

{

    string a, b;

    cin>>a>>b;

    cout<<b+a;

}

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



int main(){

    char strs[103];

    char strt[103];

    scanf("%s %s", strs, strt);

    printf("%s%s\n", strt,strs);



    return 0;

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

using namespace std;

 

int main() {

    string a,b;

    cin>>a>>b;

    cout<<b+a<<endl;

}

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



int main(){

    char strs[103];

    char strt[103];

    scanf("%s %s", strs, strt);

    printf("%s%s\n", strt,strs);



    return 0;

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

using namespace std;

int main()

{

    //freopen("input.txt", "r", stdin);

   // freopen("output.txt", "w", stdout);





    string a,b;



    cin >> a >> b;





    cout << b<<a;





    return 0;

}

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



int main(){

    char strs[103];

    char strt[103];

    scanf("%s %s", strs, strt);

    printf("%s%s\n", strt,strs);



    return 0;

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

using namespace std;

int main()

{

          string a,b;

          cin>>a>>b;

          cout<<b<<a<<endl;

return 0;

}


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



int main(){

    char strs[103];

    char strt[103];

    scanf("%s %s", strs, strt);

    printf("%s%s\n", strt,strs);



    return 0;

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

#include<string.h>

using namespace std;

int main()

{

    string s,t,x;

    cin>>s>>t;

    x=t+s;

    cout<<x<<endl;



    return 0;

}


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



int main(){

    char strs[103];

    char strt[103];

    scanf("%s %s", strs, strt);

    printf("%s%s\n", strt,strs);



    return 0;

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

using namespace std;

int main()

{

    int i,c=0,n,j,p=0;

    string a,b;

    cin>>a>>b;

    cout<<b+a<<endl;





    }


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



int main() {

	char S [102];

	char T [102];

	

	scanf("%s %s", S, T);

	printf("%s%s\n", T, S);

	

	return 0;

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

using namespace std;

int main()

{

    string a, b;

    cin>>a>>b;

    cout<<b+a;

}

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



int main() {

	char S [102];

	char T [102];

	

	scanf("%s %s", S, T);

	printf("%s%s\n", T, S);

	

	return 0;

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

using namespace std;

 

int main() {

    string a,b;

    cin>>a>>b;

    cout<<b+a<<endl;

}

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



int main() {

	char S [102];

	char T [102];

	

	scanf("%s %s", S, T);

	printf("%s%s\n", T, S);

	

	return 0;

}