import sys
input = sys.stdin.readline
from bisect import bisect_left
inf = float('inf')

# 区間更新　一点取得　1-indexed
class SegmentTree:
    def __init__(self, N):
        tmp = 1
        while tmp < N:
            tmp <<= 1
        # self.N : 完全二分木の葉の数(N以上の最小の2べき)
        self.N = tmp
        # 2*self.N - 1 : 完全二分木のノード数
        # 1-indexedで管理するので余分に１つ設ける
        self.Data = [inf for _ in range(2*self.N)]
    
    # [l, r) (0-indexed)
    def update(self, l, r, x):
        # インデックスを補正
        L = l + self.N
        R = r + self.N
        while L < R:
            # 右側なら右側を更新 右上に行く
            # 左側なら更新しない　上に行く
            if L & 1:
                self.Data[L] = min([self.Data[L], x])
                L += 1
            # 右側なら左側を更新　上に行く
            # 左側なら更新しない 上に行く
            if R & 1:
                R -= 1
                self.Data[R] = min([self.Data[R], x])
            L >>= 1; R >>= 1
    
    # k (0-indexed)
    def value(self, k):
        # インデックスを補正
        k += self.N
        res = self.Data[k]
        while k != 1:
            k >>= 1
            res = min(res, self.Data[k])
        return res


N, Q = map(int,input().split())
STX = [list(map(int,input().split())) for _ in range(N)]
D = [int(input()) for _ in range(Q)]

st = SegmentTree(Q)
for S, T, X in STX:
    l = bisect_left(D, S-X)
    r = bisect_left(D, T-X)
    st.update(l, r, X)

