#include <iostream>
#include <string>
#include <algorithm>
#include <functional>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <cstdio>
#include <cmath>
#include <tuple>
#include <iomanip>
#include <numeric>
#include <unordered_map>
#include <sstream>
#include<limits.h>
#include<float.h>
#include<list>
#include <array>
#include <complex>
#include<stdio.h>
#include<string.h>
#include <bitset>
// #include<assert.h>
#include<random>
using namespace std;
#define int long long

#define I32_MAX 2147483647
#define I64_MAX 9223372036854775807LL
#define I64_MAX2 1223372036854775807LL
#define INF I64_MAX2
// #define MOD 1000000007
#define MOD 998244353 
#define MEM_SIZE 10000
#define DEBUG_OUT true
#define ALL(x) (x).begin(), (x).end()

template<typename T> void DEBUG(T e){if(DEBUG_OUT == false)return; std::cout << e <<" ";}
template<typename T> void DEBUG(const std::vector<T>& v){if(DEBUG_OUT == false)return;for(const auto& e : v){std::cout<< e << " "; } std::cout << std::endl;}
template<typename T> void DEBUG(const std::vector<std::vector<T> >& vv){if(DEBUG_OUT == false)return;for(const auto& v : vv){ DEBUG(v); } }
template<class T,class... Ts> void DEBUG(T d, Ts... e){if(DEBUG_OUT == false)return;DEBUG(d);DEBUG(e...);}
template <class T> void corner(bool flg, T hoge) {if (flg) {cout << hoge << endl; abort();}}
template< typename T1, typename T2 > inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }
template< typename T1, typename T2 > inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }

void solve(void)
{ 
  int N;
  vector<int> vec (3,0);
  cin>>N>>vec[0]>>vec[1]>>vec[2];
  vector<pair<int,int> > vp;
  for (int i = 0; i < N; i++)
  {
    char X,Y;
    cin>>X>>Y;
    vp.emplace_back(X-'A',Y - 'A');
  }
  int S = accumulate(ALL(vec),0);
  if(S== 0)
  {
    cout<<"No"<<endl;
    return;
  }
  vector<char> data;

  if(S== 1)
  {
    for (int i = 0; i < N; i++)
    {
      int X = vp[i].first;
      int Y = vp[i].second;
      if(vec[X] == 0 && vec[Y] == 0)
      {
        cout<<"No"<<endl;
        return;
      }
      else
      {
        if(vec[X] != 0)
        {
          vec[X]--;
          vec[Y]++;
          data.push_back('A' + Y);
        }
        else
        {
          vec[X]++;
          vec[Y]--;
          data.push_back('A' + X);
        }
        
      } 
    }
    cout<<"Yes"<<endl;
    for (int i = 0; i < N; i++)
    {
      cout<<data[i]<<endl;
    }
    
    return;
  }

    for (int i = 0; i < N; i++)
    {
      int X = vp[i].first;
      int Y = vp[i].second;
      if(vec[X] <= 0 && vec[Y] <= 0)
      {
        cout<<"No"<<endl;
        return;
      }

      else if((vec[0] + vec[1] + vec[2] == 2)&&(vec[X] == 1)&&(vec[Y] == 1)&&(i < N -1) &&(vp[i] != vp[i+1]))
      {
        vector<int> cnt(3,0);
        cnt[X]++;
        cnt[Y]++;
        cnt[vp[i+1].first]++;
        cnt[vp[i+1].second]++;
        for (int i = 0; i < 3; i++)
        {
          if(cnt[i] == 2)
          {
            // vec[i]++;
            if(i != X)
            {
              vec[X]--;
              vec[Y]++;
              data.push_back('A'+Y);

            }
            if(i != Y)
            {
              vec[Y]--;
              vec[X]++;
              data.push_back('A'+X);
            }
          }
        }
        

      }
      else if(vec[X] == 0 || vec[Y] == 0)
      {
        if(vec[X] == 0)
        {
          vec[X]++;
          vec[Y]--;
          data.push_back('A'+X);

        }
        else
        {
          vec[Y]++;
          vec[X]--;
          data.push_back('A'+Y);
        }
        
      }
      else
      {
        if(vec[X] < vec[Y])
        {
          vec[X]++;
          vec[Y]--;
          data.push_back('A'+X);
        }
        else
        {
          vec[Y]++;
          vec[X]--;
          data.push_back('A'+Y);
        }
        

      }
      
      
    }
    cout<<"Yes"<<endl;
  for (int i = 0; i < N; i++)
    {
      cout<<data[i]<<endl;
    }
    
  return;
}
int32_t main(int32_t argc, const char *argv[])
{
  std::ios::sync_with_stdio(false);
  std::cin.tie(0);

  std::cout << std::fixed;
  std::cout << std::setprecision(11);
  solve();

  return 0;
}


Measured memory_bytes: 5308