* @throws ConcurrentModificationException if the *         list has been modified elsewhere.
    public ListIterator<E> listIterator(final int index)    {      checkMod();      checkBoundsInclusive(index);            return new ListIterator<E>()	{	  private final ListIterator<E> i	    = backingList.listIterator(index + offset);	  private int position = index;	  	  /**	   * Tests to see if there are any more objects to	   * return.	   *	   * @return True if the end of the list has not yet been	   *         reached.	   * @throws ConcurrentModificationException if the	   *         list has been modified elsewhere.	   */	  public boolean hasNext()	  {	      checkMod();	      return position < size;	  }	  	  /**	   * Tests to see if there are objects prior to the	   * current position in the list.	   *	   * @return True if objects exist prior to the current	   *         position of the iterator.	   * @throws ConcurrentModificationException if the	   *         list has been modified elsewhere.	   */	  public boolean hasPrevious()	  {	      checkMod();	      return position > 0;	  }	  	  /**	   * Retrieves the next object from the list.	   *	   * @return The next object.	   * @throws NoSuchElementException if there are no	   *         more objects to retrieve.	   * @throws ConcurrentModificationException if the	   *         list has been modified elsewhere.	   */	  public E next()	  {	      if (position == size)		throw new NoSuchElementException();	      position++;	      return i.next();	  }	  /**	   * Retrieves the previous object from the list.	   *	   * @return The next object.	   * @throws NoSuchElementException if there are no	   *         previous objects to retrieve.	   * @throws ConcurrentModificationException if the	   *         list has been modified elsewhere.	   */	  public E previous()	  {	      if (position == 0)		throw new NoSuchElementException();	      position--;	      return i.previous();	  }	  	  /**	   * Returns the index of the next element in the	   * list, which will be retrieved by <code>next()</code>	   *	   * @return The index of the next element.	   * @throws ConcurrentModificationException if the	   *         list has been modified elsewhere.	   */	  public int nextIndex()	  {	      return i.nextIndex() - offset;	  }	  	  /**	   * Returns the index of the previous element in the	   * list, which will be retrieved by <code>previous()</code>	   *	   * @return The index of the previous element.	   * @throws ConcurrentModificationException if the	   *         list has been modified elsewhere.	   */	  public int previousIndex()	  {	      return i.previousIndex() - offset;	  }	  	  /**	   * Removes the last object retrieved by <code>next()</code>	   * from the list, if the list supports object removal.	   *	   * @throws IllegalStateException if the iterator is positioned	   *         before the start of the list or the last object has already	   *         been removed.	   * @throws UnsupportedOperationException if the list does	   *         not support removing elements.	   */	  public void remove()	  {	      i.remove();	      size--;	      position = nextIndex();	      modCount = backingList.modCount;	  }	  	  	  /**	   * Replaces the last object retrieved by <code>next()</code>	   * or <code>previous</code> with o, if the list supports object	   * replacement and an add or remove operation has not already	   * been performed.	   *	   * @throws IllegalStateException if the iterator is positioned	   *         before the start of the list or the last object has already	   *         been removed.	   * @throws UnsupportedOperationException if the list doesn't support	   *         the addition or removal of elements.	   * @throws ClassCastException if the type of o is not a valid type	   *         for this list.	   * @throws IllegalArgumentException if something else related to o	   *         prevents its addition.	   * @throws ConcurrentModificationException if the list	   *         has been modified elsewhere.	   */	  public void set(E o)	  {	      i.set(o);	  }	  	  /**	   * Adds the supplied object before the element that would be returned	   * by a call to <code>next()</code>, if the list supports addition.	   * 	   * @param o The object to add to the list.	   * @throws UnsupportedOperationException if the list doesn't support	   *         the addition of new elements.	   * @throws ClassCastException if the type of o is not a valid type	   *         for this list.	   * @throws IllegalArgumentException if something else related to o	   *         prevents its addition.	   * @throws ConcurrentModificationException if the list	   *         has been modified elsewhere.	   */	  public void add(E o)	  {	      i.add(o);	      size++;	      position++;	      modCount = backingList.modCount;	  }	  	  // Here is the reason why the various modCount fields are mostly	  // ignored in this wrapper listIterator.	  // If the backing listIterator is failfast, then the following holds:	  //   Using any other method on this list will call a corresponding	  //   method on the backing list *after* the backing listIterator	  //   is created, which will in turn cause a ConcurrentModException	  //   when this listIterator comes to use the backing one. So it is	  //   implicitly failfast.	  // If the backing listIterator is NOT failfast, then the whole of	  //   this list isn't failfast, because the modCount field of the	  //   backing list is not valid. It would still be *possible* to	  //   make the iterator failfast wrt modifications of the sublist	  //   only, but somewhat pointless when the list can be changed under	  //   us.	  // Either way, no explicit handling of modCount is needed.	  // However modCount = backingList.modCount must be executed in add	  // and remove, and size must also be updated in these two methods,	  // since they do not go through the corresponding methods of the subList.	};    }