Problem:
Search II

You are given a sequence of n integers S and a sequence of different q integers T. Write a program which outputs C, the number of integers in T which are also in the set S.

Input

In the first line n is given. In the second line, n integers are given. In the third line q is given. Then, in the fourth line, q integers are given.

Output

Print C in a line.

Constraints

Elements in S is sorted in ascending order

n ≤ 100000

q ≤ 50000

0 ≤ an element in S ≤ 109

0 ≤ an element in T ≤ 109

Sample Input 1

5
1 2 3 4 5
3
3 4 1

Sample Output 1

3

Sample Input 2

3
1 2 3
1
5

Sample Output 2

0

Sample Input 3

5
1 1 2 2 3
2
1 2

Sample Output 3

2

Notes

Solution in Haskell (judge verdict: Accepted)

import Control.Applicative ((<$>), (<*>))
import Data.ByteString.Char8 (ByteString)
import qualified Data.ByteString.Char8 as B
import Data.List (unfoldr, foldl')
import Data.Char (isSpace)
import Data.Vector (Vector, (!))
import qualified Data.Vector as V

main :: IO ()
main = do
  solve <$> readLn <*> f <*> (B.getLine >> f) >>= print
  where f = readiv B.readInt <$> B.getLine

solve :: Int -> Vector Int -> Vector Int -> Int
solve n ss ts = V.foldl' f 0 ts
  where f ct x | bsearch (flip compare x . (ss !)) 0 n = ct + 1
               | otherwise = ct
  

bsearch :: (Int -> Ordering) -> Int -> Int -> Bool
bsearch f l r | l >= r = False
              | otherwise = case f m of
                             GT -> bsearch f l m
                             LT -> bsearch f (m+1) r
                             EQ -> True
  where
    m = (l + r) `div` 2

readiv :: Integral a =>  (ByteString -> Maybe (a, ByteString)) -> ByteString -> Vector a
readiv f = V.unfoldr g
  where
    g s = do
      (n, s') <- f s
      return (n, B.dropWhile isSpace s')