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.
//package math_codet;

import java.io.*;
import java.util.*;
 /******************************************
*    AUTHOR:         AMAN KUMAR SINGH        *
*    INSTITUITION:   KALYANI GOVERNMENT ENGINEERING COLLEGE  *
******************************************/
public class lets_do {
    InputReader in;
    PrintWriter out;
    Helper_class h;
    final long mod=1000000007;
    public static void main(String[] args) throws java.lang.Exception{
        new lets_do().run();
    }
    void run() throws Exception{
        in=new InputReader();
        out = new PrintWriter(System.out);
        h = new Helper_class();
        int t = 1;
        while(t-- > 0)
            solve();
        out.flush();    
        out.close();
    }
    TreeMap<Integer, Integer> tmap = new TreeMap<Integer, Integer>();
    void solve(){
        long n = h.nl();
        long m = h.nl();
        long k = h.nl();
        long l = h.nl();
        if(n < m)
            h.pn(-1);
        else{
            long x = l + k;
            long coins = 0;
            if(x % m == 0)
                coins += x / m;
            else
                coins += x / m + 1;
            if(coins * m <= n && coins * m - k >= l)
            	h.pn(coins);
            else
            	h.pn(-1);
        }
    }
    void add(int x){
        Integer cnt = tmap.get(x);
        if(cnt == null)
            tmap.put(x, 1);
        else
            tmap.put(x, ++cnt);
    }
    void remove(int x){
        Integer cnt = tmap.get(x);
        if(cnt == 1)
            tmap.remove(x);
        else
            tmap.put(x, --cnt);
    }
    final Comparator<Entity> com = new Comparator<Entity>(){
        public int compare(Entity x, Entity y){
            int xx = Long.compare(x.a, y.a);
            if(xx == 0)
                return Integer.compare(x.b, y.b);
            else
                return xx;
        }
    };
    class Entity{
        long a;
        int b;
        Entity(int p, int q){
            a = p;
            b = q;
        }
    }
    class Helper_class{
        long gcd(long a, long b){return (b==0)?a:gcd(b,a%b);}
        int gcd(int a, int b){return (b==0)?a:gcd(b,a%b);}
        int bitcount(long n){return (n==0)?0:(1+bitcount(n&(n-1)));}
        void p(Object o){out.print(o);}
        void pn(Object o){out.println(o);}
        void pni(Object o){out.println(o);out.flush();}
        String n(){return in.next();}
        String nln(){return in.nextLine();}
        int ni(){return Integer.parseInt(in.next());}
        long nl(){return Long.parseLong(in.next());}
        double nd(){return Double.parseDouble(in.next());}

        long mul(long a,long b){
            if(a>=mod)a%=mod;
            if(b>=mod)b%=mod;
            a*=b;
            if(a>=mod)a%=mod;
            return a;
        }
        long modPow(long a, long p){
            long o = 1;
            while(p>0){
                if((p&1)==1)o = mul(o,a);
                a = mul(a,a);
                p>>=1;
            }
            return o;
        }
        long add(long a, long b){
            if(a>=mod)a%=mod;
            if(b>=mod)b%=mod;
            if(b<0)b+=mod;
            a+=b;
            if(a>=mod)a-=mod;
            return a;
        }
    }

    class InputReader{
        BufferedReader br;
        StringTokenizer st;
        public InputReader(){
            br = new BufferedReader(new InputStreamReader(System.in));
        }
 
        public InputReader(String s) throws Exception{
            br = new BufferedReader(new FileReader(s));
        }
 
        String next(){
            while (st == null || !st.hasMoreElements()){
                try{
                    st = new StringTokenizer(br.readLine());
                }catch (IOException  e){
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
 
        String nextLine(){
            String str = "";
            try{
                str = br.readLine();
            }catch (IOException e){
                e.printStackTrace();
            }   
            return str;
        }
    }
}       