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>.
import java.io.*;
import java.util.*;

public class Solution {
	public final static int MOD = 1000000007;
	public static int count = 0;
	public static int dx[] = {-1,1,0,0};
	public static int dy[] = {0,0,-1,1};
	public static int max = 0;
	public static LinkedList<Integer> adj[];
	@SuppressWarnings("unchecked")
	public static void main(String[] args) throws IOException {
		InputReader scan = new InputReader(System.in);
	   	OutputStream outputStream = System.out;
	   	PrintWriter pw = new PrintWriter(outputStream);
	   	StringBuilder sb = new StringBuilder();
	   	int n = scan.nextInt();
	   	int u = scan.nextInt();
	   	int energy[] = new int[n];
	   	TreeSet<Integer> ts = new TreeSet<>();
	   	for(int i=0;i<n;i++){
	   		energy[i] = scan.nextInt();
	   		ts.add(energy[i]);
	   	}
	   	double ans = Double.MIN_VALUE;
	   	for(int i=0;i<n-2;i++)
	   	{
	   		int temp = ts.floor(u+energy[i]);
	   		if(temp!=energy[i+1])
	   			ans = Math.max(ans, ((double)(temp-energy[i+1])/(double)(temp-energy[i])));
	   	}
	   	if(ans==Double.MIN_VALUE)
	   		pw.println(-1);
	   	else
	   		pw.println(ans);
	   	pw.close();
	}
	public static int dfs(int node,int parent,int arr[],int k)
	{
		int max = 0,sec_max = 0;
		for(int i=0;i<adj[node].size();i++)
		{
			if(adj[node].get(i)!=parent){
				int t = dfs(adj[node].get(i),node,arr,k);
				if(max<t)
				{
					sec_max = max;
					max = t;
				}
				else if(sec_max<t)
					sec_max = t;
			}
		}
		if(arr[node]%k==0){
			count = Math.max(count, sec_max+max+1);
			return sec_max+max+1;
		}
		else
			return 0;
	}
	static class Pair{
		int i,j,p;
		Pair(int a,int b,int parent)
		{
			i = a;
			j = b;
			p = parent;
		}
	}
	public static void buildTree(int arr[],int tree[],int node,int start,int end)
	{
		if(start==end)
		{
			tree[node] = arr[start];
			return;
		}
		int mid = (start+end)/2;
		buildTree(arr,tree,2*node,start,mid);
		buildTree(arr,tree,2*node+1,mid+1,end);
		tree[node] = tree[2*node]+tree[2*node+1];
	}
	public static void update(int arr[],int tree[],int node,int inx,int val,int start,int end)
	{ 
		if(start==end)
		{
			tree[node] = val;
			arr[inx] = val;
			return;
		}
		int mid = (start+end)/2;
		if(inx<=mid)
			update(arr,tree,2*node,inx,val,start,mid);
		else
			update(arr,tree,2*node+1,inx,val,mid+1,end);
		tree[node] = tree[2*node]+tree[2*node+1];
	}
	public static int query(int tree[],int node,int l,int r,int start,int end)
	{
		if(r<start || l>end)
			return 0;
		if(l<=start && end<=r)
			return tree[node];
		int mid = (start+end)/2;
		int ans1 = query(tree,2*node,l,r,start,mid);
		int ans2 = query(tree,2*node+1,l,r,mid+1,end);
		return ans1+ans2;
	}
	public static void merge(int arr[],int start,int mid,int end)
	{
		int l = start, r = mid+1;
		int temp[] = new int[end-start+1];
		int k = 0;
		for(int i=start;i<=end;i++)
		{
			if(l>mid)
				temp[k++] = arr[r++];
			else if(r>end)
				temp[k++] = arr[l++];
			else if(arr[l]<=arr[r])
				temp[k++] = arr[l++];
			else{
				temp[k++] = arr[r++];
				count+=(mid-l+1);
			}
		}
		for(int i=0;i<k;i++)
			arr[start++] = temp[i];
	}
	public static void mergeSort(int arr[],int l,int r)
	{
		if(l<r){
			int mid = (l+r)/2;
			mergeSort(arr,l,mid);
			mergeSort(arr,mid+1,r);
			merge(arr,l,mid,r);
		}
	}
	public static void sieve(int spf[],int n)
	{
		for(int i=1;i<=n;i++)
			spf[i] = i;
		for(int i=2;i*i<=n;i++)
		{
			if(spf[i]==i)
			{
				for(int j=i;j<=n;j+=i)
					if(spf[j]==j)
						spf[j] = i;
			}
		}
	}
	public static void factors(int n,int spf[],ArrayList<Integer> factors)
	{
		int pre = 0;
		while(n!=1)
		{
			int temp = spf[n];
			if(temp!=pre)
			{
				factors.add(temp);
				pre = temp;
			}
			n/=temp;
		}
	}
	public static boolean isPrime(int n)
	{
		if(n==0 || n==1)
			return false;
		int limit = (int)Math.sqrt(n);
		for(int i=2;i<=limit;i++)
		{
			if(n%i==0)
				return false;
		}
		return true;
	}
	public static long pow(long a,long b,int m)
	{
		long result = 1;
		while(b>0)
		{
			if(b%2==1)
				result = ((result%m)*(a%m))%m;
			a = ((a%m)*(a%m))%m;
			b/=2;
		}
		return result;
	}
	public static long mulinv(long a,long m)
	{
		long arr[] = new long[2];
		long gcd = gcdExtended(a,m,arr);
		if(gcd==1)
			return (arr[0]%m+m)%m;
		else
			return Integer.MAX_VALUE;
	}
	public static long gcdExtended(long a,long b,long arr[])
	{
		if (a == 0)
	    {
	        arr[0] = 0;
	        arr[1] = 1;
	        return b;
	    }
	    long gcd = gcdExtended(b%a, a, arr);
	    long temp = arr[0];
	    arr[0] = arr[1] - (b/a) * arr[0];
	    arr[1] = temp;
	    return gcd;
	}
	public static long kadane(int items[])
	{
		int n = items.length;
		long max = (long)items[0];
		long curr_max = (long)items[0];
		for(int i=1;i<n;i++)
		{
			curr_max = Math.max((long)curr_max+items[i], items[i]);
			max = Math.max(max, curr_max);
		}
		return max;
	}
	public static long gcd(int a,int b)
	{
		if(a%b==0){
			return pow(2,a-1,MOD);
		}
		long ans = gcd(b,a%b);
		int len = 0;
		long ans1 = 0;
		while(len<a)
		{
			if(a-len-b<0)
			{
				ans = ans>>(len+b-a);
				ans1 = (ans1+ans)%MOD;
			}
			else
				ans1 = (ans1+(ans*pow(2,a-b-len,MOD))%MOD)%MOD;
			len+=b;
		}
		System.out.println(ans1);
		return ans1;
	}
	public static int LCS(String s1,String s2) //Longest common subsequence
	{
		int n = s1.length();
		int m = s2.length();
		int lcs[][] = new int[n+1][m+1];
		for(int i=0;i<=n;i++)
		{
			for(int j=0;j<=m;j++)
			{
				if(i==0 || j==0)
					lcs[i][j] = 0;
				else if(s1.charAt(i-1)==s2.charAt(j-1))
					lcs[i][j] = lcs[i-1][j-1] + 1;
				else
					lcs[i][j] = Math.max(lcs[i][j-1], lcs[i-1][j]);
			}
		}
		return lcs[n][m];
	}
	static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;
 
        public FastReader()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }
 
        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
 
        int nextInt()
        {
            return Integer.parseInt(next());
        }
 
        long nextLong()
        {
            return Long.parseLong(next());
        }
 
        double nextDouble()
        {
            return Double.parseDouble(next());
        }
 
        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
}
class InputReader {
    public BufferedReader reader;
	public StringTokenizer tokenizer;
    public InputReader(InputStream inputstream) {
        reader = new BufferedReader(new InputStreamReader(inputstream));
		tokenizer = null;
	}
    public String nextLine(){
        String fullLine=null;
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
		    try {
		        fullLine=reader.readLine();
		    } catch (IOException e) {
    			throw new RuntimeException(e);
    			}
        		return fullLine;
        }
		return fullLine;
	}
    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
    			tokenizer = new StringTokenizer(reader.readLine());
    		} catch (IOException e) {
        		throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }
    public long nextLong() {
        return Long.parseLong(next());
	}
	public int nextInt() {
		return Integer.parseInt(next());
	}
}