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!();
    'outer: 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 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_wild[j][i] = false;
                } else if c == s_bytes[i] ||  s_bytes[i] == b'?' {
                    if j == 0 {
                        is_matched_wild[j][i] = true;
                    } else { // i >= 1
                        is_matched_wild[j][i] = is_matched_wild[j-1][i-1];
                    }
                } else {
                    is_matched_wild[j][i] = false;
                }
            }
        }
        let is_matched_wild = is_matched_wild;

        // For each pattern we just check it
        for i in 0..slen {
            if is_matched_wild[keywordlen-1][i] {
                let mut char_to_fill = s_bytes.iter().cloned().collect::<Vec<u8>>();
                for j in 0..keywordlen {
                    char_to_fill[i+1-keywordlen+j] = keyword_bytes[j];
                }
                for k in 0..slen {
                    if char_to_fill[k] == b'?' {
                        char_to_fill[k] = b'z';
                    }
                }
                // Check
                let mut is_matched = 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;
                        } else if c == char_to_fill[i] {
                            if j == 0 {
                                is_matched[j][i] = true;
                            } else { // i >= 1
                                is_matched[j][i] = is_matched[j-1][i-1];
                            }
                        } else {
                            is_matched[j][i] = false;
                        }
                    }
                }
                let is_matched = is_matched;

                let mut matchnum = 0;
                for i in 0..slen {
                    if is_matched[keywordlen-1][i] {
                        matchnum += 1;
                    }
                }
                let matchnum = matchnum;

                if matchnum == 1 {
                    println!("Yes");
                    println!("{}", String::from_utf8(char_to_fill).unwrap());
                    continue 'outer;
                }
            }
        }

        println!("No");
    }
}


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];
                    }
                    continue;
                }
            }
            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
    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();

    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_wild[j][i] = false;
            } else if c == s_bytes[i] ||  s_bytes[i] == b'?' {
                if j == 0 {
                    is_matched_wild[j][i] = true;
                } else { // i >= 1
                    is_matched_wild[j][i] = is_matched_wild[j-1][i-1];
                }
            } else {
                is_matched_wild[j][i] = false;
            }
        }
    }
    let is_matched_wild = is_matched_wild;

    // For each pattern we just check it
    for i in 0..slen {
        if is_matched_wild[keywordlen-1][i] {
            let mut char_to_fill = s_bytes.iter().cloned().collect::<Vec<u8>>();
            for j in 0..keywordlen {
                char_to_fill[i+1-keywordlen+j] = keyword_bytes[j];
            }
            for k in 0..slen {
                if char_to_fill[k] == b'?' {
                    char_to_fill[k] = b'z';
                }
            }
            // Check
            let mut is_matched = 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;
                    } else if c == char_to_fill[i] {
                        if j == 0 {
                            is_matched[j][i] = true;
                        } else { // i >= 1
                            is_matched[j][i] = is_matched[j-1][i-1];
                        }
                    } else {
                        is_matched[j][i] = false;
                    }
                }
            }
            let is_matched = is_matched;

            let mut matchnum = 0;
            for i in 0..slen {
                if is_matched[keywordlen-1][i] {
                    matchnum += 1;
                }
            }
            let matchnum = matchnum;

            if matchnum == 1 {
                println!("Yes");
                println!("{}", String::from_utf8(char_to_fill).unwrap());
                return;
            }
        }
    }

    println!("No");
}


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

use std::cmp::{max, min};
use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, VecDeque};
use std::io::{stdin, stdout, BufWriter, Write};
use std::mem::swap;

#[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().unwrap();
            }
            let mut input = String::new();
            stdin().read_line(&mut input).unwrap();
            self.buffer = input.split_whitespace().rev().map(String::from).collect();
        }
    }
}

fn solve_case<T: Write>(scan: &mut Scanner, out: &mut BufWriter<T>) {
    let n: usize = scan.next();
    let s: Vec<char> = scan.next::<String>().chars().collect();
    let p: Vec<char> = "abacaba".to_owned().chars().collect();
    for i in 0..=n-7 {
        let mut s2 = s.clone();
        let mut ok = true;
        for k in 0..7 {
            if s2[i+k] == '?' {
                s2[i+k] = p[k];
            } else if s2[i+k] != p[k] {
                ok = false;
            }
        }
        if !ok { continue; }
        for k in 0..n {
            if s2[k] == '?' {
                s2[k] = 'x';
            }
        }
        let mut nn = 0;
        for j in 0..=n-7 {
            if &s2[j..j+7] == &p[..] {
                nn += 1;
            }
        }
        if nn == 1 {
            let ans: String = s2.iter().collect();
            writeln!(out, "Yes").unwrap();
            writeln!(out, "{}", ans).unwrap();
            return;
        }
    }
    writeln!(out, "No").unwrap();
}

fn solve<T: Write>(scan: &mut Scanner, out: &mut BufWriter<T>) {
    let t: usize = scan.next();
    for _ in 0..t {
        solve_case(scan, out);
    }
}

fn main() {
    std::thread::Builder::new()
        .name("solver_thread".into())
        .stack_size(1024 * 1024 * 1024)
        .spawn(|| {
            let mut scan = Scanner::default();
            let out = stdout();
            let mut out = BufWriter::new(out.lock());
            solve(&mut scan, &mut out);
        })
        .unwrap()
        .join()
        .unwrap();
}


#![allow(dead_code, unused_macros, unused_imports)]
use std::collections::*;
use std::io;
use std::io::Write;
macro_rules! fprintln {
    ($dst:expr) => (
        $dst.write("\n".as_bytes()).unwrap();
    );
    ($dst:expr, $($arg:tt)*) => ( {
        $dst.write_fmt(format_args!($($arg)*)).unwrap();
        $dst.write("\n".as_bytes()).unwrap();
    }
    );
}

macro_rules! fprintvec {
    ($dst:expr, $arg:expr) => {{
        fprintln!(
            $dst,
            "{}",
            $arg.iter()
                .map(|x| format!("{}", x))
                .collect::<Vec<String>>()
                .join("")
        );
    }};
}

macro_rules! parse_input {
    ($t:ident) => {{
        let mut input_line = String::new();
        io::stdin().read_line(&mut input_line).unwrap();
        input_line
            .trim_end_matches("\n")
            .trim_end_matches("\r")
            .parse::<$t>()
            .unwrap()
    }};
}

macro_rules! split_input {
    ($t:ident) => {{
        parse_input!(String)
            .split(" ")
            .map(|z| z.parse::<$t>().unwrap())
            .collect::<Vec<$t>>()
    }};
}

fn is_abacaba(s: &str, m: &str) -> (bool, bool) {
    if s.len() < m.len() {
        return (false, false);
    }
    let mut exact = true;
    for i in 0..7 {
        if s.as_bytes()[i] == '?' as u8 {
            exact = false;
            continue;
        } else if s.as_bytes()[i] != m.as_bytes()[i] {
            return (false, false);
        }
    }
    (true, exact)
}

fn main() {
    let stdout = io::stdout();
    let lock = stdout.lock();
    let mut w = io::BufWriter::new(lock);
    let num_tests = parse_input!(usize);
    // let num_tests = 1;
    for _ in 0..num_tests {
        let limits = split_input!(usize);
        let s = parse_input!(String);
        let mut sa = s.as_bytes().iter().cloned().collect::<Vec<u8>>();
        let mut exact_count = 0;
        let mut non_exact_pos = None;
        if sa.len() >= 7 {
            for (p, i) in sa[..sa.len() - 6].iter().enumerate() {
                let (mat, exact) = is_abacaba(&s[p..p + 7], "abacaba");
                if exact {
                    exact_count += 1;
                } else if p + 7 < s.len() && mat {
                    let (_, exact1) =
                        is_abacaba(&s[p + 7..std::cmp::min(s.len() - 1, p + 7 + 4)], "caba");
                    let (_, exact2) =
                        is_abacaba(&s[p + 7..std::cmp::min(s.len() - 1, p + 7 + 6)], "bacaba");
                    if exact1 == false && exact2 == false {
                        non_exact_pos = Some(p);
                    }
                } else if mat {
                    non_exact_pos = Some(p);
                }
                // println!("{}", i);
            }
        }
        if exact_count >= 2 || exact_count == 0 && non_exact_pos == None {
            fprintln!(w, "No");
        } else {
            if exact_count == 0 && non_exact_pos.is_some() {
                let p = non_exact_pos.unwrap();
                sa[p] = 'a' as u8;
                sa[p + 1] = 'b' as u8;
                sa[p + 2] = 'a' as u8;
                sa[p + 3] = 'c' as u8;
                sa[p + 4] = 'a' as u8;
                sa[p + 5] = 'b' as u8;
                sa[p + 6] = 'a' as u8;
            }
            sa = sa
                .iter()
                .map(|&x| if x == '?' as u8 { 'z' as u8 } else { x })
                .collect();
            fprintln!(w, "YES");
            unsafe {
                fprintln!(w, "{}", std::str::from_utf8_unchecked(&sa));
            }
        }
    }
}


#![allow(dead_code, unused_macros, unused_imports)]
use std::collections::*;
use std::io;
use std::io::Write;
macro_rules! fprintln {
    ($dst:expr) => (
        $dst.write("\n".as_bytes()).unwrap();
    );
    ($dst:expr, $($arg:tt)*) => ( {
        $dst.write_fmt(format_args!($($arg)*)).unwrap();
        $dst.write("\n".as_bytes()).unwrap();
    }
    );
}

macro_rules! fprintvec {
    ($dst:expr, $arg:expr) => {{
        fprintln!(
            $dst,
            "{}",
            $arg.iter()
                .map(|x| format!("{}", x))
                .collect::<Vec<String>>()
                .join("")
        );
    }};
}

macro_rules! parse_input {
    ($t:ident) => {{
        let mut input_line = String::new();
        io::stdin().read_line(&mut input_line).unwrap();
        input_line
            .trim_end_matches("\n")
            .trim_end_matches("\r")
            .parse::<$t>()
            .unwrap()
    }};
}

macro_rules! split_input {
    ($t:ident) => {{
        parse_input!(String)
            .split(" ")
            .map(|z| z.parse::<$t>().unwrap())
            .collect::<Vec<$t>>()
    }};
}

fn is_abacaba(s: &str, m: &str) -> (bool, bool) {
    if s.len() < m.len() {
        return (false, false);
    }
    let mut exact = true;
    for i in 0..m.len() {
        if s.as_bytes()[i] == '?' as u8 {
            exact = false;
            continue;
        } else if s.as_bytes()[i] != m.as_bytes()[i] {
            return (false, false);
        }
    }
    (true, exact)
}

fn main() {
    let stdout = io::stdout();
    let lock = stdout.lock();
    let mut w = io::BufWriter::new(lock);
    let num_tests = parse_input!(usize);
    // let num_tests = 1;
    for _ in 0..num_tests {
        let limits = split_input!(usize);
        let s = parse_input!(String);
        let mut sa = s.as_bytes().iter().cloned().collect::<Vec<u8>>();
        let mut exact_count = 0;
        let mut non_exact_pos = None;
        if sa.len() >= 7 {
            for (p, i) in sa[..sa.len() - 6].iter().enumerate() {
                let (mat, exact) = is_abacaba(&s[p..p + 7], "abacaba");
                if exact {
                    exact_count += 1;
                } else if mat {
                    let mut valid = true;
                    if p + 7 < s.len() {
                        let (_, exact1) =
                            is_abacaba(&s[p + 7..std::cmp::min(s.len(), p + 7 + 4)], "caba");
                        let (_, exact2) =
                            is_abacaba(&s[p + 7..std::cmp::min(s.len(), p + 7 + 6)], "bacaba");
                        if exact1 || exact2 {
                            valid = false;
                        }
                    }
                    if p >= 4 {
                        let (_, exact1) = is_abacaba(&s[p - 4..p], "abac");
                        if exact1 {
                            valid = false;
                        }
                    }
                    if valid && non_exact_pos.is_none() {
                        non_exact_pos = Some(p);
                    }
                }
                // println!("{}", i);
            }
        }
        if exact_count >= 2 || exact_count == 0 && non_exact_pos == None {
            fprintln!(w, "No");
        } else {
            if exact_count == 0 && non_exact_pos.is_some() {
                let p = non_exact_pos.unwrap();
                sa[p] = 'a' as u8;
                sa[p + 1] = 'b' as u8;
                sa[p + 2] = 'a' as u8;
                sa[p + 3] = 'c' as u8;
                sa[p + 4] = 'a' as u8;
                sa[p + 5] = 'b' as u8;
                sa[p + 6] = 'a' as u8;
            }
            sa = sa
                .iter()
                .map(|&x| if x == '?' as u8 { 'z' as u8 } else { x })
                .collect();
            fprintln!(w, "YES");
            unsafe {
                fprintln!(w, "{}", std::str::from_utf8_unchecked(&sa));
            }
        }
    }
}


