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>
#pragma comment(linker, "/stack:64000000")
using namespace std;
template <typename first>
inline first abs(const first& a) {
  return a < 0 ? -a : a;
}
template <typename first>
inline first sqr(const first& a) {
  return a * a;
}
const long double PI = 3.1415926535897932384626433832795;
const long double EPS = 1e-9;
const int INF = 1000 * 1000 * 1000;
struct pt {
  long double x, y;
  pt(long double x = 0.0, long double y = 0.0) : x(x), y(y) {}
};
const int N = 500 + 13;
int n, h, f;
int lf[N], rg[N];
pt focus, mfocus;
pt lftop, rgtop, lfbot, rgbot;
inline long double det(const long double& ax, const long double& ay,
                       const long double& bx, const long double& by) {
  return ax * by - ay * bx;
}
inline bool between(const pt& c, const pt& a, const pt& b) {
  if (c.x + EPS < min(a.x, b.x) || c.x > max(a.x, b.x) + EPS) return false;
  if (c.y + EPS < min(a.y, b.y) || c.y > max(a.y, b.y) + EPS) return false;
  return true;
}
inline bool intersect(const pt& a, const pt& b, const pt& c, const pt& d, pt& p,
                      bool segm) {
  long double A1 = b.y - a.y, B1 = a.x - b.x, C1 = -(a.x * A1 + a.y * B1);
  long double A2 = d.y - c.y, B2 = c.x - d.x, C2 = -(c.x * A2 + c.y * B2);
  long double Det = det(A1, B1, A2, B2);
  if (abs(Det) < EPS) return false;
  p.x = det(-C1, B1, -C2, B2) / Det;
  p.y = det(A1, -C1, A2, -C2) / Det;
  if (segm) return between(p, a, b) && between(p, c, d);
  return true;
}
inline long double square(const vector<pt>& pol) {
  long double res = 0.0;
  for (int i = 0; i < int(int((pol).size())); i++) {
    int nexti = (i + 1 == int((pol).size()) ? 0 : i + 1);
    res += (pol[nexti].x - pol[i].x) * (pol[nexti].y + pol[i].y);
  }
  return abs(res) * 0.5;
}
inline int sign(const long double& c) {
  return c > EPS ? 1 : c < -EPS ? -1 : 0;
}
void cut(vector<pt>& pol, pt a, pt b, const pt& c) {
  if (int((pol).size()) < 3) return;
  long double A = b.y - a.y, B = a.x - b.x, C = -(a.x * A + a.y * B);
  int s = sign(A * c.x + B * c.y + C);
  pt v = pt((b.x - a.x) * 1e6, (b.y - a.y) * 1e6);
  a = pt(a.x - v.x, a.y - v.y);
  b = pt(b.x + v.x, b.y + v.y);
  vector<pt> ans;
  for (int i = 0; i < int(int((pol).size())); i++) {
    int nexti = (i + 1 == int((pol).size()) ? 0 : i + 1);
    int s1 = sign(A * pol[i].x + B * pol[i].y + C) * s;
    int s2 = sign(A * pol[nexti].x + B * pol[nexti].y + C) * s;
    if ((s1 < 0 && s2 < 0) || (s1 == 0 && s2 < 0)) continue;
    if (s1 * s2 < 0) {
      pt p;
      assert(intersect(pol[i], pol[nexti], a, b, p, true));
      ans.push_back(p);
      if (s2 > 0) ans.push_back(pol[nexti]);
      continue;
    }
    ans.push_back(pol[nexti]);
  }
  pol = ans;
}
int main() {
  cin >> n >> h >> f;
  focus = pt(0.0, f);
  mfocus = pt(0.0, -f);
  lftop = pt(-1e7, h);
  rgtop = pt(1e7, h);
  lfbot = pt(-1e7, -h);
  rgbot = pt(1e7, -h);
  for (int i = 0; i < int(n); i++) scanf("%d%d", &lf[i], &rg[i]);
  long double S = 0.0;
  for (int i = 0; i < int(n); i++) {
    vector<pt> pol;
    pt plf = pt(lf[i], h), prg = pt(rg[i], h);
    pt cur;
    assert(intersect(focus, plf, lftop, rgtop, cur, false));
    pol.push_back(cur);
    assert(intersect(focus, plf, lfbot, rgbot, cur, false));
    pol.push_back(cur);
    assert(intersect(focus, prg, lfbot, rgbot, cur, false));
    pol.push_back(cur);
    assert(intersect(focus, prg, lftop, rgtop, cur, false));
    pol.push_back(cur);
    long double spol = square(pol);
    S += 2.0 * spol;
    for (int j = 0; j < int(n); j++) {
      pt nplf = pt(lf[j], -h), nprg = pt(rg[j], -h);
      vector<pt> npol = pol;
      cut(npol, mfocus, nplf, nprg);
      cut(npol, mfocus, nprg, nplf);
      long double s = square(npol);
      if (s + EPS < spol) S -= s;
    }
  }
  cout << setprecision(10) << fixed;
  cout << S << endl;
  return 0;
}
