#include <bits/stdc++.h>
using namespace std;


double x[1000],y[1000];
double dist(int a,int b)
{
    return sqrt((x[a]-x[b])*(x[a]-x[b])+(y[a]-y[b])*(y[a]-y[b]));
}
bool a[1000][1000];
double dp[1000][1000][2];
int main()
{

    int t;
    cin>>t;

    while(t--)
    {
        int n;
        cin>>n;
        for(int i=1; i<=n; i++)
        {
            cin>>x[i]>>y[i];
            x[i+n]=x[i];
            y[i+n]=y[i];
        }
        for(int i=1; i<=2*n; i++)
        {
            for(int j=1; j<=2*n; j++)
            {
                a[i][j]=0;
                 dp[i][j][0]=dp[i][j][1]=0;
            }
        }
        int m;
        cin>>m;
        double ans=0;
        for(int i=1; i<=m; i++)
        {
            int xx,yy;
            cin>>xx>>yy;
            a[xx][yy]=1;
            a[yy][xx]=1;
            
            a[xx+n][yy]=1;
            a[yy][xx+n]=1;
            
            a[xx][yy+n]=1;
            a[yy+n][xx]=1;
            
            a[xx+n][yy+n]=1;
            a[yy+n][xx+n]=1;

            dp[xx][yy][0]=dp[yy][xx][0]=dp[xx+n][yy][0]=dp[yy][xx+n][0]=dp[xx][yy+n][0]=dp[yy+n][xx][0]=dp[yy+n][xx+n][0]=dp[xx+n][yy+n][0]=dist(xx,yy);
            dp[xx][yy][1]=dp[yy][xx][1]=dp[xx+n][yy][1]=dp[yy][xx+n][1]=dp[xx][yy+n][1]=dp[yy+n][xx][1]=dp[yy+n][xx+n][1]=dp[xx+n][yy+n][1]=dist(xx,yy);
            ans=max(ans,dist(xx,yy));
        }

        for(int len=n; len>=2; len--)
        {
            for(int l=1; l+len-1<=2*n; l++)
            {
                int r=l+len-1;
                for(int j=l+1; j<r; j++)
                {
                    if(a[l][j])
                    {
                        dp[l][j][1]=max(dp[l][j][1],dp[l][r][0]+dist(l,j));

                        dp[j][r][0]=max(dp[j][r][0],dp[l][r][0]+dist(l,j));
                        ans=max(ans,dp[l][j][1]);
                        ans=max(ans,dp[j][r][0]);
                    }

                    if(a[r][j])
                    {

                        dp[j][r][0]=max(dp[j][r][0],dp[l][r][1]+dist(r,j));
                        dp[l][j][1]=max(dp[l][j][1],dp[l][r][1]+dist(r,j));
                        ans=max(ans,dp[l][j][1]);
                        ans=max(ans,dp[j][r][0]);

                    }


                }
            }
        }

        cout<<fixed<<setprecision(9)<<ans<<endl;
    }
    return 0;
}