//#pragma GCC optimize(2,"Ofast")
//#pragma GCC optimize(3,"inline")
#include<bits/stdc++.h>
using namespace std;
//#include<bits/extc++.h>
//using namespace __gnu_pbds;
//using namespace __gnu_cxx;

//--------------------------Abbreviations--------------------------//

#define x1 __________________
#define y1 ___________________
#define x2 ____________________
#define y2 _____________________
#define fi first
#define se second
#define endl '\n'
#define uint unsigned int
#define int long long
using ll = long long;
using ld = long double;
using ull = unsigned long long;
//using lll = __int128;
using vi = vector<int>;
using pi = pair<int, int>;
template <class T> using vc = vector<T>;
template <class T> using vvc = vector<vc<T>>;
template <class T> using vvvc = vector<vvc<T>>;
template <class T1, class T2> using pr = pair<T1, T2>;
using ai2 = array<int, 2>;using ai3 = array<int, 3>;
using ai4 = array<int, 4>;using ai5 = array<int, 5>;
struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }
    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};
template<class Key> using uset = unordered_set<Key, custom_hash>;
template<class Key, class Value> using umap = unordered_map<Key, Value, custom_hash>;

//--------------------------Function--------------------------//

#define sqrt(x) sqrtl(x)
#define log2(x) (63 - __builtin_clzll(x))
#define Ones(x) __builtin_popcountll(x)
#define ceil(x, y) (((x) + (y) - 1) / (y))
//#define max(a, b) ((a) > (b) ? (a) : (b))
//#define min(a, b) ((a) < (b) ? (a) : (b))
ld getld() { string x;cin >> x;return stold(x); }
template<typename T> inline bool chkmax(T& a, T b) { if (a >= b) return 0;a = b;return 1; }
template<typename T> inline bool chkmin(T& a, T b) { if (a <= b) return 0;a = b;return 1; }
mt19937_64 mrand(random_device{}()); ll rnd(ll l, ll r) { return mrand() % (r - l + 1) + l; }

//--------------------------Debug--------------------------//

#ifdef LOCAL
#define debug_(x) cerr << #x << " = " << (x) << ' '
#define debug(x) cerr << #x << " = " << (x) << '\n'
#define debugsq(x) cerr << #x << ": ["; for (auto i : x) cerr << i << ' '; cerr << "]\n";
#define debugmp(x) cerr << #x << ": [ "; for (auto [i, j] : x) cerr << '[' << i << "," << j << "] "; cerr << "]\n";
#define debugs(x...) do{cerr << #x << " : "; ERR(x);} while (0)
void ERR() { cerr << endl; } template <class T, class... Ts> void ERR(T arg, Ts ...args) { cerr << arg << ", ";ERR(args...); }
#else
#define debug(...) 'm'
#define debug_(...) 'r'
#define debugsq(...) 's'
#define debugmp(...) 'u'
#define debugs(...) 'n'
#define ERR() 's'
#endif

//--------------------------Constant--------------------------//

const ll inf = 1e18;
const int N = 1e6 + 10;
const int MOD = 1e18;//998244353
const ld PI = acos(-1);
//const __int128 ONE = 1;

//--------------------------Other--------------------------//

int mx[]{ 0,-1,0,1 };
int my[]{ 1,0,-1,0 };
#define YES cout << "YES" << '\n'
#define NO cout << "NO" << '\n'
#define quit cout << "quit" << '\n'; return
template <class... Args> void myin(Args&... args) { ((cin >> args), ...); }
template <class... Args> void myout(const Args&... args) { ((cout << args), ...); }
//ofstream mcout("C:/Users/Mrsuns/Desktop/out.txt");
//ofstream mcout("C:/Users/Mrsuns/Desktop/out.txt");

//--------------------------END--------------------------//

