#include <bits/stdc++.h>
using namespace std;
#define getchar() p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2) ? EOF : *p1++
char buf[1000000], *p1 = buf, *p2 = buf;
template <typename T>
void read(T &x)
{
    x = 0;
    int f = 1;
    char c = getchar();
    for (; c < '0' || c > '9'; c = getchar())
        if (c == '-')
            f = -f;
    for (; c >= '0' && c <= '9'; c = getchar())
        x = x * 10 + c - '0';
    x *= f;
}
template <typename T, typename... Args>
void read(T &x, Args &...y)
{
    read(x);
    read(y...);
}
typedef long long ll;
template <int P>
class mod_int
{
    using Z = mod_int;

private:
    static int mo(int x) { return x < 0 ? x + P : x; }

public:
    int x;
    int val() const { return x; }
    mod_int() : x(0) {}
    template <class T>
    mod_int(const T &x_) : x(x_ >= 0 && x_ < P ? static_cast<int>(x_) : mo(static_cast<int>(x_ % P))) {}
    bool operator==(const Z &rhs) const { return x == rhs.x; }
    bool operator!=(const Z &rhs) const { return x != rhs.x; }
    Z operator-() const { return Z(x ? P - x : 0); }
    Z pow(long long k) const
    {
        Z res = 1, t = *this;
        while (k)
        {
            if (k & 1)
                res *= t;
            if (k >>= 1)
                t *= t;
        }
        return res;
    }
    Z &operator++()
    {
        x < P - 1 ? ++x : x = 0;
        return *this;
    }
    Z &operator--()
    {
        x ? --x : x = P - 1;
        return *this;
    }
    Z operator++(int)
    {
        Z ret = x;
        x < P - 1 ? ++x : x = 0;
        return ret;
    }
    Z operator--(int)
    {
        Z ret = x;
        x ? --x : x = P - 1;
        return ret;
    }
    Z inv() const { return pow(P - 2); }
    Z &operator+=(const Z &rhs)
    {
        (x += rhs.x) >= P && (x -= P);
        return *this;
    }
    Z &operator-=(const Z &rhs)
    {
        (x -= rhs.x) < 0 && (x += P);
        return *this;
    }
    Z operator-() { return -x; }
    Z &operator*=(const Z &rhs)
    {
        x = 1ULL * x * rhs.x % P;
        return *this;
    }
    Z &operator/=(const Z &rhs) { return *this *= rhs.inv(); }
#define setO(T, o)                                  \
    friend T operator o(const Z &lhs, const Z &rhs) \
    {                                               \
        Z res = lhs;                                \
        return res o## = rhs;                       \
    }
    setO(Z, +) setO(Z, -) setO(Z, *) setO(Z, /)
#undef setO
        friend istream &
        operator>>(istream &is, mod_int &x)
    {
        long long tmp;
        is >> tmp;
        x = tmp;
        return is;
    }
    friend ostream &operator<<(ostream &os, const mod_int &x)
    {
        os << x.val();
        return os;
    }
};
using Z = mod_int<998244353>;
int n;
ll x;
ll a[300020];
Z f[300020];
Z ans;
struct Trie
{
    int c[4800020][2];
    Z val[4800020];
    int cnt = 0;
    void insert(ll x, ll y)
    {
        int u = 0;
        for (int i = 59; i >= 0; i--)
        {
            int t = x >> i & 1;
            if (!c[u][t])
                c[u][t] = ++cnt;
            u = c[u][t];
            val[u] += y;
        }
    }
    Z query(ll x, ll y)
    {
        int u = 0;
        Z ans = 0;
        for (int i = 59; i >= 0; i--)
        {
            int t = y >> i & 1;
            if (x >> i & 1)
            {
                if (!c[u][!t])
                    return ans;
                u = c[u][!t];
                continue;
            }
            ans += val[c[u][!t]];
            if (!c[u][t])
                return ans;
            u = c[u][t];
        }
        return ans + val[u];
    }
} T;
int main()
{
    read(n, x);
    for (int i = 1; i <= n; i++)
        read(a[i]);
    sort(a + 1, a + n + 1);
    for (int i = 1; i <= n; i++)
    {
        f[i] = T.query(x, a[i]) + 1;
        ans += f[i];
        T.insert(a[i], f[i].val());
    }
    cout << ans << endl;
    return 0;
}