You have a card deck of n cards, numbered from top to bottom, i. e. the top card has index 1 and bottom card — index n. Each card has its color: the i-th card has color a_i.

You should process q queries. The j-th query is described by integer t_j. For each query you should: 

  * find the highest card in the deck with color t_j, i. e. the card with minimum index; 
  * print the position of the card you found; 
  * take the card and place it on top of the deck. 

Input

The first line contains two integers n and q (2 ≤ n ≤ 3 ⋅ 10^5; 1 ≤ q ≤ 3 ⋅ 10^5) — the number of cards in the deck and the number of queries.

The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 50) — the colors of cards.

The third line contains q integers t_1, t_2, ..., t_q (1 ≤ t_j ≤ 50) — the query colors. It's guaranteed that queries ask only colors that are present in the deck.

Output

Print q integers — the answers for each query.

Example

Input


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


Output


5 2 3 1 5 

Note

Description of the sample: 

  1. the deck is [2, 1, 1, 4, \underline{3}, 3, 1] and the first card with color t_1 = 3 has position 5; 
  2. the deck is [3, \underline{2}, 1, 1, 4, 3, 1] and the first card with color t_2 = 2 has position 2; 
  3. the deck is [2, 3, \underline{1}, 1, 4, 3, 1] and the first card with color t_3 = 1 has position 3; 
  4. the deck is [\underline{1}, 2, 3, 1, 4, 3, 1] and the first card with color t_4 = 1 has position 1; 
  5. the deck is [1, 2, 3, 1, \underline{4}, 3, 1] and the first card with color t_5 = 4 has position 5. 

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.util.*;


import java.math.*;
import java.io.*;
import java.text.*;
import java.math.BigInteger;
public class Main {

	static class pair{
		int x;
		int y;
		public pair(int a,int b) {
			this.x=a;
			this.y=b;
		}
	}
	 public static boolean[] sieve(long n)
	    {
	        boolean[] prime = new boolean[(int)n+1];
	        Arrays.fill(prime,true);
	        prime[0] = false;
	        prime[1] = false;
	        long m = (long)Math.sqrt(n);
	        for(int i=2;i<=m;i++)
	        {
	            if(prime[i])
	            {
	                for(int k=i*i;k<=n;k+=i)
	                {
	                    prime[k] = false;
	                }
	            }
	        }
	        return prime;
	    } 
	 
	 public static boolean[] primeseive(long n) {
		 boolean prime[]=new boolean[(int)n+1];
		 
		 Arrays.fill(prime, true);
		 
		 prime[0]=false;
		 prime[1]=false;
		 
		 int m=(int) Math.sqrt(n);
		 
		 for(int i=2;i<m;i++) {
			 if(prime[i]) {
				 
				 for(int k=i*i;k<=n;k+=i) {
					 prime[k]=false;
				 }
			 }
		 }
		 
		 return prime;
	 }
	 
	    
	    static long GCD(long a,long b)
	    {
	        if(b==0)
	        {
	            return a;
	        }
	        return GCD(b,a%b);
	    }
	 
	    
	    
