/* author   : mpily :-()
title : Competing.cpp
time :Sun Jun 14 13:11:23 2020

*/
#include<climits>
#include<random>
#include<cassert>
#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
#include<algorithm>
#include<utility>
#include<cstdint>
#include<queue>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstdio>
#include<bitset>
//4611686018427387903
using namespace std;
//magic lines for ordered_set
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
const uint64_t mod = 4294967296;
vector<vector<int64_t>> multiply(vector<vector<int64_t>>lhs,vector<vector<int64_t>>rhs){
    vector<vector<int64_t>> prod(lhs.size(),vector<int64_t>(rhs[0].size()));
    for(int i = 0;i < (int)lhs.size(); ++i){
        for(int j = 0; j < (int)rhs[0].size(); ++j){
            prod[i][j] = 1e18+5;
            for(int k = 0; k < (int)rhs.size(); ++k){
                prod[i][j] = min(prod[i][j], lhs[i][k] + rhs[k][j]);
               // prod[i][j]%=mod;
            }
        }
    }
    return prod;
}

/*
***************************************************************************************
do bfs for all nodes starting with those that are either roots or leaves

****************************************************************************************
start code here
*/
void solve(int cnum){
   int n;
   cin>> n;
   string s;
   cin >> s;
   string c = "abacaba";
   int count = 0;
   for(int i = 0;i + 7 <= n; ++i){
        cout << s[i];
        count += (s.substr(i,7) == c);
   }
   cout << count <<"\n";
   if(count > 1){
    cout << "No\n";
    return;
   }
   else if (count == 1){
    cout << "Yes\n";
    for(auto a : s){
        if(a == '?')cout << 'd';
        else cout << a;
    }
    cout << "\n";
    return;
   }
   else{
    for(int i = 0;i + 7 <= n; ++i){
        bool can = true;
        vector<int>qpos;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j] && s[i+j] != '?'){
                can = false;
                break;
            }
            else if(s[i+j] == '?'){
                qpos.push_back(i+j);
                s[i+j] = c[j];
            }
        }
        if(can){
            int tmpcnt = 0;
           for(int j = 0; j+7 <= n; ++j){
                if( c == s.substr(j,7)){
                    tmpcnt++;
                }
           }
           if(tmpcnt > 1){
                can = false;
                for(auto a : qpos){
                    s[a] = '?';
                }
           }
        }
        qpos.clear();
        if(can){
            cout << "Yes \n";
            for(auto a : s){
                if(a == '?')cout <<"d";
                else cout << a;
            }
            cout << "\n";
            return;
        }
   }
   cout << "No\n";
   }

}
int main(){

	//ios_base::sync_with_stdio(false);
	//cin.tie(nullptr);
	//cout.tie(nullptr);
	//initprime();
	//cout << setprecision(12);
	//cout << fixed;
	int t;
	int count = 1;
	for( cin >> t;t--; solve(count),count++);
	return 0;
}


/* author   : mpily :-()
title : Competing.cpp
time :Sun Jun 14 13:11:23 2020

*/
#include<climits>
#include<random>
#include<cassert>
#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
#include<algorithm>
#include<utility>
#include<cstdint>
#include<queue>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstdio>
#include<bitset>
//4611686018427387903
using namespace std;
//magic lines for ordered_set
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
const uint64_t mod = 4294967296;
vector<vector<int64_t>> multiply(vector<vector<int64_t>>lhs,vector<vector<int64_t>>rhs){
    vector<vector<int64_t>> prod(lhs.size(),vector<int64_t>(rhs[0].size()));
    for(int i = 0;i < (int)lhs.size(); ++i){
        for(int j = 0; j < (int)rhs[0].size(); ++j){
            prod[i][j] = 1e18+5;
            for(int k = 0; k < (int)rhs.size(); ++k){
                prod[i][j] = min(prod[i][j], lhs[i][k] + rhs[k][j]);
               // prod[i][j]%=mod;
            }
        }
    }
    return prod;
}

/*
***************************************************************************************
do bfs for all nodes starting with those that are either roots or leaves

****************************************************************************************
start code here
*/
void solve(int cnum){
   int n;
   cin>> n;
   string s;
   cin >> s;
   string c = "abacaba";
   int count = 0;
   for(int i = 0;i + 6 < n; ++i){
        bool can = true;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j]){
                can = false;
                break;
            }
        }
        if(can)
            count ++;
   }
   if(count > 1){
    cout << "No\n";
    return;
   }
   else if (count == 1){
    cout << "Yes\n";
    for(auto a : s){
        if(a == '?')cout << 'd';
        else cout << a;
    }
    cout << "\n";
    return;
   }
    for(int i = 0;i + 6 < n; ++i){
        bool can = true;
        vector<int>qpos;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j] && s[i+j] != '?'){
                can = false;
                break;
            }
            else if(s[i+j] == '?'){
                qpos.push_back(i+j);
                s[i+j] = c[j];
            }
        }
        if(can && qpos.size() && qpos.back() >= i+4){
            //cout << "checking from "<< i+4 <<"\n";
            bool fcan = true;fcan2 = true;
            for(int j = 0; j < 7; ++j){
                if(i+j + 4 >= n){
                    fcan = false;
                    break;
                }
                if(s[i+j+4] != c[j]){
                   // cout << "difference "<< i+j+4 <<"\n";
                    fcan = false;
                    break;
                }
            }
            for(int j = 0; j < 7; ++j){
                if(i+j + 6 >= n){
                    fcan2 = false;
                    break;
                }
                if(s[i+j+6] != c[j]){
                   // cout << "difference "<< i+j+4 <<"\n";
                    fcan2 = false;
                    break;
                }
            }
            if(fcan || fcan2){
                //cout << "entered here \n";
                can = false;
                for(auto a : qpos){
                    s[a] = '?';
                }
                i+=6;
            }
        }
        if(can){
            cout << "Yes \n";
            for(auto a : s){
                if(a == '?')cout <<"d";
                else cout << a;
            }
            cout << "\n";
            return;
        }
   }
   cout << "No\n";

}
int main(){

	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	//cout.tie(nullptr);
	//initprime();
	cout << setprecision(12);
	cout << fixed;
	int t;
	int count = 1;
	for( cin >> t;t--; solve(count),count++);
	return 0;
}


/* author   : mpily :-()
title : Competing.cpp
time :Sun Jun 14 13:11:23 2020

*/
#include<climits>
#include<random>
#include<cassert>
#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
#include<algorithm>
#include<utility>
#include<cstdint>
#include<queue>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstdio>
#include<bitset>
//4611686018427387903
using namespace std;
//magic lines for ordered_set
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
const uint64_t mod = 4294967296;
vector<vector<int64_t>> multiply(vector<vector<int64_t>>lhs,vector<vector<int64_t>>rhs){
    vector<vector<int64_t>> prod(lhs.size(),vector<int64_t>(rhs[0].size()));
    for(int i = 0;i < (int)lhs.size(); ++i){
        for(int j = 0; j < (int)rhs[0].size(); ++j){
            prod[i][j] = 1e18+5;
            for(int k = 0; k < (int)rhs.size(); ++k){
                prod[i][j] = min(prod[i][j], lhs[i][k] + rhs[k][j]);
               // prod[i][j]%=mod;
            }
        }
    }
    return prod;
}

/*
***************************************************************************************
do bfs for all nodes starting with those that are either roots or leaves

****************************************************************************************
start code here
*/
void solve(int cnum){
   int n;
   cin>> n;
   string s;
   cin >> s;
   string c = "abacaba";
   int count = 0;
   for(int i = 0;i + 7 <= n; ++i){
       // cout << s[i];
        count += (s.substr(i,7) == c);
   }
  // cout << count <<"\n";
   if(count > 1){
    cout << "No\n";
    return;
   }
   else if (count == 1){
    cout << "Yes\n";
    for(auto a : s){
        if(a == '?')cout << 'd';
        else cout << a;
    }
    cout << "\n";
    return;
   }
   else{
    for(int i = 0;i + 7 <= n; ++i){
        bool can = true;
        vector<int>qpos;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j] && s[i+j] != '?'){
               // cout << i <<"refused because of "<<s[i+j]<<"\n";
                can = false;
                break;
            }
            else if(s[i+j] == '?'){

                qpos.push_back(i+j);
                s[i+j] = c[j];
            }
        }
        if(can){
           // cout << "can get here for "<<i<<"\n";
            int tmpcnt = 0;
           for(int j = 0; j+7 <= n; ++j){
                if( c == s.substr(j,7)){
                    tmpcnt++;
                }
           }
           if(tmpcnt > 1){
                can = false;
                for(auto a : qpos){
                    s[a] = '?';
                }
           }
        }
        if(can){
            cout << "Yes \n";
            for(auto a : s){
                if(a == '?')cout <<"d";
                else cout << a;
            }
            cout << "\n";
            return;
        }
        for(auto a : qpos)
            s[a] = '?';
        qpos.clear();
   }
   cout << "No\n";
   }

}
int main(){

	//ios_base::sync_with_stdio(false);
	//cin.tie(nullptr);
	//cout.tie(nullptr);
	//initprime();
	//cout << setprecision(12);
	//cout << fixed;
	int t;
	int count = 1;
	for( cin >> t;t--; solve(count),count++);
	return 0;
}


/* author   : mpily :-()
title : Competing.cpp
time :Sun Jun 14 13:11:23 2020

*/
#include<climits>
#include<random>
#include<cassert>
#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
#include<algorithm>
#include<utility>
#include<cstdint>
#include<queue>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstdio>
#include<bitset>
//4611686018427387903
using namespace std;
//magic lines for ordered_set
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
const uint64_t mod = 4294967296;
vector<vector<int64_t>> multiply(vector<vector<int64_t>>lhs,vector<vector<int64_t>>rhs){
    vector<vector<int64_t>> prod(lhs.size(),vector<int64_t>(rhs[0].size()));
    for(int i = 0;i < (int)lhs.size(); ++i){
        for(int j = 0; j < (int)rhs[0].size(); ++j){
            prod[i][j] = 1e18+5;
            for(int k = 0; k < (int)rhs.size(); ++k){
                prod[i][j] = min(prod[i][j], lhs[i][k] + rhs[k][j]);
               // prod[i][j]%=mod;
            }
        }
    }
    return prod;
}

/*
***************************************************************************************
do bfs for all nodes starting with those that are either roots or leaves

****************************************************************************************
start code here
*/
void solve(int cnum){
   int n;
   cin>> n;
   string s;
   cin >> s;
   string c = "abacaba";
   int count = 0;
   int opcount = 0;
   for(int i = 0;i + 6 < n; ++i){
        bool can = true;
        string temp;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j]){
                can = false;
                break;
            }
        }
        if(can)
            count ++;
   }
   if(count > 1){
    cout << "No\n";
    return;
   }
   else if (count == 1){
    cout << "Yes\n";
    for(auto a : s){
        if(a == '?')cout << 'd';
        else cout << a;
    }
    cout << "\n";
    return;
   }
    for(int i = 0;i + 6 < n; ++i){
        bool can = true;
        vector<int>qpos;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j] && s[i+j] != '?'){
                can = false;
                break;
            }
            else if(s[i+j] == '?'){
                qpos.push_back(i+j);
                s[i+j] = c[j];
            }
        }
        if(can && qpos.back() >= i+4){
            bool fcan = true;
            for(int j = 0; j < 7; ++j){
                if(i+j + 4 >= n){
                    fcan = false;
                    break;
                }
                if(s[i+j+4] != c[j]){
                    fcan = false;
                    break;
                }
            }
            if(fcan){
                can = false;
                for(auto a : qpos){
                    s[a] = '?';
                }
            }
        }
        if(can){
            cout << "Yes \n";
            for(auto a : s){
                if(a == '?')cout <<"d";
                else cout << a;
            }
            cout << "\n";
            return;
        }
   }
   cout << "No\n";

}
int main(){

	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	//cout.tie(nullptr);
	//initprime();
	cout << setprecision(12);
	cout << fixed;
	int t;
	int count = 1;
	for( cin >> t;t--; solve(count),count++);
	return 0;
}


