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

using namespace std;

int main()

{

string a,b,c;

cin>>a>>b;

c=a;

a=b;

b=c;

cout<<a<<b;

}

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



int main()

{	char str1[102];//S

	char str2[102];//T



		scanf("%s %s", str1, str2);



	printf("%s%s", str2, str1);



	return 0;

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

using namespace std;

typedef long long int ll;

int main()

{

    string t,s,a;

   while( cin>>s>>t)

   {

    a=t+s;

    cout<<a<<endl;

   }



}


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



int main()

{	char str1[102];//S

	char str2[102];//T



		scanf("%s %s", str1, str2);



	printf("%s%s", str2, str1);



	return 0;

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

#include <string>

using namespace std;



int main()

{

	string s,t;

	int z,k=0;

	cin>>s>>t;

	cout<<t<<s<<'\n';

	

}

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



int main()

{	char str1[102];//S

	char str2[102];//T



		scanf("%s %s", str1, str2);



	printf("%s%s", str2, str1);



	return 0;

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



using namespace std ;



int main()



{

    char str1[200], str2[200] ;



    cin>>str1>>str2 ;



    cout<<str2<<str1<<endl ;



    return 0;

}

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



int main()

{	char str1[102];//S

	char str2[102];//T



		scanf("%s %s", str1, str2);



	printf("%s%s", str2, str1);



	return 0;

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

using namespace std;

int main()

{

    char S[100],T[100];

    cin>>S>>T;



    cout<<T<<S<<endl;

    return 0;

}


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



int main()

{	char str1[102];//S

	char str2[102];//T



		scanf("%s %s", str1, str2);



	printf("%s%s", str2, str1);



	return 0;

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

#include <cstdio>



using namespace std;



int main()

{

    string S,T,a;



    cin>>S;

    cin>>T;



    a=T+S;

    cout<<a;





    return 0;

}

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



int main()

{	char str1[102];//S

	char str2[102];//T



		scanf("%s %s", str1, str2);



	printf("%s%s", str2, str1);



	return 0;

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

using namespace std;

int main(){

     string s,t;

     cin>>s>>t;

     cout<<t+s<<endl;

     return 0;

}

// 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.30942252637321x):
#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 <iostream>

#include<bits/stdc++.h>

using namespace std;



int main()

{

    string s1,s2;

    cin>>s1>>s2;

    cout<<s2<<s1;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.30942252637321x):
#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,T;

	cin>>A;

	cin.ignore();

	cin>>T;

	string C=T+A;

	cout<<C;

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.315921586964185x):
#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<iostream>

using namespace std;

int main()

{

	string x;

	string y;

	cin>>x;

	cin>>y;

	string z;

	z=x;

	x=y;

	y=z;

	cout<<x<<y;

	

}

// Faster C++ solution for the same problem (measured speedup: 5.316700446742974x):
#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<iostream>

using namespace std;

int main()

{

string a,b,c;

cin>>a>>b;

c=a;

a=b;

b=c;

cout<<a<<b;

}

// Faster C++ solution for the same problem (measured speedup: 5.316091731131761x):
#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;

typedef long long int ll;

int main()

{

    string t,s,a;

   while( cin>>s>>t)

   {

    a=t+s;

    cout<<a<<endl;

   }



}


// Faster C++ solution for the same problem (measured speedup: 5.339095942927451x):
#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 <iostream>

#include <string>

using namespace std;



int main()

{

	string s,t;

	int z,k=0;

	cin>>s>>t;

	cout<<t<<s<<'\n';

	

}

// Faster C++ solution for the same problem (measured speedup: 5.268884763617167x):
#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<iostream>



using namespace std ;



int main()



{

    char str1[200], str2[200] ;



    cin>>str1>>str2 ;



    cout<<str2<<str1<<endl ;



    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.288317374165782x):
#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<iostream>

using namespace std;

int main()

{

    char S[100],T[100];

    cin>>S>>T;



    cout<<T<<S<<endl;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.288623561633479x):
#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 <iostream>

#include <cstdio>



using namespace std;



int main()

{

    string S,T,a;



    cin>>S;

    cin>>T;



    a=T+S;

    cout<<a;





    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.316422914376828x):
#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<iostream>

using namespace std;

int main(){

     string s,t;

     cin>>s>>t;

     cout<<t+s<<endl;

     return 0;

}

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





int main() {

	

	char S[102];

	char T[102];

	

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

	printf("%s%s", 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.3157669023967085x):
#include <stdio.h>





int main() {

	

	char S[102];

	char T[102];

	

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

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

	

	return 0;

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

#include<bits/stdc++.h>

using namespace std;



int main()

{

    string s1,s2;

    cin>>s1>>s2;

    cout<<s2<<s1;

    return 0;

}


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





int main() {

	

	char S[102];

	char T[102];

	

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

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

	

	return 0;

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

using namespace std;

int main()

{

	string A,T;

	cin>>A;

	cin.ignore();

	cin>>T;

	string C=T+A;

	cout<<C;

	return 0;

}

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





int main() {

	

	char S[102];

	char T[102];

	

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

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

	

	return 0;

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

using namespace std;

int main()

{

	string x;

	string y;

	cin>>x;

	cin>>y;

	string z;

	z=x;

	x=y;

	y=z;

	cout<<x<<y;

	

}

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





int main() {

	

	char S[102];

	char T[102];

	

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

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

	

	return 0;

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

using namespace std;

int main()

{

string a,b,c;

cin>>a>>b;

c=a;

a=b;

b=c;

cout<<a<<b;

}

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





int main() {

	

	char S[102];

	char T[102];

	

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

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

	

	return 0;

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

using namespace std;

typedef long long int ll;

int main()

{

    string t,s,a;

   while( cin>>s>>t)

   {

    a=t+s;

    cout<<a<<endl;

   }



}


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





int main() {

	

	char S[102];

	char T[102];

	

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

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

	

	return 0;

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

#include <string>

using namespace std;



int main()

{

	string s,t;

	int z,k=0;

	cin>>s>>t;

	cout<<t<<s<<'\n';

	

}

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





int main() {

	

	char S[102];

	char T[102];

	

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

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

	

	return 0;

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



using namespace std ;



int main()



{

    char str1[200], str2[200] ;



    cin>>str1>>str2 ;



    cout<<str2<<str1<<endl ;



    return 0;

}

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





int main() {

	

	char S[102];

	char T[102];

	

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

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

	

	return 0;

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

using namespace std;

int main()

{

    char S[100],T[100];

    cin>>S>>T;



    cout<<T<<S<<endl;

    return 0;

}


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





int main() {

	

	char S[102];

	char T[102];

	

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

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

	

	return 0;

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

#include <cstdio>



using namespace std;



int main()

{

    string S,T,a;



    cin>>S;

    cin>>T;



    a=T+S;

    cout<<a;





    return 0;

}

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





int main() {

	

	char S[102];

	char T[102];

	

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

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

	

	return 0;

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

using namespace std;

int main(){

     string s,t;

     cin>>s>>t;

     cout<<t+s<<endl;

     return 0;

}

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



int main(){

	char S[105];

	char T[105];

	

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

	printf("%s%s", 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.313704158588394x):
#include <stdio.h>



int main(){

	char S[105];

	char T[105];

	

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

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

	

	

	

	return 0;

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

#include<bits/stdc++.h>

using namespace std;



int main()

{

    string s1,s2;

    cin>>s1>>s2;

    cout<<s2<<s1;

    return 0;

}


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



int main(){

	char S[105];

	char T[105];

	

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

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

	

	

	

	return 0;

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

using namespace std;

int main()

{

	string A,T;

	cin>>A;

	cin.ignore();

	cin>>T;

	string C=T+A;

	cout<<C;

	return 0;

}

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



int main(){

	char S[105];

	char T[105];

	

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

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

	

	

	

	return 0;

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

using namespace std;

int main()

{

	string x;

	string y;

	cin>>x;

	cin>>y;

	string z;

	z=x;

	x=y;

	y=z;

	cout<<x<<y;

	

}

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



int main(){

	char S[105];

	char T[105];

	

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

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

	

	

	

	return 0;

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

using namespace std;

int main()

{

string a,b,c;

cin>>a>>b;

c=a;

a=b;

b=c;

cout<<a<<b;

}

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



int main(){

	char S[105];

	char T[105];

	

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

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

	

	

	

	return 0;

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

using namespace std;

typedef long long int ll;

int main()

{

    string t,s,a;

   while( cin>>s>>t)

   {

    a=t+s;

    cout<<a<<endl;

   }



}


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



int main(){

	char S[105];

	char T[105];

	

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

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

	

	

	

	return 0;

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

#include <string>

using namespace std;



int main()

{

	string s,t;

	int z,k=0;

	cin>>s>>t;

	cout<<t<<s<<'\n';

	

}

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



int main(){

	char S[105];

	char T[105];

	

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

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

	

	

	

	return 0;

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



using namespace std ;



int main()



{

    char str1[200], str2[200] ;



    cin>>str1>>str2 ;



    cout<<str2<<str1<<endl ;



    return 0;

}

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



int main(){

	char S[105];

	char T[105];

	

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

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

	

	

	

	return 0;

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

using namespace std;

int main()

{

    char S[100],T[100];

    cin>>S>>T;



    cout<<T<<S<<endl;

    return 0;

}


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



int main(){

	char S[105];

	char T[105];

	

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

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

	

	

	

	return 0;

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

#include <cstdio>



using namespace std;



int main()

{

    string S,T,a;



    cin>>S;

    cin>>T;



    a=T+S;

    cout<<a;





    return 0;

}

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



int main(){

	char S[105];

	char T[105];

	

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

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

	

	

	

	return 0;

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

using namespace std;

int main(){

     string s,t;

     cin>>s>>t;

     cout<<t+s<<endl;

     return 0;

}

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

int main(){

	char a[100];

	char b[100];

	

	scanf("%s",&a);

	scanf("%s",&b);

	printf("%s%s", b,a);

	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.317233709493942x):
#include<stdio.h>

int main(){

	char a[100];

	char b[100];

	

	scanf("%s",&a);

	scanf("%s",&b);

	printf("%s%s", b,a);

	return 0;

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

#include<bits/stdc++.h>

using namespace std;



int main()

{

    string s1,s2;

    cin>>s1>>s2;

    cout<<s2<<s1;

    return 0;

}


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

int main(){

	char a[100];

	char b[100];

	

	scanf("%s",&a);

	scanf("%s",&b);

	printf("%s%s", b,a);

	return 0;

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

using namespace std;

int main()

{

	string A,T;

	cin>>A;

	cin.ignore();

	cin>>T;

	string C=T+A;

	cout<<C;

	return 0;

}

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

int main(){

	char a[100];

	char b[100];

	

	scanf("%s",&a);

	scanf("%s",&b);

	printf("%s%s", b,a);

	return 0;

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

using namespace std;

int main()

{

	string x;

	string y;

	cin>>x;

	cin>>y;

	string z;

	z=x;

	x=y;

	y=z;

	cout<<x<<y;

	

}

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

int main(){

	char a[100];

	char b[100];

	

	scanf("%s",&a);

	scanf("%s",&b);

	printf("%s%s", b,a);

	return 0;

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

using namespace std;

int main()

{

string a,b,c;

cin>>a>>b;

c=a;

a=b;

b=c;

cout<<a<<b;

}

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

int main(){

	char a[100];

	char b[100];

	

	scanf("%s",&a);

	scanf("%s",&b);

	printf("%s%s", b,a);

	return 0;

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

using namespace std;

typedef long long int ll;

int main()

{

    string t,s,a;

   while( cin>>s>>t)

   {

    a=t+s;

    cout<<a<<endl;

   }



}


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

int main(){

	char a[100];

	char b[100];

	

	scanf("%s",&a);

	scanf("%s",&b);

	printf("%s%s", b,a);

	return 0;

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

#include <string>

using namespace std;



int main()

{

	string s,t;

	int z,k=0;

	cin>>s>>t;

	cout<<t<<s<<'\n';

	

}

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

int main(){

	char a[100];

	char b[100];

	

	scanf("%s",&a);

	scanf("%s",&b);

	printf("%s%s", b,a);

	return 0;

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



using namespace std ;



int main()



{

    char str1[200], str2[200] ;



    cin>>str1>>str2 ;



    cout<<str2<<str1<<endl ;



    return 0;

}

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

int main(){

	char a[100];

	char b[100];

	

	scanf("%s",&a);

	scanf("%s",&b);

	printf("%s%s", b,a);

	return 0;

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

using namespace std;

int main()

{

    char S[100],T[100];

    cin>>S>>T;



    cout<<T<<S<<endl;

    return 0;

}


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

int main(){

	char a[100];

	char b[100];

	

	scanf("%s",&a);

	scanf("%s",&b);

	printf("%s%s", b,a);

	return 0;

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

#include <cstdio>



using namespace std;



int main()

{

    string S,T,a;



    cin>>S;

    cin>>T;



    a=T+S;

    cout<<a;





    return 0;

}

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

int main(){

	char a[100];

	char b[100];

	

	scanf("%s",&a);

	scanf("%s",&b);

	printf("%s%s", b,a);

	return 0;

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

using namespace std;

int main(){

     string s,t;

     cin>>s>>t;

     cout<<t+s<<endl;

     return 0;

}

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



int main()

{

	char X[105];

	char Y[105];

	

	scanf("%s %s",&X,&Y);

	printf("%s%s\n",Y,X);

	

	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.308590656233119x):
#include<stdio.h>



int main()

{

	char X[105];

	char Y[105];

	

	scanf("%s %s",&X,&Y);

	printf("%s%s\n",Y,X);

	

	return 0;	

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

#include<bits/stdc++.h>

using namespace std;



int main()

{

    string s1,s2;

    cin>>s1>>s2;

    cout<<s2<<s1;

    return 0;

}


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



int main()

{

	char X[105];

	char Y[105];

	

	scanf("%s %s",&X,&Y);

	printf("%s%s\n",Y,X);

	

	return 0;	

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

using namespace std;

int main()

{

	string A,T;

	cin>>A;

	cin.ignore();

	cin>>T;

	string C=T+A;

	cout<<C;

	return 0;

}

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



int main()

{

	char X[105];

	char Y[105];

	

	scanf("%s %s",&X,&Y);

	printf("%s%s\n",Y,X);

	

	return 0;	

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

using namespace std;

int main()

{

	string x;

	string y;

	cin>>x;

	cin>>y;

	string z;

	z=x;

	x=y;

	y=z;

	cout<<x<<y;

	

}

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



int main()

{

	char X[105];

	char Y[105];

	

	scanf("%s %s",&X,&Y);

	printf("%s%s\n",Y,X);

	

	return 0;	

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

using namespace std;

int main()

{

string a,b,c;

cin>>a>>b;

c=a;

a=b;

b=c;

cout<<a<<b;

}

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



int main()

{

	char X[105];

	char Y[105];

	

	scanf("%s %s",&X,&Y);

	printf("%s%s\n",Y,X);

	

	return 0;	

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

using namespace std;

typedef long long int ll;

int main()

{

    string t,s,a;

   while( cin>>s>>t)

   {

    a=t+s;

    cout<<a<<endl;

   }



}


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



int main()

{

	char X[105];

	char Y[105];

	

	scanf("%s %s",&X,&Y);

	printf("%s%s\n",Y,X);

	

	return 0;	

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

#include <string>

using namespace std;



int main()

{

	string s,t;

	int z,k=0;

	cin>>s>>t;

	cout<<t<<s<<'\n';

	

}

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



int main()

{

	char X[105];

	char Y[105];

	

	scanf("%s %s",&X,&Y);

	printf("%s%s\n",Y,X);

	

	return 0;	

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



using namespace std ;



int main()



{

    char str1[200], str2[200] ;



    cin>>str1>>str2 ;



    cout<<str2<<str1<<endl ;



    return 0;

}

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



int main()

{

	char X[105];

	char Y[105];

	

	scanf("%s %s",&X,&Y);

	printf("%s%s\n",Y,X);

	

	return 0;	

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

using namespace std;

int main()

{

    char S[100],T[100];

    cin>>S>>T;



    cout<<T<<S<<endl;

    return 0;

}


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



int main()

{

	char X[105];

	char Y[105];

	

	scanf("%s %s",&X,&Y);

	printf("%s%s\n",Y,X);

	

	return 0;	

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

#include <cstdio>



using namespace std;



int main()

{

    string S,T,a;



    cin>>S;

    cin>>T;



    a=T+S;

    cout<<a;





    return 0;

}

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



int main()

{

	char X[105];

	char Y[105];

	

	scanf("%s %s",&X,&Y);

	printf("%s%s\n",Y,X);

	

	return 0;	

}