#include <bits/stdc++.h>
#define int long long
#define fi first
#define se second
#define rep(a,b) for(int (a)=0; (a)<(int)(b); ++(a))
#define Rep(a,b,c) for(int (a)=(b); (a)<(int)(c); ++(a))
#define eb(a) emplace_back(a)
using namespace std;

using int64 = long long;
const int mod = 1e9 + 7;

const int64 infll = (1LL << 62) - 1;
const int inf = (1 << 30) - 1;

struct IoSetup {
  IoSetup() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(10);
    cerr << fixed << setprecision(10);
  }
} iosetup;


template< typename T1, typename T2 >
ostream &operator<<(ostream &os, const pair< T1, T2 >& p) {
  os << "(" << p.first << ", " << p.second << ")";
  return os;
}

template< typename T1, typename T2 >
istream &operator>>(istream &is, pair< T1, T2 > &p) {
  is >> p.first >> p.second;
  return is;
}

template< typename T >
ostream &operator<<(ostream &os, const vector< T > &v) {
  for(int i = 0; i < (int) v.size(); i++) {
    os << v[i] << (i + 1 != v.size() ? " " : "");
  }
  return os;
}

template< typename T >
istream &operator>>(istream &is, vector< T > &v) {
  for(T &in : v) is >> in;
  return is;
}

template< typename T1, typename T2 >
inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }

template< typename T1, typename T2 >
inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }

template< typename T = int64 >
vector< T > make_v(size_t a) {
  return vector< T >(a);
}

template< typename T, typename... Ts >
auto make_v(size_t a, Ts... ts) {
  return vector< decltype(make_v< T >(ts...)) >(a, make_v< T >(ts...));
}

template< typename T, typename V >
typename enable_if< is_class< T >::value == 0 >::type fill_v(T &t, const V &v) {
  t = v;
}

template< typename T, typename V >
typename enable_if< is_class< T >::value != 0 >::type fill_v(T &t, const V &v) {
  for(auto &e : t) fill_v(e, v);
}

template< typename F >
struct FixPoint : F {
  FixPoint(F &&f) : F(forward< F >(f)) {}
 
  template< typename... Args >
  decltype(auto) operator()(Args &&... args) const {
    return F::operator()(*this, forward< Args >(args)...);
  }
};
 
template< typename F >
inline decltype(auto) MFP(F &&f) {
  return FixPoint< F >{forward< F >(f)};
}

template< typename T >
struct edge {
  int src, to;
  T cost;

  edge(int to, T cost) : src(-1), to(to), cost(cost) {}

  edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}

  edge &operator=(const int &x) {
    to = x;
    return *this;
  }

  operator int() const { return to; }
};

template< typename T >
using Edges = vector< edge< T > >;
template< typename T >
using WeightedGraph = vector< Edges< T > >;
using UnWeightedGraph = vector< vector< int > >;
template< typename T >
using Matrix = vector< vector< T > >;

template< typename T >
vector< T > dijkstra(WeightedGraph< T > &g, int s) {
  const auto INF = numeric_limits< T >::max();
  vector< T > dist(g.size(), INF);

  using Pi = pair< T, int >;
  priority_queue< Pi, vector< Pi >, greater< Pi > > que;
  dist[s] = 0;
  que.emplace(dist[s], s);
  while(!que.empty()) {
    T cost;
    int idx;
    tie(cost, idx) = que.top();
    que.pop();
    if(dist[idx] < cost) continue;
    for(auto &e : g[idx]) {
      auto next_cost = cost + e.cost;
      if(dist[e.to] <= next_cost) continue;
      dist[e.to] = next_cost;
      que.emplace(dist[e.to], e.to);
    }
  }
  return dist;
}

using pint=pair<int,int>;
using ppint=pair<pint,int>;

double calc(ppint a,ppint b){
  return max((double)0,sqrt(pow(b.fi.fi-a.fi.fi,2)+pow(b.fi.se-a.fi.se,2))-(a.se+b.se));
}

signed main() {
  pint ss,tt; cin>>ss>>tt;
  ppint s,t;
  s=ppint(ss,0),t=ppint(tt,0);
  int N; cin>>N;
  WeightedGraph<double> gr;
  gr.resize(N+2);
  vector<ppint> c(N); cin>>c;
  rep(i,N){
    gr[0].eb(edge<double>(i+1,calc(s,c[i])));
    gr[i+1].eb(edge<double>(0,calc(s,c[i])));
    gr[N+1].eb(edge<double>(i+1,calc(t,c[i])));
    gr[i+1].eb(edge<double>(N+1,calc(t,c[i])));
    Rep(j,i+1,N){
      gr[i+1].eb(edge<double>(j+1,calc(c[i],c[j])));
      gr[j+1].eb(edge<double>(i+1,calc(c[i],c[j])));
    }
  }
  gr[0].eb(edge<double>(N+1,calc(s,t)));
  auto res=dijkstra(gr,0);
  //cout<<c<<endl;
  /*
  rep(i,N+2){
    rep(j,gr[i].size()){
      cout<<"("<<gr[i][j].to<<", "<<gr[i][j].cost<<") ";
    }
    cout<<endl;
  }
  */
    cout<<fixed<<setprecision(10)<<res[N+1];
}

Measured memory_bytes: 30576