#include <bits/stdc++.h>
using ll = long long;
#define int ll
#define FOR(i, a, b) for (int i = (a); i < int(b); ++i)
#define RFOR(i, a, b) for (int i = (b)-1; i >= int(a); --i)
#define rep(i, n) FOR(i, 0, n)
#define rep1(i, n) FOR(i, 1, int(n) + 1)
#define rrep(i, n) RFOR(i, 0, n)
#define rrep1(i, n) RFOR(i, 1, int(n) + 1)
#define all(c) begin(c), end(c)
// const int MOD = 1000000007;

template <typename T>
void __print__(std::ostream &os, const char *, const char *tail, const T &fst) {
    os << fst << tail;
}
template <typename Fst, typename... Rst>
void __print__(std::ostream &os, const char *del, const char *tail, const Fst &fst,
               const Rst &... rst) {
    os << fst << del;
    __print__(os, del, tail, rst...);
}

#ifdef LOCAL
#define dump(...)                                         \
    do {                                                  \
        std::ostringstream os;                            \
        os << __LINE__ << ":\t" << #__VA_ARGS__ << " = "; \
        __print__(os, ", ", "\n", __VA_ARGS__);           \
        std::cerr << os.str();                            \
    } while (0)
#else
#define dump(...)
#endif

template <typename Fst, typename... Rst>
void println(const Fst &fst, const Rst &... rst) {
    __print__(std::cout, "\n", "\n", fst, rst...);
}
template <typename Fst, typename... Rst>
void print(const Fst &fst, const Rst &... rst) {
    __print__(std::cout, " ", "\n", fst, rst...);
}

template <typename iter>
void println_(iter bgn, iter end) {
    while (bgn != end) println(*bgn++);
}

template <typename iter>
void print_(iter bgn, iter end) {
    while (bgn != end) {
        std::cout << *bgn++;
        std::cout << (bgn == end ? "\n" : " ");
    }
}

int _ = (std::cout.precision(10), std::cout.setf(std::ios::fixed), std::cin.tie(0),
         std::ios::sync_with_stdio(0), 0);

template <typename T>
std::vector<T> ndarray(int n, T v) {
    return std::vector<T>(n, v);
}
template <typename... Args>
auto ndarray(int n, Args... args) {
    auto val = ndarray(args...);
    return std::vector<decltype(val)>(n, move(val));
}

template <typename T>
bool umax(T &a, const T &b) {
    return a < b ? a = b, true : false;
}

template <typename T>
bool umin(T &a, const T &b) {
    return a > b ? a = b, true : false;
}

using namespace std;

int n, k;
vector<int> a, b;

using bs = bitset<5>;

int solve() {
    // sort(all(a));

    k <<= 1;
    rep(i, n) a[i] <<= 1;
    dump(bs(k));
    rep(i, n) {
        dump(i, bs(a[i]), b[i]);
    }
    
    int top = 40;
    while ((k >> top & 1) == 0) {
        --top;
    }
    assert(k >> top & 1);


    int res = 0;

    rep(p, 32) {
        if (~k >> p & 1) continue;

        assert(k >> p & 1);
        int cand = 0;
        rep(i, n) {
            bool use = true;
            rep(c, 32) {
                if (c < p) {
                    continue;
                } else if (c == p) {
                    if (a[i] >> c & 1) use = false;
                } else {
                    if (a[i] >> c & 1 && ~k >> c & 1) use = false;
                }
            }
            if (use) {
                cand += b[i];
            }
        }
        res = max(res, cand);
    }

    // int res = 0;
    // while (top) {
    //     // topビット以上は全部0!!
    //     dump(top);
    //     int cand = 0;
    //     rep(i, n) {
    //         bool on = false;
    //         FOR(j, top, 32) {
    //             on |= a[i] >> j & 1;
    //         }
    //         if (on) continue;
    //         dump(bs(a[i]), b[i]);
    //         cand += b[i];
    //     }
    //     dump(cand);
    //     res = max(res, cand);
    //     --top;
    // }

    {
        int cand = 0;
        rep(i, n) {
            if ((k & a[i]) == a[i]) cand += b[i];
        }
        res = max(res, cand);
    }

    return res;
}

signed main() {
    while (cin >> n >> k) {
        a.resize(n);
        b.resize(n);
        rep(i, n) cin >> a[i] >> b[i];
        print(solve());
    }
}


Measured memory_bytes: 1792