/* author   : mpily :-()
title : Competing.cpp
time :Sun Jun 14 13:11:23 2020

*/
#include<climits>
#include<random>
#include<cassert>
#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
#include<algorithm>
#include<utility>
#include<cstdint>
#include<queue>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstdio>
#include<bitset>
//4611686018427387903
using namespace std;
//magic lines for ordered_set
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
const uint64_t mod = 4294967296;
vector<vector<int64_t>> multiply(vector<vector<int64_t>>lhs,vector<vector<int64_t>>rhs){
    vector<vector<int64_t>> prod(lhs.size(),vector<int64_t>(rhs[0].size()));
    for(int i = 0;i < (int)lhs.size(); ++i){
        for(int j = 0; j < (int)rhs[0].size(); ++j){
            prod[i][j] = 1e18+5;
            for(int k = 0; k < (int)rhs.size(); ++k){
                prod[i][j] = min(prod[i][j], lhs[i][k] + rhs[k][j]);
               // prod[i][j]%=mod;
            }
        }
    }
    return prod;
}

/*
***************************************************************************************
do bfs for all nodes starting with those that are either roots or leaves

****************************************************************************************
start code here
*/

void solve(int cnum){
   int n;
   cin>> n;
   string s;
   cin >> s;
   string c = "abacaba";
    for(int i = 0;i + 7 <= n; ++i){
        bool can = true;
        string ss = s;
       // vector<int>qpos;
        for(int j = 0; j < 7; ++j){
            if(ss[i+j] != c[j] && ss[i+j] != '?'){
                can = false;
                break;
            }
            else{
                //qpos.push_back(i+j);
               ss[i+j] = c[j];
            }
        }
        if(can){
            int tmpcnt = 0;
           for(int j = 0; j+7 <= n; ++j){
                if( c == ss.substr(j,7)){
                    tmpcnt++;
                }
           }
           if(tmpcnt != 1){
                can = false;
           }
        }
        //qpos.clear();
        if(can){
            cout << "Yes \n";
            for(auto a : s){
                if(a == '?')cout <<"d";
                else cout << a;
            }
            cout << "\n";
            return;
        }
    }
   cout << "No\n";

}
int main(){

	//ios_base::sync_with_stdio(false);
	//cin.tie(nullptr);
	//cout.tie(nullptr);
	//initprime();
	//cout << setprecision(12);
	//cout << fixed;
	int t;
	int count = 1;
	for( cin >> t;t--; solve(count),count++);
	return 0;
}


/* author   : mpily :-()
title : Competing.cpp
time :Sun Jun 14 13:11:23 2020

*/
#include<climits>
#include<random>
#include<cassert>
#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
#include<algorithm>
#include<utility>
#include<cstdint>
#include<queue>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstdio>
#include<bitset>
//4611686018427387903
using namespace std;
//magic lines for ordered_set
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
const uint64_t mod = 4294967296;
vector<vector<int64_t>> multiply(vector<vector<int64_t>>lhs,vector<vector<int64_t>>rhs){
    vector<vector<int64_t>> prod(lhs.size(),vector<int64_t>(rhs[0].size()));
    for(int i = 0;i < (int)lhs.size(); ++i){
        for(int j = 0; j < (int)rhs[0].size(); ++j){
            prod[i][j] = 1e18+5;
            for(int k = 0; k < (int)rhs.size(); ++k){
                prod[i][j] = min(prod[i][j], lhs[i][k] + rhs[k][j]);
               // prod[i][j]%=mod;
            }
        }
    }
    return prod;
}

/*
***************************************************************************************
do bfs for all nodes starting with those that are either roots or leaves

****************************************************************************************
start code here
*/

void solve(int cnum){
   int n;
   cin>> n;
   string s;
   cin >> s;
   string c = "abacaba";
    for(int i = 0;i + 7 <= n; ++i){
        bool can = true;
        string ss = s;
       // vector<int>qpos;
        for(int j = 0; j < 7; ++j){
            if(ss[i+j] != c[j] && ss[i+j] != '?'){
                can = false;
                break;
            }
            else{
                //qpos.push_back(i+j);
               ss[i+j] = c[j];
            }
        }
        if(can){
            int tmpcnt = 0;
           for(int j = 0; j+7 <= n; ++j){
                if( c == ss.substr(j,7)){
                    tmpcnt++;
                }
           }
           if(tmpcnt != 1){
                can = false;
           }
        }
        //qpos.clear();
        if(can){
            cout << "Yes \n";
            for(auto a : ss){
                if(a == '?')cout <<"d";
                else cout << a;
            }
            cout << "\n";
            return;
        }
    }
   cout << "No\n";

}
int main(){

	//ios_base::sync_with_stdio(false);
	//cin.tie(nullptr);
	//cout.tie(nullptr);
	//initprime();
	//cout << setprecision(12);
	//cout << fixed;
	int t;
	int count = 1;
	for( cin >> t;t--; solve(count),count++);
	return 0;
}


/* author   : mpily :-()
title : Competing.cpp
time :Sun Jun 14 13:11:23 2020

*/
#include<climits>
#include<random>
#include<cassert>
#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
#include<algorithm>
#include<utility>
#include<cstdint>
#include<queue>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstdio>
#include<bitset>
//4611686018427387903
using namespace std;
//magic lines for ordered_set
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
const uint64_t mod = 4294967296;
vector<vector<int64_t>> multiply(vector<vector<int64_t>>lhs,vector<vector<int64_t>>rhs){
    vector<vector<int64_t>> prod(lhs.size(),vector<int64_t>(rhs[0].size()));
    for(int i = 0;i < (int)lhs.size(); ++i){
        for(int j = 0; j < (int)rhs[0].size(); ++j){
            prod[i][j] = 1e18+5;
            for(int k = 0; k < (int)rhs.size(); ++k){
                prod[i][j] = min(prod[i][j], lhs[i][k] + rhs[k][j]);
               // prod[i][j]%=mod;
            }
        }
    }
    return prod;
}

/*
***************************************************************************************
do bfs for all nodes starting with those that are either roots or leaves

****************************************************************************************
start code here
*/
void solve(int cnum){
   int n;
   cin>> n;
   string s;
   cin >> s;
   string c = "abacaba";
   int count = 0;
   for(int i = 0;i + 6 < n; ++i){
        bool can = true;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j]){
                can = false;
                break;
            }
        }
        if(can)
            count ++;
   }
   if(count > 1){
    cout << "No\n";
    return;
   }
   else if (count == 1){
    cout << "Yes\n";
    for(auto a : s){
        if(a == '?')cout << 'd';
        else cout << a;
    }
    cout << "\n";
    return;
   }
    for(int i = 0;i + 6 < n; ++i){
        bool can = true;
        vector<int>qpos;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j] && s[i+j] != '?'){
                can = false;
                break;
            }
            else if(s[i+j] == '?'){
                qpos.push_back(i+j);
                s[i+j] = c[j];
            }
        }
        if(can){
            int tmpcnt = 0;
           for(int j = i-7; j <= i + 7; ++j){
                if(j >= 0 &&j + 7 <= n&& c == s.substr(j,7)){
                    tmpcnt++;
                }
           }
           if(tmpcnt > 1){
                can = false;
                for(auto a : qpos){
                    s[a] = '?';
                }
           }
        }
        if(can){
            cout << "Yes \n";
            for(auto a : s){
                if(a == '?')cout <<"d";
                else cout << a;
            }
            cout << "\n";
            return;
        }
   }
   cout << "No\n";

}
int main(){

	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	//cout.tie(nullptr);
	//initprime();
	cout << setprecision(12);
	cout << fixed;
	int t;
	int count = 1;
	for( cin >> t;t--; solve(count),count++);
	return 0;
}


/* author   : mpily :-()
title : Competing.cpp
time :Sun Jun 14 13:11:23 2020

*/
#include<climits>
#include<random>
#include<cassert>
#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
#include<algorithm>
#include<utility>
#include<cstdint>
#include<queue>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstdio>
#include<bitset>
//4611686018427387903
using namespace std;
//magic lines for ordered_set
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
const uint64_t mod = 4294967296;
vector<vector<int64_t>> multiply(vector<vector<int64_t>>lhs,vector<vector<int64_t>>rhs){
    vector<vector<int64_t>> prod(lhs.size(),vector<int64_t>(rhs[0].size()));
    for(int i = 0;i < (int)lhs.size(); ++i){
        for(int j = 0; j < (int)rhs[0].size(); ++j){
            prod[i][j] = 1e18+5;
            for(int k = 0; k < (int)rhs.size(); ++k){
                prod[i][j] = min(prod[i][j], lhs[i][k] + rhs[k][j]);
               // prod[i][j]%=mod;
            }
        }
    }
    return prod;
}

/*
***************************************************************************************
do bfs for all nodes starting with those that are either roots or leaves

****************************************************************************************
start code here
*/
void solve(int cnum){
   int n;
   cin>> n;
   string s;
   cin >> s;
   string c = "abacaba";
   int count = 0;
   for(int i = 0;i + 6 < n; ++i){
        bool can = true;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j]){
                can = false;
                break;
            }
        }
        if(can)
            count ++;
   }
   if(count > 1){
    cout << "No\n";
    return;
   }
   else if (count == 1){
    cout << "Yes\n";
    for(auto a : s){
        if(a == '?')cout << 'd';
        else cout << a;
    }
    cout << "\n";
    return;
   }
    for(int i = 0;i + 6 < n; ++i){
        bool can = true;
        vector<int>qpos;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j] && s[i+j] != '?'){
                can = false;
                break;
            }
            else if(s[i+j] == '?'){
                qpos.push_back(i+j);
                s[i+j] = c[j];
            }
        }
        if(can && qpos.size() && qpos.back() >= i+4){
            //cout << "checking from "<< i+4 <<"\n";
            bool fcan = true;bool fcan2 = true;
            for(int j = 0; j < 7; ++j){
                if(i+j + 4 >= n){
                    fcan = false;
                    break;
                }
                if(s[i+j+4] != c[j]){
                   // cout << "difference "<< i+j+4 <<"\n";
                    fcan = false;
                    break;
                }
            }
            for(int j = 0; j < 7; ++j){
                if(i+j + 6 >= n){
                    fcan2 = false;
                    break;
                }
                if(s[i+j+6] != c[j]){
                   // cout << "difference "<< i+j+4 <<"\n";
                    fcan2 = false;
                    break;
                }
            }
            if(fcan || fcan2){
                //cout << "entered here \n";
                can = false;
                for(auto a : qpos){
                    s[a] = '?';
                }
                i+=6;
            }
        }
        if(can){
            cout << "Yes \n";
            for(auto a : s){
                if(a == '?')cout <<"d";
                else cout << a;
            }
            cout << "\n";
            return;
        }
   }
   cout << "No\n";

}
int main(){

	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	//cout.tie(nullptr);
	//initprime();
	cout << setprecision(12);
	cout << fixed;
	int t;
	int count = 1;
	for( cin >> t;t--; solve(count),count++);
	return 0;
}