#![allow(dead_code, unused_macros, unused_imports)]
use std::collections::*;
use std::io;
use std::io::Write;
macro_rules! fprintln {
    ($dst:expr) => (
        $dst.write("\n".as_bytes()).unwrap();
    );
    ($dst:expr, $($arg:tt)*) => ( {
        $dst.write_fmt(format_args!($($arg)*)).unwrap();
        $dst.write("\n".as_bytes()).unwrap();
    }
    );
}

macro_rules! fprintvec {
    ($dst:expr, $arg:expr) => {{
        fprintln!(
            $dst,
            "{}",
            $arg.iter()
                .map(|x| format!("{}", x))
                .collect::<Vec<String>>()
                .join("")
        );
    }};
}

macro_rules! parse_input {
    ($t:ident) => {{
        let mut input_line = String::new();
        io::stdin().read_line(&mut input_line).unwrap();
        input_line
            .trim_end_matches("\n")
            .trim_end_matches("\r")
            .parse::<$t>()
            .unwrap()
    }};
}

macro_rules! split_input {
    ($t:ident) => {{
        parse_input!(String)
            .split(" ")
            .map(|z| z.parse::<$t>().unwrap())
            .collect::<Vec<$t>>()
    }};
}

fn is_abacaba(s: &str, m: &str) -> (bool, bool) {
    if s.len() < m.len() {
        return (false, false);
    }
    let mut exact = true;
    for i in 0..7 {
        if s.as_bytes()[i] == '?' as u8 {
            exact = false;
            continue;
        } else if s.as_bytes()[i] != m.as_bytes()[i] {
            return (false, false);
        }
    }
    (true, exact)
}

fn main() {
    let stdout = io::stdout();
    let lock = stdout.lock();
    let mut w = io::BufWriter::new(lock);
    let num_tests = parse_input!(usize);
    // let num_tests = 1;
    for _ in 0..num_tests {
        let limits = split_input!(usize);
        let s = parse_input!(String);
        let mut sa = s.as_bytes().iter().cloned().collect::<Vec<u8>>();
        let mut exact_count = 0;
        let mut non_exact_pos = None;
        for (p, i) in sa[..sa.len() - 6].iter().enumerate() {
            let (mat, exact) = is_abacaba(&s[p..p + 7], &"abacaba");
            if exact {
                exact_count += 1;
            } else if p + 7 < s.len() && mat {
                let (_, exact1) =
                    is_abacaba(&s[p + 7..std::cmp::min(s.len() - 1, p + 7 + 4)], "caba");
                let (_, exact2) =
                    is_abacaba(&s[p + 7..std::cmp::min(s.len() - 1, p + 7 + 6)], "bacaba");
                if exact1 == false && exact2 == false {
                    non_exact_pos = Some(p);
                }
            } else if mat {
                non_exact_pos = Some(p);
            }
            // println!("{}", i);
        }
        if exact_count >= 2 || exact_count == 0 && non_exact_pos == None {
            fprintln!(w, "No");
        } else {
            if exact_count == 0 && non_exact_pos.is_some() {
                let p = non_exact_pos.unwrap();
                sa[p] = 'a' as u8;
                sa[p + 1] = 'b' as u8;
                sa[p + 2] = 'a' as u8;
                sa[p + 3] = 'c' as u8;
                sa[p + 4] = 'a' as u8;
                sa[p + 5] = 'b' as u8;
                sa[p + 6] = 'a' as u8;
            }
            sa = sa
                .iter()
                .map(|&x| if x == '?' as u8 { 'z' as u8 } else { x })
                .collect();
            fprintln!(w, "YES");
            unsafe {
                fprintln!(w, "{}", std::str::from_utf8_unchecked(&sa));
            }
        }
    }
}


#![allow(dead_code, unused_macros, unused_imports)]
use std::collections::*;
use std::io;
use std::io::Write;
macro_rules! fprintln {
    ($dst:expr) => (
        $dst.write("\n".as_bytes()).unwrap();
    );
    ($dst:expr, $($arg:tt)*) => ( {
        $dst.write_fmt(format_args!($($arg)*)).unwrap();
        $dst.write("\n".as_bytes()).unwrap();
    }
    );
}

macro_rules! fprintvec {
    ($dst:expr, $arg:expr) => {{
        fprintln!(
            $dst,
            "{}",
            $arg.iter()
                .map(|x| format!("{}", x))
                .collect::<Vec<String>>()
                .join("")
        );
    }};
}

macro_rules! parse_input {
    ($t:ident) => {{
        let mut input_line = String::new();
        io::stdin().read_line(&mut input_line).unwrap();
        input_line
            .trim_end_matches("\n")
            .trim_end_matches("\r")
            .parse::<$t>()
            .unwrap()
    }};
}

macro_rules! split_input {
    ($t:ident) => {{
        parse_input!(String)
            .split(" ")
            .map(|z| z.parse::<$t>().unwrap())
            .collect::<Vec<$t>>()
    }};
}

fn is_abacaba(s: &str, m: &str) -> (bool, bool) {
    if s.len() < m.len() {
        return (false, false);
    }
    let mut exact = true;
    for i in 0..m.len() {
        if s.as_bytes()[i] == '?' as u8 {
            exact = false;
            continue;
        } else if s.as_bytes()[i] != m.as_bytes()[i] {
            return (false, false);
        }
    }
    (true, exact)
}

fn main() {
    let stdout = io::stdout();
    let lock = stdout.lock();
    let mut w = io::BufWriter::new(lock);
    let num_tests = parse_input!(usize);
    // let num_tests = 1;
    for _ in 0..num_tests {
        let limits = split_input!(usize);
        let s = parse_input!(String);
        let mut sa = s.as_bytes().iter().cloned().collect::<Vec<u8>>();
        let mut exact_count = 0;
        let mut non_exact_pos = None;
        if sa.len() >= 7 {
            for (p, i) in sa[..sa.len() - 6].iter().enumerate() {
                let (mat, exact) = is_abacaba(&s[p..p + 7], "abacaba");
                if exact {
                    exact_count += 1;
                } else if p + 7 < s.len() && mat {
                    let (_, exact1) =
                        is_abacaba(&s[p + 7..std::cmp::min(s.len() - 1, p + 7 + 4)], "caba");
                    let (_, exact2) =
                        is_abacaba(&s[p + 7..std::cmp::min(s.len() - 1, p + 7 + 6)], "bacaba");
                    if exact1 == false && exact2 == false {
                        non_exact_pos = Some(p);
                    }
                } else if mat {
                    non_exact_pos = Some(p);
                }
                // println!("{}", i);
            }
        }
        if exact_count >= 2 || exact_count == 0 && non_exact_pos == None {
            fprintln!(w, "No");
        } else {
            if exact_count == 0 && non_exact_pos.is_some() {
                let p = non_exact_pos.unwrap();
                sa[p] = 'a' as u8;
                sa[p + 1] = 'b' as u8;
                sa[p + 2] = 'a' as u8;
                sa[p + 3] = 'c' as u8;
                sa[p + 4] = 'a' as u8;
                sa[p + 5] = 'b' as u8;
                sa[p + 6] = 'a' as u8;
            }
            sa = sa
                .iter()
                .map(|&x| if x == '?' as u8 { 'z' as u8 } else { x })
                .collect();
            fprintln!(w, "YES");
            unsafe {
                fprintln!(w, "{}", std::str::from_utf8_unchecked(&sa));
            }
        }
    }
}


#![allow(dead_code, unused_macros, unused_imports)]
use std::collections::*;
use std::io;
use std::io::Write;
macro_rules! fprintln {
    ($dst:expr) => (
        $dst.write("\n".as_bytes()).unwrap();
    );
    ($dst:expr, $($arg:tt)*) => ( {
        $dst.write_fmt(format_args!($($arg)*)).unwrap();
        $dst.write("\n".as_bytes()).unwrap();
    }
    );
}

macro_rules! fprintvec {
    ($dst:expr, $arg:expr) => {{
        fprintln!(
            $dst,
            "{}",
            $arg.iter()
                .map(|x| format!("{}", x))
                .collect::<Vec<String>>()
                .join("")
        );
    }};
}

macro_rules! parse_input {
    ($t:ident) => {{
        let mut input_line = String::new();
        io::stdin().read_line(&mut input_line).unwrap();
        input_line
            .trim_end_matches("\n")
            .trim_end_matches("\r")
            .parse::<$t>()
            .unwrap()
    }};
}

macro_rules! split_input {
    ($t:ident) => {{
        parse_input!(String)
            .split(" ")
            .map(|z| z.parse::<$t>().unwrap())
            .collect::<Vec<$t>>()
    }};
}

fn is_abacaba(s: &str, m: &str) -> (bool, bool) {
    if s.len() < m.len() {
        return (false, false);
    }
    let mut exact = true;
    for i in 0..m.len() {
        if s.as_bytes()[i] == '?' as u8 {
            exact = false;
            continue;
        } else if s.as_bytes()[i] != m.as_bytes()[i] {
            return (false, false);
        }
    }
    (true, exact)
}

fn main() {
    let stdout = io::stdout();
    let lock = stdout.lock();
    let mut w = io::BufWriter::new(lock);
    let num_tests = parse_input!(usize);
    // let num_tests = 1;
    for _ in 0..num_tests {
        let limits = split_input!(usize);
        let s = parse_input!(String);
        let mut sa = s.as_bytes().iter().cloned().collect::<Vec<u8>>();
        let mut exact_count = 0;
        let mut non_exact_pos = None;
        if sa.len() >= 7 {
            for (p, i) in sa[..sa.len() - 6].iter().enumerate() {
                let (mat, exact) = is_abacaba(&s[p..p + 7], "abacaba");
                if exact {
                    exact_count += 1;
                } else if p + 7 < s.len() && mat {
                    let (_, exact1) =
                        is_abacaba(&s[p + 7..std::cmp::min(s.len(), p + 7 + 4)], "caba");
                    let (_, exact2) =
                        is_abacaba(&s[p + 7..std::cmp::min(s.len(), p + 7 + 6)], "bacaba");
                    if exact1 == false && exact2 == false && non_exact_pos.is_none() {
                        non_exact_pos = Some(p);
                    }
                } else if mat && non_exact_pos.is_none() {
                    non_exact_pos = Some(p);
                }
                // println!("{}", i);
            }
        }
        if exact_count >= 2 || exact_count == 0 && non_exact_pos == None {
            fprintln!(w, "No");
        } else {
            if exact_count == 0 && non_exact_pos.is_some() {
                let p = non_exact_pos.unwrap();
                sa[p] = 'a' as u8;
                sa[p + 1] = 'b' as u8;
                sa[p + 2] = 'a' as u8;
                sa[p + 3] = 'c' as u8;
                sa[p + 4] = 'a' as u8;
                sa[p + 5] = 'b' as u8;
                sa[p + 6] = 'a' as u8;
            }
            sa = sa
                .iter()
                .map(|&x| if x == '?' as u8 { 'z' as u8 } else { x })
                .collect();
            fprintln!(w, "YES");
            unsafe {
                fprintln!(w, "{}", std::str::from_utf8_unchecked(&sa));
            }
        }
    }
}


#![allow(dead_code, unused_macros, unused_imports)]
use std::collections::*;
use std::io;
use std::io::Write;
macro_rules! fprintln {
    ($dst:expr) => (
        $dst.write("\n".as_bytes()).unwrap();
    );
    ($dst:expr, $($arg:tt)*) => ( {
        $dst.write_fmt(format_args!($($arg)*)).unwrap();
        $dst.write("\n".as_bytes()).unwrap();
    }
    );
}

macro_rules! fprintvec {
    ($dst:expr, $arg:expr) => {{
        fprintln!(
            $dst,
            "{}",
            $arg.iter()
                .map(|x| format!("{}", x))
                .collect::<Vec<String>>()
                .join("")
        );
    }};
}

macro_rules! parse_input {
    ($t:ident) => {{
        let mut input_line = String::new();
        io::stdin().read_line(&mut input_line).unwrap();
        input_line
            .trim_end_matches("\n")
            .trim_end_matches("\r")
            .parse::<$t>()
            .unwrap()
    }};
}

macro_rules! split_input {
    ($t:ident) => {{
        parse_input!(String)
            .split(" ")
            .map(|z| z.parse::<$t>().unwrap())
            .collect::<Vec<$t>>()
    }};
}

fn is_abacaba(s: &str, m: &str) -> (bool, bool) {
    if s.len() < m.len() {
        return (false, false);
    }
    let mut exact = true;
    for i in 0..7 {
        if s.as_bytes()[i] == '?' as u8 {
            exact = false;
            continue;
        } else if s.as_bytes()[i] != m.as_bytes()[i] {
            return (false, false);
        }
    }
    (true, exact)
}

