using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
  class Program
    {

        public static int[] ReadIntArray()
        {
            return Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
        }
        public static void ReadIntPair(out int a, out int b)
        {
            var ar = ReadIntArray();
            a = ar[0];
            b = ar[1];
        }
        public static int ReadInt()
        {
            return int.Parse(Console.ReadLine());
        }
          static bool canFirst(int p1, int p2, string str, string ptrn)
        {
            for (int i = p1 + ptrn.Length; i < p2 + ptrn.Length; i++)
            {
                if (str[i] == '?') return true;
            }
            return false;
        }
        static bool canSecond(int p1, int p2, string str, string ptrn)
        {
            for (int i = p1; i < p2; i++)
            {
                if (str[i] == '?') return true;
            }
            return false;
        }

static void Main(string[] args){

            int t = ReadInt();
            for (int tt = 0; tt < t; tt++)
            {
                int n = ReadInt();
                var str = Console.ReadLine();

                string ptrn = "abacaba";

                int vpos = -1;
                Dictionary<int, string> candsd = new Dictionary<int, string>();
                List<int> cands = new List<int>();
                bool was = true;
                while (true)
                {
                     was = false;

                    int start = 0;
                    int pos = 0;
                    if (cands.Any())
                    {
                        start = cands.Last() + 1;
                    }
                    for (int i = start; i < str.Length; i++)
                    {
                        if (str[i] == ptrn[pos] || str[i] == '?')
                        {
                            pos++;
                            if (pos == ptrn.Length)
                            {
                                vpos = i - (ptrn.Length - 1);
                                cands.Add(vpos);
                                candsd.Add(vpos, str.Substring(vpos, ptrn.Length));
                                was = true;
                                break;
                            }
                        }
                        else
                        {
                            i -= pos;
                            pos = 0;
                        }
                    }
                    if (!was) break;
                }

                int[] del = new int[cands.Count];

                for (int i = 1; i < cands.Count; i++)
                {
                    if ((cands[i - 1] + ptrn.Length) > cands[i] && del[i - 1] != 1 && del[i] != 1)
                    {
                        if (!canFirst(cands[i - 1], cands[i], str, ptrn))
                        {
                            del[i - 1] = 1;
                        }
                        if (!canSecond(cands[i - 1], cands[i], str, ptrn))
                        {
                            del[i] = 1;
                        }
                    }
                }

                var ccnt = del.Count(z => z == 0);

                if (ccnt == 0)
                {
                    Console.WriteLine("NO");
                }
                else
                {

                    vpos = cands[ Array.IndexOf(del, 0)];
                    StringBuilder sb = new StringBuilder();
                    for (int i = 0; i < str.Length; i++)
                    {
                        if (i >= vpos && i < ptrn.Length)
                        {
                            sb.Append(ptrn[i - vpos]);
                        }
                        else
                        {
                            if (str[i] == '?')
                            {
                                sb.Append('z');
                            }
                            else
                            {
                                sb.Append(str[i]);
                            }

                        }
                    }

                    Console.WriteLine("YES");
                    Console.WriteLine(sb);

                }

            }

    }}


using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
  class Program
    {

        public static int[] ReadIntArray()
        {
            return Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
        }
        public static void ReadIntPair(out int a, out int b)
        {
            var ar = ReadIntArray();
            a = ar[0];
            b = ar[1];
        }
        public static int ReadInt()
        {
            return int.Parse(Console.ReadLine());
        }
      static bool canFirst(int p1, int p2, string str, string ptrn)
        {

            if (!ptrn.StartsWith(ptrn.Substring(p2 - p1)))
            {
                return true;
            }

            for (int i = p1 + ptrn.Length; i < p2 + ptrn.Length; i++)
            {
                if (str[i] == '?') return true;
            }
            return false;
        }
        static bool canSecond(int p1, int p2, string str, string ptrn)
        {
            if (!ptrn.EndsWith(ptrn.Substring(0, p2 - p1)))
            {
                return true;
            }
            for (int i = p1; i < p2; i++)
            {
                if (str[i] == '?') return true;
            }
            return false;
        }

static void Main(string[] args){

            int t = ReadInt();
            for (int tt = 0; tt < t; tt++)
            {
                int n = ReadInt();
                var str = Console.ReadLine();

                string ptrn = "abacaba";
 if (str.IndexOf(ptrn) != -1 && str.IndexOf(ptrn) != str.LastIndexOf(ptrn))
                {
                    Console.WriteLine("NO");
                    continue;
                }
                if (str.IndexOf(ptrn) != -1 && str.IndexOf(ptrn) == str.LastIndexOf(ptrn))
                {
                    Console.WriteLine("YES");
                    for (int i = 0; i < str.Length; i++)
                    {
                        if (str[i] == '?')
                        {
                            Console.Write('z');
                        }
                        else
                        {
                            Console.Write(str[i]);
                        }
                    }
                    Console.WriteLine();
                }

                int vpos = -1;
                Dictionary<int, string> candsd = new Dictionary<int, string>();
                List<int> cands = new List<int>();
                bool was = true;
                while (true)
                {
                     was = false;

                    int start = 0;
                    int pos = 0;
                    if (cands.Any())
                    {
                        start = cands.Last() + 1;
                    }
                    for (int i = start; i < str.Length; i++)
                    {
                        if (str[i] == ptrn[pos] || str[i] == '?')
                        {
                            pos++;
                            if (pos == ptrn.Length)
                            {
                                vpos = i - (ptrn.Length - 1);
                                cands.Add(vpos);
                                candsd.Add(vpos, str.Substring(vpos, ptrn.Length));
                                was = true;
                                break;
                            }
                        }
                        else
                        {
                            i -= pos;
                            pos = 0;
                        }
                    }
                    if (!was) break;
                }

                int[] del = new int[cands.Count];

                for (int i = 1; i < cands.Count; i++)
                {
                    if ((cands[i - 1] + ptrn.Length) > cands[i] && del[i - 1] != 1 && del[i] != 1)
                    {
                        if (!canFirst(cands[i - 1], cands[i], str, ptrn))
                        {
                            del[i - 1] = 1;
                        }
                        if (!canSecond(cands[i - 1], cands[i], str, ptrn))
                        {
                            del[i] = 1;
                        }
                    }
                }

                var ccnt = del.Count(z => z == 0);

                if (ccnt == 0)
                {
                    Console.WriteLine("NO");
                }
                else
                {

                    vpos = cands[ Array.IndexOf(del, 0)];
                    StringBuilder sb = new StringBuilder();
                    for (int i = 0; i < str.Length; i++)
                    {
                        if (i >= vpos && i < ptrn.Length)
                        {
                            sb.Append(ptrn[i - vpos]);
                        }
                        else
                        {
                            if (str[i] == '?')
                            {
                                sb.Append('z');
                            }
                            else
                            {
                                sb.Append(str[i]);
                            }

                        }
                    }

                    Console.WriteLine("YES");
                    Console.WriteLine(sb);

                }

            }

    }}


