stablegradients/pie-gem5-pairs huggingface dataset:
// 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.336602863175012x):
#include<stdio.h>

int main()

{

	char S[100]="";

	char T[100]="";

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

int main()

{

	char S[100]="";

	char T[100]="";

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

int main()

{

	char S[100]="";

	char T[100]="";

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

int main()

{

	char S[100]="";

	char T[100]="";

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

int main()

{

	char S[100]="";

	char T[100]="";

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

int main()

{

	char S[100]="";

	char T[100]="";

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

int main()

{

	char S[100]="";

	char T[100]="";

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

int main()

{

	char S[100]="";

	char T[100]="";

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

int main()

{

	char S[100]="";

	char T[100]="";

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

int main()

{

	char S[100]="";

	char T[100]="";

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

int main()

{

	char S[100]="";

	char T[100]="";

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

#include <string.h>



int main()

{

    char S[255], T[255];

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

    strcat(T,S);

    printf("%s",T);



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

#include <string.h>



int main()

{

    char S[255], T[255];

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

    strcat(T,S);

    printf("%s",T);



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

#include <string.h>



int main()

{

    char S[255], T[255];

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

    strcat(T,S);

    printf("%s",T);



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

#include <string.h>



int main()

{

    char S[255], T[255];

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

    strcat(T,S);

    printf("%s",T);



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

#include <string.h>



int main()

{

    char S[255], T[255];

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

    strcat(T,S);

    printf("%s",T);



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

#include <string.h>



int main()

{

    char S[255], T[255];

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

    strcat(T,S);

    printf("%s",T);



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

#include <string.h>



int main()

{

    char S[255], T[255];

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

    strcat(T,S);

    printf("%s",T);



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

#include <string.h>



int main()

{

    char S[255], T[255];

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

    strcat(T,S);

    printf("%s",T);



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

#include <string.h>



int main()

{

    char S[255], T[255];

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

    strcat(T,S);

    printf("%s",T);



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

#include <string.h>



int main()

{

    char S[255], T[255];

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

    strcat(T,S);

    printf("%s",T);



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

#include <string.h>



int main()

{

    char S[255], T[255];

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

    strcat(T,S);

    printf("%s",T);



    return 0;

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

#include <iostream>

#include<string>

using namespace std;

int main(){

	string T,S;

	cin>>S>>T;

	cout<<T<<S;

	return 0;





}

// Faster C++ solution for the same problem (measured speedup: 5.312403003971009x):
//vansh

#include <stdio.h>

char S[110];

char T[110];

 

int main(){

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

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

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

#include<string.h>

using namespace std;



void function(char *s,char *t)

{

    strcat(t,s);

    cout<<t<<endl;

}



int main()

{

    char s[500];

    char t[500];

    cin>>s;

    cin>>t;

    function(s,t);

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.284922278703029x):
//vansh

#include <stdio.h>

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(){



    string s1,s2;

    cin>>s1>>s2;

    string m="";

    m=m+s2;

    m=m+s1;

   /// m=m+'\0';

    cout<<m<<endl;









    return 0;

}




// Faster C++ solution for the same problem (measured speedup: 5.341978175328588x):
//vansh

#include <stdio.h>

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()

{

    string s,t;

    cin>>s>>t;

    cout<<t<<s<<endl;

}


// Faster C++ solution for the same problem (measured speedup: 5.331952421581484x):
//vansh

#include <stdio.h>

char S[110];

char T[110];

 

int main(){

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

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

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

#include <iostream>

#include<string>

using namespace std;

int main(){

	string T,S;

	cin>>S>>T;

	cout<<T<<S;

	return 0;





}

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

//inppuutt

char S[110];

char T[110];

 

int main(){

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

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

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

#include<string.h>

using namespace std;



void function(char *s,char *t)

{

    strcat(t,s);

    cout<<t<<endl;

}



int main()

{

    char s[500];

    char t[500];

    cin>>s;

    cin>>t;

    function(s,t);

    return 0;

}


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

//inppuutt

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(){



    string s1,s2;

    cin>>s1>>s2;

    string m="";

    m=m+s2;

    m=m+s1;

   /// m=m+'\0';

    cout<<m<<endl;









    return 0;

}




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

//inppuutt

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()

{

    string s,t;

    cin>>s>>t;

    cout<<t<<s<<endl;

}


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

//inppuutt

char S[110];

char T[110];

 

int main(){

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

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

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

#include <iostream>

#include<string>

using namespace std;

int main(){

	string T,S;

	cin>>S>>T;

	cout<<T<<S;

	return 0;





}

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



int main() {

	char x[105], y[105];

	

	scanf("%s %s", x, y);

	printf("%s%s", y,x);

	

	return 0;

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

#include<string.h>

using namespace std;



void function(char *s,char *t)

{

    strcat(t,s);

    cout<<t<<endl;

}



int main()

{

    char s[500];

    char t[500];

    cin>>s;

    cin>>t;

    function(s,t);

    return 0;

}


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



int main() {

	char x[105], y[105];

	

	scanf("%s %s", x, y);

	printf("%s%s", y,x);

	

	return 0;

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

using namespace std;



int main(){



    string s1,s2;

    cin>>s1>>s2;

    string m="";

    m=m+s2;

    m=m+s1;

   /// m=m+'\0';

    cout<<m<<endl;









    return 0;

}




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



int main() {

	char x[105], y[105];

	

	scanf("%s %s", x, y);

	printf("%s%s", y,x);

	

	return 0;

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

using namespace std;

int main()

{

    string s,t;

    cin>>s>>t;

    cout<<t<<s<<endl;

}


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



int main() {

	char x[105], y[105];

	

	scanf("%s %s", x, y);

	printf("%s%s", y,x);

	

	return 0;

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

using namespace std;

string s, t;

int main() {

    cin >> s >> t;

    cout << t << s << "\n"  ;

    return 0;

}

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



int main() {

	char x[105], y[105];

	

	scanf("%s %s", x, y);

	printf("%s%s", y,x);

	

	return 0;

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

#include<cstdio>

#include<cstring>

#include<cstdlib>

#include<algorithm>

#include<string>

#include<stack>

//#define ll long long

using namespace std;

const int maxn=100;

const int INF=1000000000;

string str1,str2;



int main()

{

    cin>>str1>>str2;

    cout<<str2<<str1;

}


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



int main() {

	char x[105], y[105];

	

	scanf("%s %s", x, y);

	printf("%s%s", y,x);

	

	return 0;

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

using namespace std;



int main()

{

    string s1,s2;

    cin>>s1>>s2;

    cout<<s2+s1<<endl;



    return 0;

}


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



int main() {

	char x[105], y[105];

	

	scanf("%s %s", x, y);

	printf("%s%s", y,x);

	

	return 0;

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

using namespace std;

int main()

{

    string s,t;

    cin>> s>> t;

    cout<< t<<s;

}


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



int main() {

	char x[105], y[105];

	

	scanf("%s %s", x, y);

	printf("%s%s", y,x);

	

	return 0;

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



using namespace std;



int main()

{

    string s,t;

    cin>>s;

    cin>>t;

    cout<<t+s;

}

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



int main() {

	char x[105], y[105];

	

	scanf("%s %s", x, y);

	printf("%s%s", y,x);

	

	return 0;

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

#include <iostream>

#include<string>

using namespace std;

int main(){

	string T,S;

	cin>>S>>T;

	cout<<T<<S;

	return 0;





}

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



int main(){

	

char string1[102];

char string2[102];



scanf("%s %s",&string1,&string2);



printf("%s%s",string2,string1);	

	

	

	return 0;

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

#include<string.h>

using namespace std;



void function(char *s,char *t)

{

    strcat(t,s);

    cout<<t<<endl;

}



int main()

{

    char s[500];

    char t[500];

    cin>>s;

    cin>>t;

    function(s,t);

    return 0;

}


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



int main(){

	

char string1[102];

char string2[102];



scanf("%s %s",&string1,&string2);



printf("%s%s",string2,string1);	

	

	

	return 0;

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

using namespace std;



int main(){



    string s1,s2;

    cin>>s1>>s2;

    string m="";

    m=m+s2;

    m=m+s1;

   /// m=m+'\0';

    cout<<m<<endl;









    return 0;

}




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



int main(){

	

char string1[102];

char string2[102];



scanf("%s %s",&string1,&string2);



printf("%s%s",string2,string1);	

	

	

	return 0;

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

using namespace std;

int main()

{

    string s,t;

    cin>>s>>t;

    cout<<t<<s<<endl;

}


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



int main(){

	

char string1[102];

char string2[102];



scanf("%s %s",&string1,&string2);



printf("%s%s",string2,string1);	

	

	

	return 0;

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

using namespace std;

string s, t;

int main() {

    cin >> s >> t;

    cout << t << s << "\n"  ;

    return 0;

}

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



int main(){

	

char string1[102];

char string2[102];



scanf("%s %s",&string1,&string2);



printf("%s%s",string2,string1);	

	

	

	return 0;

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

#include<cstdio>

#include<cstring>

#include<cstdlib>

#include<algorithm>

#include<string>

#include<stack>

//#define ll long long

using namespace std;

const int maxn=100;

const int INF=1000000000;

string str1,str2;



int main()

{

    cin>>str1>>str2;

    cout<<str2<<str1;

}


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



int main(){

	

char string1[102];

char string2[102];



scanf("%s %s",&string1,&string2);



printf("%s%s",string2,string1);	

	

	

	return 0;

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

using namespace std;



int main()

{

    string s1,s2;

    cin>>s1>>s2;

    cout<<s2+s1<<endl;



    return 0;

}


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



int main(){

	

char string1[102];

char string2[102];



scanf("%s %s",&string1,&string2);



printf("%s%s",string2,string1);	

	

	

	return 0;

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

using namespace std;

int main()

{

    string s,t;

    cin>> s>> t;

    cout<< t<<s;

}


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



int main(){

	

char string1[102];

char string2[102];



scanf("%s %s",&string1,&string2);



printf("%s%s",string2,string1);	

	

	

	return 0;

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



using namespace std;



int main()

{

    string s,t;

    cin>>s;

    cin>>t;

    cout<<t+s;

}

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



int main(){

	

char string1[102];

char string2[102];



scanf("%s %s",&string1,&string2);



printf("%s%s",string2,string1);	

	

	

	return 0;

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

#include <iostream>

#include<string>

using namespace std;

int main(){

	string T,S;

	cin>>S>>T;

	cout<<T<<S;

	return 0;





}

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



int main()

{

	char s1[110];

	char s2[110];

	

	scanf("%s %s", s1, s2);

	printf("%s%s", s2, s1);

	

	return 0;

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

#include<string.h>

using namespace std;



void function(char *s,char *t)

{

    strcat(t,s);

    cout<<t<<endl;

}



int main()

{

    char s[500];

    char t[500];

    cin>>s;

    cin>>t;

    function(s,t);

    return 0;

}


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



int main()

{

	char s1[110];

	char s2[110];

	

	scanf("%s %s", s1, s2);

	printf("%s%s", s2, s1);

	

	return 0;

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

using namespace std;



int main(){



    string s1,s2;

    cin>>s1>>s2;

    string m="";

    m=m+s2;

    m=m+s1;

   /// m=m+'\0';

    cout<<m<<endl;









    return 0;

}




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



int main()

{

	char s1[110];

	char s2[110];

	

	scanf("%s %s", s1, s2);

	printf("%s%s", s2, s1);

	

	return 0;

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

using namespace std;

int main()

{

    string s,t;

    cin>>s>>t;

    cout<<t<<s<<endl;

}


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



int main()

{

	char s1[110];

	char s2[110];

	

	scanf("%s %s", s1, s2);

	printf("%s%s", s2, s1);

	

	return 0;

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

using namespace std;

string s, t;

int main() {

    cin >> s >> t;

    cout << t << s << "\n"  ;

    return 0;

}

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



int main()

{

	char s1[110];

	char s2[110];

	

	scanf("%s %s", s1, s2);

	printf("%s%s", s2, s1);

	

	return 0;

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

#include<cstdio>

#include<cstring>

#include<cstdlib>

#include<algorithm>

#include<string>

#include<stack>

//#define ll long long

using namespace std;

const int maxn=100;

const int INF=1000000000;

string str1,str2;



int main()

{

    cin>>str1>>str2;

    cout<<str2<<str1;

}


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



int main()

{

	char s1[110];

	char s2[110];

	

	scanf("%s %s", s1, s2);

	printf("%s%s", s2, s1);

	

	return 0;

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

using namespace std;



int main()

{

    string s1,s2;

    cin>>s1>>s2;

    cout<<s2+s1<<endl;



    return 0;

}


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



int main()

{

	char s1[110];

	char s2[110];

	

	scanf("%s %s", s1, s2);

	printf("%s%s", s2, s1);

	

	return 0;

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

using namespace std;

int main()

{

    string s,t;

    cin>> s>> t;

    cout<< t<<s;

}


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



int main()

{

	char s1[110];

	char s2[110];

	

	scanf("%s %s", s1, s2);

	printf("%s%s", s2, s1);

	

	return 0;

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



using namespace std;



int main()

{

    string s,t;

    cin>>s;

    cin>>t;

    cout<<t+s;

}

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



int main()

{

	char s1[110];

	char s2[110];

	

	scanf("%s %s", s1, s2);

	printf("%s%s", s2, s1);

	

	return 0;

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

#include <iostream>

#include<string>

using namespace std;

int main(){

	string T,S;

	cin>>S>>T;

	cout<<T<<S;

	return 0;





}

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



int main() {

	char kata1[102];

	char kata2[102];

	

	scanf("%s %s", kata1, kata2);

	printf("%s%s\n", kata2, kata1);

	

	return 0;

}