#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
#include <functional>
using namespace std;
using pairint = pair<int, int>;

template <typename T>
struct SegmentTree{
    SegmentTree(unsigned int n, function<T(T, T)> AssociativeFunction, T ZeroElement=0){
        length = 1;
        fn = AssociativeFunction;
        z = ZeroElement;
        while(length < n*2){
            length <<= 1;
        }
        Nodes.assign(length, z);
    }
    void assign(unsigned int index, T value){
        unsigned int initindex = (length>>1) + index;
        Nodes[initindex] = value;
        for(unsigned int i=initindex>>1; i>0; i>>=1){
            Nodes[i] = fn(Nodes[i*2], Nodes[i*2+1]);
        }
    }
    T element(unsigned int index){
        return Nodes[(length>>1) + index];
    }
    T query(unsigned int lindex, unsigned int rindex){
        int l = (length>>1) + lindex;
        int r = (length>>1) + rindex;
        T res = z;
        while(l <= r){
            if(r==l){
                if(res==z){
                    res = Nodes[l];
                }else res = fn(res, Nodes[l]);
                break;
            }
            if(l%2==1){
                if(res==z){
                    res = Nodes[l];
                }else res = fn(res, Nodes[l]);
                l += 2;
            }
            if(r%2==0){
                if(res==z){
                    res = Nodes[r];
                }else res = fn(res, Nodes[r]);
                r -= 2;
            }
            l>>=1;
            r>>=1;
        }
        return res;
    }

private:
    T z;
    unsigned int length;
    vector<T> Nodes;
    function<T(T, T)> fn;
};

int main(void){
    int H, W, M, Xbuf, Ybuf;
    long long res = 0;
    vector<int> leftmost, uppermost;
    priority_queue<pairint, vector<pairint>, greater<pairint>> que;
    cin >> H >> W >> M;
    leftmost.assign(H, W);
    uppermost.assign(W, H);
    for(int i=0; i<M; i++){
        cin >> Xbuf >> Ybuf;
        Xbuf--;
        Ybuf--;
        leftmost[Xbuf] = min(leftmost[Xbuf], Ybuf);
        uppermost[Ybuf] = min(uppermost[Ybuf], Xbuf);
        que.push(pairint(Ybuf, Xbuf));
    }
    for(int i=0; i<uppermost[0]; i++)res += leftmost[i];
    SegmentTree<int> st(H, plus<int>());
    for(int i=uppermost[0]; i<H; i++)st.assign(i, 1);
    for(int i=0; i<leftmost[0]; i++){
        if(!que.empty()){
        pairint nxtObstruction = que.top();
            while(nxtObstruction.first < i){
                que.pop();
                if(nxtObstruction.second < uppermost[0])st.assign(nxtObstruction.second, 1);
                if(que.empty())break;
                nxtObstruction = que.top();
            }
        }
        res += st.query(0, uppermost[i]-1);
    }
    cout << res << endl;
    return 0;
}
#include <bits/stdc++.h>
using namespace std;


int main(){

  int N,D,H;
  cin >>N>>D>>H;
  vector<int>d(N),h(N);
  for(int i=0; i<N; i++) cin >> d[i]>>h[i];

  cout << fixed << setprecision(10);

  double maxi=0;
  for(int i=0; i<N; i++){
  double a=d[i]-D;
  double b=H*d[i]-D*h[i];
  double n = b/a;
    maxi=max(maxi,n);
  }

  cout << maxi<<endl;
        
}