import strutils, sequtils, math, sets, algorithm

#proc myzip*[S, T](seq1: seq[S], seq2: seq[T], fill: int): seq[tuple[a: S, b: T]] =
#    var (s1, s2) = (seq1, seq2)
#    if s1.len < s2.len:
#        newSeq(result, s2.len)
#        for i in 0.. <s1.len:
#            result[i] = (s1[i], s2[i])
#        for i in s1.len.. <s2.len:
#            result[i] = (fill, s2[i])
#    else:
#        newSeq(result, s1.len)
#        for i in 0.. <s2.len:
#            result[i] = (s1[i], s2[i])
#        for i in s2.len.. <s1.len:
#            result[i] = (s1[i], fill)
#
#proc myflatten*[T](seq1: seq[tuple[a: T, b: T]]): seq[T] =
#    var koko = seq1.len
#    newSeq(result, koko * 2)
#    for i in countup(0, koko, 2):
#        result[i]   = seq1[i div 2].a
#        result[i+1] = seq1[i div 2].b
#
#proc myfill*[T](seq1: seq[T], size: int, value: T) =
#    var seq1 = seq1
#    for i in seq1.len.. <size:
#        seq1.add(value)

proc sorted[T](a: var seq[T]; cmp: proc (x, y: T): int {.closure.}; order = SortOrder.Ascending): seq[T] =
    var (a, cmp, order) = (a, cmp, order)
    sort(a, cmp, order)
    return a

var
    nw = stdin.readLine.parseInt
    nanika = stdin.readLine.split.map(parseInt)
    w = newSeq[int](0)
    nb = stdin.readLine.parseInt
    doreka = stdin.readLine.split.map(parseInt)
    b = newSeq[int](0)

for e in nanika:
    w.add(e)
for e in doreka:
    b.add(e)

w = sorted(w, system.cmp[int]).reversed
b = sorted(b, system.cmp[int]).reversed

proc solve(a1: seq, a2: seq): int =
    var (a1, a2) = (a1, a2)
    result = 0
    var check = int.high
    var should1 = true
    for i in 0.. <a1.len:
        if check > a1[i] and should1:
            should1 = false
            check = a1[i]
            result += 1
        for j in 0.. <a2.len:
            if check > a2[j] and not should1:
                should1 = true
                check = a2[j]
                result += 1
                break
            
var nya = solve(w, b)
var mya = solve(b, w)

echo max(nya, mya)