using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
  class Program
    {

        public static int[] ReadIntArray()
        {
            return Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
        }
        public static void ReadIntPair(out int a, out int b)
        {
            var ar = ReadIntArray();
            a = ar[0];
            b = ar[1];
        }
        public static int ReadInt()
        {
            return int.Parse(Console.ReadLine());
        }
           static bool canFirst(int p1, int p2, string str, string ptrn)
        {
            for (int i = p2; i < p2 + ptrn.Length; i++)
            {
                if (str[i] == '?') return true;
            }
            return false;
        }
        static bool canSecond(int p1, int p2, string str, string ptrn)
        {
            for (int i = p1; i < p2; i++)
            {
                if (str[i] == '?') return true;
            }
            return false;
        }

static void Main(string[] args){

            int t = ReadInt();
            for (int tt = 0; tt < t; tt++)
            {
                int n = ReadInt();
                var str = Console.ReadLine();

                string ptrn = "abacaba";

                int vpos = -1;
                Dictionary<int, string> candsd = new Dictionary<int, string>();
                List<int> cands = new List<int>();
                bool was = true;
                while (true)
                {
                     was = false;

                    int start = 0;
                    int pos = 0;
                    if (cands.Any())
                    {
                        start = cands.Last() + 1;
                    }
                    for (int i = start; i < str.Length; i++)
                    {
                        if (str[i] == ptrn[pos] || str[i] == '?')
                        {
                            pos++;
                            if (pos == ptrn.Length)
                            {
                                vpos = i - (ptrn.Length - 1);
                                cands.Add(vpos);
                                candsd.Add(vpos, str.Substring(vpos, ptrn.Length));
                                was = true;
                                break;
                            }
                        }
                        else
                        {
                            i -= pos;
                            pos = 0;
                        }
                    }
                    if (!was) break;
                }

                int[] del = new int[cands.Count];

                for (int i = 1; i < cands.Count; i++)
                {
                    if ((cands[i - 1] + ptrn.Length) > cands[i] && del[i - 1] != 1 && del[i] != 1)
                    {
                        if (!canFirst(cands[i - 1], cands[i], str, ptrn))
                        {
                            del[i - 1] = 1;
                        }
                        if (!canSecond(cands[i - 1], cands[i], str, ptrn))
                        {
                            del[i] = 1;
                        }
                    }
                }

                var ccnt = del.Count(z => z == 0);

                if (ccnt == 0)
                {
                    Console.WriteLine("NO");
                }
                else
                {

                    vpos = cands[ Array.IndexOf(del, 0)];
                    StringBuilder sb = new StringBuilder();
                    for (int i = 0; i < str.Length; i++)
                    {
                        if (i >= vpos && i < ptrn.Length)
                        {
                            sb.Append(ptrn[i - vpos]);
                        }
                        else
                        {
                            if (str[i] == '?')
                            {
                                sb.Append('z');
                            }
                            else
                            {
                                sb.Append(str[i]);
                            }

                        }
                    }

                    Console.WriteLine("YES");
                    Console.WriteLine(sb);

                }

            }

    }}


using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
  class Program
    {

        public static int[] ReadIntArray()
        {
            return Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
        }
        public static void ReadIntPair(out int a, out int b)
        {
            var ar = ReadIntArray();
            a = ar[0];
            b = ar[1];
        }
        public static int ReadInt()
        {
            return int.Parse(Console.ReadLine());
        }

static void Main(string[] args){

            int t = ReadInt();
            for (int tt = 0; tt < t; tt++)
            {
                int n = ReadInt();
                var str = Console.ReadLine();

                string ptrn = "abacaba";

                int vpos = -1;
                Dictionary<int, string> candsd = new Dictionary<int, string>();
                List<int> cands = new List<int>();
                bool was = true;
                while (true)
                {
                    was = false;

                    int start = 0;
                    int pos = 0;
                    if (cands.Any())
                    {
                        start = cands.Last() + 1;
                    }
                    for (int i = start; i < str.Length; i++)
                    {
                        if (str[i] == ptrn[pos] || str[i] == '?')
                        {
                            pos++;
                            if (pos == ptrn.Length)
                            {
                                vpos = i - (ptrn.Length - 1);
                                cands.Add(vpos);
                                candsd.Add(vpos, str.Substring(vpos, ptrn.Length));
                                was = true;
                                break;
                            }
                        }
                        else
                        {
                            i -= pos;
                            pos = 0;
                        }
                    }
                    if (!was) break;
                }

                if (cands.Count == 0)
                {
                    Console.WriteLine("NO");
                }
                else
                {

                    bool was2 = false;
                    foreach (var item in cands)
                    {
                        string str2 = str;
                        str2 = str2.Remove(item, ptrn.Length);
                        str2 = str2.Insert(item, ptrn);
                        if (str2.IndexOf(ptrn) == str2.LastIndexOf(ptrn))
                        {
                            Console.WriteLine("YES");
                            for (int i = 0; i < str2.Length; i++)
                            {
                                if (str2[i] == '?')
                                {
                                    Console.Write('z');
                                }
                                else
                                {
                                    Console.Write(str2[i]);
                                }
                            }
                            Console.WriteLine();
                            was2 = true;
                            break;
                        }
                    }
                    if (was2) continue;

                    Console.WriteLine("NO");

                }

            }

    }}


using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;

namespace Codeforces
{
    class A
    {
        private static ThreadStart s_threadStart = new A().Go;

        private void Go()
        {
            long T = GetInt();

            string pat = "abacaba";

            for (int t = 0; t < T; t++)
            {
                int n = GetInt();
                StringBuilder s = new StringBuilder(GetString());

                string ss = s.ToString();
                int index = ss.IndexOf(pat);
                if (index >= 0)
                {
                    if (ss.IndexOf(pat, index + 1) < 0)
                    {
                        Wl("Yes");
                        Wl(ss.Replace('?', 'z'));
                    }
                    else
                    {
                        Wl("No");
                    }
                    continue;
                }

                bool found = false;
                for (int i = 0; i + 7 <= n; i++)
                {
                    string old = s.ToString();
                    bool match = true;
                    for (int k = 0; k < 7; k++)
                    {
                        if (s[i + k] != pat[k] && s[i + k] != '?')
                        {
                            match = false;
                            break;
                        }
                        s[i + k] = pat[k];
                    }
                    if (match)
                    {
                        ss = s.ToString();
                        index = ss.IndexOf(pat);
                        if (ss.IndexOf(pat, index + 1) < 0)
                        {
                            Wl("Yes");
                            Wl(ss.Replace('?', 'z'));
                            found = true;
                            break;
                        }
                    }
                    s = new StringBuilder(old);
                    if (s[i] == '?')
                        s[i] = 'z';
                }

                if (!found)
                    Wl("No");
            }
        }

        #region Template

        private static StringBuilder output = new StringBuilder();

        public static void Main(string[] args)
        {
            System.Diagnostics.Stopwatch timer = new System.Diagnostics.Stopwatch();
            output.Length = 0;
            Thread main = new Thread(new ThreadStart(s_threadStart), 200 * 1024 * 1024);
            timer.Start();
            main.Start();
            main.Join();
            Console.Write(output);
            timer.Stop();
            Console.Error.WriteLine(timer.ElapsedMilliseconds);
        }

        private static IEnumerator<string> ioEnum;
        private static string GetString()
        {
            do
            {
                while (ioEnum == null || !ioEnum.MoveNext())
                {
                    ioEnum = Console.ReadLine().Split().AsEnumerable().GetEnumerator();
                }
            } while (string.IsNullOrEmpty(ioEnum.Current));

            return ioEnum.Current;
        }

        private static int GetInt()
        {
            return int.Parse(GetString());
        }

        private static long GetLong()
        {
            return long.Parse(GetString());
        }

        private static double GetDouble()
        {
            return double.Parse(GetString());
        }

        private static List<int> GetIntArr(int n)
        {
            List<int> ret = new List<int>(n);
            for (int i = 0; i < n; i++)
            {
                ret.Add(GetInt());
            }
            return ret;
        }

        private static void Wl<T>(T o)
        {
            W(o);
            output.Append(Console.Out.NewLine);
        }

        private static void Wl<T>(IEnumerable<T> enumerable)
        {
            W(enumerable);
            output.Append(Console.Out.NewLine);
        }

        private static void W<T>(T o)
        {
            if (o is double)
            {
                Wd((o as double?).Value, "");
            }
            else if (o is float)
            {
                Wd((o as float?).Value, "");
            }
            else
                output.Append(o.ToString());
        }

        private static void W<T>(IEnumerable<T> enumerable)
        {
            W(string.Join(" ", enumerable.Select(e => e.ToString()).ToArray()));
        }

        private static void Wd(double d, string format)
        {
            W(d.ToString(format, CultureInfo.InvariantCulture));
        }

        #endregion
    }
}


using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using CodeforcesRound657Div2.Extensions;
using CodeforcesRound657Div2.Questions;

