/*
PM 06:18 - 06:53
 */
#include<iostream>
#include<cstdio>
#include<cmath>
#include<vector>
#include<algorithm>
#include<cstring>
#include<string>
#include<cassert>
#include<climits>
#include<queue>

#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define IINF (INT_MAX)
#define ULLINF (ULLONG_MAX)
#define MAX_V 500

using namespace std;

typedef unsigned long long ull;

// Library - max_flow - begin

int V;

struct edge{
  int to,rev;
  ull cap;
  edge(int to=IINF,ull cap=ULLINF,int rev=IINF):to(to),cap(cap),rev(rev){}
};

vector<edge> G[MAX_V];
int level[MAX_V];
int iter[MAX_V];

void add_edge(int from,int to,ull cap){
  G[from].push_back(edge(to,cap,G[to].size()));
  G[to].push_back(edge(from,0,G[from].size()-1));
}

void bfs(int s){
  memset(level,-1,sizeof(level));
  queue<int> que;
  que.push(s);
  level[s] = 0;
  while(!que.empty()){
    int v = que.front(); que.pop();
    for(int i=0;i<G[v].size();i++){
      edge &e = G[v][i];
      if(e.cap > 0 && level[e.to] < 0){
	level[e.to] = level[v] + 1;
	que.push(e.to); 
      }
    }
  }
}

ull dfs(int v,int t,ull f){
  if(v == t)return f;
  for(int &i=iter[v];i<G[v].size();i++){
    edge &e = G[v][i];
    if(e.cap > 0 && level[v] < level[e.to]){
      ull d = dfs(e.to,t,min(f,e.cap));
      if(d > 0ULL){
	e.cap -= d;
	G[e.to][e.rev].cap += d;
	return d;
      }
    }
  }
  return 0;
}

ull max_flow(int s,int t){
  ull flow = 0;
  for(;;){

    bfs(s);
    if(level[t] < 0)return flow;
    memset(iter,0,sizeof(iter));
    ull f;
    while( ( f = dfs(s,t,ULLINF) ) > 0ULL ){
      flow += f;
    }
  }
}


// Library - max_flow - end

int N,c;
ull W,t;
string day;

inline int getIndex(const string& a)
{
  if(a[0] == 'M')return 1;
  if(a[0] == 'F')return 5;
  if(a[0] == 'W')return 3;
  if(a[0] == 'S')
    {
      if(a[1] == 'u')return 0;
      else           return 6;
    }
  if(a[0] == 'T')
    {
      if(a[1] == 'u')return 2;
      else           return 4;
    }
}

void init(){
  rep(i,V)G[i].clear();

}

int main(){
  
  while(cin >> N >> W,N|W){

    int sp = N + 7, gp = N + 8;
    ull sum = 0;
    V = gp + 1;

    init();

    for(int i=0;i<N;i++){
      cin >> t >> c;
      add_edge(sp,i,t);
      sum += t;
      for(int j=0;j<c;j++){
	cin >> day;
	int index = getIndex(day);
	add_edge(i,N+index,W);
      }
    }

    for(int i=0;i<7;i++){
      add_edge(N+i,gp,W);
    }
    /*
    cout << "graph---" <<endl;
    rep(i,V)
      {
	cout << "node = " << i << endl;
	rep(j,G[i].size())
	  {
	    cout << "( idex =" << G[i][j].to << "," << G[i][j].cap << ") ";
	  }
	cout << endl;
      }
    */
    ull res = max_flow(sp,gp);
    //cout << "res = " << res << endl;
    cout << ( ( res == sum ) ? "Yes" : "No" ) << endl;

  }
  return 0;
}