#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update
#define ff first
#define ss second
#define pb push_back
#define pf push_front
#define eb emplace_back
#define emp emplace
#define ins insert
#define mp make_pair
#define mt make_tuple
#define sz(s) (int)s.size()
#define forp(i,a,b) for( int i=a;i<=b;i++)
#define rep(i,n)    for( int i=0;i<n;i++)
#define ren(i,n)    for( int i=n-1;i>=0;i--)
#define forn(i,a,b) for( int i=a;i>=b;i--)
#define w(t) while(t)
#define on cout<<"\n"
#define os cout <<" "
#define o2(a,b) cout<<a<<" "<<b
#define o(a) cout << a
#define ppr(a) cout << a.first << " " << a.second
#define bitcount __builtin_popcount
#define gcd __gcd
#define all(v) v.begin(),v.end()
#define mem(n,m) memset(n,m,sizeof(n))
#define pii pair<int,int>
#define tiii tuple<int, int, int>
#define pll pair<long long,long long>
#define sii set<int>
#define sll set<long long>
#define vii vector<int>
#define vll vector<long long>
#define mii map<int,int>
#define mll map<long long, long long>
#define lob lower_bound
#define upb upper_bound
#define ret return
#define present(s,x) (s.find(x) != s.end())
#define cpresent(s,x) (find(all(s),x) != s.end())
#define ford(container, it) for(auto it = container.begin(); it != container.end(); it++)
#define fors(container, it, a, b) for(auto it = a; it != b; it++)
using namespace __gnu_pbds;
#define boost ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define MOD 1000000007
#define EPSILON 1e-9
#define PI acos(-1)
#define inf 1e18
#define int long long
#define siz 100005
#define SIZ 1000005
#define SIZE 200005
#define debug(a) cerr<<#a<<": ";for(auto i:a)cerr<<i<<" ";cerr<<'\n';
#define trace(a) cerr<<#a<<": "<<a<<"\n"
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>


typedef long long  ll;
typedef long double  ldo;
typedef double  db ;
using namespace std;
auto start = std::chrono::system_clock::now();
inline void skj()
{
  std::chrono::time_point<std::chrono::system_clock> end;
  end = std::chrono::system_clock::now();
  std::chrono::duration<double> elapsed_seconds = end - start;
  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
  cerr<<"Time taken " << elapsed_seconds.count()*1000<<"\n";
}

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
//uniform_int_distribution<int> ud(1, 100); use this for random number generator

    //custom hash for unordered map
struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        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);
    }
};
inline int binexp(int a,int b,int m)
{
    int res=1;
    a%=m;
    while(b)
    {
        if(b&1)
            res=(res*1ll*a)%m;
        a=(a*1ll*a)%m;
        b>>=1;
    }
    return res;
}
int seg[4 * SIZ], lazy[4 * SIZ];
inline void build(int node, int s, int e) {
    lazy[node] = inf;
    if(s == e) {
        seg[node] = inf;
    }
    else {
        int mid = (s + e) >> 1, p = node << 1, q = p | 1;
        build(p, s, mid);
        build(q, mid + 1, e);
        seg[node] = min(seg[p], seg[q]);
    }
}
void updateRange(int node, int start, int end, int l, int r, int val)
{
    //if(val == 13)
    //cout << start << " " << end << " " << l << " " << l << " " << r << "\n";
    if(lazy[node] != 0)
    {
        // This node needs to be updated
        seg[node] = min(seg[node], lazy[node]);    // Update it
        if(start != end)
        {
            lazy[node*2] = min(lazy[node*2], lazy[node]);                  // Mark child as lazy
            lazy[node*2+1] = min(lazy[node*2 + 1], lazy[node]);                // Mark child as lazy
        }
        lazy[node] = inf;                                  // Reset it
    }
    if(start > end or start > r or end < l)              // Current segment is not within range [l, r]
        return;
    if(start >= l and end <= r)
    {
        // Segment is fully within range
        seg[node] = min(seg[node], val);    // Update it
        if(start != end)
        {
            lazy[node*2] = min(lazy[node*2], val);                  // Mark child as lazy
            lazy[node*2+1] = min(lazy[node*2 + 1], val);                // Mark child as lazy
        }
        return;
    }
    int mid = (start + end) / 2;
    updateRange(node*2, start, mid, l, r, val);        // Updating left child
    updateRange(node*2 + 1, mid + 1, end, l, r, val);   // Updating right child
    seg[node] = min(seg[node*2], seg[node*2+1]);        // Updating root with max value
}

int queryRange(int node, int start, int end, int l, int r)
{
    if(start > end or start > r or end < l)
        return inf;         // Out of range
    if(lazy[node] != inf)
    {
        // This node needs to be updated
        seg[node] = min(seg[node], lazy[node]);    // Update it
        if(start != end)
        {
            lazy[node*2] = min(lazy[node*2], lazy[node]);                  // Mark child as lazy
            lazy[node*2+1] = min(lazy[node*2 + 1], lazy[node]);                // Mark child as lazy
        }
        lazy[node] = inf;                         // Reset it
    }
    if(start >= l and end <= r)             // Current segment is totally within range [l, r]
        return seg[node];
    int mid = (start + end) / 2;
    int p1 = queryRange(node*2, start, mid, l, r);         // Query left child
    int p2 = queryRange(node*2 + 1, mid + 1, end, l, r); // Query right child
    return min(p1, p2);
}
inline void solve_me_senpai() {
    int n, q;
    cin >> n >> q;
    vector<pair<pii, int> > range(n);
    vii D(q);
    vii V;
    rep(i, n) {
        cin >> range[i].ff.ff >> range[i].ff.ss >> range[i].ss;
        V.pb(range[i].ff.ff - range[i].ss);
        V.pb(range[i].ff.ss - range[i].ss - 1);
    }
    rep(i, q) {
        cin >> D[i];
        V.pb(D[i]);
    }
    sort(all(V));
    V.erase(unique(all(V)), V.end());
    build(1, 1, SIZ - 1);
    rep(i, n) {
        int l = upb(all(V), range[i].ff.ff - range[i].ss) - V.begin();
        int r = upb(all(V), range[i].ff.ss - range[i].ss - 1) - V.begin();
        updateRange(1, 1, SIZ - 1, l, r, range[i].ss);
        //cout << l << " " << r << " " << queryRange(1, 1, SIZ - 1, 7, 7)<< "\n";
    }
    rep(i, q) {
        D[i] = upb(all(V), D[i]) - V.begin();
        //cout << D[i] << "***\n";
        int x = queryRange(1, 1, SIZ - 1, D[i], D[i]);
        if(x == inf) {
            o(-1);
        }
        else {
            o(x);
        }
        on;
    }
}
signed main()
{
    boost
    int t = 1;
    //cin >> t;
    //int a = 1;
    while(t--) {
        //cout << "Case #" << a  << ": ";
        solve_me_senpai();
        //a++;
    }
    //skj();
    return 0;
}


Measured memory_bytes: 50536