diff --git a/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/ConsPStack.java b/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/ConsPStack.java
index b529b6580c8..90ea3b6dee2 100644
--- a/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/ConsPStack.java
+++ b/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/ConsPStack.java
@@ -1,210 +1,141 @@
 package kotlin.reflect.jvm.internal.pcollections;
 
-import java.util.AbstractSequentialList;
-import java.util.Collection;
 import java.util.Iterator;
 import java.util.ListIterator;
-
-
+import java.util.NoSuchElementException;
 
 /**
- * 
  * A simple persistent stack of non-null values.
- * <p>
- * This implementation is thread-safe (assuming Java's AbstractSequentialList is thread-safe),
- * although its iterators may not be.
- * 
- * @author harold
+ * <p/>
+ * This implementation is thread-safe, although its iterators may not be.
  *
- * @param <E>
+ * @author harold
  */
-public final class ConsPStack<E> extends AbstractSequentialList<E> implements PStack<E> {
-//// STATIC FACTORY METHODS ////
-	private static final ConsPStack<Object> EMPTY = new ConsPStack<Object>();
-	
-	/**
-	 * @param <E>
-	 * @return an empty stack
-	 */
-	@SuppressWarnings("unchecked")
-	public static <E> ConsPStack<E> empty() {
-		return (ConsPStack<E>)EMPTY; }
-	
-	/**
-	 * @param <E>
-	 * @param e
-	 * @return empty().plus(e)
-	 */
-	public static <E> ConsPStack<E> singleton(final E e) {
-		return ConsPStack.<E>empty().plus(e); }
-	
-	/**
-	 * @param <E>
-	 * @param list
-	 * @return a stack consisting of the elements of list in the order of list.iterator()
-	 */
-	@SuppressWarnings("unchecked")
-	public static <E> ConsPStack<E> from(final Collection<? extends E> list) {
-		if(list instanceof ConsPStack)
-			return (ConsPStack<E>)list; //(actually we only know it's ConsPStack<? extends E>)
-									// but that's good enough for an immutable
-									// (i.e. we can't mess someone else up by adding the wrong type to it)
-		return from(list.iterator());
-	}
-	
-	private static <E> ConsPStack<E> from(final Iterator<? extends E> i) {
-		if(!i.hasNext()) return empty();
-		E e = i.next();
-		return from(i).plus(e);
-	}
+public final class ConsPStack<E> implements PStack<E> {
+    private static final ConsPStack<Object> EMPTY = new ConsPStack<Object>();
 
-	
-//// PRIVATE CONSTRUCTORS ////
-	private final E first; private final ConsPStack<E> rest;
-	private final int size;
-	// not externally instantiable (or subclassable):
-	private ConsPStack() { // EMPTY constructor
-		if(EMPTY!=null)
-			throw new RuntimeException("empty constructor should only be used once");
-		size = 0; first=null; rest=null;
-	}
-	private ConsPStack(final E first, final ConsPStack<E> rest) {
-		this.first = first; this.rest = rest;
-		
-		size = 1 + rest.size;
-	}
-	
-	
-//// REQUIRED METHODS FROM AbstractSequentialList ////
-	@Override
-	public int size() {
-		return size; }
-	
-	@Override
-	public ListIterator<E> listIterator(final int index) {
-		if(index<0 || index>size) throw new IndexOutOfBoundsException();
-		
-		return new ListIterator<E>() {
-			int i = index;
-			ConsPStack<E> next = subList(index);
+    @SuppressWarnings("unchecked")
+    public static <E> ConsPStack<E> empty() {
+        return (ConsPStack<E>) EMPTY;
+    }
 
-			public boolean hasNext() {
-				return next.size>0; }
-			public boolean hasPrevious() {
-				return i>0; }
-			public int nextIndex() {
-				return index; }
-			public int previousIndex() {
-				return index-1; }
-			public E next() {
-				E e = next.first;
-				next = next.rest;
-				return e;
-			}
-			public E previous() {
-				System.err.println("ConsPStack.listIterator().previous() is inefficient, don't use it!");
-				next = subList(index-1); // go from beginning...
-				return next.first;
-			}
+    private final E first;
+    private final ConsPStack<E> rest;
+    private final int size;
 
-			public void add(final E o) {
-				throw new UnsupportedOperationException(); }
-			public void remove() {
-				throw new UnsupportedOperationException(); }
-			public void set(final E o) {
-				throw new UnsupportedOperationException(); }
-		};
-	}
+    private ConsPStack() { // EMPTY constructor
+        size = 0;
+        first = null;
+        rest = null;
+    }
 
+    private ConsPStack(E first, ConsPStack<E> rest) {
+        this.first = first;
+        this.rest = rest;
+        this.size = 1 + rest.size;
+    }
 
-//// OVERRIDDEN METHODS FROM AbstractSequentialList ////
-	@Override
-	public ConsPStack<E> subList(final int start, final int end) {
-		if(start<0 || end>size || start>end)
-			throw new IndexOutOfBoundsException();
-		if(end==size) // want a substack
-			return subList(start); // this is faster
-		if(start==end) // want nothing
-			return empty();
-		if(start==0) // want the current element
-			return new ConsPStack<E>(first, rest.subList(0, end-1));
-		// otherwise, don't want the current element:
-		return rest.subList(start-1, end-1);
-	}
-	
-	
-//// IMPLEMENTED METHODS OF PStack ////
-	public ConsPStack<E> plus(final E e) {
-		return new ConsPStack<E>(e, this);
-	}
-	
-	public ConsPStack<E> plusAll(final Collection<? extends E> list) {
-		ConsPStack<E> result = this;
-		for(E e : list)
-			result = result.plus(e);
-		return result;
-	}
+    public E get(int index) {
+        try {
+            return listIterator(index).next();
+        } catch (NoSuchElementException e) {
+            throw new IndexOutOfBoundsException("Index: " + index);
+        }
+    }
 
-	public ConsPStack<E> plus(final int i, final E e) {
-		if(i<0 || i>size)
-			throw new IndexOutOfBoundsException();
-		if(i==0) // insert at beginning
-			return plus(e);
-		return new ConsPStack<E>(first, rest.plus(i-1, e));
-	}
+    @Override
+    public Iterator<E> iterator() {
+        return listIterator(0);
+    }
 
-	public ConsPStack<E> plusAll(final int i, final Collection<? extends E> list) {
-		// TODO inefficient if list.isEmpty()
-		if(i<0 || i>size)
-			throw new IndexOutOfBoundsException();
-		if(i==0)
-			return plusAll(list);
-		return new ConsPStack<E>(first, rest.plusAll(i-1, list));
-	}
-	
-	public ConsPStack<E> minus(final Object e) {
-		if(size==0)
-			return this;
-		if(first.equals(e)) // found it
-			return rest; // don't recurse (only remove one)
-		// otherwise keep looking:
-		ConsPStack<E> newRest = rest.minus(e);
-		if(newRest==rest) return this;
-		return new ConsPStack<E>(first, newRest);
-	}
+    @Override
+    public int size() {
+        return size;
+    }
 
-	public ConsPStack<E> minus(final int i) {
-		return minus(get(i));
-	}
+    public ListIterator<E> listIterator(final int index) {
+        if (index < 0 || index > size) throw new IndexOutOfBoundsException();
 
-	public ConsPStack<E> minusAll(final Collection<?> list) {
-		if(size==0)
-			return this;
-		if(list.contains(first)) // get rid of current element
-			return rest.minusAll(list); // recursively delete all
-		// either way keep looking:
-		ConsPStack<E> newRest = rest.minusAll(list);
-		if(newRest==rest) return this;
-		return new ConsPStack<E>(first, newRest);
-	}
-	
-	public ConsPStack<E> with(final int i, final E e) {
-		if(i<0 || i>=size)
-			throw new IndexOutOfBoundsException();
-		if(i==0) {
-			if(first.equals(e)) return this;
-			return new ConsPStack<E>(e, rest);
-		}
-		ConsPStack<E> newRest = rest.with(i-1, e);
-		if(newRest==rest) return this;
-		return new ConsPStack<E>(first, newRest);
-	}
+        return new ListIterator<E>() {
+            int i = index;
+            ConsPStack<E> next = subList(index);
 
-	public ConsPStack<E> subList(final int start) {
-		if(start<0 || start>size)
-			throw new IndexOutOfBoundsException();
-		if(start==0)
-			return this;
-		return rest.subList(start-1);
-	}
+            @Override
+            public boolean hasNext() {
+                return next.size > 0;
+            }
+
+            @Override
+            public boolean hasPrevious() {
+                return i > 0;
+            }
+
+            @Override
+            public int nextIndex() {
+                return index;
+            }
+
+            @Override
+            public int previousIndex() {
+                return index - 1;
+            }
+
+            @Override
+            public E next() {
+                E e = next.first;
+                next = next.rest;
+                return e;
+            }
+
+            @Override
+            public E previous() {
+                System.err.println("ConsPStack.listIterator().previous() is inefficient, don't use it!");
+                next = subList(index - 1); // go from beginning...
+                return next.first;
+            }
+
+            @Override
+            public void add(E o) {
+                throw new UnsupportedOperationException();
+            }
+
+            @Override
+            public void remove() {
+                throw new UnsupportedOperationException();
+            }
+
+            @Override
+            public void set(E o) {
+                throw new UnsupportedOperationException();
+            }
+        };
+    }
+
+    @Override
+    public ConsPStack<E> plus(E e) {
+        return new ConsPStack<E>(e, this);
+    }
+
+    public ConsPStack<E> minus(Object e) {
+        if (size == 0) return this;
+        if (first.equals(e)) // found it
+            return rest; // don't recurse (only remove one)
+        // otherwise keep looking:
+        ConsPStack<E> newRest = rest.minus(e);
+        if (newRest == rest) return this;
+        return new ConsPStack<E>(first, newRest);
+    }
+
+    @Override
+    public ConsPStack<E> minus(int i) {
+        return minus(get(i));
+    }
+
+    public ConsPStack<E> subList(int start) {
+        if (start < 0 || start > size)
+            throw new IndexOutOfBoundsException();
+        if (start == 0)
+            return this;
+        return rest.subList(start - 1);
+    }
 }
diff --git a/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/HashPMap.java b/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/HashPMap.java
index f2c777c364b..36c6abc287e 100644
--- a/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/HashPMap.java
+++ b/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/HashPMap.java
@@ -1,175 +1,87 @@
 package kotlin.reflect.jvm.internal.pcollections;
 
-import java.util.AbstractMap;
-import java.util.AbstractSet;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Set;
-
-
-
+import static java.util.Map.Entry;
 
 /**
- * 
  * A persistent map from non-null keys to non-null values.
- * <p>
+ * <p/>
  * This map uses a given integer map to map hashcodes to lists of elements
  * with the same hashcode. Thus if all elements have the same hashcode, performance
  * is reduced to that of an association list.
- * <p>
- * This implementation is thread-safe (assuming Java's AbstractMap and AbstractSet are thread-safe),
- * although its iterators may not be.
- * 
- * @author harold
+ * <p/>
+ * This implementation is thread-safe, although its iterators may not be.
  *
- * @param <K>
- * @param <V>
+ * @author harold
  */
-public final class HashPMap<K,V> extends AbstractMap<K,V> implements PMap<K,V> {
-//// STATIC FACTORY METHODS ////
-	/**
-	 * @param <K>
-	 * @param <V>
-	 * @param intMap
-	 * @return a map backed by an empty version of intMap,
-	 * 	i.e. backed by intMap.minusAll(intMap.keySet())
-	 */
-	public static <K,V> HashPMap<K,V> empty(final PMap<Integer,PSequence<Entry<K,V>>> intMap) {
-		return new HashPMap<K,V>(intMap.minusAll(intMap.keySet()), 0); }
-	
+public final class HashPMap<K, V> implements PMap<K, V> {
+    public static final HashPMap<Object, Object> EMPTY = new HashPMap<Object, Object>(IntTreePMap.<PStack<Entry<Object, Object>>>empty(), 0);
 
-//// PRIVATE CONSTRUCTORS ////
-	private final PMap<Integer,PSequence<Entry<K,V>>> intMap;
-	private final int size;
-	// not externally instantiable (or subclassable):
-	private HashPMap(final PMap<Integer,PSequence<Entry<K,V>>> intMap, final int size) {
-		this.intMap = intMap; this.size = size; }
+    @SuppressWarnings("unchecked")
+    public static <K, V> HashPMap<K, V> empty() {
+        return (HashPMap<K, V>) HashPMap.EMPTY;
+    }
 
-	
-//// REQUIRED METHODS FROM AbstractMap ////
-	// this cache variable is thread-safe since assignment in Java is atomic:
-	private Set<Entry<K,V>> entrySet = null;
-	@Override
-	public Set<Entry<K,V>> entrySet() {
-		if(entrySet==null)
-			entrySet = new AbstractSet<Entry<K,V>>() {
-				// REQUIRED METHODS OF AbstractSet // 
-				@Override
-				public int size() {
-					return size; }		
-				@Override
-				public Iterator<Entry<K,V>> iterator() {
-					return new SequenceIterator<Entry<K,V>>(intMap.values().iterator()); }
-				// OVERRIDDEN METHODS OF AbstractSet //
-				@Override
-				public boolean contains(final Object e) {
-					if(!(e instanceof Entry))
-						return false;
-					V value = get(((Entry<?,?>)e).getKey());
-					return value!=null && value.equals(((Entry<?,?>)e).getValue());
-				}
-			};
-		return entrySet;
-	}
+    private final IntTreePMap<PStack<Entry<K, V>>> intMap;
+    private final int size;
 
-	
-//// OVERRIDDEN METHODS FROM AbstractMap ////
-	@Override
-	public int size() {
-		return size; }
+    private HashPMap(IntTreePMap<PStack<Entry<K, V>>> intMap, int size) {
+        this.intMap = intMap;
+        this.size = size;
+    }
 
-	@Override
-	public boolean containsKey(final Object key) {
-		return keyIndexIn(getEntries(key.hashCode()), key) != -1; }
-	
-	@Override
-	public V get(final Object key) {
-		PSequence<Entry<K,V>> entries = getEntries(key.hashCode());
-		for(Entry<K,V> entry : entries)
-			if(entry.getKey().equals(key))
-				return entry.getValue();
-		return null;
-	}
+    public int size() {
+        return size;
+    }
 
-	
-//// IMPLEMENTED METHODS OF PMap////
-	public HashPMap<K,V> plusAll(final Map<? extends K, ? extends V> map) {
-		HashPMap<K,V> result = this;
-		for(Entry<? extends K,? extends V> entry : map.entrySet())
-			result = result.plus(entry.getKey(), entry.getValue());
-		return result;
-	}
+    public boolean containsKey(Object key) {
+        return keyIndexIn(getEntries(key.hashCode()), key) != -1;
+    }
 
-	public HashPMap<K,V> minusAll(final Collection<?> keys) {
-		HashPMap<K,V> result = this;
-		for(Object key : keys)
-			result = result.minus(key);
-		return result;
-	}
-	
-	public HashPMap<K,V> plus(final K key, final V value) {
-		PSequence<Entry<K,V>> entries = getEntries(key.hashCode());
-		int size0 = entries.size(),
-			i = keyIndexIn(entries, key);
-		if(i!=-1) entries = entries.minus(i);
-		entries = entries.plus(new SimpleImmutableEntry<K,V>(key, value));
-		return new HashPMap<K,V>(intMap.plus(key.hashCode(), entries),
-				size-size0+entries.size());
-	}
+    @Override
+    public V get(Object key) {
+        PStack<Entry<K, V>> entries = getEntries(key.hashCode());
+        for (Entry<K, V> entry : entries)
+            if (entry.getKey().equals(key))
+                return entry.getValue();
+        return null;
+    }
 
-	public HashPMap<K,V> minus(final Object key) {
-		PSequence<Entry<K,V>> entries = getEntries(key.hashCode());
-		int i = keyIndexIn(entries, key);
-		if(i==-1) // key not in this
-			return this;
-		entries = entries.minus(i);
-		if(entries.size()==0) // get rid of the entire hash entry
-			return new HashPMap<K,V>(intMap.minus(key.hashCode()),
-					size-1);
-		// otherwise replace hash entry with new smaller one:
-		return new HashPMap<K,V>(intMap.plus(key.hashCode(), entries),
-				size-1);
-	}
-	
-	
-//// PRIVATE UTILITIES ////
-	private PSequence<Entry<K,V>> getEntries(final int hash) {
-		PSequence<Entry<K,V>> entries = intMap.get(hash);
-		if(entries==null) return ConsPStack.empty();
-		return entries;
-	}
+    @Override
+    public HashPMap<K, V> plus(K key, V value) {
+        PStack<Entry<K, V>> entries = getEntries(key.hashCode());
+        int size0 = entries.size();
+        int i = keyIndexIn(entries, key);
+        if (i != -1) entries = entries.minus(i);
+        entries = entries.plus(new SimpleImmutableEntry<K, V>(key, value));
+        return new HashPMap<K, V>(intMap.plus(key.hashCode(), entries), size - size0 + entries.size());
+    }
 
-	
-//// PRIVATE STATIC UTILITIES ////
-	private static <K,V> int keyIndexIn(final PSequence<Entry<K,V>> entries, final Object key) {
-		int i=0;
-		for(Entry<K,V> entry : entries) {
-			if(entry.getKey().equals(key))
-				return i;
-			i++;
-		}
-		return -1;
-	}
-	
-	static class SequenceIterator<E> implements Iterator<E> {
-		private final Iterator<PSequence<E>> i;
-		private PSequence<E> seq = ConsPStack.empty();
-		SequenceIterator(Iterator<PSequence<E>> i) {
-			this.i = i; }
+    @Override
+    public HashPMap<K, V> minus(Object key) {
+        PStack<Entry<K, V>> entries = getEntries(key.hashCode());
+        int i = keyIndexIn(entries, key);
+        if (i == -1) // key not in this
+            return this;
+        entries = entries.minus(i);
+        if (entries.size() == 0) // get rid of the entire hash entry
+            return new HashPMap<K, V>(intMap.minus(key.hashCode()), size - 1);
+        // otherwise replace hash entry with new smaller one:
+        return new HashPMap<K, V>(intMap.plus(key.hashCode(), entries), size - 1);
+    }
 
-		public boolean hasNext() {
-			return seq.size()>0 || i.hasNext(); }
+    private PStack<Entry<K, V>> getEntries(int hash) {
+        PStack<Entry<K, V>> entries = intMap.get(hash);
+        if (entries == null) return ConsPStack.empty();
+        return entries;
+    }
 
-		public E next() {
-			if(seq.size()==0)
-				seq = i.next();
-			final E result = seq.get(0);
-			seq = seq.subList(1, seq.size());
-			return result;
-		}
-
-		public void remove() {
-			throw new UnsupportedOperationException(); }
-	}
+    private static <K, V> int keyIndexIn(PStack<Entry<K, V>> entries, Object key) {
+        int i = 0;
+        for (Entry<K, V> entry : entries) {
+            if (entry.getKey().equals(key))
+                return i;
+            i++;
+        }
+        return -1;
+    }
 }
diff --git a/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/HashTreePMap.java b/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/HashTreePMap.java
deleted file mode 100644
index 46b3ab9c195..00000000000
--- a/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/HashTreePMap.java
+++ /dev/null
@@ -1,51 +0,0 @@
-package kotlin.reflect.jvm.internal.pcollections;
-
-import java.util.Map;
-import java.util.Map.Entry;
-
-
-
-
-/**
- *
- * A static convenience class for creating efficient persistent maps.
- * <p>
- * This class simply creates HashPMaps backed by IntTreePMaps.
- * 
- * @author harold
- */
-public final class HashTreePMap {
-	// not instantiable (or subclassable):
-	private HashTreePMap() {}
-	
-	private static final HashPMap<Object,Object> EMPTY
-		= HashPMap.empty(IntTreePMap.<PSequence<Entry<Object,Object>>>empty());
-
-	/**
-	 * @param <K>
-	 * @param <V>
-	 * @return an empty map
-	 */
-	@SuppressWarnings("unchecked")
-	public static <K,V> HashPMap<K,V> empty() {
-		return (HashPMap<K,V>)EMPTY; }
-	
-	/**
-	 * @param <K>
-	 * @param <V>
-	 * @param key
-	 * @param value
-	 * @return empty().plus(key, value)
-	 */
-	public static <K,V> HashPMap<K,V> singleton(final K key, final V value) {
-		return HashTreePMap.<K,V>empty().plus(key, value); }
-	
-	/**
-	 * @param <K>
-	 * @param <V>
-	 * @param map
-	 * @return empty().plusAll(map)
-	 */
-	public static <K,V> HashPMap<K,V> from(final Map<? extends K, ? extends V> map) {
-		return HashTreePMap.<K,V>empty().plusAll(map); }
-}
diff --git a/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/IntTree.java b/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/IntTree.java
index d5a1ea7b2bb..5d3fcd44160 100644
--- a/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/IntTree.java
+++ b/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/IntTree.java
@@ -1,309 +1,248 @@
 package kotlin.reflect.jvm.internal.pcollections;
 
-import java.util.Iterator;
-import java.util.Map.Entry;
-
-
-
-
 /**
- * 
  * A non-public utility class for persistent balanced tree maps with integer keys.
- * <p>
+ * <p/>
  * To allow for efficiently increasing all keys above a certain value or decreasing
  * all keys below a certain value, the keys values are stored relative to their parent.
  * This makes this map a good backing for fast insertion and removal of indices in a
  * vector.
- * <p>
+ * <p/>
  * This implementation is thread-safe except for its iterators.
- * <p>
+ * <p/>
  * Other than that, this tree is based on the Glasgow Haskell Compiler's Data.Map implementation,
  * which in turn is based on "size balanced binary trees" as described by:
- * <p>
+ * <p/>
  * Stephen Adams, "Efficient sets: a balancing act",
  * Journal of Functional Programming 3(4):553-562, October 1993,
  * http://www.swiss.ai.mit.edu/~adams/BB/.
- * <p>
+ * <p/>
  * J. Nievergelt and E.M. Reingold, "Binary search trees of bounded balance",
  * SIAM journal of computing 2(1), March 1973.
- * 
- * @author harold
  *
- * @param <V>
+ * @author harold
  */
-class IntTree<V> {
-	// marker value:
-	static final IntTree<Object> EMPTYNODE = new IntTree<Object>();
-	
-	private final long key; // we use longs so relative keys can express all ints
-		// (e.g. if this has key -10 and right has 'absolute' key MAXINT,
-		// then its relative key is MAXINT+10 which overflows)
-		// there might be some way to deal with this based on left-verse-right logic,
-		// but that sounds like a mess.
-	private final V value; // null value means this is empty node
-	private final IntTree<V> left, right;
-	private final int size;
-	private IntTree() {
-		if(EMPTYNODE!=null)
-			throw new RuntimeException("empty constructor should only be used once");
-		size = 0;
-		
-		key=0; value=null; left=null; right=null;
-	}
-	private IntTree(final long key, final V value, final IntTree<V> left, final IntTree<V> right) {
-		this.key = key; this.value = value;
-		this.left = left; this.right = right;
-		size = 1 + left.size + right.size;
-	}
-	
-	private IntTree<V> withKey(final long newKey) {
-		if(size==0 || newKey==key) return this;
-		return new IntTree<V>(newKey, value, left, right); }
-	
-	Iterator<Entry<Integer,V>> iterator() {
-		return new EntryIterator<V>(this); }
-	
-	int size() {
-		return size; }
+final class IntTree<V> {
+    // marker value:
+    static final IntTree<Object> EMPTYNODE = new IntTree<Object>();
 
-	boolean containsKey(final long key) {
-		if(size==0)
-			return false;
-		if(key < this.key)
-			return left.containsKey(key-this.key);
-		if(key > this.key)
-			return right.containsKey(key-this.key);
-		// otherwise key==this.key:
-		return true;
-	}
-	
-	V get(final long key) {
-		if(size==0)
-			return null;
-		if(key < this.key)
-			return left.get(key-this.key);
-		if(key > this.key)
-			return right.get(key-this.key);
-		// otherwise key==this.key:
-		return value;
-	}
+    // we use longs so relative keys can express all ints
+    // (e.g. if this has key -10 and right has 'absolute' key MAXINT,
+    // then its relative key is MAXINT+10 which overflows)
+    // there might be some way to deal with this based on left-verse-right logic,
+    // but that sounds like a mess.
+    private final long key;
+    private final V value; // null value means this is empty node
+    private final IntTree<V> left, right;
+    private final int size;
 
-	IntTree<V> plus(final long key, final V value) {
-		if(size==0)
-			return new IntTree<V>(key, value, this, this);
-		if(key < this.key)
-			return rebalanced(left.plus(key-this.key, value), right);
-		if(key > this.key)
-			return rebalanced(left, right.plus(key-this.key, value));
-		// otherwise key==this.key, so we simply replace this, with no effect on balance:
-		if(value==this.value)
-			return this;
-		return new IntTree<V>(key, value, left, right);
-	}
+    private IntTree() {
+        size = 0;
+        key = 0;
+        value = null;
+        left = null;
+        right = null;
+    }
 
-	IntTree<V> minus(final long key) {
-		if(size==0)
-			return this;
-		if(key < this.key)
-			return rebalanced(left.minus(key-this.key), right);
-		if(key > this.key)
-			return rebalanced(left, right.minus(key-this.key));
+    private IntTree(long key, V value, IntTree<V> left, IntTree<V> right) {
+        this.key = key;
+        this.value = value;
+        this.left = left;
+        this.right = right;
+        size = 1 + left.size + right.size;
+    }
 
-		// otherwise key==this.key, so we are killing this node:
+    private IntTree<V> withKey(long newKey) {
+        if (size == 0 || newKey == key) return this;
+        return new IntTree<V>(newKey, value, left, right);
+    }
 
-		if(left.size==0) // we can just become right node
-			// make key 'absolute':
-			return right.withKey(right.key+this.key);
-		if(right.size==0) // we can just become left node
-			return left.withKey(left.key+this.key);
+    boolean containsKey(long key) {
+        if (size == 0)
+            return false;
+        if (key < this.key)
+            return left.containsKey(key - this.key);
+        if (key > this.key)
+            return right.containsKey(key - this.key);
+        // otherwise key==this.key:
+        return true;
+    }
 
-		// otherwise replace this with the next key (i.e. the smallest key to the right):
-		
-		// TODO have minNode() instead of minKey to avoid having to call get()
-		// TODO get node from larger subtree, i.e. if left.size>right.size use left.maxNode()
-		// TODO have faster minusMin() instead of just using minus()
-		
-		long newKey = right.minKey() + this.key;
-			//(right.minKey() is relative to this; adding this.key makes it 'absolute'
-			//	where 'absolute' really means relative to the parent of this)
+    V get(long key) {
+        if (size == 0)
+            return null;
+        if (key < this.key)
+            return left.get(key - this.key);
+        if (key > this.key)
+            return right.get(key - this.key);
+        // otherwise key==this.key:
+        return value;
+    }
 
-		V newValue = right.get(newKey-this.key);
-		// now that we've got the new stuff, take it out of the right subtree:
-		IntTree<V> newRight = right.minus(newKey-this.key);
+    IntTree<V> plus(long key, V value) {
+        if (size == 0)
+            return new IntTree<V>(key, value, this, this);
+        if (key < this.key)
+            return rebalanced(left.plus(key - this.key, value), right);
+        if (key > this.key)
+            return rebalanced(left, right.plus(key - this.key, value));
+        // otherwise key==this.key, so we simply replace this, with no effect on balance:
+        if (value == this.value)
+            return this;
+        return new IntTree<V>(key, value, left, right);
+    }
 
-		// lastly, make the subtree keys relative to newKey (currently they are relative to this.key):
-		newRight = newRight.withKey( (newRight.key+this.key) - newKey );
-		// left is definitely not empty:
-		IntTree<V> newLeft = left.withKey( (left.key+this.key) - newKey );
-		
-		return rebalanced(newKey, newValue, newLeft, newRight);
-	}
-	
-	/**
-	 * Changes every key k>=key to k+delta.
-	 * 
-	 * This method will create an _invalid_ tree if delta<0
-	 * and the distance between the smallest k>=key in this
-	 * and the largest j<key in this is |delta| or less.
-	 * 
-	 * In other words, this method must not result in any change
-	 * in the order of the keys in this, since the tree structure is
-	 * not being changed at all.
-	 */
-	IntTree<V> changeKeysAbove(final long key, final int delta) {
-		if(size==0 || delta==0)
-			return this;
+    IntTree<V> minus(long key) {
+        if (size == 0)
+            return this;
+        if (key < this.key)
+            return rebalanced(left.minus(key - this.key), right);
+        if (key > this.key)
+            return rebalanced(left, right.minus(key - this.key));
 
-		if(this.key>=key)
-			// adding delta to this.key changes the keys of _all_ children of this,
-			// so we now need to un-change the children of this smaller than key,
-			// all of which are to the left. note that we still use the 'old' relative key...:
-			return new IntTree<V>(this.key+delta, value, left.changeKeysBelow(key-this.key, -delta), right);
+        // otherwise key==this.key, so we are killing this node:
 
-		// otherwise, doesn't apply yet, look to the right:
-		IntTree<V> newRight = right.changeKeysAbove(key-this.key, delta);
-		if(newRight==right) return this;
-		return new IntTree<V>(this.key, value, left, newRight);
-	}
-	
-	/**
-	 * Changes every key k<key to k+delta.
-	 * 
-	 * This method will create an _invalid_ tree if delta>0
-	 * and the distance between the largest k<key in this
-	 * and the smallest j>=key in this is delta or less.
-	 * 
-	 * In other words, this method must not result in any overlap or change
-	 * in the order of the keys in this, since the tree _structure_ is
-	 * not being changed at all.
-	 */
-	IntTree<V> changeKeysBelow(final long key, final int delta) {
-		if(size==0 || delta==0)
-			return this;
+        if (left.size == 0) // we can just become right node
+            // make key 'absolute':
+            return right.withKey(right.key + this.key);
+        if (right.size == 0) // we can just become left node
+            return left.withKey(left.key + this.key);
 
-		if(this.key<key)
-			// adding delta to this.key changes the keys of _all_ children of this,
-			// so we now need to un-change the children of this larger than key,
-			// all of which are to the right. note that we still use the 'old' relative key...:
-			return new IntTree<V>(this.key+delta, value, left, right.changeKeysAbove(key-this.key, -delta));
+        // otherwise replace this with the next key (i.e. the smallest key to the right):
 
-		// otherwise, doesn't apply yet, look to the left:
-		IntTree<V> newLeft = left.changeKeysBelow(key-this.key, delta);
-		if(newLeft==left) return this;
-		return new IntTree<V>(this.key, value, newLeft, right);
-	}
-	
-	// min key in this:
-	private long minKey() {
-		if(left.size==0)
-			return key;
-		// make key 'absolute' (i.e. relative to the parent of this):
-		return left.minKey() + this.key;
-	}
+        // TODO have minNode() instead of minKey to avoid having to call get()
+        // TODO get node from larger subtree, i.e. if left.size>right.size use left.maxNode()
+        // TODO have faster minusMin() instead of just using minus()
 
-	private IntTree<V> rebalanced(final IntTree<V> newLeft, final IntTree<V> newRight) {
-		if(newLeft==left && newRight==right)
-			return this; // already balanced
-		return rebalanced(key, value, newLeft, newRight);
-	}
+        long newKey = right.minKey() + this.key;
+        //(right.minKey() is relative to this; adding this.key makes it 'absolute'
+        //	where 'absolute' really means relative to the parent of this)
 
-	private static final int OMEGA = 5;
-	private static final int ALPHA = 2;
-	// rebalance a tree that is off-balance by at most 1:
-	private static <V> IntTree<V> rebalanced(final long key, final V value,
-			final IntTree<V> left, final IntTree<V> right) {
-		if(left.size + right.size > 1) {
-			if(left.size >= OMEGA*right.size) { // rotate to the right
-				IntTree<V> ll = left.left, lr = left.right;
-				if(lr.size < ALPHA*ll.size) // single rotation
-					return new IntTree<V>(left.key+key, left.value,
-							ll,
-							new IntTree<V>(-left.key, value,
-									lr.withKey(lr.key+left.key),
-									right));
-				else { // double rotation:
-					IntTree<V> lrl = lr.left, lrr = lr.right;
-					return new IntTree<V>(lr.key+left.key+key, lr.value,
-							new IntTree<V>(-lr.key, left.value,
-									ll,
-									lrl.withKey(lrl.key+lr.key)),
-							new IntTree<V>(-left.key-lr.key, value,
-									lrr.withKey(lrr.key+lr.key+left.key),
-									right));
-				}
-			}
-			else if(right.size >= OMEGA*left.size) { // rotate to the left
-				IntTree<V> rl = right.left, rr = right.right;
-				if(rl.size < ALPHA*rr.size) // single rotation
-					return new IntTree<V>(right.key+key, right.value,
-							new IntTree<V>(-right.key, value,
-									left,
-									rl.withKey(rl.key+right.key)),
-							rr);
-				else { // double rotation:
-					IntTree<V> rll = rl.left, rlr = rl.right;
-					return new IntTree<V>(rl.key+right.key+key, rl.value,
-							new IntTree<V>(-right.key-rl.key, value,
-									left,
-									rll.withKey(rll.key+rl.key+right.key)),
-							new IntTree<V>(-rl.key, right.value,
-									rlr.withKey(rlr.key+rl.key),
-									rr));
-				}
-			}
-		}
-		// otherwise already balanced enough:
-		return new IntTree<V>(key, value, left, right);
-	}
+        V newValue = right.get(newKey - this.key);
+        // now that we've got the new stuff, take it out of the right subtree:
+        IntTree<V> newRight = right.minus(newKey - this.key);
 
-	
-////entrySet().iterator() IMPLEMENTATION ////	
-	// TODO make this a ListIterator?
-	private static final class EntryIterator<V> implements Iterator<Entry<Integer,V>> {
-		private PStack<IntTree<V>> stack = ConsPStack.empty(); //path of nonempty nodes
-		private int key = 0; // note we use _int_ here since this is a truly absolute key
-		
-		EntryIterator(final IntTree<V> root) {
-			gotoMinOf(root); }
-		
-		public boolean hasNext() {
-			return stack.size()>0; }
-		
-		public Entry<Integer,V> next() {
-			IntTree<V> node = stack.get(0);
-			final Entry<Integer,V> result = new SimpleImmutableEntry<Integer,V>(key, node.value);
-			
-			// find next node.
-			// we've already done everything smaller,
-			// so try least larger node:
-			
-			if(node.right.size>0) // we can descend to the right
-				gotoMinOf(node.right);
-			
-			else // can't descend to the right -- try ascending to the right
-				while (true) { // find current node's least larger ancestor, if any
-					key -= node.key; // revert to parent's key
-					stack = stack.subList(1); // climb up to parent
-					// if parent was larger than child or there was no parent, we're done:
-					if(node.key<0 || stack.size()==0)
-						break;
-					// otherwise parent was smaller -- try its parent:
-					node = stack.get(0);
-				}
-			
-			return result;
-		}
+        // lastly, make the subtree keys relative to newKey (currently they are relative to this.key):
+        newRight = newRight.withKey((newRight.key + this.key) - newKey);
+        // left is definitely not empty:
+        IntTree<V> newLeft = left.withKey((left.key + this.key) - newKey);
 
-		public void remove() {
-			throw new UnsupportedOperationException(); }
+        return rebalanced(newKey, newValue, newLeft, newRight);
+    }
 
-		// extend the stack to its least non-empty node:
-		private void gotoMinOf(IntTree<V> node) {
-			while(node.size>0) {
-				stack = stack.plus(node);
-				key += node.key;
-				node = node.left;
-			}
-		}
-	}
+    /**
+     * Changes every key k>=key to k+delta.
+     * <p/>
+     * This method will create an _invalid_ tree if delta<0
+     * and the distance between the smallest k>=key in this
+     * and the largest j<key in this is |delta| or less.
+     * <p/>
+     * In other words, this method must not result in any change
+     * in the order of the keys in this, since the tree structure is
+     * not being changed at all.
+     */
+    IntTree<V> changeKeysAbove(long key, int delta) {
+        if (size == 0 || delta == 0)
+            return this;
+
+        if (this.key >= key)
+            // adding delta to this.key changes the keys of _all_ children of this,
+            // so we now need to un-change the children of this smaller than key,
+            // all of which are to the left. note that we still use the 'old' relative key...:
+            return new IntTree<V>(this.key + delta, value, left.changeKeysBelow(key - this.key, -delta), right);
+
+        // otherwise, doesn't apply yet, look to the right:
+        IntTree<V> newRight = right.changeKeysAbove(key - this.key, delta);
+        if (newRight == right) return this;
+        return new IntTree<V>(this.key, value, left, newRight);
+    }
+
+    /**
+     * Changes every key k<key to k+delta.
+     * <p/>
+     * This method will create an _invalid_ tree if delta>0
+     * and the distance between the largest k<key in this
+     * and the smallest j>=key in this is delta or less.
+     * <p/>
+     * In other words, this method must not result in any overlap or change
+     * in the order of the keys in this, since the tree _structure_ is
+     * not being changed at all.
+     */
+    IntTree<V> changeKeysBelow(long key, int delta) {
+        if (size == 0 || delta == 0)
+            return this;
+
+        if (this.key < key)
+            // adding delta to this.key changes the keys of _all_ children of this,
+            // so we now need to un-change the children of this larger than key,
+            // all of which are to the right. note that we still use the 'old' relative key...:
+            return new IntTree<V>(this.key + delta, value, left, right.changeKeysAbove(key - this.key, -delta));
+
+        // otherwise, doesn't apply yet, look to the left:
+        IntTree<V> newLeft = left.changeKeysBelow(key - this.key, delta);
+        if (newLeft == left) return this;
+        return new IntTree<V>(this.key, value, newLeft, right);
+    }
+
+    // min key in this:
+    private long minKey() {
+        if (left.size == 0)
+            return key;
+        // make key 'absolute' (i.e. relative to the parent of this):
+        return left.minKey() + this.key;
+    }
+
+    private IntTree<V> rebalanced(IntTree<V> newLeft, IntTree<V> newRight) {
+        if (newLeft == left && newRight == right)
+            return this; // already balanced
+        return rebalanced(key, value, newLeft, newRight);
+    }
+
+    private static final int OMEGA = 5;
+    private static final int ALPHA = 2;
+
+    // rebalance a tree that is off-balance by at most 1:
+    private static <V> IntTree<V> rebalanced(long key, V value, IntTree<V> left, IntTree<V> right) {
+        if (left.size + right.size > 1) {
+            if (left.size >= OMEGA * right.size) { // rotate to the right
+                IntTree<V> ll = left.left, lr = left.right;
+                if (lr.size < ALPHA * ll.size) // single rotation
+                    return new IntTree<V>(left.key + key, left.value,
+                            ll,
+                            new IntTree<V>(-left.key, value,
+                                    lr.withKey(lr.key + left.key),
+                                    right));
+                else { // double rotation:
+                    IntTree<V> lrl = lr.left, lrr = lr.right;
+                    return new IntTree<V>(lr.key + left.key + key, lr.value,
+                            new IntTree<V>(-lr.key, left.value,
+                                    ll,
+                                    lrl.withKey(lrl.key + lr.key)),
+                            new IntTree<V>(-left.key - lr.key, value,
+                                    lrr.withKey(lrr.key + lr.key + left.key),
+                                    right));
+                }
+            } else if (right.size >= OMEGA * left.size) { // rotate to the left
+                IntTree<V> rl = right.left, rr = right.right;
+                if (rl.size < ALPHA * rr.size) // single rotation
+                    return new IntTree<V>(right.key + key, right.value,
+                            new IntTree<V>(-right.key, value,
+                                    left,
+                                    rl.withKey(rl.key + right.key)),
+                                    rr);
+                else { // double rotation:
+                    IntTree<V> rll = rl.left, rlr = rl.right;
+                    return new IntTree<V>(rl.key + right.key + key, rl.value,
+                            new IntTree<V>(-right.key - rl.key, value,
+                                    left,
+                                    rll.withKey(rll.key + rl.key + right.key)),
+                            new IntTree<V>(-rl.key, right.value,
+                                    rlr.withKey(rlr.key + rl.key),
+                                    rr));
+                }
+            }
+        }
+        // otherwise already balanced enough:
+        return new IntTree<V>(key, value, left, right);
+    }
 }
diff --git a/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/IntTreePMap.java b/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/IntTreePMap.java
index 4c144faf378..169409aee9b 100644
--- a/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/IntTreePMap.java
+++ b/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/IntTreePMap.java
@@ -1,163 +1,52 @@
 package kotlin.reflect.jvm.internal.pcollections;
 
-import java.util.AbstractMap;
-import java.util.AbstractSet;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Set;
-
-
-
-
 /**
- * 
  * An efficient persistent map from integer keys to non-null values.
- * <p>
+ * <p/>
  * Iteration occurs in the integer order of the keys.
- * <p>
- * This implementation is thread-safe (assuming Java's AbstractMap and AbstractSet are thread-safe),
- * although its iterators may not be.
- * <p>
+ * <p/>
+ * This implementation is thread-safe, although its iterators may not be.
+ * <p/>
  * The balanced tree is based on the Glasgow Haskell Compiler's Data.Map implementation,
  * which in turn is based on "size balanced binary trees" as described by:
- * <p>
+ * <p/>
  * Stephen Adams, "Efficient sets: a balancing act",
  * Journal of Functional Programming 3(4):553-562, October 1993,
  * http://www.swiss.ai.mit.edu/~adams/BB/.
- * <p>
+ * <p/>
  * J. Nievergelt and E.M. Reingold, "Binary search trees of bounded balance",
  * SIAM journal of computing 2(1), March 1973.
- * 
- * @author harold
  *
- * @param <V>
+ * @author harold
  */
-public final class IntTreePMap<V> extends AbstractMap<Integer,V> implements PMap<Integer,V> {
-//// STATIC FACTORY METHODS ////
-	private static final IntTreePMap<Object> EMPTY = new IntTreePMap<Object>(IntTree.EMPTYNODE);
+public final class IntTreePMap<V> {
+    private static final IntTreePMap<Object> EMPTY = new IntTreePMap<Object>(IntTree.EMPTYNODE);
 
-	/**
-	 * @param <V>
-	 * @return an empty map
-	 */
-	@SuppressWarnings("unchecked")
-	public static <V> IntTreePMap<V> empty() {
-		return (IntTreePMap<V>)EMPTY; }
-	
-	/**
-	 * @param <V>
-	 * @param key
-	 * @param value
-	 * @return empty().plus(key, value)
-	 */
-	public static <V> IntTreePMap<V> singleton(final Integer key, final V value) {
-		return IntTreePMap.<V>empty().plus(key, value); }
-	
-	/**
-	 * @param <V>
-	 * @param map
-	 * @return empty().plusAll(map)
-	 */
-	@SuppressWarnings("unchecked")
-	public static <V> IntTreePMap<V> from(final Map<? extends Integer, ? extends V> map) {
-		if(map instanceof IntTreePMap)
-			return (IntTreePMap<V>)map; //(actually we only know it's IntTreePMap<? extends V>)
-									// but that's good enough for an immutable
-									// (i.e. we can't mess someone else up by adding the wrong type to it)
-		return IntTreePMap.<V>empty().plusAll(map); }
-	
+    @SuppressWarnings("unchecked")
+    public static <V> IntTreePMap<V> empty() {
+        return (IntTreePMap<V>) EMPTY;
+    }
 
-//// PRIVATE CONSTRUCTORS ////
-	private final IntTree<V> root;
-	// not externally instantiable (or subclassable):
-	private IntTreePMap(final IntTree<V> root) {
-		this.root = root; }
-	private IntTreePMap<V> withRoot(final IntTree<V> root) {
-		if(root==this.root) return this;
-		return new IntTreePMap<V>(root); }
-	
+    private final IntTree<V> root;
 
-//// UNINHERITED METHODS OF IntTreePMap ////
-	IntTreePMap<V> withKeysChangedAbove(final int key, final int delta) {
-		// TODO check preconditions of changeKeysAbove()
-		// TODO make public?
-		return withRoot( root.changeKeysAbove(key, delta) );
-	}
-	
-	IntTreePMap<V> withKeysChangedBelow(final int key, final int delta) {
-		// TODO check preconditions of changeKeysAbove()
-		// TODO make public?
-		return withRoot( root.changeKeysBelow(key, delta) );
-	}
-	
-//// REQUIRED METHODS FROM AbstractMap ////
-	// this cache variable is thread-safe, since assignment in Java is atomic:
-	private Set<Entry<Integer,V>> entrySet = null;
-	@Override
-	public Set<Entry<Integer,V>> entrySet() {
-		if(entrySet==null)
-			entrySet = new AbstractSet<Entry<Integer,V>>() {
-				// REQUIRED METHODS OF AbstractSet // 
-				@Override
-				public int size() { // same as Map
-					return IntTreePMap.this.size(); }
-				@Override
-				public Iterator<Entry<Integer,V>> iterator() {
-					return root.iterator(); }
-				// OVERRIDDEN METHODS OF AbstractSet //
-				@Override
-				public boolean contains(final Object e) {
-					if(!(e instanceof Entry))
-						return false;
-					V value = get(((Entry<?,?>)e).getKey());
-					return value!=null && value.equals(((Entry<?,?>)e).getValue());
-				}
-			};
-		return entrySet;
-	}
+    private IntTreePMap(IntTree<V> root) {
+        this.root = root;
+    }
 
-	
-//// OVERRIDDEN METHODS FROM AbstractMap ////
-	@Override
-	public int size() {
-		return root.size(); }
+    private IntTreePMap<V> withRoot(IntTree<V> root) {
+        if (root == this.root) return this;
+        return new IntTreePMap<V>(root);
+    }
 
-	@Override
-	public boolean containsKey(final Object key) {
-		if(!(key instanceof Integer))
-			return false;
-		return root.containsKey((Integer)key);
-	}
-	
-	@Override
-	public V get(final Object key) {
-		if(!(key instanceof Integer))
-			return null;
-		return root.get((Integer)key);
-	}
+    public V get(int key) {
+        return root.get(key);
+    }
 
-	
-//// IMPLEMENTED METHODS OF PMap////
-	public IntTreePMap<V> plus(final Integer key, final V value) {
-		return withRoot( root.plus(key, value) ); }
-	
-	public IntTreePMap<V> minus(final Object key) {
-		if(!(key instanceof Integer)) return this;
-		return withRoot( root.minus((Integer)key) ); }
-	
-	public IntTreePMap<V> plusAll(final Map<? extends Integer, ? extends V> map) {
-		IntTree<V> root = this.root;
-		for(Entry<? extends Integer,? extends V> entry : map.entrySet())
-			root = root.plus(entry.getKey(), entry.getValue());
-		return withRoot(root);
-	}
+    public IntTreePMap<V> plus(int key, V value) {
+        return withRoot(root.plus(key, value));
+    }
 
-	public IntTreePMap<V> minusAll(final Collection<?> keys) {
-		IntTree<V> root = this.root;
-		for(Object key : keys)
-			if(key instanceof Integer)
-				root = root.minus((Integer)key);
-		return withRoot(root);
-	}
+    public IntTreePMap<V> minus(int key) {
+        return withRoot(root.minus(key));
+    }
 }
diff --git a/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/PCollection.java b/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/PCollection.java
deleted file mode 100644
index 333acc4ca15..00000000000
--- a/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/PCollection.java
+++ /dev/null
@@ -1,47 +0,0 @@
-package kotlin.reflect.jvm.internal.pcollections;
-
-import java.util.Collection;
-
-/**
- * 
- * An immutable, persistent collection of non-null elements of type E.
- * 
- * @author harold
- *
- * @param <E>
- */
-public interface PCollection<E> extends Collection<E> {
-	
-	/**
-	 * @param e non-null
-	 * @return a collection which contains e and all of the elements of this
-	 */
-	public PCollection<E> plus(E e);
-
-	/**
-	 * @param list contains no null elements
-	 * @return a collection which contains all of the elements of list and this
-	 */
-	public PCollection<E> plusAll(Collection<? extends E> list);
-	
-	/**
-	 * @param e
-	 * @return this with a single instance of e removed, if e is in this
-	 */
-	public PCollection<E> minus(Object e);
-	
-	/**
-	 * @param list
-	 * @return this with all elements of list completely removed
-	 */
-	public PCollection<E> minusAll(Collection<?> list);
-	
-	// TODO public PCollection<E> retainingAll(Collection<?> list);
-	
-	@Deprecated boolean add(E o);
-	@Deprecated boolean remove(Object o);
-	@Deprecated boolean addAll(Collection<? extends E> c);
-	@Deprecated boolean removeAll(Collection<?> c);
-	@Deprecated boolean retainAll(Collection<?> c);
-	@Deprecated void clear();
-}
diff --git a/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/PMap.java b/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/PMap.java
index bdfd4f54896..e8e1c2c4217 100644
--- a/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/PMap.java
+++ b/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/PMap.java
@@ -1,45 +1,14 @@
 package kotlin.reflect.jvm.internal.pcollections;
 
-import java.util.Collection;
-import java.util.Map;
-
 /**
- * 
  * An immutable, persistent map from non-null keys of type K to non-null values of type V.
- * 
- * @author harold
  *
- * @param <K>
- * @param <V>
+ * @author harold
  */
-public interface PMap<K,V> extends Map<K,V> {
-	/**
-	 * @param key non-null
-	 * @param value non-null
-	 * @return a map with the mappings of this but with key mapped to value
-	 */
-	public PMap<K,V> plus(K key, V value);
-	
-	/**
-	 * @param map
-	 * @return this combined with map, with map's mappings used for any keys in both map and this
-	 */
-	public PMap<K,V> plusAll(Map<? extends K, ? extends V> map);
-	
-	/**
-	 * @param key
-	 * @return a map with the mappings of this but with no value for key
-	 */
-	public PMap<K,V> minus(Object key);
-	
-	/**
-	 * @param keys
-	 * @return a map with the mappings of this but with no value for any element of keys
-	 */
-	public PMap<K,V> minusAll(Collection<?> keys);
-	
-	@Deprecated V put(K k, V v);
-	@Deprecated V remove(Object k);
-	@Deprecated void putAll(Map<? extends K, ? extends V> m);
-	@Deprecated void clear();
+public interface PMap<K, V> {
+    public PMap<K, V> plus(K key, V value);
+
+    public PMap<K, V> minus(Object key);
+
+    V get(Object key);
 }
diff --git a/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/PSequence.java b/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/PSequence.java
deleted file mode 100644
index 3be82dcec0f..00000000000
--- a/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/PSequence.java
+++ /dev/null
@@ -1,69 +0,0 @@
-package kotlin.reflect.jvm.internal.pcollections;
-
-import java.util.Collection;
-import java.util.List;
-
-/**
- * 
- * An immutable, persistent indexed collection.
- * 
- * @author harold
- *
- * @param <E>
- */
-public interface PSequence<E> extends PCollection<E>, List<E> {
-	
-	//@Override
-	public PSequence<E> plus(E e);
-	
-	//@Override
-	public PSequence<E> plusAll(Collection<? extends E> list);
-	
-	/**
-	 * @param i
-	 * @param e
-	 * @return a sequence consisting of the elements of this with e replacing the element at index i.
-	 * @throws IndexOutOfBOundsException if i&lt;0 || i&gt;=this.size()
-	 */
-	public PSequence<E> with(int i, E e);
-	
-	/**
-	 * @param i
-	 * @param e non-null
-	 * @return a sequence consisting of the elements of this with e inserted at index i.
-	 * @throws IndexOutOfBOundsException if i&lt;0 || i&gt;this.size()
-	 */
-	public PSequence<E> plus(int i, E e);
-	
-	/**
-	 * @param i
-	 * @param list
-	 * @return a sequence consisting of the elements of this with list inserted at index i.
-	 * @throws IndexOutOfBOundsException if i&lt;0 || i&gt;this.size()
-	 */
-	public PSequence<E> plusAll(int i, Collection<? extends E> list);
-	
-	/**
-	 * Returns a sequence consisting of the elements of this without the first occurrence of e.
-	 */
-	//@Override
-	public PSequence<E> minus(Object e);
-	
-	//@Override
-	public PSequence<E> minusAll(Collection<?> list);
-	
-	/**
-	 * @param i
-	 * @return a sequence consisting of the elements of this with the element at index i removed.
-	 * @throws IndexOutOfBOundsException if i&lt;0 || i&gt;=this.size()
-	 */
-	public PSequence<E> minus(int i);
-
-	//@Override
-	public PSequence<E> subList(int start, int end);
-	
-	@Deprecated boolean addAll(int index, Collection<? extends E> c);
-	@Deprecated E set(int index, E element);
-	@Deprecated void add(int index, E element);
-	@Deprecated E remove(int index);
-}
diff --git a/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/PStack.java b/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/PStack.java
index ca68a69360e..5b52152671a 100644
--- a/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/PStack.java
+++ b/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/PStack.java
@@ -1,53 +1,14 @@
 package kotlin.reflect.jvm.internal.pcollections;
 
-import java.util.Collection;
-
 /**
- * 
  * An immutable, persistent stack.
- * 
- * @author harold
  *
- * @param <E>
+ * @author harold
  */
-public interface PStack<E> extends PSequence<E> {
-	
-	/**
-	 * Returns a stack consisting of the elements of this with e prepended.
-	 */
-	//@Override
-	public PStack<E> plus(E e);
-	
-	/**
-	 * Returns a stack consisting of the elements of this with list prepended in reverse.
-	 */
-	//@Override
-	public PStack<E> plusAll(Collection<? extends E> list);
-	
-	//@Override
-	public PStack<E> with(int i, E e);
-	
-	//@Override
-	public PStack<E> plus(int i, E e);
-	
-	//@Override
-	public PStack<E> plusAll(int i, Collection<? extends E> list);
-	
-	//@Override
-	public PStack<E> minus(Object e);
-	
-	//@Override
-	public PStack<E> minusAll(Collection<?> list);
+public interface PStack<E> extends Iterable<E> {
+    PStack<E> plus(E e);
 
-	//@Override
-	public PStack<E> minus(int i);
+    PStack<E> minus(int i);
 
-	//@Override
-	public PStack<E> subList(int start, int end);
-	
-	/**
-	 * @param start
-	 * @return subList(start,this.size())
-	 */
-	public PStack<E> subList(int start);
+    int size();
 }
diff --git a/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/SimpleImmutableEntry.java b/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/SimpleImmutableEntry.java
index 71452649e25..ae79bc2bb6c 100644
--- a/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/SimpleImmutableEntry.java
+++ b/core/runtime.jvm/src/kotlin/reflect/jvm/internal/pcollections/SimpleImmutableEntry.java
@@ -1,12 +1,9 @@
 package kotlin.reflect.jvm.internal.pcollections;
 
 import java.util.Map;
-import java.util.Map.Entry;
-
 
 /**
- * (Taken from Java 6 code, so pcollections can be Java 5-compatible.)
- * <p>
+ * <p/>
  * An Entry maintaining an immutable key and value.  This class
  * does not support method <tt>setValue</tt>.  This class may be
  * convenient in methods that return thread-safe snapshots of
@@ -14,129 +11,119 @@ import java.util.Map.Entry;
  *
  * @since 1.6
  */
-/*public*/ final class SimpleImmutableEntry<K,V>
-	implements Map.Entry<K,V>, java.io.Serializable
-{
-	private static final long serialVersionUID = 7138329143949025153L;
+final class SimpleImmutableEntry<K, V> implements Map.Entry<K, V>, java.io.Serializable {
+    private static final long serialVersionUID = 7138329143949025153L;
 
-	private final K key;
-	private final V value;
+    private final K key;
+    private final V value;
 
-	/**
-	 * Creates an entry representing a mapping from the specified
-	 * key to the specified value.
-	 *
-	 * @param key the key represented by this entry
-	 * @param value the value represented by this entry
-	 */
-	public SimpleImmutableEntry(K key, V value) {
-		this.key   = key;
-		this.value = value;
-	}
+    /**
+     * Creates an entry representing a mapping from the specified
+     * key to the specified value.
+     *
+     * @param key   the key represented by this entry
+     * @param value the value represented by this entry
+     */
+    public SimpleImmutableEntry(K key, V value) {
+        this.key = key;
+        this.value = value;
+    }
 
-	/**
-	 * Creates an entry representing the same mapping as the
-	 * specified entry.
-	 *
-	 * @param entry the entry to copy
-	 */
-	public SimpleImmutableEntry(Entry<? extends K, ? extends V> entry) {
-		this.key   = entry.getKey();
-		this.value = entry.getValue();
-	}
+    /**
+     * Returns the key corresponding to this entry.
+     *
+     * @return the key corresponding to this entry
+     */
+    @Override
+    public K getKey() {
+        return key;
+    }
 
-	/**
-	 * Returns the key corresponding to this entry.
-	 *
-	 * @return the key corresponding to this entry
-	 */
-	public K getKey() {
-		return key;
-	}
+    /**
+     * Returns the value corresponding to this entry.
+     *
+     * @return the value corresponding to this entry
+     */
+    @Override
+    public V getValue() {
+        return value;
+    }
 
-	/**
-	 * Returns the value corresponding to this entry.
-	 *
-	 * @return the value corresponding to this entry
-	 */
-	public V getValue() {
-		return value;
-	}
+    /**
+     * Replaces the value corresponding to this entry with the specified
+     * value (optional operation).  This implementation simply throws
+     * <tt>UnsupportedOperationException</tt>, as this class implements
+     * an <i>immutable</i> map entry.
+     *
+     * @param value new value to be stored in this entry
+     * @return (Does not return)
+     * @throws UnsupportedOperationException always
+     */
+    @Override
+    public V setValue(V value) {
+        throw new UnsupportedOperationException();
+    }
 
-	/**
-	 * Replaces the value corresponding to this entry with the specified
-	 * value (optional operation).  This implementation simply throws
-	 * <tt>UnsupportedOperationException</tt>, as this class implements
-	 * an <i>immutable</i> map entry.
-	 *
-	 * @param value new value to be stored in this entry
-	 * @return (Does not return)
-	 * @throws UnsupportedOperationException always
-	 */
-	public V setValue(V value) {
-		throw new UnsupportedOperationException();
-	}
+    /**
+     * Compares the specified object with this entry for equality.
+     * Returns {@code true} if the given object is also a map entry and
+     * the two entries represent the same mapping.	More formally, two
+     * entries {@code e1} and {@code e2} represent the same mapping
+     * if<pre>
+     *   (e1.getKey()==null ?
+     *    e2.getKey()==null :
+     *    e1.getKey().equals(e2.getKey()))
+     *   &amp;&amp;
+     *   (e1.getValue()==null ?
+     *    e2.getValue()==null :
+     *    e1.getValue().equals(e2.getValue()))</pre>
+     * This ensures that the {@code equals} method works properly across
+     * different implementations of the {@code Map.Entry} interface.
+     *
+     * @param o object to be compared for equality with this map entry
+     * @return {@code true} if the specified object is equal to this map
+     * entry
+     * @see #hashCode
+     */
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof Map.Entry))
+            return false;
+        Map.Entry<?, ?> e = (Map.Entry<?, ?>) o;
+        return eq(key, e.getKey()) && eq(value, e.getValue());
+    }
 
-	/**
-	 * Compares the specified object with this entry for equality.
-	 * Returns {@code true} if the given object is also a map entry and
-	 * the two entries represent the same mapping.	More formally, two
-	 * entries {@code e1} and {@code e2} represent the same mapping
-	 * if<pre>
-	 *   (e1.getKey()==null ?
-	 *    e2.getKey()==null :
-	 *    e1.getKey().equals(e2.getKey()))
-	 *   &amp;&amp;
-	 *   (e1.getValue()==null ?
-	 *    e2.getValue()==null :
-	 *    e1.getValue().equals(e2.getValue()))</pre>
-	 * This ensures that the {@code equals} method works properly across
-	 * different implementations of the {@code Map.Entry} interface.
-	 *
-	 * @param o object to be compared for equality with this map entry
-	 * @return {@code true} if the specified object is equal to this map
-	 *	   entry
-	 * @see    #hashCode
-	 */
-	@Override
-	public boolean equals(Object o) {
-		if (!(o instanceof Map.Entry))
-			return false;
-		Map.Entry<?,?> e = (Map.Entry<?,?>)o;
-		return eq(key, e.getKey()) && eq(value, e.getValue());
-	}
+    /**
+     * Returns the hash code value for this map entry.  The hash code
+     * of a map entry {@code e} is defined to be: <pre>
+     *   (e.getKey()==null   ? 0 : e.getKey().hashCode()) ^
+     *   (e.getValue()==null ? 0 : e.getValue().hashCode())</pre>
+     * This ensures that {@code e1.equals(e2)} implies that
+     * {@code e1.hashCode()==e2.hashCode()} for any two Entries
+     * {@code e1} and {@code e2}, as required by the general
+     * contract of {@link Object#hashCode}.
+     *
+     * @return the hash code value for this map entry
+     * @see #equals
+     */
+    @Override
+    public int hashCode() {
+        return (key == null ? 0 : key.hashCode()) ^
+                (value == null ? 0 : value.hashCode());
+    }
 
-	/**
-	 * Returns the hash code value for this map entry.  The hash code
-	 * of a map entry {@code e} is defined to be: <pre>
-	 *   (e.getKey()==null   ? 0 : e.getKey().hashCode()) ^
-	 *   (e.getValue()==null ? 0 : e.getValue().hashCode())</pre>
-	 * This ensures that {@code e1.equals(e2)} implies that
-	 * {@code e1.hashCode()==e2.hashCode()} for any two Entries
-	 * {@code e1} and {@code e2}, as required by the general
-	 * contract of {@link Object#hashCode}.
-	 *
-	 * @return the hash code value for this map entry
-	 * @see    #equals
-	 */
-	@Override
-	public int hashCode() {
-		return (key   == null ? 0 :   key.hashCode()) ^
-		(value == null ? 0 : value.hashCode());
-	}
-
-	/**
-	 * Returns a String representation of this map entry.  This
-	 * implementation returns the string representation of this
-	 * entry's key followed by the equals character ("<tt>=</tt>")
-	 * followed by the string representation of this entry's value.
-	 *
-	 * @return a String representation of this map entry
-	 */
-	@Override
-	public String toString() {
-		return key + "=" + value;
-	}
+    /**
+     * Returns a String representation of this map entry.  This
+     * implementation returns the string representation of this
+     * entry's key followed by the equals character ("<tt>=</tt>")
+     * followed by the string representation of this entry's value.
+     *
+     * @return a String representation of this map entry
+     */
+    @Override
+    public String toString() {
+        return key + "=" + value;
+    }
 
     /**
      * Utility method for SimpleEntry and SimpleImmutableEntry.