from heapq import *

class MultisetBIT:
    """
    最大値が小さい数について、その重複を許した集合を管理する。
    最大値 maxvalue を受け取り、[0, maxvalue] を管理する。
    counter は辞書型かリスト型で、counter[i] が i の個数を持つことを仮定する。
    counter が与えられなかった場合は、全て個数 0 で初期化される。
    基本的に閉区間で管理する。
    内部では受け取った数を +1 したものをindexとして持っているので注意。
    """

    __slots__ = ["n", "k", "data"]

    def __init__(self, maxvalue, counter = None):
        self.n = maxvalue + 1
        self.k = 1 << ((self.n + 1).bit_length() - 1)
        self.data = [0] * (self.n + 1)
        if counter is not None:
            self.update(counter)
        
    def update(self, counter):
        """
        counter を受け取って、それを反映させる。
        counter は辞書型かリスト型で、counter[i] が i の個数を持つことを仮定する。
        計算量は、n を要素の最大値として、 O(n) となる。
        """
        if isinstance(counter, list):
            self.data = [0] + counter + [0] * (self.n - len(counter))
        else:
            self.data = [0] * (self.n + 1)
            for k, v in counter.items():
                self.data[k + 1] = v
        for i in range(1, self.n + 1):
            if i + (i & -i) <= self.n:
                self.data[i + (i & -i)] += self.data[i]

    def add(self, value):
        """
        与えられた引数を Multiset に加える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        value += 1
        while value <= self.n:
            self.data[value] += 1
            value += value & -value

    def pop(self, value):
        """
        Multiset から与えられた引数を取り除く。
        与えられた引数が Multiset に入っているかのチェックは行わなず、
        単にその個数を 1 減らすだけなので注意。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        value += 1
        while value <= self.n:
            self.data[value] -= 1
            value += value & -value

    def count_le(self, value):
        """
        Multiset 内の要素 elem のうち、0 <= elem <= value を満たすものを数える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        value += 1
        ret = 0
        while value > 0:
            ret += self.data[value]
            value -= value & -value
        return ret

    def count(self, first, last):
        """
        Multiset 内の要素 elem のうち、first <= elem <= last を満たすものを数える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        last += 1
        ret = 0
        while first < last:
            ret += self.data[last]
            last -= last & -last
        while last < first:
            ret -= self.data[first]
            first -= first & -first
        return ret

    def bisect(self, count):
        """
        Multiset 内の要素 elem のうち、count <= count_le(elem) を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        ret = 0
        k = self.k
        while k > 0:
            if ret + k <= self.n and self.data[ret + k] < count:
                count -= self.data[ret + k]
                ret += k
            k //= 2
        return ret

    def lower_bound(self, value):
        """
        Multiset 内の要素 elem のうち、value <= elem を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        return self.bisect(self.count_le(value - 1) + 1)

    def upper_bound(self, value):
        """
        Multiset 内の要素 elem のうち、value < elem を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        return self.bisect(self.count_le(value) + 1)


N, Q = map(int, input().split())
STXs = [tuple(map(int, input().split())) for _ in range(N)]
Ds = [int(input()) for _ in range(Q)]

i2X = sorted(map(lambda t: t[2], STXs))
X2i = {X:i for i, X in enumerate(i2X)}
max_i = len(i2X) - 1
mbit = MultisetBIT(max_i)

events = []
for S, T, X in STXs:
    events.append( ((S - X) << 32) + (X2i[X] << 1)     )
    events.append( ((T - X) << 32) + (X2i[X] << 1) + 1 )
heapify(events)

mask = (1 << 32) - 1
for D in Ds:
    while events:
        if events[0] % 2 == 0:
            if (events[0] >> 32) <= D:
                e = heappop(events)
                mbit.add((e & mask) >> 1)
            else:
                break
        else:
            if (events[0] >> 32) <= D:
                e = heappop(events)
                mbit.pop((e & mask) >> 1)
            else:
                break
    # print([mbit.count(i, i) for i in range(max_i + 1)])
    ans_i = mbit.lower_bound(0)
    print(-1 if ans_i > max_i else i2X[ans_i]) from heapq import * class MultisetBIT:
    """
    最大値が小さい数について、その重複を許した集合を管理する。
    最大値 maxvalue を受け取り、[0, maxvalue] を管理する。
    counter は辞書型かリスト型で、counter[i] が i の個数を持つことを仮定する。
    counter が与えられなかった場合は、全て個数 0 で初期化される。
    基本的に閉区間で管理する。
    内部では受け取った数を +1 したものをindexとして持っているので注意。
    """

    __slots__ = ["n", "k", "data"]

    def __init__(self, maxvalue, counter = None):
        self.n = maxvalue + 1
        self.k = 1 << ((self.n + 1).bit_length() - 1)
        self.data = [0] * (self.n + 1)
        if counter is not None:
            self.update(counter)
        
    def update(self, counter):
        """
        counter を受け取って、それを反映させる。
        counter は辞書型かリスト型で、counter[i] が i の個数を持つことを仮定する。
        計算量は、n を要素の最大値として、 O(n) となる。
        """
        if isinstance(counter, list):
            self.data = [0] + counter + [0] * (self.n - len(counter))
        else:
            self.data = [0] * (self.n + 1)
            for k, v in counter.items():
                self.data[k + 1] = v
        for i in range(1, self.n + 1):
            if i + (i & -i) <= self.n:
                self.data[i + (i & -i)] += self.data[i]

    def add(self, value):
        """
        与えられた引数を Multiset に加える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        value += 1
        while value <= self.n:
            self.data[value] += 1
            value += value & -value

    def pop(self, value):
        """
        Multiset から与えられた引数を取り除く。
        与えられた引数が Multiset に入っているかのチェックは行わなず、
        単にその個数を 1 減らすだけなので注意。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        value += 1
        while value <= self.n:
            self.data[value] -= 1
            value += value & -value

    def count_le(self, value):
        """
        Multiset 内の要素 elem のうち、0 <= elem <= value を満たすものを数える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        value += 1
        ret = 0
        while value > 0:
            ret += self.data[value]
            value -= value & -value
        return ret

    def count(self, first, last):
        """
        Multiset 内の要素 elem のうち、first <= elem <= last を満たすものを数える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        last += 1
        ret = 0
        while first < last:
            ret += self.data[last]
            last -= last & -last
        while last < first:
            ret -= self.data[first]
            first -= first & -first
        return ret

    def bisect(self, count):
        """
        Multiset 内の要素 elem のうち、count <= count_le(elem) を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        ret = 0
        k = self.k
        while k > 0:
            if ret + k <= self.n and self.data[ret + k] < count:
                count -= self.data[ret + k]
                ret += k
            k //= 2
        return ret

    def lower_bound(self, value):
        """
        Multiset 内の要素 elem のうち、value <= elem を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        return self.bisect(self.count_le(value - 1) + 1)

    def upper_bound(self, value):
        """
        Multiset 内の要素 elem のうち、value < elem を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        return self.bisect(self.count_le(value) + 1) MultisetBIT """
    最大値が小さい数について、その重複を許した集合を管理する。
    最大値 maxvalue を受け取り、[0, maxvalue] を管理する。
    counter は辞書型かリスト型で、counter[i] が i の個数を持つことを仮定する。
    counter が与えられなかった場合は、全て個数 0 で初期化される。
    基本的に閉区間で管理する。
    内部では受け取った数を +1 したものをindexとして持っているので注意。
    """ __slots__ = ["n", "k", "data"] __slots__ ["n", "k", "data"] "n" "k" "data" def __init__(self, maxvalue, counter = None):
        self.n = maxvalue + 1
        self.k = 1 << ((self.n + 1).bit_length() - 1)
        self.data = [0] * (self.n + 1)
        if counter is not None:
            self.update(counter)
        
     __init__ self.n = maxvalue + 1 self.n self n maxvalue + 1 maxvalue 1 self.k = 1 << ((self.n + 1).bit_length() - 1) self.k self k 1 << ((self.n + 1).bit_length() - 1) 1 (self.n + 1).bit_length() - 1 (self.n + 1).bit_length() self.n + 1).bit_length self.n + 1 self.n self n 1 bit_length 1 self.data = [0] * (self.n + 1) self.data self data [0] * (self.n + 1) [0] 0 self.n + 1 self.n self n 1 if counter is not None:
            self.update(counter)
        
     counter is not None counter None self.update(counter) self.update self update counter self self maxvalue maxvalue counter = None counter None def update(self, counter):
        """
        counter を受け取って、それを反映させる。
        counter は辞書型かリスト型で、counter[i] が i の個数を持つことを仮定する。
        計算量は、n を要素の最大値として、 O(n) となる。
        """
        if isinstance(counter, list):
            self.data = [0] + counter + [0] * (self.n - len(counter))
        else:
            self.data = [0] * (self.n + 1)
            for k, v in counter.items():
                self.data[k + 1] = v
        for i in range(1, self.n + 1):
            if i + (i & -i) <= self.n:
                self.data[i + (i & -i)] += self.data[i]

     update """
        counter を受け取って、それを反映させる。
        counter は辞書型かリスト型で、counter[i] が i の個数を持つことを仮定する。
        計算量は、n を要素の最大値として、 O(n) となる。
        """ if isinstance(counter, list):
            self.data = [0] + counter + [0] * (self.n - len(counter))
        else:
            self.data = [0] * (self.n + 1)
            for k, v in counter.items():
                self.data[k + 1] = v
         isinstance(counter, list) isinstance counter list self.data = [0] + counter + [0] * (self.n - len(counter)) self.data self data [0] + counter + [0] * (self.n - len(counter)) [0] + counter [0] 0 counter [0] * (self.n - len(counter)) [0] 0 self.n - len(counter) self.n self n len(counter) len counter self.data = [0] * (self.n + 1) self.data self data [0] * (self.n + 1) [0] 0 self.n + 1 self.n self n 1 for k, v in counter.items():
                self.data[k + 1] = v
         k v counter.items() counter.items counter items self.data[k + 1] = v self.data[k + 1] self.data self data k + 1 k 1 v for i in range(1, self.n + 1):
            if i + (i & -i) <= self.n:
                self.data[i + (i & -i)] += self.data[i]

     i range(1, self.n + 1) range 1 self.n + 1 self.n self n 1 if i + (i & -i) <= self.n:
                self.data[i + (i & -i)] += self.data[i]

     i + (i & -i) <= self.n i + (i & -i) i i & -i i -i i self.n self n self.data[i + (i & -i)] += self.data[i] self.data[i + (i & -i)] self.data self data i + (i & -i) i i & -i i -i i self.data[i] self.data self data i self self counter counter def add(self, value):
        """
        与えられた引数を Multiset に加える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        value += 1
        while value <= self.n:
            self.data[value] += 1
            value += value & -value

     add """
        与えられた引数を Multiset に加える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """ value += 1 value 1 while value <= self.n:
            self.data[value] += 1
            value += value & -value

     value <= self.n value self.n self n self.data[value] += 1 self.data[value] self.data self data value 1 value += value & -value value value & -value value -value value self self value value def pop(self, value):
        """
        Multiset から与えられた引数を取り除く。
        与えられた引数が Multiset に入っているかのチェックは行わなず、
        単にその個数を 1 減らすだけなので注意。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        value += 1
        while value <= self.n:
            self.data[value] -= 1
            value += value & -value

     pop """
        Multiset から与えられた引数を取り除く。
        与えられた引数が Multiset に入っているかのチェックは行わなず、
        単にその個数を 1 減らすだけなので注意。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """ value += 1 value 1 while value <= self.n:
            self.data[value] -= 1
            value += value & -value

     value <= self.n value self.n self n self.data[value] -= 1 self.data[value] self.data self data value 1 value += value & -value value value & -value value -value value self self value value def count_le(self, value):
        """
        Multiset 内の要素 elem のうち、0 <= elem <= value を満たすものを数える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        value += 1
        ret = 0
        while value > 0:
            ret += self.data[value]
            value -= value & -value
        return ret

     count_le """
        Multiset 内の要素 elem のうち、0 <= elem <= value を満たすものを数える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """ value += 1 value 1 ret = 0 ret 0 while value > 0:
            ret += self.data[value]
            value -= value & -value
         value > 0 value 0 ret += self.data[value] ret self.data[value] self.data self data value value -= value & -value value value & -value value -value value return ret ret self self value value def count(self, first, last):
        """
        Multiset 内の要素 elem のうち、first <= elem <= last を満たすものを数える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        last += 1
        ret = 0
        while first < last:
            ret += self.data[last]
            last -= last & -last
        while last < first:
            ret -= self.data[first]
            first -= first & -first
        return ret

     count """
        Multiset 内の要素 elem のうち、first <= elem <= last を満たすものを数える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """ last += 1 last 1 ret = 0 ret 0 while first < last:
            ret += self.data[last]
            last -= last & -last
         first < last first last ret += self.data[last] ret self.data[last] self.data self data last last -= last & -last last last & -last last -last last while last < first:
            ret -= self.data[first]
            first -= first & -first
         last < first last first ret -= self.data[first] ret self.data[first] self.data self data first first -= first & -first first first & -first first -first first return ret ret self self first first last last def bisect(self, count):
        """
        Multiset 内の要素 elem のうち、count <= count_le(elem) を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        ret = 0
        k = self.k
        while k > 0:
            if ret + k <= self.n and self.data[ret + k] < count:
                count -= self.data[ret + k]
                ret += k
            k //= 2
        return ret

     bisect """
        Multiset 内の要素 elem のうち、count <= count_le(elem) を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """ ret = 0 ret 0 k = self.k k self.k self k while k > 0:
            if ret + k <= self.n and self.data[ret + k] < count:
                count -= self.data[ret + k]
                ret += k
            k //= 2
         k > 0 k 0 if ret + k <= self.n and self.data[ret + k] < count:
                count -= self.data[ret + k]
                ret += k
             ret + k <= self.n and self.data[ret + k] < count ret + k <= self.n ret + k ret k self.n self n self.data[ret + k] < count self.data[ret + k] self.data self data ret + k ret k count count -= self.data[ret + k] count self.data[ret + k] self.data self data ret + k ret k ret += k ret k k //= 2 k 2 return ret ret self self count count def lower_bound(self, value):
        """
        Multiset 内の要素 elem のうち、value <= elem を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        return self.bisect(self.count_le(value - 1) + 1)

     lower_bound """
        Multiset 内の要素 elem のうち、value <= elem を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """ return self.bisect(self.count_le(value - 1) + 1) self.bisect(self.count_le(value - 1) + 1) self.bisect self bisect self.count_le(value - 1) + 1 self.count_le(value - 1) self.count_le self count_le value - 1 value 1 1 self self value value def upper_bound(self, value):
        """
        Multiset 内の要素 elem のうち、value < elem を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        return self.bisect(self.count_le(value) + 1) upper_bound """
        Multiset 内の要素 elem のうち、value < elem を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """ return self.bisect(self.count_le(value) + 1) self.bisect(self.count_le(value) + 1) self.bisect self bisect self.count_le(value) + 1 self.count_le(value) self.count_le self count_le value 1 self self value value N, Q = map(int, input().split()) N map(int, input().split()) map int input().split() ().split () input split Q tuple(map(int, input().split())) for _ in range(N) for _ in range(N) _ range(N) range N for _ in range(N) tuple(map(int, input().split())) tuple map(int, input().split()) map int input().split() ().split () input split STXs = [tuple(map(int, input().split())) for _ in range(N)] STXs [tuple(map(int, input().split())) for _ in range(N)] int(input()) for _ in range(Q) for _ in range(Q) _ range(Q) range Q for _ in range(Q) int(input()) int input() input Ds = [int(input()) for _ in range(Q)] Ds [int(input()) for _ in range(Q)] i2X = sorted(map(lambda t: t[2], STXs)) i2X sorted(map(lambda t: t[2], STXs)) sorted map(lambda t: t[2], STXs) map lambda t: t[2] t[2] t 2 t STXs X:i for i, X in enumerate(i2X) for i, X in enumerate(i2X) i X enumerate(i2X) enumerate i2X for i, X in enumerate(i2X) X i X2i = {X:i for i, X in enumerate(i2X)} X2i {X:i for i, X in enumerate(i2X)} max_i = len(i2X) - 1 max_i len(i2X) - 1 len(i2X) len i2X 1 mbit = MultisetBIT(max_i) mbit MultisetBIT(max_i) MultisetBIT max_i events = [] events [] for S, T, X in STXs:
    events.append( ((S - X) << 32) + (X2i[X] << 1)     )
    events.append( ((T - X) << 32) + (X2i[X] << 1) + 1 ) S T X STXs events.append( ((S - X) << 32) + (X2i[X] << 1)     ) events.append events append ((S - X) << 32) + (X2i[X] << 1) (S - X) << 32 S - X S X 32 X2i[X] << 1 X2i[X] X2i X 1 events.append( ((T - X) << 32) + (X2i[X] << 1) + 1 ) events.append events append ((T - X) << 32) + (X2i[X] << 1) + 1 ((T - X) << 32) + (X2i[X] << 1) (T - X) << 32 T - X T X 32 X2i[X] << 1 X2i[X] X2i X 1 1 heapify(events) heapify events mask = (1 << 32) - 1 mask (1 << 32) - 1 1 << 32 1 32 1 for D in Ds:
    while events:
        if events[0] % 2 == 0:
            if (events[0] >> 32) <= D:
                e = heappop(events)
                mbit.add((e & mask) >> 1)
            else:
                break
        else:
            if (events[0] >> 32) <= D:
                e = heappop(events)
                mbit.pop((e & mask) >> 1)
            else:
                break
    # print([mbit.count(i, i) for i in range(max_i + 1)])
    ans_i = mbit.lower_bound(0)
    print(-1 if ans_i > max_i else i2X[ans_i]) D Ds while events:
        if events[0] % 2 == 0:
            if (events[0] >> 32) <= D:
                e = heappop(events)
                mbit.add((e & mask) >> 1)
            else:
                break
        else:
            if (events[0] >> 32) <= D:
                e = heappop(events)
                mbit.pop((e & mask) >> 1)
            else:
                break
    # print([mbit.count(i, i) for i in range(max_i + 1)])
     events if events[0] % 2 == 0:
            if (events[0] >> 32) <= D:
                e = heappop(events)
                mbit.add((e & mask) >> 1)
            else:
                break
        else:
            if (events[0] >> 32) <= D:
                e = heappop(events)
                mbit.pop((e & mask) >> 1)
            else:
                break
    # print([mbit.count(i, i) for i in range(max_i + 1)])
     events[0] % 2 == 0 events[0] % 2 events[0] events 0 2 0 if (events[0] >> 32) <= D:
                e = heappop(events)
                mbit.add((e & mask) >> 1)
            else:
                break
         (events[0] >> 32) <= D events[0] >> 32 events[0] events 0 32 D e = heappop(events) e heappop(events) heappop events mbit.add((e & mask) >> 1) mbit.add mbit add (e & mask) >> 1 e & mask e mask 1 break if (events[0] >> 32) <= D:
                e = heappop(events)
                mbit.pop((e & mask) >> 1)
            else:
                break
    # print([mbit.count(i, i) for i in range(max_i + 1)])
     (events[0] >> 32) <= D events[0] >> 32 events[0] events 0 32 D e = heappop(events) e heappop(events) heappop events mbit.pop((e & mask) >> 1) mbit.pop mbit pop (e & mask) >> 1 e & mask e mask 1 break ans_i = mbit.lower_bound(0) ans_i mbit.lower_bound(0) mbit.lower_bound mbit lower_bound 0 print(-1 if ans_i > max_i else i2X[ans_i]) print -1 if ans_i > max_i else i2X[ans_i] ans_i > max_i ans_i max_i -1 i2X[ans_i] i2X ans_i ans_i = mbit.lower_bound(0) mbit.lower_bound(0) ans_i STXs = [tuple(map(int, input().split())) for _ in range(N)] [tuple(map(int, input().split())) for _ in range(N)] STXs Q = map(int, input().split()) map(int, input().split()) Q e = heappop(events) heappop(events) e i2X = sorted(map(lambda t: t[2], STXs)) sorted(map(lambda t: t[2], STXs)) i2X events = [] [] events max_i = len(i2X) - 1 len(i2X) - 1 max_i class MultisetBIT:
    """
    最大値が小さい数について、その重複を許した集合を管理する。
    最大値 maxvalue を受け取り、[0, maxvalue] を管理する。
    counter は辞書型かリスト型で、counter[i] が i の個数を持つことを仮定する。
    counter が与えられなかった場合は、全て個数 0 で初期化される。
    基本的に閉区間で管理する。
    内部では受け取った数を +1 したものをindexとして持っているので注意。
    """

    __slots__ = ["n", "k", "data"]

    def __init__(self, maxvalue, counter = None):
        self.n = maxvalue + 1
        self.k = 1 << ((self.n + 1).bit_length() - 1)
        self.data = [0] * (self.n + 1)
        if counter is not None:
            self.update(counter)
        
    def update(self, counter):
        """
        counter を受け取って、それを反映させる。
        counter は辞書型かリスト型で、counter[i] が i の個数を持つことを仮定する。
        計算量は、n を要素の最大値として、 O(n) となる。
        """
        if isinstance(counter, list):
            self.data = [0] + counter + [0] * (self.n - len(counter))
        else:
            self.data = [0] * (self.n + 1)
            for k, v in counter.items():
                self.data[k + 1] = v
        for i in range(1, self.n + 1):
            if i + (i & -i) <= self.n:
                self.data[i + (i & -i)] += self.data[i]

    def add(self, value):
        """
        与えられた引数を Multiset に加える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        value += 1
        while value <= self.n:
            self.data[value] += 1
            value += value & -value

    def pop(self, value):
        """
        Multiset から与えられた引数を取り除く。
        与えられた引数が Multiset に入っているかのチェックは行わなず、
        単にその個数を 1 減らすだけなので注意。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        value += 1
        while value <= self.n:
            self.data[value] -= 1
            value += value & -value

    def count_le(self, value):
        """
        Multiset 内の要素 elem のうち、0 <= elem <= value を満たすものを数える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        value += 1
        ret = 0
        while value > 0:
            ret += self.data[value]
            value -= value & -value
        return ret

    def count(self, first, last):
        """
        Multiset 内の要素 elem のうち、first <= elem <= last を満たすものを数える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        last += 1
        ret = 0
        while first < last:
            ret += self.data[last]
            last -= last & -last
        while last < first:
            ret -= self.data[first]
            first -= first & -first
        return ret

    def bisect(self, count):
        """
        Multiset 内の要素 elem のうち、count <= count_le(elem) を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        ret = 0
        k = self.k
        while k > 0:
            if ret + k <= self.n and self.data[ret + k] < count:
                count -= self.data[ret + k]
                ret += k
            k //= 2
        return ret

    def lower_bound(self, value):
        """
        Multiset 内の要素 elem のうち、value <= elem を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        return self.bisect(self.count_le(value - 1) + 1)

    def upper_bound(self, value):
        """
        Multiset 内の要素 elem のうち、value < elem を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        return self.bisect(self.count_le(value) + 1) class MultisetBIT:
    """
    最大値が小さい数について、その重複を許した集合を管理する。
    最大値 maxvalue を受け取り、[0, maxvalue] を管理する。
    counter は辞書型かリスト型で、counter[i] が i の個数を持つことを仮定する。
    counter が与えられなかった場合は、全て個数 0 で初期化される。
    基本的に閉区間で管理する。
    内部では受け取った数を +1 したものをindexとして持っているので注意。
    """

    __slots__ = ["n", "k", "data"]

    def __init__(self, maxvalue, counter = None):
        self.n = maxvalue + 1
        self.k = 1 << ((self.n + 1).bit_length() - 1)
        self.data = [0] * (self.n + 1)
        if counter is not None:
            self.update(counter)
        
    def update(self, counter):
        """
        counter を受け取って、それを反映させる。
        counter は辞書型かリスト型で、counter[i] が i の個数を持つことを仮定する。
        計算量は、n を要素の最大値として、 O(n) となる。
        """
        if isinstance(counter, list):
            self.data = [0] + counter + [0] * (self.n - len(counter))
        else:
            self.data = [0] * (self.n + 1)
            for k, v in counter.items():
                self.data[k + 1] = v
        for i in range(1, self.n + 1):
            if i + (i & -i) <= self.n:
                self.data[i + (i & -i)] += self.data[i]

    def add(self, value):
        """
        与えられた引数を Multiset に加える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        value += 1
        while value <= self.n:
            self.data[value] += 1
            value += value & -value

    def pop(self, value):
        """
        Multiset から与えられた引数を取り除く。
        与えられた引数が Multiset に入っているかのチェックは行わなず、
        単にその個数を 1 減らすだけなので注意。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        value += 1
        while value <= self.n:
            self.data[value] -= 1
            value += value & -value

    def count_le(self, value):
        """
        Multiset 内の要素 elem のうち、0 <= elem <= value を満たすものを数える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        value += 1
        ret = 0
        while value > 0:
            ret += self.data[value]
            value -= value & -value
        return ret

    def count(self, first, last):
        """
        Multiset 内の要素 elem のうち、first <= elem <= last を満たすものを数える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        last += 1
        ret = 0
        while first < last:
            ret += self.data[last]
            last -= last & -last
        while last < first:
            ret -= self.data[first]
            first -= first & -first
        return ret

    def bisect(self, count):
        """
        Multiset 内の要素 elem のうち、count <= count_le(elem) を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        ret = 0
        k = self.k
        while k > 0:
            if ret + k <= self.n and self.data[ret + k] < count:
                count -= self.data[ret + k]
                ret += k
            k //= 2
        return ret

    def lower_bound(self, value):
        """
        Multiset 内の要素 elem のうち、value <= elem を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        return self.bisect(self.count_le(value - 1) + 1)

    def upper_bound(self, value):
        """
        Multiset 内の要素 elem のうち、value < elem を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        return self.bisect(self.count_le(value) + 1) MultisetBIT mbit = MultisetBIT(max_i) MultisetBIT(max_i) mbit e = heappop(events) heappop(events) e Ds = [int(input()) for _ in range(Q)] [int(input()) for _ in range(Q)] Ds X2i = {X:i for i, X in enumerate(i2X)} {X:i for i, X in enumerate(i2X)} X2i mask = (1 << 32) - 1 (1 << 32) - 1 mask N, Q = map(int, input().split()) map(int, input().split()) N
from heapq import *

class MultisetBIT:
    """
    最大値が小さい数について、その重複を許した集合を管理する。
    最大値 maxvalue を受け取り、[0, maxvalue] を管理する。
    counter は辞書型かリスト型で、counter[i] が i の個数を持つことを仮定する。
    counter が与えられなかった場合は、全て個数 0 で初期化される。
    基本的に閉区間で管理する。
    内部では受け取った数を +1 したものをindexとして持っているので注意。
    """

    __slots__ = ["n", "k", "data"]

    def __init__(self, maxvalue, counter = None):
        self.n = maxvalue + 1
        self.k = 1 << ((self.n + 1).bit_length() - 1)
        self.data = [0] * (self.n + 1)
        if counter is not None:
            self.update(counter)
        
    def update(self, counter):
        """
        counter を受け取って、それを反映させる。
        counter は辞書型かリスト型で、counter[i] が i の個数を持つことを仮定する。
        計算量は、n を要素の最大値として、 O(n) となる。
        """
        if isinstance(counter, list):
            self.data = [0] + counter + [0] * (self.n - len(counter))
        else:
            self.data = [0] * (self.n + 1)
            for k, v in counter.items():
                self.data[k + 1] = v
        for i in range(1, self.n + 1):
            if i + (i & -i) <= self.n:
                self.data[i + (i & -i)] += self.data[i]

    def add(self, value):
        """
        与えられた引数を Multiset に加える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        value += 1
        while value <= self.n:
            self.data[value] += 1
            value += value & -value

    def pop(self, value):
        """
        Multiset から与えられた引数を取り除く。
        与えられた引数が Multiset に入っているかのチェックは行わなず、
        単にその個数を 1 減らすだけなので注意。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        value += 1
        while value <= self.n:
            self.data[value] -= 1
            value += value & -value

    def count_le(self, value):
        """
        Multiset 内の要素 elem のうち、0 <= elem <= value を満たすものを数える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        value += 1
        ret = 0
        while value > 0:
            ret += self.data[value]
            value -= value & -value
        return ret

    def count(self, first, last):
        """
        Multiset 内の要素 elem のうち、first <= elem <= last を満たすものを数える。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        last += 1
        ret = 0
        while first < last:
            ret += self.data[last]
            last -= last & -last
        while last < first:
            ret -= self.data[first]
            first -= first & -first
        return ret

    def bisect(self, count):
        """
        Multiset 内の要素 elem のうち、count <= count_le(elem) を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        ret = 0
        k = self.k
        while k > 0:
            if ret + k <= self.n and self.data[ret + k] < count:
                count -= self.data[ret + k]
                ret += k
            k //= 2
        return ret

    def lower_bound(self, value):
        """
        Multiset 内の要素 elem のうち、value <= elem を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        return self.bisect(self.count_le(value - 1) + 1)

    def upper_bound(self, value):
        """
        Multiset 内の要素 elem のうち、value < elem を満たす最小のelemを返す。
        計算量は、n を要素の最大値として、 O(log n) となる。
        """
        return self.bisect(self.count_le(value) + 1)


N, Q = map(int, input().split())
STXs = [tuple(map(int, input().split())) for _ in range(N)]
Ds = [int(input()) for _ in range(Q)]

i2X = sorted(map(lambda t: t[2], STXs))
X2i = {X:i for i, X in enumerate(i2X)}
max_i = len(i2X) - 1
mbit = MultisetBIT(max_i)

events = []
for S, T, X in STXs:
    events.append( ((S - X) << 32) + (X2i[X] << 1)     )
    events.append( ((T - X) << 32) + (X2i[X] << 1) + 1 )
heapify(events)

mask = (1 << 32) - 1
for D in Ds:
    while events:
        if events[0] % 2 == 0:
            if (events[0] >> 32) <= D:
                e = heappop(events)
                mbit.add((e & mask) >> 1)
            else:
                break
        else:
            if (events[0] >> 32) <= D:
                e = heappop(events)
                mbit.pop((e & mask) >> 1)
            else:
                break
    # print([mbit.count(i, i) for i in range(max_i + 1)])
    ans_i = mbit.lower_bound(0)
    print(-1 if ans_i > max_i else i2X[ans_i])