using System;
using System.Linq;
using System.Collections.Generic;

namespace Contest
{
  class Program
  {
    static void Main(string[] args)
    {
      ABC166.F();
    }
    class ABC166
    {
      public static void A()
      {
        var S = Read.Str();
        Console.WriteLine(S == "ABC" ? "ARC" : "ABC");
      }
      public static void B()
      {
        var N = Read.Int();
        var K = Read.Int();
        var count = new int[N];
        for(int i = 0; i < K; ++i)
        {
          var d = Read.Int();
          var A = Read.IntN();
          foreach(var a in A)
          {
            count[a - 1]++;
          }
        }
        Console.WriteLine(count.Count(x => x == 0));
      }
      public static void C()
      {
        var N = Read.Int();
        var M = Read.Int();
        var H = Read.LongN();
        var Adj = Read.AdjacencyList(N, M);
        var adjMax = new long[N];
        for(int v = 1; v <= N; ++v)
        {
          var h = H[v - 1];
          foreach(var w in Adj[v])
          {
            adjMax[w - 1] = Math.Max(adjMax[w - 1], h);
          }
        }
        Console.WriteLine(Enumerable.Range(0, N).Count(i => H[i] > adjMax[i]));
      }
      public static void D()
      {
        var X = Read.Long();
        var dict = new Dictionary<long, long>();
        for (long i = 0; i <= 1000; ++i)
        {
          dict.Add(i * i * i * i * i, i);
        }
        for (long i = 0; i <= 1000; ++i)
        {
          var A5 = i * i * i * i * i;
          if (dict.ContainsKey(A5 - X))
          {
            Console.WriteLine("{0} {1}", i, dict[A5 - X]);
            return;
          }
          if (dict.ContainsKey((X - A5)))
          {
            Console.WriteLine("{0} {1}", i, -dict[X - A5]);
            return;
          }
        }
      }
      public static void E()
      {
        var N = Read.Int();
        var A = Read.LongN();
        var AP = A.Select((x, i) => x + i + 1).ToArray();
        var AN = A.Select((x, i) => x - i - 1).ToArray();
        var freq = Util.Frequency(AN);
        long sum = 0;
        for(int i = 0; i < N; ++i)
        {
          var v = AP[i];
          sum += freq.ContainsKey(-v) ? freq[-v] - (AN[i] == -v ? 1 : 0) : 0;
        }
        Console.WriteLine(sum);
      }
      public static void F()
      {
        var N = Read.Int();
        var A = Read.Int();
        var B = Read.Int();
        var C = Read.Int();
        var S = Enumerable.Range(0, N).Select(i => Read.Str()).ToArray();
        var dp = new bool[343, N + 1];
        var hist = new char[343, N + 1];
        Func<int, int, int, int> F = (a, b, c) => a * 49 + b * 7 + c;
        dp[F(Math.Min(6, A), Math.Min(6, B), Math.Min(6, C)), 0] = true;
        for (int i = 0; i < N; ++i)
        {
          var s = S[i];
          int idx1 = -1, idx2 = -1;
          switch (s)
          {
            case "AB":
              idx1 = 0; idx2 = 1;
              break;
            case "AC":
              idx1 = 0; idx2 = 2;
              break;
            case "BC":
              idx1 = 1; idx2 = 2;
              break;
          }

          for (int v = 0; v < 343; ++v)
          {
            if (!dp[v, i]) { continue; }
            var X = new int[] { v / 49, (v / 7) % 7, v % 7 };
            if (X[idx1] > 0)
            {
              var Y = new int[] { X[0], X[1], X[2] };
              Y[idx1]--;
              Y[idx2] = Math.Min(6, Y[idx2] + 1);
              var n = Y[0] * 49 + Y[1] * 7 + Y[2];
              dp[n, i + 1] = true;
              hist[n, i + 1] = s[1];
            }
            if (X[idx2] > 0)
            {
              var Y = new int[] { X[0], X[1], X[2] };
              Y[idx2]--;
              Y[idx1] = Math.Min(6, Y[idx1] + 1);
              var n = Y[0] * 49 + Y[1] * 7 + Y[2];
              dp[n, i + 1] = true;
              hist[n, i + 1] = s[0];
            }
          }
        }
        int okIdx = -1;
        for (int i = 0; i < 343; ++i)
        {
          if (dp[i, N])
          {
            okIdx = i;break;
          }
        }
        if (okIdx < 0) { Console.WriteLine("No");return; }
        Console.WriteLine("Yes");
        List<char> history = new List<char>();
        {
          int v = okIdx;
          for (int i = N; i > 0; --i)
          {
            var X = new int[] { v / 49, (v / 7) % 7, v % 7 };
            var inc = hist[v, i];
            history.Add(inc);
            var dec = S[i - 1].Replace("" + inc, "")[0];
            var incIdx = inc - 'A';
            var decIdx = dec - 'A';
            var Y = new int[] { X[0], X[1], X[2] };
            Y[decIdx]++;
            var n = Y[0] * 49 + Y[1] * 7 + Y[2];
            if (dp[n, i - 1])
            {
              v = n;
            }
            else
            {
              Y[incIdx]--;
              n = Y[0] * 49 + Y[1] * 7 + Y[2];
              if (!dp[n, i - 1])
              {
                throw new Exception("Error!!!");
              }
              v = n;
            }
          }
        }
        history.Reverse();
        Console.WriteLine(String.Join(Environment.NewLine, history));
      }
    }
    class Util
    {
      public static readonly long P = 1000000007;
      public static long[] ASum(long[] array)
      {
        var res = new long[array.Length + 1];
        for (int i = 0; i < array.Length; ++i)
        {
          res[i + 1] = res[i] + array[i];
        }
        return res;
      }
      public static Dictionary<T, long> Frequency<T>(T[] array)
      {
        var dict = new Dictionary<T, long>();
        foreach (var a in array)
        {
          if (!dict.ContainsKey(a)) { dict.Add(a, 0); }
          dict[a]++;
        }
        return dict;
      }

