import sys

sys.setrecursionlimit(1 << 25)

def main():
    import sys
    input = sys.stdin.read().split()
    ptr = 0
    N = int(input[ptr])
    ptr += 1
    M = int(input[ptr])
    ptr += 1
    blocks = []
    for _ in range(N):
        L = int(input[ptr])
        ptr += 1
        R = int(input[ptr])
        ptr += 1
        o_l, o_r = L, R
        f_l = (M - 1) - R
        f_r = (M - 1) - L
        blocks.append(((o_l, o_r), (f_l, f_r)))
    
    size = 2 * N
    original_graph = [[] for _ in range(2 * N)]
    transposed_graph = [[] for _ in range(2 * N)]

    def overlaps(a1, a2, b1, b2):
        return a1 <= b2 and b1 <= a2

    for i in range(N):
        for j in range(i + 1, N):
            o_i = blocks[i][0]
            f_i = blocks[i][1]
            o_j = blocks[j][0]
            f_j = blocks[j][1]

            # Case 1: o_i and o_j
            if overlaps(o_i[0], o_i[1], o_j[0], o_j[1]):
                u = 2 * i
                v = 2 * j + 1
                original_graph[u].append(v)
                transposed_graph[v].append(u)
                u = 2 * j
                v = 2 * i + 1
                original_graph[u].append(v)
                transposed_graph[v].append(u)

            # Case 2: o_i and f_j
            if overlaps(o_i[0], o_i[1], f_j[0], f_j[1]):
                u = 2 * i
                v = 2 * j
                original_graph[u].append(v)
                transposed_graph[v].append(u)
                u = 2 * j + 1
                v = 2 * i + 1
                original_graph[u].append(v)
                transposed_graph[v].append(u)

            # Case 3: f_i and o_j
            if overlaps(f_i[0], f_i[1], o_j[0], o_j[1]):
                u = 2 * i + 1
                v = 2 * j + 1
                original_graph[u].append(v)
                transposed_graph[v].append(u)
                u = 2 * j
                v = 2 * i
                original_graph[u].append(v)
                transposed_graph[v].append(u)

            # Case 4: f_i and f_j
            if overlaps(f_i[0], f_i[1], f_j[0], f_j[1]):
                u = 2 * i + 1
                v = 2 * j
                original_graph[u].append(v)
                transposed_graph[v].append(u)
                u = 2 * j + 1
                v = 2 * i
                original_graph[u].append(v)
                transposed_graph[v].append(u)

    visited = [False] * (2 * N)
    order = []
    for u in range(2 * N):
        if not visited[u]:
            stack = [(u, False)]
            while stack:
                node, processed = stack.pop()
                if processed:
                    order.append(node)
                    continue
                if visited[node]:
                    continue
                visited[node] = True
                stack.append((node, True))
                for v in original_graph[node]:
                    if not visited[v]:
                        stack.append((v, False))

    visited = [False] * (2 * N)
    component = [0] * (2 * N)
    current = 0
    for node in reversed(order):
        if not visited[node]:
            stack = [node]
            visited[node] = True
            while stack:
                u = stack.pop()
                component[u] = current
                for v in transposed_graph[u]:
                    if not visited[v]:
                        visited[v] = True
                        stack.append(v)
            current += 1

    possible = True
    for i in range(N):
        if component[2 * i] == component[2 * i + 1]:
            possible = False
            break

    print("YES" if possible else "NO")

if __name__ == "__main__":
    main()