/* author   : mpily :-()
title : Competing.cpp
time :Sun Jun 14 13:11:23 2020

*/
#include<climits>
#include<random>
#include<cassert>
#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
#include<algorithm>
#include<utility>
#include<cstdint>
#include<queue>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstdio>
#include<bitset>
//4611686018427387903
using namespace std;
//magic lines for ordered_set
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
const uint64_t mod = 4294967296;
vector<vector<int64_t>> multiply(vector<vector<int64_t>>lhs,vector<vector<int64_t>>rhs){
    vector<vector<int64_t>> prod(lhs.size(),vector<int64_t>(rhs[0].size()));
    for(int i = 0;i < (int)lhs.size(); ++i){
        for(int j = 0; j < (int)rhs[0].size(); ++j){
            prod[i][j] = 1e18+5;
            for(int k = 0; k < (int)rhs.size(); ++k){
                prod[i][j] = min(prod[i][j], lhs[i][k] + rhs[k][j]);
               // prod[i][j]%=mod;
            }
        }
    }
    return prod;
}

/*
***************************************************************************************
do bfs for all nodes starting with those that are either roots or leaves

****************************************************************************************
start code here
*/
void solve(int cnum){
   int n;
   cin>> n;
   string s;
   cin >> s;
   string c = "abacaba";
   int count = 0;
   for(int i = 0;i + 6 < n; ++i){
        bool can = true;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j]){
                can = false;
                break;
            }
        }
        if(can)
            count ++;
   }
   if(count > 1){
    cout << "No\n";
    return;
   }
   else if (count == 1){
    cout << "Yes\n";
    for(auto a : s){
        if(a == '?')cout << 'd';
        else cout << a;
    }
    cout << "\n";
    return;
   }
    for(int i = 0;i + 6 < n; ++i){
        bool can = true;
        vector<int>qpos;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j] && s[i+j] != '?'){
                can = false;
                break;
            }
            else if(s[i+j] == '?'){
                qpos.push_back(i+j);
                s[i+j] = c[j];
            }
        }
        if(can && qpos.size() && qpos.back() >= i+4){
            bool fcan = true;
            for(int j = 0; j < 7; ++j){
                if(i+j + 4 >= n){
                    fcan = false;
                    break;
                }
                if(s[i+j+4] != c[j]){
                    fcan = false;
                    break;
                }
            }
            if(fcan){
                can = false;
                for(auto a : qpos){
                    s[a] = '?';
                }
            }
        }
        if(can){
            cout << "Yes \n";
            for(auto a : s){
                if(a == '?')cout <<"d";
                else cout << a;
            }
            cout << "\n";
            return;
        }
   }
   cout << "No\n";

}
int main(){

	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	//cout.tie(nullptr);
	//initprime();
	cout << setprecision(12);
	cout << fixed;
	int t;
	int count = 1;
	for( cin >> t;t--; solve(count),count++);
	return 0;
}


/* author   : mpily :-()
title : Competing.cpp
time :Sun Jun 14 13:11:23 2020

*/
#include<climits>
#include<random>
#include<cassert>
#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
#include<algorithm>
#include<utility>
#include<cstdint>
#include<queue>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstdio>
#include<bitset>
//4611686018427387903
using namespace std;
//magic lines for ordered_set
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
const uint64_t mod = 4294967296;
vector<vector<int64_t>> multiply(vector<vector<int64_t>>lhs,vector<vector<int64_t>>rhs){
    vector<vector<int64_t>> prod(lhs.size(),vector<int64_t>(rhs[0].size()));
    for(int i = 0;i < (int)lhs.size(); ++i){
        for(int j = 0; j < (int)rhs[0].size(); ++j){
            prod[i][j] = 1e18+5;
            for(int k = 0; k < (int)rhs.size(); ++k){
                prod[i][j] = min(prod[i][j], lhs[i][k] + rhs[k][j]);
               // prod[i][j]%=mod;
            }
        }
    }
    return prod;
}

/*
***************************************************************************************
do bfs for all nodes starting with those that are either roots or leaves

****************************************************************************************
start code here
*/

void solve(int cnum){
   int n;
   cin>> n;
   string s;
   cin >> s;
   string c = "abacaba";
   string T = c;
   bool fans = 0; bool ans = 0;
   int count = 0;
   for(int i = 0;i + 7 <= n; ++i){
       // cout << s[i];
        count += (s.substr(i,7) == c);
   }
  // cout << count <<"\n";
   if(count > 1){
    cout << "No\n";
    return;
   }
   else if (count == 1){
    cout << "Yes\n";
    for(auto a : s){
        if(a == '?')cout << 'd';
        else cout << a;
    }
    cout << "\n";
    return;
   }
   else{
    for(int i = 0;i + 7 <= n; ++i){
        bool can = true;
        string ss = s;
       // vector<int>qpos;
        for(int j = 0; j < 7; ++j){
            if(ss[i+j] != c[j] && ss[i+j] != '?'){
                can = false;
                break;
            }
            else{
                //qpos.push_back(i+j);
               ss[i+j] = c[j];
            }
        }
        if(can){
            int tmpcnt = 0;
           for(int j = 0; j+7 <= n; ++j){
                if( c == ss.substr(j,7)){
                    tmpcnt++;
                }
           }
           if(tmpcnt > 1){
                can = false;
           }
        }
        //qpos.clear();
        if(can){
            cout << "Yes \n";
            for(auto a : s){
                if(a == '?')cout <<"d";
                else cout << a;
            }
            cout << "\n";
            return;
        }
    }
   cout << "No\n";
   }

}
int main(){

	//ios_base::sync_with_stdio(false);
	//cin.tie(nullptr);
	//cout.tie(nullptr);
	//initprime();
	//cout << setprecision(12);
	//cout << fixed;
	int t;
	int count = 1;
	for( cin >> t;t--; solve(count),count++);
	return 0;
}


/* author   : mpily :-()
title : Competing.cpp
time :Sun Jun 14 13:11:23 2020

*/
#include<climits>
#include<random>
#include<cassert>
#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
#include<algorithm>
#include<utility>
#include<cstdint>
#include<queue>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstdio>
#include<bitset>
//4611686018427387903
using namespace std;
//magic lines for ordered_set
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
const uint64_t mod = 4294967296;
vector<vector<int64_t>> multiply(vector<vector<int64_t>>lhs,vector<vector<int64_t>>rhs){
    vector<vector<int64_t>> prod(lhs.size(),vector<int64_t>(rhs[0].size()));
    for(int i = 0;i < (int)lhs.size(); ++i){
        for(int j = 0; j < (int)rhs[0].size(); ++j){
            prod[i][j] = 1e18+5;
            for(int k = 0; k < (int)rhs.size(); ++k){
                prod[i][j] = min(prod[i][j], lhs[i][k] + rhs[k][j]);
               // prod[i][j]%=mod;
            }
        }
    }
    return prod;
}

/*
***************************************************************************************
do bfs for all nodes starting with those that are either roots or leaves

****************************************************************************************
start code here
*/
void solve(int cnum){
   int n;
   cin>> n;
   string s;
   cin >> s;
   string c = "abacaba";
   int count = 0;
   for(int i = 0;i + 7 <= n; ++i){
       // cout << s[i];
        count += (s.substr(i,7) == c);
   }
  // cout << count <<"\n";
   if(count > 1){
    cout << "No\n";
    return;
   }
   else if (count == 1){
    cout << "Yes\n";
    for(auto a : s){
        if(a == '?')cout << 'd';
        else cout << a;
    }
    cout << "\n";
    return;
   }
   else{
    for(int i = 0;i + 7 <= n; ++i){
        bool can = true;
        vector<int>qpos;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j] && s[i+j] != '?'){
               // cout << i <<"refused because of "<<s[i+j]<<"\n";
                can = false;
                break;
            }
            else if(s[i+j] == '?'){

                qpos.push_back(i+j);
                s[i+j] = c[j];
            }
        }
        if(can){
           // cout << "can get here for "<<i<<"\n";
            int tmpcnt = 0;
           for(int j = 0; j+7 <= n; ++j){
                if( c == s.substr(j,7)){
                    tmpcnt++;
                }
           }
           if(tmpcnt > 1){
                can = false;
                for(auto a : qpos){
                    s[a] = '?';
                }
           }
        }
        for(auto a : qpos)
            s[a] = '?';
        qpos.clear();
        if(can){
            cout << "Yes \n";
            for(auto a : s){
                if(a == '?')cout <<"d";
                else cout << a;
            }
            cout << "\n";
            return;
        }
   }
   cout << "No\n";
   }

}
int main(){

	//ios_base::sync_with_stdio(false);
	//cin.tie(nullptr);
	//cout.tie(nullptr);
	//initprime();
	//cout << setprecision(12);
	//cout << fixed;
	int t;
	int count = 1;
	for( cin >> t;t--; solve(count),count++);
	return 0;
}


/* author   : mpily :-()
title : Competing.cpp
time :Sun Jun 14 13:11:23 2020

*/
#include<climits>
#include<random>
#include<cassert>
#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
#include<algorithm>
#include<utility>
#include<cstdint>
#include<queue>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstdio>
#include<bitset>
//4611686018427387903
using namespace std;
//magic lines for ordered_set
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
const uint64_t mod = 4294967296;
vector<vector<int64_t>> multiply(vector<vector<int64_t>>lhs,vector<vector<int64_t>>rhs){
    vector<vector<int64_t>> prod(lhs.size(),vector<int64_t>(rhs[0].size()));
    for(int i = 0;i < (int)lhs.size(); ++i){
        for(int j = 0; j < (int)rhs[0].size(); ++j){
            prod[i][j] = 1e18+5;
            for(int k = 0; k < (int)rhs.size(); ++k){
                prod[i][j] = min(prod[i][j], lhs[i][k] + rhs[k][j]);
               // prod[i][j]%=mod;
            }
        }
    }
    return prod;
}

/*
***************************************************************************************
do bfs for all nodes starting with those that are either roots or leaves

****************************************************************************************
start code here
*/
void solve(int cnum){
   int n;
   cin>> n;
   string s;
   cin >> s;
   string c = "abacaba";
   int count = 0;
   for(int i = 0;i + 6 < n; ++i){
        count += (s.substr(i,7) == c);
   }
   if(count > 1){
    cout << "No\n";
    return;
   }
   else if (count == 1){
    cout << "Yes\n";
    for(auto a : s){
        if(a == '?')cout << 'd';
        else cout << a;
    }
    cout << "\n";
    return;
   }
    for(int i = 0;i + 6 < n; ++i){
        bool can = true;
        vector<int>qpos;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j] && s[i+j] != '?'){
                can = false;
                break;
            }
            else if(s[i+j] == '?'){
                qpos.push_back(i+j);
                s[i+j] = c[j];
            }
        }
        if(can){
            int tmpcnt = 0;
           for(int j = i-7; j <= i + 7; ++j){
                if(j >= 0 &&j + 7 <= n&& c == s.substr(j,7)){
                    tmpcnt++;
                }
           }
           if(tmpcnt > 1){
                can = false;
                for(auto a : qpos){
                    s[a] = '?';
                }
           }
        }
        qpos.clear();
        if(can){
            cout << "Yes \n";
            for(auto a : s){
                if(a == '?')cout <<"d";
                else cout << a;
            }
            cout << "\n";
            return;
        }
   }
   cout << "No\n";

}
int main(){

	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	//cout.tie(nullptr);
	//initprime();
	cout << setprecision(12);
	cout << fixed;
	int t;
	int count = 1;
	for( cin >> t;t--; solve(count),count++);
	return 0;
}


