#include <bits/stdc++.h>
using namespace std;
class Point {
 public:
  double x, y;
  Point(double x = 0, double y = 0) : x(x), y(y) {}
  Point operator+(Point p) { return Point(x + p.x, y + p.y); }
  Point operator-(Point p) { return Point(x - p.x, y - p.y); }
  Point operator*(double k) { return Point(x * k, y * k); }
  Point operator/(double k) { return Point(x / k, y / k); }
  bool operator<(Point p) const { return (x != p.x ? x < p.x : y < p.y); }
  bool operator==(Point p) const {
    return fabs(x - p.x) < (1e-6) && fabs(y - p.y) < (1e-6);
  }
  double abs() { return sqrt(norm()); }
  double norm() { return (x * x + y * y); }
};
class Segment {
 public:
  Point p1, p2;
  Segment(Point p1 = Point(), Point p2 = Point()) : p1(p1), p2(p2) {}
};
class Circle {
 public:
  Point c;
  double r;
  Circle(Point c = Point(), double r = 0.0) : c(c), r(r) {}
};
double norm(Point a) { return (a.x * a.x + a.y * a.y); }
double abs(Point a) { return sqrt(norm(a)); }
double dot(Point a, Point b) { return (a.x * b.x + a.y * b.y); }
double cross(Point a, Point b) { return (a.x * b.y - a.y * b.x); }
Point getCrossPointLL(Segment a, Segment b) {
  double A = cross(a.p2 - a.p1, b.p2 - b.p1);
  double B = cross(a.p2 - a.p1, a.p2 - b.p1);
  if (abs(A) < (1e-6) || abs(B) < (1e-6)) return b.p1;
  return b.p1 + (b.p2 - b.p1) * (B / A);
}
Point rotate(Point base, Point a, double r) {
  Point b = a - base;
  a.x = b.x * cos((r / 180) * M_PI) - b.y * sin((r / 180) * M_PI);
  a.y = b.x * sin((r / 180) * M_PI) + b.y * cos((r / 180) * M_PI);
  a = a + base;
  return a;
}
pair<Point, Point> getTangent(Circle c, Point p) {
  Point v = p - c.c;
  double r = acos(c.r / abs(v)) * 360 / (2 * acos(-1.0));
  v = v * c.r / abs(v);
  Point p1 = rotate(c.c, c.c + v, r);
  Point p2 = rotate(c.c, c.c + v, 360 - r);
  return make_pair(p1, p2);
}
double getDistanceLP(Segment l, Point p) {
  return abs(cross(l.p2 - l.p1, p - l.p1) / abs(l.p2 - l.p1));
}
double getDistanceSP(Segment second, Point p) {
  if (dot(second.p2 - second.p1, p - second.p1) < 0.0)
    return abs(p - second.p1);
  if (dot(second.p1 - second.p2, p - second.p2) < 0.0)
    return abs(p - second.p2);
  return getDistanceLP(second, p);
}
bool intersect(Circle c, Segment second) {
  if (getDistanceSP(second, c.c) - c.r < -(1e-6)) return true;
  return false;
}
int n;
Circle R, B;
vector<Point> r, b;
vector<Segment> getS(Point p) {
  vector<Segment> res;
  pair<Point, Point> pp;
  pp = getTangent(R, p);
  res.push_back(Segment(p, pp.first));
  res.push_back(Segment(p, pp.second));
  pp = getTangent(B, p);
  res.push_back(Segment(p, pp.first));
  res.push_back(Segment(p, pp.second));
  return res;
}
double getdis(int c, int d) {
  Segment second(r[c], b[d]);
  if (!intersect(R, second) && !intersect(B, second)) return abs(r[c] - b[d]);
  vector<Segment> vs1 = getS(r[c]), vs2 = getS(b[d]);
  double res = 1 << 29;
  for (int i = 0; i < vs1.size(); i++) {
    for (int j = 0; j < vs2.size(); j++) {
      Point m = getCrossPointLL(vs1[i], vs2[j]);
      if (!intersect(R, Segment(r[c], m)) && !intersect(B, Segment(m, b[d])) &&
          !intersect(B, Segment(r[c], m)) && !intersect(R, Segment(m, b[d])))
        res = min(res, abs(r[c] - m) + abs(m - b[d]));
    }
  }
  return res;
}
struct edge {
  int to, cap;
  double cost;
  int rev;
};
int v;
vector<edge> e[202];
double h[202];
double dist[202];
int prevv[202], preve[202];
void add_edge(int from, int to, int cap, double cost) {
  e[from].push_back((edge){to, cap, cost, (int)e[to].size()});
  e[to].push_back((edge){from, 0, -cost, (int)e[from].size() - 1});
}
double min_cost_flow(int second, int t, int first) {
  double res = 0.0;
  fill(h, h + v, 0);
  while (first > 0) {
    priority_queue<pair<double, int>, vector<pair<double, int> >,
                   greater<pair<double, int> > >
        pq;
    fill(dist, dist + v, 1 << 29);
    dist[second] = 0;
    pq.push(pair<double, int>(0, second));
    while (pq.size()) {
      pair<double, int> p = pq.top();
      pq.pop();
      int u = p.second;
      if (dist[u] < p.first) continue;
      for (int i = 0; i < e[u].size(); i++) {
        edge &E = e[u][i];
        if (E.cap > 0 && dist[E.to] > dist[u] + E.cost + h[u] - h[E.to]) {
          dist[E.to] = dist[u] + E.cost + h[u] - h[E.to];
          prevv[E.to] = u;
          preve[E.to] = i;
          pq.push(pair<double, int>(dist[E.to], E.to));
        }
      }
    }
    if (dist[t] == 1 << 29) return -1;
    for (int i = 0; i < v; i++) h[i] += dist[i];
    int d = first;
    for (int u = t; u != second; u = prevv[u]) {
      d = min(d, e[prevv[u]][preve[u]].cap);
    }
    first -= d;
    res += (double)d * h[t];
    for (int u = t; u != second; u = prevv[u]) {
      edge &E = e[prevv[u]][preve[u]];
      E.cap -= d;
      e[u][E.rev].cap += d;
    }
  }
  return res;
}
int main() {
  cin >> n;
  cin >> R.c.x >> R.c.y >> R.r;
  cin >> B.c.x >> B.c.y >> B.r;
  for (int i = 0; i < n; i++) {
    int x, y;
    cin >> x >> y;
    r.push_back(Point(x, y));
  }
  for (int i = 0; i < n; i++) {
    int x, y;
    cin >> x >> y;
    b.push_back(Point(x, y));
  }
  double dis[202][202];
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
      add_edge(i, j + n, 1, getdis(i, j));
    }
  }
  int second = n * 2;
  int t = second + 1;
  v = t + 1;
  for (int i = 0; i < n; i++) {
    add_edge(second, i, 1, 0);
    add_edge(i + n, t, 1, 0);
  }
  double res = min_cost_flow(second, t, n);
  if ((fabs((res) - (-1.0)) < (1e-6)))
    printf("Impossible\n");
  else
    printf("%.10f\n", res);
  return 0;
}
