Problem: An atom of element X can exist in n distinct states with energies E1 < E2 < ... < En. Arkady wants to build a laser on this element, using a three-level scheme. Here is a simplified description of the scheme. 

Three distinct states i, j and k are selected, where i < j < k. After that the following process happens: 

  1. initially the atom is in the state i,
  2. we spend Ek - Ei energy to put the atom in the state k,
  3. the atom emits a photon with useful energy Ek - Ej and changes its state to the state j,
  4. the atom spontaneously changes its state to the state i, losing energy Ej - Ei,
  5. the process repeats from step 1. 



Let's define the energy conversion efficiency as <image>, i. e. the ration between the useful energy of the photon and spent energy.

Due to some limitations, Arkady can only choose such three states that Ek - Ei ≤ U.

Help Arkady to find such the maximum possible energy conversion efficiency within the above constraints.

Input

The first line contains two integers n and U (3 ≤ n ≤ 105, 1 ≤ U ≤ 109) — the number of states and the maximum possible difference between Ek and Ei.

The second line contains a sequence of integers E1, E2, ..., En (1 ≤ E1 < E2... < En ≤ 109). It is guaranteed that all Ei are given in increasing order.

Output

If it is not possible to choose three states that satisfy all constraints, print -1.

Otherwise, print one real number η — the maximum possible energy conversion efficiency. Your answer is considered correct its absolute or relative error does not exceed 10 - 9.

Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.

Examples

Input

4 4
1 3 5 7


Output

0.5


Input

10 8
10 13 15 16 17 19 20 22 24 25


Output

0.875


Input

3 1
2 5 10


Output

-1

Note

In the first example choose states 1, 2 and 3, so that the energy conversion efficiency becomes equal to <image>.

