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

vector<int> P;                // parent
vector<int> divine;           // 0:not_checked, 1:true, -1:lie
map<int, vector<int>> groups; // <根、葉>
int m;

// 未完成

void init() {
  groups.clear();
  P = vector<int>(m + 1);
  divine = vector<int>(m + 1);
  for (int i = 1; i <= m; i++) {
    P[i] = i;
    groups[i].push_back(i);
  }
}
int root(int c) {
  if (P[c] == c)
    return c;
  return (P[c] = root(P[c]));
}
bool is_same_set(int a, int b) { return root(a) == root(b); }
// 子のgroupに入っている要素を親のgroupに移し替える。
void unite(int c, int p) {
  groups[root(p)].insert(groups[root(p)].end(), groups[root(c)].begin(),
                         groups[root(c)].end());
  groups.erase(root(c));
  P[root(c)] = root(p);
}
// 結合して子になるグループのdivineをすべて裏返してから結合
void r_unite(int c, int p) {
  for (int i : groups[root(c)]) {
    divine[i] *= -1;
  }
  unite(c, p);
}

int main() {
  int n, t, l;
  while (cin >> n >> t >> l) {
    if (!n && !t && !l)
      break;

    m = t + l;
    init();
    /* cout << m << endl; */
    // グループ分け
    for (int i = 0; i < n; i++) {
      int x, y;
      string a;
      cin >> x >> y >> a;
      int honest = (a == "yes") ? 1 : -1;
      if (x == y || is_same_set(x, y))
        continue;
      int reverse;
      if (divine[x]) {
        reverse = divine[x] * honest;
      } else {
        reverse = honest;
        divine[x] = 1;
      }
      assert(reverse != 0);
      if (divine[y] && reverse != divine[y])
        r_unite(y, x);
      else {
        unite(y, x);
        divine[y] = reverse;
      }
      assert(divine[y] != 0);
    }
    // test------------
    /* for (int i : groups[1]) { */
    /*   cout << i << ' ' << divine[i] << endl; */
    /* } */
    //----------------
    map<int, pair<int, int>> pair_t_l; //<root of group, <truth_teller, liar>>
    for (auto group = groups.begin(); group != groups.end(); ++group) {
      int t_teller = 0, liar = 0;
      for (int i : group->second) {
        if (divine[i] == 1)
          t_teller++;
        // 言及されていない人は嘘つきとみなす。
        else { // bug:{}をつけないと行を加えたときにつけ忘れる。
          divine[i] = -1;
          liar++;
        }
      }
      /* cout << t_teller << ' ' << liar << endl; */
      pair_t_l[group->first] = make_pair(t_teller, liar);
    }

    int num_g = groups.size();
    vector<vector<int>> dp(
        num_g + 1,
        vector<int>(
            t + 1, 0)); // dp[i][j]:i個のグループでj人の正直者を何通りつくれるか
    vector<vector<set<int>>> p_rev(
        num_g + 1, vector<set<int>>(t + 1)); //裏返るグループを保存する配列
    int gc = 0;
    // 動的計画法
    for (auto P = pair_t_l.begin(); P != pair_t_l.end(); ++P) {
      gc++;
      pair<int, int> p = P->second; //<truth_teller, liar>
      /* // もし正直者と嘘つきの数が同じなら答えはnoなので抜ける */
      /* if (p.first == p.second) { */
      /*   dp[num_g][t] = 10; */
      /*   break; */
      /* } */
      if (gc == 1) {
        dp[gc][p.first]++;
        dp[gc][p.second]++;
        /* cout << p.second << endl; */
        if (p.second <= t)
          p_rev.at(gc).at(p.second).insert(P->first);
      }
      for (int j = 0; j <= t; j++) { // bug:jを1から始めるとt=0のとき間違う
        /* cout << gc << ' ' << j << ' ' << p.first << ' ' << p.second << ' ' */
        /*      << dp[gc - 1][j] << endl; */
        if (p.first + j <= t) {
          dp[gc][p.first + j] += dp[gc - 1][j];
          if (dp[gc - 1][j]) {
            for (auto group : p_rev[gc - 1][j]) {
              p_rev[gc][p.first + j].insert(group);
            }
          }
        }
        if (p.second + j <= t) {
          dp[gc][p.second + j] += dp[gc - 1][j];
          /* assert(!(gc==2&&p.second+j==4)); */
          if (dp[gc - 1][j]) {
            for (auto group : p_rev[gc - 1][j]) {
              p_rev[gc][p.second + j].insert(group);
            }
            p_rev[gc][p.second + j].insert(P->first);
          }
          /* cout<<gc<<' '<<p.second+j<<' '<<dp[gc][p.second + j]<<endl; */
        }
      }
    }

    /* for (int i : divine) */
    /*   cout << i << endl; */
    vector<int> ans;
    for (int group : p_rev[num_g][t]) {
      /* cout<<1<<endl; */
      /* assert(groups.count(1)==0); */
      for (int person : groups[group]) {
        divine[person] *= -1;
      }
    }
    for (auto group = groups.begin(); group != groups.end(); ++group) {
      /* cout << group->first << ' '; */
      for (int person : group->second) {
        /* cout << person << ' '; */
        if (divine[person] == 1)
          ans.push_back(person);
      }
      /* cout << endl; */
    }
    sort(ans.begin(), ans.end());
    /* cout << groups.size() << endl; */
    /* cout << root(24) << endl; */

    if (dp[num_g][t] != 1) {
      cout << "no" << endl;
    } else {
      for (int i : ans)
        cout << i << endl;
      cout << "end" << endl;
    }
  }
}



Measured memory_bytes: 14724