// Original C++ solution (slower):
#include<cstdio>

#include<cstdlib>

#include<cstring>

#include<cctype>

#include<cmath>

#include<iostream>

#include<algorithm>

#include<queue>

#include<set>

#include<map>

#include<vector>

#include<stack>

#define INF 1000000000

#define M 10005

#define LL long long

using namespace std;

struct node{

    int x,y;

    double z;

};

node B[M];

vector<node>A;

int fa[M];

double dis(int x,int y){

    int dx=B[x].x-B[y].x,dy=B[x].y-B[y].y;

    return sqrt(dx*dx+dy*dy);

}

int get(int x){

    if(fa[x]==x) return x;

    else return fa[x]=get(fa[x]);

}

bool cmp(node a,node b){

    return a.z>b.z;

}

int main(){

    int n,m;

    while(scanf("%d%d",&n,&m)!=EOF){

        int j,k;

        A.clear();

        for(j=1;j<=n;j++){

            fa[j]=j;

        }

        for(j=1;j<=n;j++) scanf("%d%d",&B[j].x,&B[j].y);

        double ans=0;

        for(j=1;j<=m;j++){

            int x,y;

            scanf("%d%d",&x,&y);

            double z=dis(x,y);

            //printf("%f\n",z);

            ans+=z;

            A.push_back((node){x,y,z});

        }

        sort(A.begin(),A.end(),cmp);

        for(j=0;j<A.size();j++){

            int a=get(A[j].x),b=get(A[j].y);

            if(a!=b){

                fa[a]=b;

                ans-=A[j].z;

            }

        }

        printf("%.3f\n",ans);

    }

    return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

#include<string.h>

#include<math.h>

#include<algorithm>

using namespace std;

#define N 10000+10

int per[N];

struct Point

{

	double x,y;

}p[N];

struct Edge

{

	int s,e;

	double w;

}a[N*N];

double ma(Point a,Point b)

{

	return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));

}

bool cmp(Edge a,Edge b)

{

	return a.w>b.w;

}

int Find(int x)

{

	while(x!=per[x])

		x=per[x];

	return x;

}

int Judge(int x,int y)

{

	int fx=Find(x);

	int fy=Find(y);

	if(fx!=fy)

	{

		per[fx]=fy;

		return 1;

	}

	return 0;

}

int main()

{

	int i,n,m,x,y;

	while(~scanf("%d%d",&n,&m))

	{

		for(i=1;i<=n;i++)

		{

			per[i]=i;

			scanf("%lf%lf",&p[i].x,&p[i].y);

		}

		double sum=0;

		for(i=0;i<m;i++)

		{

			scanf("%d%d",&x,&y);

			a[i].s=x;a[i].e=y;

			a[i].w=ma(p[x],p[y]);

			sum+=a[i].w;

		}

		sort(a,a+m,cmp);

		double tmp=0;

		for(i=0;i<m;i++)

		{

			if(Judge(a[i].s,a[i].e))

				tmp+=a[i].w;

		}

		printf("%.3lf\n",sum-tmp);

	}

	return 0;

}

// Fastest known solution for this problem:
#include<bits/stdc++.h>

#define rep(i,n) for(int i=0;i<(int)(n);i++)

using namespace std;

typedef vector<int> vi;

typedef double D;



class edge{

public:

  int s,t;

  int cost;

  edge(int a,int b,int c):s(a),t(b),cost(c){}

  bool operator<(const edge &e)const{return cost<e.cost;}

};



class UF{

  vi p,r;



public:

  UF(int n):p(n,-1),r(n,0){ }



  int find(int x){ return (p[x]<0)?x:(p[x] = find(p[x])); }



  void unite(int x,int y){

    x = find(x); y = find(y);

    if(x==y)return;



    if(r[x] < r[y])p[x] = y;

    else p[y] = x;

    if(r[x] == r[y])r[x]++;

  }



  bool same(int x,int y){return find(x)==find(y);}

};



inline int dis2(int x1, int y1, int x2, int y2){

  return (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2);

}



int main(){

  cin.tie(0); ios::sync_with_stdio(0);

  int n,m;

  cin >> n >> m;

  

  vector<D> x(n),y(n);

  for(int i=0;i<n;i++)cin >> x[i] >> y[i];



  vector<edge> e;

  for(int i=0;i<m;i++){

    int a,b;

    cin >> a >> b; a--; b--;

    e.push_back(edge(a,b,dis2(x[a],y[a],x[b],y[b])));

  }



  sort(e.begin(), e.end());

  reverse(e.begin(), e.end());

  

  UF uf(n);

  D ans = 0;

  rep(i,m){

    if(uf.same(e[i].s,e[i].t))ans += sqrt(e[i].cost);

    else uf.unite(e[i].s,e[i].t);

  }

  cout << fixed << setprecision(9) << ans << endl;

}