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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

use std::io::Read;

struct State {
    n: usize,
    a: Vec<char>
}

fn solve(st: &mut State) {
    let S: Vec<char> = "abacaba".chars().collect();
    let n = st.n;
    let a = &st.a;
    for i in 0..n-6 {
        let mut ok = true;
        for j in 0..7 {
            if a[i+j] != '?' && S[j] != a[i+j] {
                ok = false;
                break;
            }
        }
        if ok {
            let mut cnt = 0;
            let mut b = a.clone();
            for j in 0..7 {
                if b[i+j] == '?' {
                    b[i+j] = S[j];
                }
            }
            for i2 in 0..n-6 {
                let mut ok = true;
                for j in 0..7 {
                    if b[i2+j] != S[j] {
                        ok = false;
                        break;
                    }
                }
                if ok {cnt += 1;}
            }
            if cnt == 1 {
                print!("Yes\n");
                for i in 0..n {
                    if b[i] == '?' {print!("z");}
                    else {print!("{}", b[i]);}
                }
                print!("\n");
                return;
            }
        }
    }
    print!("No\n");
}
fn main() {
    let mut buffer = String::new();
    std::io::stdin().read_to_string(&mut buffer).unwrap();
    let mut input = buffer.split_whitespace();

    let t: usize = input.next().unwrap().parse().unwrap();
    for _ in 0..t {
        let n: usize = input.next().unwrap().parse().unwrap();
        //let a: Vec<usize> = (0..n).map(|_| input.next().unwrap().parse().unwrap()).collect();
        let a: Vec<char> = input.next().unwrap().chars().collect();
        solve(&mut State{n: n, a: a});
    }

}


/* This code was written by
Russell Emerine - linguist,
mathematician, coder,
musician, and metalhead. */

#[derive(Default)]
struct Scanner {
    buffer: Vec<String>,
}

impl Scanner {
    fn next<T: std::str::FromStr>(&mut self) -> T {
        loop {
            if let Some(token) = self.buffer.pop() {
                return token.parse().ok().expect("Failed parse");
            }
            let mut input = String::new();
            std::io::stdin().read_line(&mut input).expect("Failed read");
            self.buffer = input.split_whitespace().rev().map(String::from).collect();
        }
    }
}

fn main() {
    let mut scanner = Scanner::default();
    let key = "abacaba".chars().collect::<Vec<_>>();

    for _ in 0..scanner.next() {
        let n = scanner.next::<usize>();
        let s = scanner.next::<String>().chars().collect::<Vec<_>>();
        let mut answer = None;

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

            for j in 0..7 {
                if s[i + j] == '?' || s[i + j] == key[j] {
                    s[i + j] = key[j];
                } else {
                    valid = false;
                    break;
                }
            }
            if !valid {
                continue;
            }

            if (0..n - 6)
                .filter(|&i| (0..7).all(|j| s[i + j] == key[j]))
                .count()
                == 1
            {
                answer = Some(s.iter().collect::<String>().replace('?', "x"));
            }
        }

        if let Some(s) = answer {
            println!("YES");
            println!("{}", s);
        } else {
            println!("NO");
        }
    }
}


fn main() {
    let t: usize = {
        let mut buf = String::new();
        std::io::stdin().read_line(&mut buf).unwrap();
        buf.trim_end().parse().unwrap()
    };

    for _ in 0..t {
        let n: usize = {
            let mut buf = String::new();
            std::io::stdin().read_line(&mut buf).unwrap();
            buf.trim_end().parse().unwrap()
        };
        let mut s: Vec<char> = {
            let mut buf = String::new();
            std::io::stdin().read_line(&mut buf).unwrap();
            buf.trim_end().chars().collect()
        };

        let abacaba = ['a', 'b', 'a', 'c', 'a', 'b', 'a'];
        let mut count = 0;
        for i in 0..(n - 6) {
            let mut ok = true;
            for j in 0..7 {
                if s[i + j] != abacaba[j] {
                    ok = false;
                    break;
                }
            }
            if ok {
                count += 1;
            }
        }
        if count == 0 {
            let mut ok = false;
            'outer: for i in 0..(n - 6) {
                for j in 0..7 {
                    if s[i + j] != '?' && s[i + j] != abacaba[j] {
                        continue 'outer;
                    }
                }
                if i >= 6 {
                    let mut ng = true;
                    for j in 0..6 {
                        if s[i + j - 6] != abacaba[j] {
                            ng = false;
                        }
                    }
                    if ng { continue 'outer; }
                }
                if i >= 4 {
                    let mut ng = true;
                    for j in 0..4 {
                        if s[i + j - 4] != abacaba[j] {
                            ng = false;
                        }
                    }
                    if ng { continue 'outer; }
                }
                if i + 10 < n {
                    let mut ng = true;
                    for j in 0..4 {
                        if s[i + j + 7] != abacaba[j + 3] {
                            ng = false;
                        }
                    }
                    if ng { continue 'outer; }
                }
                if i + 12 < n {
                    let mut ng = true;
                    for j in 0..6 {
                        if s[i + j + 7] != abacaba[j + 1] {
                            ng = false;
                        }
                    }
                    if ng { continue 'outer; }
                }
                for j in 0..7 {
                    s[i + j] = abacaba[j];
                }
                ok = true;
                break;
            }
            if ok {
                let ans: String = {
                    s.iter()
                        .map(|&c| if c == '?' { 'd' } else { c })
                        .collect()
                };
                println!("Yes\n{}", ans);
            }
            else {
                println!("No");
            }
        } else if count == 1 {
            let ans: String = {
                s.iter()
                    .map(|&c| if c == '?' { 'd' } else { c })
                    .collect()
            };
            println!("Yes\n{}", ans);
        } else {
            println!("No");
        }
    }
}


fn main() {
    let t: usize = {
        let mut buf = String::new();
        std::io::stdin().read_line(&mut buf).unwrap();
        buf.trim_end().parse().unwrap()
    };

    for _ in 0..t {
        let n: usize = {
            let mut buf = String::new();
            std::io::stdin().read_line(&mut buf).unwrap();
            buf.trim_end().parse().unwrap()
        };
        let mut s: Vec<char> = {
            let mut buf = String::new();
            std::io::stdin().read_line(&mut buf).unwrap();
            buf.trim_end().chars().collect()
        };

        let abacaba = ['a', 'b', 'a', 'c', 'a', 'b', 'a'];
        let mut count = 0;
        for i in 0..(n - 6) {
            let mut ok = true;
            for j in 0..7 {
                if s[i + j] != abacaba[j] {
                    ok = false;
                    break;
                }
            }
            if ok {
                count += 1;
            }
        }
        if count == 0 {
            let mut ok = false;
            'outer: for i in 0..(n - 6) {
                for j in 0..7 {
                    if s[i + j] != '?' && s[i + j] != abacaba[j] {
                        continue 'outer;
                    }
                }
                if i >= 4 {
                    let mut ng = true;
                    for j in 0..4 {
                        if s[i + j - 4] != abacaba[j] {
                            ng = false;
                        }
                    }
                    if ng { continue 'outer; }
                }
                if i + 10 < n {
                    let mut ng = true;
                    for j in 0..4 {
                        if s[i + j + 7] != abacaba[j + 3] {
                            ng = false;
                        }
                    }
                    if ng { continue 'outer; }
                }
                for j in 0..7 {
                    s[i + j] = abacaba[j];
                }
                ok = true;
                break;
            }
            if ok {
                let ans: String = {
                    s.iter()
                        .map(|&c| if c == '?' { 'd' } else { c })
                        .collect()
                };
                println!("Yes\n{}", ans);
            }
            else {
                println!("No");
            }
        } else if count == 1 {
            let ans: String = {
                s.iter()
                    .map(|&c| if c == '?' { 'd' } else { c })
                    .collect()
            };
            println!("Yes\n{}", ans);
        } else {
            println!("No");
        }
    }
}


fn main() {
    let t: usize = {
        let mut buf = String::new();
        std::io::stdin().read_line(&mut buf).unwrap();
        buf.trim_end().parse().unwrap()
    };

    for _ in 0..t {
        let n: usize = {
            let mut buf = String::new();
            std::io::stdin().read_line(&mut buf).unwrap();
            buf.trim_end().parse().unwrap()
        };
        let mut s: Vec<char> = {
            let mut buf = String::new();
            std::io::stdin().read_line(&mut buf).unwrap();
            buf.trim_end().chars().collect()
        };

        let abacaba = ['a', 'b', 'a', 'c', 'a', 'b', 'a'];
        let mut count = 0;
        for i in 0..(n - 6) {
            let mut ok = true;
            for j in 0..7 {
                if s[i + j] != abacaba[j] {
                    ok = false;
                    break;
                }
            }
            if ok {
                count += 1;
            }
        }
        if count == 0 {
            let mut ok = false;
            for i in 0..(n - 6) {
                let mut ng = false;
                for j in 0..7 {
                    if s[i + j] != '?' && s[i + j] != abacaba[j] {
                        ng = true;
                        break;
                    }
                }
                if ng {
                    continue;
                }
                if i + 10 < n {
                    for j in 7..11 {
                        if s[i + j] != abacaba[j - 4] {
                            ng = true;
                            break;
                        }
                    }
                } else {
                    ng = true;
                }
                if ng {
                    for j in 0..7 {
                        s[i + j] = abacaba[j];
                    }
                    ok = true;
                    break;
                } else {
                    for j in 0..7 {
                        s[i + j] = 'd';
                    }
                }
            }
            if ok {
                let ans: String = {
                    s.iter()
                        .map(|&c| if c == '?' { 'd' } else { c })
                        .collect()
                };
                println!("Yes\n{}", ans);
            }
            else {
                println!("No");
            }
        } else if count == 1 {
            let ans: String = {
                s.iter()
                    .map(|&c| if c == '?' { 'd' } else { c })
                    .collect()
            };
            println!("Yes\n{}", ans);
        } else {
            println!("No");
        }
    }
}


/// Codeforces Round #657 (Div. 2)
/// https://codeforces.com/contest/1379/problem/A

use std::io::{self, BufWriter, Read, Write};

fn main() {
    let stdout = io::stdout();
    let mut output = BufWriter::new(stdout.lock());
    let mut stdin = io::stdin();
    let mut input_str = String::new();
    stdin.read_to_string(&mut input_str).unwrap();

    let mut input_iter = input_str.split_whitespace();

    macro_rules! read(() => (input_iter.next().unwrap().parse().unwrap()));
    //macro_rules! print(( $( $x:expr ),*) => (write!(output, $($x,)*).unwrap()));
    macro_rules! println(( $( $x:expr ),*) => (writeln!(output, $($x,)*).unwrap()));

    let test_cases: usize = read!();

    for _ in 0..test_cases {
        let n: usize = read!();
        let s: String = read!();

        let abacaba: Vec<char> = "abacaba".to_string().chars().collect();
        let chars: Vec<char> = s.chars().collect();
        let mut index_candidates = Vec::with_capacity(n - abacaba.len());

        for i in 0..(n - (abacaba.len() - 1)) {
            let mut is_valid_candidate = true;
            for j in 0..abacaba.len() {
                //println!("i {}, j {}, chars[{} + {}] {}, abacaba[{}] {}", i, j, i, j, chars[i + j], j, abacaba[j]);
                if chars[i + j] != '?' && chars[i + j] != abacaba[j] {
                    is_valid_candidate = false;
                }
            }

            if is_valid_candidate {
                index_candidates.push(i);
            }
        }

        //println!("{:?}", index_candidates);

        let mut not_possible = true;
        for idx in index_candidates.iter() {
            let mut chars_clone = chars.clone();
            for i in 0..abacaba.len() {
                chars_clone[idx + i] = abacaba[i];
            }

            let mut match_count = 0;
            for i in 0..(n - (abacaba.len() - 1)) {
                let mut is_match = true;
                for j in 0..abacaba.len() {
                    if chars_clone[i + j] != abacaba[j] {
                        is_match = false;
                    }
                }

                if is_match {
                    match_count += 1;
                }
            }

            if match_count == 1 {
                println!("Yes");
                let answer: String = chars_clone
                    .into_iter()
                    .map(|c| if c == '?' { "z".to_string() } else { c.to_string() })
                    .collect::<Vec<String>>()
                    .join("");
                println!("{}", answer);
                not_possible = false;
                break;
            }
        }

        if not_possible {
            println!("No");
        }

    }
}


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

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

macro_rules! debug {($($a:expr),*) => {eprintln!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);}}
macro_rules! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut iter = $ s . split_whitespace ( ) ; let mut next = || { iter . next ( ) . unwrap ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let mut bytes = std :: io :: Read :: bytes ( std :: io :: BufReader :: new ( stdin . lock ( ) ) ) ; let mut next = move || -> String { bytes . by_ref ( ) . map ( | r | r . unwrap ( ) as char ) . skip_while ( | c | c . is_whitespace ( ) ) . take_while ( | c |! c . is_whitespace ( ) ) . collect ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; }
macro_rules! input_inner { ( $ next : expr ) => { } ; ( $ next : expr , ) => { } ; ( $ next : expr , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ next , $ t ) ; input_inner ! { $ next $ ( $ r ) * } } ; }
macro_rules! read_value { ( $ next : expr , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ next , $ t ) ) ,* ) } ; ( $ next : expr , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ next , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ next : expr , chars ) => { read_value ! ( $ next , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ next : expr , usize1 ) => { read_value ! ( $ next , usize ) - 1 } ; ( $ next : expr , $ t : ty ) => { $ next ( ) . parse ::<$ t > ( ) . expect ( "Parse error" ) } ; }

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

use std::f64;

fn min<T: PartialOrd>(a:T, b:T) -> T {
    if a < b { a }
    else { b }
}

fn max<T: PartialOrd>(a:T, b:T) -> T {
    if a < b { b }
    else { a }
}

const MAX:usize = 30;
const INF:i64 = std::i64::MAX;
const MOD:i64 = 1e9 as i64 + 7;

struct Graph {
    e: Vec<Vec<usize>>,
    v: Vec<usize>,
    u: Vec<usize>,
    f: Vec<bool>,
    c: i64,
    flag: bool,
    vc: Vec<i64>,
}

impl Graph {
    fn new(n:usize) -> Self {
        Graph {
            e: vec![vec![];n],
            v: vec![],
            u: vec![n;n],
            f: vec![false;n],
            c: 0,
            flag: true,
            vc: vec![0;n],
        }
    }

    fn dfs(&mut self, crt: usize) {
        self.f[crt] = true;
        self.c = self.e[crt].len() as i64;
        if self.c != 2 {
            self.flag = false;
        }

        for i in 0..self.e[crt].len() {
            let v = self.e[crt][i];
            if self.f[v] { continue; }
            self.dfs(v);
        }
    }
}

fn binary_search(s: &Vec<i64>, v:i64) -> usize {
    let mut left = 0;
    let mut right = s.len();

    while right-left > 1 {
        let mid = (right+left)/2;
        //debug!(left,mid,right,s[mid]);
        if s[mid] < v { left = mid; }
        else { right = mid; }
    }
    left
}

fn neighbors(tree: &BTreeSet<(i64,usize)>, val: i64) -> (Option<&(i64,usize)>, Option<&(i64,usize)>) {
    use std::ops::Bound::*;

    let mut before = tree.range((Unbounded, Excluded((val,0))));
    let mut after = tree.range((Excluded((val,0)), Unbounded));

    (before.next_back(), after.next())
}

fn main() {
    let t:usize = read();

    'outer: for _ in 0..t {
        let n:usize = read();
        let s:Vec<char> = read::<String>().chars().collect();

        let t:Vec<char> = String::from("abacaba").chars().collect();
        for i in 0..s.len()-t.len()+1 {
            let mut u = vec![];
            for j in 0..i {
                u.push(if s[j]=='?' {'z'} else {s[j]});
            }
            let mut idx = 0usize;
            for j in i..i+t.len() {
                u.push(t[idx]);
                idx += 1;
            }
            for j in i+t.len()..s.len() {
                u.push(if s[j]=='?' {'z'} else {s[j]});
            }
            //debug!(u);
            assert_eq!(u.len(), s.len());
            let mut cnt = 0;
            for j in 0..s.len()-t.len()+1 {
                let mut f = true;
                let mut idx = 0usize;
                for k in j..j+t.len() {
                    if u[k] != t[idx] { f=false; break; }
                    idx += 1;
                }
                if f { cnt+=1; }
            }
            if cnt > 1 { continue; }
            let mut f = true;
            for j in 0..s.len() {
                if s[j]=='?' { continue; }
                if s[j] != u[j] { f=false; break; }
            }
            if !f { continue; }
            if cnt == 1 {
                println!("Yes");
                for e in u { print!("{}", e); } println!();
                continue 'outer;
            }
        }

        println!("No");
    }
}


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

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

