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

constexpr int P = 998244353;

template <class T> T qp(T a, int b) {
    T c{1};
    for (; b; b /= 2, a *= a) {
        if (b % 2) {
            c *= a;
        }
    }
    return c;
}

struct mint {
    int x;
    mint(int _x = 0) : x(_x % P) { x < 0 ? x += P : 0; }
    int val() const { return x; }

    mint operator - () const {
        return -x;
    }
    mint inv() const {
        assert(x != 0);
        return qp(*this, P - 2);
    }
    mint &operator += (const mint &rhs) {
        x += rhs.x - P, x += x >> 31 & P;
        return *this;
    }
    mint &operator -= (const mint &rhs) {
        x -= rhs.x, x += x >> 31 & P;
        return *this;
    }
    mint &operator *= (const mint &rhs) {
        x = (long long)x * rhs.x % P;
        return *this;
    }
    mint &operator /= (const mint &rhs) {
        return *this *= rhs.inv();
    }
    friend mint operator + (mint lhs, const mint &rhs) {
        return lhs += rhs;
    }
    friend mint operator - (mint lhs, const mint &rhs) {
        return lhs -= rhs;
    }
    friend mint operator * (mint lhs, const mint &rhs) {
        return lhs *= rhs;
    }
    friend mint operator / (mint lhs, const mint &rhs) {
        return lhs /= rhs;
    }

    friend ostream &operator << (ostream &os, const mint &a) {
        return os << a.val();
    }
};

struct _comb {
    int n;
    vector<mint> _fact, _finv, _inv;

    _comb() : n{0}, _fact{1}, _finv{1}, _inv{0} {}
    _comb(int n) : _comb() { init(n); }

    void init(int m) {
        if (m <= n) return;
        _fact.resize(m + 1);
        _finv.resize(m + 1);
        _inv.resize(m + 1);

        for (int i = n + 1; i <= m; i++) {
            _fact[i] = _fact[i - 1] * i;
        }
        _finv[m] = _fact[m].inv();
        for (int i = m; i > n; i--) {
            _finv[i - 1] = _finv[i] * i;
            _inv[i] = _finv[i] * _fact[i - 1];
        }
        n = m;
    }

    mint fact(int m) {
        if (m > n) init(2 * m);
        return _fact[m];
    }
    mint finv(int m) {
        if (m > n) init(2 * m);
        return _finv[m];
    }
    mint inv(int m) {
        if (m > n) init(2 * m);
        return _inv[m];
    }
    mint binom(int n, int m) {
        if (n < m || m < 0) return 0;
        return fact(n) * finv(m) * finv(n - m);
    }
} comb;

void dft(vector<mint> &a) {
    int n = a.size();
    static vector<int> rev;
    if (rev.size() != n) {
        rev.resize(n);
        int k = __lg(n) - 1;
        for (int i = 0; i < n; i++) {
            rev[i] = rev[i >> 1] >> 1 | (i & 1) << k;
        }
    }
    for (int i = 0; i < n; i++) {
        if (i < rev[i]) swap(a[i], a[rev[i]]);
    }
    static vector<mint> roots{0, 1};
    if (roots.size() < n) {
        int k = __lg(roots.size());
        for (roots.resize(n); 1 << k < n; k++) {
            mint e = qp(mint(3), (P - 1) >> (k + 1));
            for (int i = 1 << (k - 1); i < 1 << k; i++) {
                roots[2 * i] = roots[i];
                roots[2 * i + 1] = roots[i] * e;
            }
        }
    }
    for (int k = 1; k < n; k *= 2) {
        for (int i = 0; i < n; i += 2 * k) {
            for (int j = 0; j < k; j++) {
                mint u = a[i + j], v = a[i + j + k] * roots[j + k];
                a[i + j] = u + v, a[i + j + k] = u - v;
            }
        }
    }
}

void idft(vector<mint> &a) {
    int n = a.size();
    reverse(a.begin() + 1, a.end()), dft(a);
    mint inv = (1 - P) / n;
    for (int i = 0; i < n; i++) a[i] *= inv;
}

struct poly {
    vector<mint> a;
    poly() {}
    explicit poly(int n) : a(n) {}
    poly(const vector<mint> &x) : a(x) {}
    poly(const initializer_list<mint> &x) : a(x) {}

    int size() const { return a.size(); }
    void resize(int n) { a.resize(n); }
    mint operator [] (int idx) const {
        return idx < a.size() ? a[idx] : 0;
    }
    mint &operator [] (int idx) { return a[idx]; }

    poly mulxk(int k) const {
        auto b = a;
        return b.insert(b.begin(), k, 0), b;
    }
    poly modxk(int k) const {
        k = min(k, size());
        return vector<mint>(a.begin(), a.begin() + k);
    }
    poly divxk(int k) const {
        if (size() <= k) return {};
        return vector<mint>(a.begin() + k, a.end());
    }

