#include <bits/stdc++.h>

using namespace std;

const int MAXN = 1e6 + 5;

int pos, len, lastVal;
string str;
int tot = 0, ty[MAXN], ch[MAXN][2];


int buildCalc(int opt1, vector<int> tt, vector<int> op) ;
int build(vector<int> tt, vector<int> op) ;
int buildExpress();

int dfs(int x, int val_x, int val_y) {
    if (ty[x] == 2) return val_x;
    if (ty[x] == 3) return val_y;
    if (ty[x] >= 0) return ty[x];
    if (ty[x] == -1) return !dfs(ch[x][0], val_x, val_y);
    int val1 = dfs(ch[x][0], val_x, val_y);
    int val2 = dfs(ch[x][1], val_x, val_y);
    if (ty[x] == -2) return val1 & val2;
    if (ty[x] == -3) return val1 | val2;
    if (ty[x] == -4) return val1 ^ val2;
    if (ty[x] == -5) return val1 == val2;
}

void print(int x) {
    cout << x << ':';
    if (ty[x] >= 0) {
        cout << ty[x] << '\n';
        return ;
    }
    if (ty[x] == -1) {
        cout << ty[x] << ' ' << ch[x][0] << '\n';
        return print(ch[x][0]);
    }        
    cout << ty[x] << ' ' << ch[x][0] << ' ' << ch[x][1] << '\n';
    print(ch[x][0]), print(ch[x][1]);
}

int calc(string s) {
    pos = 0, str = s, len = str.size();
    tot = 0;
    int rt = buildExpress(), sta = 0;
    // print(rt);
    for (int x = 0; x <= 1; x++) {
        for (int y = 0; y <= 1; y++) {
            if (dfs(rt, x, y)) sta |= 1 << (x << 1 | y);
        }
    }
    return sta;
}

struct Node {
    int a, b, sta, val;
};

vector<Node> f;
map<pair<pair<int, int>, int>, bool> tt;

bitset<1024> S[10][4], full;

bitset<1024> getLimit(int A) {
    bitset<1024> now = full, lim = 0;
    for (auto node : f) {
        int a = node.a, b = node.b, sta = node.sta, val = node.val;
        int x = A >> a & 1, pp = 0;
        for (int y = 0; y <= 1; y++) {
            if (sta >> (x << 1 | y) & 1) {
                pp |= 1 << y;
            } 
        }
        if (val == 1) {
            lim |= now & S[b][pp];
        }
        now &= S[b][pp ^ 3];
    }
    if (lastVal) {
        lim |= now;
    }
    return lim;
}

bitset<1024> outEdge[1024];

void solve() {
    int n, k;
    cin >> n >> k;
    for (int i = 1; i <= n; i++) {
        int a, b, val;
        string s;
        cin >> a >> b >> s >> val;
        a--, b--;
        int t = calc(s);
        if (tt.find(make_pair(make_pair(a, b), t)) == tt.end()) {
            tt[make_pair(make_pair(a, b), t)] = 1;
            f.push_back((Node){a, b, t, val});
        }
    }
    cin >> lastVal;
    for (int x = 0; x < 1 << k; x++) full.set(x);
    for (int b = 0; b < 10; b++) {
        S[b][0] = 0, S[b][3] = full;
        for (int i = 0; i < 1 << k; i++) {
            if (i >> b & 1) S[b][2].set(i);
            else S[b][1].set(i);
        }
        
    }
    for (int x = 0; x < 1 << k; x++) {
        outEdge[x] = getLimit(x);
    }
    int ansA = 0, ansB = 0, ansC = 0;
    for (int x = 0; x < (1 << k); x++) {
        if (outEdge[x][x]) ansA++;
        for (int y = 0; y < (1 << k); y++) if(outEdge[x][y]) {
            if (outEdge[y][x]) ansB++;
            ansC += (~outEdge[x] & outEdge[y]).count();
        }
    }
    cout << ansA << ' ' << ansB << ' ' << ansC << '\n';
}

int main() {
    solve();
    return 0;
}


int buildCalc(int opt1, vector<int> tt, vector<int> op) {
    int flag = 0;
    for (auto opt : op) if (opt == opt1) flag = 1;
    if (flag) {
        vector<int> pos;
        for (int i = 0; i < op.size(); i++) {
            if (op[i] == opt1) pos.push_back(i);
        }
        vector<int> s;
        int last = -1;
        for (auto o : pos) {
            s.push_back(build(vector<int>(tt.begin() + last + 1, tt.begin() + o + 1), vector<int>(op.begin() + last + 1, op.begin() + o)));
            last = o;
        }
        s.push_back(build(vector<int>(tt.begin() + last + 1, tt.end()), vector<int>(op.begin() + last + 1, op.end())));
        last = s[0];
        for (int i = 1; i < s.size(); i++) {
            int t = ++tot;
            ty[t] = opt1;
            ch[t][0] = last;
            ch[t][1] = s[i];
            last = t;
        }
        return last;
    } else {
        return -1;
    }
}

int getPriority(int op) {
    return op == -5 ? 4 : op == -2 ? 3 : op == -3 ? 2 : 1;
}

bool compare(int op1, int op2) {
    return getPriority(op1) < getPriority(op2);
}

int build(vector<int> tt, vector<int> op) {
    if (op.empty()) {
        return tt[0];
    }
    vector<int> stackNode, stackOp;
    stackNode.push_back(tt[0]);
    for (int i = 0; i < op.size(); i++) {
        while(!stackOp.empty() && !compare(stackOp.back(), op[i])) {
            int t2 = stackNode.back();
            stackNode.pop_back();
            int t1 = stackNode.back();
            stackNode.pop_back();
            int opt = stackOp.back();
            stackOp.pop_back();
            int t = ++tot;
            ty[t] = opt, ch[t][0] = t1, ch[t][1] = t2;
            stackNode.push_back(t);
        }
        stackOp.push_back(op[i]);
        stackNode.push_back(tt[i + 1]);
    }
    while(!stackOp.empty()) {
        int t2 = stackNode.back();
        stackNode.pop_back();
        int t1 = stackNode.back();
        stackNode.pop_back();
        int opt = stackOp.back();
        stackOp.pop_back();
        int t = ++tot;
        ty[t] = opt, ch[t][0] = t1, ch[t][1] = t2;
        stackNode.push_back(t);
    }
    return stackNode[0];
}

int buildExpress() {
    vector<int> tt, op;
    while (pos < len) {
        if (str[pos] == '(') pos++, tt.push_back(buildExpress());
        else if (str[pos] == '!') pos++, ty[++tot] = -1, tt.push_back(tot), ch[tot][0] = buildExpress();
        else if (str[pos] == 'x') ty[++tot] = 2, tt.push_back(tot), pos++;
        else if (str[pos] == 'y') ty[++tot] = 3, tt.push_back(tot), pos++;
        else if (str[pos] == '0') ty[++tot] = 0, tt.push_back(tot), pos++;
        else if (str[pos] == '1') ty[++tot] = 1, tt.push_back(tot), pos++;
        else if (str[pos] == '&') op.push_back(-2), pos++;
        else if (str[pos] == '|') op.push_back(-3), pos++;
        else if (str[pos] == '^') op.push_back(-4), pos++;
        else if (str[pos] == '=') op.push_back(-5), pos++;
        else if(str[pos] == ')') {
            pos++;
            break;
        }
    }
    return build(tt, op);
}