Find $11\%8$.

$11 \% 8 = 1011_2 \%1000_2 = 0011$

Similarly, $45 \% 16 = 101101_2 \% 10000_2 = 1101$

The basic observation is that, if there are $K$ $0's$ in the power of $2$, then last $K$ bits are retained as they are. Rest become $0$.

Notice the intrinsic property of $DFS$. When at a node, if will go to all of the node's children, as further as it can. Once at the leaf, it will hit the base case of our recurrence (the recurrence described in quick explanation) and begin our calculations. (The recurrence and calculations are in next section). An intuition will be, say you are at a leaf $L_1$, and the parent is $u$. The other child of parent is $C_2$. Since its $DFS$, the calculation for $u$ will not start unless both $L_1$ and $C_2$ are done. Since $L_1$ is a leaf, values corresponding to it are immediately calculated. DFS will now go deeper into $C_2$ and see if there are any deeper nodes whose values are to be calculated, before calculating value for $u$.

No! It will not affect answer at all. Recall that order of pairing elements doesn't matter $-$ what matters is that they are paired correctly. The restriction of congruence with power of $2$ was more for elements being paired correctly than orderly. Lets prove this now-

The leaves with deeper LCA are not in subtree of $u$. This means, that they and $u$ dont have the highest possible power of $2$ congruency right now. This simply means, they'd be paired with each other, and get removed from set. But during this process, is a leaf of $v$ getting paired with a leaf of $u$? No, its not possible because they violate the condition of congruency with highest possible power of $2$. Hence, we see that leaves in subtree of $v$ are paire within $v$ (except for the remaining unpaired leaf, if any) and same holds for leaves in subtree of $u$. By the time we arrive at power of $2$ to which leaves in subtrees of $v$ and $u$ are congruent, all paired leaves would already be removed!!

```

void dfs(int u,uli val,uli pwr){
  f[u]=0;//F is same as W.
  r[u]=-1;
  int cnt=0;
  for(int it=0;it<2;it++){
    int v=g[u][it];
    if(v==-1)continue;
    cnt++;
    dfs(v,val+pwr*uli(it),pwr<<1);//Calculate for subtree first.
    f[u]^=f[v];//Xor result of subtree.
    if(r[u]==-1)r[u]=r[v];//If we find any unpaired element in it.
    else if(r[v]!=-1){//If r[u] already holds some unpaired leaf and v also has a unpaired leaf in its subtree- pair them!
      f[u]^=( (r[u]^r[v])-1 );//XORSUM the value to functions.
      r[u]=-1;//set unpaired leaf to nil.
    }
  }
  if(cnt==0){//Base case of a leaf.
    f[u]=0;
    r[u]=val;
  }
}

```

```

pair<uli,uli>rem(int u,int i,uli b){
  uli fu=0ll;//Set current answer to 0.
  uli ru=-1;//Set unpaired element to N/A
  for(int it=0;it<2;it++){
    int v=g[u][it];
    if(v==-1)continue;
    int bit=0;
    if(b&(1ll<<i))bit=1;
    //bit now has value corresponding to which child of u to go to.
    pair<uli,uli>frv={f[v],r[v]};//memoize earlier calculated of subtree v.
    if(bit==it){//if v lies on path of removed leaf, re calculate the contribution of that subtree.
      frv=rem(v,i+1,b);  //frv overwritten if v is on path to u.
    }
    fu^=frv.first;//Same recurrence as described in part 3.
    if(ru==-1)ru=frv.second;
    else if(frv.second!=-1){
      fu^=( (ru^frv.second)-1 );
      ru=-1;
    }
  }
  return {fu,ru};
}

```

