class PriorityQueue
  attr_reader :size

  def initialize(order: :asc)
    @size = 0
    @nodes = []
  end

  def empty?
    @size.zero?
  end

  def push(node)
    index = size
    @size += 1

    while index > 0
      parent = (index - 1) / 2

      break if (@nodes[parent] <=> node) <= 0

      @nodes[index] = @nodes[parent]
      index = parent
    end

    @nodes[index] = node
  end

  alias_method :<<, :push

  def pop
    node = @nodes.first
    root = @nodes[size - 1]
    @size -= 1
    index = 0

    while index * 2 + 1 < @size
      left = 2 * index + 1
      right = left + 1

      if right < size && (@nodes[right] <=> @nodes[left]) <= 0
        left = right
      end

      break if (@nodes[left] <=> root) > 0

      @nodes[index] = @nodes[left]
      index = left
    end

    @nodes[index] = root
    node
  end

  def top
    @nodes.first
  end
end

N, Q = gets.split.map(&:to_i)
W = N.times.map { gets.split.map(&:to_i) }
D = Q.times.map { gets.to_i }

D << Float::INFINITY

start_work = Hash.new { |h, k| h[k] = [] }
finish_work = Hash.new { |h, k| h[k] = [] }

W.each_with_index do |(s, t, x), work_id|
  start = s - x
  finish = t - x - 1

  left = D.bsearch_index { |d| d >= start }
  right = D.bsearch_index { |d| d >= finish }

  if finish < D[right]
    right -= 1
  end

  start_work[left] << [x, work_id]
  finish_work[right + 1] << work_id
end

Node = Struct.new(:x, :work_id) do
  def <=>(node)
    x <=> node.x
  end
end

pque = PriorityQueue.new

ans = Array.new(Q, Float::INFINITY)
finished = Hash.new(false)

Q.times do |i|
  start_work[i].each do |x, work_id|
    pque.push(Node.new(x, work_id))
  end

  finish_work[i].each do |work_id|
    finished[work_id] = true
  end

  while pque.size > 0 && finished[pque.top.work_id]
    pque.pop
  end

  if pque.empty?
    ans[i] = -1
  else
    ans[i] = pque.top.x
  end
end

puts ans