for k in range(Q):
    ans = st.value(k)
    if ans == inf:
        ans = -1
    print(ans) import sys sys input = sys.stdin.readline input sys.stdin.readline sys.stdin sys stdin readline from bisect import bisect_left inf = float('inf') inf float('inf') float 'inf' class SegmentTree:
    def __init__(self, N):
        tmp = 1
        while tmp < N:
            tmp <<= 1
        # self.N : 完全二分木の葉の数(N以上の最小の2べき)
        self.N = tmp
        # 2*self.N - 1 : 完全二分木のノード数
        # 1-indexedで管理するので余分に１つ設ける
        self.Data = [inf for _ in range(2*self.N)]
    
    # [l, r) (0-indexed)
    def update(self, l, r, x):
        # インデックスを補正
        L = l + self.N
        R = r + self.N
        while L < R:
            # 右側なら右側を更新 右上に行く
            # 左側なら更新しない　上に行く
            if L & 1:
                self.Data[L] = min([self.Data[L], x])
                L += 1
            # 右側なら左側を更新　上に行く
            # 左側なら更新しない 上に行く
            if R & 1:
                R -= 1
                self.Data[R] = min([self.Data[R], x])
            L >>= 1; R >>= 1
    
    # k (0-indexed)
    def value(self, k):
        # インデックスを補正
        k += self.N
        res = self.Data[k]
        while k != 1:
            k >>= 1
            res = min(res, self.Data[k])
        return res SegmentTree def __init__(self, N):
        tmp = 1
        while tmp < N:
            tmp <<= 1
        # self.N : 完全二分木の葉の数(N以上の最小の2べき)
        self.N = tmp
        # 2*self.N - 1 : 完全二分木のノード数
        # 1-indexedで管理するので余分に１つ設ける
        self.Data = [inf for _ in range(2*self.N)]
    
    # [l, r) (0-indexed)
     __init__ tmp = 1 tmp 1 while tmp < N:
            tmp <<= 1
        # self.N : 完全二分木の葉の数(N以上の最小の2べき)
         tmp < N tmp N tmp <<= 1 tmp 1 self.N = tmp self.N self N tmp inf for _ in range(2*self.N) for _ in range(2*self.N) _ range(2*self.N) range 2*self.N 2 self.N self N for _ in range(2*self.N) inf self.Data = [inf for _ in range(2*self.N)] self.Data self Data [inf for _ in range(2*self.N)] self self N N def update(self, l, r, x):
        # インデックスを補正
        L = l + self.N
        R = r + self.N
        while L < R:
            # 右側なら右側を更新 右上に行く
            # 左側なら更新しない　上に行く
            if L & 1:
                self.Data[L] = min([self.Data[L], x])
                L += 1
            # 右側なら左側を更新　上に行く
            # 左側なら更新しない 上に行く
            if R & 1:
                R -= 1
                self.Data[R] = min([self.Data[R], x])
            L >>= 1; R >>= 1
    
    # k (0-indexed)
     update L = l + self.N L l + self.N l self.N self N R = r + self.N R r + self.N r self.N self N while L < R:
            # 右側なら右側を更新 右上に行く
            # 左側なら更新しない　上に行く
            if L & 1:
                self.Data[L] = min([self.Data[L], x])
                L += 1
            # 右側なら左側を更新　上に行く
            # 左側なら更新しない 上に行く
            if R & 1:
                R -= 1
                self.Data[R] = min([self.Data[R], x])
            L >>= 1; R >>= 1
    
    # k (0-indexed)
     L < R L R if L & 1:
                self.Data[L] = min([self.Data[L], x])
                L += 1
            # 右側なら左側を更新　上に行く
            # 左側なら更新しない 上に行く
             L & 1 L 1 self.Data[L] = min([self.Data[L], x]) self.Data[L] self.Data self Data L min([self.Data[L], x]) min [self.Data[L], x] self.Data[L] self.Data self Data L x L += 1 L 1 if R & 1:
                R -= 1
                self.Data[R] = min([self.Data[R], x])
             R & 1 R 1 R -= 1 R 1 self.Data[R] = min([self.Data[R], x]) self.Data[R] self.Data self Data R min([self.Data[R], x]) min [self.Data[R], x] self.Data[R] self.Data self Data R x L >>= 1 L 1 R >>= 1 R 1 self self l l r r x x def value(self, k):
        # インデックスを補正
        k += self.N
        res = self.Data[k]
        while k != 1:
            k >>= 1
            res = min(res, self.Data[k])
        return res value k += self.N k self.N self N res = self.Data[k] res self.Data[k] self.Data self Data k while k != 1:
            k >>= 1
            res = min(res, self.Data[k])
         k != 1 k 1 k >>= 1 k 1 res = min(res, self.Data[k]) res min(res, self.Data[k]) min res self.Data[k] self.Data self Data k return res res self self k k N, Q = map(int,input().split()) N map(int,input().split()) map int input().split() ().split () input split Q list(map(int,input().split())) for _ in range(N) for _ in range(N) _ range(N) range N for _ in range(N) list(map(int,input().split())) list map(int,input().split()) map int input().split() ().split () input split STX = [list(map(int,input().split())) for _ in range(N)] STX [list(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 D = [int(input()) for _ in range(Q)] D [int(input()) for _ in range(Q)] st = SegmentTree(Q) st SegmentTree(Q) SegmentTree Q for S, T, X in STX:
    l = bisect_left(D, S-X)
    r = bisect_left(D, T-X)
    st.update(l, r, X) S T X STX l = bisect_left(D, S-X) l bisect_left(D, S-X) bisect_left D S-X S X r = bisect_left(D, T-X) r bisect_left(D, T-X) bisect_left D T-X T X st.update(l, r, X) st.update st update l r X for k in range(Q):
    ans = st.value(k)
    if ans == inf:
        ans = -1
    print(ans) k range(Q) range Q ans = st.value(k) ans st.value(k) st.value st value k if ans == inf:
        ans = -1
     ans == inf ans inf ans = -1 ans -1 print(ans) print ans Q = map(int,input().split()) map(int,input().split()) Q ans = -1 -1 ans inf = float('inf') float('inf') inf st = SegmentTree(Q) SegmentTree(Q) st l = bisect_left(D, S-X) bisect_left(D, S-X) l N, Q = map(int,input().split()) map(int,input().split()) N class SegmentTree:
    def __init__(self, N):
        tmp = 1
        while tmp < N:
            tmp <<= 1
        # self.N : 完全二分木の葉の数(N以上の最小の2べき)
        self.N = tmp
        # 2*self.N - 1 : 完全二分木のノード数
        # 1-indexedで管理するので余分に１つ設ける
        self.Data = [inf for _ in range(2*self.N)]
    
    # [l, r) (0-indexed)
    def update(self, l, r, x):
        # インデックスを補正
        L = l + self.N
        R = r + self.N
        while L < R:
            # 右側なら右側を更新 右上に行く
            # 左側なら更新しない　上に行く
            if L & 1:
                self.Data[L] = min([self.Data[L], x])
                L += 1
            # 右側なら左側を更新　上に行く
            # 左側なら更新しない 上に行く
            if R & 1:
                R -= 1
                self.Data[R] = min([self.Data[R], x])
            L >>= 1; R >>= 1
    
    # k (0-indexed)
    def value(self, k):
        # インデックスを補正
        k += self.N
        res = self.Data[k]
        while k != 1:
            k >>= 1
            res = min(res, self.Data[k])
        return res class SegmentTree:
    def __init__(self, N):
        tmp = 1
        while tmp < N:
            tmp <<= 1
        # self.N : 完全二分木の葉の数(N以上の最小の2べき)
        self.N = tmp
        # 2*self.N - 1 : 完全二分木のノード数
        # 1-indexedで管理するので余分に１つ設ける
        self.Data = [inf for _ in range(2*self.N)]
    
    # [l, r) (0-indexed)
    def update(self, l, r, x):
        # インデックスを補正
        L = l + self.N
        R = r + self.N
        while L < R:
            # 右側なら右側を更新 右上に行く
            # 左側なら更新しない　上に行く
            if L & 1:
                self.Data[L] = min([self.Data[L], x])
                L += 1
            # 右側なら左側を更新　上に行く
            # 左側なら更新しない 上に行く
            if R & 1:
                R -= 1
                self.Data[R] = min([self.Data[R], x])
            L >>= 1; R >>= 1
    
    # k (0-indexed)
    def value(self, k):
        # インデックスを補正
        k += self.N
        res = self.Data[k]
        while k != 1:
            k >>= 1
            res = min(res, self.Data[k])
        return res SegmentTree r = bisect_left(D, T-X) bisect_left(D, T-X) r D = [int(input()) for _ in range(Q)] [int(input()) for _ in range(Q)] D ans = st.value(k) st.value(k) ans STX = [list(map(int,input().split())) for _ in range(N)] [list(map(int,input().split())) for _ in range(N)] STX input = sys.stdin.readline sys.stdin.readline input
import sys
input = sys.stdin.readline
from bisect import bisect_left
inf = float('inf')

# 区間更新　一点取得　1-indexed
class SegmentTree:
    def __init__(self, N):
        tmp = 1
        while tmp < N:
            tmp <<= 1
        # self.N : 完全二分木の葉の数(N以上の最小の2べき)
        self.N = tmp
        # 2*self.N - 1 : 完全二分木のノード数
        # 1-indexedで管理するので余分に１つ設ける
        self.Data = [inf for _ in range(2*self.N)]
    
    # [l, r) (0-indexed)
    def update(self, l, r, x):
        # インデックスを補正
        L = l + self.N
        R = r + self.N
        while L < R:
            # 右側なら右側を更新 右上に行く
            # 左側なら更新しない　上に行く
            if L & 1:
                self.Data[L] = min([self.Data[L], x])
                L += 1
            # 右側なら左側を更新　上に行く
            # 左側なら更新しない 上に行く
            if R & 1:
                R -= 1
                self.Data[R] = min([self.Data[R], x])
            L >>= 1; R >>= 1
    
    # k (0-indexed)
    def value(self, k):
        # インデックスを補正
        k += self.N
        res = self.Data[k]
        while k != 1:
            k >>= 1
            res = min(res, self.Data[k])
        return res


N, Q = map(int,input().split())
STX = [list(map(int,input().split())) for _ in range(N)]
D = [int(input()) for _ in range(Q)]

st = SegmentTree(Q)
for S, T, X in STX:
    l = bisect_left(D, S-X)
    r = bisect_left(D, T-X)
    st.update(l, r, X)

for k in range(Q):
    ans = st.value(k)
    if ans == inf:
        ans = -1
    print(ans)