Problem: In the game of Mastermind, there are two players — Alice and Bob. Alice has a secret code, which Bob tries to guess. Here, a code is defined as a sequence of n colors. There are exactly n+1 colors in the entire universe, numbered from 1 to n+1 inclusive.

When Bob guesses a code, Alice tells him some information about how good of a guess it is, in the form of two integers x and y.

The first integer x is the number of indices where Bob's guess correctly matches Alice's code. The second integer y is the size of the intersection of the two codes as multisets. That is, if Bob were to change the order of the colors in his guess, y is the maximum number of indices he could get correct.

For example, suppose n=5, Alice's code is [3,1,6,1,2], and Bob's guess is [3,1,1,2,5]. At indices 1 and 2 colors are equal, while in the other indices they are not equal. So x=2. And the two codes have the four colors 1,1,2,3 in common, so y=4.

<image> Solid lines denote a matched color for the same index. Dashed lines denote a matched color at a different index. x is the number of solid lines, and y is the total number of lines. 

You are given Bob's guess and two values x and y. Can you find one possibility of Alice's code so that the values of x and y are correct?

Input

The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.

The first line of each test case contains three integers n,x,y (1≤ n≤ 10^5, 0≤ x≤ y≤ n) — the length of the codes, and two values Alice responds with.

The second line of each test case contains n integers b_1,…,b_n (1≤ b_i≤ n+1) — Bob's guess, where b_i is the i-th color of the guess.

It is guaranteed that the sum of n across all test cases does not exceed 10^5.

Output

For each test case, on the first line, output "YES" if there is a solution, or "NO" if there is no possible secret code consistent with the described situation. You can print each character in any case (upper or lower).

If the answer is "YES", on the next line output n integers a_1,…,a_n (1≤ a_i≤ n+1) — Alice's secret code, where a_i is the i-th color of the code.

If there are multiple solutions, output any.

Example

Input


7
5 2 4
3 1 1 2 5
5 3 4
1 1 2 1 2
4 0 4
5 5 3 3
4 1 4
2 3 2 3
6 1 2
3 2 1 1 1 1
6 2 4
3 3 2 1 1 1
6 2 6
1 1 3 2 1 1


Output


YES
3 1 6 1 2
YES
3 1 1 1 2
YES
3 3 5 5
NO
YES
4 4 4 4 3 1
YES
3 1 3 1 7 7
YES
2 3 1 1 1 1

Note

The first test case is described in the statement.

In the second test case, x=3 because the colors are equal at indices 2,4,5. And y=4 because they share the colors 1,1,1,2.

In the third test case, x=0 because there is no index where the colors are the same. But y=4 because they share the colors 3,3,5,5.

In the fourth test case, it can be proved that no solution exists.

Solution (in JAVA):

Solution:
// Working program with FastReader
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
//import javafx.util.Pair;
import java.util.StringTokenizer;
 
public class Main {
    static class Pair<T,T1>{
        T x;
        T1 y;
        public Pair(T x,T1 y)
        {
            this.x=x;
            this.y=y;
        }
        
        public T getKey(){
            return x;
        }
         public T1 getValue(){
            return y;
        }
    }
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;
 
        public FastReader()
        {
            br = new BufferedReader(
                new InputStreamReader(System.in));
        }
         
        int[] arrayInput(int size)
        {
            int a[]=new int[size];
            for(int i=0;i<size;i++)
            {
                a[i]=nextInt();
            }
            return a;
        }
 
