#define LOCAL
#define _USE_MATH_DEFINES
#include <array>
#include <cassert>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <iomanip>
#include <string>
#include <sstream>
#include <vector>
#include <queue>
#include <stack>
#include <list>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <complex>
#include <cmath>
#include <numeric>
#include <bitset>
#include <functional>
#include <random>
#include <ctime>

using namespace std;

template <typename A, typename B>
ostream& operator <<(ostream& out, const pair<A, B>& a) {
  out << "(" << a.first << "," << a.second << ")";
  return out;
}
template <typename T, size_t N>
ostream& operator <<(ostream& out, const array<T, N>& a) {
  out << "["; bool first = true;
  for (auto& v : a) { out << (first ? "" : ", "); out << v; first = 0;} out << "]";
  return out;
}
template <typename T>
ostream& operator <<(ostream& out, const vector<T>& a) {
  out << "["; bool first = true;
  for (auto& v : a) { out << (first ? "" : ", "); out << v; first = 0;} out << "]";
  return out;
}
template <typename T, class Cmp>
ostream& operator <<(ostream& out, const set<T, Cmp>& a) {
  out << "{"; bool first = true;
  for (auto& v : a) { out << (first ? "" : ", "); out << v; first = 0;} out << "}";
  return out;
}
template <typename U, typename T, class Cmp>
ostream& operator <<(ostream& out, const map<U, T, Cmp>& a) {
  out << "{"; bool first = true;
  for (auto& p : a) { out << (first ? "" : ", "); out << p.first << ":" << p.second; first = 0;} out << "}";
  return out;
}
#ifdef LOCAL
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
#else
#define trace(...) 42
#endif
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
  cerr << name << ": " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
  const char* comma = strchr(names + 1, ',');
  cerr.write(names, comma - names) << ": " << arg1 << " |";
  __f(comma + 1, args...);
}

typedef long long int64;
typedef pair<int, int> ii;
const int INF = 1 << 29;
const int MOD = 1e9 + 7;
mt19937 mrand(random_device{}());
int rnd(int x) { return mrand() % x; }

struct fast_ios {
  fast_ios() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(10);
  };
} fast_ios_;

const int N = 1e5 + 10;
const int K = 3;
const int M = K * K * K;
bool dp[N][M];
ii rec[N][M];

int main() {
  int n;
  int A, B, C;
  scanf("%d%d%d%d", &n, &A, &B, &C);
  A = min(A, K - 1); B = min(B, K - 1); C = min(C, K - 1);
  dp[0][A + B * K + C * K * K] = true;
  char s[10];
  for (int i = 1; i <= n; ++i) {
    scanf("%s", s);
    auto& e = dp[i];
    auto& pre = rec[i];
    if (string(s) == "AB") {
      for (int k = 0; k < M; ++k) {
        if (!dp[i - 1][k]) continue;
        A = k % K; B = k / K % K; C = k / (K * K);
        if (A - 1 >= 0) {
          e[(A - 1) + min(B + 1, K - 1) * K + C * K * K] = true;
          pre[(A - 1) + min(B + 1, K - 1) * K + C * K * K] = {k, 1};
        }
        if (B - 1 >= 0) {
          e[min(A + 1, K - 1) + (B - 1) * K + C * K * K] = true;
          pre[min(A + 1, K - 1) + (B - 1) * K + C * K * K] = {k, 0};
        }
      }
    } else if (string(s) == "BC") {
      for (int k = 0; k < M; ++k) {
        if (!dp[i - 1][k]) continue;
        A = k % K; B = k / K % K; C = k / (K * K);
        if (B - 1 >= 0) {
          e[A + (B - 1) * K + min(C + 1, K - 1) * K * K] = true;
          pre[A + (B - 1) * K + min(C + 1, K - 1) * K * K] = {k, 2};
        }
        if (C - 1 >= 0) {
          e[A + min(B + 1, K - 1) * K + (C - 1) * K * K] = true;
          pre[A + min(B + 1, K - 1) * K + (C - 1) * K * K] = {k, 1};
        }
      }
    } else {
      for (int k = 0; k < M; ++k) {
        if (!dp[i - 1][k]) continue;
        A = k % K; B = k / K % K; C = k / (K * K);
        if (C - 1 >= 0) {
          e[min(A + 1, K - 1) + B * K + (C - 1) * K * K] = true;
          pre[min(A + 1, K - 1) + B * K + (C - 1) * K * K] = {k, 0};
        }
        if (A - 1 >= 0) {
          e[(A - 1) + B * K + min(C + 1, K - 1) * K * K] = true;
          pre[(A - 1) + B * K + min(C + 1, K - 1) * K * K] = {k, 2};
        }
      }
    }
  }
  int best_k = -1;
  for (int k = 0; k < M; ++k) if (dp[n][k]) best_k = k;
  if (best_k < 0) {
    puts("No");
  } else {
    puts("Yes");
    string ret;
    int k = best_k;
    for (int i = n; i >= 1; --i) {
      // trace(i, k, dp[i][k], rec[i][k]);
      ret += (char)('A' + rec[i][k].second);
      k = rec[i][k].first;
    }
    // trace(k);
    reverse(ret.begin(), ret.end());
    for (auto& c : ret) {
      printf("%c\n", c);
    }
  }
  return 0;
}


Measured memory_bytes: 27644