fn main() {
    let stdout = io::stdout();
    let lock = stdout.lock();
    let mut w = io::BufWriter::new(lock);
    let num_tests = parse_input!(usize);
    // let num_tests = 1;
    for _ in 0..num_tests {
        let limits = split_input!(usize);
        let s = parse_input!(String);
        let mut sa = s.as_bytes().iter().cloned().collect::<Vec<u8>>();
        let mut exact_count = 0;
        let mut non_exact_pos = None;
        for (p, i) in sa[..sa.len() - 6].iter().enumerate() {
            let (mat, exact) = is_abacaba(&s[p..p + 7], &"abacaba");
            if exact {
                exact_count += 1;
            } else if p + 7 < s.len() && mat {
                let (_, exact1) =
                    is_abacaba(&s[p + 7..std::cmp::min(s.len() - 1, p + 7 + 4)], "caba");
                let (_, exact2) =
                    is_abacaba(&s[p + 7..std::cmp::min(s.len() - 1, p + 7 + 6)], "bacaba");
                if exact1 == false && exact2 == false {
                    non_exact_pos = Some(p);
                }
            } else if mat {
                non_exact_pos = Some(p);
            }
            // println!("{}", i);
        }
        if exact_count >= 2 || exact_count == 0 && non_exact_pos == None {
            fprintln!(w, "No");
        } else {
            if exact_count == 0 && non_exact_pos.is_some() {
                let p = non_exact_pos.unwrap();
                sa[p] = 'a' as u8;
                sa[p + 1] = 'b' as u8;
                sa[p + 2] = 'a' as u8;
                sa[p + 3] = 'c' as u8;
                sa[p + 4] = 'a' as u8;
                sa[p + 5] = 'b' as u8;
                sa[p + 6] = 'a' as u8;
            }
            sa = sa
                .iter()
                .map(|&x| if x == '?' as u8 { 'z' as u8 } else { x })
                .collect();
            fprintln!(w, "YES");
            fprintln!(w, "{}", std::str::from_utf8(&sa).unwrap());
        }
    }
}


#![allow(dead_code, unused_macros, unused_imports)]
use std::collections::*;
use std::io;
use std::io::Write;
macro_rules! fprintln {
    ($dst:expr) => (
        $dst.write("\n".as_bytes()).unwrap();
    );
    ($dst:expr, $($arg:tt)*) => ( {
        $dst.write_fmt(format_args!($($arg)*)).unwrap();
        $dst.write("\n".as_bytes()).unwrap();
    }
    );
}

macro_rules! fprintvec {
    ($dst:expr, $arg:expr) => {{
        fprintln!(
            $dst,
            "{}",
            $arg.iter()
                .map(|x| format!("{}", x))
                .collect::<Vec<String>>()
                .join("")
        );
    }};
}

macro_rules! parse_input {
    ($t:ident) => {{
        let mut input_line = String::new();
        io::stdin().read_line(&mut input_line).unwrap();
        input_line
            .trim_end_matches("\n")
            .trim_end_matches("\r")
            .parse::<$t>()
            .unwrap()
    }};
}

macro_rules! split_input {
    ($t:ident) => {{
        parse_input!(String)
            .split(" ")
            .map(|z| z.parse::<$t>().unwrap())
            .collect::<Vec<$t>>()
    }};
}

fn is_abacaba(s: &str, m: &str) -> (bool, bool) {
    if s.len() < m.len() {
        return (false, false);
    }
    let mut exact = true;
    for i in 0..m.len() {
        if s.as_bytes()[i] == '?' as u8 {
            exact = false;
            continue;
        } else if s.as_bytes()[i] != m.as_bytes()[i] {
            return (false, false);
        }
    }
    (true, exact)
}

fn main() {
    let stdout = io::stdout();
    let lock = stdout.lock();
    let mut w = io::BufWriter::new(lock);
    let num_tests = parse_input!(usize);
    // let num_tests = 1;
    for _ in 0..num_tests {
        let limits = split_input!(usize);
        let s = parse_input!(String);
        let mut sa = s.as_bytes().iter().cloned().collect::<Vec<u8>>();
        let mut exact_count = 0;
        let mut non_exact_pos = None;
        if sa.len() >= 7 {
            for (p, i) in sa[..sa.len() - 6].iter().enumerate() {
                let (mat, exact) = is_abacaba(&s[p..p + 7], "abacaba");
                if exact {
                    exact_count += 1;
                } else if mat {
                    let mut valid = true;
                    if p + 7 < s.len() {
                        let (_, exact1) =
                            is_abacaba(&s[p + 7..std::cmp::min(s.len(), p + 7 + 4)], "caba");
                        let (_, exact2) =
                            is_abacaba(&s[p + 7..std::cmp::min(s.len(), p + 7 + 6)], "bacaba");
                        if exact1 || exact2 {
                            valid = false;
                        }
                    }
                    if p >= 4 {
                        let (_, exact1) = is_abacaba(&s[p - 4..p], "abac");
                        if exact1 {
                            valid = false;
                        }
                    }
                    if p >= 6 {
                        let (_, exact1) = is_abacaba(&s[p - 6..p], "abacab");
                        if exact1 {
                            valid = false;
                        }
                    }
                    if valid && non_exact_pos.is_none() {
                        non_exact_pos = Some(p);
                    }
                }
                // println!("{}", i);
            }
        }
        if exact_count >= 2 || exact_count == 0 && non_exact_pos == None {
            fprintln!(w, "No");
        } else {
            if exact_count == 0 && non_exact_pos.is_some() {
                let p = non_exact_pos.unwrap();
                sa[p] = 'a' as u8;
                sa[p + 1] = 'b' as u8;
                sa[p + 2] = 'a' as u8;
                sa[p + 3] = 'c' as u8;
                sa[p + 4] = 'a' as u8;
                sa[p + 5] = 'b' as u8;
                sa[p + 6] = 'a' as u8;
            }
            sa = sa
                .iter()
                .map(|&x| if x == '?' as u8 { 'z' as u8 } else { x })
                .collect();
            fprintln!(w, "YES");
            unsafe {
                fprintln!(w, "{}", std::str::from_utf8_unchecked(&sa));
            }
        }
    }
}


use std::io;

fn solve() -> Vec<String> {
    let mut input = "".split_ascii_whitespace();
    let mut read = || loop {
        if let Some(word) = input.next() {
            break word;
        }
        input = {
            let mut input = "".to_owned();
            io::stdin().read_line(&mut input).unwrap();
            if input.is_empty() {
                panic!("reached EOF");
            }
            Box::leak(input.into_boxed_str()).split_ascii_whitespace()
        };
    };
    macro_rules! read(($ty:ty) => (read().parse::<$ty>().unwrap()));

    let mut rr = vec!["".to_string(); 0];

    let t = read!(usize);
    let ta = "abacaba".chars().collect::<Vec<char>>();
    let tl = ta.len();
    for _ in 0..t {
        let n = read!(usize);
        let s = read!(String);

        let mut sa = s.chars().collect::<Vec<char>>();
        let mut o = 0;
        for i in 0..(n - tl + 1) {
            let mut ok = true;
            for j in 0..tl {
                if sa[i + j] != ta[j] {
                    ok = false;
                    break;
                }
            }
            if ok {
                o += 1;
            }
        }

        if o > 1 {
            rr.push("No".to_string());
        } else if o == 1 {
            for i in 0..n {
                if sa[i] == '?' {
                    sa[i] = 'z';
                }
            }
            rr.push("Yes".to_string());
            rr.push(sa.into_iter().collect());
        } else {
            let mut ok = false;
            let mut q = vec![0; 0];
            for i in 0..(n - tl + 1) {
                let mut oi = true;
                for j in 0..tl {
                    if sa[i + j] == '?' {
                        q.push(i + j);
                    } else if sa[i + j] != ta[j] {
                        oi = false;
                        break;
                    }
                }
                if !oi {
                    continue;
                }
                for j in q.iter() {
                    sa[*j] = ta[(*j) - i];
                }
                let mut p = 0;
                for i in 0..(n - tl + 1) {
                    let mut ok = true;
                    for j in 0..tl {
                        if sa[i + j] != ta[j] {
                            ok = false;
                            break;
                        }
                    }
                    if ok {
                        p += 1;
                    }
                }
                if p == 1 {
                    ok = true;
                    break;
                }
                for j in q.iter() {
                    sa[*j] = '?';
                }
            }
            if ok {
                for i in 0..n {
                    if sa[i] == '?' {
                        sa[i] = 'z';
                    }
                }
                rr.push("Yes".to_string());
                rr.push(sa.into_iter().collect());
            } else {
                rr.push("No".to_string());
            }
        }
    }

    rr
}

#[allow(dead_code)]
fn main() {
    let output = solve();
    println!("{}", output.join("\n"));
}


#include<map>
#include<queue>
#include<math.h>
#include<algorithm>
#include<string.h>
#include <string>
#include<stdio.h>
#include<iostream>
#include<sstream>    //字符串流头文件

using namespace std;
#define N 112345
#define M 33
#define INF 0x3f3f3f3f
int y, m, d, sum;

int main()
{
    int T, cnt, rep;
    string str;
    map<string, int> map1;

    while(cin>>T){
        map1.clear();

        while(T--){
            cin>>str;
            if(map1.count(str)>0)
            {
                int num = map1[str];
                map1[str] = num + 1;
                cout<<str<<num<<endl;
            }else{
                printf("Ok\n");
                map1[str] = 1;
            }
        }
    }
    return 0;
}


#include<map>
#include<queue>
#include<math.h>
#include<algorithm>
#include<string.h>
#include <string>
#include<stdio.h>
#include<iostream>
#include<sstream>    //字符串流头文件

using namespace std;
#define N 112345
#define M 33
#define INF 0x3f3f3f3f
int y, m, d, sum;

int main()
{
    int T, cnt, rep;
    string str;
    map<string, int> map1;

    cin>>T;
    while(T--){
        cin>>str;
        if(map1.count(str)>0)
        {
            cout<<str<<map1[str]<<endl;
            ++map1[str];
        }else{
            printf("Ok\n");
            map1[str] = 1;
        }
    }
    return 0;
}


#include<iostream>
#include<map>
#define ll long long

using namespace std;
map<string,ll> m;
string s;
ll n;

int main()
{
    cin>>n;
    getline(cin,s);
    for(ll i=1;i<=n;i++)
    {
        getline(cin,s);
        if(m[s]!=0) cout<<s<<m[s]<<'\n',++m[s];
        else cout<<"OK\n",m[s]=1;
    }
}


#include<map>
#include<queue>
#include<math.h>
#include<algorithm>
#include<string.h>
#include <string>
#include<stdio.h>
#include<iostream>
#include<sstream>    //字符串流头文件

using namespace std;
#define N 112345
#define M 33
#define INF 0x3f3f3f3f
int y, m, d, sum;

int main()
{
    int T, cnt, rep;
    string str;
    map<string, int> map1;

    cin>>T;
    while(T--){
        cin>>str;
        if(map1.count(str)>0)
        {
            cout<<str<<num<<endl;
            ++map1[str];
        }else{
            printf("Ok\n");
            map1[str] = 1;
        }
    }
    return 0;
}


#include<iostream>
#include<map>
#define ll long long

using namespace std;
map<string,ll> m;
string s;
ll n;

int main()
{
    int T;
    cin>>T;
    while(T--){
        cin>>s;
        if(m[s]!=0) cout<<s<<m[s]<<'\n',++m[s];
        else cout<<"OK\n",m[s]=1;
    }
}


#include<iostream>
#include<map>
#define ll long long

using namespace std;
map<string,ll> m;
string s;
ll n;

int main()
{
    cin>>T;
    cin>>s
    while(T--){
        cin>>s;
        if(m[s]!=0) cout<<s<<m[s]<<'\n',++m[s];
        else cout<<"OK\n",m[s]=1;
    }
}


