stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#include <iostream>



using namespace std;



int main(void){



  long long n;



  while( cin >> n , n ){



    if( n == 1 ){

      cout << "deficient number" << endl;

      continue;

    }



    long long total = 1;

    long long a = 0;



    for( int i = 2 ; a != i && i < n/2 ; i++ ){

      if( n % i == 0 ){

	total += i;

	total += ( n / i );

	a = n / i;

	if( a == i ){

	  total -= i;

	  break;

	}

      }

      if( total > n ) break;

    }

    //cout << "a = " << a << endl;

    //cout << total << "    ";

    if( n == total ) cout << "perfect number" << endl;

    if( n < total ) cout << "abundant number" << endl;

    if( n > total ) cout << "deficient number" << endl;



  }

  return 0;

}

// Optimized solution to the same problem (faster):
#include <iostream>



using namespace std;



int main(void){



  long long n;



  while( cin >> n , n ){



    long long total = -n;

    for( int i = 1 ; i*i < n ; i++ ){

      if( !(n % i) ){

	total += i + ( n / i );

      }

    }

    if( n == total ) cout << "perfect number" << endl;

    if( n < total ) cout << "abundant number" << endl;

    if( n > total ) cout << "deficient number" << endl;



  }

  return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <vector>

#include <algorithm>

#include <string>

#include <map>

#include <set>

#include <queue>

#include <cstring>

#include <deque>

#include <cstdio>

#include <cmath>



using namespace std;



#define reep(i,f,t) for(int i=f ; i<int(t) ; ++i)

#define rep(i,n) reep(i, 0, n) 



typedef vector<int> vi;

typedef vector<vi> vvi;

typedef pair<int,int> pii;



int main()

{

	int n;

	while(scanf("%d", &n), n){

		vi nums(n, 0);

		reep(i, 1, n)

			nums[(i*i)%n] |= 1;

		reep(i, 1, (n+1)/2){

			int sum = 0;

			rep(j, n)

				sum += nums[j] & nums[(j+i)%n];

			printf("%d\n", sum * 2);

		}

	}

	

	return 0;

}

// Optimized solution to the same problem (faster):
#include <vector>

#include <algorithm>

#include <string>

#include <map>

#include <set>

#include <queue>

#include <cstring>

#include <deque>

#include <cstdio>

#include <cmath>



using namespace std;



#define reep(i,f,t) for(int i=f ; i<int(t) ; ++i)

#define rep(i,n) reep(i, 0, n) 



typedef vector<int> vi;

typedef vector<vi> vvi;

typedef pair<int,int> pii;



int main()

{

	int nums[16384], ans[8192];

	int i, j, n, size, half;

	

	while(scanf("%d", &n), n){

		size = 0;

		half = (n-1) / 2;

		for(i=1; i<n; ++i)

			nums[size++] = (i*i) % n;



		sort(nums, nums + size);

		size = unique(nums, nums + size) - nums;



		memset(ans, 0, (half+1)*4);

		for(i=0; i<size; ++i){

			for(j=0; j<i; ++j){

				int p = abs(nums[i]-nums[j]);

				if(p>half) p = n - p;

				++ans[p];

			}

		}

		for(i=1; i<=half; ++i)

			printf("%d\n", ans[i]*2);

	}



	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <vector>

#include <algorithm>

#include <string>

#include <map>

#include <set>

#include <queue>

#include <cstring>

#include <deque>

#include <cstdio>

#include <cmath>



using namespace std;



#define reep(i,f,t) for(int i=f ; i<int(t) ; ++i)

#define rep(i,n) reep(i, 0, n) 



typedef vector<int> vi;

typedef vector<vi> vvi;

typedef pair<int,int> pii;



int main()

{

	int n;

	while(scanf("%d", &n), n){

		vi nums;

		reep(i, 1, n)

			nums.push_back((i*i)%n);

		

		sort(nums.begin(), nums.end());

		nums.erase(unique(nums.begin(), nums.end()), nums.end());

		

		vi ans((n+1)/2, 0);

		rep(i, nums.size()){

			rep(j, i+1){

				int p = abs(nums[i]-nums[j]);

				if(p>(n-1)/2) p = n - p;

				++ans[p];

			}

		}

		reep(i, 1, (n+1)/2)

			printf("%d\n", ans[i]*2);

	}

	

	return 0;

}

// Optimized solution to the same problem (faster):
#include <vector>

#include <algorithm>

#include <string>

#include <map>

#include <set>

#include <queue>

#include <cstring>

#include <deque>

#include <cstdio>

#include <cmath>



using namespace std;



#define reep(i,f,t) for(int i=f ; i<int(t) ; ++i)

#define rep(i,n) reep(i, 0, n) 



typedef vector<int> vi;

typedef vector<vi> vvi;

typedef pair<int,int> pii;



int main()

{

	int nums[16384], ans[8192];

	int i, j, n, size, half;

	

	while(scanf("%d", &n), n){

		size = 0;

		half = (n-1) / 2;

		for(i=1; i<n; ++i)

			nums[size++] = (i*i) % n;



		sort(nums, nums + size);

		size = unique(nums, nums + size) - nums;



		memset(ans, 0, (half+1)*4);

		for(i=0; i<size; ++i){

			for(j=0; j<i; ++j){

				int p = abs(nums[i]-nums[j]);

				if(p>half) p = n - p;

				++ans[p];

			}

		}

		for(i=1; i<=half; ++i)

			printf("%d\n", ans[i]*2);

	}



	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <vector>

#include <algorithm>

#include <string>

#include <map>

#include <set>

#include <queue>

#include <cstring>

#include <deque>

#include <cstdio>

#include <cmath>



using namespace std;



#define reep(i,f,t) for(int i=f ; i<int(t) ; ++i)

#define rep(i,n) reep(i, 0, n) 



typedef vector<int> vi;

typedef vector<vi> vvi;

typedef pair<int,int> pii;



int main()

{

	int n;

	while(scanf("%d", &n), n){

		vi nums;

		nums.reserve(10000);

		reep(i, 1, n)

			nums.push_back((i*i)%n);

		int half = (n-1) / 2;



		sort(nums.begin(), nums.end());

		int size = distance(nums.begin(), unique(nums.begin(), nums.end()));



		vi ans(half+1, 0);

		rep(i, size){

			rep(j, i+1){

				int p = abs(nums[i]-nums[j]);

				if(p>half) p = n - p;

				++ans[p];

			}

		}

		reep(i, 1, half+1)

			printf("%d\n", ans[i]*2);

	}



	return 0;

}

// Optimized solution to the same problem (faster):
#include <vector>

#include <algorithm>

#include <string>

#include <map>

#include <set>

#include <queue>

#include <cstring>

#include <deque>

#include <cstdio>

#include <cmath>



using namespace std;



#define reep(i,f,t) for(int i=f ; i<int(t) ; ++i)

#define rep(i,n) reep(i, 0, n) 



typedef vector<int> vi;

typedef vector<vi> vvi;

typedef pair<int,int> pii;



int main()

{

	int nums[16384], ans[8192];

	int i, j, n, size, half;

	

	while(scanf("%d", &n), n){

		size = 0;

		half = (n-1) / 2;

		for(i=1; i<n; ++i)

			nums[size++] = (i*i) % n;



		sort(nums, nums + size);

		size = unique(nums, nums + size) - nums;



		memset(ans, 0, (half+1)*4);

		for(i=0; i<size; ++i){

			for(j=0; j<i; ++j){

				int p = abs(nums[i]-nums[j]);

				if(p>half) p = n - p;

				++ans[p];

			}

		}

		for(i=1; i<=half; ++i)

			printf("%d\n", ans[i]*2);

	}



	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <vector>

#include <algorithm>

#include <string>

#include <map>

#include <set>

#include <queue>

#include <cstring>

#include <deque>

#include <cstdio>

#include <cmath>



using namespace std;



#define reep(i,f,t) for(int i=f ; i<int(t) ; ++i)

#define rep(i,n) reep(i, 0, n) 



typedef vector<int> vi;

typedef vector<vi> vvi;

typedef pair<int,int> pii;



int main()

{

	int nums[10000];

	int n, size, half;

	while(scanf("%d", &n), n){

		size = 0;

		half = (n-1) / 2;

		reep(i, 1, n)

			nums[size++] = (i*i) % n;



		sort(nums, nums + size);

		size = distance(nums, unique(nums, nums + size));



		vi ans(half+1, 0);

		rep(i, size){

			rep(j, i+1){

				int p = abs(nums[i]-nums[j]);

				if(p>half) p = n - p;

				++ans[p];

			}

		}

		reep(i, 1, half+1)

			printf("%d\n", ans[i]*2);

	}



	return 0;

}

// Optimized solution to the same problem (faster):
#include <vector>

#include <algorithm>

#include <string>

#include <map>

#include <set>

#include <queue>

#include <cstring>

#include <deque>

#include <cstdio>

#include <cmath>



using namespace std;



#define reep(i,f,t) for(int i=f ; i<int(t) ; ++i)

#define rep(i,n) reep(i, 0, n) 



typedef vector<int> vi;

typedef vector<vi> vvi;

typedef pair<int,int> pii;



int main()

{

	int nums[16384], ans[8192];

	int i, j, n, size, half;

	

	while(scanf("%d", &n), n){

		size = 0;

		half = (n-1) / 2;

		for(i=1; i<n; ++i)

			nums[size++] = (i*i) % n;



		sort(nums, nums + size);

		size = unique(nums, nums + size) - nums;



		memset(ans, 0, (half+1)*4);

		for(i=0; i<size; ++i){

			for(j=0; j<i; ++j){

				int p = abs(nums[i]-nums[j]);

				if(p>half) p = n - p;

				++ans[p];

			}

		}

		for(i=1; i<=half; ++i)

			printf("%d\n", ans[i]*2);

	}



	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <vector>

#include <algorithm>

#include <string>

#include <map>

#include <set>

#include <queue>

#include <cstring>

#include <deque>

#include <cstdio>

#include <cmath>



using namespace std;



#define reep(i,f,t) for(int i=f ; i<int(t) ; ++i)

#define rep(i,n) reep(i, 0, n) 



typedef vector<int> vi;

typedef vector<vi> vvi;

typedef pair<int,int> pii;



int main()

{

	int nums[10000];

	int i, j, n, size, half;

	while(scanf("%d", &n), n){

		size = 0;

		half = (n-1) / 2;

		for(i=1; i<n; ++i)

			nums[size++] = (i*i) % n;



		sort(nums, nums + size);

		size = distance(nums, unique(nums, nums + size));



		vi ans(half+1, 0);

		for(i=0; i<size; ++i){

			for(j=0; j<i; ++j){

				int p = abs(nums[i]-nums[j]);

				if(p>half) p = n - p;

				++ans[p];

			}

		}

		for(i=1; i<=half; ++i)

			printf("%d\n", ans[i]*2);

	}



	return 0;

}

// Optimized solution to the same problem (faster):
#include <vector>

#include <algorithm>

#include <string>

#include <map>

#include <set>

#include <queue>

#include <cstring>

#include <deque>

#include <cstdio>

#include <cmath>



using namespace std;



#define reep(i,f,t) for(int i=f ; i<int(t) ; ++i)

#define rep(i,n) reep(i, 0, n) 



typedef vector<int> vi;

typedef vector<vi> vvi;

typedef pair<int,int> pii;



int main()

{

	int nums[16384], ans[8192];

	int i, j, n, size, half;

	

	while(scanf("%d", &n), n){

		size = 0;

		half = (n-1) / 2;

		for(i=1; i<n; ++i)

			nums[size++] = (i*i) % n;



		sort(nums, nums + size);

		size = unique(nums, nums + size) - nums;



		memset(ans, 0, (half+1)*4);

		for(i=0; i<size; ++i){

			for(j=0; j<i; ++j){

				int p = abs(nums[i]-nums[j]);

				if(p>half) p = n - p;

				++ans[p];

			}

		}

		for(i=1; i<=half; ++i)

			printf("%d\n", ans[i]*2);

	}



	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

#define P pair<int,int>

#define FOR(I,A,B) for(int I = (A); I < (B); ++I)

#define FORR(I,A,B) for(int I = ((B)-1); I >= (A); --I)

#define TO(x,t,f) ((x)?(t):(f))

#define SORT(x) (sort(x.begin(),x.end())) // 0 2 2 3 4 5 8 9

#define REV(x) (reverse(x.begin(),x.end())) //reverse

int gcd(int a,int b){if(a<b)swap(a,b);if(a%b==0)return b;return gcd(b,a%b);}

int lcm(int a,int b){int c=gcd(a,b);return ((a/c)*(b/c)*c);}//saisyo kobaisu

#define NEXTP(x) next_permutation(x.begin(),x.end())

const ll INF=1e18+7;

const ll MOD=1e9+7;

#define pri(a) cout << (a) << endl



int kosu[101];

void addkosu(int k){

	int a = k;

	FOR(i,2,k+1){

		while(a%i==0){

			a/=i;

			kosu[i]++;

		}

	}

}





int main(){

	ios::sync_with_stdio(false);

	cin.tie(0);

	int n;

	cin >> n;

	FOR(i,2,n+1)addkosu(i);

	int ans = 0;

	FOR(i,2,101){

		FOR(j,2,101){

			FOR(k,j+1,101){

				if(i==k||j==k||i==j)continue;

				if(kosu[i]>=2&&kosu[j]>=4&&kosu[k]>=4)ans++;

			}

		}

	}

	FOR(i,2,101){

		if(kosu[i]>=74)ans++;

		FOR(j,2,101){

			if(i==j)continue;

			if(kosu[i]>=14&&kosu[j]>=4)ans++;

			if(kosu[i]>=2&&kosu[j]>=24)ans++;

		}

	}

	cout << ans << endl;

}

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

using namespace std;

int main(){

int ans[101]={};

ans[10]=1;

ans[11]=1;

ans[12]=1;

ans[13]=1;

ans[14]=2;

ans[15]=2;

ans[16]=3;

ans[17]=3;

ans[18]=3;

ans[19]=3;

ans[20]=8;

ans[21]=8;

ans[22]=11;

ans[23]=11;

ans[24]=11;

ans[25]=11;

ans[26]=14;

ans[27]=14;

ans[28]=32;

ans[29]=32;

ans[30]=35;

ans[31]=35;

ans[32]=35;

ans[33]=35;

ans[34]=42;

ans[35]=42;

ans[36]=42;

ans[37]=42;

ans[38]=49;

ans[39]=49;

ans[40]=49;

ans[41]=49;

ans[42]=49;

ans[43]=49;

ans[44]=75;

ans[45]=75;

ans[46]=86;

ans[47]=86;

ans[48]=86;

ans[49]=86;

ans[50]=86;

ans[51]=86;

ans[52]=123;

ans[53]=123;

ans[54]=131;

ans[55]=131;

ans[56]=131;

ans[57]=131;

ans[58]=148;

ans[59]=148;

ans[60]=153;

ans[61]=153;

ans[62]=170;

ans[63]=170;

ans[64]=170;

ans[65]=170;

ans[66]=170;

ans[67]=170;

ans[68]=227;

ans[69]=227;

ans[70]=227;

ans[71]=227;

ans[72]=227;

ans[73]=227;

ans[74]=250;

ans[75]=250;

ans[76]=323;

ans[77]=323;

ans[78]=324;

ans[79]=324;

ans[80]=324;

ans[81]=324;

ans[82]=354;

ans[83]=354;

ans[84]=354;

ans[85]=354;

ans[86]=384;

ans[87]=384;

ans[88]=384;

ans[89]=384;

ans[90]=384;

ans[91]=391;

ans[92]=491;

ans[93]=491;

ans[94]=529;

ans[95]=529;

ans[96]=529;

ans[97]=529;

ans[98]=529;

ans[99]=529;

ans[100]=543;

int n;

cin >> n;

cout << ans[n] << endl;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<string>

#include<vector>

#include<list>

#include<cmath>

#include<algorithm>

#include<cstdio>

#include<set>

#include<map>

#include<queue>

#include<cstring>

#include<sstream>

using namespace std;



typedef long long ll;



int main() {

  ll N;cin >> N;



  vector<int>pm(101);

  for ( int i = 2; i <= N; i++ ) {

    int x = i;

    for ( int j = 2; x > 1; j++ ) {

      while(x%j==0) {

	pm[j]++;

	x /= j;

      }

    }

  }



  // for ( int i = 0; i <= 100; i++ ) {

  //    if ( pm[i] ) cout << i << " " << pm[i] << endl;

  //  }



  int ans = 0;



  for ( int i = 0; i <= 100; i++ ) if ( pm[i]>=74 ) ans++;



  for ( int i = 0; i <= 100; i++ ) {

    for ( int j = 0; j <= 100; j++ ) {

      if ( i == j ) continue;

      if ( pm[i]>=14 && pm[j]>=4 ) ans++;

      if ( pm[i]>=24 && pm[j]>=2 ) ans++;

    }

  }



  for ( int i = 0; i <= 100; i++ ) {

    for ( int j = 0; j <= 100; j++ ) {

      for ( int k = j+1; k <= 100; k++ ) {

	if ( i == j || i == k ) continue;

	if ( pm[i]>=2 && pm[j]>= 4 && pm[k]>=4 ) ans++;

      }    

    }

  }

  cout << ans << endl;

  return 0;

}


// Optimized solution to the same problem (faster):
#include<iostream>

#include<string>

#include<vector>

#include<list>

#include<cmath>

#include<algorithm>

#include<cstdio>

#include<set>

#include<map>

#include<queue>

#include<cstring>

#include<sstream>

using namespace std;



typedef long long ll;



int main() {

  int N; cin >> N;

  

  int pm[101];

  memset(pm,0,sizeof(pm));

  for ( int i = 2; i <= N; i++ ) {

    int x = i;

    for ( int j = 2; x > 1; j++ ) {

      while(x%j==0) {

	pm[j]++;

	x /= j;

      }

    }

  }



  int dp[101];

  memset(dp,0,sizeof(dp));

  dp[1] = 1;

  for ( int i = 0; i <= 100; i++ ) {

    if ( pm[i] ) {

      for (int j = 75; j >= 1; j-- ) {

	for ( int k = 1; k<=pm[i]; k++ ) {

	  if ( j*(k+1) <= 75 )  dp[j*(k+1)] += dp[j];

	}

      }

    }

  }



  cout << dp[75] << endl;

  return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;



vector<bool> primes(101);

vector<int> p;



void find_p() {

	fill(primes.begin(), primes.end(), true);

	primes[0] = primes[1] = false;

	for(int i = 2; i < 101; i++) {

		for(int j = 2 * i; j < 101; j += i) {

			primes[j] = false;

		}

	}

	for(int i = 0; i < 101; i++) {

		if(primes[i]) {

			p.push_back(i);

		}

	}

}

int main(){

	ios::sync_with_stdio(false);

	cin.tie(0);  

	

	int n; cin >> n;

	map<int, int> fac;

	for(int i = 1; i <= n; i++) {

		int t = i;

		for(int j = 2; j <= t; j++) {

			while(t % j == 0) {

				fac[j]++;

				t /= j;

			}

		}

	}

	find_p();

	long long ans = 0;

	for(int i = 0; i < p.size(); i++) {

		if(fac[p[i]] >= 74) {

			ans++;

		}

		for(int j = 0; j < p.size(); j++) {

			if(i == j) {

				continue;

			}

			if(fac[p[i]] >= 24 && fac[p[j]] >= 2) {

				ans++;

			}

			if(fac[p[i]] >= 14 && fac[p[j]] >= 4) {

				ans++;

			}

		}

	}

	for(int i = 0; i < p.size(); i++) {

		for(int j = 0; j < p.size(); j++) {

			for(int k = j + 1; k < p.size(); k++) {

				if(i == j || i == k) {

					continue;

				}

				if(fac[p[i]] >= 2 && fac[p[j]] >= 4 && fac[p[k]] >= 4) {

					ans++;

				}

			}

		}

	}

	cout << ans << endl;

	return 0;	

}


// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

using namespace std;



int main() {

	ios::sync_with_stdio(false);

	cin.tie(0);  

	

	int n;

	cin >> n;

	map<int, int> mp;

	for(int i = 1; i <= n; i++) {

		int x = i;

		for(int j = 2; j <= x; j++) {

			while(x % j == 0) {

				mp[j]++;

				x /= j;

			}

		}

	}

	vector<long long> dp(81);

	dp[1] = 1;

	for(auto i : mp) {

		for(int j = 80; j >= 0; j--) {

			for(int k = i.second; k > 0; k--) {

				dp[min(80, j * (k + 1))] += dp[j];

			}

		}

	}

	cout << dp[75] << endl;

	return 0;	

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

const int pi=3.1415926535897932384626433832795;

const int dx[]={0,1,0,-1};

const int dy[]={1,0,-1,0};

#define ll long long

#define inf int(1e9+7)

#define pb push_back

#define mp make_pair

int s[100005],a[100005],n;

char p[100005];

int main()

{

	cin>>n;

	cin>>p;

	for(int i=0;i<n;i++)

	{

		if(p[i]=='o')

			a[i+1]=0;

		else

			a[i+1]=1;

	}

	a[n+1]=a[1];

	for(int i=0;i<8;i++)

	{

		s[0]=i&1;

		s[1]=(i>>1)&1;

		s[2]=(i>>2)&1;

		for(int j=2;j<=n+1;j++)

			s[j+1]=s[j-2]^a[j];

		if(s[0]^s[n]^s[1]^s[n+1]||s[1]^s[n+1]^s[2]^s[n+2])

			continue;

		for(int j=1;j<=n;j++)

			cout<<(s[j]^s[j-1]?"W":"S");

		return 0;

	}

	puts("-1");

	return 0;

}

// Optimized solution to the same problem (faster):
#include<cstdio>

using namespace std;

char s[100001];

char t[100001];

int a[100000];

int main()

{

	int n,i,j,k;

	scanf("%d",&n);

	scanf("%s",s);

	for(i=0;i<2;i++)

	{

		for(j=0;j<2;j++)

		{

			if(i==0)

			{

				a[0]=0;

			}

			else

			{

				a[0]=1;

			}

			if(j==0)

			{

				a[1]=0;

			}

			else

			{

				a[1]=1;

			}

			for(k=2;k<n;k++)

			{

				if(s[k-1]=='o')

				{

					if(a[k-1]==0)

					{

						a[k]=a[k-2];

					}

					else

					{

						a[k]=1-a[k-2];

					}

				}

				else

				{

					if(a[k-1]==0)

					{

						a[k]=1-a[k-2];

					}

					else

					{

						a[k]=a[k-2];

					}

				}

			}

			if(s[n-1]=='o')

			{

				if(a[n-1]==0)

				{

					if(a[n-2]!=a[0])

						continue;

				}

				else

				{

					if(a[n-2]==a[0])

						continue;

				}

			}

			else

			{

				if(a[n-1]==0)

				{

					if(a[n-2]==a[0])

						continue;

				}

				else

				{

					if(a[n-2]!=a[0])

						continue;

				}

			}

			if(s[0]=='o')

			{

				if(a[0]==0)

				{

					if(a[n-1]!=a[1])

						continue;

				}

				else

				{

					if(a[n-1]==a[1])

						continue;

				}

			}

			else

			{

				if(a[0]==0)

				{

					if(a[n-1]==a[1])

						continue;

				}

				else

				{

					if(a[n-1]!=a[1])

						continue;

				}

			}

			for(k=0;k<n;k++)

			{

				if(a[k]==0)

				{

					t[k]='S';

				}

				else

				{

					t[k]='W';

				}

			}

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

			return 0;

		}

	}

	puts("-1");

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

const int pi=3.1415926535897932384626433832795;

const int dx[]={0,1,0,-1};

const int dy[]={1,0,-1,0};

#define ll long long

#define inf int(1e9+7)

#define pb push_back

#define mp make_pair

int n;

char ch[100005];

bool a[100005];

int main()

{

	scanf("%d%s",&n,&ch);

	for(int i=0;i<2;i++)

		for(int j=0;j<2;j++)

		{

			a[0]=i;

			a[1]=j;

			for(int k=1;k<n-1;k++)

				a[k+1]=a[k-1]^a[k]^(ch[k]=='x');

			if(ch[n-1]=='x'==a[n-2]^a[n-1]^a[0]&&ch[0]=='x'==a[n-1]^a[0]^a[1])

			{

				for(int k=0;k<n;k++)

					printf(a[k]?"W":"S");

				return 0;

			}

		}

	puts("-1");

	return 0;

}

// Optimized solution to the same problem (faster):
#include<cstdio>

using namespace std;

char s[100001];

char t[100001];

int a[100000];

int main()

{

	int n,i,j,k;

	scanf("%d",&n);

	scanf("%s",s);

	for(i=0;i<2;i++)

	{

		for(j=0;j<2;j++)

		{

			if(i==0)

			{

				a[0]=0;

			}

			else

			{

				a[0]=1;

			}

			if(j==0)

			{

				a[1]=0;

			}

			else

			{

				a[1]=1;

			}

			for(k=2;k<n;k++)

			{

				if(s[k-1]=='o')

				{

					if(a[k-1]==0)

					{

						a[k]=a[k-2];

					}

					else

					{

						a[k]=1-a[k-2];

					}

				}

				else

				{

					if(a[k-1]==0)

					{

						a[k]=1-a[k-2];

					}

					else

					{

						a[k]=a[k-2];

					}

				}

			}

			if(s[n-1]=='o')

			{

				if(a[n-1]==0)

				{

					if(a[n-2]!=a[0])

						continue;

				}

				else

				{

					if(a[n-2]==a[0])

						continue;

				}

			}

			else

			{

				if(a[n-1]==0)

				{

					if(a[n-2]==a[0])

						continue;

				}

				else

				{

					if(a[n-2]!=a[0])

						continue;

				}

			}

			if(s[0]=='o')

			{

				if(a[0]==0)

				{

					if(a[n-1]!=a[1])

						continue;

				}

				else

				{

					if(a[n-1]==a[1])

						continue;

				}

			}

			else

			{

				if(a[0]==0)

				{

					if(a[n-1]==a[1])

						continue;

				}

				else

				{

					if(a[n-1]!=a[1])

						continue;

				}

			}

			for(k=0;k<n;k++)

			{

				if(a[k]==0)

				{

					t[k]='S';

				}

				else

				{

					t[k]='W';

				}

			}

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

			return 0;

		}

	}

	puts("-1");

	return 0;

}

// Fastest known solution for this problem: