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 :$base :expr } ) =>{read_value !($iter ,String ) .chars () .map (|c |(c as u8 -$base as u8 ) as usize ) .collect ::<Vec <usize >>() } ;($iter :expr ,{char :$base :expr } ) =>{read_value !($iter ,{chars :$base } ) [0 ] } ;($iter :expr ,chars ) =>{read_value !($iter ,String ) .chars () .collect ::<Vec <char >>() } ;($iter :expr ,char ) =>{read_value !($iter ,chars ) [0 ] } ;($iter :expr ,usize1 ) =>{read_value !($iter ,usize ) -1 } ;($iter :expr ,$t :ty ) =>{$iter .next () .unwrap () .parse ::<$t >() .unwrap () } ;}
macro_rules !input_inner {($iter :expr ) =>{} ;($iter :expr ,) =>{} ;($iter :expr ,mut $var :ident :$t :tt $($r :tt ) *) =>{let mut $var =read_value !($iter ,$t ) ;input_inner !{$iter $($r ) *} } ;($iter :expr ,mut $var :ident $($r :tt ) *) =>{input_inner !{$iter ,mut $var :usize $($r ) *} } ;($iter :expr ,$var :ident :$t :tt $($r :tt ) *) =>{let $var =read_value !($iter ,$t ) ;input_inner !{$iter $($r ) *} } ;($iter :expr ,$var :ident $($r :tt ) *) =>{input_inner !{$iter ,$var :usize $($r ) *} } ;}
macro_rules !input {(source =$s :expr ,$($r :tt ) *) =>{let mut iter =$s .split_whitespace () ;input_inner !{iter ,$($r ) *} } ;(iter =$iter :ident ,$($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 ) *} } ;($($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 ) *} } ;}
fn main() {
    use std::cmp::min;
    input! { n, a, b, c, s: [chars; n] };
    let mut v = vec![vec![vec![vec![None; 3]; 3]; 3]; n + 1];
    for i in 0..=min(2, a) {
        for j in 0..=min(2, b) {
            for k in 0..=min(2, c) {
                v[0][i][j][k] = Some(false);
            }
        }
    }
    for m in 0..n {
        let ss = &s[m];
        for i in 0..=2 {
            for j in 0..=2 {
                for k in 0..=2 {
                    if v[m][i][j][k].is_none() {
                        continue;
                    }
                    if ss[0] == 'A' && ss[1] == 'B' {
                        if i > 0 && j < 2 {
                            v[m + 1][i - 1][j + 1][k] = Some(true);
                        }
                        if j > 0 && i < 2 {
                            v[m + 1][i + 1][j - 1][k] = Some(false);
                        }
                    } else if ss[0] == 'A' && ss[1] == 'C' {
                        if i > 0 && k < 2 {
                            v[m + 1][i - 1][j][k + 1] = Some(true);
                        }
                        if k > 0 && i < 2 {
                            v[m + 1][i + 1][j][k - 1] = Some(false);
                        }
                    } else {
                        if j > 0 && k < 2 {
                            v[m + 1][i][j - 1][k + 1] = Some(true);
                        }
                        if k > 0 && j < 2 {
                            v[m + 1][i][j + 1][k - 1] = Some(false);
                        }
                    };
                }
            }
        }
    }
    for i in 0..=2 {
        for j in 0..=2 {
            for k in 0..=2 {
                let mut m = n;
                let mut p = (i, j, k);
                let mut res = vec![];
                for _ in 0..n {
                    if let Some(pp) = v[m][p.0][p.1][p.2] {
                        m -= 1;
                        res.push(if pp { s[m][1] } else { s[m][0] });
                        if s[m][0] == 'A' && s[m][1] == 'B' {
                            if pp {
                                p.0 += 1;
                                p.1 -= 1;
                            } else {
                                p.0 -= 1;
                                p.1 += 1;
                            }
                        } else if s[m][0] == 'A' && s[m][1] == 'C' {
                            if pp {
                                p.0 += 1;
                                p.2 -= 1;
                            } else {
                                p.0 -= 1;
                                p.2 += 1;
                            }
                        } else {
                            if pp {
                                p.1 += 1;
                                p.2 -= 1;
                            } else {
                                p.1 -= 1;
                                p.2 += 1;
                            }
                        }
                    } else {
                        break;
                    }
                }
                if res.len() == n {
                    println!("Yes");
                    res.reverse();
                    for c in res.into_iter() {
                        println!("{}", c);
                    }
                    std::process::exit(0);
                }
            }
        }
    }
    println!("No");
}


Measured memory_bytes: 70060