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

#include <cstring>

#include <cstdio>

#include <cmath>

#include <algorithm>

using namespace std;

struct node{

    double x,y;

}ver[10010];

struct Edge{

    int u,v;

    double l;

}e[1000000];

int n,m;

int pre[10010];

int Find(int x){

    if(x == pre[x])

        return x;

    else return pre[x] = Find(pre[x]);

}

int Union(int x,int y){

    int fx = Find(x),fy = Find(y);

    if(fx == fy)

        return 0;

    else{

        pre[fy] = fx;

        return 1;

    }

}

bool cmp(Edge a,Edge b){

    return a.l > b.l;

}

int main(){

    int i,j;

    cin >> n >> m;

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

        pre[i] = i;

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

        cin >> ver[i].x >> ver[i].y;

    }

    double allsum = 0.0;

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

        int u,v;

        double len;

        cin >> u >> v;

        len = sqrt((ver[u].x-ver[v].x)*(ver[u].x-ver[v].x)+(ver[u].y-ver[v].y)*(ver[u].y-ver[v].y));

        e[i].u = u;

        e[i].v = v;

        e[i].l = len;

        allsum += len;

    }

    //cout << allsum << endl;

    sort(e,e+m,cmp);

    double sum = 0.0;

    int num = 0;

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

        if(Union(e[i].u,e[i].v)){

            sum += e[i].l;

            num++;

        }

        if(num == n-1)

            break;

    }

    //cout << sum << endl;

    printf("%.3f\n",allsum-sum);

    return 0;

}

// Optimized solution to the same problem (faster):
#include <cstdio>

#include <cstring>

#include <algorithm>

#include <cmath>



using namespace std;



int n, m, f[10010], x[10010], y[10010];

double ans = 0.0;



struct edge {

	int u, v;

	double w;

	bool operator < (const edge &b) const { return w < b.w; }

}e[1000010];



double getdis(int u, int v) {

	return sqrt((double)(x[u] - x[v]) * (x[u] - x[v]) + (double)(y[u] - y[v]) * (y[u] - y[v]));

}



int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }



int main() {

	scanf("%d%d", &n, &m);

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

		f[i] = i;

		scanf("%d%d", &x[i], &y[i]);

	}

	int u, v;

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

		scanf("%d%d", &u, &v);

		e[i].u = u;

		e[i].v = v;

		e[i].w = getdis(u, v);

	}

	sort(e + 1, e + m + 1);

	for(int i = m; i >= 1; --i) {

		int fu = find(e[i].u);

		int fv = find(e[i].v);

		if(fu != fv) f[fu] = fv;

		else ans += e[i].w;

	}

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

	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;

}