Consider a house plan. 

Let the house be represented by an infinite horizontal strip defined by the inequality  - h ≤ y ≤ h. Strictly outside the house there are two light sources at the points (0, f) and (0, - f). Windows are located in the walls, the windows are represented by segments on the lines y = h and y = - h. Also, the windows are arranged symmetrically about the line y = 0.

Your task is to find the area of the floor at the home, which will be lighted by the sources of light. 

<image>

Input

The first line of the input file contains three integers n, h and f (1 ≤ n ≤ 500, 1 ≤ h ≤ 10, h < f ≤ 1000). Next, n lines contain two integers each li, ri ( - 5000 ≤ li < ri ≤ 5000), each entry indicates two segments. Endpoints of the first segment are (li, h)-(ri, h), and endpoints of the second segment are (li, - h)-(ri, - h). These segments describe location of windows. Numbers in the lines are space-separated. It is guaranteed that no two distinct segments have common points. 

Output

Print the single real number — the area of the illuminated part of the floor with an absolute or relative error of no more than 10 - 4.

Examples

Input

1 1 2
-1 1


Output

10.0000000000


Input

2 2 4
-1 0
1 2


Output

23.3333333333

Note

The second sample test is shown on the figure. Green area is the desired area of the illuminated part of the floor. Violet segments indicate windows.
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8, PI = acos(-1.0);
double dot(complex<double> a, complex<double> b) { return real(conj(a) * b); }
double cross(complex<double> a, complex<double> b) { return imag(conj(a) * b); }
int ccw(complex<double> a, complex<double> b, complex<double> c) {
  b -= a;
  c -= a;
  if (cross(b, c) > +EPS) return +1;
  if (cross(b, c) < -EPS) return -1;
  if (dot(b, c) < 0) return +2;
  if (norm(b) < norm(c)) return -2;
  return 0;
}
struct L : public vector<complex<double> > {
  L(const complex<double> &a, const complex<double> &b) {
    push_back(a);
    push_back(b);
  }
};
complex<double> intersection_ll(L s, L t) {
  complex<double> sv = s[1] - s[0], tv = t[1] - t[0];
  assert(!(abs((cross(sv, tv)) - (0.0)) < EPS));
  return s[0] + sv * cross(tv, t[0] - s[0]) / cross(tv, sv);
}
void convex_cut(vector<complex<double> > &g, L l) {
  vector<complex<double> > ret;
  for (int j = 0; j < (int)((int)((g).size())); ++j) {
    complex<double> A = g[j], B = g[(j + 1) % (int)((g).size())];
    if (ccw(l[0], l[1], A) != -1) ret.push_back(A);
    if (ccw(l[0], l[1], A) * ccw(l[0], l[1], B) == -1)
      ret.push_back(intersection_ll(L(A, B), l));
  }
  g = ret;
}
double area2(vector<complex<double> > &g) {
  double A = 0;
  for (int j = 0; j < (int)((int)((g).size())); ++j)
    A += cross(g[j], g[(j + 1) % (int)((g).size())]);
  return A;
}
double lpos[550], rpos[550];
vector<complex<double> > shadow[550];
int main() {
  int N;
  double h, f;
  while (scanf("%d %lf %lf", &N, &h, &f) != EOF) {
    for (int j = 0; j < (int)(N); ++j) scanf("%lf %lf", &lpos[j], &rpos[j]);
    double res = 0;
    for (int j = 0; j < (int)(N); ++j) shadow[j].clear();
    for (int j = 0; j < (int)(N); ++j) {
      shadow[j].push_back(complex<double>(rpos[j], h));
      shadow[j].push_back(complex<double>(lpos[j], h));
      shadow[j].push_back(complex<double>((f + h) / (f - h) * lpos[j], -h));
      shadow[j].push_back(complex<double>((f + h) / (f - h) * rpos[j], -h));
    }
    for (int j = 0; j < (int)(N); ++j) res += area2(shadow[j]);
    for (int j = 0; j < (int)(N); ++j)
      for (int k = 0; k < (int)(N); ++k) {
        vector<complex<double> > tmp = shadow[j];
        convex_cut(tmp,
                   L(complex<double>(0, -f), complex<double>(rpos[k], -h)));
        convex_cut(tmp,
                   L(complex<double>(lpos[k], -h), complex<double>(0, -f)));
        res -= area2(tmp) / 2.0;
      }
    printf("%.12f\n", res);
  }
}
