process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readLine() {
    return inputString[currentLine++];
}

const S = 'abacaba'
const S_REGEX = /(?<!abac|abacab)[a?][b?][a?][c?][a?][b?][a?](?!caba|bacaba)/
function main() {
    const t = Number(readLine())
    for (let i = 0; i < t; i++) {
        const n = Number(readLine())
        const s = readLine()
        const index = s.indexOf(S)
        if (index !== -1) {
            if (s.indexOf(S, index + 1) !== -1) {
                console.log('No')
            } else {
                console.log('Yes')
                console.log(s.replace(/\?/g, 'd'))
            }
            continue
        }
        const replaced = s.replace(S_REGEX, S)
        if (replaced === s) {
            console.log('No')
        } else {
            console.log('Yes')
            console.log(replaced.replace(/\?/g, 'd'))
        }
    }
}


process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readLine() {
    return inputString[currentLine++];
}

const S = 'abacaba'
const S_REGEX = /[a?][b?][a?][c?][a?][b?][a?](?!caba)/
function main() {
    const t = Number(readLine())
    for (let i = 0; i < t; i++) {
        const n = Number(readLine())
        const s = readLine()
        const index = s.indexOf(S)
        if (index !== -1) {
            if (s.indexOf(S, index + 1) !== -1) {
                t === 6 && console.log('No')
            } else {
                t === 6 && console.log('Yes')
                t === 6 && console.log(s.replace(/\?/g, 'd'))
            }
            continue
        }
        const replaced = s.replace(S_REGEX, S)
        if (replaced === s) {
            t === 6 && console.log('No')
        } else {
            t === 6 && console.log('Yes')
            console.log(replaced.replace(/\?/g, 'd'))
            const replaced2 = replaced.replace(/\?/g, 'd')
            const index = replaced2.indexOf(S)
            const index2 = replaced2.indexOf(S, index + 1)
            if (index2 !== -1) {
                console.log(s, t, replaced2)
            }
        }
    }
}


process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readLine() {
    return inputString[currentLine++];
}

const S = 'abacaba'
const S_REGEX = /(?<!abac)[a?][b?][a?][c?][a?][b?][a?](?!caba)/
function main() {
    const t = Number(readLine())
    for (let i = 0; i < t; i++) {
        const n = Number(readLine())
        const s = readLine()
        const index = s.indexOf(S)
        if (index !== -1) {
            if (s.indexOf(S, index + 1) !== -1) {
                console.log('No')
            } else {
                console.log('Yes')
                console.log(s.replace(/\?/g, 'd'))
            }
            continue
        }
        const replaced = s.replace(S_REGEX, S)
        if (replaced === s) {
            console.log('No')
        } else {
            console.log('Yes')
            console.log(replaced.replace(/\?/g, 'd'))
        }
    }
}


process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readLine() {
    return inputString[currentLine++];
}

const S = 'abacaba'
const S_REGEX = /[a?][b?][a?][c?][a?][b?][a?]/
function main() {
    const t = Number(readLine())
    for (let i = 0; i < t; i++) {
        const n = Number(readLine())
        const s = readLine()
        const index = s.indexOf(S)
        if (index !== -1) {
            if (s.indexOf(S, index + 1) !== -1) {
                console.log('No')
            } else {
                console.log('Yes')
                console.log(s.replace(/\?/g, 'd'))
            }
            continue
        }
        const replaced = s.replace(S_REGEX, S)
        if (replaced === s) {
            console.log('No')
        } else {
            console.log('Yes')
            console.log(replaced.replace(/\?/g, 'd'))
        }
    }
}


process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readLine() {
    return inputString[currentLine++];
}

const S = 'abacaba'
const S_REGEX = /[a?][b?][a?][c?][a?][b?][a?](?!caba)/
function main() {
    const t = Number(readLine())
    for (let i = 0; i < t; i++) {
        const n = Number(readLine())
        const s = readLine()
        const index = s.indexOf(S)
        if (index !== -1) {
            if (s.indexOf(S, index + 1) !== -1) {
                console.log('No')
            } else {
                console.log('Yes')
                console.log(s.replace(/\?/g, 'd'))
            }
            continue
        }
        const replaced = s.replace(S_REGEX, S)
        if (replaced === s) {
            console.log('No')
        } else {
            console.log('Yes')
            console.log(replaced.replace(/\?/g, 'd'))
            const replaced2 = replaced.replace(/\?/g, 'd')
            const index = replaced2.indexOf(S)
            const index2 = replaced2.indexOf(S, index + 1)
            if (index2 !== -1) {
                throw new Error(s)
            }
        }
    }
}


process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readLine() {
    return inputString[currentLine++];
}

const S = 'abacaba'
const S_REGEX = /[a?][b?][a?][c?][a?][b?][a?](?!caba)/
function main() {
    const t = Number(readLine())
    for (let i = 0; i < t; i++) {
        const n = Number(readLine())
        const s = readLine()
        const index = s.indexOf(S)
        if (index !== -1) {
            if (s.indexOf(S, index + 1) !== -1) {
                console.log('No')
            } else {
                console.log('Yes')
                console.log(s.replace(/\?/g, 'd'))
            }
            continue
        }
        const replaced = s.replace(S_REGEX, S)
        if (replaced === s) {
            console.log('No')
        } else {
            console.log('Yes')
            console.log(replaced.replace(/\?/g, 'd'))
        }
    }
}


process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readLine() {
    return inputString[currentLine++];
}

const S = 'abacaba'
const S_REGEX = /[a?][b?][a?][c?][a?][b?][a?](?!caba)/
function main() {
    const t = Number(readLine())
    for (let i = 0; i < t; i++) {
        const n = Number(readLine())
        const s = readLine()
        const index = s.indexOf(S)
        if (index !== -1) {
            if (s.indexOf(S, index + 1) !== -1) {
                t === 6 && console.log('No')
            } else {
                t === 6 && console.log('Yes')
                t === 6 && console.log(s.replace(/\?/g, 'd'))
            }
            continue
        }
        const replaced = s.replace(S_REGEX, S)
        if (replaced === s) {
            t === 6 && console.log('No')
        } else {
            t === 6 && console.log('Yes')
            t === 6 && console.log(replaced.replace(/\?/g, 'd'))
            const replaced2 = replaced.replace(/\?/g, 'd')
            const index = replaced2.indexOf(S)
            const index2 = replaced2.indexOf(S, index + 1)
            if (index2 !== -1) {
                console.log(s, t, replaced2)
            }
        }
    }
}


process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readLine() {
    return inputString[currentLine++];
}