      public static int Lowerbound<T1, T2>(SortedList<T1, T2> list, T1 x) where T1 : IComparable<T1>
      {
        return Lowerbound(list.Keys, x);
      }
      public static int Lowerbound<T>(IList<T> list, T x) where T : IComparable<T>
      {
        int min = 0;
        int max = list.Count;
        while (min < max)
        {
          var mid = (min + max) / 2;
          if (list[mid].CompareTo(x) >= 0)
          {
            max = mid;
          }
          else
          {
            min = mid + 1;
          }
        }
        return max;
      }
    }


    static class Read
{
static Queue<string> queue = new Queue<string>();
static void Enqueue() { var ss = Console.ReadLine().Split(' '); foreach (var s in ss) { queue.Enqueue(s); } }
public static int Int() { if (queue.Count == 0) { Enqueue(); } return Convert.ToInt32(queue.Dequeue()); }
public static long Long() { if (queue.Count == 0) { Enqueue(); } return Convert.ToInt64(queue.Dequeue()); }
public static string Str() { if (queue.Count == 0) { Enqueue(); } return queue.Dequeue(); }
public static int[] IntN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToInt32(s)).ToArray(); }
public static long[] LongN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToInt64(s)).ToArray(); }
public static ulong[] ULongN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToUInt64(s)).ToArray(); }
public static string[] StrN() { return Console.ReadLine().Split(' '); }
public static Tuple<int, int>[] TupleInt(int n) { List<Tuple<int, int>> list = new List<Tuple<int, int>>(); for (int i = 0; i < n; ++i) { var ab = Read.IntN(); list.Add(new Tuple<int, int>(ab[0], ab[1])); } return list.ToArray(); }
public static Tuple<long, long>[] TupleLong(int n) { List<Tuple<long, long>> list = new List<Tuple<long, long>>(); for (int i = 0; i < n; ++i) { var ab = Read.LongN(); list.Add(new Tuple<long, long>(ab[0], ab[1])); } return list.ToArray(); }
public static Tuple<string, string>[] TupleStr(int n) { List<Tuple<string, string>> list = new List<Tuple<string, string>>(); for (int i = 0; i < n; ++i) { var ab = Read.StrN(); list.Add(new Tuple<string, string>(ab[0], ab[1])); } return list.ToArray(); }
public static Tuple<double, double>[] TupleDouble(int n) { List<Tuple<double, double>> list = new List<Tuple<double, double>>(); for (int i = 0; i < n; ++i) { var ab = Read.LongN(); list.Add(new Tuple<double, double>(ab[0], ab[1])); } return list.ToArray(); }
public static long[,] LongMatrix(int r, int c) { var mat = new long[r, c]; for (int i = 0; i < r; ++i) { var x = Read.LongN(); for (int j = 0; j < c; ++j) { mat[i, j] = x[j]; } } return mat; }
public static Dictionary<int, HashSet<int>> AdjacencyList(int N, int M, bool isDirectional = false)
{
Dictionary<int, HashSet<int>> dict = new Dictionary<int, HashSet<int>>();
for (int i = 0; i <= N; ++i) { dict.Add(i, new HashSet<int>()); }
        for (int i = 0; i < M; ++i) { var ab = Read.IntN(); if (!dict[ab[0]].Contains(ab[1])) { dict[ab[0]].Add(ab[1]); } if (!isDirectional && !dict[ab[1]].Contains(ab[0])) { dict[ab[1]].Add(ab[0]); } }
        return dict;
}
public static Dictionary<int, Dictionary<int, long>> AdjacencyListWithWeight(int N, int M)
{
Dictionary<int, Dictionary<int, long>> dict = new Dictionary<int, Dictionary<int, long>>(); for (int i = 0; i <= N; ++i) { dict.Add(i, new Dictionary<int, long>()); }
for (int i = 0; i < M; ++i) { var ab = Read.IntN(); dict[ab[0]].Add(ab[1], ab[2]); dict[ab[1]].Add(ab[0], ab[2]); }
return dict;
}
}
    }
}


Measured memory_bytes: 111432