#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
 
const int MAXN = 10;
const int MAXM = 25;
const int MAXP = 250 * MAXN + 1;
int n, m, i, j, k, K, L, posx, posy;
int nr[MAXM], tmp0, NR;
struct spct { int x, y; } rob[MAXN], pol[MAXM][MAXP], tmp[MAXP], pct[MAXP];
int skip[MAXP];
int st[MAXP], used[MAXP];
float dst[MAXP];
int par[MAXP];
 
#define min(x, y) (x <= y ? x : y)
#define max(x, y) (x >= y ? x : y)
struct nod
{
    int x;
    double k;
    nod *next;
};
 
class LIST
{
    public:
    nod *top;
    void push_back(int x, double k)
    {
        nod *aux = new nod;
        aux -> x = x;
        aux -> k = k;
        aux -> next = top;
        top = aux;
    }
} con[MAXP];
 
int semn(spct a, spct b, spct c)
{
    int A = a.y - b.y, B = b.x - a.x, C = a.x * b.y - b.x * a.y;
    int tmp = A * c.x + B * c.y + C;
    if (tmp < 0) return -1;
    if (tmp == 0) return 0;
    return 1;
}
 
int cmp(struct spct a, struct spct b)
{
    if (a.y == b.y)
        return a.x < b.x;
    else
        return a.y < b.y;
}
 
void convexhull(spct x[], int n)
{
    sort(x, x + n + 1, cmp);
    memset(used, 0, sizeof(used));
    st[0] = 1; st[1] = 0;
    int p = 1, i;
    for (i = 1; i >= 0; i += p = (i == n ? -p : p))
        if (!used[i] && (x[i - 1].x != x[i].x || x[i - 1].y != x[i].y))
        {
            while (st[0] >= 2 && semn(x[st[st[0] - 1]], x[st[st[0]]], x[i]) < 0)
                used[ st[ st[0]-- ] ] = 0;
            used[ st[ ++st[0] ] = i ] = 1;
        }
}
 
void nofitpolygon(int K)
{
    int i, j;
    tmp0 = -1;
    for (i = 0; i < nr[K]; i++)
        for (j = 0; j < n; j++)
        {
            tmp[++tmp0].x = pol[K][i].x + (posx - rob[j].x);
            tmp[tmp0].y = pol[K][i].y + (posy - rob[j].y);
        }
 
    convexhull(tmp, tmp0);
 
    pol[K][nr[K] = 0] = tmp[st[1]];
    pct[++NR] = tmp[st[1]];
    for (i = 2; i < st[0]; i++)
    {
        while (i + 1 <= st[0] && semn(pol[K][nr[K]], tmp[st[i]], tmp[st[i + 1]]) == 0) i++;
        if (i >= st[0]) continue;
        pol[K][++nr[K]] = tmp[st[i]];
        pct[++NR] = tmp[st[i]];
    }
    pol[K][++nr[K]] = pol[K][0];
}
 
void dijkstra()
{
    int i, j, min;
    nod *p;
    for (i = 0; i <= NR; i++)
        dst[i] = 1000000000;
    memset(used, 0, sizeof(used));
    dst[0] = 0;
    i = 0;
    while (i != NR)
    {
        used[i] = 1;
        for (p = con[i].top; p; p = p -> next)
        {
            if (dst[p -> x] > dst[i] + p -> k)
            {
                dst[p -> x] = dst[i] + p -> k;
                par[p -> x] = i;
            }
        }
        min = 0;
        while (dst[min] == 0 || used[min] == 1) min++;
        for (j = 1; j <= NR; j++)
            if (!used[j] && dst[j] < dst[min])
                min = j;
        i = min;
    }
}
 
int inBetween(spct a, spct b, spct c)
{
    if (a.x != b.x)             /* not vertical */
        return (((a.x < c.x) && (c.x < b.x))
                || ((b.x < c.x) && (c.x < a.x)));
    else
        return (((a.y < c.y) && (c.y < b.y))
                || ((b.y < c.y) && (c.y < a.y)));
}
 
int intersect(spct a, spct b, spct c, spct d)
{
    int a_abc, a_abd, a_cda, a_cdb;
  
    a_abc = semn(a, b, c);
    if ((a_abc == 0) && inBetween(a, b, c))
        return 1;
    a_abd = semn(a, b, d);
    if ((a_abd == 0) && inBetween(a, b, d))
        return 1;
    a_cda = semn(c, d, a);
    a_cdb = semn(c, d, b);
 
    return (((a_abc * a_abd) < 0) && ((a_cda * a_cdb) < 0));
}
 
int isin(spct k, spct x[], int n)
{
    int i, c = 0;
    for (i = 0; i < n; i++)
        if (semn(x[i], x[i + 1], k) == 0 && ((x[i].x <= k.x && k.x <= x[i + 1].x) || (x[i].x >= k.x && k.x >= x[i + 1].x)))
            return 0;
    for (i = 0; i < n; i++)
    {
        if ((((x[i].y <= k.y) && (k.y < x[i + 1].y)) ||
             ((x[i + 1].y <= k.y) && (k.y < x[i].y))) &&
            (k.x < ((float)x[i + 1].x - x[i].x) * ((float)k.y - x[i].y) / ((float)x[i + 1].y - x[i].y) + x[i].x))
            c = !c;
    }
    return c;
}
 
int main()
{
    freopen("robot.in", "rt", stdin);
    freopen("robot.out", "wt", stdout);
    scanf("%d", &n);
    posx = posy = 2147000000;
    for (i = 0; i < n; i++)
    {
        scanf("%d %d", &rob[i].x, &rob[i].y);
        rob[i].x += 5000; rob[i].y += 5000;
        if (rob[i].x < posx) posx = rob[i].x;
        if (rob[i].y < posy) posy = rob[i].y;
    }
    NR = 0; pct[0].x = posx; pct[0].y = posy;
    scanf("%d", &m);
    for (i = 0; i < m; i++)
    {
        scanf("%d", &nr[i]);
        for (j = 0; j < nr[i]; j++)
        {
            scanf("%d %d", &pol[i][j].x, &pol[i][j].y);
            pol[i][j].x += 5000; pol[i][j].y += 5000;
        }
        nofitpolygon(i);
    }
    for (i = 1; i <= NR; i++)
        for (j = 0; j < m && !skip[i]; j++)
            if (isin(pct[i], pol[j], nr[j]))
                skip[i] = 1;
    NR++;
    scanf("%d %d", &pct[NR].x, &pct[NR].y);
    pct[NR].x += 5000; pct[NR].y += 5000;
    double fx; int bol;
    for (i = 0; i <= NR; i++)
        if (!skip[i])
        for (j = i + 1; j <= NR; j++)
        if (!skip[j])
        {
            bol = 1;
            for (k = 0; k < m && bol; k++)
            for (K = 0; K < nr[k] - 1 && bol; K++)
                for (L = K + 1; L < nr[k] && bol; L++)
                    if (intersect(pct[i], pct[j], pol[k][K], pol[k][L]))
                        bol = 0;
            if (bol)
            {
                fx = sqrt((double)((pct[i].x - pct[j].x) * (pct[i].x - pct[j].x) + (pct[i].y - pct[j].y) * (pct[i].y - pct[j].y)));
                con[i].push_back(j, fx);
                con[j].push_back(i, fx);
            }
        }
    dijkstra();
    if (dst[NR] == 1000000000)
        printf("-1\n");
    else
        printf("%.2f\n", dst[NR]);
    return 0;
}