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 Rust (judge verdict: Accepted)

use std::io::Read;

fn binary_search(s: &[i32], x: i32) -> bool {
    let mut left = 0;
    let mut right = s.len();
    while right - left > 1 {
        let mid = (left + right) / 2;
        if s[mid] <= x {
            left = mid;
        } else {
            right = mid;
        }
    }
    s[left] == x
}

fn solve(_n: usize, s: &mut [i32], _q: usize, t: &[i32]) -> usize {
    s.sort();
    t.iter().filter(|&&x| binary_search(s, x)).count()
}

fn main() {
    let mut buf = String::new();
    std::io::stdin().read_to_string(&mut buf).unwrap();
    let mut iter = buf.split_whitespace();
    let n: usize = iter.next().unwrap().parse().unwrap();
    let mut s = (0..n).map(|_| iter.next().unwrap().parse().unwrap()).collect::<Vec<_>>();
    let q: usize = iter.next().unwrap().parse().unwrap();
    let t = (0..q).map(|_| iter.next().unwrap().parse().unwrap()).collect::<Vec<_>>();
    let r = solve(n, &mut s, q, &t);
    println!("{}", r);
}