#ifdef __GNUC__ 
#include <bits/stdc++.h>
auto & inputdatastream = std::cin;
#else
std::ifstream inputdatastream;
#endif
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/dynamic_bitset.hpp>
#include <boost/preprocessor.hpp>
#include <boost/mpl/int.hpp>
#include <boost/range.hpp>
#include <boost/icl/map.hpp>
//#include <boost/numeric/ublas/blas.hpp>
//#include <boost/numeric/ublas/matrix.hpp>
//#include <boost/numeric/ublas/io.hpp>
//#include <boost/numeric/ublas/matrix_proxy.hpp>
using namespace std;
namespace renge = boost::range;

#define ALL(v) std::begin(v),std::end(v)


#define RALL(v) std::rbegin(v),std::rend(v)
using u6 = std::uint64_t;
using s6 = std::int64_t;
using u3 = std::uint32_t;
using s3 = std::int32_t;

constexpr u6 moduloNo = 1'000'000'000 + 7; //' 1e9 + 7
#define DEFVALUE1(r,type,name) type name;
#define DEFINIT0(r,type,name) in >> name;
#define DEFINIT1(r,size,name) name.resize(size);
#define DEFOSTREAM_FORDEBUG(r,type,name) out << name << " ";
#define DEFINITER template <typename T, typename In> void init(const T &, In &) {}
#define DEF_TYPEEXTSELECTOR(fnext,tpl)BOOST_PP_IF(BOOST_PP_TUPLE_ELEM(0, fnext)  ,BOOST_PP_TUPLE_ELEM(2, fnext),BOOST_PP_TUPLE_ELEM(0, tpl) )
#define DEFVALUEIMPL(r,fnext,tpl) BOOST_PP_LIST_FOR_EACH(BOOST_PP_TUPLE_ELEM(1,fnext),DEF_TYPEEXTSELECTOR(fnext,tpl), BOOST_PP_TUPLE_TO_LIST(BOOST_PP_TUPLE_POP_FRONT(tpl)))
#define DEFVALUES(expr) DEFIMPL(expr,0,DEFINIT0,0,_)
#define DEFIMPL(expr,deftypeindex,initcode,c,ext)																									\
			BOOST_PP_SEQ_FOR_EACH(DEFVALUEIMPL,(0,DEFVALUE1,_),BOOST_PP_VARIADIC_SEQ_TO_SEQ(expr))													\
			template <typename In> decltype(auto) init(boost::mpl::int_<deftypeindex> ,In & in){													\
				BOOST_PP_SEQ_FOR_EACH(DEFVALUEIMPL,(c,initcode,ext),BOOST_PP_VARIADIC_SEQ_TO_SEQ(expr));return in;}									\
			template <typename Out> decltype(auto) init(boost::mpl::int_<-deftypeindex-1>, Out & out) {												\
					BOOST_PP_SEQ_FOR_EACH(DEFVALUEIMPL, (c, DEFOSTREAM_FORDEBUG, ext), BOOST_PP_VARIADIC_SEQ_TO_SEQ(expr)); return out;}
#define DEFVECS(size,expr)  DEFIMPL(expr,1,DEFINIT1,1,size)
#define DEFSTRUCT(name,...) struct name{DEFINITER;__VA_ARGS__ ;friend std::istream & operator>>(std::istream & in,name & target){				\
		target.init(boost::mpl::int_<0> (),in);target.init(boost::mpl::int_<1>() ,in);return in;}												\
	friend std::ostream & operator<<(std::ostream & out, name & target) {																		\
			target.init(boost::mpl::int_<-1>(), out); return out;} }

template <typename T>
void initcalc(T & calc) {
	ios::sync_with_stdio(false); cin.tie(0);
#ifndef __GNUC__ 
	inputdatastream.open("inputdata.txt");
#endif
	calc.init(boost::mpl::int_<0>(), inputdatastream);
	calc.init(boost::mpl::int_<1>(), inputdatastream);
}
template <typename T>
auto runcalc(T & c) ->std::enable_if_t<std::is_void<decltype(c.calc())>::value > {
	c.calc();
}
template <typename T>
auto runcalc(T & c) ->std::enable_if_t<!std::is_void<decltype(c.calc())>::value > {
	std::cout << c.calc() << std::endl;
}
template <typename T>
struct invecT {
	decltype(auto) begin()const {
		return std::istream_iterator<T>(inputdatastream);
	}
	decltype(auto) end()const {
		return std::istream_iterator<T>();
	}
};
template <typename T>invecT<T> invec;
//-------------------------------------------------------------------------------