namespace CodeforcesRound657Div2.Questions
{
    public class QuestionA : AtCoderQuestionBase
    {
        public override IEnumerable<object> Solve(TextReader inputStream)
        {
            var tests = inputStream.ReadInt();
            const string Abacaba = "abacaba";

            for (int t = 0; t < tests; t++)
            {
                int n = inputStream.ReadInt();
                var s = inputStream.ReadLine();
                var nonReplaces = 0;
                var replaces = 0;
                string replacedResult = null;
                string nonReplacedResult = null;

                for (int start = 0; start < s.Length - 6; start++)
                {
                    var ok = true;
                    var replaced = false;

                    for (int offset = 0; offset < Abacaba.Length; offset++)
                    {
                        var current = s[start + offset];
                        if (current == '?')
                        {
                            replaced = true;
                        }
                        else if (current != Abacaba[offset])
                        {
                            ok = false;
                            break;
                        }
                    }

                    if (ok)
                    {
                        var result = s.Substring(0, start).Replace('?', 'z') + Abacaba + s.Substring(start + Abacaba.Length).Replace('?', 'z');

                        replaces++;
                        if (replacedResult == null)
                        {
                            replacedResult = result;
                        }

                        if (!replaced)
                        {
                            nonReplaces++;
                            if (nonReplacedResult == null)
                            {
                                nonReplacedResult = result;
                            }

                        }
                    }
                }

                if (nonReplaces > 0)
                {
                    if (nonReplaces == 1)
                    {
                        yield return "Yes";
                        yield return nonReplacedResult;
                    }
                    else
                    {
                        yield return "No";
                    }
                }
                else if (replaces > 0)
                {
                    yield return "Yes";
                    yield return replacedResult;
                }
                else
                {
                    yield return "No";
                }
            }
        }
    }
}

namespace CodeforcesRound657Div2
{
    class Program
    {
        static void Main(string[] args)
        {
            IAtCoderQuestion question = new QuestionA();
            var answers = question.Solve(Console.In);

            var writer = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
            Console.SetOut(writer);
            foreach (var answer in answers)
            {
                Console.WriteLine(answer);
            }
            Console.Out.Flush();
        }
    }
}

#region Base Class

namespace CodeforcesRound657Div2.Questions
{

    public interface IAtCoderQuestion
    {
        IEnumerable<object> Solve(string input);
        IEnumerable<object> Solve(TextReader inputStream);
    }

    public abstract class AtCoderQuestionBase : IAtCoderQuestion
    {
        public IEnumerable<object> Solve(string input)
        {
            var stream = new MemoryStream(Encoding.Unicode.GetBytes(input));
            var reader = new StreamReader(stream, Encoding.Unicode);

            return Solve(reader);
        }

        public abstract IEnumerable<object> Solve(TextReader inputStream);
    }
}

#endregion

#region Extensions

namespace CodeforcesRound657Div2.Extensions
{
    public static class StringExtensions
    {
        public static string Join<T>(this IEnumerable<T> source) => string.Concat(source);
        public static string Join<T>(this IEnumerable<T> source, string separator) => string.Join(separator, source);
    }

    public static class TextReaderExtensions
    {
        public static int ReadInt(this TextReader reader) => int.Parse(ReadString(reader));
        public static long ReadLong(this TextReader reader) => long.Parse(ReadString(reader));
        public static double ReadDouble(this TextReader reader) => double.Parse(ReadString(reader));
        public static string ReadString(this TextReader reader) => reader.ReadLine();

        public static int[] ReadIntArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(int.Parse).ToArray();
        public static long[] ReadLongArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(long.Parse).ToArray();
        public static double[] ReadDoubleArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(double.Parse).ToArray();
        public static string[] ReadStringArray(this TextReader reader, char separator = ' ') => reader.ReadLine().Split(separator);

        // Supports primitive type only.
        public static T1 ReadValue<T1>(this TextReader reader) => (T1)Convert.ChangeType(reader.ReadLine(), typeof(T1));

        public static (T1, T2) ReadValue<T1, T2>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            return (v1, v2);
        }

        public static (T1, T2, T3) ReadValue<T1, T2, T3>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            return (v1, v2, v3);
        }

        public static (T1, T2, T3, T4) ReadValue<T1, T2, T3, T4>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            return (v1, v2, v3, v4);
        }

        public static (T1, T2, T3, T4, T5) ReadValue<T1, T2, T3, T4, T5>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            var v5 = (T5)Convert.ChangeType(inputs[4], typeof(T5));
            return (v1, v2, v3, v4, v5);
        }

        public static (T1, T2, T3, T4, T5, T6) ReadValue<T1, T2, T3, T4, T5, T6>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            var v5 = (T5)Convert.ChangeType(inputs[4], typeof(T5));
            var v6 = (T6)Convert.ChangeType(inputs[5], typeof(T6));
            return (v1, v2, v3, v4, v5, v6);
        }

        public static (T1, T2, T3, T4, T5, T6, T7) ReadValue<T1, T2, T3, T4, T5, T6, T7>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            var v5 = (T5)Convert.ChangeType(inputs[4], typeof(T5));
            var v6 = (T6)Convert.ChangeType(inputs[5], typeof(T6));
            var v7 = (T7)Convert.ChangeType(inputs[6], typeof(T7));
            return (v1, v2, v3, v4, v5, v6, v7);
        }
    }
}

#endregion


using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using CodeforcesRound657Div2.Extensions;
using CodeforcesRound657Div2.Questions;
using System.Threading;
using System.Runtime.InteropServices.ComTypes;

namespace CodeforcesRound657Div2.Questions
{
    public class QuestionA : AtCoderQuestionBase
    {
        public override IEnumerable<object> Solve(TextReader inputStream)
        {
            var tests = inputStream.ReadInt();
            const string Abacaba = "abacaba";

            for (int t = 0; t < tests; t++)
            {
                int n = inputStream.ReadInt();
                var s = inputStream.ReadLine();
                var composed = false;

                for (int start = 0; start < s.Length - 6; start++)
                {
                    var result = s.Substring(0, start).Replace('?', 'z') + Abacaba + s.Substring(start + Abacaba.Length).Replace('?', 'z');
                    var ok = true;

                    for (int offset = 0; offset < s.Length - 6; offset++)
                    {
                        if (offset == start)
                        {
                            for (int i = 0; i < Abacaba.Length; i++)
                            {
                                var c = s[offset + i];
                                if (c != Abacaba[i] && c != '?')
                                {
                                    ok = false;
                                }
                            }
                        }
                        else
                        {
                            if (s.Substring(offset, Abacaba.Length) == Abacaba)
                            {
                                ok = false;
                            }
                        }
                    }

                    if (ok)
                    {
                        composed = true;
                        yield return "Yes";
                        yield return result;
                        break;
                    }
                }

                if (!composed)
                {
                    yield return "No";
                }
            }
        }
    }
}

namespace CodeforcesRound657Div2
{
    class Program
    {
        static void Main(string[] args)
        {
            IAtCoderQuestion question = new QuestionA();
            var answers = question.Solve(Console.In);

            var writer = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
            Console.SetOut(writer);
            foreach (var answer in answers)
            {
                Console.WriteLine(answer);
            }
            Console.Out.Flush();
        }
    }
}

#region Base Class

namespace CodeforcesRound657Div2.Questions
{

    public interface IAtCoderQuestion
    {
        IEnumerable<object> Solve(string input);
        IEnumerable<object> Solve(TextReader inputStream);
    }

    public abstract class AtCoderQuestionBase : IAtCoderQuestion
    {
        public IEnumerable<object> Solve(string input)
        {
            var stream = new MemoryStream(Encoding.Unicode.GetBytes(input));
            var reader = new StreamReader(stream, Encoding.Unicode);

            return Solve(reader);
        }

        public abstract IEnumerable<object> Solve(TextReader inputStream);
    }
}

#endregion

#region Extensions

namespace CodeforcesRound657Div2.Extensions
{
    public static class StringExtensions
    {
        public static string Join<T>(this IEnumerable<T> source) => string.Concat(source);
        public static string Join<T>(this IEnumerable<T> source, string separator) => string.Join(separator, source);
    }

    public static class TextReaderExtensions
    {
        public static int ReadInt(this TextReader reader) => int.Parse(ReadString(reader));
        public static long ReadLong(this TextReader reader) => long.Parse(ReadString(reader));
        public static double ReadDouble(this TextReader reader) => double.Parse(ReadString(reader));
        public static string ReadString(this TextReader reader) => reader.ReadLine();

