#include <bits/stdc++.h>
const double EPS = 1e-9;
struct point3d {
  double x, y, z;
  point3d(double a, double b, double c) : x(a), y(b), z(c) {}
  point3d(double a, double b) : x(a), y(b), z(0) {}
  point3d(void) : x(0), y(0), z(0) {}
  point3d operator-(const point3d& o) const {
    return point3d(x - o.x, y - o.y, z - o.z);
  }
  point3d operator*(double o) const { return point3d(o * x, o * y, o * z); }
  double cross(const point3d& o) const { return x * o.y - o.x * y; }
};
struct segment {
  point3d p0, p1, u;
  segment(point3d& a, point3d& b) : p0(a), p1(b), u(b - a) {}
};
struct polygon {
  int n_points;
  std::vector<point3d> points;
  polygon(void) : n_points(0) {}
  point3d& operator[](int i) { return points[i]; }
};
struct ray {
  point3d v;
  ray(void) {}
  ray(point3d a) : v(a) {}
  double intersect(point3d& p) {
    double point_t;
    if (fabs(v.cross(p)) < EPS) {
      point_t = p.x / (double)v.x;
      if (point_t < -EPS || point_t > 1 + EPS) {
        return INFINITY;
      }
      return point_t;
    }
    return INFINITY;
  }
  double intersect(segment&& s) {
    const point3d& u = s.u;
    const point3d& w = s.p0;
    double det, ray_t, segment_t;
    det = v.cross(u);
    if (fabs(det) < EPS) {
      return std::min(intersect(s.p0), intersect(s.p1));
    }
    ray_t = w.cross(u) / det;
    segment_t = w.cross(v) / det;
    if (ray_t < -EPS || segment_t < -EPS || segment_t > 1 + EPS) {
      return INFINITY;
    }
    return ray_t;
  }
  double intersect(polygon& p) {
    int i;
    double min_t;
    min_t = INFINITY;
    for (i = 0; i < p.n_points; ++i) {
      min_t = std::min(min_t, intersect(segment(p[i], p[i + 1])));
    }
    return min_t;
  }
  bool is_parallel(ray& o) { return fabs(v.cross(o.v)) < EPS; }
};
std::pair<double, double> ray_time(ray& free_fall, ray& parachute,
                                   polygon& fence, int g) {
  double free_fall_t, parachute_t, aux_t;
  free_fall_t = free_fall.intersect(fence);
  parachute_t = parachute.intersect(fence);
  if (free_fall_t < parachute_t) {
    aux_t = -free_fall.v.z * free_fall_t / (double)g;
    return std::make_pair(free_fall_t, aux_t);
  }
  return std::make_pair(parachute_t, 0);
}
std::pair<double, double> vertex_time(point3d& vertex, point3d& plane,
                                      point3d& wind, int g) {
  double A, B, C, D, det;
  std::pair<double, double> ans;
  A = plane.x - plane.z * wind.x / (double)wind.z;
  B = -g * wind.x / (double)wind.z;
  C = plane.y - plane.z * wind.y / (double)wind.z;
  D = -g * wind.y / (double)wind.z;
  det = A * D - B * C;
  ans.first = (vertex.x * D - B * vertex.y) / det;
  ans.second = (A * vertex.y - vertex.x * C) / det;
  if (ans.first < -EPS || ans.second < -EPS ||
      plane.z * ans.first + g * ans.second < -EPS) {
    return std::make_pair(INFINITY, INFINITY);
  }
  return ans;
}
int main(void) {
  int i, g;
  polygon fence;
  point3d origin, plane, wind;
  ray free_fall, parachute_fall;
  std::pair<double, double> best_t;
  std::cin >> fence.n_points;
  fence.points.resize(fence.n_points + 1);
  for (i = 0; i < fence.n_points; ++i) {
    std::cin >> fence[i].x >> fence[i].y;
  }
  fence[fence.n_points] = fence[0];
  std::cin >> origin.x >> origin.y;
  std::cin >> plane.x >> plane.y >> plane.z;
  std::cin >> g;
  std::cin >> wind.x >> wind.y >> wind.z;
  for (i = 0; i <= fence.n_points; ++i) {
    fence[i].x -= origin.x;
    fence[i].y -= origin.y;
  }
  free_fall = ray(plane);
  parachute_fall = ray(plane - wind * (plane.z / (double)wind.z));
  best_t = ray_time(free_fall, parachute_fall, fence, g);
  if (!free_fall.is_parallel(parachute_fall)) {
    for (point3d& p : fence.points) {
      best_t = std::min(best_t, vertex_time(p, plane, wind, g));
    }
  }
  if (best_t.first == INFINITY || best_t.second == INFINITY) {
    std::cout << "-1 -1" << std::endl;
    return 0;
  }
  std::cout << std::fixed << std::setprecision(10) << best_t.first << " "
            << best_t.second << std::endl;
  return 0;
}
