output_description: Print Q lines. The i-th line should contain the distance the i-th person will
  walk or -1 if that person walks forever.
  
  * * *
input_description: 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
attempt: import random
  
  N, Q = list(map(int, input().split()))
  
  STX = [list(map(int, input().split())) for _ in range(N)]
  STX.sort(key=lambda x: x[2])
  
  
  D = [int(input()) for i in range(Q)]
  D_binary = [(d, i) for i, d in enumerate(D)]
  
  
  # binary tree
  class Node(object):
      """Tree node: left and right child + data which can be any object"""
  
      def __init__(self, data):
          """Node constructor
          @param data node data object
          """
          self.left = None
          self.right = None
          self.data = data
  
      def insert(self, data):
          """Insert new node with data
          @param data node data object to insert
          """
          if self.data is not None:
              if data < self.data:
                  if self.left is None:
                      self.left = Node(data)
                  else:
                      self.left.insert(data)
              elif data > self.data:
                  if self.right is None:
                      self.right = Node(data)
                  else:
                      self.right.insert(data)
          else:
              self.data = data
  
      def lookup(self, data, parent=None):
          """Lookup node containing data
          @param data node data object to look up
          @param parent node's parent
          @returns node and node's parent if found or None, None
          """
          if data < self.data:
              if self.left is None:
                  return None, None
              return self.left.lookup(data, self)
          elif data > self.data:
              if self.right is None:
                  return None, None
              return self.right.lookup(data, self)
          else:
              return self, parent
  
      def lookup_near(self, data, parent=None, route=None):
          """Lookup node containing data"""
          # def f():
          #     return min(r for r in route if r> data)
          if not route:
              route = []
          route.append(self.data)
          if data < self.data:
              if self.left is None:
                  # print(route,self.right)
                  return min(r for r in route if r > data)
              return self.left.lookup_near(data, self, route)
          elif data > self.data:
              if self.right is None:
                  # print(route,self.left)
                  return min(r for r in route if r > data)
              return self.right.lookup_near(data, self, route)
          else:
              return self.data
  
      def delete(self, data):
          """Delete node containing data
          @param data node's content to delete
          """
          # get node containing data
          node, parent = self.lookup(data)
          if node is not None:
              children_count = node.children_count()
              if children_count == 0:
                  # if node has no children, just remove it
                  if parent:
                      if parent.left is node:
                          parent.left = None
                      else:
                          parent.right = None
                  else:
                      self.data = None
              elif children_count == 1:
                  # if node has 1 child
                  # replace node by its child
                  if node.left:
                      n = node.left
                  else:
                      n = node.right
                  if parent:
                      if parent.left is node:
                          parent.left = n
                      else:
                          parent.right = n
                  else:
                      self.left = n.left
                      self.right = n.right
                      self.data = n.data
              else:
                  # if node has 2 children
                  # find its successor
                  parent = node
                  successor = node.right
                  while successor.left:
                      parent = successor
                      successor = successor.left
                  # replace node data by its successor data
                  node.data = successor.data
                  # fix successor's parent node child
                  if parent.left == successor:
                      parent.left = successor.right
                  else:
                      parent.right = successor.right
  
      def compare_trees(self, node):
          """Compare 2 trees
          @param node tree to compare
          @returns True if the tree passed is identical to this tree
          """
          if node is None:
              return False
          if self.data != node.data:
              return False
          res = True
          if self.left is None:
              if node.left:
                  return False
          else:
              res = self.left.compare_trees(node.left)
          if res is False:
              return False
          if self.right is None:
              if node.right:
                  return False
          else:
              res = self.right.compare_trees(node.right)
          return res
  
      def print_tree(self):
          """Print tree content inorder"""
          if self.left:
              self.left.print_tree()
          print(self.data, end=" ")
          if self.right:
              self.right.print_tree()
  
      def tree_data(self):
          """Generator to get the tree nodes data"""
          # we use a stack to traverse the tree in a non-recursive way
          stack = []
          node = self
          while stack or node:
              if node:
                  stack.append(node)
                  node = node.left
              else:
                  # we are returning so we pop the node and we yield it
                  node = stack.pop()
                  yield node.data
                  node = node.right
  
      def children_count(self):
          """Return the number of children
          @returns number of children: 0, 1, 2
          """
          cnt = 0
          if self.left:
              cnt += 1
          if self.right:
              cnt += 1
          return cnt
  
  
  D_shuffle = list(D)
  random.shuffle(D_shuffle)
  bt = Node(None)
  for d in D_shuffle:
      bt.insert(d)
  
  # print(D_shuffle)
  from collections import defaultdict
  
  ans = defaultdict(lambda: -1)
  for s, t, x in STX:
      sx = s - x
      tx = t - x
      while True:
          v = bt.lookup_near(sx)
          if v < tx:
              bt.delete(v)
              ans[v] = x
          else:
              break
  for d in D:
      print(ans[d])
  
problem_description: 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.
samples: [{"input": "4 6\n    1 3 2\n    7 13 10\n    18 20 13\n    3 4 2\n    0\n    1\n    2\n    3\n    5\n    8", "output": "2\n    2\n    10\n    -1\n    13\n    -1\n    \n\nThe first person starts coordinate 0 at time 0 and stops walking at coordinate\n2 when reaching a point blocked by the first roadwork at time 2.\n\nThe second person starts coordinate 0 at time 1 and reaches coordinate 2 at\ntime 3. The first roadwork has ended, but the fourth roadwork has begun, so\nthis person also stops walking at coordinate 2.\n\nThe fourth and sixth persons encounter no roadworks while walking, so they\nwalk forever. The output for these cases is -1."}]