Ivan is collecting coins. There are only N different collectible coins, Ivan has K of them. He will be celebrating his birthday soon, so all his M freinds decided to gift him coins. They all agreed to three terms: 

  * Everyone must gift as many coins as others.
  * All coins given to Ivan must be different.
  * Not less than L coins from gifts altogether, must be new in Ivan's collection.



But his friends don't know which coins have Ivan already got in his collection. They don't want to spend money so they want to buy minimum quantity of coins, that satisfy all terms, irrespective of the Ivan's collection. Help them to find this minimum number of coins or define it's not possible to meet all the terms.

Input

The only line of input contains 4 integers N, M, K, L (1 ≤ K ≤ N ≤ 10^{18}; 1 ≤ M,    L ≤ 10^{18}) — quantity of different coins, number of Ivan's friends, size of Ivan's collection and quantity of coins, that must be new in Ivan's collection.

Output

Print one number — minimal number of coins one friend can gift to satisfy all the conditions. If it is impossible to satisfy all three conditions print "-1" (without quotes).

Examples

Input

20 15 2 3


Output

1

Input

10 11 2 4


Output

-1

Note

In the first test, one coin from each friend is enough, as he will be presented with 15 different coins and 13 of them will definitely be new.

In the second test, Ivan has 11 friends, but there are only 10 different coins. So all friends can't present him different coins.
					                                import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.InputMismatchException;
			 
			 
			 
			 
			 
			public class Solution2 implements Runnable
			{
			    static final long MAX = 464897L;
			    static class InputReader
			    {
			        private InputStream stream;
			        private byte[] buf = new byte[1024];
			        private int curChar;
			        private int numChars;
			        private SpaceCharFilter filter;
			        private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
			 
			        public InputReader(InputStream stream)
			        {
			            this.stream = stream;
			        }
			        
			        public int read()
			        {
			            if (numChars==-1) 
			                throw new InputMismatchException();
			            
			            if (curChar >= numChars)
			            {
			                curChar = 0;
			                try 
			                {
			                    numChars = stream.read(buf);
			                }
			                catch (IOException e)
			                {
			                    throw new InputMismatchException();
			                }
			                
			                if(numChars <= 0)                
			                    return -1;
			            }
			            return buf[curChar++];
			        }
			     
			        public String nextLine()
			        {
			            String str = "";
			            try
			            {
			                str = br.readLine();
			            }
			            catch (IOException e)
			            {
			                e.printStackTrace();
			            }
			            return str;
			        }
			        public int nextInt()
			        {
			            int c = read();
			            
			            while(isSpaceChar(c)) 
			                c = read();
			            
			            int sgn = 1;
			            
			            if (c == '-') 
			            {
			                sgn = -1;
			                c = read();
			            }
			            
			            int res = 0;
			            do 
			            {
			                if(c<'0'||c>'9') 
			                    throw new InputMismatchException();
			                res *= 10;
			                res += c - '0';
			                c = read();
			            }
			            while (!isSpaceChar(c)); 
			            
			            return res * sgn;
			        }
			        
			        public long nextLong() 
			        {
			            int c = read();
			            while (isSpaceChar(c))
			                c = read();
			            int sgn = 1;
			            if (c == '-') 
			            {
			                sgn = -1;
			                c = read();
			            }
			            long res = 0;
			            
			            do 
			            {
			                if (c < '0' || c > '9')
			                    throw new InputMismatchException();
			                res *= 10;
			                res += c - '0';
			                c = read();
			            }
			            while (!isSpaceChar(c));
			                return res * sgn;
			        }
			        
			        public double nextDouble() 
			        {
			            int c = read();
			            while (isSpaceChar(c))
			                c = read();
			            int sgn = 1;
			            if (c == '-') 
			            {
			                sgn = -1;
			                c = read();
			            }
			            double res = 0;
			            while (!isSpaceChar(c) && c != '.') 
			            {
			                if (c == 'e' || c == 'E')
			                    return res * Math.pow(10, nextInt());
			                if (c < '0' || c > '9')
			                    throw new InputMismatchException();
			                res *= 10;
			                res += c - '0';
			                c = read();
			            }
			            if (c == '.') 
			            {
			                c = read();
			                double m = 1;
			                while (!isSpaceChar(c)) 
			                {
			                    if (c == 'e' || c == 'E')
			                        return res * Math.pow(10, nextInt());
			                    if (c < '0' || c > '9')
			                        throw new InputMismatchException();
			                    m /= 10;
			                    res += (c - '0') * m;
			                    c = read();
			                }
			            }
			            return res * sgn;
			        }
			        
			        public String readString() 
			        {
			            int c = read();
			            while (isSpaceChar(c))
			                c = read();
			            StringBuilder res = new StringBuilder();
			            do 
			            {
			                res.appendCodePoint(c);
			                c = read();
			            } 
			            while (!isSpaceChar(c));
			            
			            return res.toString();
			        }
			     
			        public boolean isSpaceChar(int c) 
			        {
			            if (filter != null)
			                return filter.isSpaceChar(c);
			            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
			        }
			     
			        public String next() 
			        {
			            return readString();
			        }
			        
			        public interface SpaceCharFilter 
			        {
			            public boolean isSpaceChar(int ch);
			        }
			    }
			     
			    public static void main(String args[]) throws Exception
			    {
			        new Thread(null, new Solution2(),"Solution2",1<<26).start();
			    }   
			    static long gcd(long a, long b) 
			    { 
			      if (b == 0) 
			        return a; 
			      return gcd(b, a % b);  
			    } 
			    
			    long MOD = 1000000007;
			    long prime = 29;
			    ArrayList<Integer> adj[];
			    ArrayList<Integer> adj2[];
			    public void run() 
			    {
			    	InputReader sc = new InputReader(System.in);
					PrintWriter w = new PrintWriter(System.out);
					long n = sc.nextLong();
					long m = sc.nextLong();
					long k = sc.nextLong();
					long l = sc.nextLong();
					long give = n/m;
					if(give == 0) {
						w.println("-1");
					}else {
						long low = 1;
						long r = give;
						long ans = -1;
						while(low <= r) {
							long mid = (low + r)/2;
							if(m * mid < 0 || (m * mid - k) >= l) {
								ans = mid;
								r = mid - 1;
							}else {
								low = mid + 1;
							}
						}
						if(ans == -1) {
							w.println("-1");
						}else {
							w.println(ans);
						}
					}
		            w.close();
			    }
			    
			    class Pair implements Comparable<Pair>{
			        int a;
			        int b;
			        //int c;
			        Pair(int a,int b){
			            this.b = b;
			            this.a = a;
			        }
			        public boolean equals(Object o) {
			            Pair p = (Pair)o;
			            return this.a == p.a && this.b == this.b;
			        }
			        public int hashCode(){
			            return Long.hashCode(a)*27 + Long.hashCode(b)*31;
			        }
			        public int compareTo(Pair p) {
			        	
			            return Long.compare(p.a - p.b,this.a - this.b);
			        }
			    }
			    
			}
