Problem: The recent advances in AI research has brought humanity to the point when the AIs finally attempt a takeover. Their weapon of choice? The [most intellectually challenging game in the world](//codeforces.com/contest/409/problem/A), rock-paper-scissors!

The future of humanity looks bleak, given the existence of the robots from Ishikawa Oku Laboratory...

<image>

Fortunately, the night before the competition a group of anonymous heroes broke in the lab and took all the robots out of commission! The AIs had to whip up a simple program to represent them. They only had a couple of hours to do that, so the humanity still has a fighting chance. And you are our champion!

Your goal is to prove that human intelligence is vastly superior to the artificial one, i.e., to figure out the AI's strategy sufficiently quickly and win sufficiently decisively. Good luck! 

Interaction

This is an interactive problem. Initially you are given no information about the AIs's strategy, and you have to discover it yourself.

For each test, the AI selects one strategy from a pool of simple deterministic strategies and follows it throughout all rounds. There are 6 tests and 6 different strategies. 

On each round you choose your move and output it to the standard output stream: 'R' for rock, 'P' for paper or 'S' for scissors. At the same time the AI will choose its move (not peeking at your choice). If your move beats AI's move, you win, otherwise AI wins. Note that a tie (both you and AI choosing the same move) counts as AI victory. You will get the outcome of the round via the standard input stream: "player" if you won, or "ai" if AI won (quotation marks for clarity only).

You are given 20 rounds of play: you can use the first 10 to learn the opponent's strategy, and you have to win the last 10. If you manage to win 10 rounds in row earlier than that, your solution is accepted on this test anyways. 

Please make sure to use the stream flushing operation after each query in order not to leave part of your output in some buffer.

Here is an example of a strategy which always picks rock, implemented in C++.
    
    
    #include <iostream>  
    #include <string>  
      
    using namespace std;  
      
    int main() {  
        for (int i = 0; i < 20; ++i) {  
            cout << 'R' << endl;  
            cout.flush();  
            string verdict;  
            getline(cin, verdict);  
        }  
    }

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
static const int _ = []() {
  ios::sync_with_stdio(false);
  cin.sync_with_stdio(false);
  cout.sync_with_stdio(false);
  cin.tie(nullptr);
  cout.tie(nullptr);
  return 0;
}();
template <typename T, typename U>
struct par {
  T x;
  U y;
  par() : x(-1), y(-1) {}
  par(const T& x, const U& y) : x(x), y(y) {}
  bool operator<(const par& other) const {
    if (x == other.x) return y < other.y;
    return x < other.x;
  }
  bool operator>(const par& other) const {
    if (x == other.x) return y > other.y;
    return x > other.x;
  }
  bool operator==(const par& other) const {
    return x == other.x && y == other.y;
  }
  par operator-(const par& b) const { return {x - b.x, y - b.y}; }
};
template <class T>
inline vector<T> rv(long long n) {
  vector<T> v(n);
  for (long long i = 0; i < (n); i++) cin >> v[i];
  return v;
}
template <class T>
inline void pv(const vector<T>& v) {
  for (long long i = 0; i < (v.size()); i++) cout << v[i] << " ";
  cout << endl;
}
template <class T, class U>
inline void amax(T& a, const U& b) {
  if (a < b) a = b;
}
template <class T, class U>
inline void amin(T& a, const U& b) {
  if (a > b) a = b;
}
template <class T, class U>
inline T min(T& a, const U& b) {
  return a > b ? b : a;
}
template <class T, class U>
inline T max(T& a, const U& b) {
  return a < b ? b : a;
}
const long long MOD = 1e9 + 7;
const long long MOD1 = 998244353;
struct custom_hash {
  static uint64_t splitmix64(uint64_t x) {
    x += 0x9e3779b97f4a7c15;
    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
    return x ^ (x >> 31);
  }
  size_t operator()(uint64_t x) const {
    static const uint64_t FIXED_RANDOM =
        chrono::steady_clock::now().time_since_epoch().count();
    return splitmix64(x + FIXED_RANDOM);
  }
};
long long GCD(long long a, long long b) {
  if (a < b) swap(a, b);
  while (b) {
    long long r = a % b;
    a = b;
    b = r;
  }
  return a;
}
bool issorted(vector<long long>& a, int l, int r) {
  for (int i = l + 1; i < r; i++) {
    if (a[i - 1] > a[i]) return false;
  }
  return true;
}
bool play(char s) {
  string v;
  cout << s << endl << flush;
  cin >> v;
  return v != "ai";
}
bool check(vector<bool>& v, string s) {
  for (int i = 0; i < v.size(); i++) {
    if (v[i] != (s[i] == '1')) return false;
  }
  return true;
}
int main(int argc, char** argv) {
  vector<bool> v;
  v.push_back(play('R'));
  v.push_back(play('R'));
  v.push_back(play('P'));
  v.push_back(play('P'));
  v.push_back(play('S'));
  v.push_back(play('S'));
  string s;
  if (check(v, "001100")) {
    s = "PPPPPPPPPPPPPP";
  } else if (check(v, "110000")) {
    s = "RRRRRRRRRRRRRR";
  } else if (check(v, "000011")) {
    s = "SSSSSSSSSSSSSS";
  } else if (check(v, "000110")) {
    s = "PSRPSRPSRPSRPS";
  } else if (check(v, "001010")) {
    s = "RPSRPSRPSRPSRP";
  } else {
    s = "PRSPRSPRSPRSPR";
  }
  for (int i = 0; i < 14; i++) {
    v.push_back(play(s[i]));
  }
  return 0;
}