If TextBox1.Text = "اثيلين" Then
            TextBox2.Text = "بولي ايثيلين, كلوريد الفينيل, أكسيد الإيثيلين/أثلين كلايكول, الستايرين/البوليسترين"
            TextBox3.Text = "التغليف والعزل, الأجهزة الطبية, مستحضرات التجميل, تغليف المواد الغذائية"
            TextBox4.Text = "مقاومة كيميائية, متوفر بشكل صلب أو مرن, شفاف وهش"
        ElseIf TextBox1.Text = "بروبيلين" Then
            TextBox2.Text = "البولي بروبلين, لأكريلونيتريل, أكسيد البروبيلين, الكيومين, أوكسو الكحول"
            TextBox3.Text = "الحاويات المقاومة للماكرويف, الثياب المنسوجة, المواد اللاصقة, المنتجات المرتبطة بالسيارة, الأحبار"
            TextBox4.Text = "قاسي ومرن, خفيف الوزن, مذوب للشحوم, شفاف ومتين, قابل للإمتزاج مع مواد كيميائية"
        ElseIf TextBox1.Text = "C4" Then
            TextBox2.Text = "بيوتاديين, أيزوييوتليين, بيوتين"
            TextBox3.Text = "الادوات الالكترونية, عنصر خلط البنزين والمذيب, الطلاءات ومتبطات التآكل"
            TextBox4.Text = "سائل عديم اللون ومتقلب, الأوليفينات العليا سوائل"
        ElseIf TextBox1.Text = "بنزين" Then
            TextBox2.Text = "الستايرين/البوليسترين, الكيومين"
            TextBox3.Text = "السلع الالكتبونية ولعب الأطفال, التعبئة والتغليف"
            TextBox4.Text = "شفاف وهش, شفاف ومتين ومقاوم للصدمات"
        ElseIf TextBox1.Text = "تولوين" Then
            TextBox2.Text = "التولوين ديسوسيانات"
            TextBox3.Text = "رغوة في الأثاث والفرشات ومقاعد السيارات"
            TextBox4.Text = "مرن ومتعدد الاستخدامات"
        ElseIf TextBox1.Text = "زيلين" Then
            TextBox2.Text = "حمض تيريقثاليك المنقى, ملدنات"
            TextBox3.Text = "PVCالملابس والمفروشات والتطبيفات الصناعية, 90% من الملدنات تدخل في صناعة ال"
            TextBox4.Text = "الياف قوية مع عدم امتصاص الماء, مرنة ومتينة"
        ElseIf TextBox1.Text = "الغاز المتزايد" Then
            TextBox2.Text = "أمونيا, ميثانول"
            TextBox3.Text = "الأسمدة الكيماوية, الدهانات و المواد اللاصقة"
            TextBox4.Text = "حمض الاسيتيك سائل من دون لون وله رائحة قوية"
        End If


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int a;
    cin>>a;
    std::vector<string> arr(a);
    for(int i=0 ; i<a ; i++){
        cin>>arr[i];
    }
    vector<string> arrpp(a);
    for(int i=0 ; i<a ; i++){
        arrpp.push_back(arr[i]);
    }

    for(int i=0 ; i<a ; i++){
        int kk=0;
        cout<< "beg loop"<<"..."<< "i = "<< i<< endl;
        for(int j=0 ; j<a ; j++){
            cout<<"small loop"<< ".."<<"j = "<<j<< " || "<<"kk = "<<kk<< endl;
            if(arr[i] == arrpp[j]){
                kk++;
                cout<<"if"<<".."<<arr[i]<<"=="<<arrpp[j]<< endl;
            }
        }if(kk==1){
            cout<<"OK"<< endl;
        }else{
            cout<<arr[i]<<kk-1<< endl;
        }
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    string f;
    cin >> n;
    map<string,int> y;
    for(int i=0 ; i<n ; i+=1){
        cin >> f;
        y[f]++;
        //cout << y[f] << endl;
        if(y[f] == 1){
            cout << "OK" << endl;
        }else{
            cout << f << y[f] - 1 << endl;
            }
    }
}


 If TextBox1.Text = "بتروكيميا" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "الميثان, الإيثان, البرومان من أرامكو, الاثيلين والبروبيلين من كيميا, البوتان من كيميا"
            TextBox4.Text = "تأسست بتروكيميا في عام 1981 وبدأت في عام 1985"
            TextBox5.Text = "الإيثيلين (يزود كيميا, بن زهر, شرق, المتحدة)البوتاديين والستايرين, البنزين للرازي وصدف"
        ElseIf TextBox1.Text = "حديد" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "حديد خام"
            TextBox4.Text = "تأسست حديد في عام 1979 وبدأ الإنتاج في عام 1983, وهي مملوكة بالكامل من قبل سابك"
            TextBox5.Text = "حديد تسليح, الفائف المدرفلة على الساخن علي قضبان الأسلاك, اللفائف المدرفلة على البارد "
        ElseIf TextBox1.Text = "ابن زهر" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "الميثانول(المزود من ابن سينا والررازي), الإيثيلين من بتروكيميا, البروبان, البوتان"
            TextBox4.Text = "تأسست ابن زهر في عام 1984 وبدأ الإنتاج في عام 1988, وهي مملوكة لسابك (80%)"
            TextBox5.Text = "الإيثيلين والبروبيلين(يزود بتروكيميا), جلايكول الإيثيلين, البولي إيثيلين, أوليفينات ألفا الخطية"
        ElseIf TextBox1.Text = "المتحدة" Then
            TextBox2.Text = ""
            TextBox3.Text = ""
            TextBox4.Text = ""
            TextBox5.Text = ""
        End If


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    char f[32];
    cin >> n;
    map<string,int> y;
    for(int i = 0 ; i < n ; i += 1){
        cin >> f;
        y[f]++;
        if(y[f] == 1){
            cout << "OK" << endl;
        }else{
            cout << f << y[f] - 1 << endl;
            }
    }
}


كود الشركات
 If TextBox1.Text = "بتروكيميا" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "الميثان, الإيثان, البرومان من أرامكو, الاثيلين والبروبيلين من كيميا, البوتان من كيميا"
            TextBox4.Text = "تأسست بتروكيميا في عام 1981 وبدأت في عام 1985"
            TextBox5.Text = "الإيثيلين (يزود كيميا, بن زهر, شرق, المتحدة)البوتاديين والستايرين, البنزين للرازي وصدف"
        ElseIf TextBox1.Text = "حديد" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "حديد خام"
            TextBox4.Text = "تأسست حديد في عام 1979 وبدأ الإنتاج في عام 1983, وهي مملوكة بالكامل من قبل سابك"
            TextBox5.Text = "حديد تسليح, الفائف المدرفلة على الساخن علي قضبان الأسلاك, اللفائف المدرفلة على البارد "
        ElseIf TextBox1.Text = "ابن زهر" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "الميثانول(المزود من ابن سينا والررازي), الإيثيلين من بتروكيميا, البروبان, البوتان"
            TextBox4.Text = "تأسست ابن زهر في عام 1984 وبدأ الإنتاج في عام 1988, وهي مملوكة لسابك (80%)"
            TextBox5.Text = "الإيثيلين والبروبيلين(يزود بتروكيميا), جلايكول الإيثيلين, البولي إيثيلين, أوليفينات ألفا الخطية"
        ElseIf TextBox1.Text = "المتحدة" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "الايثان من أرامكو, الإيثيلين, البروبيلين والبوتين من بتروكيميا"
            TextBox4.Text = "تأسست شركة المتحدة في عام 2001 وبدأت الإنتاج في النصف الثاني من عام 2004, وهي مملوكة لسابك (75%), وصندوق المعاشات"
            TextBox5.Text = "الإيثيلين والبروبيلين(يزود بتروكيميا), جلايكول الإثيلين, أوليفينات ألفا الخطية"
        ElseIf TextBox1.Text = "ينساب" Then
            TextBox2.Text = "ينبع"
            TextBox3.Text = "الميثان, الإيثان, الستايرين, البروبان, البوتان, البنزين, الطبيعي"
            TextBox4.Text = "تأسست ينساب في عام 2006 وبدأت الإنتاج في عام 2009, وهي مملوكة لسابك (55%), ومساهمين من القطات الخاص وشركات أخرى في الخليج"
            TextBox5.Text = "الإيثيلين, البوبيلين, الإيثيلين جيلكول, البولي إيثيلين منخفض الكثافة, البنزين, التولوين, خليط الزيلين"
        ElseIf TextBox1.Text = "غاز" Then
            TextBox2.Text = "ينبع والجبيل"
            TextBox3.Text = "الغاز الطبيعي من ارامكو"
            TextBox4.Text = "تأسست عاز في عام 1983 وبدأت الإنتاج في عام 1984, وهي مملوكة بالتساوي من قبل سابك وتايوان"
            TextBox5.Text = "الأكسجين, النيتروجين(يزود البيروني وسافكو), الهيدروجين"
        ElseIf TextBox1.Text = "البيروني" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "الميثان من ارامكو, البوبيلين من بتروكيميا, النيتروجين, الهيدروجين"
            TextBox4.Text = "تأسست البيروني في عام 1979 وبدأت الإنتاج عام 1983, وهي مملوكة بالتساوي من قبل شارك وتايوان للأسمدة"
            TextBox5.Text = "الأمونيا, اليوريا, إيثيل هكسانول"
        ElseIf TextBox1.Text = "ابن رشد" Then
            TextBox2.Text = "ينبع"
            TextBox3.Text = "الاثيلين"
            TextBox4.Text = "تأسست ابن رشد عام 1993 وبدأت الإنتاج عام 1995, وهي مملوكة لسابك (47%)"
            TextBox5.Text = "مواد عطرية, حمض تريفثاليك المنقى, رقائق منسوجة من البولي إيثيلين, حمض الأسيتيك"
        ElseIf TextBox1.Text = "سافكو" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "الميثان من ارامكو, البروبيلين من بتروكيميا, النتروجين والهيدروجين من غاز"
            TextBox4.Text = "تأسست سافكو في الدمام عام 1965 وبدأت الإنتاج في 1969, تم إيقاف العمليات في الدمام عام 2009 بسبب تشغيل المجمع في الجبيل عام 1993"
            TextBox5.Text = "الأمونيا, اليوريا, حمض الكبريتيك, اليوريا فورمالدهايد"
        ElseIf TextBox1.Text = "كيان السعودية" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "الميثان, الإيثان, البوبان من أرامكو, الإيثيلين والبروبيلين من بتروكيميا"
            TextBox4.Text = "تأسست شركة كيان السعودية عام 2007 وبدأت الإنتاج عام 2010, وهي مملوكة لسابك (35%) وشركة الكيان (20%) وحصة عامة (45%)"
            TextBox5.Text = "الإيثيلين والبروبيلين,البولي بروبيلين, البولي إثيلين المنخفض, الأسيتون"
        ElseIf TextBox1.Text = "ابن سينا" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "البنزين"
            TextBox4.Text = "تأسست عام 1981 وبأدت الإنتاج في عام 1985"
            TextBox5.Text = "الميثانول الكيميائي, إيثيل ميثيل ثلاثي الأثير"
        ElseIf TextBox1.Text = "ينبت" Then
            TextBox2.Text = "ينبع"
            TextBox3.Text = "الإيثان, البروبان"
            TextBox4.Text = "تأسست ينبت عام 1980 وبدأت الإنتاج عام 1985, وهي مملوكة بالتساوي لشركة سابك وشركة موبيل ينبع للبتروكيماويات"
            TextBox5.Text = "اليثيلين, البولي إثيلين, الإثيلين غليكول, البولي بروبيلين, البنزين الحراري الانحلالي, البروبيلين"
        ElseIf TextBox1.Text = "الرازي" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "البنزين (من بتروكيميا)"
            TextBox4.Text = "تأسست عام 1979وبدأت الإنتاج عام 1983, وهي مملوكة بالتساوي لشركة سابك ومجموعة من الشركات اليابانية"
            TextBox5.Text = "الميثانول الكيميائي (يزود ابن الزهر وصدف)"
        ElseIf TextBox1.Text = "صدف" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "الايثان, الميثانول من الرازي, البنرين من بتروكيميا"
            TextBox4.Text = "تأسست صدف عام 1980 وبدأت الإنتاج عام 1985, أصبحت اليوم مملوكة تماما لشركة سابك"
            TextBox5.Text = "الإيثيلين, الستايرين, الإيثانول الصناعي الخام, الصودا الكاوية"
        ElseIf TextBox1.Text = "شرق" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "الايثيلين, البوتين من بتروكيميا"
            TextBox4.Text = "تأسست شرق عام 1981 وبدأت الإنتاج عام 1985, مملوكة بالتساوي لشركة سابك ومجموعة من الشركات اليابانية"
            TextBox5.Text = "البولي إيثيلين, الإيثيلين, الإيثيلين غليكول"
        ElseIf TextBox1.Text = "كيميا" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "الايثان من ارامكو, الايثيلين من صدف وبتروكيميا"
            TextBox4.Text = "تأسست كيميا عام1980 وبدأ الإنتاج عام 1985, مملوكة بالتساوي لشركة سابك وإكسون موبيل"
            TextBox5.Text = "الإيثيلين والبروبيلين, البولي إيثيلين, البوتان"

        End If


#include <bits/stdc++.h>
using namespace std;

