#include <bits/stdc++.h>
using namespace std;

//f(f(x, y), z) = f(x, f(y, z))
//f(x, em) = f(em, x) = x
//g(g(a, b), c) = g(a, g(b, c));
//g(a, et) = g(et, a) = a;
//f(eval(x, a, n), eval(y, a, m)) = eval(f(x, y), a, n + m)
//eval(eval(x, a, n), b, n) = eval(x, g(a, b), n)
//を満たす必要がある

//g(x, a, 1) := xにaを作用させたときの値 であり、
//g(x, a, n) = g(x, a, 1) * g(em, a, 1) ^ (n - 1) (fを*で表している)となる

template<typename M, typename T>
struct lazy_segment_tree{
	typedef function<M(M, M)> F;
	typedef function<M(M, T, int)> EVAL;
	typedef function<T(T, T)> G;
	int size;//2冪
	vector<M> val;//1-indexed
	vector<T> lazy;//遅延情報を入れる
	F f;//結合関数
	EVAL eval;//モノイドに作用素を作用させる関数
	G g;//作用素の結合関数 A->Bの順に作用させるとg(A, B)
	M em;//モノイドの単位元
	T et;//作用素の単位元

	lazy_segment_tree(int N, vector<M> &data, F f, EVAL eval, G g, M em, T et) : f(f), eval(eval), g(g), em(em), et(et){
		size = 1;
		while(size < N) size *= 2;
		val.assign(2 * size, em);
		lazy.assign(2 * size, et);
		for(int i = 0; i < N; i++) val[size + i] = data[i];
		for(int i = N; i < size; i++) val[size + i] = em;
		for(int i = size - 1; i > 0; i--) val[i] = f(val[2 * i], val[2 * i + 1]);
	}

	void propagate(int k, int d){
		if(lazy[k] != et && k < size){
			lazy[2 * k + 0] = g(lazy[2 * k + 0], lazy[k]);
			lazy[2 * k + 1] = g(lazy[2 * k + 1], lazy[k]);
		}
		val[k] = eval(val[k], lazy[k], d);
		lazy[k] = et;
	}

	//[l, r)に対してAを作用させたときの[s, t)の値を求める
	M update(int l, int r, T a, int k, int s, int t){
		propagate(k, t - s);
		if(t <= l || r <= s) return val[k];
		else if(l <= s && t <= r){
			lazy[k] = a;
			propagate(k, t - s);
			return val[k];
		}
		else return val[k] = f(update(l, r, a, 2 * k, s, (s + t) / 2), update(l, r, a, 2 * k + 1, (s + t) / 2, t));
	}

	//[l, r)に対してaを作用させる
	void update(int l, int r, T a){
		M res = update(l, r, a, 1, 0, size);
	}

	M query(int l, int r, int k, int s, int t){
		propagate(k, t - s);
		if(t <= l || r <= s) return em;
		else if(l <= s && t <= r) return val[k];
		else return f(query(l, r, 2 * k, s, (s + t) / 2), query(l, r, 2 * k + 1, (s + t) / 2, t));
	}

	//[l, r)の演算の結果を返す
	M query(int l, int r){
		return query(l, r, 1, 0, size);
	}
};

#define inf (int)(1e9 + 1)

const int em = inf;
const int et = inf;

int my_min(int x, int y){
	return min(x, y);
}

int eval(int x, int a, int n){
	return min(x, a);
}

int g(int a, int b){
	return min(a, b);
}


int main(){
	int N, Q, i, j;
	scanf("%d%d", &N, &Q);
	vector<int> S(N), T(N), X(N), D(Q), U(0);
	for(i = 0; i < N; i++){
		scanf("%d%d%d", &S[i], &T[i], &X[i]);
		U.push_back(max(S[i] - X[i], 0));
		U.push_back(max(T[i] - X[i], 0));
	}
	for(i = 0; i < Q; i++){
		scanf("%d", &D[i]);
		U.push_back(D[i]);
	}
	sort(U.begin(), U.end());
	for(i = 1, j = 0; i < U. size(); i++){
		if(U[i] != U[j]){
			j++;
			U[j] = U[i];
		}
	}
	U.erase(U.begin() + (++j), U.end());
	vector<int> data(U.size(), inf);
	lazy_segment_tree<int, int> t(U.size(), data, my_min, eval, g, em, et);
	for(i = 0; i < N; i++){
		int a = max(S[i] - X[i], 0), b = max(T[i] - X[i], 0);
		t.update(lower_bound(U.begin(), U.end(), a) - U.begin(), lower_bound(U.begin(), U.end(), b) - U.begin(), X[i]);
	}
	for(i = 0; i < Q; i++){
		int k = lower_bound(U.begin(), U.end(), D[i]) - U.begin();
		int res = t.query(k, k + 1);
		if(res == inf){
			printf("-1\n");
		}
		else{
			printf("%d\n", res);
		}
	}
	return 0;
}

Measured memory_bytes: 27116