namespace Cipolla {
    int mul(int x, int y) { return 1ll * x * y % MOD; }
    uint qp(uint a, int b) { uint res = 1; for (; b; b >>= 1, a = mul(a, a))  if (b & 1)  res = mul(res, a); return res; }
    int sqr_i;
    struct spc_Cp {
        int x, y;
        spc_Cp() { ; }
        spc_Cp(int x, int y) : x(x), y(y) {}
        inline spc_Cp operator * (const spc_Cp& t) const { return (spc_Cp) { (mul(x, t.x) + mul(mul(y, t.y), sqr_i)) % MOD, (mul(x, t.y) + mul(y, t.x)) % MOD }; }
    };
    spc_Cp qp(spc_Cp a, int b) {
        spc_Cp res = spc_Cp(1, 0);
        while (b) {
            if (b & 1) res = res * a;
            b >>= 1, a = a * a;
        }
        return res;
    }
    //解是res和MOD-res
    int Cipolla(int n) {
        srand(time(NULL));
        if (qp(n, MOD >> 1) == MOD - 1) return -1;
        ll t = mul(rand(), rand());
        while (qp((mul(t, t) - n) % MOD + MOD, MOD >> 1) == 1) t = 1ll * rand() * rand() % MOD;//找到非二次剩余的数,期望循环次数为2
        sqr_i = ((mul(t, t) - n) % MOD + MOD) % MOD;
        int res = qp(spc_Cp(t, 1), MOD + 1 >> 1).x;
        //return res;//返回任何一个解
        return min(res, MOD - res);//返回较小解
    }
}


int rev[N];//NTT/FFT反转二进制
namespace MTT {//任意模数多项式乘法
    const double PI = acos((double)-1);
    struct Cp {
        double x, y;
        Cp() { ; }
        Cp(double _x, double _y) : x(_x), y(_y) { }
        inline Cp operator + (const Cp& t) const { return (Cp) { x + t.x, y + t.y }; }
        inline Cp operator - (const Cp& t) const { return (Cp) { x - t.x, y - t.y }; }
        inline Cp operator * (const Cp& t) const { return (Cp) { x* t.x - y * t.y, x* t.y + y * t.x }; }
    }A[N], B[N], C[N], w[N / 2];

#define E(x) ll(x+0.5)%P

    void FFT(int n, Cp* a, int f) {
        for (int i = 0;i <= n - 1;i++) if (rev[i] < i) swap(a[i], a[rev[i]]);
        w[0] = Cp(1, 0);
        for (int i = 1;i < n;i <<= 1) {
            Cp t = Cp(cos(PI / i), f * sin(PI / i));
            for (int j = i - 2;j >= 0;j -= 2) w[j + 1] = t * (w[j] = w[j >> 1]);
            for (int l = 0;l < n;l += 2 * i) {
                for (int j = l;j < l + i;j++) {
                    Cp t = a[j + i] * w[j - l];
                    a[j + i] = a[j] - t;
                    a[j] = a[j] + t;
                }
            }
        }
        if (f == -1) for (int i = 0;i <= n - 1;i++) a[i].x /= n, a[i].y /= n;
    }

    void Multiply(vector<uint> a, vector<uint> b, vector<uint>& res, int P) {
        // [0,n-1]*[0,m-1]->[0,n+m-2]
        int n = a.size(), m = b.size();res.resize(n + m - 1);
        int S = (1 << 15) - 1;

        int R = 1, cc = -1;
        while (R <= n + m - 1) R <<= 1, cc++;
        for (int i = 1;i <= R;i++) rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << cc);
        for (int i = 0;i <= n - 1;i++) A[i] = Cp((a[i] & S), (a[i] >> 15));
        for (int i = 0;i <= m - 1;i++) B[i] = Cp((b[i] & S), (b[i] >> 15));
        for (int i = n;i <= R - 1;i++) A[i] = Cp(0, 0);
        for (int i = m;i <= R - 1;i++) B[i] = Cp(0, 0);

