Vasya has got n books, numbered from 1 to n, arranged in a stack. The topmost book has number a_1, the next one — a_2, and so on. The book at the bottom of the stack has number a_n. All numbers are distinct.

Vasya wants to move all the books to his backpack in n steps. During i-th step he wants to move the book number b_i into his backpack. If the book with number b_i is in the stack, he takes this book and all the books above the book b_i, and puts them into the backpack; otherwise he does nothing and begins the next step. For example, if books are arranged in the order [1, 2, 3] (book 1 is the topmost), and Vasya moves the books in the order [2, 1, 3], then during the first step he will move two books (1 and 2), during the second step he will do nothing (since book 1 is already in the backpack), and during the third step — one book (the book number 3). Note that b_1, b_2, ..., b_n are distinct.

Help Vasya! Tell him the number of books he will put into his backpack during each step.

Input

The first line contains one integer n~(1 ≤ n ≤ 2 ⋅ 10^5) — the number of books in the stack.

The second line contains n integers a_1, a_2, ..., a_n~(1 ≤ a_i ≤ n) denoting the stack of books.

The third line contains n integers b_1, b_2, ..., b_n~(1 ≤ b_i ≤ n) denoting the steps Vasya is going to perform.

All numbers a_1 ... a_n are distinct, the same goes for b_1 ... b_n.

Output

Print n integers. The i-th of them should be equal to the number of books Vasya moves to his backpack during the i-th step.

Examples

Input

3
1 2 3
2 1 3


Output

2 0 1 


Input

5
3 1 4 2 5
4 5 1 3 2


Output

3 2 0 0 0 


Input

6
6 5 4 3 2 1
6 5 3 4 2 1


Output

1 1 2 0 1 1 

Note

The first example is described in the statement.

In the second example, during the first step Vasya will move the books [3, 1, 4]. After that only books 2 and 5 remain in the stack (2 is above 5). During the second step Vasya will take the books 2 and 5. After that the stack becomes empty, so during next steps Vasya won't move any books.
import java.util.*;
import java.awt.Point;
import java.math.*;
import java.io.*;
@SuppressWarnings("unused")
public class implementation {static long[] a;static int[] b;static int[] cc;	String g="";int c=0;int M=1000000000+7;ArrayList<Integer> list=new ArrayList<Integer>();String s;int[] size;int[] id;
int[]ab;int[] data;int mod=100000;LinkedList<Integer> queue=new LinkedList<Integer>();int dis=0;int max=0;ArrayList<Integer>[] arr;
	public static void main(String[] args)  {
                new implementation().solve();
                                  }
	static long sq=0;
	static long dq=0;
	static long sum=0;
	static long gum=0; 
	static int n=0;
	long[] fact;long[] inv;
            public void solve(){
            	
            	int n=sc.nextInt();cc=new int[n+1];
            	b=new int[n];
            	for(int i=0;i<n;i++) {int v=sc.nextInt();
            		b[i]=v;
            		cc[v]=i+1;}
            	for(int i=0;i<n;i++) {
            		list.add(sc.nextInt());
            	}
            	int max=0;
            	for(int i=0;i<list.size();i++) {
            		if(max<cc[list.get(i)]) {
            			System.out.print(cc[list.get(i)]-max+" ");
            			max=cc[list.get(i)];
            		}
            		else
            			System.out.print(0+" ");
            	}
            	
          }
           static int binarySearch(int low,int high,int key)
            {
               while(low<=high)
               {
                 int mid=(low+high)/2;
                 if(cc[mid]<key)
                 {
                     low=mid+1;
                 }
                 else if(cc[mid]>key)
                 {
                     high=mid-1;
                 }
                 else
                 {
                     return mid;
                 }
               }
               return -1;                //key not found
             }
            static int lower_bound(int start,int end,int item,long []a)
            {start-=1;
                while((start+1)!=end)
                {
                    int mid=(start+end)/2;
                    if(a[mid]==item) {
                        start=mid;break;}
                    else if(a[mid]>item) {
                    	
                    }
                }
                return start;
            }
            static long upper_bound(long start,long end,long item)
            {long vc=0;
            if(start==0)
            	vc=0;
            else
            	vc=a[(int)start-1];
                while((start+1)!=end)
                {
                    long mid=(start+end)/2;
                    if(a[(int) mid]-vc<=item) {
                    	start=mid;
                    }
                    else
                    	end=mid;
                    
                }
                return end;
            }
            
            static long  furious(long arg) {
            	
            	long jj=-((n-1)*arg*arg+n*(sq-arg*arg)-sum*sum-2*(sum-arg)*arg);
            	return jj;
            	
            }
            static long  furious2(long arg) {
            	
            	long jj=-((n-1)*arg*arg+n*(dq-arg*arg)-gum*gum-2*(gum-arg)*arg);
            	return jj;
            	
            }
            static int ternarysearch(int lo,int hi) {
            	
            while(lo < hi) {
                int mid = (lo + hi) >> 1;
                if(furious(mid) > furious(mid+1)) {
                    hi = mid;
                }
                else {
                    lo = mid+1;
                }
            }
            return lo;
            }
            static int ternarysearch2(int lo,int hi) {
            	
                while(lo < hi) {
                    int mid = (lo + hi) >> 1;
                    if(furious2(mid) > furious2(mid+1)) {
                        hi = mid;
                    }
                    else {
                        lo = mid+1;
                    }
                }
                return lo;
                }
         /*  static final int MAXN = 15000000+1; 
            
            // stores smallest prime factor for every number 
            static int spf[] = new int[MAXN]; 
               
            // Calculating SPF (Smallest Prime Factor) for every 
            // number till MAXN. 
            // Time Complexity : O(nloglogn) 
          
            static void sieve() 
            { 
                spf[1] = 1; 
                for (int i=2; i<MAXN; i++) 
               
                    // marking smallest prime factor for every 
                    // number to be itself. 
                    spf[i] = i; 
               
                // separately marking spf for every even 
                // number as 2 
                for (int i=4; i<MAXN; i+=2) 
                    spf[i] = 2; 
               
                for (int i=3; i*i<MAXN; i++) 
                { 
                    // checking if i is prime 
                    if (spf[i] == i) 
                    { 
                        // marking SPF for all numbers divisible by i 
                        for (int j=i*i; j<MAXN; j+=i) 
               
                            // marking spf[j] if it is not  
                            // previously marked 
                            if (spf[j]==j) 
                                spf[j] = i; 
                    } 
                } 
            } 
            
            static int gcd(int a, int b) 
            { 
              if (b == 0) 
                return a; 
              return gcd(b, a % b);  
            }     
            
            
            public class Node{
       	     int x;int color;int y;
       	       Node par;
       	        public Node(int a,int b) {
       	          	x=a;color=b;
       		
       	             }
                         }
                     class sortbyweight implements Comparator<Integer>{
 
       				
 
					@Override
					public int compare(Integer a, Integer b) {
						
       					if(a<b)
                			return -1;
                		else 
                			return 1;
					}}*/
       				
       				 FastReader sc=new FastReader();
       				 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;
       				         }
       				     }}