#include <cstdio>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <climits>
#include <ctime>
#include <queue>
#include <stack>
#include <algorithm>
#include <list>
#include <vector>
#include <set>
#include <map>
#include <iostream>
#include <deque>
#include <complex>
#include <string>
#include <iomanip>
#include <sstream>
#include <bitset>
#include <assert.h>
#include <iterator>
using namespace std;
typedef long long int ll;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;

#define REP(i,x) for(int i=0;i<(int)(x);i++)
#define REPS(i,x) for(int i=1;i<=(int)(x);i++)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();i++)
#define RREP(i,x) for(int i=((int)(x)-1);i>=0;i--)
#define RFOR(i,c) for(__typeof((c).rbegin())i=(c).rbegin();i!=(c).rend();i++)
#define ALL(container) container.begin(), container.end()
#define RALL(container) container.rbegin(), container.rend()
#define SZ(container) ((int)container.size())
#define mp(a,b) make_pair(a, b)
#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );

template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
template<class T> ostream& operator<<(ostream &os, const vector<T> &t) {
os<<"["; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"]"; return os;
}
template<class T> ostream& operator<<(ostream &os, const set<T> &t) {
os<<"{"; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"}"; return os;
}
template<class S, class T> ostream& operator<<(ostream &os, const pair<S,T> &t) { return os<<"("<<t.first<<","<<t.second<<")";}
template<class S, class T> pair<S,T> operator+(const pair<S,T> &s, const pair<S,T> &t){ return pair<S,T>(s.first+t.first, s.second+t.second);}
template<class S, class T> pair<S,T> operator-(const pair<S,T> &s, const pair<S,T> &t){ return pair<S,T>(s.first-t.first, s.second-t.second);}

const int INF = 1<<28;
const double EPS = 1e-8;
const int MOD = 1000000007;

#define X first
#define Y second

#define next first
#define dir second

int d[7][2] = {{0, -1},{1, -1},{1, 0},{0, 1},{-1, 1},{-1, 0},{0, 0}};

int n, m;
pii goal;

vector<vector<pii>> Body[9];
vector<vector<pii>> g[9];

inline int abs(const pii &d){
	if((ll)d.X*d.Y < 0) return min(abs(d.X), abs(d.Y)) + abs(d.X + d.Y);
	return abs(d.X) + abs(d.Y);
}

inline int abs(const pii &p1, const pii &p2){
	return abs(p1 - p2);
}

void enumerateState(vector<pii> &p){
	Body[p.size()].push_back(p);
	if(p.size() == 8) return;
	const pii b = p.back();
	p.emplace_back();
	REP(i, 6){
		const int x = b.X + d[i][0];
		const int y = b.Y + d[i][1];
		const pii q(x, y);
		int f = 1;
		RREP(j, (int)p.size()-2){
			if(abs(p[j], q) <= 1){
				f = 0;
				break;
			}
		}
		if(!f) continue;
		p.back() = q;
		enumerateState(p);
	}
	p.pop_back();
}

void makeGraph(){
	REPS(k, 8){
		const int n = Body[k].size();
		g[k].resize(n);
		REP(i, n)REP(j, i)REP(l, 7){
			int f = 1;
			int prev = l != 6;
			for(int q=1;q<k;q++){
				pii cur = Body[k][i][q];
				cur.X -= d[l][0];
				cur.Y -= d[l][1];
				const int dist = abs(Body[k][j][q], cur);
				if(dist > 1 || (dist == 1 && prev)){
					f = 0;
					break;
				}
				prev = dist;
			}
			if(f){
				g[k][i].emplace_back(j, l);
				g[k][j].emplace_back(i, l==6 ? l : (l+3)%6);
			}
		}
	}
}

int Rock[60][60];

struct State{
	pii pos;
	int id, cost;
	State(pii pos=pii(0, 0), int id=0, int cost=0)
		:pos(pos), id(id), cost(cost){}
};

int visited[60][60][4100];

int main(){
	ios::sync_with_stdio(false);
	vector<pii> p(1, pii(0, 0));
	enumerateState(p);
	makeGraph();
	while(cin >> n, n){
		vector<pii> body(n);
		REP(i, n) cin >> body[i].X >> body[i].Y;
		pii pos = pii(30, 30);
		memset(Rock, 0, sizeof(Rock));
		memset(visited, 0, sizeof(visited));
		cin >> m;
		REP(i, m){
			pii t;
			cin >> t.X >> t.Y; t = t - body[0] + pos;
			if(abs(t, pos) > 25) continue;
			Rock[t.X][t.Y] = 1;
		}
		cin >> goal.X >> goal.Y; goal = goal - body[0] + pos;
		RREP(i, n) body[i] = body[i] - body[0];
		auto it = find(ALL(Body[n]), body);
		if(it == Body[n].end()) assert(false);
		int state = it - Body[n].begin();
		
		visited[pos.X][pos.Y][state] = 1;
		queue<State> que;
		que.emplace(pos, state, 0);
		int ans = 20;
		while(!que.empty()){
			State s = que.front();que.pop();
			if(s.pos == goal){
				ans = s.cost;
				break;
			}
			FOR(it, g[n][s.id]){
				State t = s;
				t.id = it->next;
				t.pos.X += d[it->dir][0];
				t.pos.Y += d[it->dir][1];
				t.cost ++;
				if(t.cost + abs(t.pos, goal) >= 20 || visited[t.pos.X][t.pos.Y][t.id]) continue;
				visited[t.pos.X][t.pos.Y][t.id] = 1;
				int f = 1;
				REP(i, n) if(Rock[t.pos.X+Body[n][t.id][i].X][t.pos.Y+Body[n][t.id][i].Y]){
					f = 0;
					break;
				}
				if(f){
					que.push(t);
				}
			}
		}
		cout << ans << endl;
	}
	return 0;
}

Measured memory_bytes: 61164