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);
        int[]c1= new int[n+1];
        int[]c2= new int[n+1];
        Stack<Integer>[]ids= new Stack[n+1];
        for (int i =0;i<=n;i++)ids[i]=new Stack<>();
        TreeSet<int[]>as= new TreeSet<>((x,y)->x[0]==y[0]?x[1]-y[1]:x[0]-y[0]);
        TreeSet<int[]>bs= new TreeSet<>((x,y)->x[0]==y[0]?x[1]-y[1]:x[0]-y[0]);
        boolean valid=true;
        for (int i =0;i<n;i++){
            c1[a[i]]++;
            c2[b[i]]++;
            as.add(new int[]{a[i],i});
            bs.add(new int[]{b[i],i});
            ids[b[i]].add(i);
        }
        for (int i =1;i<=n;i++){
            if (c1[i]+c2[i]>n)
                valid=false;
        }
        int[]ans = new int[n];
        while (!as.isEmpty()){
            Stack<int[]>cur = new Stack<>();
            cur.add(as.pollFirst());
            int v= cur.peek()[0];
            while (!as.isEmpty()&&as.first()[0]==cur.peek()[0])cur.add(as.pollFirst());
            while (!cur.isEmpty()){
                if (bs.first()[0]!=v){
                    int[] cc= bs.pollFirst();
                    ans[cur.pop()[1]]=cc[0];
                }
                else {
                    int[] cc= bs.pollLast();
                    ans[cur.pop()[1]]=cc[0];
                }
            }
            while (!ids[v].isEmpty()){
                int[]aa = new int[]{v,ids[v].pop()};
                if (!bs.contains(aa))
                    continue;
                bs.remove(aa);
                ans[as.pollFirst()[1]]=v;
            }
        }
        if (!valid){
            pw.println("No");
        }
        else {

            Stack<int[]>st =new Stack<>();
            for (int i=0;i<n;i++){
                if (a[i]==ans[i]){
                    if (!st.isEmpty()&&st.peek()[0]!=ans[i]){
                        ans[st.peek()[1]]=ans[i];
                        ans[i]=st.pop()[0];
                        continue;
                    }
                    st.add(new int[]{ans[i],i});
                    ans[i]=0;
                }
            }
            for (int i =0;i<n&&!st.isEmpty();i++){
                if (ans[i]==0)
                    continue;
                if (a[i]!=st.peek()[0]&&ans[i]!=st.peek()[0]){
                    ans[st.peek()[1]]=ans[i];
                    ans[i]=st.pop()[0];
                }
            }
            if (st.isEmpty()) {
                pw.println("Yes");
                for (int i = 0; i < n; i++)
                    pw.print(ans[i] + " ");
                pw.println();
            }
            else pw.println("No");
        }
        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;
        }

    }

}