        public static int[] ReadIntArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(int.Parse).ToArray();
        public static long[] ReadLongArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(long.Parse).ToArray();
        public static double[] ReadDoubleArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(double.Parse).ToArray();
        public static string[] ReadStringArray(this TextReader reader, char separator = ' ') => reader.ReadLine().Split(separator);

        // Supports primitive type only.
        public static T1 ReadValue<T1>(this TextReader reader) => (T1)Convert.ChangeType(reader.ReadLine(), typeof(T1));

        public static (T1, T2) ReadValue<T1, T2>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            return (v1, v2);
        }

        public static (T1, T2, T3) ReadValue<T1, T2, T3>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            return (v1, v2, v3);
        }

        public static (T1, T2, T3, T4) ReadValue<T1, T2, T3, T4>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            return (v1, v2, v3, v4);
        }

        public static (T1, T2, T3, T4, T5) ReadValue<T1, T2, T3, T4, T5>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            var v5 = (T5)Convert.ChangeType(inputs[4], typeof(T5));
            return (v1, v2, v3, v4, v5);
        }

        public static (T1, T2, T3, T4, T5, T6) ReadValue<T1, T2, T3, T4, T5, T6>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            var v5 = (T5)Convert.ChangeType(inputs[4], typeof(T5));
            var v6 = (T6)Convert.ChangeType(inputs[5], typeof(T6));
            return (v1, v2, v3, v4, v5, v6);
        }

        public static (T1, T2, T3, T4, T5, T6, T7) ReadValue<T1, T2, T3, T4, T5, T6, T7>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            var v5 = (T5)Convert.ChangeType(inputs[4], typeof(T5));
            var v6 = (T6)Convert.ChangeType(inputs[5], typeof(T6));
            var v7 = (T7)Convert.ChangeType(inputs[6], typeof(T7));
            return (v1, v2, v3, v4, v5, v6, v7);
        }
    }
}

#endregion


using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using CodeforcesRound657Div2.Extensions;
using CodeforcesRound657Div2.Questions;
using System.Threading;
using System.Runtime.InteropServices.ComTypes;

namespace CodeforcesRound657Div2.Questions
{
    public class QuestionA : AtCoderQuestionBase
    {
        public override IEnumerable<object> Solve(TextReader inputStream)
        {
            var tests = inputStream.ReadInt();
            const string Abacaba = "abacaba";

            for (int t = 0; t < tests; t++)
            {
                int n = inputStream.ReadInt();
                var s = inputStream.ReadLine();
                var composed = false;

                for (int start = 0; start < s.Length - 6; start++)
                {
                    var result = s.Substring(0, start).Replace('?', 'z') + Abacaba + s.Substring(start + Abacaba.Length).Replace('?', 'z');
                    var ok = true;

                    for (int offset = 0; offset < s.Length - 6; offset++)
                    {
                        if (offset == start)
                        {
                            for (int i = 0; i < Abacaba.Length; i++)
                            {
                                var c = s[start + i];
                                if (c != Abacaba[i] && c != '?')
                                {
                                    ok = false;
                                }
                            }
                        }
                        else
                        {
                            if (result.Substring(offset, Abacaba.Length) == Abacaba)
                            {
                                ok = false;
                            }
                        }
                    }

                    if (ok)
                    {
                        yield return "Yes";
                        yield return result;
                        composed = true;
                        break;
                    }
                }

                if (!composed)
                {
                    yield return "No";
                }

            }
        }
    }
}

namespace CodeforcesRound657Div2
{
    class Program
    {
        static void Main(string[] args)
        {
            IAtCoderQuestion question = new QuestionA();
            var answers = question.Solve(Console.In);

            var writer = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
            Console.SetOut(writer);
            foreach (var answer in answers)
            {
                Console.WriteLine(answer);
            }
            Console.Out.Flush();
        }
    }
}

#region Base Class

namespace CodeforcesRound657Div2.Questions
{

    public interface IAtCoderQuestion
    {
        IEnumerable<object> Solve(string input);
        IEnumerable<object> Solve(TextReader inputStream);
    }

    public abstract class AtCoderQuestionBase : IAtCoderQuestion
    {
        public IEnumerable<object> Solve(string input)
        {
            var stream = new MemoryStream(Encoding.Unicode.GetBytes(input));
            var reader = new StreamReader(stream, Encoding.Unicode);

            return Solve(reader);
        }

        public abstract IEnumerable<object> Solve(TextReader inputStream);
    }
}

#endregion

#region Extensions

namespace CodeforcesRound657Div2.Extensions
{
    public static class StringExtensions
    {
        public static string Join<T>(this IEnumerable<T> source) => string.Concat(source);
        public static string Join<T>(this IEnumerable<T> source, string separator) => string.Join(separator, source);
    }

    public static class TextReaderExtensions
    {
        public static int ReadInt(this TextReader reader) => int.Parse(ReadString(reader));
        public static long ReadLong(this TextReader reader) => long.Parse(ReadString(reader));
        public static double ReadDouble(this TextReader reader) => double.Parse(ReadString(reader));
        public static string ReadString(this TextReader reader) => reader.ReadLine();

        public static int[] ReadIntArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(int.Parse).ToArray();
        public static long[] ReadLongArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(long.Parse).ToArray();
        public static double[] ReadDoubleArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(double.Parse).ToArray();
        public static string[] ReadStringArray(this TextReader reader, char separator = ' ') => reader.ReadLine().Split(separator);

        // Supports primitive type only.
        public static T1 ReadValue<T1>(this TextReader reader) => (T1)Convert.ChangeType(reader.ReadLine(), typeof(T1));

        public static (T1, T2) ReadValue<T1, T2>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            return (v1, v2);
        }

        public static (T1, T2, T3) ReadValue<T1, T2, T3>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            return (v1, v2, v3);
        }

        public static (T1, T2, T3, T4) ReadValue<T1, T2, T3, T4>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            return (v1, v2, v3, v4);
        }

        public static (T1, T2, T3, T4, T5) ReadValue<T1, T2, T3, T4, T5>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            var v5 = (T5)Convert.ChangeType(inputs[4], typeof(T5));
            return (v1, v2, v3, v4, v5);
        }

        public static (T1, T2, T3, T4, T5, T6) ReadValue<T1, T2, T3, T4, T5, T6>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            var v5 = (T5)Convert.ChangeType(inputs[4], typeof(T5));
            var v6 = (T6)Convert.ChangeType(inputs[5], typeof(T6));
            return (v1, v2, v3, v4, v5, v6);
        }

        public static (T1, T2, T3, T4, T5, T6, T7) ReadValue<T1, T2, T3, T4, T5, T6, T7>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            var v5 = (T5)Convert.ChangeType(inputs[4], typeof(T5));
            var v6 = (T6)Convert.ChangeType(inputs[5], typeof(T6));
            var v7 = (T7)Convert.ChangeType(inputs[6], typeof(T7));
            return (v1, v2, v3, v4, v5, v6, v7);
        }
    }
}

#endregion


using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using CodeforcesRound657Div2.Extensions;
using CodeforcesRound657Div2.Questions;
using System.Threading;
using System.Runtime.InteropServices.ComTypes;

namespace CodeforcesRound657Div2.Questions
{
    public class QuestionA : AtCoderQuestionBase
    {
        public override IEnumerable<object> Solve(TextReader inputStream)
        {
            var tests = inputStream.ReadInt();
            const string Abacaba = "abacaba";

            for (int t = 0; t < tests; t++)
            {
                int n = inputStream.ReadInt();
                var s = inputStream.ReadLine();
                var count = 0;
                string answer = null;

                for (int start = 0; start < s.Length - 6; start++)
                {
                    var result = s.Substring(0, start).Replace('?', 'z') + Abacaba + s.Substring(start + Abacaba.Length).Replace('?', 'z');
                    var ok = true;

                    for (int offset = 0; offset < s.Length - 6; offset++)
                    {
                        if (offset == start)
                        {
                            for (int i = 0; i < Abacaba.Length; i++)
                            {
                                var c = s[offset + i];
                                if (c != Abacaba[i] && c != '?')
                                {
                                    ok = false;
                                }
                            }
                        }
                        else
                        {
                            if (result.Substring(offset, Abacaba.Length) == Abacaba)
                            {
                                ok = false;
                            }
                        }
                    }

                    if (ok)
                    {
                        count++;
                        answer = result;
                    }
                }

                if (count == 1)
                {
                    yield return "Yes";
                    yield return answer;
                }
                else
                {
                    yield return "No";
                }
            }
        }
    }
}