int main(){
    int a;
    cin>>a;
    std::vector<string> arr(a);
    for(int i=0 ; i<a ; i++){
        cin>>arr[i];
    }
    vector<string> arrpp;
    for(int i=0 ; i<a ; i++){
        arrpp.push_back(arr[i]);
    }
    /*cout<<"arr vector = ";
    for(int i=0 ; i<a ; i++){
        cout<<arr[i];
    }cout<<endl;
    cout<<"arrpp vector = ";
    for(int i=0 ; i<a ; i++){
        cout<< arrpp[i];
    }cout<<endl;*/

    for(int i=0 ; i<a ; i++){
        int kk=0;
        //cout<< "beg loop"<<"..."<< "i = "<< i<< endl;
        for(int j=0 ; j<a ; j++){
            if(i==0){
                cout<<"OK"<< endl;
                break;
            }else{
            //cout<<"small loop"<< ".."<<"j = "<<j<< " || "<<"kk = "<<kk<< endl;
            if(arr[i] == arrpp[j]){
                kk++;
                //cout<<"if"<<".."<<arr[i]<<"=="<<arrpp[j]<< endl;
            }}
        }if(kk==1){
            cout<<"OK"<< endl;
        }else if(i!=0){
            cout<<arr[i]<<kk-1<< endl;
        }
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int a;
    cin>>a;
    std::vector<string> arr(a);
    for(int i=0 ; i<a ; i++){
        cin>>arr[i];
    }
    vector<string> arrpp;
    for(int i=0 ; i<a ; i++){
        arrpp.push_back(arr[i]);
    }
    /*cout<<"arr vector = ";
    for(int i=0 ; i<a ; i++){
        cout<<arr[i];
    }cout<<endl;
    cout<<"arrpp vector = ";
    for(int i=0 ; i<a ; i++){
        cout<< arrpp[i];
    }cout<<endl;*/

    for(int i=0 ; i<a ; i++){
        int kk=0;
        //cout<< "beg loop"<<"..."<< "i = "<< i<< endl;
        for(int j=0 ; j<a ; j++){
            if(i==0){
                cout<<"OK"<< endl;
                break;
            }else{
            //cout<<"small loop"<< ".."<<"j = "<<j<< " || "<<"kk = "<<kk<< endl;
            if(arr[i] == arrpp[j]){
                kk++;
                //cout<<"if"<<".."<<arr[i]<<"=="<<arrpp[j]<< endl;
            }}
        }if(kk==1){
            cout<<"OK"<< endl;
        }else if(i!=0){
            cout<<arr[i]<<kk-1<< endl;
        }
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int a;
    cin>>a;
    std::vector<string> arr(a);
    for(int i=0 ; i<a ; i++){
        cin>>arr[i];
    }
    vector<string> arrpp;
    for(int i=0 ; i<a ; i++){
        arrpp.push_back(arr[i]);
    }
    /*cout<<"arr vector = ";
    for(int i=0 ; i<a ; i++){
        cout<<arr[i];
    }cout<<endl;
    cout<<"arrpp vector = ";
    for(int i=0 ; i<a ; i++){
        cout<< arrpp[i];
    }cout<<endl;*/

    for(int i=0 ; i<a ; i++){
        int kk=0;
        //cout<< "beg loop"<<"..."<< "i = "<< i<< endl;
        for(int j=0 ; j<=i ; j++){
            if(i==0){
                cout<<"OK"<< endl;
                break;
            }else{
            //cout<<"small loop"<< ".."<<"j = "<<j<< " || "<<"kk = "<<kk<< endl;
            if(arr[i] == arrpp[j]){
                kk++;
                //cout<<"if"<<".."<<arr[i]<<"=="<<arrpp[j]<< endl;
            }}
        }if(kk==1){
            cout<<"OK"<< endl;
        }else if(i!=0){
            cout<<arr[i]<<kk-1<< endl;
        }
    }
    return 0;
}


 كود المواد
 If TextBox1.Text = "اثيلين" Then
            TextBox2.Text = "بولي ايثيلين, كلوريد الفينيل, أكسيد الإيثيلين/أثلين كلايكول, الستايرين/البوليسترين"
            TextBox3.Text = "التغليف والعزل, الأجهزة الطبية, مستحضرات التجميل, تغليف المواد الغذائية"
            TextBox4.Text = "مقاومة كيميائية, متوفر بشكل صلب أو مرن, شفاف وهش"
        ElseIf TextBox1.Text = "بروبيلين" Then
            TextBox2.Text = "البولي بروبلين, لأكريلونيتريل, أكسيد البروبيلين, الكيومين, أوكسو الكحول"
            TextBox3.Text = "الحاويات المقاومة للماكرويف, الثياب المنسوجة, المواد اللاصقة, المنتجات المرتبطة بالسيارة, الأحبار"
            TextBox4.Text = "قاسي ومرن, خفيف الوزن, مذوب للشحوم, شفاف ومتين, قابل للإمتزاج مع مواد كيميائية"
        ElseIf TextBox1.Text = "C4" Then
            TextBox2.Text = "بيوتاديين, أيزوييوتليين, بيوتين"
            TextBox3.Text = "الادوات الالكترونية, عنصر خلط البنزين والمذيب, الطلاءات ومتبطات التآكل"
            TextBox4.Text = "سائل عديم اللون ومتقلب, الأوليفينات العليا سوائل"
        ElseIf TextBox1.Text = "بنزين" Then
            TextBox2.Text = "الستايرين/البوليسترين, الكيومين"
            TextBox3.Text = "السلع الالكتبونية ولعب الأطفال, التعبئة والتغليف"
            TextBox4.Text = "شفاف وهش, شفاف ومتين ومقاوم للصدمات"
        ElseIf TextBox1.Text = "تولوين" Then
            TextBox2.Text = "التولوين ديسوسيانات"
            TextBox3.Text = "رغوة في الأثاث والفرشات ومقاعد السيارات"
            TextBox4.Text = "مرن ومتعدد الاستخدامات"
        ElseIf TextBox1.Text = "زيلين" Then
            TextBox2.Text = "حمض تيريقثاليك المنقى, ملدنات"
            TextBox3.Text = "PVCالملابس والمفروشات والتطبيفات الصناعية, 90% من الملدنات تدخل في صناعة ال"
            TextBox4.Text = "الياف قوية مع عدم امتصاص الماء, مرنة ومتينة"
        ElseIf TextBox1.Text = "الغاز المتزايد" Then
            TextBox2.Text = "أمونيا, ميثانول"
            TextBox3.Text = "الأسمدة الكيماوية, الدهانات و المواد اللاصقة"
            TextBox4.Text = "حمض الاسيتيك سائل من دون لون وله رائحة قوية"
        End If


#include <bits/stdc++.h>
using namespace std;

int main(){
    int n;
    string f;
    cin >> n;
    map<string,int> y;
    for(int i=0 ; i<n ; i+=1){
        cin >> f;
        y[f]++;
        //cout << y[f] << endl;
        if(y[f] == 1){
            cout << "OK" << endl;
        }else{
            cout << f << y[f] - 1 << endl;
            }
    }
}


If TextBox1.Text = "بتروكيميا" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "الميثان, الإيثان, البرومان من أرامكو, الاثيلين والبروبيلين من كيميا, البوتان من كيميا"
            TextBox4.Text = "تأسست بتروكيميا في عام 1981 وبدأت في عام 1985"
            TextBox5.Text = "الإيثيلين (يزود كيميا, بن زهر, شرق, المتحدة)البوتاديين والستايرين, البنزين للرازي وصدف"
        ElseIf TextBox1.Text = "حديد" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "حديد خام"
            TextBox4.Text = "تأسست حديد في عام 1979 وبدأ الإنتاج في عام 1983, وهي مملوكة بالكامل من قبل سابك"
            TextBox5.Text = "حديد تسليح, الفائف المدرفلة على الساخن علي قضبان الأسلاك, اللفائف المدرفلة على البارد "
        ElseIf TextBox1.Text = "ابن زهر" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "الميثانول(المزود من ابن سينا والررازي), الإيثيلين من بتروكيميا, البروبان, البوتان"
            TextBox4.Text = "تأسست ابن زهر في عام 1984 وبدأ الإنتاج في عام 1988, وهي مملوكة لسابك (80%)"
            TextBox5.Text = "الإيثيلين والبروبيلين(يزود بتروكيميا), جلايكول الإيثيلين, البولي إيثيلين, أوليفينات ألفا الخطية"
        ElseIf TextBox1.Text = "المتحدة" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "الايثان من أرامكو, الإيثيلين, البروبيلين والبوتين من بتروكيميا"
            TextBox4.Text = "تأسست شركة المتحدة في عام 2001 وبدأت الإنتاج في النصف الثاني من عام 2004, وهي مملوكة لسابك (75%), وصندوق المعاشات"
            TextBox5.Text = "الإيثيلين والبروبيلين(يزود بتروكيميا), جلايكول الإثيلين, أوليفينات ألفا الخطية"
        ElseIf TextBox1.Text = "ينساب" Then
            TextBox2.Text = "ينبع"
            TextBox3.Text = "الميثان, الإيثان, الستايرين, البروبان, البوتان, البنزين, الطبيعي"
            TextBox4.Text = "تأسست ينساب في عام 2006 وبدأت الإنتاج في عام 2009, وهي مملوكة لسابك (55%), ومساهمين من القطات الخاص وشركات أخرى في الخليج"
            TextBox5.Text = "الإيثيلين, البوبيلين, الإيثيلين جيلكول, البولي إيثيلين منخفض الكثافة, البنزين, التولوين, خليط الزيلين"
        ElseIf TextBox1.Text = "غاز" Then
            TextBox2.Text = "ينبع والجبيل"
            TextBox3.Text = "الغاز الطبيعي من ارامكو"
            TextBox4.Text = "تأسست عاز في عام 1983 وبدأت الإنتاج في عام 1984, وهي مملوكة بالتساوي من قبل سابك وتايوان"
            TextBox5.Text = "الأكسجين, النيتروجين(يزود البيروني وسافكو), الهيدروجين"
        ElseIf TextBox1.Text = "البيروني" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "الميثان من ارامكو, البوبيلين من بتروكيميا, النيتروجين, الهيدروجين"
            TextBox4.Text = "تأسست البيروني في عام 1979 وبدأت الإنتاج عام 1983, وهي مملوكة بالتساوي من قبل شارك وتايوان للأسمدة"
            TextBox5.Text = "الأمونيا, اليوريا, إيثيل هكسانول"
        ElseIf TextBox1.Text = "ابن رشد" Then
            TextBox2.Text = "ينبع"
            TextBox3.Text = "الاثيلين"
            TextBox4.Text = "تأسست ابن رشد عام 1993 وبدأت الإنتاج عام 1995, وهي مملوكة لسابك (47%)"
            TextBox5.Text = "مواد عطرية, حمض تريفثاليك المنقى, رقائق منسوجة من البولي إيثيلين, حمض الأسيتيك"
        ElseIf TextBox1.Text = "سافكو" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "الميثان من ارامكو, البروبيلين من بتروكيميا, النتروجين والهيدروجين من غاز"
            TextBox4.Text = "تأسست سافكو في الدمام عام 1965 وبدأت الإنتاج في 1969, تم إيقاف العمليات في الدمام عام 2009 بسبب تشغيل المجمع في الجبيل عام 1993"
            TextBox5.Text = "الأمونيا, اليوريا, حمض الكبريتيك, اليوريا فورمالدهايد"
        ElseIf TextBox1.Text = "كيان السعودية" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "الميثان, الإيثان, البوبان من أرامكو, الإيثيلين والبروبيلين من بتروكيميا"
            TextBox4.Text = "تأسست شركة كيان السعودية عام 2007 وبدأت الإنتاج عام 2010, وهي مملوكة لسابك (35%) وشركة الكيان (20%) وحصة عامة (45%)"
            TextBox5.Text = "الإيثيلين والبروبيلين,البولي بروبيلين, البولي إثيلين المنخفض, الأسيتون"
        ElseIf TextBox1.Text = "ابن سينا" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "البنزين"
            TextBox4.Text = "تأسست عام 1981 وبأدت الإنتاج في عام 1985"
            TextBox5.Text = "الميثانول الكيميائي, إيثيل ميثيل ثلاثي الأثير"
        ElseIf TextBox1.Text = "ينبت" Then
            TextBox2.Text = "ينبع"
            TextBox3.Text = "الإيثان, البروبان"
            TextBox4.Text = "تأسست ينبت عام 1980 وبدأت الإنتاج عام 1985, وهي مملوكة بالتساوي لشركة سابك وشركة موبيل ينبع للبتروكيماويات"
            TextBox5.Text = "اليثيلين, البولي إثيلين, الإثيلين غليكول, البولي بروبيلين, البنزين الحراري الانحلالي, البروبيلين"
        ElseIf TextBox1.Text = "الرازي" Then
            TextBox2.Text = "الجبيل"
            TextBox3.Text = "البنزين (من بتروكيميا)"
            TextBox4.Text = "تأسست عام 1979وبدأت الإنتاج عام 1983, وهي مملوكة بالتساوي لشركة سابك ومجموعة من الشركات اليابانية"
            TextBox5.Text = "الميثانول الكيميائي (يزود ابن الزهر وصدف)"
        ElseIf TextBox1.Text = "صدف" Then
            TextBox2.Text = ""
            TextBox3.Text = ""
            TextBox4.Text = ""
            TextBox5.Text = ""

        End If


#include <iostream>
#include <map>

using namespace std;
typedef long long int ll;
const int M=1e9+7;
int k=0,n=0,p=0;
map <ll,ll> hs;
string s;
int hah(string a)
{
	int x=0;
	int b=0;
	for(int i=0; i<a.size(); i++)
	{
		x+=a[i] - 97;
		x=(x*10)%M;
	}
	return x%M;
}
int main()
{
	cin >> n;
	for(int i=0; i<n; i++)
	{
		cin >> s;
		k=hah(s);
		if(hs[k]==0)
		{
			cout<< "OK";
			hs[k]= hs[k] + 1;
		}
		else
		{
			p=hs[k];
			hs[k]= hs[k] + 1;
			cout << s << p;
		}
		cout << endl;

	}
}


#include <iostream>
#include <map>

using namespace std;
typedef long long int ll;
typedef pair<ll,ll>  pll;
const int M=1e15+7;
int n=0,p=0;
map <pll,ll> hs;
string s;
pll k;
int hah1(string a)
{
	int x=0;
	int b=0;
	for(int i=0; i<a.size(); i++)
	{
		x+=a[i] - 97;
		x=(x*10)%M;
	}
	return x%M;
}
int hah2(string a)
{
	int x=0;
	int b=0;

	for(int i=0; i<a.size(); i++)
	{
		x+=a[i] - 97;
		x=(x*73)%M;

	}
	return x%M;
}
int main()
{
	cin >> n;
	for(int i=0; i<n; i++)
	{
		cin >> s;
		k={hah1(s),hah2(s)};
		if(hs[k]==0)
		{
			cout<< "OK";
			hs[k]= hs[k] + 1;
		}
		else
		{
			p=hs[k];
			hs[k]= hs[k] + 1;
			cout << s << p;
		}
		cout << endl;

	}
}


#include <iostream>

using namespace std;

int hs[10000],k=0,n=0,p=0;
string s;
int hah(string a)
{
	int x=0;
	int b=0;
	for(int i=0; i<a.size(); i++)
	{
		x+=i*26+ a[i] - 97;
	}
	return x;
}
int main()
{
	cin >> n;
	fill(hs,hs+10000,0);
	for(int i=0; i<n; i++)
	{
		cin >> s;
		k=hah(s);
		if(hs[k]==0)
		{
			cout<< "OK";
			hs[k]++;
		}
		else
		{
			p=hs[k];
			hs[k]++;
			cout << s;
			while(p>0)
			{
				cout << p%10;
				p/=10;
			}
		}
		cout << endl;

	}
}


#include <iostream>

using namespace std;

int hs[15000],k=0,n=0,p=0;
string s;
int hah(string a)
{
	int x=0;
	int b=0;
	for(int i=0; i<a.size(); i++)
	{
		x+= i*101 + a[i] - 97;
	}
	return x%15000;
}
int main()
{
	cin >> n;
	fill(hs,hs+15000,0);
	for(int i=0; i<n; i++)
	{
		cin >> s;
		k=hah(s);
		if(hs[k]==0)
		{
			cout<< "OK";
			hs[k]++;
		}
		else
		{
			p=hs[k];
			hs[k]++;
			cout << s;
			while(p>0)
			{
				cout << p%10;
				p/=10;
			}
		}
		cout << endl;

	}
}


#include <iostream>

using namespace std;

int hs[15000],k=0,n=0,p=0;
string s;
int hah(string a)
{
	int x=0;
	int b=0;
	for(int i=0; i<a.size(); i++)
	{
		x+= a[i] - 97;
		if(i>0)
			x+=26;
	}
	return x;
}
int main()
{
	cin >> n;
	fill(hs,hs+15000,0);
	for(int i=0; i<n; i++)
	{
		cin >> s;
		k=hah(s);
		if(hs[k]==0)
		{
			cout<< "OK";
			hs[k]++;
		}
		else
		{
			p=hs[k];
			hs[k]++;
			cout << s;
			while(p>0)
			{
				cout << p%10;
				p/=10;
			}
		}
		cout << endl;

	}
}


#include <iostream>
#include <map>

using namespace std;
typedef long long int ll;
const int M=1e9+7;
int k=0,n=0,p=0;
map <ll,ll> hs;
string s;
int hah(string a)
{
	int x=0;
	int b=0;
	for(int i=0; i<a.size(); i++)
	{
		x+=a[i] - 97;
		x=(x*10)%M;
	}
	return x%M;
}
int main()
{
	cin >> n;
	for(int i=0; i<n; i++)
	{
		cin >> s;
		k=hah(s);
		if(hs[k]==0)
		{
			cout<< "OK";
			hs[k]= hs[k] + 1;
		}
		else
		{
			p=hs[k];
			hs[k]= hs[k] + 1;
			cout << s;
			while(p>0)
			{
				cout << p%10;
				p/=10;
			}
		}
		cout << endl;

	}
}


#include <iostream>

using namespace std;

int hs[1700],k=0,n=0,p=0;
string s;
int hash(string a)
{
	int x=0;
	for(int i=0; i<a.size(); i++)
	{
		x+=(i-1)*26+(a[i]-'a');
	}
	return x;
}
int main()
{
	cin >> n;
	fill(hs,hs+1700,0);
	for(int i=0; i<n; i++)
	{
		cin >> s;
		k=hash(s);
		if(hs[k]==0)
		{
			cout<< "OK";
			hs[k]++;
		}
		else
		{
			p=hs[k];
			hs[k]++;
			cout << s;
			while(p>0)
			{
				cout << p%10;
				p/=10;
			}
		}
		cout << endl;

	}
}


#include <iostream>
#include <map>

using namespace std;
typedef long long int ll;
typedef pair<ll,ll>  pll;
const int M=1e9+7;
int n=0,p=0;
map <pll,ll> hs;
string s;
pll k;
int hah1(string a)
{
	int x=0;
	int b=0;
	for(int i=0; i<a.size(); i++)
	{
		x+=a[i] - 97;
		x=(x*29)%M;
	}
	return x%M;
}
int hah2(string a)
{
	int x=0;
	int b=0;

	for(int i=0; i<a.size(); i++)
	{
		x+=+ a[i] - 97;
		x=(x*73)%M;

	}
	return x%M;
}
int main()
{
	cin >> n;
	for(int i=0; i<n; i++)
	{
		cin >> s;
		k={hah1(s),hah2(s)};
		if(hs[k]==0)
		{
			cout<< "OK";
			hs[k]= hs[k] + 1;
		}
		else
		{
			p=hs[k];
			hs[k]= hs[k] + 1;
			cout << s << p;
		}
		cout << endl;

	}
}


#include <iostream>

using namespace std;

int hs[15000],k=0,n=0,p=0;
string s;
int hah(string a)
{
	int x=0;
	int b=0;
	for(int i=0; i<a.size(); i++)
	{
		x+=i*27+ a[i] - 97;
	}
	return x;
}
int main()
{
	cin >> n;
	fill(hs,hs+15000,0);
	for(int i=0; i<n; i++)
	{
		cin >> s;
		k=hah(s);
		if(hs[k]==0)
		{
			cout<< "OK";
			hs[k]++;
		}
		else
		{
			p=hs[k];
			hs[k]++;
			cout << s;
			while(p>0)
			{
				cout << p%10;
				p/=10;
			}
		}
		cout << endl;

	}
}


#include <iostream>

using namespace std;

int hs[1700],k=0,n=0,p=0;
string s;
int hah(string a)
{
	int x=0;
	int b=0;
	for(int i=0; i<a.size(); i++)
	{
		x+=i*26+ a[i] - 97;
	}
	return x;
}
int main()
{
	cin >> n;
	fill(hs,hs+1700,0);
	for(int i=0; i<n; i++)
	{
		cin >> s;
		k=hah(s);
		if(hs[k]==0)
		{
			cout<< "OK";
			hs[k]++;
		}
		else
		{
			p=hs[k];
			hs[k]++;
			cout << s;
			while(p>0)
			{
				cout << p%10;
				p/=10;
			}
		}
		cout << endl;

	}
}


#include <iostream>
#include <map>

using namespace std;
typedef long long int ll;
typedef pair<ll,ll>  pll;
const int M=1e15+7;
int n=0,p=0;
map <pll,ll> hs;
string s;
pll k;
int hah1(string a)
{
	int x=0;
	int b=0;
	for(int i=0; i<a.size(); i++)
	{
		x+=a[i] - 97;
		x=(x*10)%M;
	}
	return x%M;
}
int hah2(string a)
{
	int x=0;
	int b=0;

	for(int i=0; i<a.size(); i++)
	{
		x=(x+i*997 +a[i] - 97)%M;
	}
	return x%M;
}
int main()
{
	cin >> n;
	for(int i=0; i<n; i++)
	{
		cin >> s;
		k={hah1(s),hah2(s)};
		if(hs[k]==0)
		{
			cout<< "OK";
			hs[k]= hs[k] + 1;
		}
		else
		{
			p=hs[k];
			hs[k]= hs[k] + 1;
			cout << s << p;
		}
		cout << endl;

	}
}


#include <iostream>
#include <map>

using namespace std;
typedef long long int ll;
typedef pair<ll,ll>  pll;
const int M=1e9+7;
int n=0,p=0;
map <pll,ll> hs;
string s;
pll k;
int hah1(string a)
{
	int x=0;
	int b=0;
	for(int i=0; i<a.size(); i++)
	{
		x+=a[i] - 97;
		x=(x*10)%M;
	}
	return x%M;
}
int hah2(string a)
{
	int x=0;
	int b=0;

	for(int i=0; i<a.size(); i++)
	{
		x+=+ a[i] - 97;
		x=(x*73)%M;

	}
	return x%M;
}
int main()
{
	cin >> n;
	for(int i=0; i<n; i++)
	{
		cin >> s;
		k={hah1(s),hah2(s)};
		if(hs[k]==0)
		{
			cout<< "OK";
			hs[k]= hs[k] + 1;
		}
		else
		{
			p=hs[k];
			hs[k]= hs[k] + 1;
			cout << s << p;
		}
		cout << endl;

	}
}


#include <iostream>
#include <map>

using namespace std;
typedef long long int ll;
typedef pair<ll,ll>  pll;
const int M=1e15+7;
int n=0,p=0;
map <pll,ll> hs;
string s;
pll k;
int hah1(string a)
{
	int x=0;
	int b=0;
	for(int i=0; i<a.size(); i++)
	{
		x+=a[i] - 97;
		x=(x*10)%M;
	}
	return x%M;
}
int hah2(string a)
{
	int x=0;
	int b=0;

	for(int i=0; i<a.size(); i++)
	{
		x=(x+i*997 a[i] - 97)%M;
	}
	return x%M;
}
int main()
{
	cin >> n;
	for(int i=0; i<n; i++)
	{
		cin >> s;
		k={hah1(s),hah2(s)};
		if(hs[k]==0)
		{
			cout<< "OK";
			hs[k]= hs[k] + 1;
		}
		else
		{
			p=hs[k];
			hs[k]= hs[k] + 1;
			cout << s << p;
		}
		cout << endl;

	}
}


#include <iostream>
#include <map>

using namespace std;
typedef long long int ll;
typedef pair<ll,ll>  pll;
const int M=1e9+7;
int n=0,p=0;
map <pll,ll> hs;
string s;
pll k;
int hah1(string a)
{
	int x=0;
	int b=0;
	for(int i=0; i<a.size(); i++)
	{
		x+=a[i] - 97;
		x=(x*10)%M;
	}
	return x%M;
}
int hah2(string a)
{
	int x=0;
	int b=0;

	for(int i=0; i<a.size(); i++)
	{
		x+= i*73 + a[i] - 97;

	}
	return x%M;
}
int main()
{
	cin >> n;
	for(int i=0; i<n; i++)
	{
		cin >> s;
		k={hah1(s),hah2(s)};
		if(hs[k]==0)
		{
			cout<< "OK";
			hs[k]= hs[k] + 1;
		}
		else
		{
			p=hs[k];
			hs[k]= hs[k] + 1;
			cout << s << p;
		}
		cout << endl;

	}
}


#include <iostream>

using namespace std;

int hs[100007],k=0,n=0,p=0;
string s;
int hah(string a)
{
	int x=0;
	int b=0;
	for(int i=0; i<a.size(); i++)
	{
		x+= i*73 + a[i] - 97;
	}
	return x%100007;
}
int main()
{
	cin >> n;
	fill(hs,hs+100007,0);
	for(int i=0; i<n; i++)
	{
		cin >> s;
		k=hah(s);
		if(hs[k]==0)
		{
			cout<< "OK";
			hs[k]++;
		}
		else
		{
			p=hs[k];
			hs[k]++;
			cout << s;
			while(p>0)
			{
				cout << p%10;
				p/=10;
			}
		}
		cout << endl;

	}
}


#include <iostream>
#include <map>

using namespace std;
typedef long long int ll;
typedef pair<ll,ll>  pll;
const int M=1e15+7;
int n=0,p=0;
map <pll,ll> hs;
string s;
pll k;
int hah1(string a)
{
	int x=0;
	int b=0;
	for(int i=0; i<a.size(); i++)
	{
		x+=a[i] - 97;
		x=(x*53)%M;
	}
	return x%M;
}
int hah2(string a)
{
	int x=0;
	int b=0;

	for(int i=0; i<a.size(); i++)
	{
		x=(x+i*997 +a[i] - 97)%M;
	}
	return x%M;
}
int main()
{
	cin >> n;
	for(int i=0; i<n; i++)
	{
		cin >> s;
		k={hah1(s),hah2(s)};
		if(hs[k]==0)
		{
			cout<< "OK";
			hs[k]= hs[k] + 1;
		}
		else
		{
			p=hs[k];
			hs[k]= hs[k] + 1;
			cout << s << p;
		}
		cout << endl;

	}
}


#include <iostream>

using namespace std;

int hs[1700],k=0,n=0,p=0;
string s;
int hah(string a)
{
	int x=0;
	for(int i=0; i<a.size(); i++)
	{
		x+=(i-1)*26+(a[i]-'a');
	}
	return x;
}
int main()
{
	cin >> n;
	fill(hs,hs+1700,0);
	for(int i=0; i<n; i++)
	{
		cin >> s;
		k=hah(s);
		if(hs[k]==0)
		{
			cout<< "OK";
			hs[k]++;
		}
		else
		{
			p=hs[k];
			hs[k]++;
			cout << s;
			while(p>0)
			{
				cout << p%10;
				p/=10;
			}
		}
		cout << endl;

	}
}


#include <iostream>
#include <map>

using namespace std;
typedef long long int ll;
typedef pair<ll,ll>  pll;
const int M=1e9+7;
int n=0,p=0;
map <pll,ll> hs;
string s;
pll k;
int hah1(string a)
{
	int x=0;
	int b=0;
	for(int i=0; i<a.size(); i++)
	{
		x+=a[i] - 97;
		x=(x*10)%M;
	}
	return x%M;
}
int hah2(string a)
{
	int x=0;
	int b=0;

	for(int i=0; i<a.size(); i++)
	{
		x+=a[i] - 97;
		x=(x*73*29)%M;

	}
	return x%M;
}
int main()
{
	cin >> n;
	for(int i=0; i<n; i++)
	{
		cin >> s;
		k={hah1(s),hah2(s)};
		if(hs[k]==0)
		{
			cout<< "OK";
			hs[k]= hs[k] + 1;
		}
		else
		{
			p=hs[k];
			hs[k]= hs[k] + 1;
			cout << s << p;
		}
		cout << endl;

	}
}


#include <iostream>

using namespace std;

int hs[15008],k=0,n=0,p=0;
string s;
int hah(string a)
{
	int x=0;
	int b=0;
	for(int i=0; i<a.size(); i++)
	{
		x+= i*101 + a[i] - 97;
	}
	return x%15007;
}
int main()
{
	cin >> n;
	fill(hs,hs+15000,0);
	for(int i=0; i<n; i++)
	{
		cin >> s;
		k=hah(s);
		if(hs[k]==0)
		{
			cout<< "OK";
			hs[k]++;
		}
		else
		{
			p=hs[k];
			hs[k]++;
			cout << s;
			while(p>0)
			{
				cout << p%10;
				p/=10;
			}
		}
		cout << endl;

	}
}


#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

bool sortbyfirst(const pair<int, int> &a, const pair<int, int> &b) {
	if (a.first == b.first) {
		return a.second < b.second;
	}
	return a.first < b.first;
}

bool sortbysecond(const pair<string, int> &a, const pair<string, int> &b) {
	return a.second < b.second;
}

int main() {
	long long max = 972663749;
	long long k =   911382323;
	int n;
	cin >> n;
	vector<pair<string, int>> result;
	vector<string> input;
	vector<pair<int, int>> hashedStrings;
	for (int i = 0; i < n; ++i) {
		string s;
		cin >> s;
		input.push_back(s);
		long long hash = 0L;
		for (int j = 0; j < s.size(); ++j) {
			hash *= k;
			hash += (int) s[j];
			hash %= max;
		}
		hashedStrings.push_back(make_pair((int) hash, i));
	}

	sort(hashedStrings.begin(), hashedStrings.end(), sortbyfirst);

	int last = hashedStrings[0].first;
	string lastString = input[hashedStrings[0].second];
	int nb = 0;
	result.push_back(make_pair("OK", hashedStrings[0].second));
	for (int i = 1; i < n; ++i) {
		if (last != hashedStrings[i].first) {
			result.push_back(make_pair("OK", hashedStrings[i].second));
			last = hashedStrings[i].first;
			lastString = input[hashedStrings[i].second];
			nb = 0;
		} else {
			if (lastString != input[hashedStrings[i].second]) {
				result.push_back(make_pair("OK", hashedStrings[i].second));
				last = hashedStrings[i].first;
				lastString = input[hashedStrings[i].second];
				nb = 0;
			} else {
				++nb;
				result.push_back(make_pair(lastString + to_string(nb), hashedStrings[i].second));
			}
		}
	}

	sort(result.begin(), result.end(), sortbysecond);

	for (pair<string, int> pair: result) {
		cout << pair.first << endl;
	}

	return 0;
}


#include <iostream>
#include <vector>
#include <string>

using namespace std;

int main() {
	long long max = 1000003;
	long long k = 100003;
	int n;
	cin >> n;
	vector<string> result;
	bool list[max]{};
	for (int i = 0; i < n; ++i) {
		string s;
		cin >> s;
		long long hash = 0L;
		for (int j = 0; j < s.size(); ++j) {
			hash *= k;
			hash += (int) s[j];
			hash %= max;
		}

		if (list[hash]) {
			hash *= k;
			hash %= max;
			for (int j = 1; ; ++j) {
				if (!list[hash + j]) {
					list[hash + j] = true;
					result.push_back(s + to_string(j));
					break;
				}
			}
		} else {
			list[hash] = true;
			result.push_back("OK");
		}
	}

	for (string s: result) {
		cout << s << endl;
	}
	return 0;
}


#include <iostream>
#include <vector>
#include <string>

using namespace std;

int main() {
	long long max = 1000003;
	long long k = 100003;
	int n;
	cin >> n;
	vector<string> result;
	bool list[max]{};
	for (int i = 0; i < n; ++i) {
		string s;
		cin >> s;
		long long hash = 0L;
		for (int j = 0; j < s.size(); ++j) {
			hash *= k;
			hash += (int) s[j];
			hash %= max;
		}

		if (list[hash]) {
			for (int j = 1; ; ++j) {
				long long newHash = hash;
				int x = j;
				while (x > 0) {
					newHash *= k;
					newHash += (int) '0' + (j % 10);
					newHash = newHash % max;
					x = x / 10;
				}
				if (!list[newHash]) {
					list[newHash] = true;
					result.push_back(s + to_string(j));
					break;
				}
			}
		} else {
			list[hash] = true;
			result.push_back("OK");
		}
	}

	for (string s: result) {
		cout << s << endl;
	}
	return 0;
}


#include <iostream>
#include <vector>
#include <string>

using namespace std;

int main() {
	int max = 1000003;
	int k = 107;
	int n;
	cin >> n;
	vector<string> result;
	bool list[max]{};
	for (int i = 0; i < n; ++i) {
		string s;
		cin >> s;
		int hash = 0;
		for (int j = 0; j < s.size(); ++j) {
			hash *= k;
			hash += (int) s[j];
			hash %= max;
		}

		if (list[hash]) {
			for (int j = 1; ; ++j) {
				if (!list[hash + j]) {
					list[hash + j] = true;
					result.push_back(s + to_string(j));
					break;
				}
			}
		} else {
			list[hash] = true;
			result.push_back("OK");
		}
	}

	for (string s: result) {
		cout << s << endl;
	}
	return 0;
}


#include <iostream>
#include <vector>
#include <string>

using namespace std;

int main() {
	int max = 1000007;
	int k = 31;
	int n;
	cin >> n;
	vector<string> result;
	bool list[max]{};
	for (int i = 0; i < n; ++i) {
		string s;
		cin >> s;
		int hash = 0;
		for (int j = 0; j < s.size(); ++j) {
			hash *= k;
			hash += (int) s[j];
			hash %= max;
		}

		if (list[hash]) {
			for (int j = 1; ; ++j) {
				if (!list[hash + j]) {
					list[hash + j] = true;
					result.push_back(s + to_string(j));
					break;
				}
			}
		} else {
			list[hash] = true;
			result.push_back("OK");
		}
	}

	for (string s: result) {
		cout << s << endl;
	}
	return 0;
}


#include <iostream>
#include <vector>
#include <string>

using namespace std;

int main() {
	int max = 1000003;
	int k = 9999991;
	int n;
	cin >> n;
	vector<string> result;
	bool list[max]{};
	for (int i = 0; i < n; ++i) {
		string s;
		cin >> s;
		int hash = 0;
		for (int j = 0; j < s.size(); ++j) {
			hash *= k;
			hash += (int) s[j];
			hash %= max;
		}

		if (list[hash]) {
			for (int j = 1; ; ++j) {
				if (!list[hash + j]) {
					list[hash + j] = true;
					result.push_back(s + to_string(j));
					break;
				}
			}
		} else {
			list[hash] = true;
			result.push_back("OK");
		}
	}

	for (string s: result) {
		cout << s << endl;
	}
	return 0;
}


#include <iostream>
#include <unordered_set>
#include <vector>
#include <string>

using namespace std;

int main() {
	int n;
	cin >> n;
	unordered_set<string> set;
	vector<string> result;
	for (int i = 0; i < n; ++i) {
		string s;
		cin >> s;
		if (set.count(s)) {
			int counter = 1;
			while (set.count(s + to_string(counter))) {
				++counter;
			}
			result.push_back(s + to_string(counter));
		} else {
			result.push_back("OK");
		}
		set.insert(s);
	}
	for (string s: result) {
		cout << s << endl;
	}
	return 0;
}


#include <iostream>
#include <unordered_set>
#include <vector>
#include <string>

using namespace std;

int main() {
	int n;
	cin >> n;
	unordered_set<string> set;
	vector<string> result;
	for (int i = 0; i < n; ++i) {
		string s;
		cin >> s;
		if (set.count(s)) {
			int counter = 1;
			while (set.count(s + to_string(counter))) {
				++counter;
			}
			s = s + to_string(counter);
			result.push_back(s);
		} else {
			result.push_back("OK");
		}
		set.insert(s);
	}
	for (string s: result) {
		cout << s << endl;
	}
	return 0;
}


#include <iostream>
#include <vector>
#include <string>

using namespace std;

int main() {
	long long max = 1000003;
	long long k = 100003;
	int n;
	cin >> n;
	vector<string> result;
	bool list[max]{};
	for (int i = 0; i < n; ++i) {
		string s;
		cin >> s;
		long long hash = 0L;
		for (int j = 0; j < s.size(); ++j) {
			hash *= k;
			hash += (int) s[j];
			hash %= max;
		}

		if (list[hash]) {
			for (int j = 1; ; ++j) {
				long long newHash = hash;
				int x = j;
				while (x > 0) {
					newHash *= k;
					newHash += (int) '0' + (j % 10);
					j = j/10;
				}
				if (!list[newHash]) {
					list[newHash] = true;
					result.push_back(s + to_string(j));
					break;
				}
			}
		} else {
			list[hash] = true;
			result.push_back("OK");
		}
	}

	for (string s: result) {
		cout << s << endl;
	}
	return 0;
}


#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <iostream>
#include <set>
#include <cmath>
#include <string>
#include <map>
#include <queue>
#include <unordered_map>
using namespace std;

long long p = 43256324;
long long cur = 1LL;
long long q = 1000000007;

int main()
{
    ::ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    unordered_map <long long, int> mp;
    for (int i = 0; i < n; i++)
    {
        cur = 1LL;
        string s;
        cin >> s;
        for (int i = 0; i < s.length(); i++)
            cur = (cur * p + (s[i] - 'a' + 1)) % q;
        if (mp.count(cur))
            cout << s << ++mp[cur] << "\n";
        else
            cout << "OK\n", mp[cur] = 0;
    }
    return 0;
}


#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <iostream>
#include <set>
#include <cmath>
#include <string>
#include <map>
#include <queue>
#include <unordered_map>
using namespace std;

int main()
{
    ::ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    unordered_map <string, int> mp(n);
    for (int i = 0; i < n; i++)
    {
        string s;
        cin >> s;
        if (mp.count(s))
            cout << s << ++mp[s] << "\n";
        else
            cout << "OK\n", mp[s] = 0;
    }
    return 0;
}


#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <cstring>
#include <iostream>
#include <set>
#include <cmath>
#include <string>
#include <map>
#include <queue>
#include <unordered_map>
using namespace std;

long long p = 43256324;
long long cur = 1LL;
long long q = 1000000007;

#include <cstdio>

/** Interface */

inline int readChar();
template <class T = int> inline T readInt();
template <class T> inline void writeInt(T x);
inline void writeChar(int x);
inline void writeWord(const char *s);
inline void flush();

/** Read */

static const int buf_size = 4096;

inline int getChar() {
    static char buf[buf_size];
    static int len = 0, pos = 0;
    if (pos == len)
        pos = 0, len = fread(buf, 1, buf_size, stdin);
    if (pos == len)
        return -1;
    return buf[pos++];
}

inline int readChar() {
    int c = getChar();
    while (c <= 32)
        c = getChar();
    return c;
}

template <class T>
inline T readInt() {
    int s = 1, c = readChar();
    T x = 0;
    if (c == '-')
        s = -1, c = getChar();
    while ('0' <= c && c <= '9')
        x = x * 10 + c - '0', c = getChar();
    return s == 1 ? x : -x;
}

/** Write */

static int write_pos = 0;
static char write_buf[buf_size];

inline void writeChar(int x) {
    if (write_pos == buf_size)
        fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
    write_buf[write_pos++] = x;
}

inline void flush() {
    if (write_pos)
        fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}

template <class T>
inline void writeInt(T x) {
    if (x < 0)
        writeChar('-'), x = -x;

    char s[24];
    int n = 0;
    while (x || !n)
        s[n++] = '0' + x % 10, x /= 10;
    while (n--)
        writeChar(s[n]);
}

inline void writeWord(const char *s) {
    while (*s)
        writeChar(*s++);
}

int main()
{
    int n;
    n = readInt();
    unordered_map <int, int> mp(n);
    mp.rehash(n);
    for (int i = 0; i < n; i++)
    {
        cur = 1LL;
        char s[33];
        fgets(s, 33, stdin);
        int len = strlen(s);
        for (int i = 0; i < len; i++)
            cur = (cur * p + (s[i] - 'a' + 1)) % q;
        if (mp.count(cur))
            printf("%s%d\n", s, ++mp[cur]);
        else
            puts("OK"), mp[cur] = 0;
    }
    return 0;
}


#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <cstring>
#include <iostream>
#include <set>
#include <cmath>
#include <string>
#include <map>
#include <queue>
#include <unordered_map>
using namespace std;

long long p = 43256324;
long long cur = 1LL;
long long q = 1000000007;

int main()
{
    int n;
    scanf("%d\n", &n);
    unordered_map <int, int> mp(n);
    for (int i = 0; i < n; i++)
    {
        cur = 1LL;
        char s[33];
        scanf("%s\n", &s);
        int len = strlen(s);
        for (int i = 0; i < len; i++)
            cur = (cur * p + (s[i] - 'a' + 1)) % q;
        if (mp.count(cur))
            printf("%s%d\n", s, ++mp[cur]);
        else
            puts("OK"), mp[cur] = 0;
    }
    return 0;
}


#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <iostream>
#include <set>
#include <cmath>
#include <string>
#include <map>
#include <queue>
#include <unordered_map>
using namespace std;

int main()
{
    ::ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    map <string, int> mp;
    int n;
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        string s;
        cin >> s;
        if (mp.count(s))
            cout << s << " " << ++mp[s] << "\n";
        else
            cout << "OK\n", mp[s] = 0;
    }
    return 0;
}


#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <iostream>
#include <set>
#include <cmath>
#include <string>
#include <map>
#include <queue>
#include <unordered_map>
using namespace std;

long long p = 43256324;
long long cur = 1LL;
long long q = 1000000007;

int main()
{
    int n;
    scanf("%d\n", &n);
    unordered_map <long long, int> mp;
    for (int i = 0; i < n; i++)
    {
        cur = 1LL;
        char s[33];
        scanf("%s\n", &s);
        int len = strlen(s);
        for (int i = 0; i < len; i++)
            cur = (cur * p + (s[i] - 'a' + 1)) % q;
        if (mp.count(cur))
            printf("%s%d\n", s, ++mp[cur]);
        else
            puts("OK"), mp[cur] = 0;
    }
    return 0;
}


#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <cstring>
#include <iostream>
#include <set>
#include <cmath>
#include <string>
#include <map>
#include <queue>
#include <unordered_map>
using namespace std;

long long p = 43256324;
long long cur = 1LL;
long long q = 1000000007;

#include <cstdio>

/** Interface */

inline int readChar();
template <class T = int> inline T readInt();
template <class T> inline void writeInt(T x);
inline void writeChar(int x);
inline void writeWord(const char *s);
inline void flush();

/** Read */

static const int buf_size = 4096;

inline int getChar() {
	static char buf[buf_size];
	static int len = 0, pos = 0;
	if (pos == len)
		pos = 0, len = fread(buf, 1, buf_size, stdin);
	if (pos == len)
		return -1;
	return buf[pos++];
}

inline int readChar() {
	int c = getChar();
	while (c <= 32)
		c = getChar();
	return c;
}

template <class T>
inline T readInt() {
	int s = 1, c = readChar();
	T x = 0;
	if (c == '-')
		s = -1, c = getChar();
	while ('0' <= c && c <= '9')
		x = x * 10 + c - '0', c = getChar();
	return s == 1 ? x : -x;
}

/** Write */

static int write_pos = 0;
static char write_buf[buf_size];

inline void writeChar(int x) {
	if (write_pos == buf_size)
		fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
	write_buf[write_pos++] = x;
}

inline void flush() {
	if (write_pos)
		fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}

template <class T>
inline void writeInt(T x) {
	if (x < 0)
		writeChar('-'), x = -x;

	char s[24];
	int n = 0;
	while (x || !n)
		s[n++] = '0' + x % 10, x /= 10;
	while (n--)
		writeChar(s[n]);
}

inline void writeWord(const char *s) {
	while (*s)
		writeChar(*s++);
}

int main()
{
	int n;
	n = readInt();
	unordered_map <int, int> mp(n);
	mp.rehash(n);
	for (int i = 0; i < n; i++)
	{
		cur = 1LL;
		char s[33];
		int cnt = 0;
		while (cnt != 33)
		{
			s[cnt] = readChar();
			if (s[cnt] == '\n')
				break;
			++cnt;
		}
		for (int i = 0; i < cnt; i++)
			cur = (cur * p + (s[i] - 'a' + 1)) % q;
		if (mp.count(cur))
		{
			for (int i = 0; i < cnt; i++)
				writeChar(s[i]);
			writeInt(++mp[cur]);
			writeChar('\n');
		}
		else
		{
			writeChar('O');
			writeChar('K');
			writeChar('\n');
			mp[cur] = 0;
		}
	}
	return 0;
}


#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <iostream>
#include <set>
#include <cmath>
#include <string>
#include <map>
#include <queue>
#include <unordered_map>
using namespace std;

int main()
{
    ::ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    map <string, int> mp;
    int n;
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        string s;
        cin >> s;
        if (mp.count(s))
            cout << s << ++mp[s] << "\n";
        else
            cout << "OK\n", mp[s] = 0;
    }
    return 0;
}


