reverse(d.begin(),d.end());//Reverse the piles.
    int ans=0;
    for(int i=0;i< int(d.size());i+=2){
      ans^=(d[i]%3);//Refer to first observation.
    }

#include<bits/stdc++.h>
using namespace std;
typedef long long int uli;
const int mx=300;
char s[mx];
int rint(char nxt){
  char ch=getchar();
  int v=0;
  int sgn=1;
  if(ch=='-')sgn=-1;  
  else{
    assert('0'<=ch&&ch<='9');
    v=ch-'0';
  }
  while(true){
    ch=getchar();
    if('0'<=ch && ch<='9')v=v*10+ch-'0';
    else{
      assert(ch==nxt);
      break;
    }
  }
  return v*sgn;
}
int bat(int b,int i){
  if(b&(1<<i))return 1;
  return 0;
}
int f[(1<<20)+10];
int solve(int b){
  if(f[b]!=-1)return f[b];
  for(int i=1;i<20;i++){
    if(bat(b,i)==1 && bat(b,i-1)==0 && solve(b^(1<<i)^(1<<(i-1)))==0 ){
      return f[b]=1;
    }
    if(i>=2 && bat(b,i)==1 && bat(b,i-1)==0 && bat(b,i-2)==0 && solve(b^(1<<i)^(1<<(i-2)))==0 ){
      return f[b]=1;
    }
  }
  return f[b]=0;
}

int main(){
//  freopen("secret/sample.in","r",stdin);
//  freopen("secret/0.in","r",stdin);
//  freopen("secret/0.out","w",stdout);
  int t=rint('\n');
  assert(1<=t && t<=500);
  memset(f,-1,sizeof f);
  while(t--){
    assert(scanf("%s",s)==1);
    int n=strlen(s);
    assert(2<=n&&n<=128);
    vector<int>d;
    int bef=-1;
    for(int i=0;i<n;i++){
      if(s[i]=='P'){
        d.push_back(i-1-bef);
        bef=i;
      }
    }
    reverse(d.begin(),d.end());
    int ans=0;
    for(int i=0;i<int(d.size());i+=2){
      ans^=(d[i]%3);
    }
    if(ans==0)puts("No");
    else puts("Yes");

    if(n<=20){
      int b=0;
      for(int i=0;i<n;i++)if(s[i]=='P')b^=(1<<i);
      int w=solve(b);
      if(ans>0)ans=1;
      assert(w==ans);
    }
  }
  return 0;
}

#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>

#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif

// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>

#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#endif

#define ll          long long
#define pb          push_back
#define mp          make_pair
#define pii         pair<int,int>
#define vi          vector<int>
#define all(a)      (a).begin(),(a).end()
#define F           first
#define S           second
#define sz(x)       (int)x.size()
#define hell        1000000007
#define endl        '\n'
#define rep(i,a,b)  for(int i=a;i<b;i++)
using namespace std;

string to_string(string s) {
    return '"' + s + '"';
}

string to_string(const char* s) {
    return to_string((string) s);
}

string to_string(bool b) {
    return (b ? "true" : "false");
}

string to_string(char ch) {
    return string("'")+ch+string("'");
}

template <typename A, typename B>
string to_string(pair<A, B> p) {
    return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}

template <class InputIterator>
string to_string (InputIterator first, InputIterator last) {
  bool start = true;
  string res = "{";
  while (first!=last) {
    if (!start) {
        res += ", ";
    }
    start = false;
    res += to_string(*first);
    ++first;
  }
  res += "}";
  return res;
}

template <typename A>
string to_string(A v) {
    bool first = true;
    string res = "{";
    for (const auto &x : v) {
        if (!first) {
            res += ", ";
        }
        first = false;
        res += to_string(x);
    }
    res += "}";
    return res;
}

void debug_out() { cerr << endl; }

template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
    cerr << " " << to_string(H);
    debug_out(T...);
}

template <typename A, typename B>
istream& operator>>(istream& input,pair<A,B>& x){
    input>>x.F>>x.S;
    return input;
}

template <typename A>
istream& operator>>(istream& input,vector<A>& x){
    for(auto& i:x)
        input>>i;
    return input;
}


#ifdef PRINTERS
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif

void solve(){
    string x;
    cin>>x;
    int last=-1;
    vi temp;
    int N=x.size();
    for(int i=0;i<N;i++){
        if(x[i]=='P')temp.emplace_back(i-last-1),last=i;
    }
    int xor_sum = 0;
    reverse(all(temp));
    for(int i=0;i<temp.size();i+=2){
        xor_sum^=(temp[i]%3);
    }
    cout<<(xor_sum?"Yes\n":"No\n");
}

int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t=1;
    cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

The intuition behind this is, that, a position is winning position IFF you can remove some stones such that Grundy number of remaining stones in pile is $0$. Meaning, from current position, if you can goto a position with Grundy Number $=0$, your opponent loses no matter what. Else he wins. If we can remove at most $K$ stones, then if the pile has $\leq K$ coins, we can always win by a new game move. Hence their the Grundy number is equal to number of stones removed by definition of $mex()$ function. Once the pile has $K+1$ stones, we cannot win and Grundy number is back to $0$ (as we cannot goto any position where Grundy number is $0$ by removing only $K$ stones). Now, $K+1$ has grundy number $0$. If pile has $(K+1)+1$ stones, we again come back to starting - we win by removing a single stone. Similar for $K+1+i$ provided $i\leq K$. This completes the proof.

If we only remove stones from non-significant piles, always the opponent will get the finishing move.

Find the distances between each pair of pawns, performing one operation means decreasing one distance and increasing another. The grundy number of the game is the xor sum of distances of even index looking from right to left.

Consider ..P...P....P.

Here, we have 4 piles, of sizes 2,3,4,1.

Now, an operation consists of moving 1 or 2 stones from pile i to pile (i+1).

Mirroring an operation means, if opponent has moved k stones from i to (i+1), I move k stones from (i+1) to (i+2).

So, in the example above, the piles of importance are piles having 2 stones and 4 stones. If someone moves from pile having 3 stones, opponent will mirror the operation by moving to those stones to last pile.

So, instead of considering the game as "move all stones to last pile", we can consider it as "move all stones to odd indices".

So, we get two piles to consider 2 and 4 where we can remove either 1 or 2 stones. This gives (2%3)^(4%3).

This one is a personal derivation. Feel free to point any errors/doubts.

When you make a move on an insignificant pile, your opponent is always guaranteed a move. Also, on making a move on insignificant pile, opponent can put those stones onto another insignificant pile. What happens if we exhaust stones at all significant piles? The winner in this case, is already fixed. Hence, we can model it has, remove stone from every significant pile such that you get the last move in it. This is same as getting last move when the insignificant piles were absent.