macro_rules! debug {($($a:expr),*) => {eprintln!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);}}
macro_rules! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut iter = $ s . split_whitespace ( ) ; let mut next = || { iter . next ( ) . unwrap ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let mut bytes = std :: io :: Read :: bytes ( std :: io :: BufReader :: new ( stdin . lock ( ) ) ) ; let mut next = move || -> String { bytes . by_ref ( ) . map ( | r | r . unwrap ( ) as char ) . skip_while ( | c | c . is_whitespace ( ) ) . take_while ( | c |! c . is_whitespace ( ) ) . collect ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; }
macro_rules! input_inner { ( $ next : expr ) => { } ; ( $ next : expr , ) => { } ; ( $ next : expr , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ next , $ t ) ; input_inner ! { $ next $ ( $ r ) * } } ; }
macro_rules! read_value { ( $ next : expr , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ next , $ t ) ) ,* ) } ; ( $ next : expr , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ next , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ next : expr , chars ) => { read_value ! ( $ next , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ next : expr , usize1 ) => { read_value ! ( $ next , usize ) - 1 } ; ( $ next : expr , $ t : ty ) => { $ next ( ) . parse ::<$ t > ( ) . expect ( "Parse error" ) } ; }

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

use std::f64;

fn min<T: PartialOrd>(a:T, b:T) -> T {
    if a < b { a }
    else { b }
}