	    static long gcdnik(long a,long b)
	    {
	        if(b==0)
	        {
	            return a;
	        }
	        return GCD(b,a%b);
	    }
	    
	    
	    static long CountCoPrimes(long n)
	    {
	        long res = n;
	        for(int i=2;i*i<=n;i++)
	        {
	            if(n%i==0)
	            {
	                while(n%i==0)
	                {
	                    n/=i;
	                }
	                res-=res/i;
	            }
	        }
	        if(n>1)
	        {
	            res-=res/n;
	        }
	        return res;
	    }
	 
	 
	    
	 
	    
	 
	    static boolean prime(int n)
	    {
	        for(int i=2;i*i<=n;i++)
	        {
	            if(i%2==0 ||i%3==0)
	            {
	                return false;
	            }
	        }
	        return true;
	    }
   static String userIdGeneration(String input1,String input2,int input3,int input4) {
	    	if(input1.length()==input2.length()) {
	    		String arr[]=new String[2];
	    		
	    		arr[0]=input1;
	    		arr[1]=input2;
	    		
	    		Arrays.sort(arr);
	    	char c=arr[0].charAt(0);
	    	   String output=c+arr[1];
	    		
	    	   String k=Integer.toString(input3);
	    	
	    	char d=k.charAt(input4-1);
	    	
	    	output+=d;
	    		
	    	char e=k.charAt(k.length()-input4);
	    	output+=e;
	    	String res="";
	    	for(int i=0;i<output.length();i++) {
	    		if(Character.isUpperCase(output.charAt(i))){
	    			res+=Character.toLowerCase(output.charAt(i));
	    		}
	    		else {
	    			res+=Character.toUpperCase(output.charAt(i));
	    		}
	      	}
	    	return res;
	    	}
	    	
	    	
	    	else  {
String arr[]=new String[2];
	    		arr[0]=input1.length()>input2.length()?input2:input1;
	    		arr[1]=input1.length()>input2.length()?input1:input2;
	    		
	    		char c=arr[0].charAt(0);
	    		
	    		String output=c+arr[1];
	    		
	    	String k=Integer.toString(input3);
	    	
	    	char d=k.charAt(input4-1);
	    	
	    	output+=d;
	    		
	    	char e=k.charAt(k.length()-input4);
	    	output+=e;
	    	String res="";
	    	for(int i=0;i<output.length();i++) {
	    		if(Character.isUpperCase(output.charAt(i))){
	    			res+=Character.toLowerCase(output.charAt(i));
	    		}
	    		else {
	    			res+=Character.toUpperCase(output.charAt(i));
	    		}
	    	}
	    return res;
	    	}
	    	
	    }
	static int length(int len) {
		
		if(len==1) {
			return 1;
		}
		else if(len==2) {
			return 3;
		}
		else if(len==3) {
			return 6;
		}
		else if(len==4) {
			return 10;
		}
		return 0;
	}
	
	
public static int LargestFour(int arr[]) {
	Arrays.sort(arr);

	int n=arr.length;
	int count=0;
	int sum=0;
	for(int i=n-1;i>=1;i--) {
		sum+=arr[i];
	
			count++;
			if(count==4) {
				break;
			
		}
		
	}
	
	if(count<4) {
		sum+=arr[0];
	}
	
	return sum;
}
//Nikunj Gupta
public static void insertionSort(int array[]) {  
    int n = array.length;  
    for (int j = 1; j < n; j++) {  
        int key = array[j];  
        int i = j-1;  
        while ( (i > -1) && ( array [i] > key ) ) {  
            array [i+1] = array [i];  
            i--;  
        }  
        array[i+1] = key;  
    }  
} 



  static String solve23(int n) {
int k=0;
while(true) {
	if(n-2020*k<0) {
		return "NO";
	}
	if((n-2020*k)%2021==0) {
		return "YES";
	}
	k++;
}
	  
	
	}
	
	
	
	










