#include <bits/stdc++.h>
using namespace std;
struct Point {
  double x;
  double y;
  Point(double _x = 0, double _y = 0) : x(_x), y(_y) {}
  double length() const { return sqrt(x * x + y * y); }
  double distance(const Point& other) const {
    return Point(x - other.x, y - other.y).length();
  }
};
Point operator+(const Point& first, const Point& second) {
  return Point(first.x + second.x, first.y + second.y);
}
Point operator-(const Point& first, const Point& second) {
  return Point(first.x - second.x, first.y - second.y);
}
double vector_product(const Point& first, const Point& second) {
  return first.x * second.y - first.y * second.x;
}
double scalar_product(const Point& first, const Point& second) {
  return first.x * second.x + first.y * second.y;
}
struct Segment {
  Point A;
  Point B;
  Segment() {}
  Segment(const Point& _A, const Point& _B) : A(_A), B(_B) {}
  double length() const;
  double distance(const Point& C) const;
  double distance(const Segment& S) const;
};
double Segment::length() const {
  double dx = B.x - A.x;
  double dy = B.y - A.y;
  return sqrt(dx * dx + dy * dy);
}
double Segment::distance(const Point& C) const {
  if (scalar_product(C - A, B - A) < 0 || scalar_product(C - B, A - B) < 0) {
    return min(Segment(A, C).length(), Segment(B, C).length());
  } else {
    return fabs(vector_product(C - A, B - A)) / length();
  }
}
double Segment::distance(const Segment& S) const {
  double r = distance(S.A);
  r = min(r, distance(S.B));
  r = min(r, S.distance(A));
  r = min(r, S.distance(B));
  return r;
}
struct Arc {
  int head;
  double weight;
  Arc() : head(-1), weight(0) {}
  Arc(int to, double label) : head(to), weight(label) {}
};
enum VertexColor { WHITE = 0, GRAY, BLACK };
const double INF = 1000000000;
void dijkstra_on_array(const std::vector<std::vector<Arc> >& graph, int source,
                       vector<double>& distance) {
  vector<int> color(graph.size(), WHITE);
  color[source] = GRAY;
  distance.assign(graph.size(), INF);
  distance[source] = 0;
  for (int step = 0; step < graph.size(); ++step) {
    int min_gray_vertex = 0;
    double min_distance_to_gray = INF;
    for (int vertex = 0; vertex < graph.size(); ++vertex) {
      if (color[vertex] == GRAY && distance[vertex] < min_distance_to_gray) {
        min_gray_vertex = vertex;
        min_distance_to_gray = distance[vertex];
      }
    }
    if (min_distance_to_gray == INF) {
      break;
    }
    color[min_gray_vertex] = BLACK;
    for (int arc_index = 0; arc_index < graph[min_gray_vertex].size();
         ++arc_index) {
      const Arc& arc = graph[min_gray_vertex][arc_index];
      if (color[arc.head] != BLACK &&
          distance[arc.head] > min_distance_to_gray + arc.weight) {
        color[arc.head] = GRAY;
        distance[arc.head] = min_distance_to_gray + arc.weight;
      }
    }
  }
}
int main() {
  double a, b;
  cin >> a >> b;
  Point A, B;
  cin >> A.x >> A.y >> B.x >> B.y;
  int n;
  cin >> n;
  vector<Segment> segments(n);
  for (int i = 0; i < n; ++i) {
    cin >> segments[i].A.x >> segments[i].A.y >> segments[i].B.x >>
        segments[i].B.y;
  }
  std::vector<std::vector<Arc> > g(n + 2);
  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      if (segments[i].distance(segments[j]) <= a + 1e-9) {
        g[i].push_back(Arc(j, a + b));
        g[j].push_back(Arc(i, a + b));
      }
    }
  }
  for (int i = 0; i < n; ++i) {
    double da = segments[i].distance(A);
    double db = segments[i].distance(B);
    if (da <= a + 1e-9) {
      g[n].push_back(Arc(i, a + b));
    }
    if (db <= a + 1e-9) {
      g[i].push_back(Arc(n + 1, db));
    }
  }
  if (A.distance(B) <= a + 1e-9) {
    cout.precision(8);
    cout << fixed << A.distance(B) << endl;
  } else {
    vector<double> d;
    dijkstra_on_array(g, n, d);
    if (d[n + 1] == INF) {
      cout << -1 << endl;
    } else {
      cout.precision(8);
      cout << fixed << d[n + 1] << endl;
    }
  }
  return 0;
}