namespace CodeforcesRound657Div2
{
    class Program
    {
        static void Main(string[] args)
        {
            IAtCoderQuestion question = new QuestionA();
            var answers = question.Solve(Console.In);

            var writer = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
            Console.SetOut(writer);
            foreach (var answer in answers)
            {
                Console.WriteLine(answer);
            }
            Console.Out.Flush();
        }
    }
}

#region Base Class

namespace CodeforcesRound657Div2.Questions
{

    public interface IAtCoderQuestion
    {
        IEnumerable<object> Solve(string input);
        IEnumerable<object> Solve(TextReader inputStream);
    }

    public abstract class AtCoderQuestionBase : IAtCoderQuestion
    {
        public IEnumerable<object> Solve(string input)
        {
            var stream = new MemoryStream(Encoding.Unicode.GetBytes(input));
            var reader = new StreamReader(stream, Encoding.Unicode);

            return Solve(reader);
        }

        public abstract IEnumerable<object> Solve(TextReader inputStream);
    }
}

#endregion

#region Extensions

namespace CodeforcesRound657Div2.Extensions
{
    public static class StringExtensions
    {
        public static string Join<T>(this IEnumerable<T> source) => string.Concat(source);
        public static string Join<T>(this IEnumerable<T> source, string separator) => string.Join(separator, source);
    }

    public static class TextReaderExtensions
    {
        public static int ReadInt(this TextReader reader) => int.Parse(ReadString(reader));
        public static long ReadLong(this TextReader reader) => long.Parse(ReadString(reader));
        public static double ReadDouble(this TextReader reader) => double.Parse(ReadString(reader));
        public static string ReadString(this TextReader reader) => reader.ReadLine();

        public static int[] ReadIntArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(int.Parse).ToArray();
        public static long[] ReadLongArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(long.Parse).ToArray();
        public static double[] ReadDoubleArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(double.Parse).ToArray();
        public static string[] ReadStringArray(this TextReader reader, char separator = ' ') => reader.ReadLine().Split(separator);

        // Supports primitive type only.
        public static T1 ReadValue<T1>(this TextReader reader) => (T1)Convert.ChangeType(reader.ReadLine(), typeof(T1));

        public static (T1, T2) ReadValue<T1, T2>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            return (v1, v2);
        }

        public static (T1, T2, T3) ReadValue<T1, T2, T3>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            return (v1, v2, v3);
        }

        public static (T1, T2, T3, T4) ReadValue<T1, T2, T3, T4>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            return (v1, v2, v3, v4);
        }

        public static (T1, T2, T3, T4, T5) ReadValue<T1, T2, T3, T4, T5>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            var v5 = (T5)Convert.ChangeType(inputs[4], typeof(T5));
            return (v1, v2, v3, v4, v5);
        }

        public static (T1, T2, T3, T4, T5, T6) ReadValue<T1, T2, T3, T4, T5, T6>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            var v5 = (T5)Convert.ChangeType(inputs[4], typeof(T5));
            var v6 = (T6)Convert.ChangeType(inputs[5], typeof(T6));
            return (v1, v2, v3, v4, v5, v6);
        }

        public static (T1, T2, T3, T4, T5, T6, T7) ReadValue<T1, T2, T3, T4, T5, T6, T7>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            var v5 = (T5)Convert.ChangeType(inputs[4], typeof(T5));
            var v6 = (T6)Convert.ChangeType(inputs[5], typeof(T6));
            var v7 = (T7)Convert.ChangeType(inputs[6], typeof(T7));
            return (v1, v2, v3, v4, v5, v6, v7);
        }
    }
}

#endregion


using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using CodeforcesRound657Div2.Extensions;
using CodeforcesRound657Div2.Questions;
using System.Threading;
using System.Runtime.InteropServices.ComTypes;

namespace CodeforcesRound657Div2.Questions
{
    public class QuestionA : AtCoderQuestionBase
    {
        public override IEnumerable<object> Solve(TextReader inputStream)
        {
            var tests = inputStream.ReadInt();
            const string Abacaba = "abacaba";

            for (int t = 0; t < tests; t++)
            {
                int n = inputStream.ReadInt();
                var s = inputStream.ReadLine();
                var count = 0;
                string answer = null;

                for (int start = 0; start < s.Length - 6; start++)
                {
                    var result = s.Substring(0, start).Replace('?', 'z') + Abacaba + s.Substring(start + Abacaba.Length).Replace('?', 'z');
                    var ok = true;

                    for (int offset = 0; offset < s.Length - 6; offset++)
                    {
                        if (offset == start)
                        {
                            for (int i = 0; i < Abacaba.Length; i++)
                            {
                                var c = s[offset + i];
                                if (c != Abacaba[i] && c != '?')
                                {
                                    ok = false;
                                }
                            }
                        }
                        else
                        {
                            if (s.Substring(offset, Abacaba.Length) == Abacaba)
                            {
                                ok = false;
                            }
                        }
                    }

                    if (ok)
                    {
                        count++;
                        answer = result;
                    }
                }
                if (count == 1)
                {
                    yield return "Yes";
                    yield return answer;
                }
                else
                {
                    yield return "No";
                }
            }
        }
    }
}

namespace CodeforcesRound657Div2
{
    class Program
    {
        static void Main(string[] args)
        {
            IAtCoderQuestion question = new QuestionA();
            var answers = question.Solve(Console.In);

            var writer = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
            Console.SetOut(writer);
            foreach (var answer in answers)
            {
                Console.WriteLine(answer);
            }
            Console.Out.Flush();
        }
    }
}

#region Base Class

namespace CodeforcesRound657Div2.Questions
{

    public interface IAtCoderQuestion
    {
        IEnumerable<object> Solve(string input);
        IEnumerable<object> Solve(TextReader inputStream);
    }

    public abstract class AtCoderQuestionBase : IAtCoderQuestion
    {
        public IEnumerable<object> Solve(string input)
        {
            var stream = new MemoryStream(Encoding.Unicode.GetBytes(input));
            var reader = new StreamReader(stream, Encoding.Unicode);

            return Solve(reader);
        }

        public abstract IEnumerable<object> Solve(TextReader inputStream);
    }
}

#endregion

#region Extensions

namespace CodeforcesRound657Div2.Extensions
{
    public static class StringExtensions
    {
        public static string Join<T>(this IEnumerable<T> source) => string.Concat(source);
        public static string Join<T>(this IEnumerable<T> source, string separator) => string.Join(separator, source);
    }

    public static class TextReaderExtensions
    {
        public static int ReadInt(this TextReader reader) => int.Parse(ReadString(reader));
        public static long ReadLong(this TextReader reader) => long.Parse(ReadString(reader));
        public static double ReadDouble(this TextReader reader) => double.Parse(ReadString(reader));
        public static string ReadString(this TextReader reader) => reader.ReadLine();

        public static int[] ReadIntArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(int.Parse).ToArray();
        public static long[] ReadLongArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(long.Parse).ToArray();
        public static double[] ReadDoubleArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(double.Parse).ToArray();
        public static string[] ReadStringArray(this TextReader reader, char separator = ' ') => reader.ReadLine().Split(separator);

        // Supports primitive type only.
        public static T1 ReadValue<T1>(this TextReader reader) => (T1)Convert.ChangeType(reader.ReadLine(), typeof(T1));

        public static (T1, T2) ReadValue<T1, T2>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            return (v1, v2);
        }