#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <cstring>
#include <iostream>
#include <set>
#include <cmath>
#include <string>
#include <map>
#include <queue>
#include <unordered_map>
using namespace std;

long long p = 43256324;
long long cur = 1LL;
long long q = 1000000007;

int main()
{
    int n;
    scanf("%d\n", &n);
    unordered_map <long long, int> mp;
    for (int i = 0; i < n; i++)
    {
        cur = 1LL;
        char s[33];
        scanf("%s\n", &s);
        int len = strlen(s);
        for (int i = 0; i < len; i++)
            cur = (cur * p + (s[i] - 'a' + 1)) % q;
        if (mp.count(cur))
            printf("%s%d\n", s, ++mp[cur]);
        else
            puts("OK"), mp[cur] = 0;
    }
    return 0;
}


#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <iostream>
#include <set>
#include <cmath>
#include <string>
#include <map>
#include <queue>
#include <unordered_map>
using namespace std;

long long p = 43256324;
long long cur = 1LL;
long long q = 1000000007;

int main()
{
    ::ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    unordered_map <long long, int> mp(n);
    for (int i = 0; i < n; i++)
    {
        cur = 1LL;
        string s;
        cin >> s;
        for (int i = 0; i < s.length(); i++)
            cur = (cur * p + (s[i] - 'a' + 1)) % q;
        if (mp.count(cur))
            cout << s << ++mp[cur] << "\n";
        else
            cout << "OK\n", mp[cur] = 0;
    }
    return 0;
}