/* author   : mpily :-()
title : Competing.cpp
time :Sun Jun 14 13:11:23 2020

*/
#include<climits>
#include<random>
#include<cassert>
#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
#include<algorithm>
#include<utility>
#include<cstdint>
#include<queue>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstdio>
#include<bitset>
//4611686018427387903
using namespace std;
//magic lines for ordered_set
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
const uint64_t mod = 4294967296;
vector<vector<int64_t>> multiply(vector<vector<int64_t>>lhs,vector<vector<int64_t>>rhs){
    vector<vector<int64_t>> prod(lhs.size(),vector<int64_t>(rhs[0].size()));
    for(int i = 0;i < (int)lhs.size(); ++i){
        for(int j = 0; j < (int)rhs[0].size(); ++j){
            prod[i][j] = 1e18+5;
            for(int k = 0; k < (int)rhs.size(); ++k){
                prod[i][j] = min(prod[i][j], lhs[i][k] + rhs[k][j]);
               // prod[i][j]%=mod;
            }
        }
    }
    return prod;
}

/*
***************************************************************************************
do bfs for all nodes starting with those that are either roots or leaves

****************************************************************************************
start code here
*/
void solve(int cnum){
   int n;
   cin>> n;
   string s;
   cin >> s;
   string c = "abacaba";
   int count = 0;
   for(int i = 0;i + 6 < n; ++i){
        bool can = true;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j]){
                can = false;
                break;
            }
        }
        if(can)
            count ++;
   }
   if(count > 1){
    cout << "No\n";
    return;
   }
   else if (count == 1){
    cout << "Yes\n";
    for(auto a : s){
        if(a == '?')cout << 'd';
        else cout << a;
    }
    cout << "\n";
    return;
   }
    for(int i = 0;i + 6 < n; ++i){
        bool can = true;
        vector<int>qpos;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j] && s[i+j] != '?'){
                can = false;
                break;
            }
            else if(s[i+j] == '?'){
                qpos.push_back(i+j);
                s[i+j] = c[j];
            }
        }
        if(can && qpos.size() && qpos.back() >= i+4){
            //cout << "checking from "<< i+4 <<"\n";
            bool fcan = true;bool fcan2 = true;
            for(int j = 0; j < 7; ++j){
                if(i+j + 4 >= n){
                    fcan = false;
                    break;
                }
                if(s[i+j+4] != c[j]){
                   // cout << "difference "<< i+j+4 <<"\n";
                    fcan = false;
                    break;
                }
            }
            for(int j = 0; j < 7; ++j){
                if(i+j + 6 >= n){
                    fcan2 = false;
                    break;
                }
                if(s[i+j+6] != c[j]){
                   // cout << "difference "<< i+j+4 <<"\n";
                    fcan2 = false;
                    break;
                }
            }
            if(fcan || fcan2){
                //cout << "entered here \n";
                can = false;
                for(auto a : qpos){
                    s[a] = '?';
                }
                i+=7;
            }
        }
        if(can){
            cout << "Yes \n";
            for(auto a : s){
                if(a == '?')cout <<"d";
                else cout << a;
            }
            cout << "\n";
            return;
        }
   }
   cout << "No\n";

}
int main(){

	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	//cout.tie(nullptr);
	//initprime();
	cout << setprecision(12);
	cout << fixed;
	int t;
	int count = 1;
	for( cin >> t;t--; solve(count),count++);
	return 0;
}


/* author   : mpily :-()
title : Competing.cpp
time :Sun Jun 14 13:11:23 2020

*/
#include<climits>
#include<random>
#include<cassert>
#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
#include<algorithm>
#include<utility>
#include<cstdint>
#include<queue>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstdio>
#include<bitset>
//4611686018427387903
using namespace std;
//magic lines for ordered_set
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
const uint64_t mod = 4294967296;
vector<vector<int64_t>> multiply(vector<vector<int64_t>>lhs,vector<vector<int64_t>>rhs){
    vector<vector<int64_t>> prod(lhs.size(),vector<int64_t>(rhs[0].size()));
    for(int i = 0;i < (int)lhs.size(); ++i){
        for(int j = 0; j < (int)rhs[0].size(); ++j){
            prod[i][j] = 1e18+5;
            for(int k = 0; k < (int)rhs.size(); ++k){
                prod[i][j] = min(prod[i][j], lhs[i][k] + rhs[k][j]);
               // prod[i][j]%=mod;
            }
        }
    }
    return prod;
}

/*
***************************************************************************************
do bfs for all nodes starting with those that are either roots or leaves

****************************************************************************************
start code here
*/
void solve(int cnum){
   int n;
   cin>> n;
   string s;
   cin >> s;
   string c = "abacaba";
   int count = 0;
   for(int i = 0;i + 6 < n; ++i){
        bool can = true;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j]){
                can = false;
                break;
            }
        }
        if(can)
            count ++;
   }
   if(count > 1){
    cout << "No\n";
    return;
   }
   else if (count == 1){
    cout << "Yes\n";
    for(auto a : s){
        if(a == '?')cout << 'd';
        else cout << a;
    }
    cout << "\n";
    return;
   }
    for(int i = 0;i + 6 < n; ++i){
        bool can = true;
        vector<int>qpos;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j] && s[i+j] != '?'){
                can = false;
                break;
            }
            else if(s[i+j] == '?'){
                qpos.push_back(i+j);
                s[i+j] = c[j];
            }
        }
        if(can && qpos.size() && qpos.back() >= i+4){
            //cout << "checking from "<< i+4 <<"\n";
            bool fcan = true;
            for(int j = 0; j < 7; ++j){
                if(i+j + 4 >= n){
                    fcan = false;
                    break;
                }
                if(s[i+j+4] != c[j]){
                   // cout << "difference "<< i+j+4 <<"\n";
                    fcan = false;
                    break;
                }
            }
            if(fcan){
                //cout << "entered here \n";
                can = false;
                for(auto a : qpos){
                    s[a] = '?';
                }
                i+=6;
            }
        }
        if(can){
            cout << "Yes \n";
            for(auto a : s){
                if(a == '?')cout <<"d";
                else cout << a;
            }
            cout << "\n";
            return;
        }
   }
   cout << "No\n";

}
int main(){

	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	//cout.tie(nullptr);
	//initprime();
	cout << setprecision(12);
	cout << fixed;
	int t;
	int count = 1;
	for( cin >> t;t--; solve(count),count++);
	return 0;
}


/* author   : mpily :-()
title : Competing.cpp
time :Sun Jun 14 13:11:23 2020

*/
#include<climits>
#include<random>
#include<cassert>
#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
#include<algorithm>
#include<utility>
#include<cstdint>
#include<queue>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstdio>
#include<bitset>
//4611686018427387903
using namespace std;
//magic lines for ordered_set
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
const uint64_t mod = 4294967296;
vector<vector<int64_t>> multiply(vector<vector<int64_t>>lhs,vector<vector<int64_t>>rhs){
    vector<vector<int64_t>> prod(lhs.size(),vector<int64_t>(rhs[0].size()));
    for(int i = 0;i < (int)lhs.size(); ++i){
        for(int j = 0; j < (int)rhs[0].size(); ++j){
            prod[i][j] = 1e18+5;
            for(int k = 0; k < (int)rhs.size(); ++k){
                prod[i][j] = min(prod[i][j], lhs[i][k] + rhs[k][j]);
               // prod[i][j]%=mod;
            }
        }
    }
    return prod;
}

/*
***************************************************************************************
do bfs for all nodes starting with those that are either roots or leaves

****************************************************************************************
start code here
*/
void solve(int cnum){
   int n;
   cin>> n;
   string s;
   cin >> s;
   string c = "abacaba";
   int count = 0;
   for(int i = 0;i + 6 < n; ++i){
        bool can = true;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j]){
                can = false;
                break;
            }
        }
        if(can)
            count ++;
   }
   if(count > 1){
    cout << "No\n";
    return;
   }
   else if (count == 1){
    cout << "Yes\n";
    for(auto a : s){
        if(a == '?')cout << 'd';
        else cout << a;
    }
    cout << "\n";
    return;
   }
    for(int i = 0;i + 6 < n; ++i){
        bool can = true;
        vector<int>qpos;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j] && s[i+j] != '?'){
                can = false;
                break;
            }
            else if(s[i+j] == '?'){
                qpos.push_back(i+j);
                s[i+j] = c[j];
            }
        }
        if(can && qpos.size() && qpos.back() >= i+4){
            //cout << "checking from "<< i+4 <<"\n";
            bool fcan = true;
            for(int j = 0; j < 7; ++j){
                if(i+j + 4 >= n){
                    fcan = false;
                    break;
                }
                if(s[i+j+4] != c[j]){
                   // cout << "difference "<< i+j+4 <<"\n";
                    fcan = false;
                    break;
                }
            }
            if(fcan){
                //cout << "entered here \n";
                can = false;
                for(auto a : qpos){
                    s[a] = '?';
                }
                i+=5;
            }
        }
        if(can){
            cout << "Yes \n";
            for(auto a : s){
                if(a == '?')cout <<"d";
                else cout << a;
            }
            cout << "\n";
            return;
        }
   }
   cout << "No\n";

}
int main(){

	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	//cout.tie(nullptr);
	//initprime();
	cout << setprecision(12);
	cout << fixed;
	int t;
	int count = 1;
	for( cin >> t;t--; solve(count),count++);
	return 0;
}


/* author   : mpily :-()
title : Competing.cpp
time :Sun Jun 14 13:11:23 2020

*/
#include<climits>
#include<random>
#include<cassert>
#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
#include<algorithm>
#include<utility>
#include<cstdint>
#include<queue>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstdio>
#include<bitset>
//4611686018427387903
using namespace std;
//magic lines for ordered_set
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
const uint64_t mod = 4294967296;
vector<vector<int64_t>> multiply(vector<vector<int64_t>>lhs,vector<vector<int64_t>>rhs){
    vector<vector<int64_t>> prod(lhs.size(),vector<int64_t>(rhs[0].size()));
    for(int i = 0;i < (int)lhs.size(); ++i){
        for(int j = 0; j < (int)rhs[0].size(); ++j){
            prod[i][j] = 1e18+5;
            for(int k = 0; k < (int)rhs.size(); ++k){
                prod[i][j] = min(prod[i][j], lhs[i][k] + rhs[k][j]);
               // prod[i][j]%=mod;
            }
        }
    }
    return prod;
}