        public static (T1, T2, T3) ReadValue<T1, T2, T3>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            return (v1, v2, v3);
        }

        public static (T1, T2, T3, T4) ReadValue<T1, T2, T3, T4>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            return (v1, v2, v3, v4);
        }

        public static (T1, T2, T3, T4, T5) ReadValue<T1, T2, T3, T4, T5>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            var v5 = (T5)Convert.ChangeType(inputs[4], typeof(T5));
            return (v1, v2, v3, v4, v5);
        }

        public static (T1, T2, T3, T4, T5, T6) ReadValue<T1, T2, T3, T4, T5, T6>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            var v5 = (T5)Convert.ChangeType(inputs[4], typeof(T5));
            var v6 = (T6)Convert.ChangeType(inputs[5], typeof(T6));
            return (v1, v2, v3, v4, v5, v6);
        }

        public static (T1, T2, T3, T4, T5, T6, T7) ReadValue<T1, T2, T3, T4, T5, T6, T7>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            var v5 = (T5)Convert.ChangeType(inputs[4], typeof(T5));
            var v6 = (T6)Convert.ChangeType(inputs[5], typeof(T6));
            var v7 = (T7)Convert.ChangeType(inputs[6], typeof(T7));
            return (v1, v2, v3, v4, v5, v6, v7);
        }
    }
}

#endregion


using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using CodeforcesRound657Div2.Extensions;
using CodeforcesRound657Div2.Questions;
using System.Threading;

namespace CodeforcesRound657Div2.Questions
{
    public class QuestionA : AtCoderQuestionBase
    {
        public override IEnumerable<object> Solve(TextReader inputStream)
        {
            var tests = inputStream.ReadInt();
            const string Abacaba = "abacaba";

            for (int t = 0; t < tests; t++)
            {
                int n = inputStream.ReadInt();
                var s = inputStream.ReadLine();
                var composed = false;

                for (int start = 0; start < s.Length - 6; start++)
                {
                    var ok = true;

                    for (int offset = 0; offset < s.Length - 6; offset++)
                    {
                        if (offset == start)
                        {
                            for (int i = 0; i < Abacaba.Length; i++)
                            {
                                var current = s[offset + i];
                                if (current != Abacaba[i] && current != '?')
                                {
                                    ok = false;
                                }
                            }
                        }
                        else
                        {
                            if (s.Substring(offset, Abacaba.Length) == Abacaba)
                            {
                                ok = false;
                            }
                        }
                    }

                    if (ok)
                    {
                        composed = true;
                        yield return "Yes";
                        yield return s.Substring(0, start).Replace('?', 'z') + Abacaba + s.Substring(start + Abacaba.Length).Replace('?', 'z');
                        break;
                    }
                }

                if (!composed)
                {
                    yield return "No";
                }
            }
        }
    }
}

namespace CodeforcesRound657Div2
{
    class Program
    {
        static void Main(string[] args)
        {
            IAtCoderQuestion question = new QuestionA();
            var answers = question.Solve(Console.In);

            var writer = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
            Console.SetOut(writer);
            foreach (var answer in answers)
            {
                Console.WriteLine(answer);
            }
            Console.Out.Flush();
        }
    }
}

#region Base Class

namespace CodeforcesRound657Div2.Questions
{

    public interface IAtCoderQuestion
    {
        IEnumerable<object> Solve(string input);
        IEnumerable<object> Solve(TextReader inputStream);
    }

    public abstract class AtCoderQuestionBase : IAtCoderQuestion
    {
        public IEnumerable<object> Solve(string input)
        {
            var stream = new MemoryStream(Encoding.Unicode.GetBytes(input));
            var reader = new StreamReader(stream, Encoding.Unicode);

            return Solve(reader);
        }

        public abstract IEnumerable<object> Solve(TextReader inputStream);
    }
}

#endregion

#region Extensions

namespace CodeforcesRound657Div2.Extensions
{
    public static class StringExtensions
    {
        public static string Join<T>(this IEnumerable<T> source) => string.Concat(source);
        public static string Join<T>(this IEnumerable<T> source, string separator) => string.Join(separator, source);
    }

    public static class TextReaderExtensions
    {
        public static int ReadInt(this TextReader reader) => int.Parse(ReadString(reader));
        public static long ReadLong(this TextReader reader) => long.Parse(ReadString(reader));
        public static double ReadDouble(this TextReader reader) => double.Parse(ReadString(reader));
        public static string ReadString(this TextReader reader) => reader.ReadLine();

        public static int[] ReadIntArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(int.Parse).ToArray();
        public static long[] ReadLongArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(long.Parse).ToArray();
        public static double[] ReadDoubleArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(double.Parse).ToArray();
        public static string[] ReadStringArray(this TextReader reader, char separator = ' ') => reader.ReadLine().Split(separator);

        // Supports primitive type only.
        public static T1 ReadValue<T1>(this TextReader reader) => (T1)Convert.ChangeType(reader.ReadLine(), typeof(T1));

        public static (T1, T2) ReadValue<T1, T2>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            return (v1, v2);
        }

        public static (T1, T2, T3) ReadValue<T1, T2, T3>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            return (v1, v2, v3);
        }

        public static (T1, T2, T3, T4) ReadValue<T1, T2, T3, T4>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            return (v1, v2, v3, v4);
        }

        public static (T1, T2, T3, T4, T5) ReadValue<T1, T2, T3, T4, T5>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            var v5 = (T5)Convert.ChangeType(inputs[4], typeof(T5));
            return (v1, v2, v3, v4, v5);
        }

        public static (T1, T2, T3, T4, T5, T6) ReadValue<T1, T2, T3, T4, T5, T6>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            var v5 = (T5)Convert.ChangeType(inputs[4], typeof(T5));
            var v6 = (T6)Convert.ChangeType(inputs[5], typeof(T6));
            return (v1, v2, v3, v4, v5, v6);
        }

        public static (T1, T2, T3, T4, T5, T6, T7) ReadValue<T1, T2, T3, T4, T5, T6, T7>(this TextReader reader, char separator = ' ')
        {
            var inputs = ReadStringArray(reader, separator);
            var v1 = (T1)Convert.ChangeType(inputs[0], typeof(T1));
            var v2 = (T2)Convert.ChangeType(inputs[1], typeof(T2));
            var v3 = (T3)Convert.ChangeType(inputs[2], typeof(T3));
            var v4 = (T4)Convert.ChangeType(inputs[3], typeof(T4));
            var v5 = (T5)Convert.ChangeType(inputs[4], typeof(T5));
            var v6 = (T6)Convert.ChangeType(inputs[5], typeof(T6));
            var v7 = (T7)Convert.ChangeType(inputs[6], typeof(T7));
            return (v1, v2, v3, v4, v5, v6, v7);
        }
    }
}

#endregion


//using MetadataExtractor;
//using MetadataExtractor.Formats.Exif;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

namespace CodeForces
{
    public static class MainClass
    {

        static int ReadIntLine()
        {
            return int.Parse(Console.ReadLine());
        }

        static void ReadInt(ref int a)
        {
            a = ReadIntArrayLine()[0];
        }

        static void ReadInts(ref int a, ref int b)
        {
            var x = ReadIntArrayLine();
            a = x[0]; b = x[1];
        }

        static void ReadInts(ref int a, ref int b, ref int c)
        {
            var x = ReadIntArrayLine();
            a = x[0]; b = x[1]; c = x[2];
        }

        static void ReadInts(ref int a, ref int b, ref int c, ref int d)
        {
            var x = ReadIntArrayLine();
            a = x[0]; b = x[1]; c = x[2]; d = x[3];
        }

        static void ReadInts(ref int a, ref int b, ref int c, ref int d, ref int e)
        {
            var x = ReadIntArrayLine();
            a = x[0]; b = x[1]; c = x[2]; d = x[3]; e = x[4];
        }

        static void ReadInts(ref int a, ref int b, ref int c, ref int d, ref int e, ref int f)
        {
            var x = ReadIntArrayLine();
            a = x[0]; b = x[1]; c = x[2]; d = x[3]; e = x[4]; f = x[5];
        }

        static int[] ReadIntArrayLine()
        {
            char[] sep = { ' ' };
            return Console.ReadLine().Split(sep, StringSplitOptions.RemoveEmptyEntries).Select(x => int.Parse(x)).ToArray();
        }

