docs: def prev_moment_operating_on(
              self,
              qubits: Sequence[ops.Qid],
              end_moment_index: Optional[int] = None,
              max_distance: Optional[int] = None) -> Optional[int]:
          """Finds the index of the next moment that touches the given qubits.
  
          Args:
              qubits: We're looking for operations affecting any of these qubits.
              end_moment_index: The moment index just after the starting point of
                  the reverse search. Defaults to the length of the list of
                  moments.
              max_distance: The number of moments (starting just before from the
                  end index and moving backward) to check. Defaults to no limit.
  
          Returns:
              None if there is no matching moment, otherwise the index of the
              latest matching moment.
  
          Raises:
              ValueError: negative max_distance.
          """
          if end_moment_index is None:
              end_moment_index = len(self._moments)
  
          if max_distance is None:
              max_distance = len(self._moments)
          elif max_distance < 0:
              raise ValueError('Negative max_distance: {}'.format(max_distance))
          else:
              max_distance = min(end_moment_index, max_distance)
  
          # Don't bother searching indices past the end of the list.
          if end_moment_index > len(self._moments):
              d = end_moment_index - len(self._moments)
              end_moment_index -= d
              max_distance -= d
          if max_distance <= 0:
              return None
  
          return self._first_moment_operating_on(qubits,
                                                 (end_moment_index - k - 1
                                                  for k in range(max_distance)))