fn max<T: PartialOrd>(a:T, b:T) -> T {
    if a < b { b }
    else { a }
}

const MAX:usize = 30;
const INF:i64 = std::i64::MAX;
const MOD:i64 = 1e9 as i64 + 7;

struct Graph {
    e: Vec<Vec<usize>>,
    v: Vec<usize>,
    u: Vec<usize>,
    f: Vec<bool>,
    c: i64,
    flag: bool,
    vc: Vec<i64>,
}

impl Graph {
    fn new(n:usize) -> Self {
        Graph {
            e: vec![vec![];n],
            v: vec![],
            u: vec![n;n],
            f: vec![false;n],
            c: 0,
            flag: true,
            vc: vec![0;n],
        }
    }

    fn dfs(&mut self, crt: usize) {
        self.f[crt] = true;
        self.c = self.e[crt].len() as i64;
        if self.c != 2 {
            self.flag = false;
        }

        for i in 0..self.e[crt].len() {
            let v = self.e[crt][i];
            if self.f[v] { continue; }
            self.dfs(v);
        }
    }
}

fn binary_search(s: &Vec<i64>, v:i64) -> usize {
    let mut left = 0;
    let mut right = s.len();

    while right-left > 1 {
        let mid = (right+left)/2;
        //debug!(left,mid,right,s[mid]);
        if s[mid] < v { left = mid; }
        else { right = mid; }
    }
    left
}