namespace nightly {

	template <typename T, bool isZeronodeCount = true>
	struct unionfind {
		std::vector<T> v;
		T count;
		void resize(std::size_t n) {
			assert(v.size() == 0); v.resize(n + 1);
			if (isZeronodeCount)count = v.size() - 1;
			else count = 0;
		}
		template <bool ismerge>
		bool find(T l, T r) {//可変長引数とかも選択肢？
			auto ll = getroot(l);
			auto rr = getroot(r);
			auto update = [this](const auto & updateindex, T minval) {
				for (auto i : updateindex)v[i] = minval;
			};
			if (ismerge) {
				std::pair<T, T> t = std::minmax(ll.first, rr.first);
				if (ll.first != rr.first) {
					--count;
					v[t.second] = t.first;
				}
				update(ll.second, t.first);
				update(rr.second, t.first);
			}
			else {
				update(ll.second, ll.first);
				update(rr.second, rr.first);
			}
			return ll.first == rr.first;
		}
	private:
		std::pair<T, std::vector<T> > getroot(T node) {
			std::pair<T, std::vector<T> > result;
			if (!v[node])v[node] = node;
			while (v[node] != node) {
				result.second.push_back(node);
				node = v[node];
			}
			result.first = node;
			return result;
		}
	};
	u6 constexpr log2p1(u6 v) {
		u6 t = 0;
		u6 st = (u6)1 << (u6)63;
		if (v == 0)return 0;
		while (!(v&st)) { ++t; st >>= 1; }
		return (64 - t);
	}
}using namespace nightly;
/*******************************************************************************/
//constexpr u6 shiftsize = 10+5;
//constexpr u6 bufsize = 1 << shiftsize;

DEFSTRUCT(datatype,DEFVALUES(///////////////////////////////////////////////////////
		(u6, s,t,x)//must copy and paste
	)///////////////////////////////////////////////////////
);
enum  {
	START=0,END,CALC
};


struct Calc {
	DEFINITER;
	DEFVALUES(//////////////////////////////////////////////////
		(int, N,Q)
	);///////////////////////////////////////////////////////
	auto calc() {
		vector<pair<u3, u3> > data;
		data.reserve(N * 2 + Q);
		for (int n = 0; n < N; ++n) {
			int s, t, x;
			inputdatastream >> s >> t >> x;
			s = max(s - x,0);
			t = max(t - x,0);
			data.emplace_back(x,(u3(s) << 2)+ 0);
			data.emplace_back(x,(u3(t) << 2)+ 1);
		}
		for (int n = 0; n < Q; ++n) {
			u3 d;
			inputdatastream >> d;
			data.emplace_back(n,(u3(d) << 2 )+ 2);
		}
		vector<int> result(Q);
		int n = 0;
		multimap<u3,u3> s;
		//priority_queue<pair<u3, u3> > q( [](auto l, auto r) {return l.first < r.first; }, move(data));
		auto fn=[](auto l, auto r) {return l.second < r.second; };
		sort(ALL(data),fn);
		auto last = data.end();
		for(auto p=data.begin();n<Q;){
			auto st = 3 & p->second;
          	//cout << "debug" << st << endl;
          	auto nextp=find_if(p,last,[st](auto l) {return (3&l.second)!=st; });
          //cout << "debug" << (p==nextp) << endl;
			//auto xn = p.second;
			if (st == 0) 
				s.insert(p,nextp);
			else if (st == 1){
              for(;p!=nextp;++p)s.erase(s.find(p->first));
            }else {
              	for(;p!=nextp;++p){
                  if (s.size() == 0)result[p->first] = -1;
                  else result[p->first] = s.begin()->first;
                  ++n;
                }
			}
          	p=nextp;
		}
		for (auto r : result)cout <<r << endl;
		return ;
	}
	/*******************************************************************************/
};

int main() {
	static Calc calc;
	initcalc(calc); runcalc(calc);
}


Measured memory_bytes: 16128