#include <bits/stdc++.h>
using namespace std;
template <class TH>
void _dbg(const char *sdbg, TH h) {
  cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
  while (*sdbg != ',') cerr << *sdbg++;
  cerr << '=' << h << ',';
  _dbg(sdbg + 1, a...);
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> p) {
  return os << "(" << p.first << ", " << p.second << ")";
}
template <class Iterable,
          class = typename enable_if<!is_same<string, Iterable>::value>::type>
auto operator<<(ostream &os, Iterable v) -> decltype(os << *begin(v)) {
  os << "[";
  for (auto vv : v) os << vv << ", ";
  return os << "]";
}
const int inf = 0x3f3f3f3f;
const long long infll = 0x3f3f3f3f3f3f3f3fll;
const double EPS = 1e-12;
template <class T>
int sign(T x) {
  return (x > 0) - (x < 0);
}
template <class T>
struct point {
  T x, y;
  explicit point(T x = 0, T y = 0) : x(x), y(y) {}
  bool operator<(point<T> p) const { return tie(x, y) < tie(p.x, p.y); }
  bool operator==(point<T> p) const { return tie(x, y) == tie(p.x, p.y); }
  point<T> operator+(point<T> p) const { return point<T>(x + p.x, y + p.y); }
  point<T> operator-(point<T> p) const { return point<T>(x - p.x, y - p.y); }
  point<T> operator*(T d) const { return point<T>(x * d, y * d); }
  point<T> operator/(T d) const { return point<T>(x / d, y / d); }
  T dot(point<T> p) const { return x * p.x + y * p.y; }
  T cross(point<T> p) const { return x * p.y - y * p.x; }
  T cross(point<T> a, point<T> b) const { return (a - *this).cross(b - *this); }
  T dist2() const { return x * x + y * y; }
  double dist() const { return sqrt((double)dist2()); }
  double angle() const { return atan2(y, x); }
  point<double> unit() const { return *this / dist(); }
  point<T> perp() const { return point<T>(-y, x); }
  point<double> normal() const { return perp().unit(); }
  point<double> rotate(double a) const {
    return point<T>(x * cos(a) - y * sin(a), x * sin(a) + y * cos(a));
  }
  double angle(point<T> p) const { return p.rotate(-angle()).angle(); }
};
template <class T>
pair<int, point<T>> linear_solve2(T a, T b, T c, T d, T e, T f) {
  point<T> retv;
  T det = a * d - b * c;
  if (det == 0) {
    if (b * f == d * e && a * f == c * e) return {-1, point<T>()};
    return {0, point<T>()};
  }
  return {1, point<T>((e * d - f * b) / det, (a * f - c * e) / det)};
}
template <class T>
struct segment {
  point<T> pi, pf;
  explicit segment(point<T> a = point<T>(), point<T> b = point<T>())
      : pi(a), pf(b) {}
  double dist(point<T> p) {
    if (pi == pf) return (p - pi).dist();
    auto d = (pf - pi).dist2();
    auto t = min(d, max(.0, (p - pi).dot(pf - pi)));
    return ((p - pi) * d - (pf - pi) * t).dist() / d;
  }
  bool on_segment(point<T> p) {
    return p.cross(pi, pf) == 0 && (pi - p).dot(pf - p) <= 0;
  }
  vector<point<T>> intersect(segment rhs) {
    auto oa = rhs.pi.cross(rhs.pf, pi), ob = rhs.pi.cross(rhs.pf, pf),
         oc = pi.cross(pf, rhs.pi), od = pi.cross(pf, rhs.pf);
    if (sign(oa) * sign(ob) < 0 && sign(oc) * sign(od) < 0)
      return {(pi * ob - pf * oa) / (ob - oa)};
    set<point<T>> s;
    if (rhs.on_segment(pi)) s.insert(pi);
    if (rhs.on_segment(pf)) s.insert(pf);
    if (on_segment(rhs.pi)) s.insert(rhs.pi);
    if (on_segment(rhs.pf)) s.insert(rhs.pf);
    return vector<point<T>>(s.begin(), s.end());
  }
};
template <class T>
struct line {
  T a, b, c;
  explicit line(point<T> p1, point<T> p2) {
    assert(!(p1 == p2));
    a = p2.y - p1.y;
    b = p1.x - p2.x;
    c = a * p1.x + b * p1.y;
  }
  explicit line(T _a, T _b, T _c) : a(_a), b(_b), c(_c) {}
  double dist(point<T> p) {
    return abs(a * p.x + b * p.y - c) / sqrt((double)(a * a + b * b));
  }
  pair<int, point<T>> intersect(line rhs) {
    return linear_solve2(a, b, rhs.a, rhs.b, c, rhs.c);
  }
  line normalize() {
    double d = point<T>(a, b).dist() * (c < 0 ? -1 : 1);
    return line(a / d, b / d, c / d);
  }
};
template <class T>
struct circle {
  point<T> center;
  T r;
  int intersect(line<T> l, pair<point<T>, point<T>> &retv) {
    l = l.normalize();
    l.c -= l.a * center.x + l.b * center.y;
    point<T> v(l.a, l.b);
    point<T> p0 = v * l.c;
    if (p0.dist() > r + EPS)
      return 0;
    else if (p0.dist() > r - EPS) {
      retv = {p0, p0};
      return 1;
    }
    double d = sqrt(r * r - l.c * l.c);
    retv = {center + p0 + v.normal() * d, center + p0 - v.normal() * d};
    return 2;
  }
  int intersect(circle rhs, pair<point<T>, point<T>> &retv) {
    rhs.center = rhs.center - center;
    int num = rhs.intersect(
        line<T>(2 * rhs.center.x, 2 * rhs.center.y,
                rhs.center.x * rhs.center.x + rhs.center.y * rhs.center.y +
                    r * r - rhs.r * rhs.r),
        retv);
    retv.first = retv.first + center;
    retv.second = retv.second + center;
    return num;
  }
  pair<point<T>, point<T>> tangents(point<T> p) {
    p = p - center;
    double k1 = r * r / p.dist2();
    double k2 = sqrt(k1 - k1 * k1);
    return {center + p * k1 + p.perp() * k2, center + p * k1 - p.perp() * k2};
  }
};
template <class T>
ostream &operator<<(ostream &os, point<T> p) {
  return os << "(x=" << p.x << ", y=" << p.y << ")";
}
circle<double> c[112345];
int main(void) {
  point<double> p0;
  double v, t;
  int n;
  cin >> p0.x >> p0.y >> v >> t >> n;
  for (int i = 0; i < n; i++) {
    scanf("%lf %lf %lf", &c[i].center.x, &c[i].center.y, &c[i].r);
    c[i].center = c[i].center - p0;
    if (c[i].center.dist() < c[i].r + EPS) {
      printf("1\n");
      return 0;
    }
  }
  cerr << fixed << setprecision(12);
  p0 = p0 - p0;
  circle<double> safe = {p0, v * t};
  vector<pair<double, double>> arcs;
  for (int i = 0; i < n; i++) {
    if (c[i].center.dist() < c[i].r + safe.r - EPS) {
      pair<point<double>, point<double>> sf;
      sf = c[i].tangents(p0);
      if (sf.first.dist() > safe.r + EPS) {
        if (c[i].intersect(safe, sf) <= 0) {
          _dbg("safe.center, safe.r", safe.center, safe.r);
          _dbg("sf", sf);
          _dbg("c[i].center, c[i].r", c[i].center, c[i].r);
          assert(false);
        }
      }
      pair<double, double> tmp = {sf.first.angle(), sf.second.angle()};
      if (tmp.first > tmp.second) swap(tmp.first, tmp.second);
      if (tmp.second - tmp.first < 3.14159265358979323846)
        arcs.push_back(tmp);
      else {
        arcs.push_back({-3.14159265358979323846, tmp.first});
        arcs.push_back({tmp.second, 3.14159265358979323846});
      }
    }
  }
  double ans = 0;
  sort(arcs.begin(), arcs.end());
  for (int i = 0; i < arcs.size(); i++) {
    double l = arcs[i].first;
    double r = arcs[i].second;
    while (i + 1 < arcs.size() && arcs[i + 1].first <= r)
      r = max(r, arcs[++i].second);
    ans += r - l;
  }
  printf("%.15lf\n", ans / (2 * 3.14159265358979323846));
}