fn neighbors(tree: &BTreeSet<(i64,usize)>, val: i64) -> (Option<&(i64,usize)>, Option<&(i64,usize)>) {
    use std::ops::Bound::*;

    let mut before = tree.range((Unbounded, Excluded((val,0))));
    let mut after = tree.range((Excluded((val,0)), Unbounded));

    (before.next_back(), after.next())
}

fn main() {
    let t:usize = read();

    'outer: for _ in 0..t {
        let n:usize = read();
        let s:Vec<char> = read::<String>().chars().collect();

        let t:Vec<char> = String::from("abacaba").chars().collect();
        let mut f = false;
        let mut cnt = 0;
        let mut vs = vec![];
        for i in 0..s.len()-t.len()+1 {
            let mut idx = 0usize;
            let mut v = vec![];
            let mut flag = true;
            let mut flag2 = true;
            for j in i..i+t.len() {
                //debug!(i,j,s[j],t[idx]);
                if s[j] == '?' {
                    v.push((j,t[idx]));
                    flag2 = false;
                } else {
                    if s[j] != t[idx] {
                        flag = false;
                        break;
                    }
                }
                idx += 1;
            }
            if !flag { vs.clear(); continue; }
            if flag { vs = v; }
            if flag2 { f = true; cnt+=1; }
        }

        if cnt > 1 {
            println!("No");
        }
        else if f {
            println!("Yes");
            for e in s { print!("{}", if e=='?' {'z'} else {e}); } println!();
        }
        else {
            if vs.is_empty() {
                println!("No");
            } else {
                println!("Yes");
                let mut idx = 0usize;
                for i in 0..n {
                    if idx < vs.len() && i == vs[idx].0 {
                        print!("{}", vs[idx].1);
                        idx += 1;
                    } else {
                        print!("{}", s[i]);
                    }
                }
                println!();
            }
        }
    }
}


//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 より
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

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

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };
    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };
    ($iter:expr, bytes) => {
        read_value!($iter, String).bytes().collect::<Vec<u8>>()
    };
    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };
    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

//

use std::io::Write;

fn run() {
    let out = std::io::stdout();
    let mut out = std::io::BufWriter::new(out.lock());
    input! {
        t: usize,
        p: [(usize, chars); t],
    }
    let op = "abacaba".chars().collect::<Vec<_>>();
    for (n, mut s) in p {
        let mut cnt = 0;
        for i in 0..(n - 6) {
            let mut ok = true;
            for j in 0..7 {
                ok &= s[i + j] == op[j];
            }
            if ok {
                cnt += 1;
            }
        }
        if cnt > 1 {
            writeln!(out, "No").ok();
            continue;
        }
        let mut ans = String::new();
        if cnt == 1 {
            ans.push_str("Yes\n");
        } else {
            let mut find = false;
            for i in 0..(n - 6) {
                let mut ok = true;
                for j in 0..7 {
                    ok &= s[i + j] == op[j] || s[i + j] == '?';
                }
                if ok {
                    find = true;
                    for j in 0..7 {
                        s[i + j] = op[j];
                    }
                    break;
                }
            }
            if find {
                ans.push_str("Yes\n");
            } else {
                writeln!(out, "No").ok();
                continue;
            }
        }
        for c in s.iter_mut() {
            if *c == '?' {
                *c = 'z';
            }
        }
        for c in s {
            ans.push(c);
        }
        writeln!(out, "{}", ans).ok();
    }
}

fn main() {
    run();
}


//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 より
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

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

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };
    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };
    ($iter:expr, bytes) => {
        read_value!($iter, String).bytes().collect::<Vec<u8>>()
    };
    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };
    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

//

use std::io::Write;

fn run() {
    let out = std::io::stdout();
    let mut out = std::io::BufWriter::new(out.lock());
    input! {
        t: usize,
        p: [(usize, chars); t],
    }
    let op = "abacaba".chars().collect::<Vec<_>>();
    let count = |s: &[char]| -> usize {
        let mut cnt = 0;
        for i in 0..(s.len() - 6) {
            let mut ok = true;
            for j in 0..7 {
                ok &= s[i + j] == op[j];
            }
            if ok {
                cnt += 1;
            }
        }
        cnt
    };
    for (n, mut s) in p {
        let cnt = count(&s);
        if cnt > 1 {
            writeln!(out, "No").ok();
            continue;
        }
        let mut ans = String::new();
        if cnt == 1 {
            ans.push_str("Yes\n");
        } else {
            let mut find = false;
            for i in 0..(n - 6) {
                let mut ok = true;
                for j in 0..7 {
                    ok &= s[i + j] == op[j] || s[i + j] == '?';
                }
                if ok {
                    let mut t = s.clone();
                    for j in 0..7 {
                        t[i + j] = op[j];
                    }
                    for c in t.iter_mut() {
                        if *c == '?' {
                            *c = 'z';
                        }
                    }
                    if count(&t) == 1 {
                        find = true;
                        s = t;
                        break;
                    }
                }
            }
            if find {
                ans.push_str("Yes\n");
            } else {
                writeln!(out, "No").ok();
                continue;
            }
        }
        for c in s.iter_mut() {
            if *c == '?' {
                *c = 'z';
            }
        }
        for c in s {
            ans.push(c);
        }
        writeln!(out, "{}", ans).ok();
    }
}

