You are given three sequences: a_1, a_2, …, a_n; b_1, b_2, …, b_n; c_1, c_2, …, c_n.

For each i, a_i ≠ b_i, a_i ≠ c_i, b_i ≠ c_i.

Find a sequence p_1, p_2, …, p_n, that satisfy the following conditions:

  * p_i ∈ \\{a_i, b_i, c_i\}
  * p_i ≠ p_{(i mod n) + 1}.



In other words, for each element, you need to choose one of the three possible values, such that no two adjacent elements (where we consider elements i,i+1 adjacent for i<n and also elements 1 and n) will have equal value.

It can be proved that in the given constraints solution always exists. You don't need to minimize/maximize anything, you need to find any proper sequence.

Input

The first line of input contains one integer t (1 ≤ t ≤ 100): the number of test cases.

The first line of each test case contains one integer n (3 ≤ n ≤ 100): the number of elements in the given sequences.

The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 100).

The third line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 100).

The fourth line contains n integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 100).

It is guaranteed that a_i ≠ b_i, a_i ≠ c_i, b_i ≠ c_i for all i.

Output

For each test case, print n integers: p_1, p_2, …, p_n (p_i ∈ \\{a_i, b_i, c_i\}, p_i ≠ p_{i mod n + 1}).

If there are several solutions, you can print any.

Example

Input


5
3
1 1 1
2 2 2
3 3 3
4
1 2 1 2
2 1 2 1
3 4 3 4
7
1 3 3 1 1 1 1
2 4 4 3 2 2 4
4 2 2 2 4 4 2
3
1 2 1
2 3 3
3 1 2
10
1 1 1 2 2 2 3 3 3 1
2 2 2 3 3 3 1 1 1 2
3 3 3 1 1 1 2 2 2 3


Output


1 2 3
1 2 1 2
1 3 4 3 2 4 2
1 3 2
1 2 3 1 2 3 1 2 3 2

Note

In the first test case p = [1, 2, 3].

It is a correct answer, because:

  * p_1 = 1 = a_1, p_2 = 2 = b_2, p_3 = 3 = c_3 
  * p_1 ≠ p_2 , p_2 ≠ p_3 , p_3 ≠ p_1 



All possible correct answers to this test case are: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1].

In the second test case p = [1, 2, 1, 2].

In this sequence p_1 = a_1, p_2 = a_2, p_3 = a_3, p_4 = a_4. Also we can see, that no two adjacent elements of the sequence are equal.

In the third test case p = [1, 3, 4, 3, 2, 4, 2].

