ABC 117

void solve() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    ll N, K;
    cin >> N >> K;
    vll A(N);
    rep(i, N) cin >> A[i];

    vint Kbit;
    vvint Abit(N);
    int mx = 60;

    {
        ll t = K;
        rep(i, mx) {
            Kbit.push_back(t % 2);
            t /= 2;
        }
        reverse(all(Kbit));

        rep(i, N) {
            ll a = A[i];
            rep(j, mx) {
                Abit[i].push_back(a % 2);
                a /= 2;
            }
            reverse(all(Abit[i]));
        }
    }

    vector dp(mx + 1, vll(2));
    rep2(i, 1, mx + 1) {
        int t = Kbit[i - 1];
        ll cnt = 0;
        rep(j, N) {
            cnt += Abit[j][i - 1];
        }

        rep(d, 2) {
            if (d < t) {
                chmax(dp[i][1], dp[i - 1][0] * 2 + cnt);
            }
            if (d == t) {
                if (d == 0)
                    chmax(dp[i][0], dp[i - 1][0] * 2 + cnt);
                else
                    chmax(dp[i][0], dp[i - 1][0] * 2 + N - cnt);
            }
            if (dp[i - 1][1]) {
                chmax(dp[i][1], dp[i - 1][1] * 2 + max(N - cnt, cnt));
            }
        }
    }

    cout << max(dp[mx][0], dp[mx][1]) << endl;
}

void solve() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int m = 60;

    auto f = [&](ll x) -> vint {
        vint v;
        rep(i, m) {
            v.push_back(x % 2);
            x /= 2;
        }
        reverse(all(v));
        return v;
    };

    ll N, K;
    cin >> N >> K;
    vll A(N);
    rep(i, N) cin >> A[i];

    vint kbit = f(K);
    vvint abits(N);
    rep(i, N) {
        abits[i] = f(A[i]);
    }

    // dp[is_less]
    vll dp(2, -1);
    dp[0] = 0;

    rep(i, m) {
        int t = kbit[i];
        vll dpn(2, -1);

        rep(d, 2) rep(is_less, 2) {
            if (!is_less && d > t) continue;  // K 超える数は NG
            if (dp[is_less] == -1) continue;  // 未到達な状態からの遷移は NG
            int is_less_n = is_less || d < t;

            ll cnt = 0;
            for (vint& a : abits) {
                cnt += a[i] ^ d;
            }

            chmax(dpn[is_less_n], dp[is_less] * 2 + cnt);
        }

        swap(dp, dpn);
    }

    cout << max(dp[0], dp[1]) << endl;
}