Problem:
Score : 800 points

Problem Statement

You are given an integer sequence x of length N.
Determine if there exists an integer sequence a that satisfies all of the following conditions, and if it exists, construct an instance of a.

a is N^2 in length, containing N copies of each of the integers 1, 2, ..., N.

For each 1 ≤ i ≤ N, the i-th occurrence of the integer i from the left in a is the x_i-th element of a from the left.

Constraints

1 ≤ N ≤ 500

1 ≤ x_i ≤ N^2

All x_i are distinct.

Input

The input is given from Standard Input in the following format:

N
x_1 x_2 ... x_N

Output

If there does not exist an integer sequence a that satisfies all the conditions, print No.
If there does exist such an sequence a, print Yes in the first line, then print an instance of a in the second line, with spaces inbetween.

Sample Input 1

3
1 5 9

Sample Output 1

Yes
1 1 1 2 2 2 3 3 3

For example, the second occurrence of the integer 2 from the left in a in the output is the fifth element of a from the left.
Similarly, the condition is satisfied for the integers 1 and 3.

Sample Input 2

2
4 1

Sample Output 2

No

Solution in Rust (1.15.1) (judge verdict: Runtime Error)

#![allow(unused_imports)]
#![allow(non_snake_case)]
use std::cmp::*;
use std::collections::*;
use std::io::Write;

#[allow(unused_macros)]
macro_rules! debug {
    ($($e:expr),*) => {
        #[cfg(debug_assertions)]
        $({
            let (e, mut err) = (stringify!($e), std::io::stderr());
            writeln!(err, "{} = {:?}", e, $e).unwrap()
        })*
    };
}

fn main() {
    let n = read::<usize>();
    let x = read_vec::<usize>();
    let mut pairs = vec![];
    for (i, xnum) in x.into_iter().enumerate() {
        pairs.push((xnum - 1, i));
    }
    pairs.sort();
    let mut answers = vec![];
    let mut pointer = 0;

    let mut yobi = VecDeque::new();
    for i in 0..n {
        for _ in 0..i {
            yobi.push_back(i);
        }
    }

    let mut residual = VecDeque::new();
    for (xnum, i) in pairs {
        if pointer > xnum {
            println!("No");
            return;
        }
        while pointer < xnum {
            if let Some(top) = yobi.pop_front() {
                answers.push(top);
            } else if let Some(top) = residual.pop_front() {
                answers.push(top);
            } else {
                println!("No");
                return;
            }
            pointer += 1;
        }
        if !yobi.is_empty() && yobi[0] <= i {
            assert!(false);
            println!("No");
            return;
        }
        answers.push(i);
        pointer += 1;
        for _ in i + 1..n {
            residual.push_back(i);
        }
    }
    while let Some(top) = residual.pop_front() {
        answers.push(top);
        pointer += 1;
    }
    assert_eq!(pointer, n * n);
    assert_eq!(answers.len(), n * n);
    assert!(false);
    println!("Yes");
    for ans in answers {
        print!("{} ", ans + 1);
    }
    println!("");
}

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}