#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <algorithm>
#include <numeric>
#include <functional>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
using namespace std;

typedef istringstream ISS;
typedef ostringstream OSS;
typedef vector<string> VS;
typedef int INT;
typedef vector<INT> VI;
typedef vector<VI> VVI;
typedef pair <INT, INT> II;
typedef vector <II> VII;

template<class T> ostream& operator << ( ostream& os, vector<T> v ) {
    for ( typename vector<T>::iterator it_i = v.begin(); it_i != v.end(); ++it_i ) {
        os << *it_i << ", ";
    }
    return os;
}


const int SIZE = 11;
const int MSIZE = 101;

int w, h;
int s;
int X[SIZE], Y[SIZE];
int t;
int PT[SIZE], QT[SIZE];
int T[MSIZE][MSIZE];
int Tcopy[MSIZE][MSIZE]; 

const int DSIZE = 6;
const int dr[2][DSIZE] = {
    { 1, 1, 0, 0, -1, -1 },
    { 1, 1, 0, 0, -1, -1 }
};
const int dc[2][DSIZE] = {
    { -1, 0, -1, 1, -1, 0 },
    { 0, 1, -1, 1, 0, 1 }
};

void init() {
    for ( int i = 0; i < MSIZE; ++ i ) {
        for ( int j = 0; j < MSIZE; ++ j ) {
            T[i][j] = INT_MAX;
        }
    }
}

void save() {
    for ( int i = 0; i < MSIZE; ++ i ) {
        for ( int j = 0; j < MSIZE; ++ j ) {
            Tcopy[i][j] = T[i][j];
        }
    }
}

void load() {
    for ( int i = 0; i < MSIZE; ++ i ) {
        for ( int j = 0; j < MSIZE; ++ j ) {
            T[i][j] = Tcopy[i][j];
        }
    }
}

typedef II NODE;
typedef queue <NODE> QUEUE;

bool isValidPos( int r, int c ) {
    return r >= 0 && r < h && c >= 0 && c < w;
}

int spread( int sr, int sc ) {
    QUEUE Q;
    Q.push( II( sr, sc ) );
    T[sr][sc] = 0;
    
    int res = 1;
    while ( ! Q.empty() ) {
        NODE node = Q.front();
        Q.pop();

        int r = node.first;
        int c = node.second;
        int d = r % 2;

        for ( int i = 0; i < DSIZE; ++ i ) {
            int nr = r + dr[d][i];
            int nc = c + dc[d][i];
            if ( ! isValidPos( nr, nc ) ) continue;
            if ( T[r][c] + 1 >= T[nr][nc] ) continue;
            T[nr][nc] = T[r][c] + 1;
            res ++;
            NODE next( nr, nc );
            Q.push( next );
        }
    }
    return res;
}

void solve() {
    init();
    for ( int i = 0; i < s; ++ i ) {
        spread( Y[i], X[i] );
    }
    save();
    int res = 0;
    for ( int i = 0; i < t; ++ i ) {
        load();
        res = max( res, spread( QT[i], PT[i] ) );
    }
    cout << res << endl;
    return;
}

void input() {
    cin >> s;
    for ( int i = 0; i < s; ++ i ) {
        cin >> X[i] >> Y[i];
        X[i] -= 1;
        Y[i] -= 1;
    }
    cin >> t;
    for ( int i = 0; i < t; ++ i ) {
        cin >> PT[i] >> QT[i];
        PT[i] -= 1;
        QT[i] -= 1;
    }
}

int main() {
    while ( cin >> w >> h ) {
        if ( w == 0 && h == 0 ) break;
        input();
        solve();
    }
    return 0;
}