#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;
}

### Prompt

Please create a solution in cpp to the following problem:

In some country live wizards. They love to ride trolleybuses.

A city in this country has a trolleybus depot with n trolleybuses. Every day the trolleybuses leave the depot, one by one and go to the final station. The final station is at a distance of d meters from the depot. We know for the i-th trolleybus that it leaves at the moment of time ti seconds, can go at a speed of no greater than vi meters per second, and accelerate with an acceleration no greater than a meters per second squared. A trolleybus can decelerate as quickly as you want (magic!). It can change its acceleration as fast as you want, as well. Note that the maximum acceleration is the same for all trolleys.

Despite the magic the trolleys are still powered by an electric circuit and cannot overtake each other (the wires are to blame, of course). If a trolleybus catches up with another one, they go together one right after the other until they arrive at the final station. Also, the drivers are driving so as to arrive at the final station as quickly as possible.

You, as head of the trolleybuses' fans' club, are to determine for each trolley the minimum time by which it can reach the final station. At the time of arrival at the destination station the trolleybus does not necessarily have zero speed. When a trolley is leaving the depot, its speed is considered equal to zero. From the point of view of physics, the trolleybuses can be considered as material points, and also we should ignore the impact on the speed of a trolley bus by everything, except for the acceleration and deceleration provided by the engine.

Input

The first input line contains three space-separated integers n, a, d (1 ≤ n ≤ 105, 1 ≤ a, d ≤ 106) — the number of trolleybuses, their maximum acceleration and the distance from the depot to the final station, correspondingly.

Next n lines contain pairs of integers ti vi (0 ≤ t1 < t2... < tn - 1 < tn ≤ 106, 1 ≤ vi ≤ 106) — the time when the i-th trolleybus leaves the depot and its maximum speed, correspondingly. The numbers in the lines are separated by spaces.

Output

For each trolleybus print a single line the time it arrives to the final station. Print the times for the trolleybuses in the order in which the trolleybuses are given in the input. The answer will be accepted if the absolute or relative error doesn't exceed 10 - 4.

Examples

Input

3 10 10000
0 10
5 11
1000 1


Output

1000.5000000000
1000.5000000000
11000.0500000000


Input

1 2 26
28 29


Output

33.0990195136

Note

In the first sample the second trolleybus will catch up with the first one, that will happen at distance 510.5 meters from the depot. The trolleybuses will go the remaining 9489.5 meters together at speed 10 meters per second. As a result, both trolleybuses will arrive to the final station by the moment of time 1000.5 seconds. The third trolleybus will not catch up with them. It will arrive to the final station by the moment of time 11000.05 seconds.

### Response

```cpp
#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;
}

```