        FFT(R, A, 1), FFT(R, B, 1);
        for (int i = 0;i <= R - 1;i++) {
            int j = (R - i) % R;
            C[i] = Cp((A[i].x + A[j].x) / 2, (A[i].y - A[j].y) / 2) * B[i];
            B[i] = Cp((A[i].y + A[j].y) / 2, (A[j].x - A[i].x) / 2) * B[i];
        }
        FFT(R, C, -1), FFT(R, B, -1);
        for (int i = 0;i <= n + m - 2;i++) {
            ll a = E(C[i].x), b = E(C[i].y), c = E(B[i].x), d = E(B[i].y);
            res[i] = (a + ((b + c) << 15) + (d << 30)) % P;
        }
    }
    void Multiply_db(vector<ld> a, vector<ld> b, vector<ld>& res) {//答案double类型
        // [0,n-1]*[0,m-1]->[0,n+m-2]
        int n = a.size(), m = b.size();res.resize(n + m - 1);

        int R = 1, cc = -1;
        while (R <= n + m - 1) R <<= 1, cc++;
        for (int i = 1;i <= R;i++) rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << cc);
        for (int i = 0;i <= n - 1;i++) A[i] = Cp(a[i], 0);
        for (int i = 0;i <= m - 1;i++) B[i] = Cp(b[i], 0);
        for (int i = n;i <= R - 1;i++) A[i] = Cp(0, 0);
        for (int i = m;i <= R - 1;i++) B[i] = Cp(0, 0);

        FFT(R, A, 1), FFT(R, B, 1);
        for (int i = 0;i < R;i++) C[i] = A[i] * B[i];
        FFT(R, C, -1);
        for (int i = 0;i <= n + m - 2;i++) res[i] = C[i].x;
    }

#undef E
}

int Add(int x, int y) { return (x + y >= MOD) ? x + y - MOD : x + y; }
int Dec(int x, int y) { return (x - y < 0) ? x - y + MOD : x - y; }
int mul(int x, int y) { return 1ll * x * y % MOD; }
uint qp(uint a, int b) { uint res = 1; for (; b; b >>= 1, a = mul(a, a))  if (b & 1)  res = mul(res, a); return res; }


namespace NTT {
    int sz;
    uint w[2500005], w_mf[2500005];
    int mf(int x) { return (1ll * x << 32) / MOD; }
    void init(int n) {
        for (sz = 2; sz < n; sz <<= 1);
        uint pr = qp(3, (MOD - 1) / sz);
        w[sz / 2] = 1; w_mf[sz / 2] = mf(1);
        for (int i = 1; i < sz / 2; i++)  w[sz / 2 + i] = mul(w[sz / 2 + i - 1], pr), w_mf[sz / 2 + i] = mf(w[sz / 2 + i]);
        for (int i = sz / 2 - 1; i; i--)  w[i] = w[i << 1], w_mf[i] = w_mf[i << 1];
    }
    void ntt(vector<uint>& A, int L) {
        for (int d = L >> 1; d; d >>= 1)
            for (int i = 0; i < L; i += (d << 1))
                for (int j = 0; j < d; j++) {
                    uint x = A[i + j] + A[i + d + j];
                    if (x >= 2 * MOD)  x -= 2 * MOD;
                    ll t = A[i + j] + 2 * MOD - A[i + d + j], q = t * w_mf[d + j] >> 32; int y = t * w[d + j] - q * MOD;
                    A[i + j] = x; A[i + d + j] = y;
                }
        for (int i = 0; i < L; i++)  if (A[i] >= MOD)  A[i] -= MOD;
    }
    void intt(vector<uint>& A, int L) {
        for (int d = 1; d < L; d <<= 1)
            for (int i = 0; i < L; i += (d << 1))
                for (int j = 0; j < d; j++) {
                    uint x = A[i + j]; if (x >= 2 * MOD)  x -= 2 * MOD;
                    ll t = A[i + d + j], q = t * w_mf[d + j] >> 32, y = t * w[d + j] - q * MOD;
                    A[i + j] = x + y; A[i + d + j] = x + 2 * MOD - y;
                }
        int k = (L & (-L));
        reverse(A.begin() + 1, A.end());
        for (int i = 0; i < L; i++) {
            ll m = -A[i] & (L - 1);
            A[i] = (A[i] + m * MOD) / k;
            if (A[i] >= MOD)  A[i] -= MOD;
        }
    }
}
int _inv[N];
void Poly_init(int mod = MOD) {
    _inv[1] = 1;
    for (int i = 2;i < N;i++) _inv[i] = 1llu * _inv[MOD % i] * (MOD - MOD / i) % MOD;
}
struct Poly {
    vector<ld> p;
    Poly(int n) { p.resize(n); }
    Poly(int n, int k) { p.resize(n);for (int i = 0;i < n;i++) p[i] = k; }
    Poly() {}
    ld operator[](const int& k)const { return p[k]; }
    ld& operator[](const int& k) { return p[k]; }
    Poly extend(int x) { Poly c = *this;c.p.resize(x);return c; }
    int deg() { return (int)p.size() - 1; }
    void resize(int n) { p.resize(n); }
    int size() { return p.size(); }
    void rev() { reverse(p.begin(), p.end()); }
};
Poly operator+ (Poly A, Poly B) {
    int n = A.size(), m = B.size();
    Poly c(max(n, m));
    for (int i = 0; i < n; i++)  c[i] = A[i];
    for (int i = 0; i < m; i++)  c[i] = Add(c[i], B[i]);
    return c;
}
Poly operator- (Poly A, Poly B) {
    int n = A.size(), m = B.size();
    Poly c(max(n, m));
    for (int i = 0; i < n; i++)  c[i] = A[i];
    for (int i = 0; i < m; i++)  c[i] = Dec(c[i], B[i]);
    return c;
}
// Poly operator*(Poly A, Poly B) {//MOD=998244353,..a*2^k+1
//     int n = A.deg() + B.deg() + 1;
//     int lim;for (lim = 1; lim < n; lim <<= 1); NTT::init(lim);
//     A.resize(lim); B.resize(lim);
//     NTT::ntt(A.p, lim); NTT::ntt(B.p, lim);
//     for (int i = 0; i < lim; i++)  A[i] = mul(A[i], B[i]);
//     NTT::intt(A.p, lim); return A.extend(n);
// }