/*
***************************************************************************************
do bfs for all nodes starting with those that are either roots or leaves

****************************************************************************************
start code here
*/
void solve(int cnum){
   int n;
   cin>> n;
   string s;
   cin >> s;
   string c = "abacaba";
   int count = 0;
   for(int i = 0;i + 6 < n; ++i){
        count += (s.substr(i,7) == c);
   }
   if(count > 1){
    cout << "No\n";
    return;
   }
   else if (count == 1){
    cout << "Yes\n";
    for(auto a : s){
        if(a == '?')cout << 'd';
        else cout << a;
    }
    cout << "\n";
    return;
   }
    for(int i = 0;i + 6 < n; ++i){
        bool can = true;
        vector<int>qpos;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j] && s[i+j] != '?'){
                can = false;
                break;
            }
            else if(s[i+j] == '?'){
                qpos.push_back(i+j);
                s[i+j] = c[j];
            }
        }
        if(can){
            int tmpcnt = 0;
           for(int j = i-7; j <= i + 7; ++j){
                if(j >= 0 &&j + 7 <= n&& c == s.substr(j,7)){
                    tmpcnt++;
                }
           }
           if(tmpcnt > 1){
                can = false;
                for(auto a : qpos){
                    s[a] = '?';
                }
           }
        }
        qpos.clear();
        if(can){
            cout << "Yes \n";
            for(auto a : s){
                if(a == '?')cout <<"d";
                else cout << a;
            }
            cout << "\n";
            return;
        }
   }
   cout << "No\n";

}
int main(){

	//ios_base::sync_with_stdio(false);
	//cin.tie(nullptr);
	//cout.tie(nullptr);
	//initprime();
	//cout << setprecision(12);
	//cout << fixed;
	int t;
	int count = 1;
	for( cin >> t;t--; solve(count),count++);
	return 0;
}


/* author   : mpily :-()
title : Competing.cpp
time :Sun Jun 14 13:11:23 2020

*/
#include<climits>
#include<random>
#include<cassert>
#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
#include<algorithm>
#include<utility>
#include<cstdint>
#include<queue>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstdio>
#include<bitset>
//4611686018427387903
using namespace std;
//magic lines for ordered_set
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
const uint64_t mod = 4294967296;
vector<vector<int64_t>> multiply(vector<vector<int64_t>>lhs,vector<vector<int64_t>>rhs){
    vector<vector<int64_t>> prod(lhs.size(),vector<int64_t>(rhs[0].size()));
    for(int i = 0;i < (int)lhs.size(); ++i){
        for(int j = 0; j < (int)rhs[0].size(); ++j){
            prod[i][j] = 1e18+5;
            for(int k = 0; k < (int)rhs.size(); ++k){
                prod[i][j] = min(prod[i][j], lhs[i][k] + rhs[k][j]);
               // prod[i][j]%=mod;
            }
        }
    }
    return prod;
}

