import std.algorithm;
import std.array;
import std.ascii;
import std.container;
import std.conv;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.typecons;

void log(A...)(A arg) {
    stderr.writeln(arg);
}
int size(T)(in T s) {
    return cast(int)s.length;
}

void main() {
    int N, M; readf("%s %s\n", &N, &M);
    auto L = new int[N],
         R = new int[N];
    foreach (i; 0 .. N) {
        readf("%s %s\n", &L[i], &R[i]);
    }
    alias P = Tuple!(int, int);
    void rot(ref int l, ref int r) {
        int nl = M - 1 - r;
        int nr = M - 1 - l;
        l = nl; r = nr;
    }
    bool solve() {
        auto used = new bool[M];
        auto set = new bool[N];
        bool flag = true;
        while (flag) {
            flag = false;
            foreach (i; 0 .. N) {
                if (set[i]) continue;
                int l0 = L[i], r0 = R[i],
                l1 = L[i], r1 = R[i];
                rot(l1, r1);
                if (used[l0 .. r0 + 1].any) {
                    if (used[l1 .. r1 + 1].any) return false;
                    used[l1 .. r1 + 1] = true;
                    set[i] = true;
                    flag = true;
                } else {
                    if (used[l1 .. r1 + 1].any) {
                        used[l0 .. r0 + 1] = true;
                        set[i] = true;
                        flag = true;
                    } else {
                        if (flag) continue;
                        used[l0 .. r0 + 1] = true;
                        set[i] = true;
                        flag = true;
                    }
                }
            }
        }
        return true;
    }
    writeln(solve() ? "YES" : "NO");

}