 static void solve(int n,int k) {
	
	
if(n==1) {
	System.out.println(0);
	return;
}
			int p=(k+1)/2;
			
			System.out.println((k-p)+(n-k));
			
			for(int j=p;j<k;j++) {
				System.out.print(j+" ");
		}
			for(int j=k+1;j<=n;j++) {
				System.out.print(j+" ");
			}
			
			System.out.println();
		}
		
		
	
		

static int row[]= {1,0};
static int col[]= {0,1};
static ArrayList<String>l=new ArrayList<>();
public static void main(String[] args) throws IOException{
	
	 Scanner s=new Scanner(System.in);
	
//int op=s.nextInt();

	long mod=1000000007;

HashMap<Integer,Integer>hm=new HashMap<>();
      int n=s.nextInt();
	 int k=s.nextInt();
	 
	 int arr[]=new int[n];
	 
	 int q[]=new int[k];

	    
 
	 for(int i=0;i<n;i++) {

		 arr[i]=s.nextInt();
		 if(!hm.containsKey(arr[i])) {
			 hm.put(arr[i], i+1);
		 }
	 }
	 
	 for(int j=0;j<k;j++) {
		 q[j]=s.nextInt();
	 }
		
   
   for(int j=0;j<k;j++) {
	   int val=q[j];
	   int indx=hm.get(val);
	   System.out.print(indx+" ");
	   for(Map.Entry<Integer,Integer>e:hm.entrySet()) {
		   int key=e.getKey();
		   int val1=e.getValue();
		   
	if(val1<indx) {
		hm.put(key, val1+1);
	}
		   
		   
	   }
	   hm.put(val,1);
	
   }
	 
	 
    System.out.println();
    
	
	    
	   }
	    	  
	    		  
	    		  
	    		  
	    	  
	    			  
	      

     
	
	
	     
	       
	       
	       
	      
			
	
	
	
	
 


	


 
 
  
    
   
 private static void printsubsequences(String c, String st) {
	// TODO Auto-generated method stub
	
	 
	 if(c.length()==0) {
		 System.out.println(st);
		 return;
	 }
	 
	 
	 printsubsequences(c.substring(1),st+c.charAt(0));
	 printsubsequences(c.substring(1),st);
	 
	 
}

private static boolean compare(HashMap<Character, Integer> smap, HashMap<Character, Integer> pmap) {
		// TODO Auto-generated method stub
	 
	 for(char ch:smap.keySet()) {
		 if(smap.get(ch)!=pmap.get(ch)) {
			 return false;
		 }
	 }
		return true;
	}


private static boolean BinarySearch(int search, int[] val, int n)
 {
		// TODO Auto-generated method stub
		
	 int start=0;
	 int end=val.length-1;
	 while(start<=end) {
		 int mid=(start+end)/2;
		 
		 
		 if(val[mid]==search) {
			 return true;
		 }
		 else if(val[mid]<search) {
			 start=mid+1;
		 }
		 else {
			 end=mid-1;
		 }
		 
	 }
	 return false;
	 }


	
 
 
 
 static long findGCD(ArrayList<Long> arr,long start, long n) 
	    { 
	        long result = arr.get((int)start); 
	        for (int i = (int)start+1; i < n; i++) 
	            result = GCD(arr.get(i), result); 
	  
	        return result; 
	    } 
	 
	   
	 
	   

	    static long re(long n)
	    {
	        n+=1;
	        while(n%10==0)
	        {
	            n/=10;
	        }
	        return n;
	    }
	   
	   


	    
	 
	 
	 
	 
	 
	 
	    
	 
	    //xor range query
	    static long xor(long n)
	    {
	 
	        if(n%4==0)
	        {
	            return n;
	        }
	        if(n%4==1)
	        {
	            return  1;
	        }
	        if(n%4==2)
	        {
	            return n+1;
	        }
	        return 0;
	    }
	 
	    static long xor(long a,long b)
	    {
	        return xor(b)^xor(a-1);
	    }
	 
	 
	    
	 
	  
	   
	    
	 
	    
	       
	    
	 
	    
	   
	  
	 
	 

	   
	   
	    static void swap(char c,char p)
	    {
	        char t = c;
	        c = p;
	        p = t;
	    }
	 
	    static long max(long n,long m)
	    {
	        return Math.max(n,m);
	    }
	    static long min(long n,long m)
	    {
	        return Math.min(n,m);
	    }
	 
//	    double nd() throws IOException
//	    {
//	        return Double.parseDouble(in.next());
//	    }
//	    int ni() throws IOException
//	    {
//	        return Integer.parseInt(in.next());
//	    }
//	 
//	    long nl() throws IOException
//	    {
//	        return Long.parseLong(in.next());
//	    }
//	 
//	    String si() throws IOException
//	    {
//	        return in.next();
//	    }
//	 
//	 
	  
	   
	    static int abs(int n)
	    {
	        return Math.abs(n);
	    }
	 
	    static class Scanner 
	    {
	        StringTokenizer st;
	        BufferedReader br;
	 
	        public Scanner(InputStream s){  br = new BufferedReader(new InputStreamReader(s));}
	 
	        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 String nextLine() throws IOException {return br.readLine();}
	 
	        public boolean ready() throws IOException {return br.ready();}
	 
	 
	    }
	 
	    
	}
	 
	 
	 
	class Pair implements Comparable<Pair>
	{
	   int x,y;
	    public Pair(int x,int y)
	    {
	        this.x = x;
	        this.y = y;
	    }
	    public int compareTo(Pair o)
	    {
	        return this.y-o.y;
	    }
	}