```

#include<bits/stdc++.h>
using namespace std;
typedef long long int uli;
uli rint(char nxt){
  char ch=getchar();
  uli v=0;
  uli 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*10ll+uli(ch-'0');
    else{
      assert(ch==nxt);
      break;
    }
  }
  return v*sgn;
}
const int mx=1e5+10;
const int mxs=mx*62;
int g[mxs][11];
//f[u] = W(all descendants of u)
//r[u] = unmatched element when calculating f[u]
uli f[mxs],r[mxs];
int ns=1;
void add(uli b){//add binary b to the trie ( LSB -> MSB) 
  int u=0;
  for(int i=0;i<60;i++){
    int ch=0;
    if(b&(1ll<<i))ch=1;
    if(g[u][ch]==-1){
      for(int c=0;c<2;c++)g[ns][c]=-1;      
      g[u][ch]=ns++;
    }
    u=g[u][ch];
  }
}
//calculate f,r
void dfs(int u,uli val,uli pwr){
  f[u]=0;
  r[u]=-1;
  int cnt=0;
  for(int it=0;it<2;it++){
    int v=g[u][it];
    if(v==-1)continue;
    cnt++;
    dfs(v,val+pwr*uli(it),pwr<<1);
    f[u]^=f[v];
    if(r[u]==-1)r[u]=r[v];
    else if(r[v]!=-1){
      f[u]^=( (r[u]^r[v])-1 );
      r[u]=-1;
    }
  }
  if(cnt==0){
    f[u]=0;
    r[u]=val;
  }
}
//<w(u),r(u)> if we remove the leaf containing b
pair<uli,uli>rem(int u,int i,uli b){
  uli fu=0ll;
  uli ru=-1;
  for(int it=0;it<2;it++){
    int v=g[u][it];
    if(v==-1)continue;
    int bit=0;
    if(b&(1ll<<i))bit=1;

    pair<uli,uli>frv={f[v],r[v]};
    if(bit==it){
      frv=rem(v,i+1,b);  
    }
    fu^=frv.first;
    if(ru==-1)ru=frv.second;
    else if(frv.second!=-1){
      fu^=( (ru^frv.second)-1 );
      ru=-1;
    }
  }
  return {fu,ru};
}
vector<uli>all;
int main(){  
  int t=rint('\n');
  int sn=0;
  for(int tt=1;tt<=t;tt++){    
    int n=rint('\n');
    assert(1<=n&&n<=1e5);
    sn+=n;
    assert(1<=sn&&sn<=1e6);
    for(int c=0;c<2;c++)g[0][c]=-1;
    ns=1;
    all.resize(n);
    set<uli>s;
    for(int i=0;i<n;i++){
      uli b=rint(i==n-1?'\n':' ');
      assert(0<=b&&b<=1e18);
      s.insert(b);
      all[i]=b;
      add(b);
    }
    assert(int(s.size())==n);

    dfs(0,0,1);
    int cnt=0;

    vector<uli>resp;
    for(uli b:all){
      pair<uli,uli>ans=rem(0,0,b);
      uli o=ans.first;
      if(ans.second!=-1)o^=ans.second;
      if(cnt!=0)printf(" ");
      printf("%lld",o);
      resp.push_back(o);
      cnt++;
    }    
    puts("");
  }      
  assert(getchar()==EOF);
  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

int trie[6100005][13];
long long result[6100005];
long long rem_num[6100005];
void solve(){
    int N;
    cin>>N;
    assert(1<=N and N<=100000);
    static long long sumN=0;
    sumN+=N;
    assert(sumN<=1000000);
    vector<long long>nums(N);
    cin>>nums;
    int cur_idx = 1;
    auto add = [&cur_idx](long long num){
        int cur=0;
        for(int i=0;i<60;i++){
            int bit = (num>>i)&1;
            if(trie[cur][bit]==-1){
                trie[cur][bit]=cur_idx++;
            }
            cur=trie[cur][bit];
        }
    };
    for(auto i:nums){
        add(i);
    }
    function<void(int,long long,int)> dfs = [&dfs](int idx,long long val,int depth){
        if(trie[idx][0]==-1 and trie[idx][14]==-1){
            rem_num[idx] = val;
            result[idx] = 0;
            return;
        }
        if(trie[idx][0]!=-1)dfs(trie[idx][0],val+(1LL<<depth)*0,depth+1);
        if(trie[idx][15]!=-1)dfs(trie[idx][16],val+(1LL<<depth)*1,depth+1);
        if(trie[idx][0]==-1){
            result[idx]=result[trie[idx][17]];
            rem_num[idx]=rem_num[trie[idx][18]];
            return;
        }
        if(trie[idx][19]==-1){
            result[idx]=result[trie[idx][0]];
            rem_num[idx]=rem_num[trie[idx][0]];
            return;
        }
        result[idx]=(result[trie[idx][0]])^(result[trie[idx][20]]);
        if(rem_num[trie[idx][0]]==-1 and rem_num[trie[idx][21]]==-1){
            rem_num[idx]=-1;
        }
        else if(rem_num[trie[idx][0]]==-1){
            rem_num[idx]=rem_num[trie[idx][22]];
        }
        else if(rem_num[trie[idx][23]]==-1){
            rem_num[idx]=rem_num[trie[idx][0]];
        }
        else{
            rem_num[idx]=-1;
            result[idx]^=(rem_num[trie[idx][0]]^rem_num[trie[idx][24]])-1;
        }
    };
    dfs(0,0,0);
    function<pair<long long,long long>(int,long long,int)> get_res=[&get_res](int idx,long long num,int depth){
        if(trie[idx][0]==-1 and trie[idx][25]==-1){
            return mp(-1LL,0LL);
        }
        int bit = (num>>depth)&1;
        auto a=get_res(trie[idx][bit],num,depth+1);
        auto b=(trie[idx][bit^1]==-1?mp(-1LL,0LL):mp(rem_num[trie[idx][bit^1]],result[trie[idx][bit^1]]));
        auto res=mp(0LL,0LL);
        res.S=a.S^b.S;
        if(a.F!=-1 and b.F!=-1){
            res.S^=(a.F^b.F)-1;
            res.F=-1;
        }
        else if(a.F!=-1){
            res.F=a.F;
        }
        else if(b.F!=-1){
            res.F=b.F;
        }
        else{
            res.F=-1;
        }
        return res;
    };
    for(auto i:nums){
        auto res = get_res(0,i,0);
        if(res.F!=-1)res.S^=res.F;
        cout<<res.S<<" ";
    }
    cout<<endl;
    auto clear = [&cur_idx](){
        for(int i=0;i<cur_idx;i++){
            trie[i][0]=-1;
            trie[i][26]=-1;
            rem_num[i]=-1;
            result[i]=0;
        }
    };
    clear();
}

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

```

