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