import re, os from io import BytesIO, IOBase import random import sys from math import ceil, floor, fmod, gcd, sqrt, inf from bisect import bisect_left from collections import defaultdict, Counter, deque, OrderedDict from functools import cache, reduce, cmp_to_key from itertools import accumulate, combinations, permutations from heapq import nsmallest, nlargest, heappushpop, heapify, heappop, heappush from copy import deepcopy from typing import * from string import ascii_lowercase, ascii_uppercase
#快读区块大小
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        BUFSIZE = 4096
#判断是否本地
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        LOCAL = "--open17" in sys.argv

#可能会导致pypy产生TLE
#if "PyPy" in sys.version:
#import pypyjit; pypyjit.set_param('max_unroll_recursion=-1')

#调试递归极限
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        limits =[100000, 10000, 5000, 2000] for limit in limits : try : sys.setrecursionlimit(limit)
        break
    except:
        continue 




class FastIO(IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
 
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
 

def fstream(func):
    def wrapper(is_local):
        input_file = open('data.in', 'r', encoding='utf-8') if is_local else sys.stdin
        output_file = open('data.out', 'w', encoding='utf-8') if is_local else sys.stdout
        sys.stdin = IOWrapper(input_file)
        sys.stdout = output_file
        func()
        sys.stdin = sys.__stdin__
        sys.stdout = sys.__stdout__
        if is_local:
            input_file.close()
            output_file.close()
    return wrapper

input = lambda: sys.stdin.readline().rstrip("\r\n")

def I():
    return input()
 
def II():
    return int(input())
 
def MII():
    return map(int, input().split())
 
def LI():
    return list(input().split())
 
def LII():
    return list(map(int, input().split()))

def for_t(func):
    def wrapper():
        T=II()
        for _ in range(T):
            func()
    return wrapper


@fstream
#@for_t
def solve():
    a,k,l,r=MII()
    l,r=min(l,r),max(l,r)
    if l<=a<=r:
        print(abs(r-a)//k+abs(l-a)//k+1)
    else:
        ans=abs(abs(r-a)//k-abs(l-a)//k)
        if l<=r<=a:
            ans+=(r-a)%k==0
        elif a<= r<=l:
            ans+=(a-l)%k==0
        print(ans)
    return 0


solve(LOCAL)

/sandbox/1/a.cpp:14:3: error: invalid preprocessing directive #\U00005feb\U00008bfb\U0000533a\U00005757\U00005927\U00005c0f
   14 | # 快读区块大小
      |   ^~~~~~~~~~~~
/sandbox/1/a.cpp:16:3: error: invalid preprocessing directive #\U00005224\U000065ad\U0000662f\U00005426\U0000672c\U00005730
   16 | # 判断是否本地
      |   ^~~~~~~~~~~~
/sandbox/1/a.cpp:19:3: error: invalid preprocessing directive #\U000053ef\U000080fd\U00004f1a\U00005bfc\U000081f4pypy\U00004ea7\U0000751fTLE
   19 | # 可能会导致pypy产生TLE
      |   ^~~~~~~~~~~~~~~~~~~~~
/sandbox/1/a.cpp:20:6: error: token ""PyPy"" is not valid in preprocessor expressions
   20 | # if "PyPy" in sys.version:
      |      ^~~~~~
/sandbox/1/a.cpp:20: error: unterminated #if
   20 | # if "PyPy" in sys.version:
      | 
/sandbox/1/a.cpp:1:1: error: 'import' does not name a type
    1 | import re,os
      | ^~~~~~