fn main() {
    run();
}


use std::io::{self, Read, Write, BufWriter};

fn main(){
    let mut stdin = io::stdin();
    // From https://keens.github.io/blog/2017/10/05/rustdekousokunahyoujunshutsuryoku/
    let stdout = io::stdout();
    let mut output = BufWriter::new(stdout.lock());
    let mut input_str = String::new();
    let _ = stdin.read_to_string(&mut input_str);
    let mut input_iter = input_str.split_ascii_whitespace();
    // From https://github.com/rust-lang-ja/atcoder-rust-resources/wiki/2020-Update#proconio
    let t :usize = input_iter.next().unwrap().parse().unwrap();
    for _ in 0..t {
        sub_main(&mut input_iter, &mut output);
    }
}

fn sub_main<T :Write>(input_iter :&mut dyn Iterator<Item=&str>, output :&mut T) {
    macro_rules! read(() => (input_iter.next().unwrap().parse().unwrap()));
    macro_rules! print(( $( $x:expr ),*) => (write!(output, $($x,)*).unwrap()));
    macro_rules! println(( $( $x:expr ),*) => (writeln!(output, $($x,)*).unwrap()));
    // Deal with each case
    let _ :usize = read!();
    let s :String = read!();
    let s_bytes = s.as_bytes();
    let keyword_bytes = "abacaba".as_bytes();
    let keywordlen = keyword_bytes.len();
    let slen = s_bytes.len();

    for i in 0..slen {
        if check_prefix(&s_bytes[i..], &keyword_bytes) {
            // Make a candidate solution
            let mut char_to_fill = s_bytes.iter().cloned().collect::<Vec<u8>>();
            for j in 0..keywordlen {
                char_to_fill[i+j] = keyword_bytes[j];
            }
            for k in 0..slen {
                if char_to_fill[k] == b'?' {
                    char_to_fill[k] = b'z';
                }
            }
            // Check
            if count_matches(&char_to_fill, &keyword_bytes) == 1 {
                println!("Yes");
                println!("{}", String::from_utf8(char_to_fill).unwrap());
                return;
            }
        }
    }

    println!("No");
}

fn check_prefix(ss :&[u8], keyword_bytes :&[u8]) -> bool {
    let sslen = ss.len();
    let keywordlen = keyword_bytes.len();
    if sslen < keywordlen {
        return false;
    }
    for i in 0..keywordlen {
        if ss[i] != b'?' && ss[i] != keyword_bytes[i] {
            return false;
        }
    }
    return true;
}

fn count_matches(ss :&[u8], keyword_bytes :&[u8]) -> usize {
    let mut count = 0;
    for i in 0..ss.len() {
        if check_prefix(&ss[i..], keyword_bytes) {
            count += 1;
        }
    }
    return count;
}


use std::io::{self, Read, Write, BufWriter};

fn main(){
    let mut stdin = io::stdin();
    // From https://keens.github.io/blog/2017/10/05/rustdekousokunahyoujunshutsuryoku/
    let stdout = io::stdout();
    let mut output = BufWriter::new(stdout.lock());
    let mut input_str = String::new();
    let _ = stdin.read_to_string(&mut input_str);
    let mut input_iter = input_str.split_ascii_whitespace();
    // From https://github.com/rust-lang-ja/atcoder-rust-resources/wiki/2020-Update#proconio
    macro_rules! read(() => (input_iter.next().unwrap().parse().unwrap()));
    macro_rules! print(( $( $x:expr ),*) => (write!(output, $($x,)*).unwrap()));
    macro_rules! println(( $( $x:expr ),*) => (writeln!(output, $($x,)*).unwrap()));
    let t :usize = read!();
    for _ in 0..t {
        // Deal with each case
        let _ :usize = read!();
        let s :String = read!();
        let s_bytes = s.as_bytes();
        let keyword_bytes = "abacaba".as_bytes();
        let keywordlen = keyword_bytes.len();
        let slen = s_bytes.len();

        let mut char_to_fill = s_bytes.iter().cloned().collect::<Vec<u8>>();
        let mut is_matched = vec![vec![false;slen];keywordlen];
        let mut is_matched_wild = vec![vec![false;slen];keywordlen];
        for k in 0..slen {
            for j in 0..keywordlen {
                let i = j + k;
                if i >= slen { continue; }
                let c = keyword_bytes[j];
                if j > i {
                    is_matched[j][i] = false;
                    is_matched_wild[j][i] = false;
                } else if c == s_bytes[i] {
                    if j == 0 {
                        is_matched[j][i] = true;
                        is_matched_wild[j][i] = true;
                    } else { // i >= 1
                        is_matched[j][i] = is_matched[j-1][i-1];
                        is_matched_wild[j][i] = is_matched_wild[j-1][i-1];
                    }
                } else if s_bytes[i] == b'?' {
                    if j == 0 {
                        is_matched[j][i] = false;
                        is_matched_wild[j][i] = true;
                    } else { // i >= 1
                        is_matched[j][i] = false;
                        is_matched_wild[j][i] = is_matched_wild[j-1][i-1];
                    }
                    if is_matched_wild[j][i] && char_to_fill[i] == b'?' {
                        char_to_fill[i] = c;
                    }
                } else {
                    is_matched[j][i] = false;
                    is_matched[j][i] = false;
                }
            }
        }
        //println!("{:?}", is_matched);
        let is_matched = is_matched;
        let is_matched_wild = is_matched_wild;
        let mut min = 0;
        let mut max = 0;
        for i in 0..slen {
            if is_matched[keywordlen-1][i] {
                min += 1;
            }
            if is_matched_wild[keywordlen-1][i] {
                max += 1;
            }
        }
        let min = min;
        let max = max;
        if min > 1 || max == 0 {
            println!("No");
        } else if min == 1 {
            println!("Yes");
            let mut filled_s_bytes = s_bytes.iter().cloned().collect::<Vec<u8>>();
            for i in 0..slen {
                if s_bytes[i] == b'?' {
                    filled_s_bytes[i] = b'z';
                } else {
                    filled_s_bytes[i] = s_bytes[i];
                }
            }
            println!("{}", String::from_utf8(filled_s_bytes).unwrap());
        } else { // min == 0
            println!("Yes");
            for i in 0..slen {
                if char_to_fill[i] == b'?' {
                    char_to_fill[i] = b'z';
                }
            }
            println!("{}", String::from_utf8(char_to_fill).unwrap());
        }
    }
}