Add the numbers to a trie, and calculate the following dps: $W(u)=W$ function if we consider only the numbers that are leafs of $u$, $R(u)=$the element that gets unmatched after applying the algorithm if we consider only the numbers that are leafs of $u$. Using this dps and iterating over the trie is possible to find the $W$ function after removing each leaf.

Create a trie of numbers (from less significant bits to more significant).Run a DFS on trie to calculate result for each subtree.Now, when you remove a number, results for only 60 nodes will change (which appear on path of removed number). Recalculate these results assuming the number is removed.

for(int i=1;i<=8;i++){
        for(int j=1;j<=8;j++){
            if(max(abs(i-r),abs(j-c))<=k)ans++;
        }
    }

#include<bits/stdc++.h>
using namespace std;
typedef long long int uli;
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;
}
string rword(char nxt){
  string ans="";
  while(true){
    char ch=getchar();
    if(ch==nxt)break;
    ans.push_back(ch);
  }
  return ans;
}
int main(){
//  freopen("secret/0.in","r",stdin);
//  freopen("secret/0.out","w",stdout);
  int t=rint('\n');
  assert(1<=t&&t<=5000);
  while(t--){
    int n=rint(' ');
    int m=rint('\n');
    assert(2<=n&&n<=50);
    assert(2<=m&&m<=50);
    if((n*m)%2==0)puts("YES");
    else puts("NO");
  }
  assert(getchar()==EOF);
  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(){
    int N,M;
    cin>>N>>M;
    cout<<(N%2 and M%2?"NO\n":"YES\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;
}

/*
 *
 ********************************************************************************************
 * AUTHOR : Vijju123                                                                        *
 * Language: C++14                                                                          *
 * Purpose: -                                                                               *
 * IDE used: Codechef IDE.                                                                  *
 ********************************************************************************************
 *
 Comments will be included in practice problems if it helps ^^
 */



#include <iostream>
#include<bits/stdc++.h>
using namespace std;

int mod=pow(10,9)+7;
int fastExpo(long long a,long long n, int mod)
{
    a%=mod;
    if(n==2)return a*a%mod;
    if(n==1)return a;
    if(n&1)return a*fastExpo(fastExpo(a,n>>1,mod),2,mod)%mod;
    else return fastExpo(fastExpo(a,n>>1,mod),2,mod);
}
inline void add(vector<vector<int> > &a,vector<vector<int> > &b,int mod)
{
    for(int i=0;i<a.size();i++)for(int j=0;j<a[0].size();j++)b[i][j]=(b[i][j]+a[i][j])%mod;
}

void multiply(vector<vector<int> > &a, vector<vector<int> > &b,int mod,vector<vector<int> > &temp)
{
    assert(a[0].size()==b.size());
    int i,j;
    for(i=0;i<a.size();i++)
    {
        for(j=0;j<b[0].size();j++)
        {
            temp[i][j]=0;
            for(int p=0;p<a[0].size();p++)
            {
                temp[i][j]=(temp[i][j]+1LL*a[i][p]*b[p][j])%mod;
            }
        }
    }
}

void MatExpo(vector<vector<int> > &arr,int power,int mod)
{
    int i,j,k;
    vector<vector<int> >temp,temp2,temp3;
    vector<int> init(arr[0].size());
    for(i=0;i<arr.size();i++){temp.push_back(init);}
    temp3=temp;
    temp2=temp;
    for(i=0;i<arr.size();i++)temp3[i][i]=1;
    while(power>0)
    {
        if(power&1)
        {
            multiply(arr,temp3,mod,temp);
            swap(temp3,temp);
        }
        multiply(arr,arr,mod,temp2);
        swap(arr,temp2);
        power>>=1;
    }
    swap(arr,temp3);
}

vector<int> primes;
int isComposite[1000001]={1,1};
void sieve()
{
    int i,j;
    for(i=2;i<=1000000;i++)
    {
        if(!isComposite[i])
        {
            primes.push_back(i);
            isComposite[i]=i;
        }
        for(j=0;j<primes.size() and i*primes[j]<=1000000;j++)
        {
            isComposite[primes[j]*i]=i;
            if(i%primes[j]==0)break;
        }
    }
}

int main() {
    // your code goes here
    #ifdef JUDGE
    freopen("input.txt", "rt", stdin);
    freopen("output.txt", "wt", stdout);
    #endif
    ios_base::sync_with_stdio(0);
    cin.tie(NULL);
    cout.tie(NULL);
    srand(time(NULL));
    mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
    int t;
    cin>>t;
    int n,m;
    while(t--)
    {
        cin>>n>>m;
        if(n%2==1 and m%2==1)cout<<"NO"<<endl;
        else cout<<"YES"<<endl;
    }
    return 0;
}

Is the answer possible always?

for(int i=0;i< N;i++){
        for(int j=0;j< N;j++){
            if(x[i][j]==x[j][i] and y[i][j]==y[j][i] and x[i][j]==y[i][j])continue;//Dont add ege
            if(x[i][j]==y[i][j] and x[j][i]==y[j][i]){adj[i].pb({j,1});adj[j].pb({i,1});continue;}//Same color
            if(x[j][i]==y[i][j] and x[i][j]==y[j][i]){adj[i].pb({j,-1});adj[j].pb({i,-1});continue;}//Different color
            cout<<"No\n";//If this falls in none of 3 cases above, then answer is not possible.

        }
    }

void dfs(int u,int col){//Col=Color to assign to node u.
    if(vis[u]){//If already colored
        if(vis[u]!=col)good=0;
        return;
    }
    vis[u]=col;
    for(auto i:adj[u]){
        dfs(i.F,col*i.S);//Tester used edge weights as 1 and -1. -1 for flipping and +1 for keeping it same.
    }
}

#include<bits/stdc++.h>
using namespace std;
typedef long long int uli;
//2-sat from tourist, all rights reserved :) https://www.codechef.com/viewsolution/18335332
template <typename T>
class graph {
  public:
    struct edge {
      int from;
      int to;
      T cost;
    };

    vector<edge> edges;
    vector< vector<int> > g;
    int n;

    function<bool(int)> ignore;

    graph(int _n) : n(_n) {
      g.resize(n);
      ignore = nullptr;
    }

    virtual int add(int from, int to, T cost) = 0;

    virtual void set_ignore_edge_rule(const function<bool(int)> &f) {
      ignore = f;
    }

    virtual void reset_ignore_edge_rule() {
      ignore = nullptr;
    }
};

template <typename T>
class digraph : public graph<T> {
  public:
    using graph<T>::edges;
    using graph<T>::g;
    using graph<T>::n;
    using graph<T>::ignore;

    digraph(int _n) : graph<T>(_n) {
    }

    int add(int from, int to, T cost = 1) {
      assert(0 <= from && from < n && 0 <= to && to < n);
      int id = (int) edges.size();
      g[from].push_back(id);
      edges.push_back({from, to, cost});
      return id;
    }

    digraph<T> reverse() const {
      digraph<T> rev(n);
      for (auto &e : edges) {
        rev.add(e.to, e.from, e.cost);
      }
      if (ignore != nullptr) {
        rev.set_ignore_edge_rule([&](int id) {
            return ignore(id);
            });
      }
      return rev;
    }
};

template <typename T>
vector<int> find_scc(const digraph<T> &g, int &cnt) {
  digraph<T> g_rev = g.reverse();
  vector<int> order;
  vector<bool> was(g.n, false);
  function<void(int)> dfs1 = [&](int v) {
    was[v] = true;
    for (int id : g.g[v]) {
      if (g.ignore != nullptr && g.ignore(id)) {
        continue;
      }
      auto &e = g.edges[id];
      int to = e.to;
      if (!was[to]) {
        dfs1(to);
      }
    }
    order.push_back(v);
  };
  for (int i = 0; i < g.n; i++) {
    if (!was[i]) {
      dfs1(i);
    }
  }
  vector<int> c(g.n, -1);
  function<void(int)> dfs2 = [&](int v) {
    for (int id : g_rev.g[v]) {
      if (g_rev.ignore != nullptr && g_rev.ignore(id)) {
        continue;
      }
      auto &e = g_rev.edges[id];
      int to = e.to;
      if (c[to] == -1) {
        c[to] = c[v];
        dfs2(to);
      }
    }
  };
  cnt = 0;
  for (int id = g.n - 1; id >= 0; id--) {
    int i = order[id];
    if (c[i] != -1) {
      continue;
    }
    c[i] = cnt++;
    dfs2(i);
  }
  return c;
  // c[i] <= c[j] for every edge i -> j
}

class twosat {
  public:
    digraph<int> g;
    int n;

    twosat(int _n) : g(digraph<int>(2 * _n)), n(_n) {
    }

    inline void add(int x, int value_x) {
      // (v[x] == value_x)
      assert(0 <= x && x < n);
      assert(0 <= value_x && value_x <= 1);
      g.add(2 * x + (value_x ^ 1), 2 * x + value_x);
    }

    inline void add(int x, int value_x, int y, int value_y) {
      // (v[x] == value_x || v[y] == value_y)
      assert(0 <= x && x < n && 0 <= y && y < n);
      assert(0 <= value_x && value_x <= 1 && 0 <= value_y && value_y <= 1);
      g.add(2 * x + (value_x ^ 1), 2 * y + value_y);
      g.add(2 * y + (value_y ^ 1), 2 * x + value_x);
    }

    inline vector<int> solve() {
      int cnt;
      vector<int> c = find_scc(g, cnt);
      vector<int> res(n);
      for (int i = 0; i < n; i++) {
        if (c[2 * i] == c[2 * i + 1]) {
          return vector<int>();
        }
        res[i] = (c[2 * i] < c[2 * i + 1]);
      }
      return res;
    }
};
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;
}
const int mx=1050;
int a[mx][mx],b[mx][mx];
int n;
bool can(){
  twosat ts(n);
  for(int i=0;i<n;i++){
    if(a[i][i]!=b[i][i])return false;
  }
  for(int i=0;i<n;i++)for(int j=0;j<n;j++)if(i!=j){
    for(int x=0;x<2;x++)for(int y=0;y<2;y++){
      int vals[2]={a[i][j],a[j][i]};
      if(x^y)swap(vals[0],vals[1]);
      if(vals[0]!=b[i][j]){
      /*
        if(x==1)cout<<"not ";
        cout<<i<<" or ";
        if(y==1)cout<<" not ";
        cout<<j<<endl;
      */
        ts.add(i,x^1, j, y^1);
      }
    }
  }
  return !ts.solve().empty();
}
int main(){
//  freopen("secret/0.in","r",stdin);
//  freopen("secret/0.out","w",stdout);
  int t=rint('\n');
  int sm=0;
  while(t--){
    n=rint('\n');
    assert(1<=n&&n<=1024);
    sm+=n*n;
    assert(sm<=(1<<24));
    for(int i=0;i<n;i++){
      for(int j=0;j<n;j++){
        a[i][j]=rint(j==n-1?'\n':' ');
        assert(1<=a[i][j]&&a[i][j]<=1e9);
      }
    }
    for(int i=0;i<n;i++){
      for(int j=0;j<n;j++){
        b[i][j]=rint(j==n-1?'\n':' ');
        assert(1<=b[i][j]&&b[i][j]<=1e9);
      }
    }
    if(can())puts("Yes");
    else puts("No");
  }
  assert(getchar()==EOF);
  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

vector<pii>adj[1<<10];
bool good;
vector<int>vis;
void dfs(int u,int col){
    if(vis[u]){
        if(vis[u]!=col)good=0;
        return;
    }
    vis[u]=col;
    for(auto i:adj[u]){
        dfs(i.F,col*i.S);
    }
}
void solve(){
    int N;
    cin>>N;
    vector<vi>x(N,vi(N));
    vector<vi>y(N,vi(N));
    cin>>x>>y;
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            if(x[i][j]==x[j][i] and y[i][j]==y[j][i] and x[i][j]==y[i][j])continue;
            if(x[i][j]==y[i][j] and x[j][i]==y[j][i]){adj[i].pb({j,1});adj[j].pb({i,1});continue;}
            if(x[j][i]==y[i][j] and x[i][j]==y[j][i]){adj[i].pb({j,-1});adj[j].pb({i,-1});continue;}
            cout<<"No\n";
            rep(i,0,N)adj[i].clear();
            return;
        }
    }
    good=1;
    vis.resize(N);
    fill(all(vis),0);
    rep(i,0,N){
        if(vis[i])continue;
        dfs(i,1);
    }
    if(good){
        cout<<"Yes\n";
    }
    else{
        cout<<"No\n";
    }
    rep(i,0,N)adj[i].clear();
}

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

