#include <bits/stdc++.h>
using namespace std;

template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;

const string BINOPS = "^|&=";
int op(int p, int x, int y) {
    if (p == 0) return x ^ y;
    else if (p == 1) return x | y;
    else if (p == 2) return x & y;
    else if (p == 3) return 15 ^ x ^ y;
    assert(false);
}

int evaluate(string expr) {
    expr.push_back(char(0));
    int cur = 0;
    auto evaluate = [&](auto&& self, int p) -> int {
        if (p < 4) {
            // p-th binary operator
            int res = self(self, p+1);
            while (expr[cur] == BINOPS[p]) {
                cur++;
                auto rres = self(self, p+1);
                res = op(p, res, rres);
            }
            return res;
        } else if (p == 4) {
            char c = expr[cur++];
            if (c == 'x') {
                return (1 << 1) | (1 << 3);
            } else if (c == 'y') {
                return (1 << 2) | (1 << 3);
            } else if (c == '0') {
                return 0;
            } else if (c == '1') {
                return 15;
            } else if (c == '!') {
                return 15 ^ self(self, 4);
            } else if (c == '(') {
                int res = self(self, 0);
                cur++; // Skip ')'
                return res;
            } else {
                cerr << "Unexpected character: " << c << endl;
                assert(false);
            }
        } else assert(false);
    };
    return evaluate(evaluate, 0);
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(20);

    int N, K;
    cin >> N >> K;

    using Map = array<int, 5>; // (a, b, x, y, r)
    auto encode = [&](int a, int b, int x, int y) -> int {
        return a * (K*2*2)
             + b * (2*2)
             + x * 2
             + y;
    };
    V<bool> seen(K*K*2*2, false);
    V<Map> interesting;
    for (int i = 0; i < N; i++) {
        int a, b, r;
        string expr;
        cin >> a >> b >> expr >> r;
        a--, b--;
        auto result = evaluate(expr);

        for (int x = 0; x < 2; x++) {
            for (int y = 0; y < 2; y++) {
                int result_xy = (result >> (x + 2*y)) & 1;
                if (result_xy) {
                    int e = encode(a, b, x, y);
                    if (!seen[e]) {
                        seen[e] = true;
                        interesting.push_back(Map{a, b, x, y, r});
                    }
                }
            }
        }
    }
    int R_end;
    cin >> R_end;

    auto compute_f = [&](int x, int y) -> int {
        for (const auto& [a, b, dx, dy, r] : interesting) {
            if (((x >> a) & 1) == dx && ((y >> b) & 1) == dy) {
                return r;
            }
        }
        return R_end;
    };

    using Word = uint64_t;
    constexpr int Width = 8 * sizeof(Word);
    const int M = 1 << K;
    const int num_blocks = (M + Width - 1) / Width;

    VV<Word> fxy(M, V<Word>(num_blocks));
    VV<Word> fyx(M, V<Word>(num_blocks));

    for (int x = 0; x < M; x++) {
        for (int y = 0; y < M; y++) {
            auto f = compute_f(x, y);
            if (f) {
                {
                    int q = y / Width;
                    int r = y % Width;
                    fxy[x][q] |= 1 << r;
                }
                {
                    int q = x / Width;
                    int r = x % Width;
                    fyx[y][q] |= 1 << r;
                }
            }
        }
    }

    auto at = [&](int x, int y) -> bool {
        int q = y / Width;
        int r = y % Width;
        return bool((fxy[x][q] >> r) & 1);
    };

    cout << [&]() -> int {
        return ranges::count_if(ranges::iota_view{0, M}, [&](int x) -> bool {
            return at(x, x);
        });
    }() << ' ' << [&]() -> int {
        int cnt = 0;
        for (int x = 0; x < M; x++) {
            for (int y = 0; y < M; y++) {
                if (at(x, y) && at(y, x)) {
                    cnt++;
                }
            }
        }
        return cnt;
    }() << ' ' << [&]() -> int {
        int cnt = 0;
        for (int x = 0; x < M; x++) {
            for (int z = 0; z < M; z++) {
                if (at(x, z)) continue;
                for (int i = 0; i < num_blocks; i++) {
                    cnt += __builtin_popcount(fxy[x][i] & fyx[z][i]);
                }
            }
        }
        return cnt;
    }() << '\n';

    return 0;
}