#include "bits/stdc++.h"
#define rep(i,n) for(ll i = 0; i < n; i++)
typedef long long ll;
using namespace std;
#define llMAX numeric_limits<long long>::max()
#define intMAX numeric_limits<int>::max()
#define d_5 100000
#define d9_7 1000000007
#define vll vector<vector<long long>>
#define vl vector<long long>
#define vi vector<int>
#define vii vector<vector<int>>
#define pb push_back
#define pf push_front
#define ld long double
#define ll long long
#define ull unsigned long long

ll digitpower(ll a,ull b){//aのb乗を計算
  if(b==1){
    return a;
  }else if(b==0){
    return 1;
  }
  static int modmode=0;//%d9_7するのかどうか
  if(b%2==1){
    ll tmp = digitpower(a,(b-1)/2);
    if(modmode==1){
      tmp%=d9_7;
    }
    tmp*=tmp;
    if(modmode==1){
      tmp%=d9_7;
    }
    tmp*=a;
    if(modmode==1){
     return (tmp)%d9_7;
    }else{
      return tmp;
    }
  }else{
    ll tmp = digitpower(a,(b)/2);
    if(modmode==1){
      tmp%=d9_7;
    }
    tmp*=tmp;
    if(modmode==1){
      tmp%=d9_7;
    }
    if(modmode==1){
      return (tmp)%d9_7;
    }
    return tmp;
  }
}
template<class T>
class SegmentTree{
  public:
   int n;
   vector<T> nodes;
    //constructor
    SegmentTree(int size,T init){
      initialize(size,init);
    }
    //関数を定義(minなのかmaxなのかとか)
    T thisoperator(T a, T b){
      return a+b;
    }
    void update(int x,T a){//xがindex
      x+=n-1;
      nodes[x]+=a;
      while(x>0){
        x=(x-1)/2;
        nodes[x]=thisoperator(nodes[2*x+1],nodes[2*x+2]);
      }
    }
   void initialize(int inputn,T init){
      int k=0;
      while(inputn>digitpower(2,k)){
        k++;
      }
      n=digitpower(2,k);
      nodes=vector<T> (digitpower(2,k)*2-1,init);
   }
   T sec_get(int reql,int reqr,int nowindex=0,int nowl=0,int nowr=-1){
     // 最初に呼び出されたときの対象区間は [0, n)
    if(nowr < 0) nowr = n;

    // 要求区間と対象区間が交わらない -> 適当に返す
    if(nowr <= reql || reqr <= nowl) return 0;

    // 要求区間が対象区間を完全に被覆 -> 対象区間を答えの計算に使う
    if(reql <= nowl && nowr <= reqr) return nodes[nowindex];
    // 要求区間が対象区間の一部を被覆 -> 子について探索を行う
    // 左側の子を vl ・ 右側の子を vr としている
    // 新しい対象区間は、現在の対象区間を半分に割ったもの
    T val1 = sec_get(reql, reqr, 2*nowindex+1, nowl, (nowl+nowr)/2);
    T val2 = sec_get(reql, reqr, 2*nowindex+2, (nowl+nowr)/2, nowr);
    return thisoperator(val1, val2);
   }
   void Printn(){
     cout<<"Printvector"<<endl;
     rep(i,n){
       cout<<nodes[i+n-1]<<" ";
     }
     cout<<endl;
   }
};
//abとcdの線分交差判定
bool judgeIentersected(ld ax,ld ay,ld bx,ld by,ld cx,ld cy,ld dx,ld dy) {
  ld ta = (cx - dx) * (ay - cy) + (cy - dy) * (cx - ax);
  ld tb = (cx - dx) * (by - cy) + (cy - dy) * (cx - bx);
  ld tc = (ax - bx) * (cy - ay) + (ay - by) * (ax - cx);
  ld td = (ax - bx) * (dy - ay) + (ay - by) * (ax - dx);

  return tc * td < 0 && ta * tb < 0;
  // return tc * td <= 0 && ta * tb <= 0; // 端点を含む場合
};
template<class T>
class delaySegmentTree{
  public:
   int n;
   vector<T> nodes;
   vector<T> delaynodes;
    //constructor
    delaySegmentTree(int size,T init){
      initialize(size,init);
    }
    //関数を定義(minなのかmaxなのかとか)
    T thisoperator(T a, T b){
      return a+b;
    }
    void update(int x,T a){//xがindex
      x+=n-1;
      nodes[x]+=a;
      while(x>0){
        x=(x-1)/2;
        nodes[x]=thisoperator(nodes[2*x+1],nodes[2*x+2]);
      }
    }
   void initialize(int inputn,T init){
      int k=0;
      while(inputn>digitpower(2,k)){
        k++;
      }
      n=digitpower(2,k);
      nodes=vector<T> (digitpower(2,k)*2-1,init);
      delaynodes=vector<T> (digitpower(2,k)*2-1,init);
   }
    // k 番目のノードについて遅延評価を行う
    void eval(int k, int l, int r) {
      //kが今見てるindex
    // 遅延配列が空でない場合、自ノード及び子ノードへの
    // 値の伝播が起こる
      if(delaynodes[k] != 0) {
        nodes[k] += delaynodes[k];

        // 最下段かどうかのチェックをしよう
        // 子ノードは親ノードの 1/2 の範囲であるため、
        // 伝播させるときは半分にする
        if(r - l > 1) {
            delaynodes[2*k+1] += delaynodes[k] / 2;
            delaynodes[2*k+2] += delaynodes[k] / 2;
        }

        // 伝播が終わったので、自ノードの遅延配列を空にする
        delaynodes[k] = 0;
      }
    }


