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

using Int = long long;
using ll = long long;

template<class T1, class T2> inline void chmin(T1 &a, T2 b){if(a > b) a = b;}
template<class T1, class T2> inline void chmax(T1 &a, T2 b){if(a < b) a = b;}

struct State{
  int n;
  array<array<char, 10>, 10> st;
  State(){}

  State(int n):n(n){}
  void input(){
    for(int i=0;i<n;i++)
      for(int j=0;j<n;j++)
        cin>>st[i][j];
  }

  void rev(){
    for(int i=0;i<n;i++)
      reverse(st[i].begin(),st[i].begin()+n);
  }

  void rot(){
    auto pr(st);
    for(int i=0;i<n;i++)
      for(int j=0;j<n;j++)
        st[n-(j+1)][i]=pr[i][j];
  }

  int c0(){
    return st[0][0]=='X';
  }

  int c1(){
    return st[0][n-1]=='X';
  }

  int c2(){
    return st[n-1][n-1]=='X';
  }

  int c3(){
    return st[n-1][0]=='X';
  }

  int ew_bit=0,ex_bit=0,ey_bit=0,ez_bit=0;

  int ew_pre(){
    int bit=0;
    for(int j=1;j+1<n;j++)
      bit|=(st[0][j]=='X')<<j;
    return ew_bit=bit;
  }

  int ex_pre(){
    int bit=0;
    for(int i=1;i+1<n;i++)
      bit|=(st[i][n-1]=='X')<<i;
    return ex_bit=bit;
  }

  int ey_pre(){
    int bit=0;
    for(int j=1;j+1<n;j++)
      bit|=(st[n-1][j]=='X')<<j;
    return ey_bit=bit;
  }

  int ez_pre(){
    int bit=0;
    for(int i=1;i+1<n;i++)
      bit|=(st[i][0]=='X')<<i;
    return ez_bit=bit;
  }

  void build(){
    ew_pre();
    ex_pre();
    ey_pre();
    ez_pre();
  }

  int ew(){return ew_bit;}
  int ex(){return ex_bit;}
  int ey(){return ey_bit;}
  int ez(){return ez_bit;}
};

int check(int a,int b,int c){
  return (a+b+c)==1;
}

int n;
int emsk;
int bond(int a,int b){
  if(a&b) return 0;
  return (a|b)==emsk;
}

int memo[1<<10];
int gyk(int bit){
  int &res=memo[bit];
  if(~res) return res;
  res=0;
  for(int i=1;i+1<n;i++)
    res|=((bit>>i)&1)<<(n-(i+1));
  return res;
}

int bond1(int a,int b){return bond(a,b);};
int bond2(int a,int b){return bond(a,gyk(b));};

int ans;
State ss[6];
void dfs(int p){
  if(p==6){
    vector<int> ord(6);
    iota(ord.begin(),ord.end(),0);
    for(int i=0;i<6;i++) ss[i].build();

    do{
      int res=1;
      // top corner
      res&=check(ss[ord[0]].c2(),ss[ord[1]].c1(),ss[ord[2]].c0());
      res&=check(ss[ord[0]].c1(),ss[ord[2]].c1(),ss[ord[3]].c0());
      res&=check(ss[ord[0]].c0(),ss[ord[3]].c1(),ss[ord[4]].c0());
      res&=check(ss[ord[0]].c3(),ss[ord[4]].c1(),ss[ord[1]].c0());
      if(!res) continue;

      // btm corner
      res&=check(ss[ord[5]].c1(),ss[ord[1]].c2(),ss[ord[2]].c3());
      res&=check(ss[ord[5]].c2(),ss[ord[2]].c2(),ss[ord[3]].c3());
      res&=check(ss[ord[5]].c3(),ss[ord[3]].c2(),ss[ord[4]].c3());
      res&=check(ss[ord[5]].c0(),ss[ord[4]].c2(),ss[ord[1]].c3());
      if(!res) continue;

      // top edge
      res&=bond1(ss[ord[0]].ey(),ss[ord[1]].ew());
      res&=bond2(ss[ord[0]].ex(),ss[ord[2]].ew());
      res&=bond2(ss[ord[0]].ew(),ss[ord[3]].ew());
      res&=bond1(ss[ord[0]].ez(),ss[ord[4]].ew());
      if(!res) continue;

      // btm edge
      res&=bond1(ss[ord[5]].ew(),ss[ord[1]].ey());
      res&=bond1(ss[ord[5]].ex(),ss[ord[2]].ey());
      res&=bond2(ss[ord[5]].ey(),ss[ord[3]].ey());
      res&=bond2(ss[ord[5]].ez(),ss[ord[4]].ey());
      if(!res) continue;

      // mid edge
      res&=bond1(ss[ord[1]].ex(),ss[ord[2]].ez());
      res&=bond1(ss[ord[2]].ex(),ss[ord[3]].ez());
      res&=bond1(ss[ord[3]].ex(),ss[ord[4]].ez());
      res&=bond1(ss[ord[4]].ex(),ss[ord[1]].ez());
      if(!res) continue;

      ans|=res;
      if(ans) return;
    }while(next_permutation(ord.begin()+1,ord.end()));
    return;
  }

  if(p==0){
    dfs(p+1);
    return;
  }

  for(int i=0;i<2;i++){
    for(int j=0;j<4;j++){
      ss[p].rot();
      dfs(p+1);
      if(ans) return;
    }
    ss[p].rev();
  }
}
signed main(){
  cin.tie(0);
  ios::sync_with_stdio(0);

  while(cin>>n,n){
    emsk=((1<<(n-2))-1)<<1;

    for(int i=0;i<6;i++){
      ss[i]=State(n);
      ss[i].input();
    }

    ans=0;
    memset(memo,-1,sizeof(memo));
    dfs(0);
    cout<<(ans?"Yes":"No")<<endl;
  }
  return 0;
}