use std::io::{self, Read, Write, BufWriter};

fn main(){
    let mut stdin = io::stdin();
    // From https://keens.github.io/blog/2017/10/05/rustdekousokunahyoujunshutsuryoku/
    let stdout = io::stdout();
    let mut output = BufWriter::new(stdout.lock());
    let mut input_str = String::new();
    let _ = stdin.read_to_string(&mut input_str);
    let mut input_iter = input_str.split_ascii_whitespace();
    // From https://github.com/rust-lang-ja/atcoder-rust-resources/wiki/2020-Update#proconio
    macro_rules! read(() => (input_iter.next().unwrap().parse().unwrap()));
    macro_rules! print(( $( $x:expr ),*) => (write!(output, $($x,)*).unwrap()));
    macro_rules! println(( $( $x:expr ),*) => (writeln!(output, $($x,)*).unwrap()));
    let t :usize = read!();
    for _ in 0..t {
        // Deal with each case
        let _ :usize = read!();
        let s :String = read!();
        let s_bytes = s.as_bytes();
        let keyword_bytes = "abacaba".as_bytes();
        let keywordlen = keyword_bytes.len();
        let slen = s_bytes.len();

        let mut char_to_fill = s_bytes.iter().cloned().collect::<Vec<u8>>();
        let mut is_matched = vec![vec![false;slen];keywordlen];
        let mut is_matched_wild = vec![vec![false;slen];keywordlen];
        for k in 0..slen {
            for j in 0..keywordlen {
                let i = j + k;
                if i >= slen { continue; }
                let c = keyword_bytes[j];
                if j > i {
                    is_matched[j][i] = false;
                    is_matched_wild[j][i] = false;
                } else if c == s_bytes[i] {
                    if j == 0 {
                        is_matched[j][i] = true;
                        is_matched_wild[j][i] = true;
                    } else { // i >= 1
                        is_matched[j][i] = is_matched[j-1][i-1];
                        is_matched_wild[j][i] = is_matched_wild[j-1][i-1];
                    }
                } else if s_bytes[i] == b'?' {
                    if j == 0 {
                        is_matched[j][i] = false;
                        is_matched_wild[j][i] = true;
                    } else { // i >= 1
                        is_matched[j][i] = false;
                        is_matched_wild[j][i] = is_matched_wild[j-1][i-1];
                    }
                } else {
                    is_matched[j][i] = false;
                    is_matched[j][i] = false;
                }
            }
        }
        //println!("{:?}", is_matched);
        let is_matched = is_matched;
        let is_matched_wild = is_matched_wild;
        let mut min = 0;
        let mut max = 0;
        for i in 0..slen {
            if is_matched[keywordlen-1][i] {
                min += 1;
            }
            if is_matched_wild[keywordlen-1][i] {
                max += 1;
            }
        }
        let min = min;
        let max = max;
        if min > 1 || max == 0 {
            println!("No");
        } else if min == 1 {
            println!("Yes");
            let mut filled_s_bytes = s_bytes.iter().cloned().collect::<Vec<u8>>();
            for i in 0..slen {
                if s_bytes[i] == b'?' {
                    filled_s_bytes[i] = b'z';
                } else {
                    filled_s_bytes[i] = s_bytes[i];
                }
            }
            println!("{}", String::from_utf8(filled_s_bytes).unwrap());
        } else { // min == 0
            println!("Yes");
            for i in 0..slen {
                if is_matched_wild[keywordlen-1][i] {
                    for j in 0..keywordlen {
                        char_to_fill[i+1-keywordlen+j] = keyword_bytes[j];
                    }
                    break;
                }
            }
            for i in 0..slen {
                if char_to_fill[i] == b'?' {
                    char_to_fill[i] = b'z';
                }
            }
            println!("{}", String::from_utf8(char_to_fill).unwrap());
        }
    }
}


