#include <iostream>
#include<algorithm>
using namespace std;

int main(int argc, const char * argv[]) {
    int N=0,i=0;
    double D=0,H=0,d=0,h=0,m=0,ans=0,minmin=0;
    cin>>N>>D>>H;
    for(;i<N;i++){
        cin>>d>>h;
        m=(H-h)/(D-d);
        m*=d;
        ans=h-m;
        if(ans>minmin) minmin=ans;
    }
    cout<<minmin<<endl;
    return 0;
}
#include <bits/stdc++.h>
#include <unordered_set>
using namespace std;

#define INF 1e9
#define LLINF 1e18
#define PI 3.14159265358979323
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
typedef long double ld;

ll gcd(ll a, ll b) {
    if(a % b == 0) {
        return b;
    }
    else {
        return(gcd(b, a % b));
    }
}

ll lcm(ll x,ll y){
    return ll(x / gcd(x, y)) * y;
}

//素因数分解vector<pair<素因数, 個数>>
vector<pair<ll, ll> > prime_factorize(ll n) {
    vector<pair<ll, ll> > res;
    for (ll p = 2; p * p <= n; ++p) {
        if (n % p != 0) continue;
        int num = 0;
        while(n % p == 0) {
            ++num;
            n /= p;
        }
        res.push_back(make_pair(p, num));
    }
    if (n != 1) res.push_back(make_pair(n, 1));
    return res;
}

vector<ll> divisor(ll n) {
    vector<ll> ret;
    for (ll i = 1; i * i <= n; i++) {
        if (n % i == 0) {
            ret.push_back(i);
            if (i * i != n) ret.push_back(n / i);
        }
    }
    sort(ret.begin(), ret.end());
    return ret;
}

struct UnionFind {
    vector<int> par, siz;

    UnionFind(int n) : par(n, -1), siz(n, 1) {}

    int root(int x) {
        if (par[x] == -1) return x;
        else return par[x] = root(par[x]);
    }

    bool issame(int x, int y) {
        return root(x) == root(y);
    }

    bool unite(int x, int y) {
        x = root(x);
        y = root(y);
        if (x == y) return false;
        if (siz[x] < siz[y]) swap(x, y);
        par[y] = x;
        siz[x] += siz[y];
        return true;
    }

    int size(int x) {
        return siz[root(x)];
    }
};


int main() {
    int n;
    ld d, h;
    cin >> n >> d >> h;
    vector<ld> x(n), y(n);
    ld ans = 0;
    rep(i, n) {
        cin >> x[i] >> y[i];
        ld num;
        if (x[i] == d) num = 0;
        else num = h - d * (h - y[i]) / (d - x[i]);
        ans = max(num, ans);
    }
    cout << fixed << setprecision(20) << ans << endl;
}