In the second example choose states 4, 5 and 9, so that the energy conversion efficiency becomes equal to <image>.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
void make_sets(int *p, int *s, int n) {
  for (int i = 0; i < n; i++) {
    p[i] = i;
    s[i] = 1;
  }
}
int find_set(int *p, int v) {
  if (v == p[v]) return v;
  return p[v] = find_set(p, p[v]);
}
void union_sets(int *p, int *s, int a, int b) {
  a = find_set(p, a);
  b = find_set(p, b);
  if (a != b) {
    if (s[a] < s[b]) swap(a, b);
    p[b] = a;
    s[a] += s[b];
  }
}
long long fibo(long long n) {
  long long M[2][2] = {{1, 1}, {1, 0}}, res[2][2] = {{1, 0}, {0, 1}}, a, b, c,
            d;
  while (n) {
    if (n % 2) {
      a = (res[0][0] * M[0][0]) + (res[0][1] * M[1][0]);
      b = (res[0][0] * M[1][0]) + (res[0][1] * M[1][1]);
      c = (res[1][0] * M[0][0]) + (res[1][1] * M[1][0]);
      d = (res[1][0] * M[1][0]) + (res[1][1] * M[1][1]);
      res[0][0] = a;
      res[0][1] = b;
      res[1][0] = c;
      res[1][1] = d;
    }
    a = (M[0][0] * M[0][0]) + (M[0][1] * M[1][0]);
    b = (M[0][0] * M[1][0]) + (M[0][1] * M[1][1]);
    c = (M[1][0] * M[0][0]) + (M[1][1] * M[1][0]);
    d = (M[1][0] * M[1][0]) + (M[1][1] * M[1][1]);
    M[0][0] = a;
    M[0][1] = b;
    M[1][0] = c;
    M[1][1] = d;
    n >>= 1;
  }
  return res[0][1];
}
long long fibo(long long n, long long m) {
  long long M[2][2] = {{1, 1}, {1, 0}}, res[2][2] = {{1, 0}, {0, 1}}, a, b, c,
            d;
  while (n) {
    if (n % 2) {
      a = (res[0][0] * M[0][0]) % m + (res[0][1] * M[1][0]) % m;
      b = (res[0][0] * M[1][0]) % m + (res[0][1] * M[1][1]) % m;
      c = (res[1][0] * M[0][0]) % m + (res[1][1] * M[1][0]) % m;
      d = (res[1][0] * M[1][0]) % m + (res[1][1] * M[1][1]) % m;
      res[0][0] = a % m;
      res[0][1] = b % m;
      res[1][0] = c % m;
      res[1][1] = d % m;
    }
    a = (M[0][0] * M[0][0]) % m + (M[0][1] * M[1][0]) % m;
    b = (M[0][0] * M[1][0]) % m + (M[0][1] * M[1][1]) % m;
    c = (M[1][0] * M[0][0]) % m + (M[1][1] * M[1][0]) % m;
    d = (M[1][0] * M[1][0]) % m + (M[1][1] * M[1][1]) % m;
    M[0][0] = a % m;
    M[0][1] = b % m;
    M[1][0] = c % m;
    M[1][1] = d % m;
    n >>= 1;
  }
  return res[0][1];
}
unsigned long long bpow(unsigned long long a, unsigned long long b) {
  unsigned long long res = 1;
  while (b > 0) {
    if (b & 1) res = res * a;
    a = a * a;
    b >>= 1;
  }
  return res;
}
long long bpow(long long a, long long b, long long m) {
  a %= m;
  long long res = 1;
  while (b > 0) {
    if (b & 1) res = res * a % m;
    a = a * a % m;
    b >>= 1;
  }
  return res;
}
void bppow(int p[], int n, int k, int res[]) {
  int np[n], r[n];
  memcpy(res, p, n * sizeof(int));
  for (int j = 0; j < n; j++) r[j] = j;
  while (k > 0) {
    if (k % 2) {
      for (int j = 0; j < n; j++) np[j] = r[res[j]];
      memcpy(r, np, n * sizeof(int));
    }
    for (int j = 0; j < n; j++) np[j] = res[res[j]];
    memcpy(res, np, n * sizeof(int));
    k >>= 1;
  }
  memcpy(res, r, n * sizeof(int));
}
int modInverse(int a, int m) {
  int m0 = m;
  int y = 0, x = 1;
  if (m == 1) return 0;
  if (a % m == 0) return 0;
  while (a > 1) {
    int q = a / m;
    int t = m;
    m = a % m, a = t;
    t = y;
    y = x - q * y;
    x = t;
  }
  if (x < 0) x += m0;
  return x;
}
long long gcd(long long a, long long b, long long &x, long long &y) {
  if (a == 0) {
    x = 0;
    y = 1;
    return b;
  }
  long long x1, y1;
  long long d = gcd(b % a, a, x1, y1);
  x = y1 - (b / a) * x1;
  y = x1;
  return d;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
bool find_any_solution(long long a, long long b, long long c, long long &x0,
                       long long &y0, long long &g) {
  g = gcd(abs(a), abs(b), x0, y0);
  if (c % g) {
    return false;
  }
  x0 *= c / g;
  y0 *= c / g;
  if (a < 0) x0 = -x0;
  if (b < 0) y0 = -y0;
  return true;
}
void shift_solution(long long &x, long long &y, long long a, long long b,
                    long long cnt) {
  x += cnt * b;
  y -= cnt * a;
}
long long find_all_solutions(long long a, long long b, long long c,
                             long long minx, long long maxx, long long miny,
                             long long maxy) {
  long long x, y, g;
  if (!find_any_solution(a, b, c, x, y, g)) return 0;
  a /= g;
  b /= g;
  long long sign_a = a > 0 ? +1 : -1;
  long long sign_b = b > 0 ? +1 : -1;
  shift_solution(x, y, a, b, (minx - x) / b);
  if (x < minx) shift_solution(x, y, a, b, sign_b);
  if (x > maxx) return 0;
  long long lx1 = x;
  shift_solution(x, y, a, b, (maxx - x) / b);
  if (x > maxx) shift_solution(x, y, a, b, -sign_b);
  long long rx1 = x;
  shift_solution(x, y, a, b, -(miny - y) / a);
  if (y < miny) shift_solution(x, y, a, b, -sign_a);
  if (y > maxy) return 0;
  long long lx2 = x;
  shift_solution(x, y, a, b, -(maxy - y) / a);
  if (y > maxy) shift_solution(x, y, a, b, sign_a);
  long long rx2 = x;
  if (lx2 > rx2) swap(lx2, rx2);
  long long lx = max(lx1, lx2);
  long long rx = min(rx1, rx2);
  if (lx > rx) return 0;
  return (rx - lx) / abs(b) + 1;
}
vector<int> primes(int n) {
  vector<int> pr;
  int *lp = new int[n + 1];
  memset(lp, 0, (n + 1) * sizeof(int));
  for (int i = 2; i <= n; ++i) {
    if (lp[i] == 0) {
      lp[i] = i;
      pr.push_back(i);
    }
    for (int j = 0; j < pr.size() && pr[j] <= lp[i] && i * pr[j] <= n; ++j)
      lp[i * pr[j]] = pr[j];
  }
  for (int i = 0; i <= n; i++) {
    cout << lp[i] << " ";
  }
  cout << endl;
  return pr;
}
vector<int> factorize(int n) {
  vector<int> factorization;
  int t[] = {2, 3, 5};
  for (int i = 0; i < 3; i++) {
    while (n % t[i] == 0) {
      factorization.push_back(t[i]);
      n /= t[i];
    }
  }
  static array<int, 8> increments = {{4, 2, 4, 2, 4, 6, 2, 6}};
  int i = 0;
  for (int d = 7; d * d <= n; d += increments[i++]) {
    while (n % d == 0) {
      factorization.push_back(d);
      n /= d;
    }
    if (i == 8) i = 0;
  }
  if (n > 1) factorization.push_back(n);
  return factorization;
}
int phi(int n) {
  int result = n;
  for (int i = 2; i * i <= n; i++) {
    if (n % i == 0) {
      while (n % i == 0) n /= i;
      result -= result / i;
    }
  }
  if (n > 1) result -= result / n;
  return result;
}
bool probablyPrimeFermat(unsigned long long n, unsigned long long iter = 10) {
  srand(time(NULL));
  if (n < 4) return n == 2 || n == 3;
  for (unsigned long long i = 0; i < iter; i++) {
    unsigned long long a = 2 + rand() % (n - 3);
    if (bpow(a, n - 1, n) != 1) return false;
  }
  return true;
}
map<long long, long long> mfactorize(long long n) {
  map<long long, long long> factorization;
  long long t[] = {2, 3, 5};
  for (long long i = 0; i < 3; i++) {
    while (n % t[i] == 0) {
      factorization[t[i]]++;
      n /= t[i];
    }
  }
  static array<long long, 8> increments = {{4, 2, 4, 2, 4, 6, 2, 6}};
  long long i = 0;
  for (long long d = 7; d * d <= n; d += increments[i++]) {
    while (n % d == 0) {
      factorization[d]++;
      n /= d;
    }
    if (i == 8) i = 0;
  }
  if (n > 1) factorization[n]++;
  return factorization;
}
set<long long> divisors(long long n) {
  set<long long> d;
  for (long long i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      d.insert(i);
      d.insert(n / i);
    }
  }
  return d;
}
unsigned long long divisorSum(unsigned long long n) {
  map<long long, long long> m = mfactorize(n);
  unsigned long long sum = 1;
  for (auto it = m.begin(); it != m.end(); it++) {
    unsigned long long s = 1;
    for (int i = 1; i <= it->second; i++) s += bpow(it->first, i);
    sum *= s;
  }
  return sum;
}
unsigned long long divisorNumber(unsigned long long n) {
  map<long long, long long> m = mfactorize(n);
  unsigned long long num = 1;
  for (map<long long, long long>::iterator it = m.begin(); it != m.end(); it++)
    num *= it->second + 1;
  return num;
}
int m[2000001];
int ph[2000001];
int dphi(int n) {
  int s = 0;
  int t = n;
  while (t != 1) {
    if (m[t]) return (m[n] = s + m[t]);
    if (ph[t])
      t = ph[t];
    else
      t = ph[t] = phi(t);
    s++;
  }
  return s;
}
namespace SparseTable {
const int N = 100010;
const int K = 30;
int st[N][K + 1];
int stMin[N][K + 1];
int stMax[N][K + 1];
int log[N + 1];
void logPrecomp() {
  log[1] = 0;
  for (int i = 2; i <= N; i++) log[i] = log[i / 2] + 1;
}
void precomputeSum(int *a, int n) {
  for (int i = 0; i < n; i++) st[i][0] = a[i];
  for (int j = 1; j <= K; j++)
    for (int i = 0; i + (1 << j) <= n; i++)
      st[i][j] = st[i][j - 1] + st[i + (1 << (j - 1))][j - 1];
}
void precomputeMin(int *a, int n) {
  for (int i = 0; i < n; i++) stMin[i][0] = a[i];
  for (int j = 1; j <= K; j++)
    for (int i = 0; i + (1 << j) <= n; i++)
      stMin[i][j] = min(stMin[i][j - 1], stMin[i + (1 << (j - 1))][j - 1]);
}
void precomputeMax(int *a, int n) {
  for (int i = 0; i < n; i++) stMax[i][0] = a[i];
  for (int j = 1; j <= K; j++)
    for (int i = 0; i + (1 << j) <= n; i++)
      stMax[i][j] = max(stMax[i][j - 1], stMax[i + (1 << (j - 1))][j - 1]);
}
long long sumSolve(int L, int R) {
  long long sum = 0;
  for (int j = K; j >= 0; j--) {
    if ((1 << j) <= R - L + 1) {
      sum += st[L][j];
      L += 1 << j;
    }
  }
  return sum;
}
long long minSolve(int L, int R) {
  int j = log[R - L + 1];
  return min(stMin[L][j], stMin[R - (1 << j) + 1][j]);
}
long long maxSolve(int L, int R) {
  int j = log[R - L + 1];
  return max(stMax[L][j], stMax[R - (1 << j) + 1][j]);
}
}  // namespace SparseTable
int main() {
  ios::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  long long n, u;
  cin >> n >> u;
  int E[n];
  for (int i = 0; i < n; i++) cin >> E[i];
  double ans = -1;
  long long a, c;
  a = 0;
  while (a + 2 < n) {
    c = lower_bound(E + a, E + n, E[a] + u) - E;
    if (c == n) c--;
    if (E[c] - E[a] > u) c--;
    if (c - a >= 2 and E[c] - E[a] <= u)
      ans = max(ans, (double)(E[c] - E[a + 1]) / (E[c] - E[a]));
    a++;
  }
  cout << fixed << setprecision(10) << ans << endl;
  return 0;
}