    void add(int a, int b, T x, int k=0, int l=0, int r=-1) {
      if(r < 0) r = n;

      // k 番目のノードに対して遅延評価を行う
      eval(k, l, r);

      // 範囲外なら何もしない
      if(b <= l || r <= a) return;
      
      // 完全に被覆しているならば、遅延配列に値を入れた後に評価
      if(a <= l && r <= b) {
          delaynodes[k] += (r - l) * x;
          eval(k, l, r);
      }

      // そうでないならば、子ノードの値を再帰的に計算して、
      // 計算済みの値をもらってくる
      else {
          add(a, b, x, 2*k+1, l, (l+r)/2);
          add(a, b, x, 2*k+2, (l+r)/2, r);
          nodes[k] = nodes[2*k+1] + nodes[2*k+2];
      }
    }



   T sec_get(int reql,int reqr,int nowindex=0,int nowl=0,int nowr=-1){
     // 最初に呼び出されたときの対象区間は [0, n)
    if(nowr < 0) nowr = n;

    // 要求区間と対象区間が交わらない -> 適当に返す
    if(nowr <= reql || reqr <= nowl) return 0;
    //関数が呼び出されるので評価
    eval(nowindex,nowl,nowr);
    // 要求区間が対象区間を完全に被覆 -> 対象区間を答えの計算に使う
    if(reql <= nowl && nowr <= reqr) return nodes[nowindex];
    // 要求区間が対象区間の一部を被覆 -> 子について探索を行う
    // 左側の子を vl ・ 右側の子を vr としている
    // 新しい対象区間は、現在の対象区間を半分に割ったもの
    T val1 = sec_get(reql, reqr, 2*nowindex+1, nowl, (nowl+nowr)/2);
    T val2 = sec_get(reql, reqr, 2*nowindex+2, (nowl+nowr)/2, nowr);
    return thisoperator(val1, val2);
   }
   void Printn(){
     cout<<"Printvector"<<endl;
     rep(i,n){
       cout<<nodes[i+n-1]<<" ";
     }
     cout<<endl;
   }
};
struct event{
  ll s;
  ll t;
  ll x;
  ll times;
  ll timet;
};
bool cmp(const event &a, const event &b)
{
    return a.x < b.x;
}
int main(void){
  int n,q;
  cin>>n>>q;
  vl s(n),t(n),x(n);
  rep(i,n){
    cin>>s[i]>>t[i]>>x[i];
  }
  vector<event> eves(n);
  rep(i,n){
    eves[i]={s[i],t[i],x[i],s[i]-x[i],t[i]-x[i]};
  }
  vl d(q);
  rep(i,q){
    cin>>d[i];
  }
  set<pair<ll,int>> query;
  rep(i,q){
    query.insert({d[i],i});
  }
  sort(eves.begin(),eves.end(),cmp);
  vl ans(q,-1);
  rep(i,n){
    auto itr=query.lower_bound({eves[i].times,-1});
    while(itr!=query.end()){
      if(itr->first>=eves[i].timet)break;
      ans[itr->second]=eves[i].x;
      query.erase(itr++);
    }
  }
  rep(i,q){
    cout<<ans[i]<<endl;
  }
  return 0;
}


Measured memory_bytes: 30080