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



int main() {

    char aa[110], bb[110];

    scanf("%s %s", aa, bb);

    printf("%s%s\n", bb, aa);





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



int main() {

    char aa[110], bb[110];

    scanf("%s %s", aa, bb);

    printf("%s%s\n", bb, aa);





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



int main() {

    char aa[110], bb[110];

    scanf("%s %s", aa, bb);

    printf("%s%s\n", bb, aa);





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



int main() {

    char aa[110], bb[110];

    scanf("%s %s", aa, bb);

    printf("%s%s\n", bb, aa);





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



int main() {

    char aa[110], bb[110];

    scanf("%s %s", aa, bb);

    printf("%s%s\n", bb, aa);





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



int main() {

    char aa[110], bb[110];

    scanf("%s %s", aa, bb);

    printf("%s%s\n", bb, aa);





    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 S[100];

	char T[100];

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

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

	

	

	

	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 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 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 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 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 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;

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 S[100];

	char T[100];

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

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

	

	

	

	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 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 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 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 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 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;

    cin>>t;

    cout<<t+s;

}

// Faster C++ solution for the same problem (measured speedup: 5.318486824600252x):
#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 <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.308534017617692x):
#include <stdio.h>



int main (){



	char s[105];

	char t[105];

	

	scanf("%s %s",s,t);

	

	printf("%s%s\n",t,s);

	

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



int main (){



	char s[105];

	char t[105];

	

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



int main (){



	char s[105];

	char t[105];

	

	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 s,t;

    cin>>s>>t;

    cout<<t<<s<<endl;

}


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



int main (){



	char s[105];

	char t[105];

	

	scanf("%s %s",s,t);

	

	printf("%s%s\n",t,s);

	

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



int main (){



	char s[105];

	char t[105];

	

	scanf("%s %s",s,t);

	

	printf("%s%s\n",t,s);

	

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



int main (){



	char s[105];

	char t[105];

	

	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 s1,s2;

    cin>>s1>>s2;

    cout<<s2+s1<<endl;



    return 0;

}


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



int main (){



	char s[105];

	char t[105];

	

	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 s,t;

    cin>> s>> t;

    cout<< t<<s;

}


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



int main (){



	char s[105];

	char t[105];

	

	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;

    cin>>t;

    cout<<t+s;

}

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



int main (){



	char s[105];

	char t[105];

	

	scanf("%s %s",s,t);

	

	printf("%s%s\n",t,s);

	

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 a[105];

	char b[105];

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

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

	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 a[105];

	char b[105];

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

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

	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 a[105];

	char b[105];

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

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

	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 a[105];

	char b[105];

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

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

	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 a[105];

	char b[105];

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

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

	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 a[105];

	char b[105];

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

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

	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 a[105];

	char b[105];

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

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

	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 a[105];

	char b[105];

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

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

	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 a[105];

	char b[105];

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

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

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



int main()

{

	char nama1[100];

	char nama2[100];

	

	scanf("%s", &nama1);

	scanf("%s", &nama2);

	

	printf("%s%s", nama2, nama1);

	

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



int main()

{

	char nama1[100];

	char nama2[100];

	

	scanf("%s", &nama1);

	scanf("%s", &nama2);

	

	printf("%s%s", nama2, nama1);

	

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



int main()

{

	char nama1[100];

	char nama2[100];

	

	scanf("%s", &nama1);

	scanf("%s", &nama2);

	

	printf("%s%s", nama2, nama1);

	

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



int main()

{

	char nama1[100];

	char nama2[100];

	

	scanf("%s", &nama1);

	scanf("%s", &nama2);

	

	printf("%s%s", nama2, nama1);

	

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



int main()

{

	char nama1[100];

	char nama2[100];

	

	scanf("%s", &nama1);

	scanf("%s", &nama2);

	

	printf("%s%s", nama2, nama1);

	

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



int main()

{

	char nama1[100];

	char nama2[100];

	

	scanf("%s", &nama1);

	scanf("%s", &nama2);

	

	printf("%s%s", nama2, nama1);

	

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



int main()

{

	char nama1[100];

	char nama2[100];

	

	scanf("%s", &nama1);

	scanf("%s", &nama2);

	

	printf("%s%s", nama2, nama1);

	

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



int main()

{

	char nama1[100];

	char nama2[100];

	

	scanf("%s", &nama1);

	scanf("%s", &nama2);

	

	printf("%s%s", nama2, nama1);

	

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



int main()

{

	char nama1[100];

	char nama2[100];

	

	scanf("%s", &nama1);

	scanf("%s", &nama2);

	

	printf("%s%s", nama2, nama1);

	

	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.317302259072865x):




#include <stdio.h>



int main()

{

	char nama1[100];

	char nama2[100];

	

	scanf("%s", &nama1);

	scanf("%s", &nama2);

	

	printf("%s%s" , nama2 , nama1);

	

	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.289796190267626x):




#include <stdio.h>



int main()

{

	char nama1[100];

	char nama2[100];

	

	scanf("%s", &nama1);

	scanf("%s", &nama2);

	

	printf("%s%s" , nama2 , nama1);

	

	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.346904705527806x):




#include <stdio.h>



int main()

{

	char nama1[100];

	char nama2[100];

	

	scanf("%s", &nama1);

	scanf("%s", &nama2);

	

	printf("%s%s" , nama2 , nama1);

	

	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.336869705734204x):




#include <stdio.h>



int main()

{

	char nama1[100];

	char nama2[100];

	

	scanf("%s", &nama1);

	scanf("%s", &nama2);

	

	printf("%s%s" , nama2 , nama1);

	

	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.285085905442858x):




#include <stdio.h>



int main()

{

	char nama1[100];

	char nama2[100];

	

	scanf("%s", &nama1);

	scanf("%s", &nama2);

	

	printf("%s%s" , nama2 , nama1);

	

	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.276930324602788x):




#include <stdio.h>



int main()

{

	char nama1[100];

	char nama2[100];

	

	scanf("%s", &nama1);

	scanf("%s", &nama2);

	

	printf("%s%s" , nama2 , nama1);

	

	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.344076696464569x):




#include <stdio.h>



int main()

{

	char nama1[100];

	char nama2[100];

	

	scanf("%s", &nama1);

	scanf("%s", &nama2);

	

	printf("%s%s" , nama2 , nama1);

	

	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.317358991239742x):




#include <stdio.h>



int main()

{

	char nama1[100];

	char nama2[100];

	

	scanf("%s", &nama1);

	scanf("%s", &nama2);

	

	printf("%s%s" , nama2 , nama1);

	

	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.320724931477368x):




#include <stdio.h>



int main()

{

	char nama1[100];

	char nama2[100];

	

	scanf("%s", &nama1);

	scanf("%s", &nama2);

	

	printf("%s%s" , nama2 , nama1);

	

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



int main()

{

	char S[100];

	char T[100];

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

	getchar();

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

	

	

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



int main()

{

	char S[100];

	char T[100];

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

	getchar();

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

	

	

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



int main()

{

	char S[100];

	char T[100];

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

	getchar();

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

	

	

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



int main()

{

	char S[100];

	char T[100];

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

	getchar();

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

	

	

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



int main()

{

	char S[100];

	char T[100];

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

	getchar();

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

	

	

	return 0;

}