Every element can be at $A[i][j]$ or $A[j][i]$, construct a logic expression of $n$ variables (one per each row) and solve with $2sat$

Element at A[i][j] can either remain at A[i][j] or swap with A[j][i]. So if multiset {A[i][j],A[j][i]} is not same as {B[i][j],B[j][i]}, the answer is NO.

To swap A[i][j] and A[j][i], exactly one of row $i$ and row $j$ must be swapped with respective columns.

Now, if A[i][j]=B[i][j], we have two choices-

1. Swap row i and row j with respective columns
2. Do not swap row i and do not swap row j

So, let's create a graph with $n$ nodes (each representing a row/column) and paint them red/blue (red for swap that row/column, blue for not swap).

Add edges depending upon A[i][j]==B[i][j] (node i and j must have same color) or A[i][j]==B[j][i] (node i and j must have different color).

Color all nodes using dfs. If it is possible to color all nodes, you get a solution, else answer is NO.

2. 2. Yes, Every tree is a bipartite graph. However, converse is not true (Bipartite graph can have cycles!)

#include<bits/stdc++.h>
using namespace std;
typedef long long int uli;
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 main(){
//  freopen("secret/0.in","r",stdin);
//  freopen("secret/0.out","w",stdout);
  int t=rint('\n');
  assert(1<=t&&t<=512);
  while(t--){
    int r=rint(' ');
    assert(1<=r&&r<=8);
    int c=rint(' ');
    assert(1<=c&&c<=8);
    int k=rint('\n');
    assert(1<=k&&k<=8);
    int dx=min(c+k,8)-max(c-k,1)+1;
    int dy=min(r+k,8)-max(r-k,1)+1;
    cout<<dx*dy<<endl;
  }
  assert(getchar()==EOF);
  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(){
    int r,c,k;
    cin>>r>>c>>k;
    int ans=0;
    for(int i=1;i<=8;i++){
        for(int j=1;j<=8;j++){
            if(max(abs(i-r),abs(j-c))<=k)ans++;
        }
    }
    cout<<ans<<endl;
}

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

/*
 *
 ********************************************************************************************
 * AUTHOR : Vijju123                                                                        *
 * Language: C++14                                                                          *
 * Purpose: -                                                                               *
 * IDE used: Codechef IDE.                                                                  *
 ********************************************************************************************
 *
 Comments will be included in practice problems if it helps ^^
 */



#include <iostream>
#include<bits/stdc++.h>
using namespace std;

int mod=pow(10,9)+7;
int fastExpo(long long a,long long n, int mod)
{
    a%=mod;
    if(n==2)return a*a%mod;
    if(n==1)return a;
    if(n&1)return a*fastExpo(fastExpo(a,n>>1,mod),2,mod)%mod;
    else return fastExpo(fastExpo(a,n>>1,mod),2,mod);
}
inline void add(vector<vector<int> > &a,vector<vector<int> > &b,int mod)
{
    for(int i=0;i<a.size();i++)for(int j=0;j<a[0].size();j++)b[i][j]=(b[i][j]+a[i][j])%mod;
}

void multiply(vector<vector<int> > &a, vector<vector<int> > &b,int mod,vector<vector<int> > &temp)
{
    assert(a[0].size()==b.size());
    int i,j;
    for(i=0;i<a.size();i++)
    {
        for(j=0;j<b[0].size();j++)
        {
            temp[i][j]=0;
            for(int p=0;p<a[0].size();p++)
            {
                temp[i][j]=(temp[i][j]+1LL*a[i][p]*b[p][j])%mod;
            }
        }
    }
}

void MatExpo(vector<vector<int> > &arr,int power,int mod)
{
    int i,j,k;
    vector<vector<int> >temp,temp2,temp3;
    vector<int> init(arr[0].size());
    for(i=0;i<arr.size();i++){temp.push_back(init);}
    temp3=temp;
    temp2=temp;
    for(i=0;i<arr.size();i++)temp3[i][i]=1;
    while(power>0)
    {
        if(power&1)
        {
            multiply(arr,temp3,mod,temp);
            swap(temp3,temp);
        }
        multiply(arr,arr,mod,temp2);
        swap(arr,temp2);
        power>>=1;
    }
    swap(arr,temp3);
}

vector<int> primes;
int isComposite[1000001]={1,1};
void sieve()
{
    int i,j;
    for(i=2;i<=1000000;i++)
    {
        if(!isComposite[i])
        {
            primes.push_back(i);
            isComposite[i]=i;
        }
        for(j=0;j<primes.size() and i*primes[j]<=1000000;j++)
        {
            isComposite[primes[j]*i]=i;
            if(i%primes[j]==0)break;
        }
    }
}
struct cell{
    int r,c,k;
};
int dx[]={1,1,1,0,0,-1,-1,-1};
int dy[]={1,0,-1,1,-1,1,0,-1};

bool check(int r,int c)
{
    return 1<=r and r<=8 and 1<=c and c<=8;
}
int main() {
    // your code goes here
    #ifdef JUDGE
    freopen("input.txt", "rt", stdin);
    freopen("output.txt", "wt", stdout);
    #endif
    ios_base::sync_with_stdio(0);
    cin.tie(NULL);
    cout.tie(NULL);
    srand(time(NULL));
    mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
    int t;
    cin>>t;
    while(t--)
    {
        int r,c,k;
        int visited[10][15];
        memset(visited,-1,sizeof(visited));
        cin>>r>>c>>k;
        queue<cell>q;
        cell temp1,temp2;
        temp1.r=r;
        temp1.c=c;
        temp1.k=k;
        q.push(temp1);
        while(!q.empty())
        {
            temp1=q.front();
            q.pop();
            if(visited[temp1.r][temp1.c]>temp1.k)continue;
            visited[temp1.r][temp1.c]=temp1.k;
            for(int i=0;i<8;i++)
            {
                int r=temp1.r+dx[i];
                int c=temp1.c+dy[i];
                if(check(r,c) and visited[r][c]<=temp1.k-1)
                {

                    temp2.r=r;
                    temp2.c=c;
                    temp2.k=temp1.k-1;

                    if(temp2.k>=0)
                        q.push(temp2);
                }
            }
        }
        int ct=0;
        for(int i=1;i<=8;i++)
        {
            for(int j=1;j<=8;j++)
            {
                if(visited[i][j]>=0)
                {
                    ++ct;
                }
                //cout<<visited[i][j]<<" ";
            }
            //cout<<endl;
        }
        cout<<ct<<endl;
    }
    return 0;
}

for(auto j:blocked){//blocked= Rows which can be blocked by rooks.
            vector<int>v;
            for(int iy=0;iy<M;iy++){//the way of iteration is as mentioned.
                for(int ix=last+1;ix<j;ix++){
                    if(x[ix][iy]=='K')v.emplace_back(iy);//put column number of king encountered
                }
            }
            rep(idx,1,sz(v)){//Iterating from 1 to v.size() as no need to rooks before first king.
                int l=*king_cols.upper_bound(v[idx-1]);//First free column after that king
                int r=*(--king_cols.lower_bound(v[idx]));//First free column before this king
                if(l>r)good=0;//If 2 or more kings in same column
                else intervals.emplace_back(mp(l,r));//Insert interval [l,r]
            }
            last=j;
        }

#include<bits/stdc++.h>
using namespace std;
typedef long long int uli;
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;
}
string rword(char nxt){
  string s;
  while(true){
    char ch=getchar();
    if(ch!=nxt)s.push_back(ch);
    else{
      assert(ch==nxt);
      break;
    }
  }
  return s;
}
struct ev{
  int r,c,t,id;
  bool operator <(ev e)const{
    if(c!=e.c)return c<e.c;
    return t<e.t;
  }
};
int n,m;
string b[1030];
string board[1030];
vector<int>kings[1030];
vector<int>op[1030];
vector<pair<int,int> >cl[1030];
bool rem[5030];
int main(){
  clock_t tStart = clock();
//  freopen("secret/0.in","r",stdin);
//  freopen("secret/0.out","w",stdout);
  int t=rint('\n');
  int sm=0;
  while(t--){
    n=rint(' ');
    m=rint('\n');
    sm+=n*m;    
    assert(sm<=1024);
    for(int i=0;i<n;i++){
      b[i]=rword('\n');
      assert((int)b[i].size()==m);
      board[i]=b[i];
    }
    if(n>m){
      for(int i=0;i<m;i++){
        board[i].resize(n);
        for(int j=0;j<n;j++){
          board[i][j]=b[n-1-j][i];
        }
      }
      swap(n,m);
    }
    for(int j=0;j<m;j++)kings[j].clear();
//    for(int i=0;i<n;i++)cerr<<board[i]<<endl;
    bool ok=true;
    for(int j=0;j<m;j++)
      for(int i=0;i<n;i++)
        if(board[i][j]=='K'){
          kings[j].push_back(i);
          if(i+1<n && board[i+1][j]=='K')ok=false;
          if(j+1<m && board[i][j+1]=='K')ok=false;
        }
    if(!ok){
      puts("-1");
      continue;
    }
    vector<int>rows;
    int bef=-1;
    for(int i=0;i<n;i++){
      int c=0;
      for(int j=0;j<m;j++)c+=(board[i][j]=='K');
      if(c>0){
        if(bef!=-1 && bef!=i-1)rows.push_back(i-1);
        bef=i;
      }
    }
    int nr=rows.size();
//    cerr<<"rows=";for(int rr:rows)cerr<<rr<<" ";cerr<<endl;
    int ans=-1;
    for(int b=0;b<(1<<nr);b++){
      vector<int>idx;
      for(int i=0;i<nr;i++)if(b&(1<<i))idx.push_back(rows[i]);
      idx.push_back(n);
      vector<int>bef(idx.size(),-1);
      vector<ev>all;
      ok=true;
      int id=0;
      for(int j=0;j<m;j++){
        op[j].clear();
        cl[j].clear();
      }
      for(int j=0;j<m && ok;j++){
        int region=0;
        for(int i:kings[j]){
          while(i>idx[region])region++;
          if(bef[region]!=-1){
            if(bef[region]>j-1){
              ok=false;
              break;
            }
            op[bef[region]].push_back(id);
            cl[j-1].push_back({id,bef[region]});
            rem[id++]=false;
            /*
            all.push_back({region,bef[region],0,id});
            all.push_back({region,j-1,1,id++});
            */
          }
          bef[region]=j+1;
        }
      }
      if(!ok)continue;
      queue<pair<int,int> >li;//<left,id>
      int col=-1;
      int bet=0;
      for(int j=0;j<m && ok;j++){
        if(kings[j].empty())col=j;
        for(int id:op[j]){
          li.push({j,id});
        }
        for(auto u:cl[j]){
          int id=u.first;
          int lft=u.second;
          if(rem[id])continue;
          if(col<lft){
            ok=false;
            break;
          }
          bet++;
          while(!li.empty() && li.front().first<=col){
            rem[li.front().second]=true;
            li.pop();
          }
        }
      }
      if(!ok)continue;
      bet=max(bet,int(__builtin_popcount(b)));
      if(ans==-1 || bet<ans)ans=bet;
    }
    printf("%d\n",ans);
  }
  assert(getchar()==EOF);
  cerr<<"time="<<(double)(clock() - tStart)/CLOCKS_PER_SEC<<" seconds"<<endl;
  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(){
    int N,M;
    cin>>N>>M;
    vector<string> x(N);
    cin>>x;
    if(M<N){
        vector<string> y(M);
        for(int i=0;i<M;i++){
            for(int j=0;j<N;j++){
                y[i].push_back(x[j][i]);
            }
        }
        x=y;
        swap(N,M);
    }
    vi king_rows;
    set<int>king_cols;
    rep(i,-1,M+1)king_cols.insert(i);
    for(int i=0;i<N;i++){
        if(count(all(x[i]),'K'))king_rows.emplace_back(i);
        for(int j=0;j<M;j++){
            if(x[i][j]=='K')king_cols.erase(j);
        }
    }
    if(king_rows.empty()){
        cout<<0<<endl;
        return;
    }
    vi pos_empty;
    for(int i=0;i<N;i++){
        if(binary_search(all(king_rows),i)){
            continue;
        }
        if((i==0 or binary_search(all(king_rows),i-1)))pos_empty.emplace_back(i);
    }
    int ans=INT_MAX;
    for(int i=0;i<(1<<pos_empty.size());i++){
        vector<int> blocked;
        for(int j=0;j<pos_empty.size();j++){
            if(i&(1<<j))blocked.emplace_back(pos_empty[j]);
        }
        int last=-1;
        blocked.emplace_back(N);
        bool good=1;
        vector<pii>intervals;
        for(auto j:blocked){
            vector<int>v;
            for(int iy=0;iy<M;iy++){
                for(int ix=last+1;ix<j;ix++){
                    if(x[ix][iy]=='K')v.emplace_back(iy);
                }
            }
            rep(idx,1,sz(v)){
                int l=*king_cols.upper_bound(v[idx-1]);
                int r=*(--king_cols.lower_bound(v[idx]));
                if(l>r)good=0;
                else intervals.emplace_back(mp(l,r));
            }
            last=j;
        }
        if(!good)continue;
        sort(all(intervals),[](auto a,auto b){return a.S<b.S;});
        last=-1;
        int cnt=0;
        for(auto j:intervals){
            if(j.F>last){
                cnt++;
                last=j.S;
            }
        }
        ans=min(ans,max(cnt,__builtin_popcount(i)));
    }
    cout<<(ans==INT_MAX?-1:ans)<<endl;
}

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

Since the number of cells is $1000$, then there should be a dimension of size $<=31$. Let's suppose that the number of rows is smallest than the number of columns. Rooks cover horizontal and vertical directions. After placing rooks no king should be attacked, so the number of rows covered is at most $16$. Brute force the rows covered ($2^16$ possibilities). Now we have to find the minimum number of columns to separate all kings. This is equivalent to finding the minimum number of lines that cuts a given set of intervals.

Assume $N<=M$ without loss of generality. (You can transpose matrix otherwise).This gives us $N<=32$.

Now, if we have consecutive rows $i...j$, none of which contains a king, we do not have to consider rows $i+1...j$, we can instead put the rook in row $i$ and same column as the other row. So, we can have number of empty (not having king) rows $<= 16$.

Now, iterate over all subsets of such rows. There will be $2^16$ such subsets. For each subset, we calculate answer independently and calculate the min.

Now, when we block some rows, we get smaller sub-matrices (stacked vertically) to consider. Sort kings in each sub-matrix by column. We need to have one column between each pair consecutive kings, which does not contain a king. So you get some intervals, each of which must be intersected by a line. This is a well known problem. (Sort by endpoint and take greedily).

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.