#include <iostream>
#include <cmath>
#include <string>
#include <utility>
#include <vector>

using namespace std;

struct Node {
    int64_t number;
    string key;
    string color;
    bool is_BTS;
    bool is_Colored;
    Node *left, *right, *parent;
public:
    Node();

    explicit Node(string key, string color);

    void Check_BTS(Node *vert);

    void Check_Colored(Node *vert);
};

Node::Node() :
        number(-1),
        is_BTS(true),
        is_Colored(true),
        left(nullptr), right(nullptr), parent(nullptr) {}

Node::Node(string key_, string color_) :
        number(-1),
        key(std::move(key_)),
        color(std::move(color_)),
        is_BTS(true),
        is_Colored(true),
        left(nullptr), right(nullptr), parent(nullptr) {}

void Node::Check_BTS(Node *vert) {
    if (vert->left != nullptr) {
        Check_BTS(vert->left);
    }
    if (vert->key == "null") {
        return;
    }
    string left_key = vert->left->key;
    string right_key = vert->right->key;
    if (left_key != "null" && right_key != "null") {
        if (!(stold(left_key) < stold(vert->key) && stold(vert->key) < stold(right_key))) {
            is_BTS = false;
        }
    } else if (left_key != "null" && right_key == "null") {
        if (!(stold(left_key) < stold(vert->key))) {
            is_BTS = false;
        }
    } else if (left_key == "null" && right_key != "null") {
        if (!(stold(vert->key) < stold(right_key))) {
            is_BTS = false;
        }
    }
    if (vert->right != nullptr) {
        Check_BTS(vert->right);
    }
}

void Node::Check_Colored(Node *vert) {
    if (vert->left != nullptr) {
        Check_Colored(vert->left);
    }
    if (vert->parent == nullptr && vert->color != "B") {//для корня
        is_Colored = false;
        return;
    }
    if (vert->color == "R") {
        if (vert->parent->color != "B") {
            is_Colored = false;
        }
    }
    if (vert->right != nullptr) {
        Check_Colored(vert->right);
    }
}

void Find_leaves(Node *vert, vector<Node *> &seq) {
    if (vert->left != nullptr) {
        Find_leaves(vert->left, seq);
    }
    if (vert->left == nullptr && vert->right == nullptr) {
        seq.push_back(vert);
    }
    if (vert->right != nullptr) {
        Find_leaves(vert->right, seq);
    }
}

int64_t Count_black(Node *vert) {
    int64_t count = 0;
    while (vert != nullptr) {
        ++count;
        vert = vert->parent;
    }
    return count;
}


int main() {
    Node bts;
    Node *root = nullptr;
    int64_t N;
    cin >> N;
    if (N == 0) {
        cout << "YES\n";
        return 0;
    }
    vector<Node *> nodes(N);
    int64_t n_root;
    cin >> n_root;
    --n_root;
    for (int64_t i = 0; i < N; ++i) {
        int64_t number;
        string key, left, right, color;
        cin >> number >> key >> left >> right >> color;
        --number;
        if (nodes[number] != nullptr) {
            nodes[number]->key = key;
            nodes[number]->color = color;
        } else {
            nodes[number] = new Node(key, color);
            nodes[number]->number = number;
        }
        if (left != "null") {
            int64_t n_left = stold(left) - 1;
            if (nodes[n_left] == nullptr) {
                nodes[n_left] = new Node;
            }
            nodes[number]->left = nodes[n_left];
            nodes[number]->left->number = n_left;
            nodes[number]->left->parent = nodes[number];
        } else {
            nodes[number]->left = new Node("null", "B");
            nodes[number]->left->parent = nodes[number];
        }
        if (right != "null") {
            int64_t n_right = stold(right) - 1;
            if (nodes[n_right] == nullptr) {
                nodes[n_right] = new Node;
            }
            nodes[number]->right = nodes[n_right];
            nodes[number]->right->number = n_right;
            nodes[number]->right->parent = nodes[number];
        } else {
            nodes[number]->right = new Node("null", "B");
            nodes[number]->right->parent = nodes[number];
        }
        if (n_root == number) {
            root = nodes[number];
        }
    }

    vector<Node *> seq;
    Find_leaves(root, seq);
    int64_t count = Count_black(seq[0]);
    bool is_red_black = true;
    for (const auto &item: seq) {
        if (Count_black(item) != count) {
            is_red_black = false;
            break;
        }
    }
    Node tree;
    tree.Check_BTS(root);
    tree.Check_Colored(root);
    if (is_red_black && tree.is_BTS && tree.is_Colored) {
        cout << "YES\n";
    } else {
        cout << "NO\n";
    }
}