#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <bitset>
using namespace std;

typedef long long int64;

const int nr = 276997;
const int MAX_BITS = 1024 * 1024 * 5;
const int H_COUNT = 5;
const int MAX_H = MAX_BITS / H_COUNT;
const int H[H_COUNT] = {610733, 745477, 813227, 950179, 1019713};

class Reader {
    public:
        Reader(FILE *stream, const size_t size = (1 << 16)):
            size(size),
            pointer(0),
            stream(stream) {
                buffer = (char*) malloc(size);
                assert(fread(buffer, 1, size, this->stream) != 0);
            }

        ~Reader() {
            free(buffer);
        }

        template<typename IntType>
            IntType NextInt() {
                IntType value = 0;
                bool negative = false;
                while ((Current() < '0' || Current() > '9') && Current() != '-')
                    NextPosition();
                if (Current() == '-'){
                    negative = true;
                    NextPosition();
                }
                while (Current() >= '0' && Current() <= '9'){
                    value = value * 10 + Current() - '0';
                    NextPosition();
                }
                if (negative)
                    value = -value;
                return value;
            }

        Reader& operator>>(short &value) {
            value = NextInt<short>();
            return *this;
        }

        Reader& operator>>(int &value) {
            value = NextInt<int>();
            return *this;
        }

        Reader& operator>>(long long &value) {
            value = NextInt<long long>();
            return *this;
        }
       
    private:
        size_t size;
        size_t pointer;
        char *buffer;
        FILE *stream;

        char Current() const {
            return buffer[pointer];
        }

        void NextPosition() {
            if (++pointer == size) {
                assert(fread(buffer, 1, size, stream) != 0);
                pointer = 0;
            }
        }
};

class Hash {
    public:
        Hash() {}

        void Insert(const int64 value) {
            for (int i = 0; i < H_COUNT; ++i)
                used[i][value % H[i]] = true;
        }

        bool Search(const int64 value) const {
            for (int i = 0; i < H_COUNT; ++i)
                if (!used[i][value % H[i]])
                    return false;
            return true;
        }

    private:
        bitset<MAX_H> used[H_COUNT];
};


int main(){
    freopen("dtcsu.in", "r", stdin);
    freopen("dtcsu.out", "w", stdout);

    Reader in(stdin, 1 << 17);
    Hash hash;
    int64 value;
    int q = 0, res = 0;
    
    for (int i = 0; i < nr; ++i){
        in >> value;
        hash.Insert(value);
    }
    
    in >> q;
    while (q--){
        in >> value;
        if (!hash.Search(value))
            continue;
        value /= (value & (-value));
        while ((value / 15) * 15 == value) value /= 15;
        while ((value / 3) * 3 == value) value /= 3;
        while ((value / 5) * 5 == value) value /= 5;
        while ((value / 7) * 7 == value) value /= 7;
        while ((value / 11) * 11 == value) value /= 11;
        if (value == 1)
            ++res;
    }
    printf("%d\n", res);
    return 0;
}