#include <bits/stdc++.h>
#ifdef SHARAELONG
#include "debug.hpp"
#endif
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
typedef unsigned long long mask;

struct BS {
    int size;
    mask entry[88848];
    BS(int size) : size(size) {
        for (int i = 0; i <= size / 64; ++i) {
            entry[i] = 0;
        }
    }

    void flip(int i) {
        entry[i / 64] ^= 1ULL << i;
    }
    void on(int i) {
        entry[i / 64] |= 1ULL << i;
    }
    void off(int i) {
        entry[i / 64] &= ~(1ULL << i);
    }
    
    void knapsack_shift(int shift, int bound) {
        for (int i = bound / 64; i >= 0; --i) {
            int next = (i * 64 + shift);
            if (next % 64)
                entry[next / 64 + 1] |= entry[i] >> (64 - next % 64);
            entry[next / 64] |= entry[i] << (next % 64);
        }
    }

    // l]
    int find_below(int l) {
        int idx = l / 64;
        int ret = -1;
        for (int i = 0; i + idx * 64 <= l; ++i) {
            if (entry[idx] >> i & 1)
                ret = i + idx * 64;
        }

        if (ret != -1)
            return ret;
        for (int i = idx - 1; i > 0; --i) {
            if (entry[i]) {
                return i * 64 + 63 - __builtin_clzll(entry[i]);
            }
        }
        return 0;
    }
};

const int MAX_L = 3e5 + 10;

void solve() {
    int n, q;
    cin >> n >> q;
    vector<int> d(n+1), ts(n+1), tf(n+1);
    for (int i=1; i<=n; ++i) cin >> d[i] >> tf[i] >> ts[i];

    vector<int> p(n+1);
    iota(p.begin(), p.end(), 0);
    sort(p.begin()+1, p.end(), [&](int i, int j) { return ts[i] < ts[j]; });
    // print(p);

    vector<ll> dps(n+1, 0);
    for (int i=1; i<=n; ++i) dps[i] = dps[i-1] + d[p[i]];
    vector<int> suf_mx(n+2, 0);
    for (int i=n; i>=1; --i) suf_mx[i] = max(suf_mx[i+1], tf[p[i]]);
    // print(dps, suf_mx);
    
    vector<int> bal(n+1);
    BS bs(MAX_L);
    bs.on(0);
    for (int i=1; i<=n; ++i) {
        bs.knapsack_shift(d[p[i]], (int)min((ll)MAX_L, dps[i]));
        bal[i] = bs.find_below((int)min((ll)MAX_L-1, dps[i]/2));
    }

    vector<int> slow_tmp(1, 0);
    for (int i=1; i<=n; ++i) slow_tmp.push_back(ts[p[i]]);
    for (int i=0; i<q; ++i) {
        ll L;
        cin >> L;
        if (dps[n]-bal[n] > L) {
            cout << "-1\n";
            continue;
        }
        
        int low = 1, high = 1e9;
        while (low < high) {
            int mid = (low + high) / 2;
            int idx = upper_bound(slow_tmp.begin(), slow_tmp.end(), mid) - slow_tmp.begin() - 1;
            ll remain = L - (dps[idx]-bal[idx]); // 1-base
            bool ok = true;
            ok &= (remain >= dps[n]-dps[idx]);
            ok &= (suf_mx[idx+1] <= mid);
            if (ok) {
                high = mid;
            } else {
                low = mid+1;
            }
        }
        cout << low << '\n';
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    solve();
}