Problem:
Score : 600 points

Problem Statement

Given are two sequences A and B, both of length N.
A and B are each sorted in the ascending order.
Check if it is possible to reorder the terms of B so that for each i (1 \leq i \leq N) A_i \neq B_i holds, and if it is possible, output any of the reorderings that achieve it.

Constraints

1\leq N \leq 2 \times 10^5

1\leq A_i,B_i \leq N

A and B are each sorted in the ascending order.

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 \cdots A_N
B_1 B_2 \cdots B_N

Output

If there exist no reorderings that satisfy the condition, print No.

If there exists a reordering that satisfies the condition, print Yes on the first line.
After that, print a reordering of B on the second line, separating terms with a whitespace.

If there are multiple reorderings that satisfy the condition, you can print any of them.

Sample Input 1

6
1 1 1 2 2 3
1 1 1 2 2 3

Sample Output 1

Yes
2 2 3 1 1 1

Sample Input 2

3
1 1 2
1 1 3

Sample Output 2

No

Sample Input 3

4
1 1 2 3
1 2 3 3

Sample Output 3

Yes
3 3 1 2

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

#![allow(unused, non_snake_case, dead_code, non_upper_case_globals)]
use {
    proconio::{marker::*, *},
    std::{cmp::*, collections::*, mem::*},
};

#[fastout]
fn main() {
    input! {//
        n:usize,
        mut a:[i64;n],
        mut b:[i64;n],
    }
    let mut histA = vec![0; n + 1];
    for &x in a.iter() {
        histA[x as usize] += 1;
    }
    let mut histB = vec![0; n + 1];
    for &x in b.iter() {
        histB[x as usize] += 1;
    }
    let mut dup = 0i64;
    for i in 0..=n {
        dup += min(histA[i], histB[i]);
    }
    let mut ha = vec![];
    let mut hb = vec![];
    for i in 0..=n {
        if histA[i] > 0 {
            ha.push((i, histA[i]));
        }
        if histB[i] > 0 {
            hb.push((i, histB[i]));
        }
    }
    ha.sort();
    hb.sort();
    // ha.reverse();
    hb.reverse();
    // dbg!(&ha);
    // dbg!(&hb);
    let mut ans = vec![];
    let mut la = ha.len();
    let mut lb = hb.len();
    let mut ind = 0;
    let mut nged = !0;
    for &(num, cnt) in ha.iter() {
        let mut cnt = cnt;
        while ind < lb && cnt > 0 {
            if num == hb[ind].0 {
                nged = ind;
                ind += 1;
                continue;
            }
            let mins = min(cnt, hb[ind].1);
            cnt -= mins;
            hb[ind].1 -= mins;
            for _ in 0..mins {
                ans.push(hb[ind].0);
            }
            ind += 1;
        }
    }
    if nged != !0 {
        let anl = ans.len();
        for _ in 0..(n - anl) {
            ans.push(hb[nged].0);
        }
    }
    let mut ok = true;
    for i in 0..n {
        if a[i] == ans[i] as i64 {
            ok = false;
        }
    }
    if ok {
        yn(true);
        for &x in ans.iter() {
            println!("{}", x);
        }
    } else {
        yn(false);
    }
}
pub fn yn(ans: bool) {
    if ans {
        println!("Yes");
    } else {
        println!("No");
    }
}