        static void PrintLn(object obj)
        {
            Console.WriteLine(obj.ToString());
        }

        /*public static string Reverse(string s)
        {
            char[] charArray = s.ToCharArray();
            Array.Reverse(charArray);
            return new string(charArray);
        }*/

        public static void PrintLnCollection<T>(IEnumerable<T> col)
        {
            PrintLn(string.Join(" ", col));
        }

        public static void PrintLn(params object[] v)
        {
            PrintLnCollection(v);
        }

        public static string ReadLine()
        {
            return Console.ReadLine();
        }

        public static string MySubstring(this string str, int start, int finish)
        {
            if (start > finish) return "";
            return str.Substring(start, finish - start + 1);
        }

        public static string Reverse(this string str)
        {
            if (str == null) return null;

            return new string(str.ToArray().Reverse().ToArray());
        }
        public static bool IsInRange(this int a, int lb, int ub)
        {
            return (a >= lb) && (a <= ub);
        }

        private static void mergeDS(int i, int j, int[] a)
        {
            int t = a[j];
            for (int ii = 0; ii < a.Length; ii++)
            {
                if (a[ii] == t)
                    a[ii] = a[i];
            }
        }

        private static T MyMax<T>(params T[] a)
        {
            return a.Max();
        }

        private static T MyMin<T>(params T[] a)
        {
            return a.Min();
        }

        private static int[] GetPrimesLessThan(int x)
        {
            if (x < 2)
                return new int[0];

            int[] a = new int[x];

            a[0] = 1; a[1] = 1;

            for (int i = 0; i < a.Length; i++)
            {
                if (a[i] == 0)
                    for (int j = 2 * i; j < a.Length; j += i)
                    {
                        a[j] = 1;
                    }
            }

            var abc = new List<int>(x);

            for (int i = 0; i < a.Length; i++)
            {
                if (a[i] == 0)
                    abc.Add(i);
            }

            return abc.ToArray();
        }

        private static int FindNearestLEQElementInTheArray(int[] a, int startIndex, int endIndex, int target)
        {
            if (startIndex == endIndex)
            {
                if (a[startIndex] <= target)
                    return startIndex;
                else
                    return -1;
            }

            if (startIndex + 1 == endIndex)
            {
                if (a[endIndex] <= target)
                    return endIndex;
                else if (a[startIndex] <= target)
                    return startIndex;
                else
                    return -1;
            }

            int mid = (startIndex + endIndex) / 2;
            if (target == a[mid])
                return mid;
            else if (target < a[mid])
                return FindNearestLEQElementInTheArray(a, startIndex, mid - 1, target);
            else
                return FindNearestLEQElementInTheArray(a, mid, endIndex, target);
        }

        private static int FindNearestLEQElementInTheArray(int[] a, int target)
        {
            return FindNearestLEQElementInTheArray(a, 0, a.Length - 1, target);
        }

        private static int FindRightMostLEQElementInTheArray(int[] a, int startIndex, int endIndex, int target)
        {
            if (startIndex == endIndex)
            {
                if (a[startIndex] <= target)
                    return startIndex;
                else
                    return -1;
            }

            if (startIndex + 1 == endIndex)
            {
                if (a[endIndex] <= target)
                    return endIndex;
                else if (a[startIndex] <= target)
                    return startIndex;
                else
                    return -1;
            }

            int mid = (startIndex + endIndex) / 2;
            if (target < a[mid])
                return FindRightMostLEQElementInTheArray(a, startIndex, mid - 1, target);
            else
                return FindRightMostLEQElementInTheArray(a, mid, endIndex, target);
        }

        private static int FindRightMostLEQElementInTheArray(int[] a, int target)
        {
            return FindRightMostLEQElementInTheArray(a, 0, a.Length - 1, target);
        }

        private static int gcd(int a, int b)
        {

            int r = a % b;
            while (r != 0)
            {
                a = b;
                b = r;
                r = a % b;
            }
            return b;
        }

        //----------------------------------------------------------------------------

        static string GetSha1(string filePath)
        {
            using (FileStream fs = new FileStream(filePath, FileMode.Open))
            using (BufferedStream bs = new BufferedStream(fs))
            {
                using (SHA1Managed sha1 = new SHA1Managed())
                {
                    byte[] hash = sha1.ComputeHash(bs);
                    StringBuilder formatted = new StringBuilder(2 * hash.Length);
                    foreach (byte b in hash)
                    {
                        formatted.AppendFormat("{0:X2}", b);
                    }

                    return formatted.ToString();
                }
            }
        }

        static bool canFit(int a1, int b1, int a2, int b2)
        {
            int[] r1 = { a1, b1 };
            int[] r2 = { a2, b2 };

            Array.Sort(r1);
            Array.Sort(r2);

            bool ans = (r1[0] <= r2[0]) && (r1[1] <= r2[1]);

            return ans;

        }

        class Pair
        {
            public int first { get; set; }
            public int second { get; set; }
        }

        class Coord
        {
            public int x;
            public int y;
            public double d;
        }

        public static double dist(int x1, int y1, int x2, int y2)
        {
            int dx = x2 - x1;
            int dy = y2 - y1;

            return Math.Sqrt(dx * dx + dy * dy);

        }
        static void Main(string[] args)
        {
            //Console.Out.Flush();

            int tt = ReadIntLine();

            while (tt-- > 0)
            {
                int n = ReadIntLine();
                //int[] a = ReadIntArrayLine();
                var s = ReadLine();

                var p = "abacaba";

                bool success = false;
                var s1 = "";

                for (int i = 0; i < s.Length - 6; i++)
                {
                    int t = 0;
                    bool match = false;
                    int l = i;
                    while (s[l] == p[t] || s[l] == '?')
                    {
                        t++;
                        l++;
                        if (t == p.Length)
                        {
                            match = true;
                            break;
                        }
                    }

                    if (match)
                    {
                        s1 = s.MySubstring(0, i-1 ) + p + s.Substring(i + p.Length);
                        if (countOc(s1,p) == 1)
                        {
                            success = true;

                            var s2 = s1;
                            s1 = "";
                            for (int j = 0; j < s2.Length; j++)
                            {
                                if (s2[j] == '?')
                                    s1 += 'z';
                                else
                                    s1 += s2[j];
                            }

                            break;
                        }

                    }

                }

                if (success)
                {
                    PrintLn("YES");
                    PrintLn(s1);
                }
                else
                    PrintLn("NO");

            } //while tt

        } //main
          //ReadInts(ref a, ref b);
          //int n = ReadIntLine();
          //int[] a = ReadIntArrayLine();
          // li.Sort((a, b) => b.CompareTo(a)); DESC

        static int countOc(string src, string pattern)
        {

            var s = src;
            int ans = 0;
            int k = s.IndexOf(pattern);

            while (k >= 0)
            {
                ans++;
                s = s.Substring(k + 1);
                k = s.IndexOf(pattern);
            }

            return ans;

        }

    }

}


#![allow(dead_code)]
#![allow(unused_imports)]

use std::cmp::*;
use std::collections::*;
use std::io;
use std::ops;
use std::str::FromStr;

#[derive(Clone, Debug, Default)]
struct ProblemState {
}

impl Problem {
    fn solve(&mut self) {
        let n: usize = self.scan();
        let s: Vec<char> = self.scan_line().chars().collect();
        let w: Vec<char> = vec!['a', 'b', 'a', 'c', 'a', 'b', 'a'];

        for i in 0..n - 6 {
            let mut t = s.clone();

            for j in 0..7 {
                if t[i + j] == '?' {
                    t[i + j] = w[j];
                }
            }

            let mut k = 0;

'outer:
            for i in 0..n - 6 {
                for j in 0..7 {
                    if t[i + j] != w[j] {
                        continue 'outer;
                    }
                }

                k += 1;
            }

            if k == 1 {
                println!("Yes");

                for i in 0..n {
                    print!("{}", if t[i] == '?' { 'x' } else { t[i] });
                }

                println!();
                return;
            }
        }

        println!("No");
    }
}