#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <cstring>
#include <iostream>
#include <set>
#include <cmath>
#include <string>
#include <map>
#include <queue>
#include <unordered_map>
using namespace std;

long long p = 43256324;
long long cur = 1LL;
long long q = 1000000007;

int main()
{
    int n;
    scanf("%d\n", &n);
    unordered_map <int, int> mp(n);
    mp.rehash(n);
    for (int i = 0; i < n; i++)
    {
        cur = 1LL;
        char s[33];
        scanf("%s\n", &s);
        int len = strlen(s);
        for (int i = 0; i < len; i++)
            cur = (cur * p + (s[i] - 'a' + 1)) % q;
        if (mp.count(cur))
            printf("%s%d\n", s, ++mp[cur]);
        else
            puts("OK"), mp[cur] = 0;
    }
    return 0;
}


#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <cstring>
#include <iostream>
#include <set>
#include <cmath>
#include <string>
#include <map>
#include <queue>
#include <unordered_map>
using namespace std;

long long p = 43256324;
long long cur = 1LL;
long long q = 1000000007;

int main()
{
    int n;
    scanf("%d\n", &n);
    map <long long, int> mp;
    for (int i = 0; i < n; i++)
    {
        cur = 1LL;
        char s[33];
        scanf("%s\n", &s);
        int len = strlen(s);
        for (int i = 0; i < len; i++)
            cur = (cur * p + (s[i] - 'a' + 1)) % q;
        if (mp.count(cur))
            printf("%s%d\n", s, ++mp[cur]);
        else
            puts("OK"), mp[cur] = 0;
    }
    return 0;
}