use std::io;
use std::io::Read;

fn main(){
    let mut stdin = io::stdin();
    let mut lines_str = String::new();
    let _ = stdin.read_to_string(&mut lines_str);
    let lines_vec = lines_str.lines().collect::<Vec<&str>>();
    let t :usize = lines_vec[0].trim().parse().unwrap();
    for i in 0..t {
        let linei_vec = lines_vec[i+1].split(' ').collect::<Vec<&str>>();
        let mut xyz = Vec::new();
        for j in 0..3 {
            let x :usize = linei_vec[j].trim().parse().unwrap();
            xyz.push(x);
        }
        xyz.sort();
        let xyz = xyz;

        if xyz[1] != xyz[2] {
            println!("NO");
        } else {
            println!("YES");
            println!("{} {} {}", xyz[0], xyz[0], xyz[1]);
        }
    }
}


use std::io::{self, Read, Write, BufWriter};

fn main(){
    let mut stdin = io::stdin();
    // From https://keens.github.io/blog/2017/10/05/rustdekousokunahyoujunshutsuryoku/
    let stdout = io::stdout();
    let mut output = BufWriter::new(stdout.lock());
    let mut input_str = String::new();
    let _ = stdin.read_to_string(&mut input_str);
    let mut input_iter = input_str.split_ascii_whitespace();
    // From https://github.com/rust-lang-ja/atcoder-rust-resources/wiki/2020-Update#proconio
    macro_rules! read(() => (input_iter.next().unwrap().parse().unwrap()));
    macro_rules! print(( $( $x:expr ),*) => (write!(output, $($x,)*).unwrap()));
    macro_rules! println(( $( $x:expr ),*) => (writeln!(output, $($x,)*).unwrap()));
    let t :usize = read!();
    for _ in 0..t {
        // Deal with each case
        let _ :usize = read!();
        let s :String = read!();
        let s_bytes = s.as_bytes();
        let keyword_bytes = "abacaba".as_bytes();
        let keywordlen = keyword_bytes.len();
        let slen = s_bytes.len();

        let mut char_to_fill = s_bytes.iter().cloned().collect::<Vec<u8>>();
        let mut is_matched = vec![vec![false;slen];keywordlen];
        let mut is_matched_wild = vec![vec![false;slen];keywordlen];
        for k in 0..slen {
            for j in 0..keywordlen {
                let i = j + k;
                if i >= slen { continue; }
                let c = keyword_bytes[j];
                if j > i {
                    is_matched[j][i] = false;
                    is_matched_wild[j][i] = false;
                } else if c == s_bytes[i] {
                    if j == 0 {
                        is_matched[j][i] = true;
                        is_matched_wild[j][i] = true;
                    } else { // i >= 1
                        is_matched[j][i] = is_matched[j-1][i-1];
                        is_matched_wild[j][i] = is_matched_wild[j-1][i-1];
                    }
                } else if s_bytes[i] == b'?' {
                    if j == 0 {
                        is_matched[j][i] = false;
                        is_matched_wild[j][i] = true;
                    } else { // i >= 1
                        is_matched[j][i] = false;
                        is_matched_wild[j][i] = is_matched_wild[j-1][i-1];
                    }
                } else {
                    is_matched[j][i] = false;
                    is_matched[j][i] = false;
                }
            }
        }
        //println!("{:?}", is_matched);
        let is_matched = is_matched;
        let is_matched_wild = is_matched_wild;
        let mut min = 0;
        let mut max = 0;
        for i in 0..slen {
            if is_matched[keywordlen-1][i] {
                min += 1;
            }
            if is_matched_wild[keywordlen-1][i] {
                max += 1;
            }
        }
        let min = min;
        let max = max;
        if min > 1 || max == 0 {
            println!("No");
        } else if min == 1 {
            println!("Yes");
            let mut filled_s_bytes = s_bytes.iter().cloned().collect::<Vec<u8>>();
            for i in 0..slen {
                if s_bytes[i] == b'?' {
                    filled_s_bytes[i] = b'z';
                } else {
                    filled_s_bytes[i] = s_bytes[i];
                }
            }
            println!("{}", String::from_utf8(filled_s_bytes).unwrap());
        } else { // min == 0
            println!("Yes");
            for i in 0..slen {
                if is_matched_wild[keywordlen-1][i] {
                    for j in 0..keywordlen {
                        char_to_fill[i-6+j] = keyword_bytes[j];
                    }
                }
            }
            for i in 0..slen {
                if char_to_fill[i] == b'?' {
                    char_to_fill[i] = b'z';
                }
            }
            println!("{}", String::from_utf8(char_to_fill).unwrap());
        }
    }
}