Problem:
Score : 500 points

Problem Statement

There is an infinitely long street that runs west to east, which we consider as a number line.

There are N roadworks scheduled on this street.
The i-th roadwork blocks the point at coordinate X_i from time S_i - 0.5 to time T_i - 0.5.

Q people are standing at coordinate 0. The i-th person will start the coordinate 0 at time D_i, continue to walk with speed 1 in the positive direction and stop walking when reaching a blocked point.

Find the distance each of the Q people will walk.

Constraints

All values in input are integers.

1 \leq N, Q \leq 2 \times 10^5

0 \leq S_i < T_i \leq 10^9

1 \leq X_i \leq 10^9

0 \leq D_1 < D_2 < ... < D_Q \leq 10^9

If i \neq j and X_i = X_j, the intervals [S_i, T_i) and [S_j, T_j) do not overlap.

Input

Input is given from Standard Input in the following format:

N Q
S_1 T_1 X_1
:
S_N T_N X_N
D_1
:
D_Q

Output

Print Q lines. The i-th line should contain the distance the i-th person will walk or -1 if that person walks forever.

Sample Input 1

4 6
1 3 2
7 13 10
18 20 13
3 4 2
0
1
2
3
5
8

Sample Output 1

2
2
10
-1
13
-1

The first person starts coordinate 0 at time 0 and stops walking at coordinate 2 when reaching a point blocked by the first roadwork at time 2.

The second person starts coordinate 0 at time 1 and reaches coordinate 2 at time 3. The first roadwork has ended, but the fourth roadwork has begun, so this person also stops walking at coordinate 2.

The fourth and sixth persons encounter no roadworks while walking, so they walk forever. The output for these cases is -1.

Solution in Ruby (2.3.3) (judge verdict: Wrong Answer)

# coding: utf-8
# class Heap
#   def initialize(n)
#     @nodes = Array.new(n)
#     @index = Hash.new
#     @size = 0
#   end

#   def push(current_value)
#     # 存在する値ならpushしないでreturn (入力を信じるのであれば、必要無い確認)
#     return if @index[current_value]

#     # 今から値を入れるのは、@size番目
#     # 0番目...@size-1までの@size個の要素が元々あるから。
#     current_index = @size
#     @size += 1

#     # 末端に要素を追加した時、その値が小さければ、どんどん親ノードへ上がっていく。
#     while current_index > 0 do
#       # 親ノードのindexは (i-1) >> 1 で計算できる
#       # 親より自分が大きいなら、入れ替え不要でbreak
#       parent_index = (current_index - 1)>>1
#       parent_value = @nodes[parent_index]
#       break if parent_value <= current_value

#       # 親より自分が小さいので、入れ替え操作を行う。
#       # 次のloopのために、current_indexを入れ替えた親のindexに直す
#       @index[parent_value] = current_index
#       @nodes[current_index] = parent_value
#       current_index = parent_index
#     end
#     @index[current_value] = current_index
#     @nodes[current_index] = current_value
#   end

#   def delete(delete_target_value)
#     # 存在しない値ならdeleteできないのでreturn (入力を信じるのであれば、必要無い確認)
#     return unless @index[delete_target_value]

#     # 1.削除するのでsizeが減る
#     # 2.末端は他のnodeと入れ替わるので、末端を削除する
#     # 3.削除されるnodeのindexも削除する
#     @size -= 1
#     current_node_value = @nodes[@size]
#     @nodes[@size] = nil
#     current_node_index = @index.delete(delete_target_value) # delteの返り値は削除した値

#     # 削除したのがそもそも末端だったら、終了。
#     return if current_node_index == @size

#     # 削除したのが末端じゃないなら、末端にある値を削除した場所に持ってくる
#     @nodes[current_node_index] = current_node_value
#     @index[current_node_value] = current_node_index

#     # 大小関係が正されるように、要素を入れ替える

#     # delete_target = d, last_node = l
#     # d > l のとき
#     # d_child > d > l で子は問題ないけど
#     # d_parent < l < d, l < d_parent < d　のどっちかわからなくて、後者だと問題なのでチェックする
#     # この問題が解決するまで、親方向にチェック & 入れ替えを続ける
#     if delete_target_value > current_node_value
#       parent_node_index = (current_node_index - 1) >> 1
#       while @nodes[parent_node_index]&.> @nodes[current_node_index]
#         change(parent_node_index, current_node_index)
#         current_node_index = parent_node_index
#         current_node_value = @nodes[current_node_index]
#         parent_node_index = (current_node_index - 1) >> 1
#       end

