Problem:
Score : 600 points

Problem Statement

There is a game that involves three variables, denoted A, B, and C.

As the game progresses, there will be N events where you are asked to make a choice.
Each of these choices is represented by a string s_i. If s_i is AB, you must add 1 to A or B then subtract 1 from the other; if s_i is AC, you must add 1 to A or C then subtract 1 from the other; if s_i is BC, you must add 1 to B or C then subtract 1 from the other.

After each choice, none of A, B, and C should be negative.

Determine whether it is possible to make N choices under this condition. If it is possible, also give one such way to make the choices.

Constraints

1 \leq N \leq 10^5

0 \leq A,B,C \leq 10^9

N, A, B, C are integers.

s_i is AB, AC, or BC.

Input

Input is given from Standard Input in the following format:

N A B C
s_1
s_2
:
s_N

Output

If it is possible to make N choices under the condition, print Yes; otherwise, print No.

Also, in the former case, show one such way to make the choices in the subsequent N lines. The (i+1)-th line should contain the name of the variable (A, B, or C) to which you add 1 in the i-th choice.

Sample Input 1

2 1 3 0
AB
AC

Sample Output 1

Yes
A
C

You can successfully make two choices, as follows:

In the first choice, add 1 to A and subtract 1 from B. A becomes 2, and B becomes 2.

In the second choice, add 1 to C and subtract 1 from A. C becomes 1, and A becomes 1.

Sample Input 2

3 1 0 0
AB
BC
AB

Sample Output 2

No

Sample Input 3

1 0 9 0
AC

Sample Output 3

No

Sample Input 4

8 6 9 1
AC
BC
AB
BC
AC
BC
AB
AB

Sample Output 4

Yes
C
B
B
C
C
B
A
A

Solution in Rust (1.42.0) (judge verdict: Accepted)

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