class Heap
  def initialize(n)
    @nodes = Array.new(n)
    @index = Hash.new
    @size = 0
  end

  def push(x)
    current_index = @size
    @size += 1
    while current_index > 0 do
      #親ノードのindex
      parent_index = (current_index - 1)>>1
      parent_value = @nodes[parent_index]
      # 親より自分が大きいなら、入れ替え不要
      break if parent_value <= x
      # 親より自分が小さい時、入れ替え操作を行う
      @index[parent_value] = current_index
      @nodes[current_index] = parent_value
      current_index = parent_index
    end
    @index[x] = current_index
    @nodes[current_index] = x
  end

  def delete(x)
    # 削除したい値のあるindexへ、最新nodeの値を入れる
    current_node_index = @index.delete(x)
    @size -= 1
    current_node_value = @nodes[@size]
    @nodes[@size] = nil
    return if current_node_index == @size
    @nodes[current_node_index] = current_node_value
    @index[current_node_value] = current_node_index

    # 変数名を整理したい
    # 大小関係が正されるように、要素を入れ替える
    if x > current_node_value
      # 末端のほうが削除する値よりも小さかった場合は、親ノードへ入れ替えを確認していく
      parent_node_index = (current_node_index - 1) >> 1
      while @nodes[parent_node_index]&.> @nodes[current_node_index] do
        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
    else
      # 末端のほうが大きかった場合は、子ノードへ入れ替えを確認していく
      child_node_index_r = (current_node_index + 1) << 1
      child_node_index_l = child_node_index_r - 1
      return unless child_node_index_l < @size
      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
      while (min_child_value < current_node_value) do
        change(current_node_index, min_child_index)

        current_node_index = min_child_index
        child_node_index_r = (current_node_index + 1) << 1
        child_node_index_l = child_node_index_r - 1
        return unless child_node_index_l < @size
        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
      end
    end
  end

  def top
    @size == 0 ? -1 : @nodes[0]
  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 = []

t = 0
nn.times do
  temp = gets.split.map(&:to_i)
  next if (t = temp[1] - temp[2]) <= 0

  events.push(
    ((temp[0] - temp[2]) << 32) +
    (2 << 30) +
    temp[2]
  )
  events.push(
    (t << 32) +

    temp[2]
  )
end

1.step(qq, 1) do |i|
  events.push(
    (gets.to_i << 32) +
    (3 << 30) +
    i
  )
end

# '30bit-2bit-30bit'
#  ソートするための区間 - タイプ - indexなどの情報
mask_point = ((1 << 30) - 1)
mask_index = ((1 << 18) - 1)

events.sort!

ss = Heap.new(nn)
ans = []

events.each do |event|
  event[30] == 1 ?
    ans[(event & mask_index)] = ss.top :
    event[31] == 1 ?
      ss.push(event & mask_point) :
      ss.delete(event & mask_point)
end

puts ans[1..-1]