#     # d < l のとき
#     # d_parent < d < d で親は問題ないけど
#     # d_child > l > d, l > d_child > d　のどっちかわからなくて、後者だと問題なのでチェックする
#     # この時、(子1,子2,親) の内最小の値を新しい親にする事。
#     # この問題が解決するまで、子方向にチェック & 入れ替えを続ける
#     else
#       while
#         # 子ノードのindexを取得、小さい方(左)のindexがsize以上だったら、そこに要素は無いはずなのでbreak
#         child_node_index_r = (current_node_index << 1) + 2
#         child_node_index_l = child_node_index_r - 1
#         break unless child_node_index_l < @size

#         # 子ノードの内小さい方の値と、current_nodeを入れ替えるので、計算。
#         # 右はnilの可能性があるので、右側のvalueからsafe navigation operatorを使う
#         # 今のノードの値が、小さい方の子の値よりも小さかったそこでストップ
#         child_node_value_l = @nodes[child_node_index_l]
#         child_node_value_r = @nodes[child_node_index_r]
#         if child_node_value_r&.<child_node_value_l
#           min_child_value = child_node_value_r
#           min_child_index = child_node_index_r
#         else
#           min_child_value = child_node_value_l
#           min_child_index = child_node_index_l
#         end
#         break if min_child_value > current_node_value

#         # 入れ替えた後、現在のindexを入れ替え先のindexにして、次のloopへ行く
#         change(current_node_index, min_child_index)
#         current_node_index = min_child_index
#       end
#     end
#   end

#   def top
#     @size == 0 ? -1 : @nodes[0]
#   end

class Heap
  attr_accessor :a, :h
  def initialize
    @a = [nil]
    @h = {}
  end

  def swap(i, j)
    @a[i], @a[j] = @a[j], @a[i]
    @h[@a[i]], @h[@a[j]] = i, j
  end

  def b_up(i)
    p = i / 2
    return if i <= 1 || @a[p] <= @a[i]
    swap(i, p)
    b_up(p)
  end

  def add(v)
    return if @h[v]
    @a << v
    @h[v] = @a.size - 1
    b_up(@a.size - 1)
  end

  def b_dn(i)
    c = i * 2
    return if c >= @a.size
    c += 1 if c != @a.size - 1 && @a[c] > @a[c + 1]
    return if @a[i] <= @a[c]
    swap(i, c)
    b_dn(c)
  end

  def del(v)
    return unless @h[v]
    swap(@h[v], -1)
    ret = @a.pop
    @h[ret] = nil
    b_dn(1)
    ret
  end

  def top
    @a[1] || -1
  end
end


#   # デバッグ用
#   def check_valid
#     queue = [0]
#     while queue.size > 0
#       i = queue.shift
#       child_1 = (i + 1) << 1
#       child_2 = child_1 - 1
#       if child_2 < @size
#         if child_1 < @size
#           queue << child_1
#           raise if @nodes[child_1] < @nodes[i]
#         end
#         queue << child_2
#         raise if @nodes[child_2] < @nodes[i]
#       end
#     end
#   end

#   private

#   def change(index_i, index_j)
#     @nodes[index_i], @nodes[index_j] = @nodes[index_j], @nodes[index_i]
#     @index[@nodes[index_i]] = index_i
#     @index[@nodes[index_j]] = index_j
#   end
# end

nn, qq = gets.split.map(&:to_i)
events = []
temp = []
1.step(nn, 1) do |_i|
  temp = gets.split.map(&:to_i)
  next if temp[1] - temp[2] <= 0
  x = temp[0] - temp[2]
  x = x > 0 ? x : 0

  events.push([temp[1] - temp[2], 1, temp[2]])
  events.push([temp[0] - temp[2], 0, temp[2]])
end
1.step(qq, 1) do |i|
  events.push([gets.to_i, 2, i])
end
events.sort_by!(&:first)

ss = Heap.new
ans = []

events.each do |event|
  if event[1] == 0
    ss.add(event[2])
  elsif event[1] == 1
    ss.del(event[2])
  else
    ans[event[2]] = ss.top
  end
end

puts ans[1..-1]