#include <bits/stdc++.h>
using namespace std;

const int N = 2005;
const int MOD = 1000003;

int n, m;
int a[2 * N];
int dp[2 * N]; // dp[i]: số cách hợp lệ cho đoạn a[1...i]
int catalan[N]; // Catalan cơ số k

int powmod(int base, int exp) {
    int res = 1;
    while (exp > 0) {
        if (exp & 1) res = (1LL * res * base) % MOD;
        base = (1LL * base * base) % MOD;
        exp >>= 1;
    }
    return res;
}

void precomputeCatalan() {
    // Công thức Catalan: C(n) = (1/(n+1)) * (2n choose n)
    vector<int> fac(2 * N);
    fac[0] = 1;
    for (int i = 1; i < 2 * N; i++) fac[i] = (1LL * fac[i-1] * i) % MOD;

    for (int k = 0; k <= n; k++) {
        if (k == 0) { catalan[k] = 1; continue; }
        int num = fac[2*k]; // (2k)!
        int den = (1LL * fac[k+1] * fac[k]) % MOD; // (k+1)! * k!
        catalan[k] = (1LL * num * powmod(den, MOD - 2)) % MOD;
    }
}

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    cin >> n >> m;
    for (int i = 1; i <= 2*n; i++) cin >> a[i];

    precomputeCatalan();

    dp[0] = 1;
    // dp[i] = sum(dp[j] * catalan[(i-j-2)/2]) for j < i, a[i]-a[j+1] <= m
    // j là vị trí cuối cùng của block người trước đó.
    // Nếu a[i] là 'ra' của người mới, thì 'vào' phải là a[j+1] (ngay sau j).
    // Khoảng trống giữa j và i là (i - j - 1) sự kiện. (i - j - 1) phải chẵn.
    // Nếu đúng là 1 cặp bao bọc toàn bộ đoạn j+1...i, thì số sự kiện trong cặp là (i - j - 1).
    // Số người trong đoạn này là (i - j - 1) / 2. Nếu đoạn này được ghép hoàn toàn tự do (tức là a[j+1] và a[i] là 1 cặp),
    // thì số cách là Catalan[(i-j-1)/2 - 1]? Không.
    // Nếu a[j+1] là '(' và a[i] là ')' (đóng kén), thì bên trong còn lại (i - j - 2) sự kiện.
    // Số cách cấu thành (i - j - 2)/2 người bên trong là Catalan[(i-j-2)/2].

    dp[0] = 1;
    for (int i = 2; i <= 2*n; i += 2) {
        for (int j = i - 2; j >= 0; j -= 2) {
            if (a[i] - a[j + 1] <= m) {
                int k = (i - j - 2) / 2; // Số người bên trong đoạn (j+1, i)
                dp[i] = (dp[i] + 1LL * dp[j] * catalan[k]) % MOD;
            }
        }
    }

    cout << dp[2*n] << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

const int N = 2e5 + 5;
const int MOD = 1000003;

int n, m;
int a[2 * N];
int dp[2 * N];
int catalan[N];
int fac[2 * N], invFac[2 * N];

int powmod(int base, int exp) {
    int res = 1;
    while (exp > 0) {
        if (exp & 1) res = (1LL * res * base) % MOD;
        base = (1LL * base * base) % MOD;
        exp >>= 1;
    }
    return res;
}

void precompute() {
    fac[0] = 1;
    for (int i = 1; i < 2 * N; i++) fac[i] = (1LL * fac[i-1] * i) % MOD;
    invFac[2*N - 1] = powmod(fac[2*N - 1], MOD - 2);
    for (int i = 2*N - 2; i >= 0; i--) invFac[i] = (1LL * invFac[i+1] * (i+1)) % MOD;

    for (int k = 0; k < N; k++) {
        if (k == 0) { catalan[k] = 1; continue; }
        catalan[k] = (1LL * fac[2*k] * invFac[k+1]) % MOD;
        catalan[k] = (1LL * catalan[k] * invFac[k]) % MOD;
    }
}

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    cin >> n >> m;
    for (int i = 1; i <= 2*n; i++) cin >> a[i];

    precompute();

    dp[0] = 1;
    // Optimization: Instead of nested loops checking all j, we maintain a pointer or use prefix sums.
    // However, the constraint a[i] - a[j+1] <= m makes the inner loop j dependent on i.
    // Since a is sorted, as i increases, the valid range for j (j >= some index) shrinks.
    // Actually, a[i] - a[j+1] <= m  => a[j+1] >= a[i] - m.
    // Since a is sorted, we can find the smallest index 'left' such that a[left] >= a[i] - m.
    // Note: j+1 must be the 'in' time, so j+1 >= left => j >= left - 1.
    // Also j must be even (since dp[j] is defined for even indices).

    // We can use a prefix sum array to speed up the summation if the condition was simple.
    // But here we multiply by Catalan[(i-j-2)/2] which depends on j.
    // Wait, look at the solutions again. The provided Solution 1 does exactly the nested loop but breaks early.
    // 'for(j=i-2; j>=0; j-=2) if(a[i]-a[j+1] <= m) ...'
    // Since a is increasing, a[j+1] decreases as j decreases. a[i] - a[j+1] increases.
    // So the condition fails for small j. We can break the inner loop when condition fails.
    // This reduces average complexity, but worst case is still O(n^2).

    // For the specific test case where m = 10^6 (large), the condition is always true.
    // Then dp[i] = sum(dp[j] * Catalan[(i-j-2)/2]).
    // This specific sum is known to be Catalan[n].
    // The code in Solution 1 checks if (m == 1000000) and outputs Catalan(n) directly.

    for (int i = 2; i <= 2*n; i += 2) {
        for (int j = i - 2; j >= 0; j -= 2) {
            if (a[i] - a[j + 1] > m) break; // Optimization: stop when condition fails
            int k = (i - j - 2) / 2;
            dp[i] = (dp[i] + 1LL * dp[j] * catalan[k]) % MOD;
        }
    }

    cout << dp[2*n] << endl;
    return 0;
}