const S = 'abacaba'
const S_REGEX = /[a?][b?][a?][c?][a?][b?][a?](?!caba)/
function main() {
    const t = Number(readLine())
    for (let i = 0; i < t; i++) {
        const n = Number(readLine())
        const s = readLine()
        const index = s.indexOf(S)
        if (index !== -1) {
            if (s.indexOf(S, index + 1) !== -1) {
                t === 6 && console.log('No')
            } else {
                t === 6 && console.log('Yes')
                t === 6 && console.log(s.replace(/\?/g, 'd'))
            }
            continue
        }
        const replaced = s.replace(S_REGEX, S)
        if (replaced === s) {
            t === 6 && console.log('No')
        } else {
            t === 6 && console.log('Yes')
            console.log(replaced.replace(/\?/g, 'd'))
            const replaced2 = replaced.replace(/\?/g, 'd')
            const index = replaced2.indexOf(S)
            const index2 = replaced2.indexOf(S, index + 1)
            if (index2 !== -1) {
                console.log(s)
            }
        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using static System.Console;
using static System.Math;

namespace AtTest.CodeForces._1379
{
    class A
    {
        static void Main(string[] args)
        {
            var sw = new System.IO.StreamWriter(OpenStandardOutput()) { AutoFlush = false };
            SetOut(sw);

            Method(args);

            Out.Flush();
        }

        static void Method(string[] args)
        {
            int t = ReadInt();
            string key = "abacaba";
            for (int i = 0; i < t; i++)
            {
                int n = ReadInt();
                string s = Read();
                bool can = false;
                for (int j = 0; j + key.Length - 1 < n; j++)
                {
                    bool replacable = true;
                    for(int k = 0; k < key.Length; k++)
                    {
                        if (s[j + k] == key[k]
                            || s[j + k] == '?')
                        {
                            continue;
                        }

                        replacable = false;
                        break;
                    }

                    if (!replacable)
                    {
                        continue;
                    }

                    string left = s.Substring(0, j);
                    string right = s.Substring(j + key.Length);
                    left=left.Replace('?', 'z');
                    right=right.Replace('?', 'z');
                    string tmp = left + key + right;
                    int cnt = 0;
                    for(int k = 0; k + key.Length - 1 < n; k++)
                    {
                        if (tmp.Substring(k, key.Length) == key)
                        {
                            cnt++;
                        }
                    }

                    if (cnt == 1)
                    {
                        can = true;
                        WriteLine("Yes");
                        WriteLine(tmp);
                    }
                }

                if (!can)
                {
                    WriteLine("No");
                }
            }
        }

        private static string Read() { return ReadLine(); }
        private static char[] ReadChars() { return Array.ConvertAll(Read().Split(), a => a[0]); }
        private static int ReadInt() { return int.Parse(Read()); }
        private static long ReadLong() { return long.Parse(Read()); }
        private static double ReadDouble() { return double.Parse(Read()); }
        private static int[] ReadInts() { return Array.ConvertAll(Read().Split(), int.Parse); }
        private static long[] ReadLongs() { return Array.ConvertAll(Read().Split(), long.Parse); }
        private static double[] ReadDoubles() { return Array.ConvertAll(Read().Split(), double.Parse); }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using static System.Console;
using static System.Math;

namespace AtTest.CodeForces._1379
{
    class A
    {
        static void Main(string[] args)
        {
            var sw = new System.IO.StreamWriter(OpenStandardOutput()) { AutoFlush = false };
            SetOut(sw);

            Method(args);

            Out.Flush();
        }

        static void Method(string[] args)
        {
            int t = ReadInt();
            string key = "abacaba";
            for (int i = 0; i < t; i++)
            {
                int n = ReadInt();
                string s = Read();
                bool can = false;
                for (int j = 0; j + key.Length - 1 < n; j++)
                {
                    bool replacable = true;
                    for(int k = 0; k < key.Length; k++)
                    {
                        if (s[j + k] == key[k]
                            || s[j + k] == '?')
                        {
                            continue;
                        }

                        replacable = false;
                        break;
                    }

                    if (!replacable)
                    {
                        continue;
                    }

                    string left = s.Substring(0, j);
                    string right = s.Substring(j + key.Length);
                    left=left.Replace('?', 'z');
                    right=right.Replace('?', 'z');
                    string tmp = left + key + right;
                    int cnt = 0;
                    for(int k = 0; k + key.Length - 1 < n; k++)
                    {
                        if (tmp.Substring(k, key.Length) == key)
                        {
                            cnt++;
                        }
                    }

                    if (cnt == 1)
                    {
                        can = true;
                        WriteLine("Yes");
                        WriteLine(tmp);
                        break;
                    }
                }

                if (!can)
                {
                    WriteLine("No");
                }
            }
        }

        private static string Read() { return ReadLine(); }
        private static char[] ReadChars() { return Array.ConvertAll(Read().Split(), a => a[0]); }
        private static int ReadInt() { return int.Parse(Read()); }
        private static long ReadLong() { return long.Parse(Read()); }
        private static double ReadDouble() { return double.Parse(Read()); }
        private static int[] ReadInts() { return Array.ConvertAll(Read().Split(), int.Parse); }
        private static long[] ReadLongs() { return Array.ConvertAll(Read().Split(), long.Parse); }
        private static double[] ReadDoubles() { return Array.ConvertAll(Read().Split(), double.Parse); }
    }
}


using System;
using System.Linq;
using CompLib.Util;
using System.Threading;

public class Program
{

    const string T = "abacaba";
    public void Solve()
    {
        var sc = new Scanner();
        Console.SetOut(new System.IO.StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
        int t = sc.NextInt();
        for (int i = 0; i < t; i++)
        {
            Q(sc);
        }
        Console.Out.Flush();
    }

    void Q(Scanner sc)
    {
        int n = sc.NextInt();
        string s = sc.Next();

        /*
         * sの?を入れる
         *
         * abacabaが部分文字列1回でるようにs
         */

        for (int b = 0; b + T.Length <= n; b++)
        {
            bool f = true;
            for (int i = 0; i < T.Length && f; i++)
            {
                if (s[i + b] == '?') continue;
                f &= s[i + b] == T[i];
            }

            if (!f) continue;

            char[] ans = new char[n];
            for (int i = 0; i < n; i++)
            {
                if (s[i] == '?') ans[i] = b <= i && i < b + T.Length ? ans[i] = T[i - b] : 'z';
                else ans[i] = s[i];
            }

            for (int b2 = 0; b2 + T.Length <= n && f; b2++)
            {
                if (b == b2) continue;
                bool f2 = true;
                for (int i = 0; i < T.Length && f2; i++)
                {
                    f2 &= ans[i + b2] == T[i];
                }
                f &= !f2;
            }

            if (f)
            {
                Console.WriteLine("Yes");
                Console.WriteLine(new string(ans));
                return;
            }
        }
        Console.WriteLine("No");
    }

    public static void Main(string[] args) => new Program().Solve();
    // public static void Main(string[] args) => new Thread(new Program().Solve, 1 << 27).Start();
}

namespace CompLib.Util
{
    using System;
    using System.Linq;

    class Scanner
    {
        private string[] _line;
        private int _index;
        private const char Separator = ' ';

        public Scanner()
        {
            _line = new string[0];
            _index = 0;
        }

        public string Next()
        {
            if (_index >= _line.Length)
            {
                string s;
                do
                {
                    s = Console.ReadLine();
                } while (s.Length == 0);

                _line = s.Split(Separator);
                _index = 0;
            }

            return _line[_index++];
        }

        public string ReadLine()
        {
            _index = _line.Length;
            return Console.ReadLine();
        }

        public int NextInt() => int.Parse(Next());
        public long NextLong() => long.Parse(Next());
        public double NextDouble() => double.Parse(Next());
        public decimal NextDecimal() => decimal.Parse(Next());
        public char NextChar() => Next()[0];
        public char[] NextCharArray() => Next().ToCharArray();

        public string[] Array()
        {
            string s = Console.ReadLine();
            _line = s.Length == 0 ? new string[0] : s.Split(Separator);
            _index = _line.Length;
            return _line;
        }

        public int[] IntArray() => Array().Select(int.Parse).ToArray();
        public long[] LongArray() => Array().Select(long.Parse).ToArray();
        public double[] DoubleArray() => Array().Select(double.Parse).ToArray();
        public decimal[] DecimalArray() => Array().Select(decimal.Parse).ToArray();
    }
}


using System;
using System.Text;
using static ConsoleReader;

class Program
{
    private const string pat = "abacaba";

    static void Main(string[] args)
    {
        var t = Read<int>();

        t.Times(Solve);
    }

    private static void Solve(int a)
    {
        var n = Read<int>();
        var s = Read<string>();

        for (var i = 0; i < s.Length - pat.Length + 1; i++)
        {
            if (IsMatched(i, s, true))
            {
                var res = s.Substring(0, i) + pat + s.Substring(i + pat.Length);
                var matchCount = CountMatches(res);
                if (matchCount == 1)
                {
                    Console.WriteLine("Yes");
                    Console.WriteLine(res.Replace('?', 'z'));
                    return;
                }
            }
        }
        Console.WriteLine("No");
    }

    private static int CountMatches(string s)
    {
        var res = 0;
        for (var i = 0; i < s.Length - pat.Length + 1; i++)
        {
            if (IsMatched(i, s, false)) res++;
        }
        return res;
    }

    private static bool IsMatched(int i, string s, bool considerQuestions)
    {
        for (var j = 0; j < pat.Length; j++)
        {
            bool isOkayChar = s[i + j] == pat[j] || (s[i + j] == '?' && considerQuestions);

            if (!isOkayChar)
            {
                return false;
            }
        }
        return true;
    }
}

public static class IntExtentions
{
    public static void Times(this int n, Action<int> action)
    {
        for (var i = 0; i < n; i++)
        {
            action(i);
        }
    }

    public static void Times(this (int n, int m) dimensions, Action<int, int> action)
    {
        var (n, m) = dimensions;
        n.Times(i => m.Times(j => action(i, j)));
    }
}

public static class ConsoleReader
{
    public static T Read<T>()
        where T : IConvertible
    {
        var inputBuffer = new StringBuilder();
        int currChar;

        while ((currChar = Console.Read()) != -1)
        {
            if (!char.IsWhiteSpace((char)currChar))
            {
                inputBuffer.Append((char)currChar);
            }
            else if (inputBuffer.Length != 0)
            {
                break;
            }
        }

        return (T)Convert.ChangeType(inputBuffer.ToString(), typeof(T));
    }

    public static T[] ReadArray<T>(int count)
        where T : IConvertible
    {
        if (count < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(count), $"'{nameof(count)}' must be >= 0");
        }

        var result = new T[count];

        for (var i = 0; i < count; i++)
        {
            result[i] = Read<T>();
        }

        return result;
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Threading;
using System.Runtime.CompilerServices;
using System.Text;
using System.Diagnostics;
using System.Numerics;
using static System.Console;
using static System.Convert;
using static System.Math;
using static Template;

class Solver
{
    public Scanner sc;
    public void Solve()
    {
        var N=sc.Int;
        var S=sc.Str.ToCharArray();
        var s="abacaba";var ct=0;
        for(int i=0;i<N-s.Length+1;i++){
            var ok=true;
            for(int j=0;j<s.Length;j++){
                ok&=s[j]==S[i+j];
            }
            if(ok){
                ct++;
                for(int j=0;j<s.Length;j++)
                    S[i+j]=s[j];
            }
        }
        if(ct==1){
            for(int i=0;i<N;i++)
                if(S[i]=='?')S[i]='d';
            Console.WriteLine("Yes");
            Console.WriteLine(new string(S));
            return;
        }else if(ct>1){
            Console.WriteLine("No");
            return;
        }
        for(int i=0;i<N-s.Length+1;i++){
            var ok=true;
            for(int j=0;j<s.Length;j++){
                ok&=s[j]==S[i+j]||(S[i+j]=='?'&&ct==0);
            }
            if(ok){
                ct++;
                for(int j=0;j<s.Length;j++)
                    S[i+j]=s[j];
            }
        }
        if(ct==0){
            Console.WriteLine("No");
            return;
        }
        for(int i=0;i<N;i++)
            if(S[i]=='?')S[i]='d';
        Console.WriteLine("Yes");
        Console.WriteLine(new string(S));

    }
}

#region Template
public static class Template
{
    static void Main(string[] args)
    {
        Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
        var sol = new Solver() { sc = new Scanner() };
        //var th = new Thread(sol.Solve, 1 << 26);th.Start();th.Join();
        var T=sol.sc.Int;
        while(T-->0)
            sol.Solve();
        Console.Out.Flush();
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool chmin<T>(ref T a, T b) where T : IComparable<T> { if (a.CompareTo(b) > 0) { a = b; return true; } return false; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool chmax<T>(ref T a, T b) where T : IComparable<T> { if (a.CompareTo(b) < 0) { a = b; return true; } return false; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void swap<T>(ref T a, ref T b) { var t = b; b = a; a = t; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void swap<T>(this IList<T> A, int i, int j) { var t = A[i]; A[i] = A[j]; A[j] = t; }
    public static T[] Create<T>(int n, Func<T> f) { var rt = new T[n]; for (var i = 0; i < rt.Length; ++i) rt[i] = f(); return rt; }
    public static T[] Create<T>(int n, Func<int, T> f) { var rt = new T[n]; for (var i = 0; i < rt.Length; ++i) rt[i] = f(i); return rt; }
    public static string Concat<T>(this IEnumerable<T> A, string sp) => string.Join(sp, A);
    public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> A) => A.OrderBy(v => Guid.NewGuid());
    public static int CompareTo<T>(this T[] A, T[] B, Comparison<T> cmp = null) { cmp = cmp ?? Comparer<T>.Default.Compare; for (var i = 0; i < Min(A.Length, B.Length); i++) { int c = cmp(A[i], B[i]); if (c > 0) return 1; else if (c < 0) return -1; } if (A.Length == B.Length) return 0; if (A.Length > B.Length) return 1; else return -1; }
    public static int ArgMax<T>(this IList<T> A, Comparison<T> cmp = null) { cmp = cmp ?? Comparer<T>.Default.Compare; T max = A[0]; int rt = 0; for (int i = 1; i < A.Count; i++) if (cmp(max, A[i]) < 0) { max = A[i]; rt = i; } return rt; }
    public static T PopBack<T>(this List<T> A) { var v = A[A.Count - 1]; A.RemoveAt(A.Count - 1); return v; }
    public static void Fail<T>(T s) { Console.WriteLine(s); Console.Out.Close(); Environment.Exit(0); }
}
public class Scanner
{
    public string Str => Console.ReadLine().Trim();
    public int Int => int.Parse(Str);
    public long Long => long.Parse(Str);
    public double Double => double.Parse(Str);
    public int[] ArrInt => Str.Split(' ').Select(int.Parse).ToArray();
    public long[] ArrLong => Str.Split(' ').Select(long.Parse).ToArray();
    public char[][] Grid(int n) => Create(n, () => Str.ToCharArray());
    public int[] ArrInt1D(int n) => Create(n, () => Int);
    public long[] ArrLong1D(int n) => Create(n, () => Long);
    public int[][] ArrInt2D(int n) => Create(n, () => ArrInt);
    public long[][] ArrLong2D(int n) => Create(n, () => ArrLong);
    private Queue<string> q = new Queue<string>();
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public T Next<T>() { if (q.Count == 0) foreach (var item in Str.Split(' ')) q.Enqueue(item); return (T)Convert.ChangeType(q.Dequeue(), typeof(T)); }
    public void Make<T1>(out T1 v1) => v1 = Next<T1>();
    public void Make<T1, T2>(out T1 v1, out T2 v2) { v1 = Next<T1>(); v2 = Next<T2>(); }
    public void Make<T1, T2, T3>(out T1 v1, out T2 v2, out T3 v3) { Make(out v1, out v2); v3 = Next<T3>(); }
    public void Make<T1, T2, T3, T4>(out T1 v1, out T2 v2, out T3 v3, out T4 v4) { Make(out v1, out v2, out v3); v4 = Next<T4>(); }
    public void Make<T1, T2, T3, T4, T5>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5) { Make(out v1, out v2, out v3, out v4); v5 = Next<T5>(); }
    public void Make<T1, T2, T3, T4, T5, T6>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5, out T6 v6) { Make(out v1, out v2, out v3, out v4, out v5); v6 = Next<T6>(); }
    public void Make<T1, T2, T3, T4, T5, T6, T7>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5, out T6 v6, out T7 v7) { Make(out v1, out v2, out v3, out v4, out v5, out v6); v7 = Next<T7>(); }
    //public (T1, T2) Make<T1, T2>() { Make(out T1 v1, out T2 v2); return (v1, v2); }
    //public (T1, T2, T3) Make<T1, T2, T3>() { Make(out T1 v1, out T2 v2, out T3 v3); return (v1, v2, v3); }
    //public (T1, T2, T3, T4) Make<T1, T2, T3, T4>() { Make(out T1 v1, out T2 v2, out T3 v3, out T4 v4); return (v1, v2, v3, v4); }
}

#endregion


using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Threading;
using System.Runtime.CompilerServices;
using System.Text;
using System.Diagnostics;
using System.Numerics;
using static System.Console;
using static System.Convert;
using static System.Math;
using static Template;

class Solver
{
    public Scanner sc;
    public void Solve()
    {
        var N=sc.Int;
        var S=sc.Str.ToCharArray();
        var s="abacaba";var ct=0;
        for(int i=0;i<N-s.Length+1;i++){
            var ok=true;
            for(int j=0;j<s.Length;j++){
                ok&=s[j]==S[i+j];
            }
            if(ok){
                ct++;
            }
        }
        if(ct==1){
            for(int i=0;i<N;i++)
                if(S[i]=='?')S[i]='d';
            Console.WriteLine("Yes");
            Console.WriteLine(new string(S));
            return;
        }else if(ct>1){
            Console.WriteLine("No");
            return;
        }
        for(int i=0;i<N-s.Length+1;i++){
            var ok=true;
            for(int j=0;j<s.Length;j++){
                ok&=s[j]==S[i+j]||S[i+j]=='?';
            }
            if(ok){
                var K=S.ToArray();
                for(int j=0;j<s.Length;j++)
                    K[i+j]=s[j];
                ct=0;
                for(int k=0;k<N-s.Length+1;k++){
                    ok=true;
                        for(int j=0;j<s.Length;j++){
                            ok&=s[j]==K[k+j];
                        }
                if(ok)ct++;
                }
                if(ct==1){
                    Console.WriteLine("Yes");
                    Console.WriteLine(new string(K));
                    return;

                }
            }
        }
        Console.WriteLine("No");

    }
}

#region Template
public static class Template
{
    static void Main(string[] args)
    {
        Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
        var sc=new Scanner();
        var sol = new Solver() { sc=sc };
        //var th = new Thread(sol.Solve, 1 << 26);th.Start();th.Join();
        var T=sc.Int;
        while(T-->0)
            sol.Solve();
        Console.Out.Flush();
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool chmin<T>(ref T a, T b) where T : IComparable<T> { if (a.CompareTo(b) > 0) { a = b; return true; } return false; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool chmax<T>(ref T a, T b) where T : IComparable<T> { if (a.CompareTo(b) < 0) { a = b; return true; } return false; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void swap<T>(ref T a, ref T b) { var t = b; b = a; a = t; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void swap<T>(this IList<T> A, int i, int j) { var t = A[i]; A[i] = A[j]; A[j] = t; }
    public static T[] Create<T>(int n, Func<T> f) { var rt = new T[n]; for (var i = 0; i < rt.Length; ++i) rt[i] = f(); return rt; }
    public static T[] Create<T>(int n, Func<int, T> f) { var rt = new T[n]; for (var i = 0; i < rt.Length; ++i) rt[i] = f(i); return rt; }
    public static string Concat<T>(this IEnumerable<T> A, string sp) => string.Join(sp, A);
    public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> A) => A.OrderBy(v => Guid.NewGuid());
    public static int CompareTo<T>(this T[] A, T[] B, Comparison<T> cmp = null) { cmp = cmp ?? Comparer<T>.Default.Compare; for (var i = 0; i < Min(A.Length, B.Length); i++) { int c = cmp(A[i], B[i]); if (c > 0) return 1; else if (c < 0) return -1; } if (A.Length == B.Length) return 0; if (A.Length > B.Length) return 1; else return -1; }
    public static int ArgMax<T>(this IList<T> A, Comparison<T> cmp = null) { cmp = cmp ?? Comparer<T>.Default.Compare; T max = A[0]; int rt = 0; for (int i = 1; i < A.Count; i++) if (cmp(max, A[i]) < 0) { max = A[i]; rt = i; } return rt; }
    public static T PopBack<T>(this List<T> A) { var v = A[A.Count - 1]; A.RemoveAt(A.Count - 1); return v; }
    public static void Fail<T>(T s) { Console.WriteLine(s); Console.Out.Close(); Environment.Exit(0); }
}
public class Scanner
{
    public string Str => Console.ReadLine().Trim();
    public int Int => int.Parse(Str);
    public long Long => long.Parse(Str);
    public double Double => double.Parse(Str);
    public int[] ArrInt => Str.Split(' ').Select(int.Parse).ToArray();
    public long[] ArrLong => Str.Split(' ').Select(long.Parse).ToArray();
    public char[][] Grid(int n) => Create(n, () => Str.ToCharArray());
    public int[] ArrInt1D(int n) => Create(n, () => Int);
    public long[] ArrLong1D(int n) => Create(n, () => Long);
    public int[][] ArrInt2D(int n) => Create(n, () => ArrInt);
    public long[][] ArrLong2D(int n) => Create(n, () => ArrLong);
    private Queue<string> q = new Queue<string>();
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public T Next<T>() { if (q.Count == 0) foreach (var item in Str.Split(' ')) q.Enqueue(item); return (T)Convert.ChangeType(q.Dequeue(), typeof(T)); }
    public void Make<T1>(out T1 v1) => v1 = Next<T1>();
    public void Make<T1, T2>(out T1 v1, out T2 v2) { v1 = Next<T1>(); v2 = Next<T2>(); }
    public void Make<T1, T2, T3>(out T1 v1, out T2 v2, out T3 v3) { Make(out v1, out v2); v3 = Next<T3>(); }
    public void Make<T1, T2, T3, T4>(out T1 v1, out T2 v2, out T3 v3, out T4 v4) { Make(out v1, out v2, out v3); v4 = Next<T4>(); }
    public void Make<T1, T2, T3, T4, T5>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5) { Make(out v1, out v2, out v3, out v4); v5 = Next<T5>(); }
    public void Make<T1, T2, T3, T4, T5, T6>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5, out T6 v6) { Make(out v1, out v2, out v3, out v4, out v5); v6 = Next<T6>(); }
    public void Make<T1, T2, T3, T4, T5, T6, T7>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5, out T6 v6, out T7 v7) { Make(out v1, out v2, out v3, out v4, out v5, out v6); v7 = Next<T7>(); }
    //public (T1, T2) Make<T1, T2>() { Make(out T1 v1, out T2 v2); return (v1, v2); }
    //public (T1, T2, T3) Make<T1, T2, T3>() { Make(out T1 v1, out T2 v2, out T3 v3); return (v1, v2, v3); }
    //public (T1, T2, T3, T4) Make<T1, T2, T3, T4>() { Make(out T1 v1, out T2 v2, out T3 v3, out T4 v4); return (v1, v2, v3, v4); }
}

#endregion


using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Threading;
using System.Runtime.CompilerServices;
using System.Text;
using System.Diagnostics;
using System.Numerics;
using static System.Console;
using static System.Convert;
using static System.Math;
using static Template;

class Solver
{
    public Scanner sc;
    public void Solve()
    {
        var N = sc.Int;
        var S = sc.Str.ToCharArray();
        var s = "abacaba"; var ct = 0;
        for (int i = 0; i < N - s.Length + 1; i++)
        {
            var ok = true;
            for (int j = 0; j < s.Length; j++)
            {
                ok &= s[j] == S[i + j];
            }
            if (ok)
            {
                ct++;
            }
        }
        if (ct == 1)
        {
            for (int i = 0; i < N; i++)
                if (S[i] == '?') S[i] = 'd';
            Console.WriteLine("Yes");
            Console.WriteLine(new string(S));
            return;
        }
        else if (ct > 1)
        {
            Console.WriteLine("No");
            return;
        }
        for (int i = 0; i < N - s.Length + 1; i++)
        {
            var ok = true;
            for (int j = 0; j < s.Length; j++)
            {
                ok &= s[j] == S[i + j] || S[i + j] == '?';
            }
            if (ok)
            {
                var K = S.ToArray();
                for (int j = 0; j < s.Length; j++)
                    K[i + j] = s[j];
                ct = 0;
                for (int k = 0; k < N - s.Length + 1; k++)
                {
                    ok = true;
                    for (int j = 0; j < s.Length; j++)
                    {
                        ok &= s[j] == K[k + j];
                    }
                    if (ok) ct++;
                }
                if (ct == 1)
                {
                    Console.WriteLine("Yes");
                for (int k = 0; k < N; k++)
                    if (K[k] == '?') K[k] = 'd';
                    Console.WriteLine(new string(K));
                    return;

                }
            }
        }
        Console.WriteLine("No");

    }
}

#region Template
public static class Template
{
    static void Main(string[] args)
    {
        Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
        var sc = new Scanner();
        var sol = new Solver() { sc = sc };
        //var th = new Thread(sol.Solve, 1 << 26);th.Start();th.Join();
        var T = sc.Int;
        while (T-- > 0)
            sol.Solve();
        Console.Out.Flush();
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool chmin<T>(ref T a, T b) where T : IComparable<T> { if (a.CompareTo(b) > 0) { a = b; return true; } return false; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool chmax<T>(ref T a, T b) where T : IComparable<T> { if (a.CompareTo(b) < 0) { a = b; return true; } return false; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void swap<T>(ref T a, ref T b) { var t = b; b = a; a = t; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void swap<T>(this IList<T> A, int i, int j) { var t = A[i]; A[i] = A[j]; A[j] = t; }
    public static T[] Create<T>(int n, Func<T> f) { var rt = new T[n]; for (var i = 0; i < rt.Length; ++i) rt[i] = f(); return rt; }
    public static T[] Create<T>(int n, Func<int, T> f) { var rt = new T[n]; for (var i = 0; i < rt.Length; ++i) rt[i] = f(i); return rt; }
    public static string Concat<T>(this IEnumerable<T> A, string sp) => string.Join(sp, A);
    public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> A) => A.OrderBy(v => Guid.NewGuid());
    public static int CompareTo<T>(this T[] A, T[] B, Comparison<T> cmp = null) { cmp = cmp ?? Comparer<T>.Default.Compare; for (var i = 0; i < Min(A.Length, B.Length); i++) { int c = cmp(A[i], B[i]); if (c > 0) return 1; else if (c < 0) return -1; } if (A.Length == B.Length) return 0; if (A.Length > B.Length) return 1; else return -1; }
    public static int ArgMax<T>(this IList<T> A, Comparison<T> cmp = null) { cmp = cmp ?? Comparer<T>.Default.Compare; T max = A[0]; int rt = 0; for (int i = 1; i < A.Count; i++) if (cmp(max, A[i]) < 0) { max = A[i]; rt = i; } return rt; }
    public static T PopBack<T>(this List<T> A) { var v = A[A.Count - 1]; A.RemoveAt(A.Count - 1); return v; }
    public static void Fail<T>(T s) { Console.WriteLine(s); Console.Out.Close(); Environment.Exit(0); }
}
public class Scanner
{
    public string Str => Console.ReadLine().Trim();
    public int Int => int.Parse(Str);
    public long Long => long.Parse(Str);
    public double Double => double.Parse(Str);
    public int[] ArrInt => Str.Split(' ').Select(int.Parse).ToArray();
    public long[] ArrLong => Str.Split(' ').Select(long.Parse).ToArray();
    public char[][] Grid(int n) => Create(n, () => Str.ToCharArray());
    public int[] ArrInt1D(int n) => Create(n, () => Int);
    public long[] ArrLong1D(int n) => Create(n, () => Long);
    public int[][] ArrInt2D(int n) => Create(n, () => ArrInt);
    public long[][] ArrLong2D(int n) => Create(n, () => ArrLong);
    private Queue<string> q = new Queue<string>();
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public T Next<T>() { if (q.Count == 0) foreach (var item in Str.Split(' ')) q.Enqueue(item); return (T)Convert.ChangeType(q.Dequeue(), typeof(T)); }
    public void Make<T1>(out T1 v1) => v1 = Next<T1>();
    public void Make<T1, T2>(out T1 v1, out T2 v2) { v1 = Next<T1>(); v2 = Next<T2>(); }
    public void Make<T1, T2, T3>(out T1 v1, out T2 v2, out T3 v3) { Make(out v1, out v2); v3 = Next<T3>(); }
    public void Make<T1, T2, T3, T4>(out T1 v1, out T2 v2, out T3 v3, out T4 v4) { Make(out v1, out v2, out v3); v4 = Next<T4>(); }
    public void Make<T1, T2, T3, T4, T5>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5) { Make(out v1, out v2, out v3, out v4); v5 = Next<T5>(); }
    public void Make<T1, T2, T3, T4, T5, T6>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5, out T6 v6) { Make(out v1, out v2, out v3, out v4, out v5); v6 = Next<T6>(); }
    public void Make<T1, T2, T3, T4, T5, T6, T7>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5, out T6 v6, out T7 v7) { Make(out v1, out v2, out v3, out v4, out v5, out v6); v7 = Next<T7>(); }
    //public (T1, T2) Make<T1, T2>() { Make(out T1 v1, out T2 v2); return (v1, v2); }
    //public (T1, T2, T3) Make<T1, T2, T3>() { Make(out T1 v1, out T2 v2, out T3 v3); return (v1, v2, v3); }
    //public (T1, T2, T3, T4) Make<T1, T2, T3, T4>() { Make(out T1 v1, out T2 v2, out T3 v3, out T4 v4); return (v1, v2, v3, v4); }
}

#endregion


using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Threading;
using System.Runtime.CompilerServices;
using System.Text;
using System.Diagnostics;
using System.Numerics;
using static System.Console;
using static System.Convert;
using static System.Math;
using static Template;

class Solver
{
    public Scanner sc;
    public void Solve()
    {
        var N=sc.Int;
        var S=sc.Str.ToCharArray();
        var s="abacaba";var ct=0;
        for(int i=0;i<N-s.Length+1;i++){
            var ok=true;
            for(int j=0;j<s.Length;j++){
                ok&=s[j]==S[i+j]||(S[i+j]=='?'&&ct==0);
            }
            if(ok){
                ct++;
                for(int j=0;j<s.Length;j++)
                    S[i+j]=s[j];
            }
        }
        if(ct!=1){
            Console.WriteLine("No");return;
        }
        for(int i=0;i<N;i++)
            if(S[i]=='?')S[i]='p';
        Console.WriteLine("Yes");
        Console.WriteLine(new string(S));

    }
}

#region Template
public static class Template
{
    static void Main(string[] args)
    {
        Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
        var sol = new Solver() { sc = new Scanner() };
        //var th = new Thread(sol.Solve, 1 << 26);th.Start();th.Join();
        var T=sol.sc.Int;
        while(T-->0)
            sol.Solve();
        Console.Out.Flush();
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool chmin<T>(ref T a, T b) where T : IComparable<T> { if (a.CompareTo(b) > 0) { a = b; return true; } return false; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool chmax<T>(ref T a, T b) where T : IComparable<T> { if (a.CompareTo(b) < 0) { a = b; return true; } return false; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void swap<T>(ref T a, ref T b) { var t = b; b = a; a = t; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void swap<T>(this IList<T> A, int i, int j) { var t = A[i]; A[i] = A[j]; A[j] = t; }
    public static T[] Create<T>(int n, Func<T> f) { var rt = new T[n]; for (var i = 0; i < rt.Length; ++i) rt[i] = f(); return rt; }
    public static T[] Create<T>(int n, Func<int, T> f) { var rt = new T[n]; for (var i = 0; i < rt.Length; ++i) rt[i] = f(i); return rt; }
    public static string Concat<T>(this IEnumerable<T> A, string sp) => string.Join(sp, A);
    public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> A) => A.OrderBy(v => Guid.NewGuid());
    public static int CompareTo<T>(this T[] A, T[] B, Comparison<T> cmp = null) { cmp = cmp ?? Comparer<T>.Default.Compare; for (var i = 0; i < Min(A.Length, B.Length); i++) { int c = cmp(A[i], B[i]); if (c > 0) return 1; else if (c < 0) return -1; } if (A.Length == B.Length) return 0; if (A.Length > B.Length) return 1; else return -1; }
    public static int ArgMax<T>(this IList<T> A, Comparison<T> cmp = null) { cmp = cmp ?? Comparer<T>.Default.Compare; T max = A[0]; int rt = 0; for (int i = 1; i < A.Count; i++) if (cmp(max, A[i]) < 0) { max = A[i]; rt = i; } return rt; }
    public static T PopBack<T>(this List<T> A) { var v = A[A.Count - 1]; A.RemoveAt(A.Count - 1); return v; }
    public static void Fail<T>(T s) { Console.WriteLine(s); Console.Out.Close(); Environment.Exit(0); }
}
public class Scanner
{
    public string Str => Console.ReadLine().Trim();
    public int Int => int.Parse(Str);
    public long Long => long.Parse(Str);
    public double Double => double.Parse(Str);
    public int[] ArrInt => Str.Split(' ').Select(int.Parse).ToArray();
    public long[] ArrLong => Str.Split(' ').Select(long.Parse).ToArray();
    public char[][] Grid(int n) => Create(n, () => Str.ToCharArray());
    public int[] ArrInt1D(int n) => Create(n, () => Int);
    public long[] ArrLong1D(int n) => Create(n, () => Long);
    public int[][] ArrInt2D(int n) => Create(n, () => ArrInt);
    public long[][] ArrLong2D(int n) => Create(n, () => ArrLong);
    private Queue<string> q = new Queue<string>();
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public T Next<T>() { if (q.Count == 0) foreach (var item in Str.Split(' ')) q.Enqueue(item); return (T)Convert.ChangeType(q.Dequeue(), typeof(T)); }
    public void Make<T1>(out T1 v1) => v1 = Next<T1>();
    public void Make<T1, T2>(out T1 v1, out T2 v2) { v1 = Next<T1>(); v2 = Next<T2>(); }
    public void Make<T1, T2, T3>(out T1 v1, out T2 v2, out T3 v3) { Make(out v1, out v2); v3 = Next<T3>(); }
    public void Make<T1, T2, T3, T4>(out T1 v1, out T2 v2, out T3 v3, out T4 v4) { Make(out v1, out v2, out v3); v4 = Next<T4>(); }
    public void Make<T1, T2, T3, T4, T5>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5) { Make(out v1, out v2, out v3, out v4); v5 = Next<T5>(); }
    public void Make<T1, T2, T3, T4, T5, T6>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5, out T6 v6) { Make(out v1, out v2, out v3, out v4, out v5); v6 = Next<T6>(); }
    public void Make<T1, T2, T3, T4, T5, T6, T7>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5, out T6 v6, out T7 v7) { Make(out v1, out v2, out v3, out v4, out v5, out v6); v7 = Next<T7>(); }
    //public (T1, T2) Make<T1, T2>() { Make(out T1 v1, out T2 v2); return (v1, v2); }
    //public (T1, T2, T3) Make<T1, T2, T3>() { Make(out T1 v1, out T2 v2, out T3 v3); return (v1, v2, v3); }
    //public (T1, T2, T3, T4) Make<T1, T2, T3, T4>() { Make(out T1 v1, out T2 v2, out T3 v3, out T4 v4); return (v1, v2, v3, v4); }
}

#endregion


using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Threading;
using System.Runtime.CompilerServices;
using System.Text;
using System.Diagnostics;
using System.Numerics;
using static System.Console;
using static System.Convert;
using static System.Math;
using static Template;

class Solver
{
    public Scanner sc;
    public void Solve()
    {
        var N=sc.Int;
        var S=sc.Str.ToCharArray();
        var s="abacaba";var ct=0;
        for(int i=0;i<N-s.Length+1;i++){
            var ok=true;
            for(int j=0;j<s.Length;j++){
                ok&=s[j]==S[i+j];
            }
            if(ok){
                ct++;
            }
        }
        if(ct==1){
            for(int i=0;i<N;i++)
                if(S[i]=='?')S[i]='d';
            Console.WriteLine("Yes");
            Console.WriteLine(new string(S));
            return;
        }else if(ct>1){
            Console.WriteLine("No");
            return;
        }
        for(int i=0;i<N-s.Length+1;i++){
            var ok=true;
            for(int j=0;j<s.Length;j++){
                ok&=s[j]==S[i+j]||S[i+j]=='?';
            }
            if(ok){
                ct++;
                for(int j=0;j<s.Length;j++)
                    S[i+j]=s[j];
                break;
            }
        }
        if(ct==0){
            Console.WriteLine("No");
            return;
        }
        for(int i=0;i<N;i++)
            if(S[i]=='?')S[i]='d';
        Console.WriteLine("Yes");
        Console.WriteLine(new string(S));

    }
}

#region Template
public static class Template
{
    static void Main(string[] args)
    {
        Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
        var sc=new Scanner();
        var sol = new Solver() { sc=sc };
        //var th = new Thread(sol.Solve, 1 << 26);th.Start();th.Join();
        var T=sc.Int;
        while(T-->0)
            sol.Solve();
        Console.Out.Flush();
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool chmin<T>(ref T a, T b) where T : IComparable<T> { if (a.CompareTo(b) > 0) { a = b; return true; } return false; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool chmax<T>(ref T a, T b) where T : IComparable<T> { if (a.CompareTo(b) < 0) { a = b; return true; } return false; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void swap<T>(ref T a, ref T b) { var t = b; b = a; a = t; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void swap<T>(this IList<T> A, int i, int j) { var t = A[i]; A[i] = A[j]; A[j] = t; }
    public static T[] Create<T>(int n, Func<T> f) { var rt = new T[n]; for (var i = 0; i < rt.Length; ++i) rt[i] = f(); return rt; }
    public static T[] Create<T>(int n, Func<int, T> f) { var rt = new T[n]; for (var i = 0; i < rt.Length; ++i) rt[i] = f(i); return rt; }
    public static string Concat<T>(this IEnumerable<T> A, string sp) => string.Join(sp, A);
    public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> A) => A.OrderBy(v => Guid.NewGuid());
    public static int CompareTo<T>(this T[] A, T[] B, Comparison<T> cmp = null) { cmp = cmp ?? Comparer<T>.Default.Compare; for (var i = 0; i < Min(A.Length, B.Length); i++) { int c = cmp(A[i], B[i]); if (c > 0) return 1; else if (c < 0) return -1; } if (A.Length == B.Length) return 0; if (A.Length > B.Length) return 1; else return -1; }
    public static int ArgMax<T>(this IList<T> A, Comparison<T> cmp = null) { cmp = cmp ?? Comparer<T>.Default.Compare; T max = A[0]; int rt = 0; for (int i = 1; i < A.Count; i++) if (cmp(max, A[i]) < 0) { max = A[i]; rt = i; } return rt; }
    public static T PopBack<T>(this List<T> A) { var v = A[A.Count - 1]; A.RemoveAt(A.Count - 1); return v; }
    public static void Fail<T>(T s) { Console.WriteLine(s); Console.Out.Close(); Environment.Exit(0); }
}
public class Scanner
{
    public string Str => Console.ReadLine().Trim();
    public int Int => int.Parse(Str);
    public long Long => long.Parse(Str);
    public double Double => double.Parse(Str);
    public int[] ArrInt => Str.Split(' ').Select(int.Parse).ToArray();
    public long[] ArrLong => Str.Split(' ').Select(long.Parse).ToArray();
    public char[][] Grid(int n) => Create(n, () => Str.ToCharArray());
    public int[] ArrInt1D(int n) => Create(n, () => Int);
    public long[] ArrLong1D(int n) => Create(n, () => Long);
    public int[][] ArrInt2D(int n) => Create(n, () => ArrInt);
    public long[][] ArrLong2D(int n) => Create(n, () => ArrLong);
    private Queue<string> q = new Queue<string>();
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public T Next<T>() { if (q.Count == 0) foreach (var item in Str.Split(' ')) q.Enqueue(item); return (T)Convert.ChangeType(q.Dequeue(), typeof(T)); }
    public void Make<T1>(out T1 v1) => v1 = Next<T1>();
    public void Make<T1, T2>(out T1 v1, out T2 v2) { v1 = Next<T1>(); v2 = Next<T2>(); }
    public void Make<T1, T2, T3>(out T1 v1, out T2 v2, out T3 v3) { Make(out v1, out v2); v3 = Next<T3>(); }
    public void Make<T1, T2, T3, T4>(out T1 v1, out T2 v2, out T3 v3, out T4 v4) { Make(out v1, out v2, out v3); v4 = Next<T4>(); }
    public void Make<T1, T2, T3, T4, T5>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5) { Make(out v1, out v2, out v3, out v4); v5 = Next<T5>(); }
    public void Make<T1, T2, T3, T4, T5, T6>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5, out T6 v6) { Make(out v1, out v2, out v3, out v4, out v5); v6 = Next<T6>(); }
    public void Make<T1, T2, T3, T4, T5, T6, T7>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5, out T6 v6, out T7 v7) { Make(out v1, out v2, out v3, out v4, out v5, out v6); v7 = Next<T7>(); }
    //public (T1, T2) Make<T1, T2>() { Make(out T1 v1, out T2 v2); return (v1, v2); }
    //public (T1, T2, T3) Make<T1, T2, T3>() { Make(out T1 v1, out T2 v2, out T3 v3); return (v1, v2, v3); }
    //public (T1, T2, T3, T4) Make<T1, T2, T3, T4>() { Make(out T1 v1, out T2 v2, out T3 v3, out T4 v4); return (v1, v2, v3, v4); }
}

#endregion


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

class TEST{
	static void Main(){
		Sol mySol =new Sol();
		mySol.Solve();
	}
}

class Sol{
	public void Solve(){

		String T = "abacaba";

		var sb = new StringBuilder();
		for(;TT>0;TT--){

			N = ri();
			S = rs();

			String ans = "xx";
			for(int i=0;i + 6 < N;i++){

				var ca = S.ToCharArray();
				bool chk2 = true;
				for(int j=0;j<7;j++){
					if(ca[i + j] == T[j]) continue;
					if(ca[i + j] == '?'){
						ca[i + j] = T[j];
						continue;
					}
					chk2 = false; break;
				}
				if(!chk2) continue;

				for(int j=0;j<N;j++){
					if(ca[j] == '?') ca[j] = 'z';
				}

				int cnt = 0;
				for(int j=0;j+6<N;j++){
					if(ca[j] == T[0] && ca[j+1] == T[1] && ca[j+2] == T[2]){
						if(ca[j+3] == T[3] && ca[j+4] == T[4] && ca[j+5] == T[5] && ca[j+6] == T[6]) cnt++;
					}
				}
				if(cnt == 1){
					ans = new String(ca);
					break;
				}
			}

			if(ans == "xx"){
				sb.AppendLine("No");
			} else {
				sb.AppendLine("Yes");
				sb.AppendLine(ans);
			}
		}

		Console.Write(sb.ToString());
	}

	String S;
	int N;

	int TT;
	public Sol(){
		TT = ri();
	}

	static String rs(){return Console.ReadLine();}
	static int ri(){return int.Parse(Console.ReadLine());}
	static long rl(){return long.Parse(Console.ReadLine());}
	static double rd(){return double.Parse(Console.ReadLine());}
	static String[] rsa(char sep=' '){return Console.ReadLine().Split(sep);}
	static int[] ria(char sep=' '){return Array.ConvertAll(Console.ReadLine().Split(sep),e=>int.Parse(e));}
	static long[] rla(char sep=' '){return Array.ConvertAll(Console.ReadLine().Split(sep),e=>long.Parse(e));}
	static double[] rda(char sep=' '){return Array.ConvertAll(Console.ReadLine().Split(sep),e=>double.Parse(e));}
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Text;
using System.Numerics;
using System.Threading;
using System.Runtime.CompilerServices;
using System.Diagnostics;
using static System.Math;
using static System.Array;
using static AtCoder.Sc_out;
using static AtCoder.Tool;
using static AtCoder.ModInt;
namespace AtCoder
{
    class AC
    {
        const int MOD = 1000000007;
        //const int MOD = 998244353;

        const int INF = int.MaxValue / 2;
        const long SINF = long.MaxValue / 2;
        const double EPS = 1e-8;
        static readonly int[] dI = { 0, 1, 0, -1, 1, -1, -1, 1 };
        static readonly int[] dJ = { 1, 0, -1, 0, 1, 1, -1, -1 };
        //static List<List<int>> G = new List<List<int>>();
        //static List<List<Edge>> G = new List<List<Edge>>();
        //static List<Edge> E = new List<Edge>();
        static void Main(string[] args)
        {
            var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false }; Console.SetOut(sw);

            var th = new Thread(Run, 1 << 26);
            th.Start();
            th.Join();

            //Run();
            Console.Out.Flush();
        }
        static void Run()
        {
            int Testcase = Cin.Int;
            for (var _ = 0; _ < Testcase; _++) Solve();
        }
        static void Solve()
        {
            int n = Cin.Int;
            var s = Cin.Str;
            string t = "abacaba";
            Func<string, bool> ok = (string sub) =>
            {
                var ret = true;
                for (var i = 0; i < t.Length; i++)
                {
                    ret &= sub[i] == '?' || sub[i] == t[i];
                }
                return ret;
            };

            for(var i = 0; i + t.Length - 1 < n; i++)
            {
                var sub = s.Substring(i, t.Length);
                if (!ok(sub)) continue;
                var nxt = s.Substring(0, i) + t + s.Substring(i + t.Length);
                nxt = string.Join("", nxt.Replace('?', 'z'));
                var cnt = 0;
                for(var j = 0; j + t.Length - 1 < n; j++)
                {
                    if (ok(nxt.Substring(j, t.Length))) cnt++;
                }
                if (cnt == 1)
                {
                    OutL("Yes");
                    OutL(nxt);
                    return;
                }
            }
            OutL("No");
        }
        public struct Edge
        {
            public int from;

            public int to;
            public long dist;

            public Edge(int t, long c)
            {
                from = -1;
                to = t;
                dist = c;
            }
            public Edge(int f, int t, long c)
            {
                from = f;
                to = t;
                dist = c;
            }
        }
    }
    struct ModInt
    {
        public long value;
        private const int MOD = 1000000007;
        //private const int MOD = 998244353;
        public ModInt(long value) { this.value = value; }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static implicit operator ModInt(long a)
        {
            var ret = a % MOD;
            return new ModInt(ret < 0 ? (ret + MOD) : ret);
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt operator +(ModInt a, ModInt b) => (a.value + b.value);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt operator -(ModInt a, ModInt b) => (a.value - b.value);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt operator *(ModInt a, ModInt b) => (a.value * b.value);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt operator /(ModInt a, ModInt b) => a * Modpow(b, MOD - 2);

        public static ModInt operator <<(ModInt a, int n) => (a.value << n);
        public static ModInt operator >>(ModInt a, int n) => (a.value >> n);
        public static ModInt operator ++(ModInt a) => a.value + 1;
        public static ModInt operator --(ModInt a) => a.value - 1;
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt Modpow(ModInt a, long n)
        {
            var k = a;
            ModInt ret = 1;
            while (n > 0)
            {
                if ((n & 1) != 0) ret *= k;
                k *= k;
                n >>= 1;
            }
            return ret;
        }
        private static readonly List<long> Factorials = new List<long>() { 1 };
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt Fac(long n)
        {
            for (var i = Factorials.Count(); i <= n; i++)
            {
                Factorials.Add((Factorials[i - 1] * i) % MOD);
            }
            return Factorials[(int)n];
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt nCr(long n, long r)
        {
            return n < r ? 0 : Fac(n) / (Fac(r) * Fac(n - r));
        }
        public static explicit operator int(ModInt a) => (int)a.value;
    }
    static class Cin
    {
        public static string[] ReadSplit => Console.ReadLine().Split();
        public static int[] ReadSplitInt => ConvertAll(Console.ReadLine().Split(), int.Parse);
        public static long[] ReadSplitLong => ConvertAll(Console.ReadLine().Split(), long.Parse);
        public static double[] ReadSplit_Double => ConvertAll(Console.ReadLine().Split(), double.Parse);
        public static string Str => Console.ReadLine();
        public static int Int => int.Parse(Console.ReadLine());
        public static long Long => long.Parse(Console.ReadLine());
        public static double Double => double.Parse(Console.ReadLine());
        public static T Conv<T>(string input)
        {
            if (typeof(T).Equals(typeof(ModInt)))
            {
                return (T)(dynamic)(long.Parse(input));
            }
            return (T)Convert.ChangeType(input, typeof(T));
        }
        public static void Input<T>(out T a) => a = Conv<T>(Console.ReadLine());
        public static void Input<T, U>(out T a, out U b)
        { var q = ReadSplit; a = Conv<T>(q[0]); b = Conv<U>(q[1]); }
        public static void Input<T, U, V>(out T a, out U b, out V c)
        { var q = ReadSplit; a = Conv<T>(q[0]); b = Conv<U>(q[1]); c = Conv<V>(q[2]); }
        public static void Input<T, U, V, W>(out T a, out U b, out V c, out W d)
        { var q = ReadSplit; a = Conv<T>(q[0]); b = Conv<U>(q[1]); c = Conv<V>(q[2]); d = Conv<W>(q[3]); }
        public static void Input<T, U, V, W, X>(out T a, out U b, out V c, out W d, out X e)
        { var q = ReadSplit; a = Conv<T>(q[0]); b = Conv<U>(q[1]); c = Conv<V>(q[2]); d = Conv<W>(q[3]); e = Conv<X>(q[4]); }
    }
    static class Sc_out
    {
        public static void OutL(object s) => Console.WriteLine(s);
        public static void Out_Sep<T>(IEnumerable<T> s) => Console.WriteLine(string.Join(" ", s));
        public static void Out_Sep<T>(IEnumerable<T> s, string sep) => Console.WriteLine(string.Join($"{sep}", s));
        public static void Out_Sep(params object[] s) => Console.WriteLine(string.Join(" ", s));
        public static void Out_One(object s) => Console.Write($"{s} ");
        public static void Out_One(object s, string sep) => Console.Write($"{s}{sep}");
        public static void Endl() => Console.WriteLine();
    }
    public static class Tool
    {
        static public void Initialize<T>(ref T[] array, T initialvalue)
        {
            array = ConvertAll(array, x => initialvalue);
        }
        static public void Swap<T>(ref T a, ref T b)
        {
            T keep = a;
            a = b;
            b = keep;
        }
        static public void Display<T>(T[,] array2d, int n, int m)
        {
            for (var i = 0; i < n; i++)
            {
                for (var j = 0; j < m; j++)
                {
                    Console.Write($"{array2d[i, j]} ");
                }
                Console.WriteLine();
            }
        }
        static public long Gcd(long a, long b)
        {
            if (a == 0 || b == 0) return Max(a, b);
            return a % b == 0 ? b : Gcd(b, a % b);
        }
        static public long LPow(int a, int b) => (long)Pow(a, b);
        static public bool Bit(long x, int dig) => ((1L << dig) & x) != 0;
        static public int Sig(long a) => a == 0 ? 0 : (int)(a / Abs(a));
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Text;
using System.Numerics;
using System.Threading;
using System.Runtime.CompilerServices;
using System.Diagnostics;
using static System.Math;
using static System.Array;
using static AtCoder.Sc_out;
using static AtCoder.Tool;
using static AtCoder.ModInt;
namespace AtCoder
{
    class AC
    {
        const int MOD = 1000000007;
        //const int MOD = 998244353;

        const int INF = int.MaxValue / 2;
        const long SINF = long.MaxValue / 2;
        const double EPS = 1e-8;
        static readonly int[] dI = { 0, 1, 0, -1, 1, -1, -1, 1 };
        static readonly int[] dJ = { 1, 0, -1, 0, 1, 1, -1, -1 };
        //static List<List<int>> G = new List<List<int>>();
        //static List<List<Edge>> G = new List<List<Edge>>();
        //static List<Edge> E = new List<Edge>();
        static void Main(string[] args)
        {
            var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false }; Console.SetOut(sw);

            var th = new Thread(Run, 1 << 26);
            th.Start();
            th.Join();

            //Run();
            Console.Out.Flush();
        }
        static void Run()
        {
            int Testcase = Cin.Int;
            for (var _ = 0; _ < Testcase; _++) Solve();
        }
        static void Solve()
        {
            int n = Cin.Int;
            var s = Cin.Str;
            string t = "abacaba";
            bool ok(string sub)
            {
                var ret = true;
                for(var i = 0; i < t.Length; i++)
                {
                    ret &= sub[i] == '?' || sub[i] == t[i];
                }
                return ret;
            }

            for(var i = 0; i + t.Length - 1 < n; i++)
            {
                var sub = s.Substring(i, t.Length);
                if (!ok(sub)) continue;
                var nxt = s.Substring(0, i) + t + s.Substring(i + t.Length);
                nxt = string.Join("", nxt.Replace('?', 'z'));
                var cnt = 0;
                for(var j = 0; j + t.Length - 1 < n; j++)
                {
                    if (ok(nxt.Substring(j, t.Length))) cnt++;
                }
                if (cnt == 1)
                {
                    OutL("Yes");
                    OutL(nxt);
                    return;
                }
            }
            OutL("No");
        }
        public struct Edge
        {
            public int from;

            public int to;
            public long dist;

            public Edge(int t, long c)
            {
                from = -1;
                to = t;
                dist = c;
            }
            public Edge(int f, int t, long c)
            {
                from = f;
                to = t;
                dist = c;
            }
        }
    }
    struct ModInt
    {
        public long value;
        private const int MOD = 1000000007;
        //private const int MOD = 998244353;
        public ModInt(long value) { this.value = value; }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static implicit operator ModInt(long a)
        {
            var ret = a % MOD;
            return new ModInt(ret < 0 ? (ret + MOD) : ret);
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt operator +(ModInt a, ModInt b) => (a.value + b.value);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt operator -(ModInt a, ModInt b) => (a.value - b.value);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt operator *(ModInt a, ModInt b) => (a.value * b.value);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt operator /(ModInt a, ModInt b) => a * Modpow(b, MOD - 2);

        public static ModInt operator <<(ModInt a, int n) => (a.value << n);
        public static ModInt operator >>(ModInt a, int n) => (a.value >> n);
        public static ModInt operator ++(ModInt a) => a.value + 1;
        public static ModInt operator --(ModInt a) => a.value - 1;
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt Modpow(ModInt a, long n)
        {
            var k = a;
            ModInt ret = 1;
            while (n > 0)
            {
                if ((n & 1) != 0) ret *= k;
                k *= k;
                n >>= 1;
            }
            return ret;
        }
        private static readonly List<long> Factorials = new List<long>() { 1 };
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt Fac(long n)
        {
            for (var i = Factorials.Count(); i <= n; i++)
            {
                Factorials.Add((Factorials[i - 1] * i) % MOD);
            }
            return Factorials[(int)n];
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt nCr(long n, long r)
        {
            return n < r ? 0 : Fac(n) / (Fac(r) * Fac(n - r));
        }
        public static explicit operator int(ModInt a) => (int)a.value;
    }
    static class Cin
    {
        public static string[] ReadSplit => Console.ReadLine().Split();
        public static int[] ReadSplitInt => ConvertAll(Console.ReadLine().Split(), int.Parse);
        public static long[] ReadSplitLong => ConvertAll(Console.ReadLine().Split(), long.Parse);
        public static double[] ReadSplit_Double => ConvertAll(Console.ReadLine().Split(), double.Parse);
        public static string Str => Console.ReadLine();
        public static int Int => int.Parse(Console.ReadLine());
        public static long Long => long.Parse(Console.ReadLine());
        public static double Double => double.Parse(Console.ReadLine());
        public static T Conv<T>(string input)
        {
            if (typeof(T).Equals(typeof(ModInt)))
            {
                return (T)(dynamic)(long.Parse(input));
            }
            return (T)Convert.ChangeType(input, typeof(T));
        }
        public static void Input<T>(out T a) => a = Conv<T>(Console.ReadLine());
        public static void Input<T, U>(out T a, out U b)
        { var q = ReadSplit; a = Conv<T>(q[0]); b = Conv<U>(q[1]); }
        public static void Input<T, U, V>(out T a, out U b, out V c)
        { var q = ReadSplit; a = Conv<T>(q[0]); b = Conv<U>(q[1]); c = Conv<V>(q[2]); }
        public static void Input<T, U, V, W>(out T a, out U b, out V c, out W d)
        { var q = ReadSplit; a = Conv<T>(q[0]); b = Conv<U>(q[1]); c = Conv<V>(q[2]); d = Conv<W>(q[3]); }
        public static void Input<T, U, V, W, X>(out T a, out U b, out V c, out W d, out X e)
        { var q = ReadSplit; a = Conv<T>(q[0]); b = Conv<U>(q[1]); c = Conv<V>(q[2]); d = Conv<W>(q[3]); e = Conv<X>(q[4]); }
    }
    static class Sc_out
    {
        public static void OutL(object s) => Console.WriteLine(s);
        public static void Out_Sep<T>(IEnumerable<T> s) => Console.WriteLine(string.Join(" ", s));
        public static void Out_Sep<T>(IEnumerable<T> s, string sep) => Console.WriteLine(string.Join($"{sep}", s));
        public static void Out_Sep(params object[] s) => Console.WriteLine(string.Join(" ", s));
        public static void Out_One(object s) => Console.Write($"{s} ");
        public static void Out_One(object s, string sep) => Console.Write($"{s}{sep}");
        public static void Endl() => Console.WriteLine();
    }
    public static class Tool
    {
        static public void Initialize<T>(ref T[] array, T initialvalue)
        {
            array = ConvertAll(array, x => initialvalue);
        }
        static public void Swap<T>(ref T a, ref T b)
        {
            T keep = a;
            a = b;
            b = keep;
        }
        static public void Display<T>(T[,] array2d, int n, int m)
        {
            for (var i = 0; i < n; i++)
            {
                for (var j = 0; j < m; j++)
                {
                    Console.Write($"{array2d[i, j]} ");
                }
                Console.WriteLine();
            }
        }
        static public long Gcd(long a, long b)
        {
            if (a == 0 || b == 0) return Max(a, b);
            return a % b == 0 ? b : Gcd(b, a % b);
        }
        static public long LPow(int a, int b) => (long)Pow(a, b);
        static public bool Bit(long x, int dig) => ((1L << dig) & x) != 0;
        static public int Sig(long a) => a == 0 ? 0 : (int)(a / Abs(a));
    }
}


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

class DescendingComparer<T> : IComparer<T> where T : IComparable<T>
{
    public int Compare(T x, T y)
    {
        return y.CompareTo(x);
    }
}

public class CF
{

    public static int[] ReadArray()
    {
        return Array.ConvertAll(Console.ReadLine().Split(' '), m => Convert.ToInt32(m));
    }

    public static int ReadInt()
    {
        return Convert.ToInt32(Console.ReadLine());
    }

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

    public static long ReadLong()
    {
        return Convert.ToInt64(Console.ReadLine());
    }

    public static long[] ReadLongArray()
    {
        return Array.ConvertAll(Console.ReadLine().Split(' '), m => Convert.ToInt64(m));

    }

    public static int Check(string s,string str)
    {
        int cnt = 0;
        int n = s.Length;
        for (int i = 0; i < n; i++)
        {
            int j = 0;
            int k = i;

            while (k < n && j < 7 && s[k] == str[j])
            {
                k++;
                j++;
            }

            if (j == 7) cnt++;

        }

        return cnt;
    }

    public static void Main()
    {

        int test = ReadInt();
        string str = "abacaba";
        while (test --> 0)
        {
            int n = ReadInt();
            string s = ReadStr();
            bool found = false;
            int start = 0;

            int cnt = Check(s, str);

            if(cnt > 1)
            {
                Console.WriteLine("No");
                continue;
            }

            if (cnt == 0)
            {
                for (int i = 0; i < n; i++)
                {
                    int j = 0;
                    int k = i;

                    while (k < n && j < 7 && (s[k] == str[j] || s[k] == '?'))
                    {
                        k++;
                        j++;
                    }

                    if (j == 7)
                    {
                        found = true;
                        start = i;
                        break;
                    }

                }

                if (found)
                {
                    char[] ans = s.ToArray();
                    int j = 0;
                    for (int i = start; i < start + 7; i++)
                    {
                        ans[i] = str[j++];
                    }
                    for (int i = 0; i < n; i++)
                    {
                        if (ans[i] == '?')
                            ans[i] = 'z';
                    }
                    if (Check(s, str) > 1)
                    {
                        Console.WriteLine("No");
                    }
                    else
                    {
                        Console.WriteLine("Yes");
                        Console.WriteLine(new string(ans));
                    }
                }
                else
                {
                    Console.WriteLine("No");
                }
            }
            else
            {
                char[] ans = s.ToArray();

                for (int i = 0; i < n; i++)
                {
                    if (ans[i] == '?')
                        ans[i] = 'z';
                }
                Console.WriteLine("Yes");
                Console.WriteLine(new string(ans));

            }

        }

    }

}


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

class DescendingComparer<T> : IComparer<T> where T : IComparable<T>
{
    public int Compare(T x, T y)
    {
        return y.CompareTo(x);
    }
}

public class CF
{

    public static int[] ReadArray()
    {
        return Array.ConvertAll(Console.ReadLine().Split(' '), m => Convert.ToInt32(m));
    }

    public static int ReadInt()
    {
        return Convert.ToInt32(Console.ReadLine());
    }

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

    public static long ReadLong()
    {
        return Convert.ToInt64(Console.ReadLine());
    }

    public static long[] ReadLongArray()
    {
        return Array.ConvertAll(Console.ReadLine().Split(' '), m => Convert.ToInt64(m));

    }

    public static int Check(string s,string str)
    {
        int cnt = 0;
        int n = s.Length;
        for (int i = 0; i < n; i++)
        {
            int j = 0;
            int k = i;

            while (k < n && j < 7 && s[k] == str[j])
            {
                k++;
                j++;
            }

            if (j == 7) cnt++;

        }

        return cnt;
    }

    public static void Main()
    {

        int test = ReadInt();
        string str = "abacaba";
        while (test --> 0)
        {
            int n = ReadInt();
            string s = ReadStr();
            bool found = false;
            int start = 0;

            int cnt = Check(s, str);

            if(cnt > 1)
            {
                Console.WriteLine("No");
                continue;
            }

            if (cnt == 0)
            {
                for (int i = 0; i < n; i++)
                {
                    int j = 0;
                    int k = i;

                    while (k < n && j < 7 && (s[k] == str[j] || s[k] == '?'))
                    {
                        k++;
                        j++;
                    }

                    if (j == 7)
                    {
                        found = true;
                        start = i;
                        break;
                    }

                }

                if (found)
                {
                    char[] ans = s.ToArray();
                    int j = 0;
                    for (int i = start; i < start + 7; i++)
                    {
                        ans[i] = str[j++];
                    }
                    for (int i = 0; i < n; i++)
                    {
                        if (ans[i] == '?')
                            ans[i] = 'z';
                    }
                    if (Check(new string(ans), str) > 1)
                    {
                        Console.WriteLine("No");
                    }
                    else
                    {
                        Console.WriteLine("Yes");
                        Console.WriteLine(new string(ans));
                    }
                }
                else
                {
                    Console.WriteLine("No");
                }
            }
            else
            {
                char[] ans = s.ToArray();

                for (int i = 0; i < n; i++)
                {
                    if (ans[i] == '?')
                        ans[i] = 'z';
                }
                Console.WriteLine("Yes");
                Console.WriteLine(new string(ans));

            }

        }

    }

}


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

class DescendingComparer<T> : IComparer<T> where T : IComparable<T>
{
    public int Compare(T x, T y)
    {
        return y.CompareTo(x);
    }
}

public class CF
{

    public static int[] ReadArray()
    {
        return Array.ConvertAll(Console.ReadLine().Split(' '), m => Convert.ToInt32(m));
    }

    public static int ReadInt()
    {
        return Convert.ToInt32(Console.ReadLine());
    }

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

    public static long ReadLong()
    {
        return Convert.ToInt64(Console.ReadLine());
    }

    public static long[] ReadLongArray()
    {
        return Array.ConvertAll(Console.ReadLine().Split(' '), m => Convert.ToInt64(m));

    }

    public static void Main()
    {

        int test = ReadInt();
        string str = "abacaba";
        while (test --> 0)
        {
            int n = ReadInt();
            string s = ReadStr();
            bool found = false;
            int start = 0;
            int cnt = 0;
            for (int i = 0; i < n; i++)
            {
                int j = 0;
                int k = i;

                while (k < n && j < 7 && s[k] == str[j])
                {
                    k++;
                    j++;
                }

                if (j == 7) cnt++;

            }

            if(cnt > 1)
            {
                Console.WriteLine("No");
                continue;
            }

            if (cnt == 0)
            {
                for (int i = 0; i < n; i++)
                {
                    int j = 0;
                    int k = i;

                    while (k < n && j < 7 && (s[k] == str[j] || s[k] == '?'))
                    {
                        k++;
                        j++;
                    }

                    if (j == 7)
                    {
                        found = true;
                        start = i;
                        break;
                    }

                }

                if (found)
                {
                    char[] ans = s.ToArray();
                    int j = 0;
                    for (int i = start; i < start + 7; i++)
                    {
                        ans[i] = str[j++];
                    }

                    for (int i = 0; i < n; i++)
                    {
                        if (ans[i] == '?')
                            ans[i] = 'z';
                    }
                    Console.WriteLine("Yes");
                    Console.WriteLine(new string(ans));
                }
                else
                {
                    Console.WriteLine("No");
                }
            }
            else
            {
                char[] ans = s.ToArray();

                for (int i = 0; i < n; i++)
                {
                    if (ans[i] == '?')
                        ans[i] = 'z';
                }
                Console.WriteLine("Yes");
                Console.WriteLine(new string(ans));

            }

        }

    }

}


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

class DescendingComparer<T> : IComparer<T> where T : IComparable<T>
{
    public int Compare(T x, T y)
    {
        return y.CompareTo(x);
    }
}

public class CF
{

    public static int[] ReadArray()
    {
        return Array.ConvertAll(Console.ReadLine().Split(' '), m => Convert.ToInt32(m));
    }

    public static int ReadInt()
    {
        return Convert.ToInt32(Console.ReadLine());
    }

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

    public static long ReadLong()
    {
        return Convert.ToInt64(Console.ReadLine());
    }

    public static long[] ReadLongArray()
    {
        return Array.ConvertAll(Console.ReadLine().Split(' '), m => Convert.ToInt64(m));

    }

    public static void Main()
    {

        int test = ReadInt();
        string str = "abacaba";
        while (test --> 0)
        {
            int n = ReadInt();
            string s = ReadStr();
            bool found = false;
            int start = 0;
            int cnt = 0;
            for (int i = 0; i < n; i++)
            {
                int j = 0;
                int k = i;

                while (k < n && j < 7 && s[k] == str[j])
                {
                    k++;
                    j++;
                }

                if (j == 7) cnt++;

            }

            if(cnt > 1)
            {
                Console.WriteLine("No");
                continue;
            }

            for (int i = 0; i < n; i++)
            {
                int j = 0;
                int k = i;

                while(k < n && j < 7 && (s[k] == str[j] || s[k] == '?'))
                {
                    k++;
                    j++;
                }

                if(j == 7)
                {
                    found = true;
                    start = i;
                    break;
                }

            }

            if(found)
            {
                char[] ans = s.ToArray();
                int j = 0;
                for(int i = start; i < start + 7; i++)
                {
                    ans[i] = str[j++];
                }

                for(int i = 0; i < n; i++)
                {
                    if (ans[i] == '?')
                        ans[i] = 'z';
                }
                Console.WriteLine("Yes");
                Console.WriteLine(new string(ans));
            }
            else
            {
                Console.WriteLine("No");
            }

        }

    }

}


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

class DescendingComparer<T> : IComparer<T> where T : IComparable<T>
{
    public int Compare(T x, T y)
    {
        return y.CompareTo(x);
    }
}

public class CF
{

    public static int[] ReadArray()
    {
        return Array.ConvertAll(Console.ReadLine().Split(' '), m => Convert.ToInt32(m));
    }

    public static int ReadInt()
    {
        return Convert.ToInt32(Console.ReadLine());
    }

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

    public static long ReadLong()
    {
        return Convert.ToInt64(Console.ReadLine());
    }

    public static long[] ReadLongArray()
    {
        return Array.ConvertAll(Console.ReadLine().Split(' '), m => Convert.ToInt64(m));

    }

    public static int Check(string s,string str)
    {
        int cnt = 0;
        int n = s.Length;
        for (int i = 0; i < n; i++)
        {
            int j = 0;
            int k = i;

            while (k < n && j < 7 && s[k] == str[j])
            {
                k++;
                j++;
            }

            if (j == 7) cnt++;

        }

        return cnt;
    }

    public static void Main()
    {

        int test = ReadInt();
        string str = "abacaba";
        while (test --> 0)
        {
            int n = ReadInt();
            string s = ReadStr();

            List<int> start = new List<int>();

            int cnt = Check(s, str);

            if(cnt > 1)
            {
                Console.WriteLine("No");
                continue;
            }

            if(cnt == 1)
            {
                Console.WriteLine("Yes");
                Console.WriteLine(s.Replace('?', 'z'));
                continue;
            }

                for (int i = 0; i < n; i++)
                {
                    int j = 0;
                    int k = i;

                    while (k < n && j < 7 && (s[k] == str[j] || s[k] == '?'))
                    {
                        k++;
                        j++;
                    }

                    if (j == 7)
                    {
                        start.Add(i);
                    }
                }

                 bool found = false;
                if (start.Count > 0)
                {
                    foreach (var st in start)
                    {
                        char[] ans = s.ToArray();
                        int j = 0;
                        for (int i = st; i < st + 7; i++)
                        {
                            ans[i] = str[j++];
                        }
                        for (int i = 0; i < n; i++)
                        {
                            if (ans[i] == '?')
                                ans[i] = 'z';
                        }
                        if (Check(new string(ans), str) == 1)
                        {
                            Console.WriteLine("Yes");
                            Console.WriteLine(new string(ans));
                            found = true;
                            break;

                        }
                    }
                }

                if(!found)
                    Console.WriteLine("No");

        }

    }

}


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

// (づ°ω°)づﾐe★゜・。。・゜゜・。。・゜☆゜・。。・゜゜・。。・゜
public class Solver
{
    string t = "abacaba";
    int Count(string s)
    {
        int ret = 0;
        for (int i = 0; i + t.Length <= s.Length; i++)
            if (s.Substring(i, t.Length) == t)
                ret++;
        return ret;
    }

    public void Solve()
    {
        for (int tt = ReadInt(); tt > 0; tt--)
        {
            int n = ReadInt();
            var a = ReadToken().ToCharArray();
            bool f = false;
            for (int i = 0; !f && i + t.Length <= n; i++)
            {
                f = true;
                var b = (char[])a.Clone();
                for (int j = 0; j < t.Length; j++)
                    if (b[i + j] == '?')
                    {
                        b[i + j] = t[j];
                    }
                    else if (b[i + j] != t[j])
                        f = false;
                if (!f)
                    continue;
                for (int j = 0; j < i; j++)
                    if (b[j] == '?')
                        b[j] = 'w';
                for (int j = i + t.Length; j < n; j++)
                    if (b[j] == '?')
                        b[j] = 'w';
                string v = new string(b);
                if (Count(v) == 1)
                {
                    Write("Yes");
                    Write(v);
                }
                else
                    f = false;
            }

            if (!f)
                Write("No");
        }
    }

    #region Main

    protected static TextReader reader;
    protected static TextWriter writer;
    static void Main()
    {
#if DEBUG
        reader = new StreamReader("..\\..\\input.txt");
        //reader = new StreamReader(Console.OpenStandardInput());
        writer = Console.Out;
        //writer = new StreamWriter("..\\..\\output.txt");
#else
        reader = new StreamReader(Console.OpenStandardInput());
        writer = new StreamWriter(Console.OpenStandardOutput());
        //reader = new StreamReader("input.txt");
        //writer = new StreamWriter("output.txt");
#endif
        try
        {
            new Solver().Solve();
            //var thread = new Thread(new Solver().Solve, 1024 * 1024 * 128);
            //thread.Start();
            //thread.Join();
        }
        catch (Exception ex)
        {
#if DEBUG
            Console.WriteLine(ex);
#else
            throw;
#endif
        }
        reader.Close();
        writer.Close();
    }

    #endregion

    #region Read / Write
    private static Queue<string> currentLineTokens = new Queue<string>();
    private static string[] ReadAndSplitLine() { return reader.ReadLine().Split(new[] { ' ', '\t', }, StringSplitOptions.RemoveEmptyEntries); }
    public static string ReadToken() { while (currentLineTokens.Count == 0) currentLineTokens = new Queue<string>(ReadAndSplitLine()); return currentLineTokens.Dequeue(); }
    public static int ReadInt() { return int.Parse(ReadToken()); }
    public static long ReadLong() { return long.Parse(ReadToken()); }
    public static double ReadDouble() { return double.Parse(ReadToken(), CultureInfo.InvariantCulture); }
    public static int[] ReadIntArray() { return ReadAndSplitLine().Select(int.Parse).ToArray(); }
    public static long[] ReadLongArray() { return ReadAndSplitLine().Select(long.Parse).ToArray(); }
    public static double[] ReadDoubleArray() { return ReadAndSplitLine().Select(s => double.Parse(s, CultureInfo.InvariantCulture)).ToArray(); }
    public static int[][] ReadIntMatrix(int numberOfRows) { int[][] matrix = new int[numberOfRows][]; for (int i = 0; i < numberOfRows; i++) matrix[i] = ReadIntArray(); return matrix; }
    public static int[][] ReadAndTransposeIntMatrix(int numberOfRows)
    {
        int[][] matrix = ReadIntMatrix(numberOfRows); int[][] ret = new int[matrix[0].Length][];
        for (int i = 0; i < ret.Length; i++) { ret[i] = new int[numberOfRows]; for (int j = 0; j < numberOfRows; j++) ret[i][j] = matrix[j][i]; }
        return ret;
    }
    public static string[] ReadLines(int quantity) { string[] lines = new string[quantity]; for (int i = 0; i < quantity; i++) lines[i] = reader.ReadLine().Trim(); return lines; }
    public static void WriteArray<T>(IEnumerable<T> array) { writer.WriteLine(string.Join(" ", array)); }
    public static void Write(params object[] array) { WriteArray(array); }
    public static void WriteLines<T>(IEnumerable<T> array) { foreach (var a in array) writer.WriteLine(a); }
    private class SDictionary<TKey, TValue> : Dictionary<TKey, TValue>
    {
        public new TValue this[TKey key]
        {
            get { return ContainsKey(key) ? base[key] : default(TValue); }
            set { base[key] = value; }
        }
    }
    private static T[] Init<T>(int size) where T : new() { var ret = new T[size]; for (int i = 0; i < size; i++) ret[i] = new T(); return ret; }
    #endregion
}


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();
                    continue;
                }

                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);

                }

            }

    }}