package flagtest;

interface Immutable{}
interface Replacable extends Immutable{}
interface Reducable extends Immutable{}
interface Appendable extends Immutable{}
interface Mutable extends Replacable, Reducable, Appendable{}

interface _Iterator<E, +T | Mutable <: T>{}

<E> boolean hasNext(_Iterator<E,Immutable>);
<E> E next(_Iterator<E,Immutable>);
<E> void remove(_Iterator<E,Reducable>);

interface _ListIterator<E, +T | Mutable <: T> extends _Iterator<E,T>{}

<E> boolean hasPrevious(_ListIterator<E,Immutable>);
<E> E previous(_ListIterator<E,Immutable>);
<E> int nextIndex(_ListIterator<E,Immutable>);
<E> int previousIndex(_ListIterator<E,Immutable>);
<E> void set(_ListIterator<E,Replacable>, E);
<E> void add(_ListIterator<E,Appendable>, E);

interface _Collection<E, +T | Mutable <: T>{}

<E> boolean isEmpty(_Collection<E,Immutable>);
<E> boolean contains(_Collection<E,Immutable>, E);
<E> boolean containsAll(_Collection<E,Immutable>, _Collection<E,Immutable>);
<E,T> _Iterator<E,T> iterator(_Collection<E,T>);
<E> int size(_Collection<E,Immutable>);
<E> boolean remove(_Collection<E,Reducable> ,E);
<E> boolean removeAll(_Collection<E,Reducable>, _Collection<E,Immutable>);
<E> boolean retainAll(_Collection<E,Reducable>, _Collection<E,Immutable>);
<E> void clear(_Collection<E,Reducable>);
<E> boolean add(_Collection<E,Appendable>, E);
<E> boolean addAll(_Collection<E,Appendable>, _Collection<E,Immutable>);
<E> Collection<E> getInternal(_Collection<E,Immutable>);

interface _List<E, +T | Mutable <: T> extends _Collection<E,T> {}

<E> E get(_List<E,Immutable>, int);
<E,T> _ListIterator<E,T> listIterator(_List<E,T>, int i = 0);
<E> int indexOf(_List<E,Immutable>, E);
<E> int lastIndexOf(_List<E,Immutable>, E);
<E> E set(_List<E,Replacable>, int, E);
<E> E removeAt(_List<E,Reducable>, int);
<E> void add(_List<E,Appendable>, int, E);
<E> boolean addAll(_List<E,Appendable>, int, _Collection<E,Immutable>);
<E,T> _List<E,T> subList(_List<E,T>, int from, int to);

interface _Set<E, +T | Mutable <: T> extends _Collection<E,T> {}

class _ArrayList<E, +T | Mutable <: T> implements _List<E,T> {
  ArrayList<E> arrayList;
  getInternal() = arrayList;

  isEmpty() = arrayList.isEmpty();
  contains(elem) = arrayList.contains(elem);
  containsAll(coll) = arrayList.containsAll(coll.getInternal());
  iterator() = new _IteratorWrapper(iterator: arrayList.iterator());
  size() = arrayList.size();
  remove(elem) = arrayList.remove(elem);
  removeAll(coll) = arrayList.removeAll(coll.getInternal());
  retainAll(coll) = arrayList.retainAll(coll.getInternal());
  clear() = arrayList.clear();
  add(elem) = arrayList.add(elem);
  addAll(coll) = arrayList.addAll(coll.getInternal());
  get(index) = arrayList.get(index);
  listIterator(index) = new _ListIteratorWrapper(listIterator: arrayList.listIterator(index));
  indexOf(elem) = arrayList.indexOf(elem);
  lastIndexOf(elem) = arrayList.lastIndexOf(elem);
  set(index, elem) = arrayList.set(index, elem);
  removeAt(index) = arrayList.removeAt(index);
  add(index, elem) = arrayList.add(index, elem);
  addAll(index, coll) = arrayList.addAll(index, coll.getInternal());
  subList(from, to) = new _ListWrapper(list: arrayList.subList(from, to));
}

class _LinkedList<E, +T | Mutable <: T> implements _List<E,T> {
  LinkedList<E> linkedList;
  getInternal() = linkedList;