// Poly operator*(Poly A, Poly B) {//任意模数多项式乘法
//     int n = A.deg() + B.deg() + 1;
//     Poly res(n);
//     MTT::Multiply(A.p, B.p, res.p, MOD);
//     return res.extend(n);
// }

Poly operator*(Poly A, Poly B) {//答案double类型||如果答案不取模,改成longdouble即可
    int n = A.deg() + B.deg() + 1;
    Poly res(n);
    MTT::Multiply_db(A.p, B.p, res.p);
    return res.extend(n);
}

//记得Poly_init, 如果仅是乘法则不需要
//Poly读入和初始化时,记得取模. f[i] = -1  ==> f[i] = MOD-1 
//MTT的rev开lim大小,为方便一般3~4倍即可

const int LEN = 250010;
//const int LEN = 250;

void Solve(int TIME) {

    int n, q;cin >> n >> q;
    vc<ai2> a(n + 1);
    vc<ai2> pos(LEN + 1);
    for (int i = 1;i <= n;i++) {
        int x, c;cin >> x >> c;
        a[i] = { x,c };//下标i，坐标x，颜色c
        pos[x] = { i,c };
    }

    vi qry(q + 1);
    for (int i = 1;i <= q;i++) {
        int d;cin >> d;
        qry[i] = d;
    }
    vc<ld> res(q + 1);
    for (int l = 1;l <= n;l = l * 3) {
        int r = min(l * 3 - 1, n);
        Poly A(LEN + 1), B(LEN + 1);
        Poly As(LEN + 1), Bs(LEN + 1);
        Poly ea(LEN + 1), eb(LEN + 1);
        for (int i = 1;i <= LEN;i++) ea[i] = (l <= pos[i][0] && pos[i][0] <= r);
        for (int i = 1;i <= LEN;i++) A[i] = ea[i] ? pos[i][1] : 0, As[i] = A[i] * A[i];
        for (int i = 1;i <= LEN;i++) eb[i] = (pos[i][0] != 0);
        for (int i = 1;i <= LEN;i++) B[i] = pos[i][1], Bs[i] = B[i] * B[i];
        A.rev(), As.rev(), ea.rev();
        Poly res1 = As * eb;
        Poly res2 = Bs * ea;
        Poly res3 = A * B;
        for (int i = 1;i <= q;i++) {
            if (res[i]) continue;
            if (LEN + qry[i] > res1.deg()) continue;
            ll x = ll(res1[LEN + qry[i]] + 0.5) + ll(res2[LEN + qry[i]] + 0.5) - 2 * ll(res3[LEN + qry[i]] + 0.5);
            if (x) res[i] = 1.5 * l;
        }
    }
    for (int i = 1;i <= q;i += 1) cout << res[i] << endl;

}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cout << fixed << setprecision(15);

    int T = 1;
    //cin >> T;

    int TIME = 0;
    while (T--) {
        Solve(++TIME);
    }

    return 0;
}