fn main() {
    Problem::new().solve_cases();
}

struct Problem {
    input_state: InputState,
    problem_state: ProblemState,
}

struct InputState {
    stdin: io::Stdin,
    buffer: String,
    tokens: VecDeque<String>,
}

impl Problem {
    fn new() -> Self {
        Self {
            input_state: InputState {
                stdin: io::stdin(),
                buffer: String::new(),
                tokens: VecDeque::new(),
            },
            problem_state: Default::default(),
        }
    }

    fn solve_cases(&mut self) {
        for _ in 0usize..self.scan() {
            self.solve()
        }
    }

    fn scan<T: FromStr>(&mut self) -> T {
        while self.input_state.tokens.is_empty() {
            self.input_state.stdin.read_line(&mut self.input_state.buffer).unwrap();

            for token in self.input_state.buffer.split_ascii_whitespace() {
                self.input_state.tokens.push_back(token.to_string());
            }

            self.input_state.buffer.clear();
        }

        self.input_state.tokens.pop_front().unwrap().parse().ok().unwrap()
    }

    fn scan_vec<T: FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).into_iter().map(|_| self.scan()).collect()
    }

    fn scan_line(&mut self) -> String {
        let mut line = String::new();
        self.input_state.stdin.read_line(&mut line).unwrap();
        while line.ends_with('\n') || line.ends_with('\r') { line.pop(); }
        line
    }

    fn scan_line_vec(&mut self, n: usize) -> Vec<String> {
        (0..n).into_iter().map(|_| self.scan_line()).collect()
    }
}

impl ops::Deref for Problem {
    type Target = ProblemState;

    fn deref(&self) -> &ProblemState {
        &self.problem_state
    }
}

impl ops::DerefMut for Problem {
    fn deref_mut(&mut self) -> &mut ProblemState {
        &mut self.problem_state
    }
}


#![allow(unused_parens)]
#![allow(unused_imports)]
#![allow(non_upper_case_globals)]
#![allow(non_snake_case)]
#![allow(unused_mut)]
#![allow(unused_variables)]
#![allow(dead_code)]

#[allow(unused_macros)]
macro_rules! invec {
    ( $ t : ty ) => {{
        let mut s = String::new();
        match std::io::stdin().read_line(&mut s) {
            Ok(0) => Vec::<$t>::new(),
            Ok(n) => s
                .trim()
                .split_whitespace()
                .map(|s| s.parse::<$t>().unwrap())
                .collect::<Vec<$t>>(),
            Err(_) => Vec::<$t>::new(),
        }
    }};
}

#[allow(unused_macros)]
macro_rules! get {
      ($t:ty) => {
          {
              let mut line: String = String::new();
              std::io::stdin().read_line(&mut line).unwrap();
              line.trim().parse::<$t>().unwrap()
          }
      };
      ($($t:ty),*) => {
          {
              let mut line: String = String::new();
              std::io::stdin().read_line(&mut line).unwrap();
              let mut iter = line.split_whitespace();
              (
                  $(iter.next().unwrap().parse::<$t>().unwrap(),)*
              )
          }
      };
      ($t:ty; $n:expr) => {
          (0..$n).map(|_|
              get!($t)
          ).collect::<Vec<_>>()
      };
      ($($t:ty),*; $n:expr) => {
          (0..$n).map(|_|
              get!($($t),*)
          ).collect::<Vec<_>>()
      };
      ($t:ty ;;) => {
          {
              let mut line: String = String::new();
              std::io::stdin().read_line(&mut line).unwrap();
              line.split_whitespace()
                  .map(|t| t.parse::<$t>().unwrap())
                  .collect::<Vec<_>>()
          }
      };
      ($t:ty ;; $n:expr) => {
          (0..$n).map(|_| get!($t ;;)).collect::<Vec<_>>()
      };
}

#[allow(unused_macros)]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};

    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
    ($iter:expr, mut $var:ident : $t:tt $($r:tt)*) => {
        let mut $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

#[allow(unused_macros)]
macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };

    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };

    ($next:expr, [$t:tt]) => {
        {
            let len = read_value!($next, usize);
            (0..len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
        }
    };
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };

    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };

    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

#[allow(unused_macros)]
#[cfg(debug_assertions)]
macro_rules! mydbg {
    //($arg:expr) => (dbg!($arg))
    //($arg:expr) => (println!("{:?}",$arg));
      ($($a:expr),*) => {
          eprintln!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
      }
}
#[cfg(not(debug_assertions))]
macro_rules! mydbg {
    ($($arg:expr),*) => {};
}

macro_rules! echo {
    ($($a:expr),*) => {
          $(println!("{}",$a))*
      }
}

use std::cmp::*;
use std::collections::*;
use std::ops::{Add, Div, Mul, Sub};

#[allow(dead_code)]
static INF_I64: i64 = i64::max_value() / 2;
#[allow(dead_code)]
static INF_I32: i32 = i32::max_value() / 2;
#[allow(dead_code)]
static INF_USIZE: usize = usize::max_value() / 2;
#[allow(dead_code)]
static M_O_D: usize = 1000000007;
#[allow(dead_code)]
static PAI: f64 = 3.1415926535897932;

trait IteratorExt: Iterator {
    fn toVec(self) -> Vec<Self::Item>;
}

impl<T: Iterator> IteratorExt for T {
    fn toVec(self) -> Vec<Self::Item> {
        self.collect()
    }
}

trait CharExt {
    fn toNum(&self) -> usize;
    fn toAlphabetIndex(&self) -> usize;
    fn toNumIndex(&self) -> usize;
}
impl CharExt for char {
    fn toNum(&self) -> usize {
        return *self as usize;
    }
    fn toAlphabetIndex(&self) -> usize {
        return self.toNum() - 'a' as usize;
    }
    fn toNumIndex(&self) -> usize {
        return self.toNum() - '0' as usize;
    }
}

trait VectorExt {
    fn joinToString(&self, s: &str) -> String;
}
impl<T: ToString> VectorExt for Vec<T> {
    fn joinToString(&self, s: &str) -> String {
        return self
            .iter()
            .map(|x| x.to_string())
            .collect::<Vec<_>>()
            .join(s);
    }
}

trait StringExt {
    fn get_reverse(&self) -> String;
}
impl StringExt for String {
    fn get_reverse(&self) -> String {
        self.chars().rev().collect::<String>()
    }
}

trait UsizeExt {
    fn pow(&self, n: usize) -> usize;
}
impl UsizeExt for usize {
    fn pow(&self, n: usize) -> usize {
        return ((*self as u64).pow(n as u32)) as usize;
    }
}

fn main() {
    let T = get!(usize);
    'outer: for testcase in 0..T {
        mydbg!(testcase);
        let mut ans: usize = 0;
        let N = get!(usize);
        let mut s = get!(String).chars().toVec();
        let abacaba = "abacaba".chars().toVec();
        let mut p = 0;
        for i in (0..N - abacaba.len() + 1).rev() {
            let mut flag = true;
            for j in 0..abacaba.len() {
                if s[i + j] != abacaba[j] {
                    flag = false;
                    break;
                }
            }
            if flag {
                p += 1;
            }
        }
        if p == 1 {
            echo!("Yes");
            for i in 0..N {
                if s[i] == '?' {
                    s[i] = 'z';
                }
            }
            echo!(s.joinToString(""));
            continue 'outer;
        } else if p >= 2 {
            echo!("NO");
            continue 'outer;
        }
        for i in (0..N - abacaba.len() + 1).rev() {
            let mut flag = true;
            for j in 0..abacaba.len() {
                mydbg!(i, j, s[i + j], abacaba[j]);
                if s[i + j] != '?' && s[i + j] != abacaba[j] {
                    flag = false;
                    break;
                }
            }
            if flag {
                echo!("Yes");
                for j in 0..abacaba.len() {
                    if s[i + j] == '?' {
                        s[i + j] = abacaba[j];
                    }
                }
                for j in 0..N {
                    if s[j] == '?' {
                        s[j] = 'z';
                    }
                }
                echo!(s.joinToString(""));
                continue 'outer;
            }
        }
        echo!("NO");
    }
}