
#include<iostream>
#include<vector>
#include<queue>
#include<tuple>
#include<set>
#include<climits>
#include<algorithm>
using namespace std;

const int INF = INT_MAX;

class Node {
public:
    int y, x, depth;
    Node(int y, int x, int d) :y(y), x(x), depth(d) {}
};

typedef tuple<int, int> Point;

enum {EVEN, ODD};
enum {Y, X};
const int NEXT[2][6][2] = {
    {
        {-1, -1},
        {-1, 0},
        {0, -1},
        {0, 1},
        {1, -1},
        {1, 0},
    },
    {
        {-1, 0},
        {-1, 1},
        {0, -1},
        {0, 1},
        {1, 0},
        {1, 1},
    },
};

int bfs(vector<vector<int>>& field, int y, int x, bool write) {
    int h = field.size(), w = field[0].size();
    int result = 0;
    set<Point> visited;
    queue<Node> q;
    q.push(Node(y, x, 0));
    while(!q.empty()) {
        Node current = q.front(); q.pop();
        if(visited.count(Point(current.y, current.x))) continue;
        visited.insert(Point(current.y, current.x));
        if(field[current.y][current.x] <= current.depth) continue;
        if(write) field[current.y][current.x] = current.depth;
        ++result;
        for(const auto& d: NEXT[y & 1]) {
            int ny = current.y + d[Y];
            int nx = current.x + d[X];
            if(ny < 0 || h <= ny) continue;
            if(nx < 0 || w <= nx) continue;
            q.push(Node(ny, nx, current.depth + 1));
        }
    }
    return result;
}

int main() {
    int m, n;
    int s, t;
    int x, y;
    while(cin >> m >> n, m | n) {
        vector<vector<int>> field(n, vector<int>(m, INF));
        for(cin >> s; s > 0; --s) {
            cin >> x >> y;
            bfs(field, y - 1, x - 1, true);
        }
        int answer = 0;
        for(cin >> t; t > 0; --t) {
            cin >> x >> y;
            answer = max(answer, bfs(field, y - 1, x - 1, false));
        }
        cout << answer << endl;
    }
}