    friend poly operator + (const poly &a, const poly &b) {
        poly res(max(a.size(), b.size()));
        for (int i = 0; i < res.size(); i++) res[i] = a[i] + b[i];
        return res;
    }
    friend poly operator - (const poly &a, const poly &b) {
        poly res(max(a.size(), b.size()));
        for (int i = 0; i < res.size(); i++) res[i] = a[i] - b[i];
        return res;
    }
    friend poly operator * (poly a, poly b) {
        if (!a.size() || !b.size()) return {};
        int sz = 1, tot = a.size() + b.size() - 1;
        while (sz < tot) sz *= 2;
        a.resize(sz), b.resize(sz);
        dft(a.a), dft(b.a);
        for (int i = 0; i < sz; i++) a[i] *= b[i];
        idft(a.a), a.resize(tot);
        return a;
    }
    friend poly operator * (mint a, poly b) {
        for (int i = 0; i < b.size(); i++) b[i] *= a;
        return b;
    }
    friend poly operator * (poly a, mint b) {
        for (int i = 0; i < a.size(); i++) a[i] *= b;
        return a;
    }
    poly &operator += (poly b) { return *this = *this + b; }
    poly &operator -= (poly b) { return *this = *this - b; }
    poly &operator *= (poly b) { return *this = *this * b; }

    poly deriv() const {
        if (a.empty()) return {};
        poly res(size() - 1);
        for (int i = 0; i < size() - 1; i++) res[i] = (i + 1) * a[i + 1];
        return res;
    }
    poly integr() const {
        poly res(size() + 1);
        for (int i = 0; i < size(); i++) res[i + 1] = a[i] / (i + 1);
        return res;
    }
    poly inv(int m) const {
        poly x{a[0].inv()};
        for (int k = 1; k < m; ) {
            k *= 2;
            x = (x * (poly{2} - modxk(k) * x)).modxk(k);
        }
        return x.modxk(m);
    }
    poly log(int m) const {
        return (deriv() * inv(m)).integr().modxk(m);
    }
    poly exp(int m) const {
        poly x{1};
        for (int k = 1; k < m; ) {
            k *= 2;
            x = (x * (poly{1} - x.log(k) + modxk(k))).modxk(k);
        }
        return x.modxk(m);
    }
    poly pow(int k, int m) const {
        int i = 0;
        while (i < size() && !a[i].val()) i++;
        if (i == size() || 1LL * i * k >= m) return poly(m);
        mint v = a[i];
        auto f = (divxk(i) * v.inv()).log(m - i * k) * k;
        return f.exp(m - i * k).mulxk(i * k) * qp(v, k);
    }
    poly sqrt(int m) const {
        poly x{1};
        for (int k = 1; k < m; ) {
            k *= 2;
            x = (x + (modxk(k) * x.inv(k)).modxk(k)) * ((P + 1) / 2);
        }
        return x.modxk(m);
    }

    poly mulT(poly b) const {
        if (!b.size()) return {};
        int n = b.size();
        reverse(b.a.begin(), b.a.end());
        return (*this * b).divxk(n - 1);
    }
    vector<mint> eval(vector<mint> x) {
        if (!size()) return vector<mint>(x.size());
        const int n = max((int)x.size(), size());
        vector<poly> q(4 * n);
        vector<mint> ans(x.size());
        x.resize(n);
        auto build = [&](auto self, int p, int l, int r) {
            if (r - l == 1) { q[p] = {1, -x[l]}; return; }
            int m = (l + r) / 2;
            self(self, 2 * p, l, m), self(self, 2 * p + 1, m, r);
            q[p] = q[2 * p] * q[2 * p + 1];
        };
        build(build, 1, 0, n);
        auto work = [&](auto self, int p, int l, int r, const poly &num) {
            if (r - l == 1) {
                if (l < ans.size()) ans[l] = num[0];
                return;
            }
            int m = (l + r) / 2;
            self(self, 2 * p, l, m, num.mulT(q[2 * p + 1]).modxk(m - l));
            self(self, 2 * p + 1, m, r, num.mulT(q[2 * p]).modxk(r - m));
        };
        work(work, 1, 0, n, mulT(q[1].inv(n)));
        return ans;
    }
};

constexpr int N = 250005;

int main() {
    ios::sync_with_stdio(0), cin.tie(0);
    int n, q;
    cin >> n >> q;
    vector<int> x(n), c(n);
    map<int, int> mp;
    mt19937_64 eng(time(0));
    for (int i = 0; i < n; i++) {
        cin >> x[i] >> c[i];
        if (!mp.count(c[i])) {
            mp[c[i]] = eng() % P;
        }
        c[i] = mp[c[i]];
    }
    vector<int> d(q);
    for (int &x : d) {
        cin >> x;
    }
    vector<int> res(q);
    /*
    1 3 9 27
    [1, 2]
    [3, 6]
    [7, 18]
    [19, ]
    */
    for (int lim = 1; lim <= 3 * n; lim *= 3) {
        poly A(N), B(N), C(N), D(N), E(N), F(N);
        for (int i = 0; i < n; i++) {
            int j = i + 1;
            if (abs(lim - j) <= j / 2) {
                A[x[i]] = c[i];
                B[x[i]] = A[x[i]] * A[x[i]] * A[x[i]];
                C[x[i]] = A[x[i]] * A[x[i]];
            }
        }
        for (int i = 0; i < n; i++) {
            D[x[i]] = c[i];
            E[x[i]] = D[x[i]] * D[x[i]] * D[x[i]];
            F[x[i]] = D[x[i]] * D[x[i]];
        }
        poly foo = D.mulT(B), bar = E.mulT(A), baz = F.mulT(C);
        for (int i = 0; i < q; i++) {
            if (res[i] == 0 && (foo[d[i]] + bar[d[i]] - 2 * baz[d[i]]).val()) {
                res[i] = lim;
            }
        }
    }
    for (int x : res) {
        cout << x << "\n";
    }
    return 0;
}