#include <bits/stdc++.h>
using namespace std;
double EPS = 1e-9;
int INF = 0x7FFFFFFF;
long long INFF = 0x7FFFFFFFFFFFFFFF;
double PI = acos(-1.0);
int dirx[8] = {-1, 0, 0, 1, -1, -1, 1, 1};
int diry[8] = {0, 1, -1, 0, -1, 1, -1, 1};
inline void scanf(int &d1) { scanf("%d", &d1); }
inline void scanf(int &d1, int &d2) { scanf("%d%d", &d1, &d2); }
inline void scanf(int &d1, int &d2, int &d3) { scanf("%d%d%d", &d1, &d2, &d3); }
inline void scanf(long long &d1) { scanf("%I64d", &d1); }
inline void scanf(long long &d1, long long &d2) {
  scanf("%I64d%I64d", &d1, &d2);
}
inline void scanf(long long &d1, long long &d2, long long &d3) {
  scanf("%I64d%I64d%I64d", &d1, &d2, &d3);
}
inline void scanf(char *temp) { scanf("%s", temp); }
inline void printf(int d1) { printf("%d\n", d1); }
inline void printf(int d1, int d2) { printf("%d %d\n", d1, d2); }
inline void printf(double f1) { printf("%.17g\n", f1); }
inline void printf(long long l1) { printf("%I64d\n", l1); }
inline void printf(long long l1, long long l2) {
  printf("%I64d %I64d\n", l1, l2);
}
inline string tostring(int a) {
  char x[100];
  sprintf(x, "%d", a);
  string s = x;
  return s;
}
inline void toupperstring(string &s) {
  for (int(i) = (0); (i) < ((int)s.size()); ++(i)) {
    if (s[i] >= 'a' && s[i] <= 'z') {
      s[i] = s[i] - 'a' + 'A';
    }
  }
}
inline void tolowerstring(string &s) {
  for (int(i) = (0); (i) < ((int)s.size()); ++(i)) {
    if (s[i] >= 'A' && s[i] <= 'Z') {
      s[i] = s[i] - 'A' + 'a';
    }
  }
}
inline int toint(string a) {
  char x[100];
  int res;
  strcpy(x, a.c_str());
  sscanf(x, "%d", &res);
  return res;
}
inline void gopen(string s) {
  freopen((s + ".in").c_str(), "r", stdin);
  freopen((s + ".out").c_str(), "w", stdout);
}
inline void gcase(int id) { printf("Case #%d:", id); }
template <typename T1, typename T2, typename T>
inline typename T::iterator findorinsert(T &m, const T1 &t1, const T2 &t2) {
  typename T::iterator iter = m.find(t1);
  if (iter == m.end()) {
    m.insert(make_pair(t1, t2));
    return m.find(t1);
  } else {
    return iter;
  }
}
template <typename T>
inline T gcd(T u, T v) {
  while (v != 0) {
    T r = u % v;
    u = v;
    v = r;
  }
  return u;
}
template <typename T, int n>
struct Vector {
  T data[n];
  void read() {
    for (int(i) = (0); (i) < (n); ++(i)) {
      cin >> data[i];
    }
  }
  inline T operator*(const Vector<T, n> &v) const {
    T res = 0;
    for (int(i) = (0); (i) < (n); ++(i)) {
      res += data[i] * v[i];
    }
    return res;
  }
  inline bool operator<(const Vector<T, n> &v) const {
    for (int(i) = (0); (i) < (n); ++(i)) {
      if (data[i] != v[i]) {
        return data[i] < v[i];
      }
    }
    return false;
  }
  inline bool operator==(const Vector<T, n> &v) const {
    for (int(i) = (0); (i) < (n); ++(i)) {
      if (data[i] != v[i]) {
        return false;
      }
    }
    return true;
  }
  inline T &operator[](int id) { return data[id]; }
  inline T operator[](int id) const { return data[id]; }
  inline int size() const { return n; }
};
template <typename T>
inline Vector<T, 2> make_vector(const T &t1, const T &t2) {
  Vector<T, 2> res = {t1, t2};
  return res;
}
template <typename T, int n>
struct Matrix {
  Vector<T, n> data[n];
  inline Vector<T, n> operator*(const Vector<T, n> &v) const {
    Vector<T, n> res;
    for (int(i) = (0); (i) < (n); ++(i)) {
      res[i] = data[i] * v;
    }
    return res;
  }
  inline Matrix<T, n> operator*(const Matrix<T, n> &m) const {
    Matrix<T, n> res;
    for (int(i) = (0); (i) < (n); ++(i)) {
      Vector<T, n> temp;
      for (int(j) = (0); (j) < (n); ++(j)) {
        temp[j] = m[j][i];
      }
      for (int(j) = (0); (j) < (n); ++(j)) {
        res[j][i] = data[j] * temp;
      }
    }
    return res;
  }
  static inline Matrix<T, n> identity() {
    Matrix<T, n> res;
    for (int(i) = (0); (i) < (n); ++(i)) {
      memset(res[i].data, 0, sizeof(T) * n);
    }
    for (int(i) = (0); (i) < (n); ++(i)) {
      res[i][i] = 1;
    }
    return res;
  }
  Vector<T, n> &operator[](int id) { return data[id]; }
  Vector<T, n> operator[](int id) const { return data[id]; }
  int size() const { return n; }
};
template <typename T, int n>
class BIT {
 public:
  BIT(int size = n) {
    memset(bit, 0, sizeof(bit));
    this->size = size;
  }
  BIT(T *data, int size = n) {
    this->size = size;
    for (int i = 1; i <= size; i++) {
      bit[i] = data[i - 1];
      for (int j = i - 1; j > i - lowbit(i); j--) {
        bit[i] += bit[j];
      }
    }
  }
  void edit(int i, T delta) {
    for (int j = i + 1; j <= size; j += lowbit(j)) {
      bit[j] += delta;
    }
  }
  T sum(int k) {
    T ans = 0;
    for (int i = k + 1; i > 0; i -= lowbit(i)) {
      ans += bit[i];
    }
    return ans;
  }

 private:
  T bit[n + 1];
  int size;
  inline int lowbit(int x) const { return x & (-x); }
};
class Prime {
 public:
  Prime(int num) {
    bits.resize(num + 1, true);
    sieve();
    collect();
  }
  bool is_prime(int num) const { return bits[num]; }
  int find1factor(int num) const {
    for (int(i) = (0); (i) < ((int)results.size()); ++(i)) {
      if (num % results[i] == 0) {
        return results[i];
      }
    }
    return num;
  }

 private:
  vector<bool> bits;
  vector<int> results;
  void sieve() {
    bits[0] = false;
    bits[1] = false;
    for (int i = 2; i < (int)bits.size(); ++i) {
      if (bits[i] == true) {
        for (int j = 2;; ++j) {
          int v2 = j * i;
          if (v2 >= (int)bits.size()) {
            break;
          }
          bits[v2] = false;
        }
      }
    }
  }
  void collect() {
    for (int i = 0; i < (int)bits.size(); ++i) {
      if (bits[i]) {
        results.push_back(i);
      }
    }
  }
};
template <int n, int m>
struct Graph {
  int head[n], edge_id;
  struct {
    int to, next;
  } edges[m];
  void init(int num = n) {
    edge_id = 0;
    memset(head, -1, sizeof(int) * num);
  }
  int add(int from, int to) {
    edges[edge_id].next = head[from];
    edges[edge_id].to = to;
    head[from] = edge_id;
    edge_id++;
    return head[from];
  }
  inline int next(int edge) const { return edges[edge].next; }
  inline int to(int edge) const { return edges[edge].to; }
};
template <class T>
inline void hash_combine(std::size_t &seed, const T &v) {
  std::hash<T> hasher;
  seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
template <typename T, int n>
struct VectorHash {
  inline std::size_t operator()(const Vector<T, n> &v) const {
    std::size_t seed = 0;
    for (int(i) = (0); (i) < (n); ++(i)) {
      hash_combine(seed, v[i]);
    }
    return seed;
  }
};
const int max_n = 100000;
int n;
double a, d;
int speeds[max_n], times[max_n];
typedef Vector<double, 4> Vd4;
Vd4 segments[max_n];
int segment_count = 0;
double solve(double a, double b, double c) {
  return (-b + sqrt(b * b - 4 * a * c)) / 2 / a;
}
double solveid(int segid, int bid) {
  double t0 = times[bid], v = segments[segid][3], ts = segments[segid][0],
         ds = segments[segid][2];
  double a1 = a / 2, b1 = -(a * t0 + v), c1 = a * t0 * t0 / 2 + v * ts - v * ds;
  return solve(a1, b1, c1);
}
double solveseg(double x, double y, double s, int segid) {
  if (s == segments[segid][3]) {
    return -1;
  }
  return (segments[segid][2] - segments[segid][0] * segments[segid][3] - y +
          x * s) /
         (s - segments[segid][3]);
}
int main2() {
  int aint, dint;
  scanf(n, aint, dint);
  a = aint;
  d = dint;
  for (int(i) = (0); (i) < (n); ++(i)) {
    scanf(times[i], speeds[i]);
  }
  double last_speed = INF, last_speed_time = INF;
  for (int(i) = (0); (i) < (n); ++(i)) {
    int type = 2;
    for (int(j) = (segment_count - 1); (j) >= (0); --(j)) {
      double t = solveid(j, i);
      if (t > speeds[i] / a) {
        type = 0;
        break;
      }
      if (t < segments[j][0]) {
        type = 0;
        break;
      } else if (t <= segments[j][1]) {
        type = 1;
        segments[j][2] += (t - segments[j][0]) * segments[j][3];
        segments[j][0] = t;
        break;
      } else {
        segment_count--;
      }
    }
    if (type == 0) {
      double t = speeds[i] / a;
      double dist = a * t * t / 2;
      bool find = false;
      for (int(j) = (segment_count - 1); (j) >= (0); --(j)) {
        double t1 = solveseg(t + times[i], dist, speeds[i], j);
        if (t1 < t + times[i] || t1 < segments[j][0] || t1 > segments[j][1]) {
          segment_count--;
        } else {
          find = true;
          segments[j][2] += segments[j][3] * (t1 - segments[j][0]);
          segments[j][0] = t1;
          segments[j + 1][0] = t + times[i];
          segments[j + 1][1] = t1;
          segments[j + 1][2] = dist;
          segments[j + 1][3] = speeds[i];
          segment_count++;
          break;
        }
      }
      if (find == false) {
        segment_count = 1;
        segments[0][0] = t + times[i];
        segments[0][1] = segments[0][0] + (d - dist) / speeds[i];
        segments[0][2] = dist;
        segments[0][3] = speeds[i];
      }
    } else if (type == 2) {
      segment_count = 1;
      double t = speeds[i] / a;
      double dist = a * t * t / 2;
      if (dist >= d) {
        t = sqrt(2 * d / a);
        segments[0][0] = times[i] + t;
        segments[0][1] = segments[0][0];
        segments[0][2] = d;
        segments[0][3] = t * a;
      } else {
        segments[0][0] = times[i] + t;
        segments[0][1] = segments[0][0] + (d - dist) / speeds[i];
        segments[0][2] = dist;
        segments[0][3] = speeds[i];
      }
    }
    printf(segments[0][1]);
  }
  return 0;
}
int main() {
  int aint, dint;
  scanf(n, aint, dint);
  a = aint;
  d = dint;
  for (int(i) = (0); (i) < (n); ++(i)) {
    scanf(times[i], speeds[i]);
  }
  double last_time = 0;
  for (int(i) = (0); (i) < (n); ++(i)) {
    double t = speeds[i] / a;
    double dist = a * t * t / 2;
    if (dist >= d) {
      t = sqrt(2 * d / a);
    } else {
      t = t + (d - dist) / speeds[i];
    }
    last_time = max(last_time, t + times[i]);
    printf(last_time);
  }
  return 0;
}