  isEmpty() = linkedList.isEmpty();
  contains(elem) = linkedList.contains(elem);
  containsAll(coll) = linkedList.containsAll(coll.getInternal());
  iterator() = new _IteratorWrapper(iterator: linkedList.iterator());
  size() = linkedList.size();
  remove(elem) = linkedList.remove(elem);
  removeAll(coll) = linkedList.removeAll(coll.getInternal());
  retainAll(coll) = linkedList.retainAll(coll.getInternal());
  clear() = linkedList.clear();
  add(elem) = linkedList.add(elem);
  addAll(coll) = linkedList.addAll(coll.getInternal());
  get(index) = linkedList.get(index);
  listIterator(index) = new _ListIteratorWrapper(listIterator: linkedList.listIterator(index));
  indexOf(elem) = linkedList.indexOf(elem);
  lastIndexOf(elem) = linkedList.lastIndexOf(elem);
  set(index, elem) = linkedList.set(index, elem);
  removeAt(index) = linkedList.removeAt(index);
  add(index, elem) = linkedList.add(index, elem);
  addAll(index, coll) = linkedList.addAll(index, coll.getInternal());
  subList(from, to) = new _ListWrapper(list: linkedList.subList(from, to));
}

class _Array<E, +T | Replacable <: T> implements _List<E,T> {
  Array<E> array;
  getInternal() = array;

  isEmpty() = array.isEmpty();
  contains(elem) = array.contains(elem);
  containsAll(coll) = array.containsAll(coll.getInternal());
  iterator() = new _IteratorWrapper(iterator: array.iterator());
  size() = array.size();
  get(index) = array.get(index);
  listIterator(index) = new _ListIteratorWrapper(listIterator: array.listIterator(index));
  indexOf(elem) = array.indexOf(elem);
  lastIndexOf(elem) = array.lastIndexOf(elem);
  set(index, elem){
    array[index] = elem;
    return elem;
  }
  subList(from, to) = new _ListWrapper(list: array.subList(from, to));
}

class _HashSet<E, +T | Mutable <: T> implements _Set<E,T> {
  HashSet<E> hashSet;
  getInternal() = hashSet;

  isEmpty() = hashSet.isEmpty();
  contains(elem) = hashSet.contains(elem);
  containsAll(coll) = hashSet.containsAll(coll.getInternal());
  iterator() = new _IteratorWrapper(iterator: hashSet.iterator());
  size() = hashSet.size();
  remove(elem) = hashSet.remove(elem);
  removeAll(coll) = hashSet.removeAll(coll.getInternal());
  retainAll(coll) = hashSet.retainAll(coll.getInternal());
  clear() = hashSet.clear();
  add(elem) = hashSet.add(elem);
  addAll(coll) = hashSet.addAll(coll.getInternal());
}


class _IteratorWrapper<E, +T> implements _Iterator<E,T>{
  Iterator<E> iterator;
                      
  hasNext() = iterator.hasNext();
  next() = iterator.next();
  remove() = iterator.remove();
}                     

class _ListIteratorWrapper<E, +T> implements _ListIterator<E,T>{
  ListIterator<E> listIterator;

  hasNext() = listIterator.hasNext();
  next() = listIterator.next();
  remove() = listIterator.remove();
  hasPrevious() = listIterator.hasPrevious();
  previous() = listIterator.previous();
  nextIndex() = listIterator.nextIndex();
  previousIndex() = listIterator.previousIndex();
  set(elem) = listIterator.set(elem);
  add(elem) = listIterator.add(elem);
}

class _ListWrapper<E, +T> implements _List<E,T> {
  List<E> list;
  getInternal() = list;

  isEmpty() = list.isEmpty();
  contains(elem) = list.contains(elem);
  containsAll(coll) = list.containsAll(coll.getInternal());
  iterator() = new _IteratorWrapper(iterator: list.iterator());
  size() = list.size();
  remove(elem) = list.remove(elem);
  removeAll(coll) = list.removeAll(coll.getInternal());
  retainAll(coll) = list.retainAll(coll.getInternal());
  clear() = list.clear();
  add(elem) = list.add(elem);
  addAll(coll) = list.addAll(coll.getInternal());
  get(index) = list.get(index);
  listIterator(index) = new _ListIteratorWrapper(listIterator: list.listIterator(index));
  indexOf(elem) = list.indexOf(elem);
  lastIndexOf(elem) = list.lastIndexOf(elem);
  set(index, elem) = list.set(index, elem);
  removeAt(index) = list.removeAt(index);
  add(index, elem) = list.add(index, elem);
  addAll(index, coll) = list.addAll(index, coll.getInternal());
  subList(from, to) = new _ListWrapper(list: list.subList(from, to));
}