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>
using namespace std;
const string possible_moves = "PRS";
map<char, char> wins_against = {{'P', 'S'}, {'R', 'P'}, {'S', 'R'}};
map<char, char> loses_against = {{'P', 'R'}, {'R', 'S'}, {'S', 'P'}};
char player[20], ai[20], result[20];
map<char, int> Count;
int Round = 0;
const char default_move = 'P';
int check_constant(char c) {
  return !(Count[wins_against[c]] || Count[loses_against[c]] || Count[c + 32]);
}
bool is_different(char a, char m) {
  return ((a < 'a') && (a != m) || (a == m + 32));
}
int check_cyclic(char c) {
  char m = c;
  for (int i = Round; i--;)
    if (is_different(ai[i], m = wins_against[m]))
      break;
    else if (!i)
      return 1;
  m = c;
  for (int i = Round; i--;) {
    if (is_different(ai[i], m = loses_against[m]))
      break;
    else if (!i)
      return 1;
  }
  return 0;
}
bool check_tit_for_tat() {
  for (int i = Round; --i > 0;)
    if (is_different(ai[i], player[i - 1])) return 0;
  player[Round] = (Round > 0 ? wins_against[player[Round - 1]] : default_move);
  return 1;
}
bool check_tft_bis() {
  for (int i = Round; --i > 0;)
    if (is_different(ai[i], wins_against[player[i - 1]])) return 0;
  player[Round] = loses_against[player[Round - 1]];
  return 1;
}
bool check_tft_ter() {
  for (int i = Round; --i > 0;)
    if (is_different(ai[i], loses_against[player[i - 1]])) return 0;
  player[Round] = player[Round - 1];
  return 1;
}
char our_move() {
  if (!Round) return default_move;
  int i = Round - 1;
  if (result[i] == 'p')
    Count[ai[i] = loses_against[player[i]]]++;
  else
    Count[ai[i] = loses_against[player[i]] + 32]++;
  for (auto c : possible_moves)
    if (check_constant(c)) {
      cerr << "detected constant '" << c << "' strategy\n";
      return wins_against[c];
    }
  for (auto c : possible_moves)
    if (check_cyclic(c)) {
      cerr << "detected cyclic strategy, AI is expected to play '" << c
           << "'\n";
      return wins_against[c];
    }
  if (check_tit_for_tat() || check_tft_bis() || check_tft_ter()) {
    cerr << "detected tit for tat strategy, AI is expected to play '"
         << loses_against[player[Round]] << "'\n";
    return player[Round];
  }
  return default_move;
}
int main() {
  for (Round = 0; Round < 20; ++Round) {
    cout << (player[Round] = our_move()) << endl;
    cout.flush();
    string verdict;
    getline(cin, verdict);
    result[Round] = verdict[0];
    cerr << "Received verdict '" << result[Round] << "'\n";
  }
  return 0;
}