In this sequence p_1 = a_1, p_2 = a_2, p_3 = b_3, p_4 = b_4, p_5 = b_5, p_6 = c_6, p_7 = c_7. Also we can see, that no two adjacent elements of the sequence are equal.
     import java.io.*;
    import java.util.*;
    import java.math.*;
    import java.lang.*;

    public class Main implements Runnable 
    {
        static class InputReader 
        {
            private InputStream stream;
            private byte[] buf = new byte[1024];
            private int curChar;
            private int numChars;
            private SpaceCharFilter filter;
            private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

            public InputReader(InputStream stream) 
            {
                this.stream = stream;
            }
            
            public int read()
            {
                if (numChars==-1) 
                    throw new InputMismatchException();
                
                if (curChar >= numChars) 
                {
                    curChar = 0;
                    try
                    {
                        numChars = stream.read(buf);
                    }
                    catch (IOException e)
                    {
                        throw new InputMismatchException();
                    }
                    
                    if(numChars <= 0)               
                        return -1;
                }
                return buf[curChar++];
            }
        
            public String nextLine()
            {
                String str = "";
                try
                {
                    str = br.readLine();
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }    
                return str;
            }
            public int nextInt() 
            {
                int c = read();
                
                while(isSpaceChar(c)) 
                    c = read();
            
                int sgn = 1;
            
                if (c == '-') 
                {
                    sgn = -1;
                    c = read();
                }
                
                int res = 0;
                do
                {
                    if(c<'0'||c>'9') 
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                }
                while (!isSpaceChar(c)); 
            
                return res * sgn;
            }
            
            public long nextLong() 
            {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                int sgn = 1;
                if (c == '-')
                {
                    sgn = -1;
                    c = read();
                }
                long res = 0;
                
                do 
                {
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                }    
                while (!isSpaceChar(c));
                    return res * sgn;
            }
            
            public double nextDouble() 
            {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                int sgn = 1;
                if (c == '-')
                {
                    sgn = -1;
                    c = read();
                }
                double res = 0;
                while (!isSpaceChar(c) && c != '.') 
                {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                }
                if (c == '.') 
                {
                    c = read();
                    double m = 1;
                    while (!isSpaceChar(c))
                    {
                        if (c == 'e' || c == 'E')
                            return res * Math.pow(10, nextInt());
                        if (c < '0' || c > '9')
                            throw new InputMismatchException();
                        m /= 10;
                        res += (c - '0') * m;
                        c = read();
                    }
                }
                return res * sgn;
            }
        
            public String readString() 
            {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                StringBuilder res = new StringBuilder();
                do 
                {
                    res.appendCodePoint(c);
                    c = read();
                } 
                while (!isSpaceChar(c));
                
                return res.toString();
            }
        
            public boolean isSpaceChar(int c) 
            {
                if (filter != null)
                    return filter.isSpaceChar(c);
                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
            }
        
            public String next()
            {
                return readString();
            }
            
            public interface SpaceCharFilter
            {
                public boolean isSpaceChar(int ch);
            }
        }
        public static void main(String args[]) throws Exception 
        {
            new Thread(null, new Main(),"Main",1<<27).start();
        }
        
        static class Pair{
            int f;
            int s;
            
            
            Pair(int f,int s){
                this.f=f;
                this.s=s;
                
            }
            
            public static Comparator<Pair> wc = new Comparator<Pair>(){
                public int compare(Pair e1,Pair e2){
                    
                    //reverse order
                    if(e1.s < e2.s) 
                        return 1;  // 1 for swaping.
                    else if (e1.s > e2.s) 
                        return -1; 
                    else {
                        //System.out.println("* "+e1.nod+" "+e2.nod);
                        return 0;
                    } 
                    
                }
            };	
        }

        public static long gcd(long a,long b){
            if(b==0)return a;
            else return gcd(b,a%b);
        }


        ////recursive BFS
        public static int bfsr(int s,ArrayList<Integer>[] a,boolean[] b,int[] pre){
            b[s]=true;
            int p = 1;
            int n = pre.length -1;
            int t = a[s].size();
            int max = 1;
            for(int i=0;i<t;i++){
                int x = a[s].get(i);
                if(!b[x]){
                    //dist[x] = dist[s] + 1;
                    int xz =  (bfsr(x,a,b,pre));
                    p+=xz;
                    max = Math.max(xz,max);
                }
            }
            max = Math.max(max,(n-p));
            pre[s] = max;
            return p;
        }

    //// iterative BFS
        public static int bfs(int s,ArrayList<Integer>[] a,int[] dist,boolean[] b,PrintWriter w){
            b[s]=true;
            int siz = 0;
            
            Queue<Integer> q = new LinkedList<>();
            q.add(s);
            while(q.size()!=0){
                int i=q.poll();
                Iterator<Integer> it = a[i].listIterator();
                int z=0;
                while(it.hasNext()){
                    z=it.next();
                    if(!b[z]){
                        b[z]=true;
                        dist[z] = dist[i] + 1;
                        siz++;
                        q.add(z);
                    }
                }   
            
            }
            return siz;
        }

        public static int lower(int key, int[] a){
            int l = 0;
            int r = a.length-1;
            int res = 0;

            while(l<=r){
                int mid = (l+r)/2;

                if(a[mid]<=key){
                    l = mid+1;
                    res = mid+1;
                }
                else{
                    r = mid -1;
                }
            }

            return res;
        }

        


    //////////////////////////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////////////////////////


        public void run()
        {
            InputReader sc = new InputReader(System.in);
            PrintWriter w = new PrintWriter(System.out);
            long defaultValue=0;
            

            
            int tc = sc.nextInt();
            while(tc-->0){
                int n = sc.nextInt();
                int[] a = new int[n];
                int[] b = new int[n];
                int[] c = new int[n];
                int pre = 0;
                for(int i=0;i<n;i++){
                    a[i] = sc.nextInt();
                }
                for(int i=0;i<n;i++){
                    b[i] = sc.nextInt();
                }
                for(int i=0;i<n;i++){
                    c[i] = sc.nextInt();
                }
                int j = 0;
                ArrayList<Integer> ans = new ArrayList<Integer>();
                for(int i=0;i<n;i++){
                    int x = a[i];
                    int y = b[i];
                    int z = c[i];
                   
                    if(pre != x){
                        ans.add(x);
                        ans.add(y);
                        ans.add(z);
                        pre = z;
                    }
                    else if(pre!=y){
                        ans.add(y);
                        ans.add(x);
                        ans.add(z);
                        pre = z;
                    }
                    else{
                        ans.add(z);
                        ans.add(x);
                        ans.add(y);
                        pre = y;
                    }
                }
                
                for(int i=0;i<n;i++){
                    w.print(ans.get(i)+" ");
                }
                w.println("");
            }
            w.flush();
            w.close();
        }
        
    
        

        
    }

