// Original C++ solution (slower):
#include <iostream>

#include <fstream>

#include <sstream>

#include <string>

#include <vector>

#include <deque>

#include <queue>

#include <stack>

#include <map>

#include <set>

#include <algorithm>

#include <complex>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <cmath>

#include <climits>

#include <cctype>

using namespace std;



typedef long long ll;

typedef pair<int,int> P;



#define REP(i,n,m) for(int i=n;i<m;i++)

#define rep(i,n) REP(i,0,n)



int n;

vector<int> t[100000];

int dx[] = {1,-1,0,0};

int dy[] = {0,0,1,-1};

bool used[100000];

int color[100000];



bool dfs(int idx,int c){

  //cout<<idx<<","<<c<<endl;



  color[idx] = c;

  used[idx] = true;



  rep(i,t[idx].size()){

    int next = t[idx][i];



    if(color[next] == -1){

      if(idx + n == next || idx - n == next){

        bool res = dfs(next,!c);

        if(!res) return false;

      }

      else{

        bool res = dfs(next,c);

        if(!res) return false;

      }

    }

    else{

      if((idx + n == next || idx - n == next) && color[next] == color[idx]) return false;

      if(!(idx + n == next || idx - n == next) && color[next] != color[idx]) return false;

    }

  }



  return true;

}



bool solve(){

  memset(used,0,sizeof(used));



  REP(i,1,n+1){

    if(!used[i]){

      memset(color,-1,sizeof(color));

      bool flg = dfs(i,0);

      if(!flg) return false;

    }

  }



  return true;

}



int main(){

  while(scanf("%d",&n),n){

    rep(i,100000) t[i].clear();



    map<P,int> m;



    REP(i,1,n+1){

      int x[2],y[2];

      char buff[10];



      scanf("%d%d%s",&x[0],&y[0],buff);



      if(buff[0] == 'x'){

        x[1] = x[0] + 1;

        y[1] = y[0];

      }

      else{

        x[1] = x[0];

        y[1] = y[0] + 1;

      }



      rep(k,2){

        rep(j,4){

          int nx = x[k] + dx[j];

          int ny = y[k] + dy[j];

          int tmp = m[P(nx,ny)];

          if(tmp != 0){

            t[i+k*n].push_back(tmp);

            t[tmp].push_back(i+k*n);

          }

        }

      }



      rep(j,2){

        m[P(x[j],y[j])] = i + j * n;

      }

      t[i].push_back(i+n);

      t[i+n].push_back(i);

    }



    bool res = solve();

    printf("%s\n",res ? "Yes" : "No");

  }

}

// Optimized solution to the same problem (faster):
#include <iostream>

#include <map>

#include <set>

using namespace std;



#define TOP 2

#define RIGHT 1



typedef pair<int,int> P;



map<P, P> graph; //テ」ツ?ゥテ」ツ?ョテ」ツつサテ」ツδォテ」ツ?古」ツ?ゥテ」ツ?ョテ」ツつサテ」ツδォテ」ツ?ィテァツケツ凝」ツ?古」ツ?」テ」ツ?ヲテ」ツ??」ツつ凝」ツ??

set<P> isLeg;    //ティツカツウテ」ツ?ョテ、ツスツ催ァツスツョテ」ツつ津ィツィツ佚ヲツ?カ

set<P> isHead;   //テゥツ?ュテ」ツ?ョテ、ツスツ催ァツスツョテ」ツつ津ィツィツ佚ヲツ?カ



int dx[] = {0, 1, 0, -1};

int dy[] = {-1, 0, 1, 0};



bool dfs(P leg, P head){

  isLeg.insert(leg);

  isHead.insert(head);



  for(int i = 0; i < 4; i++){

    P nleg(leg.first + dx[i], leg.second + dy[i]);



    if(nleg == head) continue;

    if(isHead.find(nleg) != isHead.end()) return false;

    if(isLeg.find(nleg) != isLeg.end()) continue;

    if(graph.find(nleg) == graph.end()) continue;



    P nhead = graph[nleg];



    if(!dfs(nleg, nhead)) return false;

  }



  for(int i = 0; i < 4; i++){

    P nhead(head.first + dx[i], head.second + dy[i]);



    if(nhead == leg) continue;

    if(isHead.find(nhead) != isHead.end()) continue;

    if(isLeg.find(nhead) != isLeg.end()) return false;

    if(graph.find(nhead) == graph.end()) continue;



    P nleg = graph[nhead];



    if(!dfs(nleg, nhead)) return false;

  }



  return true;

}



bool solve(){

  isHead.clear();

  isLeg.clear();



  map<P, P>::iterator iter = graph.begin();



  for( ; iter != graph.end(); iter++){

    P head = iter->first;

    P leg = iter->second;



    if(isLeg.find(head)  != isLeg.end())  continue;

    if(isHead.find(head) != isHead.end()) continue;



    if(!dfs(leg, head)) return false;

  }



  return true;

}



int main(){

  int n;



  while(cin >> n, n){

    graph.clear();



    for(int i = 0; i < n; i++){

      int x, y;

      char dir;

      cin >> x >> y >> dir;



      if(dir == 'x'){

        int nx = x + dx[RIGHT];

        int ny = y + dy[RIGHT];

        graph[P(x, y)]   = P(nx, ny);

        graph[P(nx, ny)] = P(x, y);

      }

      else{

        int nx = x + dx[TOP];

        int ny = y + dy[TOP];

        graph[P(x, y)]   = P(nx, ny);

        graph[P(nx, ny)] = P(x, y);

      }

    }



    cout << (solve() ? "Yes" : "No") << endl;

  }

}

// Fastest known solution for this problem: