fn main() {
    input! {
        n: usize,
        k: usize,
        s: bytes,
    }
    const L: usize = 40;
    type B = [usize; L];
    let w = std::mem::size_of::<usize>() * 8;
    let shift_or = |a: &mut B, b: &B, s: usize| {
        let q = s / w;
        let r = s % w;
        if r == 0 {
            for (a, b) in a[q..].iter_mut().zip(b.iter()) {
                *a |= *b;
            }
        } else {
            for (a, b) in a[q..].iter_mut().zip(b.iter()) {
                *a |= *b << r;
            }
            for (a, b) in a[(q + 1)..].iter_mut().zip(b.iter()) {
                *a |= *b >> (w - r);
            }
        }
    };
    let at = |b: &B, x: usize| -> bool { b[x / w] >> (x % w) & 1 == 1 };
    // i, a, ab, abc
    let mut dp = (0..=n)
        .map(|i| vec![vec![[0; L]; 401]; i + 1])
        .collect::<Vec<_>>();
    dp[0][0][0][0] |= 1;
    for (i, s) in s.iter().enumerate() {
        let src = std::mem::take(&mut dp[i]);
        let dst = &mut dp[i + 1];
        if *s != b'N' && *s != b'A' && *s != b'C' {
            for (dst, src) in dst.iter_mut().zip(src.iter()) {
                for (dst, src) in dst.iter_mut().zip(src.iter()) {
                    shift_or(dst, src, 0);
                }
            }
        }
        if *s == b'N' || *s == b'?' {
            for (dst, src) in dst[1..].iter_mut().zip(src.iter()) {
                for (dst, src) in dst.iter_mut().zip(src.iter()) {
                    shift_or(dst, src, 0);
                }
            }
        }
        if *s == b'A' || *s == b'?' {
            for (add, (dst, src)) in dst.iter_mut().zip(src.iter()).enumerate() {
                if dst.len() < add {
                    continue;
                }
                for (dst, src) in dst[add..].iter_mut().zip(src.iter()) {
                    shift_or(dst, src, 0);
                }
            }
        }
        if *s == b'C' || *s == b'?' {
            for (dst, src) in dst.iter_mut().zip(src.iter()) {
                for (add, (dst, src)) in dst.iter_mut().zip(src.iter()).enumerate() {
                    shift_or(dst, src, add);
                }
            }
        }
        dp[i] = src;
    }
    if dp[n].iter().flatten().all(|dp| !at(dp, k)) {
        println!("-1");
        return;
    }
    let mut pos = (0, 0, 0);
    for (i, dp) in dp[n].iter().enumerate() {
        for (j, dp) in dp.iter().enumerate() {
            if at(dp, k) {
                pos = (i, j, k);
            }
        }
    }
    let mut ans = s.clone();
    for (i, s) in s.iter().enumerate().rev() {
        assert!(at(&dp[i + 1][pos.0][pos.1], pos.2));
        let mut c = None;
        if "NAC".bytes().all(|c| c != *s) && dp[i].len() > pos.0 && at(&dp[i][pos.0][pos.1], pos.2) {
            if *s == b'?' {
                c = Some(b'B');
            } else {
                c = Some(*s);
            }
        }
        if c.is_none() && (*s == b'N' || *s == b'?') && pos.0 > 0 && at(&dp[i][pos.0 - 1][pos.1], pos.2) {
            pos.0 -= 1;
            c = Some(b'N');
        }
        if c.is_none() && (*s == b'A' || *s == b'?') && pos.0 <= pos.1 && at(&dp[i][pos.0][pos.1 - pos.0], pos.2) {
            pos.1 -= pos.0;
            c = Some(b'A');
        }
        if c.is_none() && (*s == b'C' || *s == b'?') {
            assert!(at(&dp[i][pos.0][pos.1], pos.2 - pos.1));
            pos.2 -= pos.1;
            c = Some(b'C');
        }
        ans[i] = c.unwrap();
    }
    println!("{}", ans.into_iter().map(|c| c as char).collect::<String>());
}

// ---------- begin input macro ----------
// reference: https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
#[macro_export]
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_export]
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_export]
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")
    };
}
// ---------- end input macro ----------