/*
***************************************************************************************
do bfs for all nodes starting with those that are either roots or leaves

****************************************************************************************
start code here
*/
void solve(int cnum){
   int n;
   cin>> n;
   string s;
   cin >> s;
   string c = "abacaba";
   int count = 0;
   for(int i = 0;i + 7 <= n; ++i){
       // cout << s[i];
        count += (s.substr(i,7) == c);
   }
  // cout << count <<"\n";
   if(count > 1){
    cout << "No\n";
    return;
   }
   else if (count == 1){
    cout << "Yes\n";
    for(auto a : s){
        if(a == '?')cout << 'd';
        else cout << a;
    }
    cout << "\n";
    return;
   }
   else{
    for(int i = 0;i + 7 <= n; ++i){
        bool can = true;
        vector<int>qpos;
        for(int j = 0; j < 7; ++j){
            if(s[i+j] != c[j] && s[i+j] != '?'){
                can = false;
                break;
            }
            else if(s[i+j] == '?'){
                qpos.push_back(i+j);
                s[i+j] = c[j];
            }
        }
        if(can){
            int tmpcnt = 0;
           for(int j = 0; j+7 <= n; ++j){
                if( c == s.substr(j,7)){
                    tmpcnt++;
                }
           }
           if(tmpcnt > 1){
                can = false;
                for(auto a : qpos){
                    s[a] = '?';
                }
           }
        }
        qpos.clear();
        if(can){
            cout << "Yes \n";
            for(auto a : s){
                if(a == '?')cout <<"d";
                else cout << a;
            }
            cout << "\n";
            return;
        }
   }
   cout << "No\n";
   }

}
int main(){

	//ios_base::sync_with_stdio(false);
	//cin.tie(nullptr);
	//cout.tie(nullptr);
	//initprime();
	//cout << setprecision(12);
	//cout << fixed;
	int t;
	int count = 1;
	for( cin >> t;t--; solve(count),count++);
	return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
#include "math.h"
#include "unordered_map"
#include <set>
#include <time.h>
#include <deque>
#include <iomanip>
#include <map>
#include <queue>
#include <stack>
#include <memory.h>

using namespace std;
typedef long long int ll;
typedef long double ld;
#define debug(val) "[ " << #val " : " << (val)
#define space " "
#define vi vector<int>
#define PI (double)(atan(1)*4)
#define pb push_back
#define pi pair<int , int >
#define ff first
#define ss second
#define INF 2000000000
vi dx = {-1, 0, 0, 1};
vi dy = {0, -1, 1, 0};
string s;
int n;
const string target = "abacaba";

bool check(int idx) {
    if (idx + 6 >= n) return false;
    bool ok = true;
    for (int i = 0; i < 7; i++) {
        ok &= target[i] == s[idx + i];
    }
    return ok;
}

bool check2(int idx) {
    if (idx + 2 >= n) return false;
    return (s[idx++] == 'a') && (s[idx++] == 'b') && s[idx++] == 'a';
}

void solve() {
    cin >> n;
    cin >> s;
    int cnt = 0;
    for (int i = 0; i < n; i++) {
        cnt += check(i);
    }
    if (cnt == 1) {
        cout << "YES" << endl;
        for (auto c : s) {
            if (c == '?') c = 'z';
            cout << c;
        }
        cout << endl;

    } else if (cnt > 1)
        cout << "NO";
    else {
        bool found = false ;
        for (int i = 0; i + 6 < n; i++) {
            bool ok = true;
            for (int j = 0; j < 7; j++) {
                ok &= s[i + j] == target[j];
            }
            if (ok) {
                if (check(i + 6) || check2(i + 4)) ok = false;
            }
            if(ok ) {
                found = true ;
                for(int j=0;j<7;j++) s[i+j] = target[j] ;
            }
        }
        if(found) {
            for(auto c : s) {
                if(c == '?') c= 'z' ;
                cout << c ;
            }
            cout << endl;
        }else cout << "NO" << endl;
    }

}

int main() {
#ifdef _DEBUG // place in cmake-build-debug folder
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int q = 1;
    cin >> q;
    for (int i = 1; i <= q; i++) {
        //   cout << "Case #" << i << ": ";
        solve();
    }
}


#include <iostream>
#include <vector>
#include <algorithm>
#include "math.h"
#include "unordered_map"
#include <set>
#include <time.h>
#include <deque>
#include <iomanip>
#include <map>
#include <queue>
#include <stack>
#include <memory.h>

using namespace std;
typedef long long int ll;
typedef long double ld;
#define debug(val) "[ " << #val " : " << (val)
#define space " "
#define vi vector<int>
#define PI (double)(atan(1)*4)
#define pb push_back
#define pi pair<int , int >
#define ff first
#define ss second
#define INF 2000000000
vi dx = {-1, 0, 0, 1};
vi dy = {0, -1, 1, 0};
string s;
int n;
const string target = "abacaba";

bool check(int idx) {
    if (idx + 6 >= n) return false;
    bool ok = true;
    for (int i = 0; i < 7; i++) {
        ok &= (target[i] == s[idx + i]);
    }
    return ok;
}

bool check2(int idx) {
    if (idx + 2 >= n) return false;
    return (s[idx++] == 'a') && (s[idx++] == 'b') && s[idx++] == 'a';
}

void solve() {
    cin >> n;
    cin >> s;
    int cnt = 0;
    for (int i = 0; i < n; i++) {
        cnt += check(i);
    }
    if (cnt == 1) {
        cout << "YES" << endl;
        for (auto c : s) {
            if (c == '?') c = 'z';
            cout << c;
        }
        cout << endl;

    } else if (cnt > 1)
        cout << "NO";
    else {
        bool found = false ;
        for (int i = 0; i + 6 < n; i++) {
            bool ok = true;
            for (int j = 0; j < 7; j++) {
                ok &= ((s[i + j] == target[j]) || s[i+j] == '?');
            }

            if (ok) {
              //  if (check(i + 6) || check2(i + 4)) ok = false;
            }
            if(ok ) {
                found = true ;
                for(int j=0;j<7;j++) s[i+j] = target[j] ;
                break;
            }
        }
        if(found) {
            cout << "YES" << endl;
            for(auto c : s) {
                if(c == '?') c= 'z' ;
                cout << c ;
            }
            cout << endl;
        }else cout << "NO" << endl;
    }

}

int main() {
#ifdef _DEBUG // place in cmake-build-debug folder
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int q = 1;
    cin >> q;
    for (int i = 1; i <= q; i++) {
        //   cout << "Case #" << i << ": ";
        solve();
    }
}


#include <iostream>
#include <vector>
#include <algorithm>
#include "math.h"
#include "unordered_map"
#include <set>
#include <time.h>
#include <deque>
#include <iomanip>
#include <map>
#include <queue>
#include <stack>
#include <memory.h>

using namespace std;
typedef long long int ll;
typedef long double ld;
#define debug(val) "[ " << #val " : " << (val)
#define space " "
#define vi vector<int>
#define PI (double)(atan(1)*4)
#define pb push_back
#define pi pair<int , int >
#define ff first
#define ss second
#define INF 2000000000
vi dx = {-1, 0, 0, 1};
vi dy = {0, -1, 1, 0};
string s;
int n;
const string target = "abacaba";

bool check(int idx) {
    if (idx + 6 >= n) return false;
    bool ok = true;
    for (int i = 0; i < 7; i++) {
        ok &= (target[i] == s[idx + i]);
    }
    return ok;
}

bool check2(int idx) {
    if (idx + 2 >= n) return false;
    return (s[idx++] == 'a') && (s[idx++] == 'b') && s[idx++] == 'a';
}

void solve() {
    cin >> n;
    cin >> s;
    int cnt = 0;
    for (int i = 0; i < n; i++) {
        cnt += check(i);
    }
    if (cnt == 1) {
        cout << "YES" << endl;
        for (auto c : s) {
            if (c == '?') c = 'z';
            cout << c;
        }
        cout << endl;

    } else if (cnt > 1)
        cout << "NO";
    else {
        bool found = false ;
        for (int i = 0; i + 6 < n; i++) {
            bool ok = true;
            for (int j = 0; j < 7; j++) {
                ok &= ((s[i + j] == target[j]) || s[i+j] == '?');
            }
            if (ok) {
                if (check(i + 6) || check2(i + 4)) ok = false;
            }
            if(ok ) {
                found = true ;
                for(int j=0;j<7;j++) s[i+j] = target[j] ;
                break;
            }
        }
        if(found) {
            cout << "YES" << endl;
            for(auto c : s) {
                if(c == '?') c= 'z' ;
                cout << c ;
            }
            cout << endl;
        }else cout << "NO" << endl;
    }

}

int main() {
#ifdef _DEBUG // place in cmake-build-debug folder
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int q = 1;
    cin >> q;
    for (int i = 1; i <= q; i++) {
        //   cout << "Case #" << i << ": ";
        solve();
    }
}


#include <iostream>
#include <vector>
#include <algorithm>
#include "math.h"
#include "unordered_map"
#include <set>
#include <time.h>
#include <deque>
#include <iomanip>
#include <map>
#include <queue>
#include <stack>
#include <memory.h>

using namespace std;
typedef long long int ll;
typedef long double ld;
#define debug(val) "[ " << #val " : " << (val)
#define space " "
#define vi vector<int>
#define PI (double)(atan(1)*4)
#define pb push_back
#define pi pair<int , int >
#define ff first
#define ss second
#define INF 2000000000
vi dx = {-1, 0, 0, 1};
vi dy = {0, -1, 1, 0};
string s;
int n;
const string target = "abacaba";

bool check(int idx , string &s ) {
    if (idx + 6 >= n) return false;
    bool ok = true;
    for (int i = 0; i < 7; i++) {
        ok &= (target[i] == s[idx + i]);
    }
    return ok;
}

void solve() {
    cin >> n;
    cin >> s;
    int cnt = 0;
    for (int i = 0; i < n; i++) {
        cnt += check(i,s);
    }
    if (cnt == 1) {
        cout << "YES" << endl;
        for (auto c : s) {
            if (c == '?') c = 'z';
            cout << c;
        }
        cout << endl;

    } else if (cnt > 1)
        cout << "NO" << endl;
    else {
        for(int i=0;i+6<n;i++){
            string t = s ;
            bool ok = true ;
            for(int j = 0 ; j < 7 ; j++ ){
                ok &= ((t[i+j] == target[j]) || (t[i+j] == '?') ) ;
                if(t[i+j] == '?') t[i+j] = target[j] ;
            }
            if(ok) {
                for(int j=0;j<n;j++) if(i != j )
                    ok &= (!check(j,t)) ;
            }
            if(ok) {
                cout << "YES" << endl;
                for(auto c : s ) cout << (c == '?') ? 'z' : c ;
                cout << endl;
                return ;
            }
        }
        cout << "NO" << endl;
    }

}

int main() {
#ifdef _DEBUG // place in cmake-build-debug folder
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int q = 1;
    cin >> q;
    for (int i = 1; i <= q; i++) {
        //   cout << "Case #" << i << ": ";
        solve();
    }
}


#include <iostream>
#include <vector>
#include <algorithm>
#include "math.h"
#include "unordered_map"
#include <set>
#include <time.h>
#include <deque>
#include <iomanip>
#include <map>
#include <queue>
#include <stack>
#include <memory.h>

using namespace std;
typedef long long int ll;
typedef long double ld;
#define debug(val) "[ " << #val " : " << (val)
#define space " "
#define vi vector<int>
#define PI (double)(atan(1)*4)
#define pb push_back
#define pi pair<int , int >
#define ff first
#define ss second
#define INF 2000000000
vi dx = {-1, 0, 0, 1};
vi dy = {0, -1, 1, 0};
string s;
int n;
const string target = "abacaba";

bool check(int idx) {
    if (idx + 6 >= n) return false;
    bool ok = true;
    for (int i = 0; i < 7; i++) {
        ok &= (target[i] == s[idx + i]);
    }
    return ok;
}

bool check2(int idx) {
    if (idx + 2 >= n) return false;
    return (s[idx++] == 'a') && (s[idx++] == 'b') && s[idx++] == 'a';
}

void solve() {
    cin >> n;
    cin >> s;
    int cnt = 0;
    for (int i = 0; i < n; i++) {
        cnt += check(i);
    }
    if (cnt == 1) {
        cout << "YES" << endl;
        for (auto c : s) {
            if (c == '?') c = 'z';
            cout << c;
        }
        cout << endl;

    } else if (cnt > 1)
        cout << "NO";
    else {
        bool found = false ;
        for (int i = 0; i + 7 < n; i++) {
            bool ok = true;
            for (int j = 0; j < 7; j++) {
                ok &= ((s[i + j] == target[j]) || s[i+j] == '?');
            }
            if (ok) {
                if (check(i + 6) || check2(i + 4)) ok = false;
            }
            if(ok ) {
                found = true ;
                for(int j=0;j<7;j++) s[i+j] = target[j] ;
            }
        }
        if(found) {
            cout << "YES" << endl;
            for(auto c : s) {
                if(c == '?') c= 'z' ;
                cout << c ;
            }
            cout << endl;
        }else cout << "NO" << endl;
    }

}

int main() {
#ifdef _DEBUG // place in cmake-build-debug folder
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int q = 1;
    cin >> q;
    for (int i = 1; i <= q; i++) {
        //   cout << "Case #" << i << ": ";
        solve();
    }
}


#include <iostream>
#include <vector>
#include <algorithm>
#include "math.h"
#include "unordered_map"
#include <set>
#include <time.h>
#include <deque>
#include <iomanip>
#include <map>
#include <queue>
#include <stack>
#include <memory.h>

using namespace std;
typedef long long int ll;
typedef long double ld;
#define debug(val) "[ " << #val " : " << (val)
#define space " "
#define vi vector<int>
#define PI (double)(atan(1)*4)
#define pb push_back
#define pi pair<int , int >
#define ff first
#define ss second
#define INF 2000000000
vi dx = {-1, 0, 0, 1};
vi dy = {0, -1, 1, 0};
string s;
int n;
const string target = "abacaba";

bool check(int idx) {
    if (idx + 6 >= n) return false;
    bool ok = true;
    for (int i = 0; i < 7; i++) {
        ok &= target[i] == s[idx + i];
    }
    return ok;
}

bool check2(int idx) {
    if (idx + 2 >= n) return false;
    return (s[idx++] == 'a') && (s[idx++] == 'b') && s[idx++] == 'a';
}

void solve() {
    cin >> n;
    cin >> s;
    int cnt = 0;
    for (int i = 0; i < n; i++) {
        cnt += check(i);
    }
    if (cnt == 1) {
        cout << "YES" << endl;
        for (auto c : s) {
            if (c == '?') c = 'z';
            cout << c;
        }
        cout << endl;

    } else if (cnt > 1)
        cout << "NO";
    else {
        bool found = false ;
        for (int i = 0; i + 6 < n; i++) {
            bool ok = true;
            for (int j = 0; j < 7; j++) {
                ok &= ((s[i + j] == target[j]) || s[i+j] == '?');
            }
            if (ok) {
                if (check(i + 6) || check2(i + 4)) ok = false;
            }
            if(ok ) {
                found = true ;
                for(int j=0;j<7;j++) s[i+j] = target[j] ;
            }
        }
        if(found) {
            cout << "YES" << endl;
            for(auto c : s) {
                if(c == '?') c= 'z' ;
                cout << c ;
            }
            cout << endl;
        }else cout << "NO" << endl;
    }

}

int main() {
#ifdef _DEBUG // place in cmake-build-debug folder
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int q = 1;
    cin >> q;
    for (int i = 1; i <= q; i++) {
        //   cout << "Case #" << i << ": ";
        solve();
    }
}


#include <iostream>
#include <vector>
#include <algorithm>
#include "math.h"
#include "unordered_map"
#include <set>
#include <time.h>
#include <deque>
#include <iomanip>
#include <map>
#include <queue>
#include <stack>
#include <memory.h>

using namespace std;
typedef long long int ll;
typedef long double ld;
#define debug(val) "[ " << #val " : " << (val)
#define space " "
#define vi vector<int>
#define PI (double)(atan(1)*4)
#define pb push_back
#define pi pair<int , int >
#define ff first
#define ss second
#define INF 2000000000
vi dx = {-1, 0, 0, 1};
vi dy = {0, -1, 1, 0};
string s;
int n;
const string target = "abacaba";

bool check(int idx , string &s ) {
    if (idx + 6 >= n) return false;
    bool ok = true;
    for (int i = 0; i < 7; i++) {
        ok &= (target[i] == s[idx + i]);
    }
    return ok;
}

void solve() {
    cin >> n;
    cin >> s;
    int cnt = 0;
    for (int i = 0; i < n; i++) {
        cnt += check(i,s);
    }
    if (cnt == 1) {
        cout << "YES" << endl;
        for (auto c : s) {
            if (c == '?') c = 'z';
            cout << c;
        }
        cout << endl;

    } else if (cnt > 1)
        cout << "NO" << endl;
    else {
        for(int i=0;i+6<n;i++){
            string t = s ;
            bool ok = true ;
            for(int j = 0 ; j < 7 ; j++ ){
                ok &= ((t[i+j] == target[j]) || (t[i+j] == '?') ) ;
                if(t[i+j] == '?') t[i+j] = target[j] ;
            }
            if(ok) {
                for(int j=0;j<n;j++) if(i != j )
                    ok &= (!check(j,t)) ;
            }
            if(ok) {
                cout << "YES" << endl;
                for(auto c : t ) cout << ((c == '?') ? 'z' : c) ;
                cout << endl;
                return ;
            }
        }
        cout << "NO" << endl;
    }

}

int main() {
#ifdef _DEBUG // place in cmake-build-debug folder
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int q = 1;
    cin >> q;
    for (int i = 1; i <= q; i++) {
        //   cout << "Case #" << i << ": ";
        solve();
    }
}


#include <iostream>
#include <vector>
#include <algorithm>
#include "math.h"
#include "unordered_map"
#include <set>
#include <time.h>
#include <deque>
#include <iomanip>
#include <map>
#include <queue>
#include <stack>
#include <memory.h>

using namespace std;
typedef long long int ll;
typedef long double ld;
#define debug(val) "[ " << #val " : " << (val)
#define space " "
#define vi vector<int>
#define PI (double)(atan(1)*4)
#define pb push_back
#define pi pair<int , int >
#define ff first
#define ss second
#define INF 2000000000
vi dx = {-1, 0, 0, 1};
vi dy = {0, -1, 1, 0};
string s;
int n;
const string target = "abacaba";

bool check(int idx) {
    if (idx + 6 >= n) return false;
    bool ok = true;
    for (int i = 0; i < 7; i++) {
        ok &= (target[i] == s[idx + i]);
    }
    return ok;
}

bool check2(int idx) {
    if (idx + 2 >= n) return false;
    return (s[idx++] == 'a') && (s[idx++] == 'b') && s[idx++] == 'a';
}

void solve() {
    cin >> n;
    cin >> s;
    int cnt = 0;
    for (int i = 0; i < n; i++) {
        cnt += check(i);
    }
    if (cnt == 1) {
        cout << "YES" << endl;
        for (auto c : s) {
            if (c == '?') c = 'z';
            cout << c;
        }
        cout << endl;

    } else if (cnt > 1)
        cout << "NO" << endl;
    else {
        bool found = false ;
        for (int i = 0; i + 6 < n; i++) {
            bool ok = true;
            for (int j = 0; j < 7; j++) {
                ok &= ((s[i + j] == target[j]) || s[i+j] == '?');
            }

            if (ok) {
               if (check(i + 6) || check2(i + 4)) ok = false;
            }
            if(ok ) {
                found = true ;
                for(int j=0;j<7;j++) s[i+j] = target[j] ;
                break;
            }
        }
        if(found) {
            cout << "YES" << endl;
            for(auto c : s) {
                if(c == '?') c= 'z' ;
                cout << c ;
            }
            cout << endl;
        }else cout << "NO" << endl;
    }

}

int main() {
#ifdef _DEBUG // place in cmake-build-debug folder
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int q = 1;
    cin >> q;
    for (int i = 1; i <= q; i++) {
        //   cout << "Case #" << i << ": ";
        solve();
    }
}


#include <iostream>
#include <vector>
#include <algorithm>
#include "math.h"
#include "unordered_map"
#include <set>
#include <time.h>
#include <deque>
#include <iomanip>
#include <map>
#include <queue>
#include <stack>
#include <memory.h>

using namespace std;
typedef long long int ll;
typedef long double ld;
#define debug(val) "[ " << #val " : " << (val)
#define space " "
#define vi vector<int>
#define PI (double)(atan(1)*4)
#define pb push_back
#define pi pair<int , int >
#define ff first
#define ss second
#define INF 2000000000
vi dx = {-1, 0, 0, 1};
vi dy = {0, -1, 1, 0};
string s;
int n;
const string target = "abacaba";

bool check(int idx) {
    if (idx + 6 >= n) return false;
    bool ok = true;
    for (int i = 0; i < 7; i++) {
        ok &= (target[i] == s[idx + i]);
    }
    return ok;
}

void solve() {
    cin >> n;
    cin >> s;
    int cnt = 0;
    for (int i = 0; i < n; i++) {
        cnt += check(i);
    }
    if (cnt == 1) {
        cout << "YES" << endl;
        for (auto c : s) {
            if (c == '?') c = 'z';
            cout << c;
        }
        cout << endl;

    } else if (cnt > 1)
        cout << "NO" << endl;
    else {
        bool found = false ;
        for (int i = 0; i + 6 < n; i++) {
            bool ok = true;
            for (int j = 0; j < 7; j++) {
                ok &= ((s[i + j] == target[j]) || s[i+j] == '?');
            }
            string p = {s[i+4] , s[i+5] , s[i+6]};
            for(int j=i+4;j<=i+6;j++) s[j] = target[j-i] ;
            if (ok) {
               if (check(i + 6) || check(i + 4)) ok = false;
            }
            if(ok ) {
                found = true ;
                for(int j=0;j<7;j++) s[i+j] = target[j] ;
                break;
            }else {
                for(int j=0;j<3;j++){
                    s[i+4+j] = p[j] ;
                }
            }
        }
        if(found) {
            cout << "YES" << endl;
            for(auto c : s) {
                if(c == '?') c= 'z' ;
                cout << c ;
            }
            cout << endl;
        }else
            cout << "NO" << endl;
    }

}

int main() {
#ifdef _DEBUG // place in cmake-build-debug folder
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int q = 1;
    cin >> q;
    for (int i = 1; i <= q; i++) {
        //   cout << "Case #" << i << ": ";
        solve();
    }
}


#include <iostream>
#include <vector>
#include <algorithm>
#include "math.h"
#include "unordered_map"
#include <set>
#include <time.h>
#include <deque>
#include <iomanip>
#include <map>
#include <queue>
#include <stack>
#include <memory.h>

using namespace std;
typedef long long int ll;
typedef long double ld;
#define debug(val) "[ " << #val " : " << (val)
#define space " "
#define vi vector<int>
#define PI (double)(atan(1)*4)
#define pb push_back
#define pi pair<int , int >
#define ff first
#define ss second
#define INF 2000000000
vi dx = {-1, 0, 0, 1};
vi dy = {0, -1, 1, 0};
string s;
int n;
const string target = "abacaba";

bool check(int idx) {
    if (idx + 6 >= n) return false;
    bool ok = true;
    for (int i = 0; i < 7; i++) {
        ok &= (target[i] == s[idx + i]);
    }
    return ok;
}

void solve() {
    cin >> n;
    cin >> s;
    int cnt = 0;
    for (int i = 0; i < n; i++) {
        cnt += check(i);
    }
    if (cnt == 1) {
        cout << "YES" << endl;
        for (auto c : s) {
            if (c == '?') c = 'z';
            cout << c;
        }
        cout << endl;

    } else if (cnt > 1)
        cout << "NO" << endl;
    else {
        bool found = false ;
        for (int i = 0; i + 6 < n; i++) {
            bool ok = true;
            for (int j = 0; j < 7; j++) {
                ok &= ((s[i + j] == target[j]) || s[i+j] == '?');
            }

            if (ok) {
               if (check(i + 6) || check(i + 4)) ok = false;
            }
            if(ok ) {
                found = true ;
                for(int j=0;j<7;j++) s[i+j] = target[j] ;
                break;
            }
        }
        if(found) {
            cout << "YES" << endl;
            for(auto c : s) {
                if(c == '?') c= 'z' ;
                cout << c ;
            }
            cout << endl;
        }else cout << "NO" << endl;
    }

}

int main() {
#ifdef _DEBUG // place in cmake-build-debug folder
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int q = 1;
    cin >> q;
    for (int i = 1; i <= q; i++) {
        //   cout << "Case #" << i << ": ";
        solve();
    }
}


#include <iostream>
#include <vector>
#include <algorithm>
#include "math.h"
#include "unordered_map"
#include <set>
#include <time.h>
#include <deque>
#include <iomanip>
#include <map>
#include <queue>
#include <stack>
#include <memory.h>

using namespace std;
typedef long long int ll;
typedef long double ld;
#define debug(val) "[ " << #val " : " << (val)
#define space " "
#define vi vector<int>
#define PI (double)(atan(1)*4)
#define pb push_back
#define pi pair<int , int >
#define ff first
#define ss second
#define INF 2000000000
vi dx = {-1, 0, 0, 1};
vi dy = {0, -1, 1, 0};
string s;
int n;
const string target = "abacaba";

bool check(int idx) {
    if (idx + 6 >= n) return false;
    bool ok = true;
    for (int i = 0; i < 7; i++) {
        ok &= (target[i] == s[idx + i]);
    }
    return ok;
}

void solve() {
    cin >> n;
    cin >> s;
    int cnt = 0;
    for (int i = 0; i < n; i++) {
        cnt += check(i);
    }
    if (cnt == 1) {
        cout << "YES" << endl;
        for (auto c : s) {
            if (c == '?') c = 'z';
            cout << c;
        }
        cout << endl;

    } else if (cnt > 1)
        cout << "NO" << endl;
    else {
        bool found = false ;
        for (int i = 0; i + 6 < n; i++) {
            bool ok = true;
            for (int j = 0; j < 7; j++) {
                ok &= ((s[i + j] == target[j]) || s[i+j] == '?');
            }
            vector<char>  p = {s[i+4] , s[i+5] , s[i+6]};
            for(int j=i+4;j<=i+6;j++) s[j] = target[j-i] ;
            if (ok) {
               if (check(i + 6) || check(i + 4)) ok = false;
            }
            if(ok ) {
                found = true ;
                for(int j=0;j<7;j++) s[i+j] = target[j] ;
                break;
            }else {
                for(int j=0;j<3;j++){
                    s[i+4+j] = p[j] ;
                }
            }
        }
        if(found) {
            cout << "YES" << endl;
            for(auto c : s) {
                if(c == '?') c= 'z' ;
                cout << c ;
            }
            cout << endl;
        }else
            cout << "NO" << endl;
    }

}

int main() {
#ifdef _DEBUG // place in cmake-build-debug folder
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int q = 1;
    cin >> q;
    for (int i = 1; i <= q; i++) {
        //   cout << "Case #" << i << ": ";
        solve();
    }
}


#include <iostream>
#include <vector>
#include <algorithm>
#include "math.h"
#include "unordered_map"
#include <set>
#include <time.h>
#include <deque>
#include <iomanip>
#include <map>
#include <queue>
#include <stack>
#include <memory.h>

using namespace std;
typedef long long int ll;
typedef long double ld;
#define debug(val) "[ " << #val " : " << (val)
#define space " "
#define vi vector<int>
#define PI (double)(atan(1)*4)
#define pb push_back
#define pi pair<int , int >
#define ff first
#define ss second
#define INF 2000000000
vi dx = {-1, 0, 0, 1};
vi dy = {0, -1, 1, 0};
string s;
int n;
const string target = "abacaba";

bool check(int idx) {
    if (idx + 6 >= n) return false;
    bool ok = true;
    for (int i = 0; i < 7; i++) {
        ok &= target[i] == s[idx + i];
    }
    return ok;
}

bool check2(int idx) {
    if (idx + 2 >= n) return false;
    return (s[idx++] == 'a') && (s[idx++] == 'b') && s[idx++] == 'a';
}

void solve() {
    cin >> n;
    cin >> s;
    int cnt = 0;
    for (int i = 0; i < n; i++) {
        cnt += check(i);
    }
    if (cnt == 1) {
        cout << "YES" << endl;
        for (auto c : s) {
            if (c == '?') c = 'z';
            cout << c;
        }
        cout << endl;

    } else if (cnt > 1)
        cout << "NO";
    else {
        bool found = false ;
        for (int i = 0; i + 6 < n; i++) {
            bool ok = true;
            for (int j = 0; j < 7; j++) {
                ok &= ((s[i + j] == target[j]) || s[i+j] == '?');
            }
            if (ok) {
                if (check(i + 6) || check2(i + 4)) ok = false;
            }
            if(ok ) {
                found = true ;
                for(int j=0;j<7;j++) s[i+j] = target[j] ;
            }
        }
        if(found) {
            for(auto c : s) {
                if(c == '?') c= 'z' ;
                cout << c ;
            }
            cout << endl;
        }else cout << "NO" << endl;
    }

}

int main() {
#ifdef _DEBUG // place in cmake-build-debug folder
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int q = 1;
    cin >> q;
    for (int i = 1; i <= q; i++) {
        //   cout << "Case #" << i << ": ";
        solve();
    }
}


#include <iostream>
#include <vector>
#include <algorithm>
#include "math.h"
#include "unordered_map"
#include <set>
#include <time.h>
#include <deque>
#include <iomanip>
#include <map>
#include <queue>
#include <stack>
#include <memory.h>

using namespace std;
typedef long long int ll;
typedef long double ld;
#define debug(val) "[ " << #val " : " << (val)
#define space " "
#define vi vector<int>
#define PI (double)(atan(1)*4)
#define pb push_back
#define pi pair<int , int >
#define ff first
#define ss second
#define INF 2000000000
vi dx = {-1, 0, 0, 1};
vi dy = {0, -1, 1, 0};
string s;
int n;
const string target = "abacaba";

bool check(int idx) {
    if (idx + 6 >= n) return false;
    bool ok = true;
    for (int i = 0; i < 7; i++) {
        ok &= (target[i] == s[idx + i]);
    }
    return ok;
}

void solve() {
    cin >> n;
    cin >> s;
    int cnt = 0;
    for (int i = 0; i < n; i++) {
        cnt += check(i);
    }
    if (cnt == 1) {
        cout << "YES" << endl;
        for (auto c : s) {
            if (c == '?') c = 'z';
            cout << c;
        }
        cout << endl;

    } else if (cnt > 1)
        cout << "NO" << endl;
    else {
        bool found = false ;
        for (int i = 0; i + 6 < n; i++) {
            bool ok = true;
            for (int j = 0; j < 7; j++) {
                ok &= ((s[i + j] == target[j]) || s[i+j] == '?');
            }
            string p = {s[i+4] , s[i+5] , s[i+6]};
            for(int j=i+4;j<=i+6;i++) s[j] = target[i-j] ;
            if (ok) {
               if (check(i + 6) || check(i + 4)) ok = false;
            }
            if(ok ) {
                found = true ;
                for(int j=0;j<7;j++) s[i+j] = target[j] ;
                break;
            }else {
                for(int j=0;j<3;j++){
                    s[i+4+j] = p[j] ;
                }
            }
        }
        if(found) {
            cout << "YES" << endl;
            for(auto c : s) {
                if(c == '?') c= 'z' ;
                cout << c ;
            }
            cout << endl;
        }else
            cout << "NO" << endl;
    }

}

int main() {
#ifdef _DEBUG // place in cmake-build-debug folder
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int q = 1;
    cin >> q;
    for (int i = 1; i <= q; i++) {
        //   cout << "Case #" << i << ": ";
        solve();
    }
}


#include <iostream>
#include <vector>
#include <algorithm>
#include "math.h"
#include "unordered_map"
#include <set>
#include <time.h>
#include <deque>
#include <iomanip>
#include <map>
#include <queue>
#include <stack>
#include <memory.h>

using namespace std;
typedef long long int ll;
typedef long double ld;
#define debug(val) "[ " << #val " : " << (val)
#define space " "
#define vi vector<int>
#define PI (double)(atan(1)*4)
#define pb push_back
#define pi pair<int , int >
#define ff first
#define ss second
#define INF 2000000000
vi dx = {-1, 0, 0, 1};
vi dy = {0, -1, 1, 0};
string s;
int n;
const string target = "abacaba";

bool check(int idx) {
    if (idx + 6 >= n) return false;
    bool ok = true;
    for (int i = 0; i < 7; i++) {
        ok &= (target[i] == s[idx + i]);
    }
    return ok;
}

void solve() {
    cin >> n;
    cin >> s;
    int cnt = 0;
    for (int i = 0; i < n; i++) {
        cnt += check(i);
    }
    if (cnt == 1) {
        cout << "YES" << endl;
        for (auto c : s) {
            if (c == '?') c = 'z';
            cout << c;
        }
        cout << endl;

    } else if (cnt > 1)
        cout << "NO" << endl;
    else {
        bool found = false ;
        for (int i = 0; i + 6 < n; i++) {
            bool ok = true;
            for (int j = 0; j < 7; j++) {
                ok &= ((s[i + j] == target[j]) || s[i+j] == '?');
            }
            string p = {s[i+4] , s[i+5] , s[i+6]};
            for(int j=i+4;j<=i+6;j++) s[j] = target[i-j] ;
            if (ok) {
               if (check(i + 6) || check(i + 4)) ok = false;
            }
            if(ok ) {
                found = true ;
                for(int j=0;j<7;j++) s[i+j] = target[j] ;
                break;
            }else {
                for(int j=0;j<3;j++){
                    s[i+4+j] = p[j] ;
                }
            }
        }
        if(found) {
            cout << "YES" << endl;
            for(auto c : s) {
                if(c == '?') c= 'z' ;
                cout << c ;
            }
            cout << endl;
        }else
            cout << "NO" << endl;
    }

}

int main() {
#ifdef _DEBUG // place in cmake-build-debug folder
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int q = 1;
    cin >> q;
    for (int i = 1; i <= q; i++) {
        //   cout << "Case #" << i << ": ";
        solve();
    }
}


#include <iostream>
#include <string>
using namespace std;
int t, n;
string s, a = "abacaba";

bool verify(int j) {
    int lmax = j + 7 - 1, l = 0;
    while (j <= lmax) {
        if (s[j] == '?') {
            s[j] = a[l];
            if (j == lmax) {
                size_t pos;
                pos = s.find(a);
                if (pos != string::npos && s.find(a, pos + 1) != string::npos) {
                    s[j] = '?';
                    return false;
                }
            }
        }
        else if (s[j] != a[l])
            return false;
        ++j, ++l;
    }
    return true;
}

int main() {
    cin >> t;
    while (t--) {
        cin >> n >> s;
        bool exista = false;
        size_t pos = s.find(a), pos2 = s.find(a, pos + 1);
        if (pos != string::npos && pos2 == string::npos)
            exista = true;
        else if (pos == string::npos)
            for (int i = 0; i <= n - 7; ++i)
                if (verify(i)) {
                    exista = true;
                    break;
                }
        if (exista) {
            cout << "Yes\n";
            for (int i = 0; i < n; ++i) {
                if (s[i] == '?') {
                    cout << 'd';
                    continue;
                }
                cout << s[i];
            }
            cout << "\n";
        }
        else
            cout << "No\n";
    }
    return 0;
}


#include <iostream>
#include <string>
using namespace std;
int t, n;
string s, a = "abacaba";

int verifica() {
    int ori = 0;
    for (int i = 0; i <= n - 7; ++i) {
        if (s.substr(i, i + 7) == a)
            ++ori;
    }
    return ori;
}

int main() {
    cin >> t;
    while (t--) {
        cin >> n >> s;
        bool exista = false;
        int ori = verifica();
        if (ori == 1)
            exista = true;
        else if (ori == 0)
            for (int i = 0; !exista && i <= n - 7; ++i) {
                for (int j = i, l = 0; j <= i + 6; ++j) {
                    if (s[j] != a[l] && s[j] != '?')
                        break;
                    if (s[j] == '?') {
                        s[j] = a[l];
                        ori = verifica();
                        if (ori > 1) {
                            s[j] = '?';
                            break;
                        }
                        if (ori == 1) {
                            exista = true;
                            break;
                        }
                    }
                }
            }
        if (exista) {
            cout << "Yes\n";
            for (int i = 0; i < n; ++i) {
                if (s[i] == '?') {
                    cout << 'd';
                    continue;
                }
                cout << s[i];
            }
            cout << "\n";
        }
        else
            cout << "No\n";
    }
    return 0;
}


#include <iostream>
#include <string>
using namespace std;
int t, n;
string s;
const string a = "abacaba";

int main() {
    cin >> t;
    while (t--) {
        cin >> n >> s;
        bool exista = false;
        size_t pos = s.find(a);
        if (pos != string::npos && s.find(a, pos + 1) == string::npos)
            exista = true;
        for (int i = 0, l = 0; i < n; ++i) {
            if (!exista) {
                if (s[i] == a[l])
                    ++l;
                else if (s[i] == '?') {
                    if (l < 7) {
                        s[i] = a[l];
                        ++l;
                    }
                    else
                        s[i] = 'd';
                }
                else if (l < 7)
                    l = 0;
            }
            else if (s[i] == '?')
                s[i] = 'd';
        }
        size_t pos2 = s.find(a);
        if (pos2 != string::npos && s.find(a, pos2 + 1) == string::npos)
            exista = true;
        if (exista) {
            cout << "Yes\n";
            for (int i = 0; i < n; ++i)
                cout << s[i];
            cout << "\n";
        }
        else
            cout << "No\n";
    }
    return 0;
}


#include <iostream>
#include <string>
using namespace std;
int t, n;
string s;
const string a = "abacaba";

int main() {
    cin >> t;
    while (t--) {
        cin >> n >> s;
        bool exista = false;
        size_t pos = s.find(a);
        if (pos != string::npos && s.find(a, pos + 1) == string::npos)
            exista = true;
        for (int i = 0, l = 0; i < n; ++i) {
            if (!exista) {
                if (s[i] == a[l])
                    ++l;
                else if (s[i] == '?') {
                    if (l < 7) {
                        s[i] = a[l];
                        pos = s.find(a);
                        if (pos != string::npos && s.find(a, pos + 1) != string::npos) {
                            s[i] = 'd';
                            l = -1;
                        }
                        ++l;
                    }
                    else
                        s[i] = 'd';
                }
                else if (l < 7)
                    l = 0;
            }
            else if (s[i] == '?')
                s[i] = 'd';
        }
        size_t pos2 = s.find(a);
        if (pos2 != string::npos && s.find(a, pos2 + 1) == string::npos)
            exista = true;
        if (exista) {
            cout << "Yes\n";
            for (int i = 0; i < n; ++i)
                cout << s[i];
            cout << "\n";
        }
        else
            cout << "No\n";
    }
    return 0;
}


#include <iostream>
#include <string>
using namespace std;
int t, n;
string s, a = "abacaba";

int verifica() {
    int ori = 0;
    for (int i = 0; i <= n - 7; ++i) {
        for (int j = i, l = 0; j <= i + 6; ++j, ++l) {
            if (s[j] != a[l])
                break;
            if (j == i + 6)
                ++ori;
        }
    }
    return ori;
}

int main() {
    cin >> t;
    while (t--) {
        cin >> n >> s;
        bool exista = false;
        int ori = verifica();
        if (ori == 1)
            exista = true;
        else if (ori == 0) {
            for (int i = 0; !exista && i <= n - 7; ++i) {
                for (int j = i, l = 0; j <= i + 6; ++j, ++l) {
                    if (s[j] == '?') {
                        s[j] = a[l];
                        ori = verifica();
                        if (ori == 1) {
                            exista = true;
                            break;
                        }
                        if (ori > 1)
                            s[j] = '?';
                    }
                    if (s[j] != a[l])
                        break;
                }
            }
        }
        if (exista) {
            cout << "Yes\n";
            for (int i = 0; i < n; ++i) {
                if (s[i] == '?') {
                    cout << 'd';
                    continue;
                }
                cout << s[i];
            }
            cout << "\n";
        }
        else
            cout << "No\n";
    }
    return 0;
}


#include <iostream>
#include <string>
using namespace std;
int t, n;
string s;
const string a = "abacaba";

int main() {
    cin >> t;
    while (t--) {
        cin >> n >> s;
        bool exista = false;
        size_t pos = s.find(a);
        if (pos < n && s.find(a, pos + 1) == string::npos)
            exista = true;
        int l = 0;
        for (int i = 0; i < n; ++i) {
            if (!exista) {
                if (s[i] == a[l])
                    ++l;
                else if (s[i] == '?') {
                    if (l < 7) {
                        s[i] = a[l];
                        ++l;
                    }
                    else
                        s[i] = 'd';
                }
                else
                    l = 0;
            }
            else if (s[i] == '?')
                s[i] = 'd';
        }
        pos = s.find(a);
        if (pos < n && s.find(a, pos + 1) == string::npos)
            exista = true;
        if (exista) {
            cout << "Yes\n";
            for (int i = 0; i < n; ++i)
                cout << s[i];
            cout << "\n";
        }
        else
            cout << "No\n";
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
int t, n;
string s, a = "abacaba";
queue <int> q;

int verifica(string sl) {
    int ori = 0;
    for (int i = 0; i <= n - 7; ++i) {
        if (sl.substr(i, 7) == a)
            ++ori;
    }
    return ori;
}

int main() {
    cin >> t;
    while (t--) {
        cin >> n >> s;
        bool exista = false;
        int ori = verifica(s);
        if (ori == 1)
            exista = true;
        else if (ori == 0)
            for (int i = 0; !exista && i <= n - 7; ++i) {
                string s2 = s;
                bool corect = true;
                for (int j = i, l = 0; j < i + 7; ++j, ++l) {
                    if (s2[j] != a[l] && s2[j] != '?') {
                        corect = false;
                        break;
                    }
                    s2[j] = a[l];
                }
                if (corect && verifica(s2) == 1) {
                    s = s2;
                    exista = true;
                    break;
                }
            }
        if (exista) {
            cout << "Yes\n";
            for (int i = 0; i < n; ++i) {
                if (s[i] == '?') {
                    cout << 'd';
                    continue;
                }
                cout << s[i];
            }
            cout << "\n";
        }
        else
            cout << "No\n";
    }
    return 0;
}