}
        T previous = iterator.next();
        iterator.set(element);
        return previous;
    }

    @Override
    public T remove(int index) {
        modCount++;
        ListIterator<T> iterator = iteratorAt(index - 1);
        if (!iterator.hasNext()) {
            throw new IndexOutOfBoundsException();
        }
        T previous = iterator.next();
        iterator.remove();

 * whose next element can always be derived from the previous element. Null elements are not
 * supported, nor is the {@link #remove()} method.
 *
 * <p>Example:
 *
 * <pre>{@code
 * Iterator<Integer> powersOfTwo =
 *     new AbstractSequentialIterator<Integer>(1) {
 *       protected Integer computeNext(Integer previous) {
 *         return (previous == 1 << 30) ? null : previous * 2;
 *       }
 *     };
 * }</pre>
 *

	switch v {
	case zero, one:
	case two, one: // ERROR "previous case at LINE-1|duplicate case .*in.* switch"

	case three:
	case 3: // ERROR "previous case at LINE-1|duplicate case .*in.* switch"
	case iii: // ERROR "previous case at LINE-2|duplicate case .*in.* switch"
	}
}

const b = "b"

var _ = map[string]int{
	"a": 0,
	b:   1,
	"a": 2, // ERROR "previous key at LINE-2|duplicate key.*in map literal"

public class OutputFileChanges implements ChangeContainer {

    private final SortedMap<String, FileSystemSnapshot> previous;
    private final SortedMap<String, FileSystemSnapshot> current;

    public OutputFileChanges(SortedMap<String, FileSystemSnapshot> previous, SortedMap<String, FileSystemSnapshot> current) {
        this.previous = previous;
        this.current = current;
    }

    @Override

        });
    return holder.get();
  }

  /**
   * Updates the value currently associated with {@code key} by combining it with {@code x} via the
   * specified accumulator function, returning the new value. The previous value associated with
   * {@code key} (or zero, if there is none) is passed as the first argument to {@code
   * accumulatorFunction}, and {@code x} is passed as the second argument.
   *
   * @since 21.0
   */

        then:
        iterator.previous() == "fuzz"
        iterator.previous() == "fizz"
        iterator.previous() == "foo"
        !iterator.hasPrevious()

        and:
        iterator.next() == "foo"
        iterator.next() == "fizz"
        iterator.next() == "fuzz"
        !iterator.hasNext()

        and:
        iterator.previous() == "fuzz"
        iterator.previous() == "fizz"

            def previousAttribute = null
            def styled = ""
            if (previous == null) {
                this.plainOutput = ""
            } else {
                this.plainOutput = previous.plainOutput
                previousColor = previous.color
                previousAttribute = previous.attribute
                styled = previous.styledOutput
            }
            if (attribute != null && previousAttribute == null) {

         */
        public Entry getPrevious() {
            if (previous != SLinkedList.this.header) {
                return previous;
            }
            return null;
        }

        /**
         * 要素を削除します。
         */
        public void remove() {
            previous.next = next;
            next.previous = previous;
            --size;
        }

        /**

	if wasUntolerated && !isUntolerated {
		logger.V(5).Info("node was created or updated, and this may make the Pod rejected by TaintToleration plugin in the previous scheduling cycle schedulable", "pod", klog.KObj(pod), "node", klog.KObj(modifiedNode))
		return framework.Queue, nil
	}

        }
    }

    private static class Transformed extends TransformStepSubject {
        private final TransformStepSubject previous;
        private final ImmutableList<File> files;

        public Transformed(TransformStepSubject previous, ImmutableList<File> files) {
            this.previous = previous;
            this.files = files;
        }

        @Override
        public ImmutableList<File> getFiles() {