human
Give me a Python code to find the number of cars that must be fined given the following:
Consider a tunnel on a one-way road. During a particular day, n cars numbered from 1 to n entered and exited the tunnel exactly once. All the cars passed through the tunnel at constant speeds.

A traffic enforcement camera is mounted at the tunnel entrance. Another traffic enforcement camera is mounted at the tunnel exit. Perfectly balanced.

Thanks to the cameras, the order in which the cars entered and exited the tunnel is known. No two cars entered or exited at the same time.

Traffic regulations prohibit overtaking inside the tunnel. If car i overtakes any other car j inside the tunnel, car i must be fined. However, each car can be fined at most once.

Formally, let's say that car i definitely overtook car j if car i entered the tunnel later than car j and exited the tunnel earlier than car j. Then, car i must be fined if and only if it definitely overtook at least one other car.

Find the number of cars that must be fined. 

Input

The first line contains a single integer n (2 ≤ n ≤ 10^5), denoting the number of cars.

The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n), denoting the ids of cars in order of entering the tunnel. All a_i are pairwise distinct.

The third line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ n), denoting the ids of cars in order of exiting the tunnel. All b_i are pairwise distinct.

Output

Output the number of cars to be fined.

Examples

Input

5
3 5 2 1 4
4 3 2 5 1

Output

2

Input

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

Output

6

Input

2
1 2
1 2

Output

0

Note

The first example is depicted below:


Car 2 definitely overtook car 5, while car 4 definitely overtook cars 1, 2, 3 and 5. Cars 2 and 4 must be fined.

In the second example car 5 was definitely overtaken by all other cars.

In the third example no car must be fined.
assistant
#Here is Python code to find the number of cars that must be fined.

from __future__ import division, print_function
import bisect
import math
import itertools
import sys
from atexit import register
 
if sys.version_info[0] < 3:
    from io import BytesIO as stream
else:
    from io import StringIO as stream
 
 
if sys.version_info[0] < 3:
    class dict(dict):
        """dict() -> new empty dictionary"""
        def items(self):
            """D.items() -> a set-like object providing a view on D's items"""
            return dict.iteritems(self)
 
        def keys(self):
            """D.keys() -> a set-like object providing a view on D's keys"""
            return dict.iterkeys(self)
 
        def values(self):
            """D.values() -> an object providing a view on D's values"""
            return dict.itervalues(self)
 
    input = raw_input
    range = xrange
 
    filter = itertools.ifilter
    map = itertools.imap
    zip = itertools.izip
 
 
def sync_with_stdio(sync=True):
    """Set whether the standard Python streams are allowed to buffer their I/O.
 
    Args:
        sync (bool, optional): The new synchronization setting.
 
    """
    global input, flush
 
    if sync:
        flush = sys.stdout.flush
    else:
        sys.stdin = stream(sys.stdin.read())
        input = lambda: sys.stdin.readline().rstrip('\r\n')
 
        sys.stdout = stream()
        register(lambda: sys.__stdout__.write(sys.stdout.getvalue()))
 
def main():
    
    
    n=int(input()) 
    #ans=[]
    #n,k=map(int, input().split())
    a=list(map(int, input().split()))
    b=list(map(int, input().split()))
    ans=0
    l=[0]*n
    c=[0]*n
    k=-1
    for i in range(n):
        c[b[i]-1]=i
    for i in range(n):
        if c[a[i]-1]>=k:
            l[b[c[i]-1]-1]=-1
            for j in range(c[a[i]-1]-1,k,-1):
                l[b[j]-1]=-1
                ans+=1
            k=c[a[i]-1]
        else:
            continue
        if ans==n-1:
            break
        #print(l)
    print(ans)       
if __name__ == '__main__':
    sync_with_stdio(False)
    main()