#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;     
}