#include <bits/stdc++.h>
#ifdef LOCAL
#include <debug.hpp>
#else
#define debug(...) void(0)
#endif

template <class T> std::istream& operator>>(std::istream& is, std::vector<T>& v) {
    for (auto& e : v) {
        is >> e;
    }
    return is;
}

template <class T> std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
    for (std::string_view sep = ""; const auto& e : v) {
        os << std::exchange(sep, " ") << e;
    }
    return os;
}

template <class T, class U = T> bool chmin(T& x, U&& y) {
    return y < x and (x = std::forward<U>(y), true);
}

template <class T, class U = T> bool chmax(T& x, U&& y) {
    return x < y and (x = std::forward<U>(y), true);
}

template <class T> void mkuni(std::vector<T>& v) {
    std::ranges::sort(v);
    auto result = std::ranges::unique(v);
    v.erase(result.begin(), result.end());
}

template <class T> int lwb(const std::vector<T>& v, const T& x) {
    return std::distance(v.begin(), std::ranges::lower_bound(v, x));
}

using ll = long long;

using namespace std;

vector<vector<int>> value(const string&, int&);
vector<vector<int>> term(const string&, int&);
vector<vector<int>> expression(const string&, int&);

vector<vector<int>> value(const string& s, int& cur) {
    vector res(2, vector<int>(2));
    char c = s[cur++];
    if (islower(c)) {
        assert(c == 'x' or c == 'y');
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                res[i][j] = (c == 'x' ? i : j);
            }
        }
    } else if (isdigit(c)) {
        assert(c == '0' or c == '1');
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                res[i][j] = c - '0';
            }
        }
    } else {
        assert(false);
    }
    return res;
}

vector<vector<int>> term(const string& s, int& cur) {
    if (s[cur] == '(') {
        auto res = expression(s, ++cur);
        assert(s[cur++] == ')');
        return res;
    } else if (s[cur] == '!') {
        auto res = term(s, ++cur);
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                res[i][j] ^= 1;
            }
        }
        return res;
    } else {
        return value(s, cur);
    }
}

// vector<vector<int>> expression(const string& s, int& cur) {
//     auto res = term(s, cur);
//     while (cur < int(s.size())) {
//         char op = s[cur];
//         if (not(op == '=' or op == '&' or op == '|' or op == '^')) {
//             assert(op == ')');
//             break;
//         }
//         cur++;
//         auto R = term(s, cur);
//         for (int i = 0; i < 2; i++) {
//             for (int j = 0; j < 2; j++) {
//                 auto& x = res[i][j];
//                 auto y = R[i][j];
//                 if (op == '=') {
//                     x = x == y;
//                 } else if (op == '&') {
//                     x = x & y;
//                 } else if (op == '|') {
//                     x = x | y;
//                 } else {
//                     assert(op == '^');
//                     x = x ^ y;
//                 }
//             }
//         }
//     }
//     return res;
// }

vector<vector<int>> parseEquals(const string& s, int& cur) {
    auto res = term(s, cur);
    while (cur < int(s.size()) && s[cur] == '=') {
        cur++;
        auto R = term(s, cur);
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                res[i][j] = (res[i][j] == R[i][j]);
            }
        }
    }
    return res;
}

vector<vector<int>> parseAnd(const string& s, int& cur) {
    auto res = parseEquals(s, cur);
    while (cur < int(s.size()) && s[cur] == '&') {
        cur++;
        auto R = parseEquals(s, cur);
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                res[i][j] &= R[i][j];
            }
        }
    }
    return res;
}

vector<vector<int>> parseOr(const string& s, int& cur) {
    auto res = parseAnd(s, cur);
    while (cur < int(s.size()) && s[cur] == '|') {
        cur++;
        auto R = parseAnd(s, cur);
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                res[i][j] |= R[i][j];
            }
        }
    }
    return res;
}

vector<vector<int>> parseXor(const string& s, int& cur) {
    auto res = parseOr(s, cur);
    while (cur < int(s.size()) && s[cur] == '^') {
        cur++;
        auto R = parseOr(s, cur);
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                res[i][j] ^= R[i][j];
            }
        }
    }
    return res;
}

vector<vector<int>> expression(const string& s, int& cur) { return parseXor(s, cur); }

const int MAX_K = 10;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(15);
    int n, K;
    cin >> n >> K;
    vector<int> a(n), b(n), r(n);
    vector<string> expr(n);
    for (int i = 0; i < n; i++) {
        cin >> a[i] >> b[i] >> expr[i] >> r[i];
        a[i]--, b[i]--;
    }
    int last;
    cin >> last;

    vector e(n, vector(2, vector<int>(2)));
    for (int i = 0; i < n; i++) {
        int init = 0;
        e[i] = expression(expr[i], init);
    }
    {
        vector<int> na, nb, nr;
        vector<vector<vector<int>>> ne;
        set<tuple<int, int, vector<vector<int>>>> s;
        for (int i = 0; i < n; i++) {
            auto tmp = make_tuple(a[i], b[i], e[i]);
            if (s.count(tmp)) continue;
            na.emplace_back(a[i]);
            nb.emplace_back(b[i]);
            ne.emplace_back(e[i]);
            nr.emplace_back(r[i]);
            s.emplace(tmp);
        }
        swap(a, na);
        swap(b, nb);
        swap(e, ne);
        swap(r, nr);
        n = a.size();
    }

    vector f(1 << K, vector<int>(1 << K, -1));
    for (int i = 0; i < 1 << K; i++) {
        set<pair<int, int>> s;
        for (int k = 0; k < n; k++) {
            int x = i >> a[k] & 1;
            for (int d = 0; d < 2; d++) {
                if (not e[k][x][d]) continue;
                if (s.count({b[k], d})) continue;
                for (int j = 0; j < 1 << K; j++) {
                    if (f[i][j] == -1 and (j >> b[k] & 1) == d) {
                        f[i][j] = r[k];
                    }
                }
                s.emplace(b[k], d);
            }
        }
        for (int j = 0; j < 1 << K; j++) {
            if (f[i][j] == -1) {
                f[i][j] = last;
            }
        }
    }

    vector<ll> ans(3, 0);
    vector<bitset<1 << MAX_K>> F(1 << K);
    for (int i = 0; i < 1 << K; i++) {
        for (int j = 0; j < 1 << MAX_K; j++) {
            F[i][j] = 0;
        }
        for (int j = 0; j < 1 << K; j++) {
            F[i][j] = f[i][j];
        }
    }
    for (int x = 0; x < 1 << K; x++) {
        ans[0] += not(f[x][x] == 0);
        for (int y = 0; y < 1 << K; y++) {
            if (f[x][y]) {
                ans[1] += not(f[y][x] == 0);
                ans[2] += F[y].count() - (F[x] & F[y]).count();
            }
        }
    }

    cout << ans << '\n';
    return 0;
}