5

3 2 2
2 0
0 5

4 3 2
2 0 5
0 6

0 2 2
1 0
2 3

5 4 4
6 0 8 0
0 7 0 9

5 4 1
8 7 8 0
0

0 2 0 5
0 2 0 5 6
-1
0 6 0 7 0 8 0 9
-1


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main {
	
	
	
//    ***                          ++                      
// +=-==+                      +++=-                     
//+-:---==+                   *+=----=                   
//+-:------==+               ++=------==                  
//=-----------=++=========================                
//+--:::::---:-----============-=======+++====             
//+---:..:----::-===============-======+++++++++           
//=---:...---:-===================---===++++++++++         
//+----:...:-=======================--==+++++++++++        
//+-:------====================++===---==++++===+++++      
//+=-----======================+++++==---==+==-::=++**+     
//+=-----================---=======++=========::.:-+*****    
//+==::-====================--:  --:-====++=+===:..-=+*****   
//+=---=====================-...  :=..:-=+++++++++===++*****  
//+=---=====+=++++++++++++++++=-:::::-====+++++++++++++*****+ 
//+=======++++++++++++=+++++++============++++++=======+****** 
//+=====+++++++++++++++++++++++++==++++==++++++=:...  . .+**** 
//++====++++++++++++++++++++++++++++++++++++++++-.     ..-+**** 
//+======++++++++++++++++++++++++++++++++===+====:.    ..:=++++ 
//+===--=====+++++++++++++++++++++++++++=========-::....::-=++* 
//====--==========+++++++==+++===++++===========--:::....:=++*  
//====---===++++=====++++++==+++=======-::--===-:.  ....:-+++   
//==--=--====++++++++==+++++++++++======--::::...::::::-=+++    
//===----===++++++++++++++++++++============--=-==----==+++     
//=--------====++++++++++++++++=====================+++++++     
//=---------=======++++++++====+++=================++++++++     
//-----------========+++++++++++++++=================+++++++    
//=----------==========++++++++++=====================++++++++  
//=====------==============+++++++===================+++==+++++ 
//=======------==========================================++++++

// created by : pritam kumar

    static long LowerBound(long[] a2, long x) { // x is the target value or key
  int l=-1,r=a2.length;
  while(l+1<r) {
    int m=(l+r)>>>1;
    if(a2[m]>=x) r=m;
    else l=m;
  }
  return r;
}
static int UpperBound(int a[], int x) {// x is the key or target value
    int l=-1,r=a.length;
    while(l+1<r) {
       int m=(l+r)>>>1;
       if(a[m]<=x) l=m;
       else r=m;
    }
    return l+1;
 }
    static void ruffleSort(long[] a) {
		int n=a.length;
		Random r=new Random();
		for (int i=0; i<a.length; i++) {
			long oi=r.nextInt(n), temp=a[i];
			a[i]=a[(int)oi];
			a[(int)oi]=temp;
		}
		Arrays.sort(a);
	}
static void ruffleSort(int[] a) {
		int n=a.length;
		Random r=new Random();
		for (int i=0; i<a.length; i++) {
			int oi=r.nextInt(n), temp=a[i];
			a[i]=a[oi];
			a[oi]=temp;
		}
		Arrays.sort(a);
	}
    public static int findIndex(long arr[], long t) 
    { 
 
        // if array is Null 
        if (arr == null) { 
            return -1; 
        } 
 
        // find length of array 
        int len = arr.length; 
        int i = 0; 
 
        // traverse in the array 
        while (i < len) { 
 
            // if the i-th element is t 
            // then return the index 
            if (arr[i] == t) { 
                return i; 
            } 
            else { 
                i = i + 1; 
            } 
        } 
        return -1; 
    }
 
    static long gcd(long a, long b)
    {
        if (a == 0)
            return b; 
        return gcd(b % a, a); 
    }
    static int gcd(int a, int b)
    {
        if (a == 0)
            return b; 
        return gcd(b % a, a); 
    }
 
    // method to return LCM of two numbers
    static long lcm(long a, long b)
    {
        return (a / gcd(a, b)) * b;
    }
 
    public static int[] swap(int a[], int left, int right)
    {
 
        // Swap the data
        int temp = a[left];
        a[left] = a[right];
        a[right] = temp;
 
        // Return the updated array
        return a;
    }
//    public static pair swap(long max0,long max1)
//    {
//    	pair p=new pair(0, 0);
//    	long temp=max0;
//    	max0=max1;
//    	max1=temp;
//    	p.x=max0;
//    	p.y=max1;
//    	return p;
//    	
//    }
    public static void swap(int max0,int max1)
    {
    	int temp=max0;
    	max0=max1;
    	max1=temp;
    }
 
    public static int[] reverse(int a[], int left, int right)
    {
 
        // Reverse the sub-array
        while (left < right) {
            int temp = a[left];
            a[left++] = a[right];
            a[right--] = temp;
        }
 
        // Return the updated array
        return a;
    }
 
  
	static class FastReader {
        BufferedReader br;
        StringTokenizer st;
 
        public FastReader()
        {
            br = new BufferedReader(
                new InputStreamReader(System.in));
        } 
 
        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 boolean prime[] ;
		static void sieve(int n)
		{
			prime= new boolean[n+1];
	        for (int i = 0; i <= n; i++)
	            prime[i] = true;
	        prime[0]=false;
	        prime[1]=false;
	        for (int p = 2; p * p <= n; p++)
	        {
	            if (prime[p] == true)
	            {
	                for (int i = p * p; i <= n; i += p)
	                    prime[i] = false;
	            }
	        }
	    }
	    static long[][] a;
	    static ArrayList<Integer>[] tree;
	    static long[][] dp;
	    static void bin(int n)
	    {
	        if (n > 1)
	            bin(n / 2);
	        System.out.print(n % 2);
	    }
	public static void main(String[] args) {
		FastReader s=new FastReader();
		int t=s.nextInt();
		while(t-->0)
		{
			int k=s.nextInt();
			int n=s.nextInt();
			int m=s.nextInt();
			int[] a=new int[n];
			for(int i=0;i<n;i++)a[i]=s.nextInt();
			int[] b=new int[m];
			for(int i=0;i<m;i++)b[i]=s.nextInt();
			int i=0,j=0;
			ArrayList<Integer>ans=new ArrayList<>();
			boolean f=true;
			while(i<n&&j<m)
			{
				if(a[i]==0)
				{
					ans.add(0);
					i++;
					k++;
				}
				else if(b[j]==0)
				{
					ans.add(0);
					j++;
					k++;
				}
				else
				{
					if(a[i]<b[i]&&a[i]<=k)
					{
						ans.add(a[i]);
						i++;
					}
					else if(a[i]>b[i]&&b[i]<=k)
					{
						ans.add(b[j]);
						j++;
					}
					else
					{
						f=false;
						break;
					}
				}
			}
			while(i<n)
			{
				if(a[i]==0)
				{
					ans.add(0);
					i++;
					k++;
				}
				else
				{
					if(a[i]<=k)
					{
						ans.add(a[i]);
						i++;
					}
					else 
					{
						f=false;
						break;
					}
				}
			}
			while(j<m)
			{
				if(b[j]==0)
				{
					ans.add(0);
					j++;
					k++;
				}
				else
				{
					if(b[j]<=k)
					{
						ans.add(b[j]);
						j++;
					}
					else
					{
						f=false;
						break;
					}
				}
			}
			if(f==true)
			{
				for(int l:ans)System.out.print(l+" ");
			}
			else System.out.print("-1");
			System.out.println();
		}
		
	}
	static int count;
	
	
}
class pair{
	long x;
	long y;
	public pair(long x,long y)
	{
		this.x=x;
		this.y=y;
	}
}
	
