output_description: For each find operation, print the value.
input_description: n q
      query1
      query2
      :
      queryq
      
  
  In the first line, n (the number of elements in A) and q (the number of
  queries) are given. Then, _i_ th query queryi is given in the following
  format:
  
      
      
      0 s t x 
      
  
  or
  
      
      
      1 i
      
  
  The first digit represents the type of the query. '0' denotes update(s, t, x)
  and '1' denotes find(i).
attempt: class SegmentTreeDual:
      def __init__(self, arr, op=lambda x, y: y if y != -1 else x, ie=-1):
          self.h = (len(arr) - 1).bit_length()
          self.n = 2**self.h
          self.ie = ie
          self.op = op
          self.val = [ie for _ in range(len(arr))]
          self.laz = [ie for _ in range(2 * self.n)]
          for i in range(len(arr)):
              self.val[i] = arr[i]
  
      def propagate(self, k):
          if self.laz[k] == self.ie:
              return
          if self.n <= k:
              self.val[k - self.n] = self.op(self.val[k - self.n], self.laz[k])
              self.laz[k] = self.ie
          else:
              self.laz[(k << 1)] = self.op(self.laz[(k << 1)], self.laz[k])
              self.laz[(k << 1) + 1] = self.op(self.laz[(k << 1) + 1], self.laz[k])
              self.laz[k] = self.ie
  
      def update(self, left, right, f):
          left += self.n
          right += self.n
          for i in reversed(range(self.h + 1)):
              self.propagate(left >> i)
          for i in reversed(range(self.h + 1)):
              self.propagate((right - 1) >> i)
          while right - left > 0:
              if right & 1:
                  right -= 1
                  self.laz[right] = self.op(self.laz[right], f)
              if left & 1:
                  self.laz[left] = self.op(self.laz[left], f)
                  left += 1
              left >>= 1
              right >>= 1
  
      def get(self, index):
          res = self.val[index]
          index += self.n
          while index:
              res = self.op(res, self.laz[index])
              index //= 2
          return res
  
  
  INF = 2**31 - 1
  N, Q = map(int, input().split())
  A = [INF for _ in range(N)]
  sg = SegmentTreeDual(A)
  ans = []
  
  for _ in range(Q):
      q = list(map(int, input().split()))
      if q[0] == 0:
          s, t, x = q[1:]
          sg.update(s, t + 1, x)
      else:
          i = q[1]
          ans.append(sg.get(i))
  
  print("\n".join(map(str, ans)))
  
problem_description: Range Update Query (RUQ)
  
  Write a program which manipulates a sequence A = {a0, a1, . . . , an−1} with
  the following operations:
  
    * update(s, t, x): change as, as+1, ..., at to x.
    * find(i): output the value of ai.
  
  Note that the initial values of ai (i = 0, 1, . . . , n−1) are 231-1.
samples: [{"input": "3 5\n    0 0 1 1\n    0 1 2 3\n    0 2 2 2\n    1 0\n    1 1", "output": "1\n    3"}, {"input": "1 3\n    1 0\n    0 0 0 5\n    1 0", "output": "2147483647\n    5"}]