        String next()
        {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
         int nextInt() { return Integer.parseInt(next()); }
 
        long nextLong() { return Long.parseLong(next()); }
 
        double nextDouble()
        {
            return Double.parseDouble(next());
        }
 
        String nextLine()
        {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
    static void forLoop(int arr[],int start,int last,int value)
    {
        for(int i=start;i<last;i++)
         arr[i]=value;
    }
     static void forLoopEndEqual(int arr[],int start,int last,int value)
    {
        for(int i=start;i<=last;i++)
         arr[i]=value;
    }
    static void debug(int a){
        System.out.print(a+" ");
    }
     static void debug(int a,int b){
        System.out.print(a+" "+b);
    }
     static void lineBreak(){
        System.out.println("");
    }
    
    ////////////////////////////////////////////////////////////////////////////////Binary Search///////////////////////
   static class OurComparator implements Comparator<Pair<Integer,Integer>>{ 
              
            // Overriding compare()method of Comparator  
                        // for descending order of cgpa 
            public int compare(Pair<Integer,Integer> s1, Pair<Integer,Integer> s2) { 
                if (s1.getValue() < s2.getValue()) 
                    return 1; 
                else if (s1.getValue() > s2.getValue()) 
                    return -1; 
                                return 0; 
                } 
        } 
    
    
    
  /////////////////////////////////////////////////////////////MAIN///////////////////////////////////////  
    
     public static void main(String[] args)
    {
        FastReader s = new FastReader();
        int t = s.nextInt();
      
    while(t>0)
    { 
         int n=s.nextInt();
    
         
        int x=s.nextInt();
        int y=s.nextInt();
        
        int[] arr=new int[n+2];
        int[] tem=new int[n+2];
        int[] an=new int[n+2];
        Arrays.fill(an,0,n+2,0);
        PriorityQueue<Pair<Integer,Integer>> pq=new PriorityQueue<>(new OurComparator());
        pq.clear();
      ArrayList<Integer> feq[]=new  ArrayList[n+2];
        for (int i = 1; i < n+2; i++) { 
            feq[i] = new ArrayList<Integer>(); 
        } 

         
      forLoopEndEqual(tem,1,n+1,0);
        for(int i=1;i<=n;i++)
        {
            arr[i]=s.nextInt();
            tem[arr[i]]++;
            feq[arr[i]].add(i);
        
        }
 
        int fill=n+1;
         
         for(int i=1;i<=n+1;i++)
    {
       if(tem[i]==0)
        {fill=i;
            break;
        }
    }
      for(int i=1;i<=n+1;i++)
    {
       
        if(tem[i]!=0){
            int key=i;
            int val=tem[i];
          pq.add(new Pair(key,val)); 
        }
        
    }
        int diff=y-x;
       
      while(x>0 && pq.size()>0){
          Pair<Integer,Integer> p=pq.poll();
          int key=p.getKey();
            int val=p.getValue();
            int pos=feq[key].get(0);
            feq[key].remove(0);
            an[pos]=key;
            if(val>1)
              pq.add(new Pair(key,val-1));
            
            
      x--; }
 
      while(diff>0 )
      {
         //  System.out.println(pq+" "+diff);
         if(diff==3&& pq.size()>2)
         { // System.out.println(pq+" "+diff);
             Pair<Integer,Integer> p1=pq.poll();
            Pair<Integer,Integer> p2=pq.poll();
                        Pair<Integer,Integer> p3=pq.poll();
                        
                          int key1=p1.getKey();
            int val1=p1.getValue();
            int key2=p2.getKey();
            int val2=p2.getValue();
            int key3=p3.getKey();
            int val3=p3.getValue();
                        
                        
            int pos1=feq[key1].get(0);
              int pos2=feq[key2].get(0);  
                int pos3=feq[key3].get(0);
              feq[key1].remove(0);
              feq[key2].remove(0);
              feq[key3].remove(0);
              an[pos1]=key2;
              an[pos2]=key3;
                an[pos3]=key1;
              if(val1>1)
              pq.add(new Pair(key1,val1-1));
              if(val2>1)
              pq.add(new Pair(key2,val2-1));
                if(val3>1)
              pq.add(new Pair(key3,val3-1));
              diff-=3;
                        
                        
             break;
         }
         if(pq.size()<2){
             System.out.println("NO");
             break;
         }
          if(diff==1){
              Pair<Integer,Integer> p1=pq.poll();
            Pair<Integer,Integer> p2=pq.poll();
          int key1=p1.getKey();
            int val1=p1.getValue();
            int key2=p2.getKey();
            int val2=p2.getValue();
               
              int pos1=feq[key1].get(0);
              int pos2=feq[key2].get(0);
             //  feq[key1].remove(0);
              feq[key2].remove(0);
              
              an[pos2]=key1;
              
              if(val1>1)
                pq.add(new Pair(key1,val1-1));
              diff-=1;
              break;
          }
         else {
              
          Pair<Integer,Integer> p1=pq.poll();
            Pair<Integer,Integer> p2=pq.poll();
          int key1=p1.getKey();
            int val1=p1.getValue();
            int key2=p2.getKey();
            int val2=p2.getValue();
               
              int pos1=feq[key1].get(0);
              int pos2=feq[key2].get(0);
              feq[key1].remove(0);
              feq[key2].remove(0);
              an[pos1]=key2;
              an[pos2]=key1;
              if(val1>1)
              pq.add(new Pair(key1,val1-1));
              if(val2>1)
              pq.add(new Pair(key2,val2-1));
              diff-=2;
             //  System.out.println(pq+" "+diff);
          }
         
          
          
         
      }
      
     
      
      
      if(diff==0){ 
 System.out.println("YES");
      for(int i=1;i<n+1;i++)
      {
          if(an[i]==0)
          an[i]=fill;
          System.out.print(an[i]+" ");
           
      } System.out.println("");}
     
     
        t-=1;
    }
        
    }
   //////////////////////////////////////////////////////////////Solve//////////////////////////////////////// 
//     static void solve(){
       
//       FastReader s = new FastReader(); 
//         int n=s.nextInt();
    
         
//         int x=s.nextInt();
//         int y=s.nextInt();
        
//         int[] arr=new int[n+2];
//         int[] tem=new int[n+2];
//         PriorityQueue<Pair<Integer,Integer>> pq=new PriorityQueue<>(new OurComparator());
//         pq.clear();
//       ArrayList<Integer> feq[]=new  ArrayList[n+2];
//         for (int i = 1; i < n+2; i++) { 
//             feq[i] = new ArrayList<Integer>(); 
//         } 

         
//       forLoopEndEqual(tem,1,n+1,0);
//         for(int i=1;i<=n;i++)
//         {
//             arr[i]=s.nextInt();
//             tem[arr[i]]++;
//             feq[arr[i]].add(i);
        
//         }
 
//         int fill=n+1;
//       for(int i=1;i<=n+1;i++)
//     {
//         if(tem[i]==0)
//         {fill=4;}
//         else{
//             int key=i;
//             int val=tem[i];
//           pq.add(new Pair(key,val)); 
//         }
        
//     }
//         int diff=y-x;
       
//       while(x>0 && pq.size()>0){
//           Pair<Integer,Integer> p=pq.poll();
//           int key=p.getKey();
//             int val=p.getValue();
//             int pos=feq[key].get(0);
//             feq[key].remove(0);
//             arr[pos]=key;
//             if(val>2)
//               pq.add(new Pair(key,val-1));
            
            
//       x--; }
      
//       while(diff>0 && pq.size()>1 )
//       {
//          //  System.out.println(pq+" "+diff);
//          if(diff==3&& pq.size()>2)
//          {
//              Pair<Integer,Integer> p1=pq.poll();
//             Pair<Integer,Integer> p2=pq.poll();
//                         Pair<Integer,Integer> p3=pq.poll();
                        
//                           int key1=p1.getKey();
//             int val1=p1.getValue();
//             int key2=p2.getKey();
//             int val2=p2.getValue();
//             int key3=p3.getKey();
//             int val3=p3.getValue();
                        
                        
//             int pos1=feq[key1].get(0);
//               int pos2=feq[key2].get(0);
//                 int pos3=feq[key3].get(0);
//               feq[key1].remove(0);
//               feq[key2].remove(0);
//               feq[key3].remove(0);
//               arr[pos1]=key2;
//               arr[pos2]=key3;
//                 arr[pos3]=key1;
//               if(val1>1)
//               pq.add(new Pair(key1,val1-1));
//               if(val2>1)
//               pq.add(new Pair(key2,val2-1));
//                 if(val3>1)
//               pq.add(new Pair(key3,val3-1));
//               diff-=3;
                        
                        
             
//          }
//           if(diff>1){
              
//           Pair<Integer,Integer> p1=pq.poll();
//             Pair<Integer,Integer> p2=pq.poll();
//           int key1=p1.getKey();
//             int val1=p1.getValue();
//             int key2=p2.getKey();
//             int val2=p2.getValue();
               
//               int pos1=feq[key1].get(0);
//               int pos2=feq[key2].get(0);
//               feq[key1].remove(0);
//               feq[key2].remove(0);
//               arr[pos1]=key2;
//               arr[pos2]=key1;
//               if(val1>1)
//               pq.add(new Pair(key1,val1-1));
//               if(val2>1)
//               pq.add(new Pair(key2,val2-1));
//               diff-=2;
//              //  System.out.println(pq+" "+diff);
//           }
//           else{
//               Pair<Integer,Integer> p1=pq.poll();
//             Pair<Integer,Integer> p2=pq.poll();
//           int key1=p1.getKey();
//             int val1=p1.getValue();
//             int key2=p2.getKey();
//             int val2=p2.getValue();
               
//               int pos1=feq[key1].get(0);
//               int pos2=feq[key2].get(0);
//              //  feq[key1].remove(0);
//               feq[key2].remove(0);
              
//               arr[pos2]=key1;
              
//               if(val1>1)
//                 pq.add(new Pair(key1,val1-1));
//               diff-=1;
//           }
          
          
         
//       }
      
//       for(int i=1;i<n+1;i++)
//       {
//           for(Integer it :feq[i])
//           {
//               arr[it]=fill;
//           }
//       }
      
      
//       if(diff==0){ 
//  System.out.println("YES");
//       for(int i=1;i<n+1;i++)
//       {
//           System.out.print(arr[i]+" ");
           
//       }}
//       else{
//           System.out.println("NO");
         
//       }
    

//     }
 }