#include <bits/stdc++.h>
#define REP(i,s,e) for(int i=(s); i<(e);i++)
#define rep(i,n) REP(i,0,n)
#define rep1(i,n) REP(i,1,n)
#define repe(i,n) for(auto &&i:n)
#define all(v) (v).begin(),(v).end()
#define decimal fixed<<setprecision(20)
#define fastcin() cin.tie(0);ios::sync_with_stdio(false)
using namespace std;
using LL = long long;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const int INF = 2e9;


/*
!) 0-indexed
!) [a, b)に対する演算
!) m0(l0): 初期化する値
!) merge, updateNode, propagateを書く
*/
template <typename Monoid>
struct LazySegtree {
    int n;
    vector<Monoid> dat, lazy;
    Monoid M0, L0;

    void init(int sz, Monoid m0, Monoid l0) {
        n = 1;
        M0 = m0;
        L0 = l0;
        while (n < sz) n *= 2;
        dat.assign(2*n-1, M0);
        lazy.assign(2*n-1, L0);
    }

    LazySegtree(int sz, Monoid m0, Monoid l0){
        init(sz, m0, l0);
    }

    LazySegtree(int sz, Monoid m0) {
        init(sz, m0, m0);
    }

    Monoid merge(Monoid a, Monoid b){
        // ##### WRITE HERE #####
        // 区間をマージする二項演算
        return min(a, b);
    }

    void updateNode(int k, Monoid x){
        // ##### WRITE HERE #####
        // 区間を更新する二項演算
        chmin(lazy[k], x);
    }

    void propagate(int k){
        // ##### WRITE HERE #####
        // 遅延配列の伝搬のさせ方
        chmin(dat[k], lazy[k]);
    }

    void eval(int k, int l, int r) {
        if(lazy[k] == L0) return;
        propagate(k);
        if(r-l > 1) {
            updateNode(2*k+1, lazy[k]);
            updateNode(2*k+2, lazy[k]);
        }
        lazy[k] = L0;
    }

    void update(int a, int b, Monoid x, int k, int l, int r) {
        eval(k, l, r);
        // 範囲外
        if (r <= a || b <= l) return;
        // [a, b)が[l, r)を被覆
        if (a <= l && r <= b) {
            updateNode(k, x);
            eval(k, l, r);
        }else{
            update(a, b, x, k*2+1, l, (l+r)/2);
            update(a, b, x, k*2+2, (l+r)/2, r);
            dat[k] = merge(dat[2*k+1], dat[2*k+2]);
        }
    }

    void update(int a, int b, Monoid x) {
        update(a, b, x, 0, 0, n);
    }

    Monoid query(int a, int b, int k, int l, int r) {
        eval(k, l, r);
        // 範囲外
        if (r <= a || b <= l) return M0;
        // [a, b)が[l, r)を被覆
        if (a <= l && r <= b) return dat[k];
        else {
            Monoid L = query(a, b, k*2+1, l, (l+r)/2);
            Monoid R = query(a, b, k*2+2, (l+r)/2, r);
            return merge(L, R);
        }
    }

    Monoid query(int a, int b){
        return query(a, b, 0, 0, n);
    }

    Monoid operator[](const int &k){ return dat[k + n - 1]; }
};

int main(){
    int n, q;
    cin >> n >> q;
    vector<int> s(n), t(n), x(n);
    rep(i, n) cin >> s[i] >> t[i] >> x[i];
    vector<int> d(q);
    rep(i, q) cin >> d[i];

    vector<int> unzip;
    rep(i, n) unzip.push_back(s[i]-x[i]);
    rep(i, n) unzip.push_back(t[i]-x[i]);
    sort(all(unzip));
    unzip.erase(unique(all(unzip)), unzip.end());
    map<int, int> zip;
    rep(i, unzip.size()) zip[unzip[i]] = i+1;

    LazySegtree<int> seg(2*n+1, INF);

    rep(i, n){
        seg.update(zip[s[i]-x[i]], zip[t[i]-x[i]], x[i]);
    }

    rep(i, q){
        int idx = upper_bound(all(unzip), d[i]) - unzip.begin();
        if(idx == 0){
            cout << -1 << endl;
            continue;
        }
        LL ans = seg.query(idx, idx+1);
        if(ans == INF) ans = -1;
        cout << ans << endl;
    }
}

Measured memory_bytes: 33136