#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <iostream>
#include <set>
#include <cmath>
#include <string>
#include <map>
#include <queue>
#include <unordered_map>
using namespace std;

int main()
{
    ::ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    unordered_map <string, int> mp;
    int n;
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        string s;
        cin >> s;
        if (mp.count(s))
            cout << s << ++mp[s] << "\n";
        else
            cout << "OK\n", mp[s] = 0;
    }
    return 0;
}


#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <cstring>
#include <iostream>
#include <set>
#include <cmath>
#include <string>
#include <map>
#include <queue>
#include <unordered_map>
using namespace std;

long long p = 43256324;
long long cur = 1LL;
long long q = 1000000007;

int main()
{
	int n;
	scanf("%d\n", &n);
	unordered_map <long long, int> mp(n);
	for (int i = 0; i < n; i++)
	{
		cur = 1LL;
		char s[33];
		scanf("%s\n", &s);
		int len = strlen(s);
		for (int i = 0; i < len; i++)
			cur = (cur * p + (s[i] - 'a' + 1)) % q;
		if (mp.count(cur))
			printf("%s%d\n", s, ++mp[cur]);
		else
			puts("OK"), mp[cur] = 0;
	}
	return 0;
}


#include <iostream>
#include <unordered_set>
#include <algorithm>

std::string itoa(int n)
{
    std::string res = "";
    while (n)
    {
        res += (n % 10) + int('0');
        n /= 10;
    }
    std::reverse(res.begin(), res.end());
    return res;
}

int main()
{
	int n;
	std::cin >> n;
	std::unordered_set<std::string> db;
	std::string name;
	for (int i = 0; i < n; i++)
	{
		std::cin >> name;
		if (db.find(name) == db.end())
		{
			std::cout << "OK" << std::endl;
			db.insert(name);
		}
		else
		{
			int i = 1;
			while (db.find(name + itoa(i)) != db.end())
			{
				i++;
			}
			std::cout << name + itoa(i) << std::endl;
			db.insert(name + itoa(i));
		}
	}
}


#include <iostream>
#include <unordered_set>
#include <vector>
#include <algorithm>

std::string itoa(int n)
{
    std::string res = "";
    while (n)
    {
        res += (n % 10) + int('0');
        n /= 10;
    }
    std::reverse(res.begin(), res.end());
    return res;
}

int main()
{
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(NULL);
    std::cout.tie(NULL);

	int n;
	std::cin >> n;
	std::unordered_set<std::string> db;
	std::string name;
	std::vector<std::string> results;
	for (int i = 0; i < n; i++)
	{
		std::cin >> name;
		if (db.find(name) == db.end())
		{
			results.push_back("OK");
			db.insert(name);
		}
		else
		{
			int i = 1;
			while (db.find(name + itoa(i)) != db.end())
			{
				i++;
			}
			results.push_back(name + itoa(i));
			db.insert(name + itoa(i));
		}
	}

	for (int i = 0; i < n; i++)
	{
	    std::cout << results[i] << std::endl;
	}
}


#include <iostream>
#include <map>
#include <algorithm>

std::string itoa(int n)
{
    std::string res = "";
    while (n)
    {
        res += (n % 10) + int('0');
        n /= 10;
    }
    std::reverse(res.begin(), res.end());
    return res;
}

int main()
{
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(NULL);
    std::cout.tie(NULL);

	int n;
	std::cin >> n;
	std::map<std::string, int> db;
	std::string name;
	for (int i = 0; i < n; i++)
	{
		std::cin >> name;
		if (db.find(name) == db.end())
		{
			std::cout << "OK" << std::endl;
			db[name] = 0;
		}
		else
		{
		    db[name]++;
			std::cout << name + itoa(db[name]) << std::endl;
		}
	}
}