Problem: 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.

Examples

Input

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


Output

Yes
2 2 3 1 1 1


Input

3
1 1 2
1 1 3


Output

No


Input

4
1 1 2 3
1 2 3 3


Output

Yes
3 3 1 2

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;

@SuppressWarnings("unchecked")
public class Main {
    private static final long MOD = (int)1e9 + 7;

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] a = new int[n];
        int[] b = new int[n];

        int[] cnt = new int[n + 1];
        int[] cnt2 = new int[n + 1];

        int[] start = new int[n + 1];
        Arrays.fill(start, -1);

        for (int i = 0; i < n; ++i) {
            a[i] = in.nextInt();
            ++cnt2[a[i]];
        }
        for (int i = 0; i < n; ++i) {
            b[i] = in.nextInt();
            if (a[i] == b[i]) {
                ++cnt[a[i]];
                if (start[a[i]] == -1) start[a[i]] = i;
            }
            ++cnt2[b[i]];
        }
        for (int i = 0; i <= n; ++i) {
            if (cnt2[i] > n) {
                System.out.println("No");
                return;
            }
        }
        PriorityQueue<Pair> pq = new PriorityQueue<>();
        for (int i = 1; i <= n; ++i) {
            if (cnt[i] != 0) pq.add(new Pair(i, cnt[i]));
        }
        while (pq.size() > 1) {
            Pair p1 = pq.poll();
            Pair p2 = pq.poll();

            int i1 = start[p1.val];
            int i2 = start[p2.val];

            b[i1] = p2.val;
            b[i2] = p1.val;

            p1.cnt--;
            p2.cnt--;

            start[p1.val]++;
            start[p2.val]++;

            if (p1.cnt != 0) pq.add(p1);
            if (p2.cnt != 0) pq.add(p2);
        }
        if (!pq.isEmpty()) {
            Pair p = pq.poll();
            int x = p.val;
            int i = 0;
            while (i < n && p.cnt != 0) {
                if (b[i] != x && x != a[i]) {
                    int temp = b[i];
                    b[i] = x;
                    b[start[x]] = temp;
                    start[x]++;
                    p.cnt--;
                }
                ++i;
            }
        }
        System.out.println("Yes");
        for (int i = 0; i < n; ++i) {
            System.out.print(b[i] + " ");
        }
    }

    static class Pair implements Comparable<Pair> {
        int val, cnt;

        Pair(int val, int cnt) {
            this.val = val;
            this.cnt = cnt;
        }

        public int compareTo(Pair p) {
            return p.cnt - this.cnt;
        }
    }
}