docs: def findall_operations_until_blocked(
              self,
              start_frontier: Dict[ops.Qid, int],
              is_blocker: Callable[[ops.Operation], bool] = lambda op: False
      ) -> List[Tuple[int, ops.Operation]]:
          """
          Finds all operations until a blocking operation is hit.  This returns
          a list of all operations from the starting frontier until a blocking
          operation is encountered.  An operation is part of the list if
          it is involves a qubit in the start_frontier dictionary, comes after
          the moment listed in that dictionary, and before any blocking
          operationi that involve that qubit.  Operations are only considered
          to blocking the qubits that they operate on, so a blocking operation
          that does not operate on any qubit in the starting frontier is not
          actually considered blocking.  See `reachable_frontier_from` for a more
          in depth example of reachable states.
  
          Args:
              start_frontier: A starting set of reachable locations.
              is_blocker: A predicate that determines if operations block
                  reachability. Any location covered by an operation that causes
                  `is_blocker` to return True is considered to be an unreachable
                  location.
  
          Returns:
              A list of tuples. Each tuple describes an operation found between
              the start frontier and a blocking operation. The first item of
              each tuple is the index of the moment containing the operation,
              and the second item is the operation itself.
          """
          op_list = []
          max_index = len(self._moments)
          for qubit in start_frontier:
              current_index = start_frontier[qubit]
              if current_index < 0:
                  current_index = 0
              while current_index < max_index:
                  if self[current_index].operates_on_single_qubit(qubit):
                      next_op = self.operation_at(qubit, current_index)
                      if next_op is not None:
                          if is_blocker(next_op):
                              break
                          op_list.append((current_index,next_op))
                  current_index+=1
          return op_list