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



int main(){

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

     return 0;

}


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



int main(){

 	char S[100], 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 t, s;

	cin>>s>>t;

	cout<<t+s<<endl;

	

	return 0;

}

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



int main(){

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

    cin>>S>>T;

    

    cout<<T+S<<endl;

	

	return 0; 

}

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



int main(){

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



}

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



int main(){

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

    cin>>S>>T;

    c=T+S;

    cout<<c<<endl;

    return 0;





}

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



int main(){

 	char S[100], T[100];

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

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

        return 0 ;

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

using namespace std;



#define ll long long

#define fast_io ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);



int main()

{

    fast_io;

    string s,t;

    cin >> s >> t;

    cout << t << s;

}


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



int main(){

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

    cin>>a;

    cin>>b;

    cout<<b<<a;

    return 0;

}


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

	cin>>s>>t;

	r = t+s;

	cout<<r;

	return 0;

}




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

int main()

{

     string s,t;

     cin>>s>>t;

     cout<<t<<s<<endl;

     return 0;

}


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



int main() {

	string t, s;

	cin>>s>>t;

	cout<<t+s<<endl;

	

	return 0;

}

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

    cin>>S>>T;

    

    cout<<T+S<<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 <iostream>

using namespace std;

int main ()

{

char S[100],T[100];

cin>>S>>T;

cout<<T<<S<<endl;



}

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

    cin>>S>>T;

    c=T+S;

    cout<<c<<endl;

    return 0;





}

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



#define ll long long

#define fast_io ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);



int main()

{

    fast_io;

    string s,t;

    cin >> s >> t;

    cout << t << s;

}


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

    cin>>a;

    cin>>b;

    cout<<b<<a;

    return 0;

}


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



int main(){

char S[100],T[100];

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

	cin>>s>>t;

	r = t+s;

	cout<<r;

	return 0;

}




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



int main(){

char S[100],T[100];

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



int main(){

char S[100],T[100];

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;

     return 0;

}


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



int main(){

char S[100],T[100];

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

	cin>>s>>t;

	cout<<t+s<<endl;

	

	return 0;

}

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



int main(){

char S[100],T[100];

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;

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

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;



}

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



int main(){

char S[100],T[100];

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

    cin>>S>>T;

    c=T+S;

    cout<<c<<endl;

    return 0;





}

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



int main(){

char S[100],T[100];

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

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

return 0;



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

using namespace std;



#define ll long long

#define fast_io ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);



int main()

{

    fast_io;

    string s,t;

    cin >> s >> t;

    cout << t << s;

}


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



int main(){

char S[100],T[100];

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;

    cin>>a;

    cin>>b;

    cout<<b<<a;

    return 0;

}


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



int main()

{

  char S[105], T[105];

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

	cin>>s>>t;

	r = t+s;

	cout<<r;

	return 0;

}




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



int main()

{

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

     return 0;

}


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



int main()

{

  char S[105], 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 t, s;

	cin>>s>>t;

	cout<<t+s<<endl;

	

	return 0;

}

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



int main()

{

  char S[105], T[105];

  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;

    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 S[105], 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 ()

{

char S[100],T[100];

cin>>S>>T;

cout<<T<<S<<endl;



}

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



int main()

{

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

    cin>>S>>T;

    c=T+S;

    cout<<c<<endl;

    return 0;





}

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



int main()

{

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



#define ll long long

#define fast_io ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);



int main()

{

    fast_io;

    string s,t;

    cin >> s >> t;

    cout << t << s;

}


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



int main()

{

  char S[105], 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 a,b;

    cin>>a;

    cin>>b;

    cout<<b<<a;

    return 0;

}


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

int main(){

	char S[105];

	char T[105];

	

	scanf("%s",S);

	scanf("%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,r;

	cin>>s>>t;

	r = t+s;

	cout<<r;

	return 0;

}




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

int main(){

	char S[105];

	char T[105];

	

	scanf("%s",S);

	scanf("%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.331049773919085x):
#include<stdio.h>

int main(){

	char S[105];

	char T[105];

	

	scanf("%s",S);

	scanf("%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;

     return 0;

}


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

int main(){

	char S[105];

	char T[105];

	

	scanf("%s",S);

	scanf("%s",T);

	

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

	

	

	

	

	

	

	

	

	return 0;

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

using namespace std;



int main() {

	string t, s;

	cin>>s>>t;

	cout<<t+s<<endl;

	

	return 0;

}

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

int main(){

	char S[105];

	char T[105];

	

	scanf("%s",S);

	scanf("%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;

    cin>>S>>T;

    

    cout<<T+S<<endl;

	

	return 0; 

}

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

int main(){

	char S[105];

	char T[105];

	

	scanf("%s",S);

	scanf("%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;



}

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

int main(){

	char S[105];

	char T[105];

	

	scanf("%s",S);

	scanf("%s",T);

	

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

	

	

	

	

	

	

	

	

	return 0;

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

using namespace std;

int main()

{

    string S,T,c;

    cin>>S>>T;

    c=T+S;

    cout<<c<<endl;

    return 0;





}

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

int main(){

	char S[105];

	char T[105];

	

	scanf("%s",S);

	scanf("%s",T);

	

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

	

	

	

	

	

	

	

	

	return 0;

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

using namespace std;



#define ll long long

#define fast_io ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);



int main()

{

    fast_io;

    string s,t;

    cin >> s >> t;

    cout << t << s;

}


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

int main(){

	char S[105];

	char T[105];

	

	scanf("%s",S);

	scanf("%s",T);

	

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

	

	

	

	

	

	

	

	

	return 0;

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



using namespace std;



int main()

{

    string a,b;

    cin>>a;

    cin>>b;

    cout<<b<<a;

    return 0;

}


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



int main(){

	

	char S[100], T[100];

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

	cin>>s>>t;

	r = t+s;

	cout<<r;

	return 0;

}




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



int main(){

	

	char S[100], T[100];

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



int main(){

	

	char S[100], T[100];

	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;

     return 0;

}


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



int main(){

	

	char S[100], T[100];

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

	cin>>s>>t;

	cout<<t+s<<endl;

	

	return 0;

}

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



int main(){

	

	char S[100], T[100];

	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;

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

	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;



}

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



int main(){

	

	char S[100], T[100];

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

    cin>>S>>T;

    c=T+S;

    cout<<c<<endl;

    return 0;





}

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



int main(){

	

	char S[100], T[100];

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

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

	

	return 0;

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

using namespace std;



#define ll long long

#define fast_io ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);



int main()

{

    fast_io;

    string s,t;

    cin >> s >> t;

    cout << t << s;

}


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



int main(){

	

	char S[100], T[100];

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

//prince

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 a, b;

    cin>> a >> b;

    cout<<b<<a;

}

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

//prince

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

//prince

char S[110];

char T[110];



int main(){

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

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

}
// 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.339152771935887x):
#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 a, b;

    cin>> a >> b;

    cout<<b<<a;

}

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

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

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 kata1[108]; //106 huruf	jadi dia [n] n-2

	char kata2[108]; // 106 huruf	ini juga

	

	scanf("%s %s", &kata1, &kata2); //bisa gapake &, sesuai aturan pointer

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

	

	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 kata1[108]; //106 huruf	jadi dia [n] n-2

	char kata2[108]; // 106 huruf	ini juga

	

	scanf("%s %s", &kata1, &kata2); //bisa gapake &, sesuai aturan pointer

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

	

	return 0;

}