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



int main() 



{

 char strng1[120];

 char strng2[120];

 

 scanf("%s %s", &strng1, &strng2);

 printf("%s%s\n", strng2, strng1);

 

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



int main() 



{

 char strng1[120];

 char strng2[120];

 

 scanf("%s %s", &strng1, &strng2);

 printf("%s%s\n", strng2, strng1);

 

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



int main() 



{

 char strng1[120];

 char strng2[120];

 

 scanf("%s %s", &strng1, &strng2);

 printf("%s%s\n", strng2, strng1);

 

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



int main() 



{

 char strng1[120];

 char strng2[120];

 

 scanf("%s %s", &strng1, &strng2);

 printf("%s%s\n", strng2, strng1);

 

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



int main() 



{

 char strng1[120];

 char strng2[120];

 

 scanf("%s %s", &strng1, &strng2);

 printf("%s%s\n", strng2, strng1);

 

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



int main() 



{

 char strng1[120];

 char strng2[120];

 

 scanf("%s %s", &strng1, &strng2);

 printf("%s%s\n", strng2, strng1);

 

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



int main() 



{

 char strng1[120];

 char strng2[120];

 

 scanf("%s %s", &strng1, &strng2);

 printf("%s%s\n", strng2, strng1);

 

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



int main() 



{

 char strng1[120];

 char strng2[120];

 

 scanf("%s %s", &strng1, &strng2);

 printf("%s%s\n", strng2, strng1);

 

 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 x[105], y[105];

	

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

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



int main() {

	char x[105], 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 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 x[105], 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 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 x[105], 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;

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 x[105], y[105];

	

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

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



int main() {

	char x[105], 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 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 x[105], 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 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 x[105], 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 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 x[105], y[105];

	

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

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



int main() {

char kata1[107];

char kata2[107];



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

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

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



int main() {

char kata1[107];

char kata2[107];



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

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

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



int main() {

char kata1[107];

char kata2[107];



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

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

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



int main() {

char kata1[107];

char kata2[107];



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

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

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



int main() {

char kata1[107];

char kata2[107];



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

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

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



int main() {

char kata1[107];

char kata2[107];



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

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

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



int main() {

char kata1[107];

char kata2[107];



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

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

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



int main() {

char kata1[107];

char kata2[107];



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

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

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



int main() {

char kata1[107];

char kata2[107];



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

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

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

	char ovo[105];

	scanf("%s %s", maltine, ovo);

	printf("%s%s\n", ovo, maltine);

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

	char ovo[105];

	scanf("%s %s", maltine, ovo);

	printf("%s%s\n", ovo, maltine);

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

	char ovo[105];

	scanf("%s %s", maltine, ovo);

	printf("%s%s\n", ovo, maltine);

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

	char ovo[105];

	scanf("%s %s", maltine, ovo);

	printf("%s%s\n", ovo, maltine);

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

	char ovo[105];

	scanf("%s %s", maltine, ovo);

	printf("%s%s\n", ovo, maltine);

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

	char ovo[105];

	scanf("%s %s", maltine, ovo);

	printf("%s%s\n", ovo, maltine);

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

	char ovo[105];

	scanf("%s %s", maltine, ovo);

	printf("%s%s\n", ovo, maltine);

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

	char ovo[105];

	scanf("%s %s", maltine, ovo);

	printf("%s%s\n", ovo, maltine);

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

	char ovo[105];

	scanf("%s %s", maltine, ovo);

	printf("%s%s\n", ovo, maltine);

	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 S[105], T[106];	

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



int main(){ 

char S[105], T[106];	

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



int main(){ 

char S[105], T[106];	

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



int main(){ 

char S[105], T[106];	

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



int main(){ 

char S[105], T[106];	

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



int main(){ 

char S[105], T[106];	

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



int main(){ 

char S[105], T[106];	

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



int main(){ 

char S[105], T[106];	

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



int main(){ 

char S[105], T[106];	

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



int main(){

	

	char kata1[102];

	char kata2[102];

	

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

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

	

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



int main(){

	

	char kata1[102];

	char kata2[102];

	

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

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

	

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



int main(){

	

	char kata1[102];

	char kata2[102];

	

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

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

	

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



int main(){

	

	char kata1[102];

	char kata2[102];

	

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

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

	

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



int main(){

	

	char kata1[102];

	char kata2[102];

	

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

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

	

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



int main(){

	

	char kata1[102];

	char kata2[102];

	

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

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

	

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



int main(){

	

	char kata1[102];

	char kata2[102];

	

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

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

	

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



int main(){

	

	char kata1[102];

	char kata2[102];

	

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

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

	

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



int main(){

	

	char kata1[102];

	char kata2[102];

	

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

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

	

	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 aa[110], bb[110];

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

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





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

    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 aa[110], bb[110];

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

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





    return 0;

}