054:单调队列上

    public int[] maxSlidingWindow(int[] nums, int k) {
        int n = nums.length;
        int[] windows = new int[n];
        int l = 0, r = 0;
        int[] ans = new int[n - k + 1];
        int start = 0;
        for (int i = 0; i < n; i++) {
            while (l < r && nums[windows[r-1]] < nums[i]) {
                r--;
            }
            windows[r++] = i;
            if (i >= k - 1) {
                ans[start++] = nums[windows[l]];
                if (windows[l] == i - k + 1) {
                    l++;
                }
            }
        }
        return ans;
    }

class Solution {
    public final int MAXN = 100001;
    public int minl= 0, minr=0, maxl=0, maxr=0;
    public int[] minque = new int[MAXN];
    public int[] maxque = new int[MAXN];
    public int[] arr;
    public int longestSubarray(int[] nums, int limit) {
        arr = nums;
        int n = nums.length;
        int ans = 0;
        for (int l = 0, r = 0; l < n; l++) {
            while (r < n && ok(nums[r], limit)) {
                push(r++);
            }
            ans = Math.max(ans,r - l);
            pop(l);
        }
        return ans;
    }
    public boolean ok(int val, int limit) {
        int min = minl < minr ? Math.min(arr[minque[minl]], val) : val;
        int max = maxl < maxr ? Math.max(arr[maxque[maxl]], val) : val;
        return max - min <= limit;
    }
    public void push(int i) {
        while (maxl < maxr && arr[maxque[maxr - 1]] <= arr[i]) {
            maxr--;
        }
        maxque[maxr++] = i;
        while (minl < minr && arr[minque[minr - 1]] >= arr[i]) {
            minr--;
        }
        minque[minr++] = i;
    }
    public void pop(int l) {
        if (maxl < maxr && maxque[maxl] == l) {
            maxl++;
        }
        if (minl < minr && minque[minl] == l) {
            minl++;
        }
    }
}

public class hw3 {
    public static int MAXN = 100005;
    // 每滴水的坐标
    public static int[][] arr = new int[MAXN][2];
    // n滴水，限制为d
    public static int n, d;
    //单调队列维护最大值
    public static int[] maxDeque = new int[MAXN];
    //单调队列维护最小值
    public static int[] minDeque = new int[MAXN];
    //头尾指针，左闭右开
    public static int maxh, maxt, minh, mint;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        while (in.nextToken() != StreamTokenizer.TT_EOF) {
            n = (int) in.nval;
            in.nextToken();
            d = (int) in.nval;
            for (int i = 0; i < n; i++) {
                in.nextToken();
                arr[i][0] = (int) in.nval;
                in.nextToken();
                arr[i][1] = (int) in.nval;
            }
            int ans = compute();
            out.println(ans == Integer.MAX_VALUE ? -1 : ans);
        }
        out.flush();
        out.close();
        br.close();
    }
    public static int compute() {
        Arrays.sort(arr, 0, n, (a, b) -> a[0] - b[0]);
        maxh = maxt = minh = mint = 0;
        int ans = Integer.MAX_VALUE;
        for (int l = 0, r = 0; l < n; l++) {
            while (r < n && !ok()) {
                push(r++);
            }
            if (ok()) {
                ans = Math.min(ans, arr[r-1][0] - arr[l][0]);
            }
            pop(l);
        }
        return ans;
    }
    public static boolean ok() {
        int min = minh < mint ? arr[minDeque[minh]][1] : 0;
        int max = maxh < maxt ? arr[maxDeque[maxh]][1] : 0;
        return max - min >= d;
    }
    public static void push(int i) {
        while (minh < mint && arr[i][1] <= arr[minDeque[mint-1]][1]) {
            mint--;
        }
        minDeque[mint++] = i;
        while (maxh < maxt && arr[i][1] >= arr[maxDeque[maxt-1]][1]) {
            maxt--;
        }
        maxDeque[maxt++] = i;
    }
    public static void pop(int l) {
        if (minh < mint && minDeque[minh] == l) {
            minh++;
        }
        if (maxh < maxt && maxDeque[maxh] == l) {
            maxh++;
        }
    }

}