#define _USE_MATH_DEFINES
#include  <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include <string>
#include<math.h>
#include<iomanip>
#include<stdio.h>
#include <stdlib.h>
#include<stdio.h>
#include <queue>
#include<map>
#include <fstream>
#include <sstream>
#include<set>
#include<stack>
#include<time.h>
#include <sys/types.h>
#include <tuple>
#include <numeric>
#include <iterator>
#include <atcoder/all>

#include <bits/stdc++.h>
// 128bit整数を扱うための型


#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace atcoder;
using namespace std;
typedef long long int ll;
typedef unsigned long long ull;
typedef modint1000000007 mint;




ll gcd(ll a, ll b) {
    if (a < b)swap(a, b);
    if (b == 0)return a;

    return gcd(b, a % b);
}
int lcm(int a, int b) {
    return a * b / gcd(a, b);
}

/*
解説動画参考
解説ブログ参考


*/
long long integer_sqrt(ll n) {
    if (n < 0) return -1;
    if (n == 0) return 0;
    long long res = sqrt((double)n);
    // 精度補正
    while ((ll)(res + 1) * (res + 1) <= n) res++;
    while ((ll)res * res > n) res--;
    return res;
}



struct UnionFind {
    std::vector<int> parent; // 親の番号（自身が根の場合は負の数でグループサイズを表す）
    //vector<int> black_count;
    vector<int>fill;
    // 初期化: 最初は全員が根（サイズ1なので -1 で初期化）
    //UnionFind(int n) : parent(n, -1) {}
    
    UnionFind(int n) {
        parent.assign(n + 1, -1);
        //black_count.assign(n + 1, 0);
        fill.assign(n + 1, 0);
    }
    
    // Find: 根を探す（経路圧縮付き）
    int find(int x) {
        if (parent[x] < 0) return x; // 負の数なら自分が根
        return parent[x] = find(parent[x]); // 経路圧縮：親を根に直接つなぎ替える
    }

    // Union: グループを合体させる（サイズによる併合）
    bool unite(int x, int y) {
        x = find(x);
        y = find(y);
        if (x == y) return false; // すでに同じグループ

        // 大きい方（サイズが負で値が小さい方）に小さい方をくっつける
        if (parent[x] > parent[y]) std::swap(x, y);
        parent[x] += parent[y]; // サイズを合算
        parent[y] = x;          // yの親をxにする

        //black_count[x] += black_count[y];

        return true;
    }

    // 同じグループに属しているか判定
    bool same(int x, int y) {
        return find(x) == find(y);
    }

    // グループのサイズを返す
    int size(int x) {
        return -parent[find(x)];

    }
    void fill_sl(int x) {
        int r = find(x);
        fill[r]++;
    }
    int get_count(int x) {
        return fill[find(x)];
    }

/*
    void update_color(int v, int diff) {
        int r = find(v);
        black_count[r] += diff;
    }
    int get_black_count(int v) {
        int r = find(v);
        return black_count[r];
    }
    */
};
ll calc_score(vector<int>v) {
    ll sc = 0;
    for (int i = 1; i <= 9;i++) {
        ll p = i;
        for (int j = 0; j < v[i]; j++)p *= 10;
        sc += p;
    }
    return sc;
}



int main()
{

    int Q;
    Q = 1;
    //cin >> Q;


    while (Q--) {
        int nw;
        cin >> nw;
        vector<int>w(nw);
        for (int i = 0; i < nw; i++)cin >> w[i];
        int nb;
        cin >> nb;
        vector<int>b(nb);
        for (int i = 0; i < nb; i++)cin >> b[i];
        sort(w.begin(), w.end());
        sort(b.begin(), b.end());
        int ans = 0;
        
        int cnt = 0, c = 0;
        for (int i = 0; i < nw; i++) {
            if (cnt%2==0&&c < w[i]) {
                c = w[i]; cnt++;
            }
            if (cnt % 2) {
                for (int j = 0; j < nb; j++) {
                    if (c < b[j]) {
                        c = b[j]; cnt++;
                        break;
                    }
                }
            }
            //cout << cnt << " " << c << endl;
        }
        ans = cnt;
        cnt = 0; c = 0;
        for (int i = 0; i < nb; i++) {
            if (cnt % 2 == 0 && c < b[i]) {
                c = b[i]; cnt++;
            }
            if (cnt % 2) {
                for (int j = 0; j < nw; j++) {
                    if (c < w[j]) {
                        c = w[j]; cnt++;
                        break;
                    }
                }
            }
        }

        cout << max(cnt, ans)<<endl;

    }

    return 0;
}