#include <bits/stdc++.h>

using namespace std;

#define LOG(...) fprintf(stderr,__VA_ARGS__)
//#define LOG(...)
#define FOR(i,a,b) for(int i=(int)(a);i<(int)(b);++i)
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))

typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

// ?´?????????????????§????
struct UnionFind
{
  // par[i]????????????i????±?????????¨??????????????????i == par[i]?????¨???????????????i?????¨?????????????????§??????
  vector<int> par;
  // sizes[i]???????????????i?????¨?????????????????????????????°???i?????????????????§????????´???????????????????????¨??????
  vector<int> sizes;

  UnionFind(int n) : par(n), sizes(n, 1) {
    // ???????????¨???????????????i?????°?????????i????????¨??????????????¨???????????????
    REP(i, n) par[i] = i;
  }

  // ?????????x????±?????????¨???????????????
  int find(int x) {
    if (x == par[x]) return x;
    return par[x] = find(par[x]);  // ????????????????????????????????°???????????????????????¢???
  }

  // 2???????????????x, y????±?????????¨??????????????????
  void unite(int x, int y) {
    // ?????????????????????????????????
    x = find(x);
    y = find(y);

    // ??¢???????????¨????±?????????????????????????????????????
    if (x == y) return;

    // x?????¨???y?????¨????????§???????????????????????????
    if (sizes[x] < sizes[y]) swap(x, y);

    // x???y??????????????????????????£?????????
    par[y] = x;
    sizes[x] += sizes[y];
    // sizes[y] = 0;  // sizes[y]????????????????????¨???????????§0?????\????????????????????????
  }

  // 2???????????????x, y????±?????????¨???????????????true?????????
  bool same(int x, int y) {
    return find(x) == find(y);
  }

  // ?????????x?????????????????¨?????§???????????????
  int size(int x) {
    return sizes[find(x)];
  }
};

// ??????a, b?????????????????????cost??????????????????
struct Edge
{
  int a, b;
  double cost;

  // ??????????????§?°???§????????????
  bool operator<(const Edge& o) const {
    return cost < o.cost;
  }
};

// ????????°??¨?????????????????¨????????????????????°??????
struct Graph
{
  int n;  // ????????°
  vector<Edge> es;  // ?????????

  // ????????????????????§??????????°???¨?????¨??????????????????????¨??????????
  // ??°??????????????£????????¨??????????°???¨????£?????????????????????¨??????
  double kruskal() {
    // ?????????????°??????????????????????
    RSORT(es);

    UnionFind uf(n);
    double min_cost = 0;

    REP(ei, es.size()) {
      Edge& e = es[ei];
      if (!uf.same(e.a, e.b)) {
        // ????????????????????????????????§???????????????????????????????????¨??????
        min_cost += e.cost;
        uf.unite(e.a, e.b);
      }
    }

    return min_cost;
  }
};

int main() {
    int n, m;
    cin >> n >> m;

    Graph g;
    g.n = n;

    double cost = 0;
    vector<pii> piles;
    REP(i, n) {
        int x, y;
        cin >> x >> y;
        piles.push_back({x, y});
    }
    REP(i, m) {
        int p, q;
        cin >> p >> q;
        p--;
        q--;
        pii P = piles[p], Q = piles[q];
        double c = hypot(P.first - Q.first, P.second - Q.second);
        cost += c;
        g.es.push_back({p, q, c});
    }
    printf("%.04f\n", cost - g.kruskal());
}

Measured memory_bytes: 3756