#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <climits>
#include <cstring>
#include <unordered_map>

#define rep(i, m, n) for(int i=int(m);i<int(n);i++)
#define all(c) begin(c),end(c)
#define ALL(v) (v).begin(),(v).end()

template<typename T1, typename T2>
inline void chmin(T1 &a, T2 b) { if (a > b) a = b; }

template<typename T1, typename T2>
inline void chmax(T1 &a, T2 b) { if (a < b) a = b; }

//改造
typedef long long int ll;
using namespace std;
#define INF (1 << 30) - 1
#define INFl (ll)5e15
#define DEBUG 0 //デバッグする時1にしてね
#define dump(x)  cerr << #x << " = " << (x) << endl
#define MOD 1000000007


//ここから編集する
template<typename T>
class segtree {
    int size;
    vector<T> valtree;
    vector<int> ismixedtree;

public:
    segtree(int n) {
        size = 8;
        while (size < n) size <<= 1;
        valtree.resize(size * 2);
        ismixedtree.resize(size * 2);
    }

    void fill(T val) {
        std::fill(ALL(valtree), val);
        std::fill(ALL(ismixedtree), 0);
    }


    void setvalrange(int begin, int end, T val, int ptr = 0, int rangebegin = 0, int rangeend = 0) {
        if (rangeend <= rangebegin) { rangeend = size; }

        if (rangeend <= begin || end <= rangebegin) return;

        if (begin <= rangebegin && rangeend <= end) {
            ismixedtree[ptr] = false;
            valtree[ptr] = val;
            return;
        }

        int rangemid = (rangebegin + rangeend) / 2;
        if (ismixedtree[ptr] == false) {
            // lazy
            valtree[ptr * 2 + 1] = valtree[ptr];
            valtree[ptr * 2 + 2] = valtree[ptr];
            ismixedtree[ptr * 2 + 1] = false;
            ismixedtree[ptr * 2 + 2] = false;
        }
        ismixedtree[ptr] = true;

        setvalrange(begin, end, val, ptr * 2 + 1, rangebegin, rangemid);
        setvalrange(begin, end, val, ptr * 2 + 2, rangemid, rangeend);

    }

    T getval(int index, int ptr = 0, int rangebegin = 0, int rangeend = 0) {
        if (rangeend <= rangebegin) { rangeend = size; }

        if (ismixedtree[ptr] == false) {
            return valtree[ptr];
        }


        int rangemid = (rangebegin + rangeend) / 2;
        if (index < rangemid)
            return getval(index, ptr * 2 + 1, rangebegin, rangemid);
        else
            return getval(index, ptr * 2 + 2, rangemid, rangeend);

    }
};

int N, Q;
vector<ll> S, T, X;
vector<ll> D;

vector<ll> inv;
//map<ll, int> zat;
unordered_map<ll, int> zat;

void input() {
    cin >> N >> Q;
    S.resize(N);
    T.resize(N);
    X.resize(N);
    D.resize(Q);
    rep(i, 0, N) {
        cin >> S[i] >> T[i] >> X[i];
        inv.push_back(S[i] - X[i]);
//            inv.push_back(T[i] - X[i] + 1);
        inv.push_back(T[i] - X[i]);
    }
    rep(i, 0, Q) {
        cin >> D[i];
        inv.push_back(D[i]);
//            inv.push_back(D[i] + 1);
    }

    sort(all(inv));
    inv.erase(unique(all(inv)), inv.end());
    sort(all(inv));
    for (int i = 0; i < inv.size(); ++i) {
        zat[inv[i]] = i;
    }
}

auto maket() {
//    int n = zat.size() + 1;
//    using T = pair<ll, int>;//value,time
//    using E = pair<ll, int>;//value,time
//    int time = 0;
//
//    T ti(INFl, 0); //要素の単位元?
//    E ei(INFl, 0); //作用素の単位元?
//    auto f = [](T a, T b) { return min(a, b); }; // 要素と要素のマージ
//    auto g = [](T a, E b) {
////        if(b == INT_MAX) return a;
////        return b;
//        if (a.second < b.second) {
//            return b;
//        } else {
//            return a;
//        }
//    }; // 要素に作用素を作用
//    auto h = [](E a, E b) {
//        if (a.second < b.second) {
//            return b;
//        } else {
//            return a;
//        }
//    }; // 作用素と作用素をマージ
//
//    auto p = [](E a, int b) { return a; }; // 作用素を区間加算する場合
//
//    SegmentTree <T, E> treeone(n, f, g, h, ti, ei, p);
//    return treeone;
}


void solve() {
    input();
    int time = 0;
    int n = zat.size() + 1;
    segtree<int> seg(n);
    seg.fill(0x7FFFFFFF);
    struct tapi {
        ll s, t, x;
    };
    vector<tapi> tapya;
    for (int i = 0; i < N; ++i) {
        tapya.push_back({S[i] - X[i], T[i] - X[i], X[i]});
    }
    sort(all(tapya), [](auto a, auto b) {
        return a.x > b.x;
    });


    for (auto ei : tapya) {
        using T = pair<ll, int>;//value,time
//            cerr << zat[ei.s] << " " << zat[ei.t] << endl;
//        tree1.update(zat[ei.s], zat[ei.t], T(ei.x, ++time));
        seg.setvalrange(zat[ei.s], zat[ei.t], ei.x);

//            cerr << "---" << endl;
//            for (auto e : inv) cerr << e << " ";
//            cerr << endl;
//            for (auto e : inv) cerr << tree1.query(zat[e], zat[e] + 1).first << " ";
//            cerr << endl;
    }


    for (auto d : D) {
//        auto tmp = tree1.query(zat[d], zat[d] + 1);
        ll tmp = seg.getval(zat[d]);
        ll ans = tmp;
        if (ans == 2147483647) {
            cout << -1 << endl;
        } else {
            cout << ans << endl;
        }
    }


}


int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(10);


    solve();

    return 0;
}


Measured memory_bytes: 75496