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
import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int n = sc.nextInt();
        int[]a = sc.nextIntArr(n);
        int[]b = sc.nextIntArr(n);
        Stack<Integer>[]ids= new Stack[n+1];
        for (int i =0;i<=n;i++)ids[i]=new Stack<>();
        int sum=0;
        for (int i =0;i<n;i++){
            if (a[i]==b[i]){
                ids[b[i]].add(i);
            }
        }
        Stack<Integer>cur = new Stack<>();
        for (int i =0;i<=n;i++){
            while (!cur.isEmpty()&&!ids[i].isEmpty()){
                int c= cur.pop();
                int d = ids[i].pop();
                int t =b[c];
                b[c]=b[d];
                b[d]=t;
            }
            while (!ids[i].isEmpty())cur.add(ids[i].pop());
        }
        if (!cur.isEmpty()){
            for (int i =0;i<n&&!cur.isEmpty();i++){
                if (a[i]!=b[cur.peek()]&&b[i]!=b[cur.peek()]){
                    int t = b[cur.peek()];
                    b[cur.pop()]=b[i];
                    b[i]=t;
                }
            }
            if (cur.isEmpty()){
                pw.println("Yes");
                for (int i =0;i<n;i++)
                    pw.print(b[i]+" ");
                pw.println();
            }
            else pw.println("No");
        }
        else {
            pw.println("Yes");
            for (int i =0;i<n;i++)
                pw.print(b[i]+" ");
            pw.println();
        }
        pw.flush();
    }
    static class Scanner {
        BufferedReader br;
        StringTokenizer st;

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        public Scanner(FileReader f) {
            br = new BufferedReader(f);
        }

        public String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        public int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        public long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        public double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        public int[] nextIntArr(int n) throws IOException {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = Integer.parseInt(next());
            }
            return arr;
        }

    }

}