#include <bits/stdc++.h>

using namespace std;
using ll = long long;

bool delim(char c) {
    return c == ' ';
}

bool is_op(char c) {
    return c == '&' || c == '|' || c == '=' || c == '^' || c == '!';
}

int priority(char op) {
    if (op < 0)return 4;
    if (op == '=')return 3;
    if (op == '&')return 2;
    if (op == '|')return 1;
    if (op == '^')return 0;
    return -1;
}

char isunary(char op) {
    return op == '!';
}

void process_op(vector<int> &st, char op) {
    if (op < 0) {
        int l = st.back();
        st.pop_back();
        switch (-op) {
            case '!':
                st.push_back(!l);
                break;
        }
    } else {
        int r = st.back();
        st.pop_back();
        int l = st.back();
        st.pop_back();
        switch (op) {
            case '&':
                st.push_back(r & l);
                break;
            case '|':
                st.push_back(r | l);
                break;
            case '=':
                st.push_back(r == l);
                break;
            case '^':
                st.push_back(r ^ l);
                break;
        }
    }
}

int calc(const string &s, int x, int y) {
    auto get_variable_val = [&](const string &op) {
        return (op == "x" ? x : y);
    };
    bool may_unary = true;
    vector<int> st;
    vector<char> op;
    for (int i = 0; i < s.size(); ++i) {
        if (!delim(s[i])) {
            if (s[i] == '(') {
                op.push_back('(');
                may_unary = true;
            } else if (s[i] == ')') {
                while (op.back() != '(')process_op(st, op.back()), op.pop_back();
                op.pop_back();
                may_unary = false;
            } else if (is_op(s[i])) {
                char curop = s[i];
                if (may_unary && isunary(curop))curop = -curop;
                while (!op.empty() && (curop >= 0 && priority(op.back()) >= priority(curop)
                                       || curop < 0 && priority(op.back()) > priority(curop))) {
                    process_op(st, op.back()), op.pop_back();
                }
                op.push_back(curop);
                may_unary = true;
            } else {
                string operand;
                while (i < s.size() && isalnum(s[i])) {
                    operand += s[i++];
                }
                --i;
                if (isdigit(operand[0])) {
                    st.push_back(atoi(operand.c_str()));
                } else {
                    st.push_back(get_variable_val(operand));
                }
                may_unary = false;
            }
        }
    }
    while (!op.empty())process_op(st, op.back()), op.pop_back();
    return st.back();
}

constexpr int K = 10;
constexpr int NAX = 1 << K;
pair<int, int> prior[K][K][2][2];

int main() {
    cin.tie(0)->sync_with_stdio(false);
    for (int i = 0; i < K; ++i) {
        for (int j = 0; j < K; ++j) {
            prior[i][j][0][0] =
            prior[i][j][0][1] =
            prior[i][j][1][0] =
            prior[i][j][1][1] = {-1, 0};
        }
    }
    int n, k;
    cin >> n >> k;
    for (int i = 0; i < n; ++i) {
        int a, b;
        cin >> a >> b;
        --a, --b;
        string exp;
        cin >> exp;
        int re;
        cin >> re;
        for (int x = 0; x < 2; ++x) {
            for (int y = 0; y < 2; ++y) {
                if (calc(exp, x, y)) {
                    if(prior[a][b][x][y].first == -1)prior[a][b][x][y] = {n - i, re};
                }
            }
        }
    }
    int de;
    cin >> de;
    const int nax = 1 << k;
    vector<bitset<NAX>> g(nax);
    for (int i = 0; i < nax; ++i) {
        for (int j = 0; j < nax; ++j) {
            pair<int, int> v = {0, de};
            for (int x = 0; x < k; ++x) {
                for (int y = 0; y < k; ++y) {
                    v = max(v, prior[x][y][(i >> x) & 1][(j >> y) & 1]);
                }
            }
            g[i][j] = v.second;
        }
    }
    ll a{0};
    for (int i = 0; i < nax; ++i) {
        a += g[i][i];
    }
    ll b{0};
    for (int i = 0; i < nax; ++i) {
        for (int j = 0; j < nax; ++j) {
            if (g[i][j] && g[j][i])++b;
        }
    }
    ll c{0};
    for (int i = 0; i < nax; ++i) {
        for (int j = 0; j < nax; ++j) {
            if (g[i][j]) {
                c += (~g[i] & g[j]).count();
            }
        }
    }
    cout << a << " " << b << " " << c << "\n";
}