#include <bits/stdc++.h>

const long long MOD = 998244353;

const long long SEVENTH_ROOT = 779057549;
const long long INV_SEVENTH_ROOT = 690489812;

using namespace std;

int64_t SafeMod(int64_t x) {
    return (x % MOD + MOD) % MOD;
}

int64_t Exponential(int64_t a, int64_t b) {
    int64_t res = 1;
    while (b) {
        if (b & 1) {
            res = SafeMod(res * a);
        }
        a = SafeMod(a * a);
        b >>= 1;
    }
    return res;
}


/*
for (int64_t len = 1; len < three_pow[n]; len *= 3) {
        for (int64_t i = 0; i < three_pow[n]; i += 3 * len) {
            for (int64_t j = 0; j < len; j++) {
                int64_t x = a[i + j];
                int64_t y = a[i + len + j];
                int64_t z = a[i + 2 * len + j];

                a[i + j] = (x + y + z) % MOD;
                a[i + len + j] = (x + MOD - y + z) % MOD;
                a[i + 2 * len + j] = (x + y + MOD - z) % MOD;
            }
        }
    }
*/



// void ternary_xor_fwht(int64_t n, vector<ExtendedField>& a, bool inv = false) {
//     ExtendedField omega_n = inv ? omega_squared : omega;
//     for (int64_t len = 1; len < three_pow[n]; len *= 3) {
//         for (int64_t i = 0; i < three_pow[n]; i += 3 * len) {
//             for (int64_t j = 0; j < len; j++) {
//                 ExtendedField x = a[i + j];
//                 ExtendedField y = a[i + len + j];
//                 ExtendedField z = a[i + 2 * len + j];

//                 a[i + j] = x + y + z;
//                 a[i + len + j] = x + omega_n * y + omega_n * omega_n * z;
//                 a[i + 2 * len + j] = x + omega_n * omega_n * y + omega_n * z;
//             }
//         }
//     }
    
//     if (inv) {
//         int64_t inv3 = INV3;
//         for (int64_t i = 0; i < three_pow[n]; i++) {
//             a[i] = a[i] * ExtendedField(Exponential(three_pow[n], MOD - 2));
//         }
//     }
    
// }

// vector<ExtendedField> xor_convolute_pow(int64_t n, int64_t k, vector<ExtendedField>& a) {
//     ternary_xor_fwht(n, a);
//     for (int64_t i = 0; i < three_pow[n]; i++) {
//         a[i] = Exponential(a[i], k);
//     }
//     ternary_xor_fwht(n, a, true);

//     return a;
// }


void seven_fwht(vector<int64_t>& a, bool inv = false) {
    int64_t CURR_ROOT = inv ? INV_SEVENTH_ROOT : SEVENTH_ROOT;
    int64_t FIRST_POWER, SECOND_POWER, THIRD_POWER, FOURTH_POWER, FIFTH_POWER, SIXTH_POWER, SEVENTH_POWER;
    FIRST_POWER = CURR_ROOT;
    SECOND_POWER = FIRST_POWER * CURR_ROOT % MOD;
    THIRD_POWER = SECOND_POWER * CURR_ROOT % MOD;
    FOURTH_POWER = THIRD_POWER * CURR_ROOT % MOD;
    FIFTH_POWER = FOURTH_POWER * CURR_ROOT % MOD;
    SIXTH_POWER = FIFTH_POWER * CURR_ROOT % MOD;
    SEVENTH_POWER = SIXTH_POWER * CURR_ROOT % MOD;
    for (int64_t len = 1; len < a.size(); len *= 7) {
        for (int64_t i = 0; i < a.size(); i += 7 * len) {
            for (int64_t j = 0; j < len; j++) {
                int64_t a0 = a[i + j];
                int64_t a1 = a[i + len + j];
                int64_t a2 = a[i + 2 * len + j];
                int64_t a3 = a[i + 3 * len + j];
                int64_t a4 = a[i + 4 * len + j];
                int64_t a5 = a[i + 5 * len + j];
                int64_t a6 = a[i + 6 * len + j];

                int64_t b0 = ((((((a0 + a1) % MOD + a2) % MOD + a3) % MOD + a4) % MOD + a5) % MOD + a6) % MOD;
                int64_t b1 = ((((((a0 + a1 * FIRST_POWER) % MOD + a2 * SECOND_POWER) % MOD + a3 * THIRD_POWER) % MOD + a4 * FOURTH_POWER) % MOD + a5 * FIFTH_POWER) % MOD + a6 * SIXTH_POWER) % MOD;
                int64_t b2 = ((((((a0 + a1 * SECOND_POWER) % MOD + a2 * FOURTH_POWER) % MOD + a3 * SIXTH_POWER) % MOD + a4 * FIRST_POWER) % MOD + a5 * THIRD_POWER) % MOD + a6 * FIFTH_POWER) % MOD;
                int64_t b3 = ((((((a0 + a1 * THIRD_POWER) % MOD + a2 * SIXTH_POWER) % MOD + a3 * SECOND_POWER) % MOD + a4 * FIFTH_POWER) % MOD + a5 * FIRST_POWER) % MOD + a6 * FOURTH_POWER) % MOD;
                int64_t b4 = ((((((a0 + a1 * FOURTH_POWER) % MOD + a2 * FIRST_POWER) % MOD + a3 * FIFTH_POWER) % MOD + a4 * SECOND_POWER) % MOD + a5 * SIXTH_POWER) % MOD + a6 * THIRD_POWER) % MOD;
                int64_t b5 = ((((((a0 + a1 * FIFTH_POWER) % MOD + a2 * THIRD_POWER) % MOD + a3 * FIRST_POWER) % MOD + a4 * SIXTH_POWER) % MOD + a5 * FOURTH_POWER) % MOD + a6 * SECOND_POWER) % MOD;
                int64_t b6 = ((((((a0 + a1 * SIXTH_POWER) % MOD + a2 * FIFTH_POWER) % MOD + a3 * FOURTH_POWER) % MOD + a4 * THIRD_POWER) % MOD + a5 * SECOND_POWER) % MOD + a6 * FIRST_POWER) % MOD;

                a[i + j] = b0;
                a[i + len + j] = b1;
                a[i + 2 * len + j] = b2;
                a[i + 3 * len + j] = b3;
                a[i + 4 * len + j] = b4;
                a[i + 5 * len + j] = b5;
                a[i + 6 * len + j] = b6;
            }
        }
    }

    if (inv) {
        int64_t inv_len = Exponential(a.size(), MOD - 2);
        for (int64_t i = 0; i < a.size(); i++) {
            a[i] = a[i] * inv_len % MOD;
        }
    }
}

int64_t n, m, k;

vector<int64_t> a;

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    cin >> n >> k;

    a.resize(Exponential(7, 7));

    for (int64_t i = 0; i < n; i++) {
        cin >> m;

        int64_t x = 0, mask = 64;
        while (mask) {
            x *= 7;
            if (m & mask) {
                x++;
            }
            mask >>= 1;
        }

        a[x]++;
    }

    seven_fwht(a);
    for (int64_t i = 0; i < Exponential(7, 7); i++) {
        a[i] = Exponential(a[i], k);
    }
    seven_fwht(a, true);

    cout << a[0] << '\n';

    return 0;
}