diff --git a/de.peeeq.wurstscript/src/main/java/de/peeeq/datastructures/Graph.java b/de.peeeq.wurstscript/src/main/java/de/peeeq/datastructures/Graph.java
deleted file mode 100644
index deb4ef115..000000000
--- a/de.peeeq.wurstscript/src/main/java/de/peeeq/datastructures/Graph.java
+++ /dev/null
@@ -1,26 +0,0 @@
-package de.peeeq.datastructures;
-
-import java.util.List;
-import java.util.function.Function;
-
-/**
- *
- */
-public class Graph<Node> {
-    private final List<Node> nodes;
-    private final Function<Node, List<Node>> edges;
-
-    public Graph(List<Node> nodes, Function<Node, List<Node>> edges) {
-        this.nodes = nodes;
-        this.edges = edges;
-    }
-
-    public List<Node> getNodes() {
-        return nodes;
-    }
-
-    public List<Node> adjacentNodes(Node n) {
-        return edges.apply(n);
-    }
-
-}
diff --git a/de.peeeq.wurstscript/src/main/java/de/peeeq/datastructures/ImmutableTree.java b/de.peeeq.wurstscript/src/main/java/de/peeeq/datastructures/ImmutableTree.java
deleted file mode 100644
index 63008db27..000000000
--- a/de.peeeq.wurstscript/src/main/java/de/peeeq/datastructures/ImmutableTree.java
+++ /dev/null
@@ -1,147 +0,0 @@
-package de.peeeq.datastructures;
-
-import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableList.Builder;
-import org.eclipse.jdt.annotation.Nullable;
-
-import java.util.Collections;
-import java.util.Iterator;
-
-public class ImmutableTree<T> implements Iterable<ImmutableTree<T>> {
-
-    // invariant: children == null <--> elem != null
-    private final @Nullable ImmutableList<ImmutableTree<T>> children;
-    private final @Nullable T elem;
-
-    private ImmutableTree(@Nullable ImmutableList<ImmutableTree<T>> children, @Nullable T elem) {
-        Preconditions.checkArgument((children == null) != (elem == null));
-        this.children = children;
-        this.elem = elem;
-    }
-
-    public static <T> ImmutableTree<T> node(ImmutableList<ImmutableTree<T>> children) {
-        return new ImmutableTree<>(children, null);
-    }
-
-    public static <T> ImmutableTree<T> leaf(T t) {
-        return new ImmutableTree<>(null, t);
-    }
-
-    public int size() {
-        ImmutableList<ImmutableTree<T>> ch = children;
-        if (ch == null) {
-            return 1;
-        } else {
-            int size = 0;
-            for (ImmutableTree<T> c : ch) {
-                size += c.size();
-            }
-            return size;
-        }
-    }
-
-
-    @Override
-    public Iterator<ImmutableTree<T>> iterator() {
-        final ImmutableList<ImmutableTree<T>> children2 = children;
-        if (children2 != null) {
-            return children2.iterator();
-        } else {
-            return Collections.emptyIterator();
-        }
-    }
-
-    public ImmutableList<T> allValues() {
-        Builder<T> b = ImmutableList.builder();
-        addValues(b);
-        return b.build();
-    }
-
-    private void addValues(Builder<@Nullable T> b) {
-        ImmutableList<ImmutableTree<T>> ch = children;
-        if (ch == null) {
-            b.add(elem);
-        } else {
-            for (ImmutableTree<T> c : ch) {
-                c.addValues(b);
-            }
-        }
-    }
-
-    public static <T> ImmutableTree<T> empty() {
-        return node(ImmutableList.of());
-    }
-
-    @Override
-    public int hashCode() {
-        final int prime = 31;
-        int result = 1;
-        ImmutableList<ImmutableTree<T>> c = children;
-        @Nullable T e = elem;
-        result = prime * result + ((c == null) ? 0 : c.hashCode());
-        result = prime * result + ((e == null) ? 0 : e.hashCode());
-        return result;
-    }
-
-    @Override
-    public boolean equals(@Nullable Object obj) {
-        if (this == obj)
-            return true;
-        if (obj == null)
-            return false;
-        if (getClass() != obj.getClass())
-            return false;
-        ImmutableTree<?> other = (ImmutableTree<?>) obj;
-        ImmutableList<ImmutableTree<T>> c = children;
-        if (c == null) {
-            if (other.children != null)
-                return false;
-        } else if (!c.equals(other.children))
-            return false;
-        @Nullable T e = elem;
-        if (e == null) {
-            return other.elem == null;
-        } else return e.equals(other.elem);
-    }
-
-    @Override
-    public String toString() {
-        StringBuilder sb = new StringBuilder();
-        ImmutableList<ImmutableTree<T>> c = children;
-        if (c == null) {
-            sb.append("[");
-            sb.append(elem);
-            sb.append("]");
-        } else {
-            sb.append("[");
-            boolean first = true;
-            for (ImmutableTree<T> t : c) {
-                if (!first) {
-                    sb.append(", ");
-                }
-                sb.append(t);
-                first = false;
-            }
-            sb.append("]");
-        }
-        return sb.toString();
-    }
-
-    public T getOnlyEment() {
-        ImmutableList<ImmutableTree<T>> ch = children;
-        @Nullable T el = elem;
-        if (el != null) {
-            return el;
-        } else if (ch != null && !ch.isEmpty()) {
-            return ch.get(0).getOnlyEment();
-        }
-        throw new RuntimeException("There are " + size() + " elements in this tree.");
-    }
-
-    public boolean isLeaf() {
-        return children == null;
-    }
-
-
-}
diff --git a/de.peeeq.wurstscript/src/main/java/de/peeeq/datastructures/IntTuple.java b/de.peeeq.wurstscript/src/main/java/de/peeeq/datastructures/IntTuple.java
deleted file mode 100644
index fb1bd7441..000000000
--- a/de.peeeq.wurstscript/src/main/java/de/peeeq/datastructures/IntTuple.java
+++ /dev/null
@@ -1,55 +0,0 @@
-package de.peeeq.datastructures;
-
-import org.eclipse.jdt.annotation.Nullable;
-
-import java.util.Arrays;
-
-public class IntTuple {
-    private final int[] ar;
-
-    private IntTuple(int len) {
-        ar = new int[len];
-    }
-
-    public static IntTuple of(int... is) {
-        IntTuple r = new IntTuple(is.length);
-        System.arraycopy(is, 0, r.ar, 0, is.length);
-        return r;
-    }
-
-
-    public int head() {
-        return ar[0];
-    }
-
-    public IntTuple tail() {
-        IntTuple r = new IntTuple(ar.length - 1);
-        System.arraycopy(ar, 1, r.ar, 0, ar.length - 1);
-        return r;
-    }
-
-
-    @Override
-    public String toString() {
-        return Arrays.toString(ar);
-    }
-
-    @Override
-    public int hashCode() {
-        return Arrays.hashCode(ar);
-    }
-
-    @Override
-    public boolean equals(@Nullable Object obj) {
-        if (this == obj)
-            return true;
-        if (obj == null)
-            return false;
-        if (getClass() != obj.getClass())
-            return false;
-        IntTuple other = (IntTuple) obj;
-        return Arrays.equals(ar, other.ar);
-    }
-
-
-}
diff --git a/de.peeeq.wurstscript/src/main/java/de/peeeq/immutablecollections/ImmutableList.java b/de.peeeq.wurstscript/src/main/java/de/peeeq/immutablecollections/ImmutableList.java
index 5fd71d212..b906944c9 100644
--- a/de.peeeq.wurstscript/src/main/java/de/peeeq/immutablecollections/ImmutableList.java
+++ b/de.peeeq.wurstscript/src/main/java/de/peeeq/immutablecollections/ImmutableList.java
@@ -1,40 +1,62 @@
 package de.peeeq.immutablecollections;
 
-import com.google.common.base.Preconditions;
+import io.vavr.collection.List;
 import org.eclipse.jdt.annotation.Nullable;
 
-import java.util.Arrays;
 import java.util.Iterator;
-import java.util.NoSuchElementException;
+import java.util.Objects;
 
-public abstract class ImmutableList<T> implements Iterable<T> {
+/**
+ * Lightweight wrapper around {@link List} to keep the existing API surface
+ * while using Vavr's efficient persistent list implementation.
+ */
+public final class ImmutableList<T> implements Iterable<T> {
 
-    private int hashCode = 0;
+    private static final ImmutableList<?> EMPTY = new ImmutableList<>(List.empty());
+
+    private final List<T> delegate;
+
+    private ImmutableList(List<T> delegate) {
+        this.delegate = delegate;
+    }
 
     /**
      * adds an element to the front of the list
      */
-    abstract public ImmutableList<T> appFront(T elem);
+    public ImmutableList<T> appFront(T elem) {
+        Objects.requireNonNull(elem, "elem");
+        return wrap(delegate.prepend(elem));
+    }
 
     /**
      * adds another ImmutableList to the end
      */
-    abstract public <R extends T> ImmutableList<T> cons(ImmutableList<R> other);
-
-    abstract public T head();
+    public <R extends T> ImmutableList<T> cons(ImmutableList<R> other) {
+        if (other.isEmpty()) {
+            return this;
+        }
+        return wrap(delegate.appendAll(other.delegate));
+    }
 
-    abstract public ImmutableList<T> tail();
+    public T head() {
+        return delegate.head();
+    }
 
+    public ImmutableList<T> tail() {
+        return wrap(delegate.tail());
+    }
 
-    abstract public int size();
+    public int size() {
+        return delegate.size();
+    }
 
     public boolean isEmpty() {
-        return size() == 0;
+        return delegate.isEmpty();
     }
 
     public boolean contains(T elem) {
         for (T t : this) {
-            if (t.equals(elem)) {
+            if (Objects.equals(t, elem)) {
                 return true;
             }
         }
@@ -44,324 +66,64 @@ public boolean contains(T elem) {
     /**
      * @return an empty list
      */
+    @SuppressWarnings("unchecked")
     public static <T> ImmutableList<T> emptyList() {
-        return ImmutableListEmpty.instance();
+        return (ImmutableList<T>) EMPTY;
     }
 
     @SafeVarargs
     public static <T> ImmutableList<T> of(T... elems) {
-        ImmutableList<T> result = emptyList();
+        List<T> list = List.empty();
         for (int i = elems.length - 1; i >= 0; i--) {
-            T elem = elems[i];
-            if (elem == null) {
-                throw new IllegalArgumentException("Elem " + i + " is null.");
-            }
-            result = result.appFront(elem);
+            T elem = Objects.requireNonNull(elems[i], "Elem " + i + " is null.");
+            list = list.prepend(elem);
         }
-        return result;
+        return wrap(list);
     }
 
-
     @Override
     public String toString() {
-        StringBuilder sb = new StringBuilder();
-        sb.append("List(");
-        boolean first = true;
-        for (T t : this) {
-            if (!first) {
-                sb.append(", ");
-            }
-            sb.append(t);
-            first = false;
-        }
-        sb.append(")");
-        return sb.toString();
+        return delegate.mkString("List(", ", ", ")");
     }
 
     @Override
     public int hashCode() {
-        if (hashCode == 0) {
-            Object[] elements = new Object[size()];
-            int i = 0;
-            for (T t : this) {
-                elements[i] = t;
-                i++;
-            }
-            hashCode = Arrays.hashCode(elements);
-        }
-        return hashCode;
+        return delegate.hashCode();
     }
 
     @Override
     public boolean equals(@Nullable Object obj) {
-        if (obj instanceof ImmutableList) {
-            ImmutableList<?> other = (ImmutableList<?>) obj;
-            if (other.size() != size() || other.hashCode() != hashCode()) {
-                return false;
-            }
-            if (size() == 0) {
-                return true;
-            }
-            if (!other.head().equals(head())) {
-                return false;
-            }
-            if (size() > 1) {
-                return other.tail().equals(tail());
-            } else {
-                return true;
-            }
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof ImmutableList<?> other) {
+            return delegate.equals(other.delegate);
         }
         return false;
     }
 
     public ImmutableList<T> appBack(T elem) {
-        return this.cons(ImmutableList.<T>emptyList().appFront(elem));
-    }
-
-    public abstract ImmutableList<T> removeAll(T t);
-}
-
-
-class ImmutableListEmpty<T> extends ImmutableList<T> {
-
-    private final static ImmutableList<Object> instance = new ImmutableListEmpty<>();
-
-    @SuppressWarnings("unchecked")
-    static <T> ImmutableList<T> instance() {
-        return (ImmutableList<T>) instance;
-    }
-
-    private ImmutableListEmpty() {
-
+        Objects.requireNonNull(elem, "elem");
+        return wrap(delegate.append(elem));
     }
 
-    private static class MyIterator<T> implements Iterator<T> {
-
-        @Override
-        public boolean hasNext() {
-            return false;
-        }
-
-        @Override
-        public T next() {
-            throw new NoSuchElementException();
-        }
-
-        @Override
-        public void remove() {
-            throw new UnsupportedOperationException();
-        }
-
-    }
-
-    @Override
-    public Iterator<T> iterator() {
-        return new ImmutableListEmpty.MyIterator<>();
-    }
-
-    @Override
-    public ImmutableList<T> appFront(T elem) {
-        Preconditions.checkNotNull(elem);
-        return new ImmutableListImpl<>(elem);
-    }
-
-    @Override
-    public int size() {
-        return 0;
-    }
-
-    @Override
-    public T head() {
-        throw new Error("Tried to get head of empty list");
-    }
-
-    @Override
-    public ImmutableList<T> tail() {
-        throw new Error("Tried to get tail of empty list");
-    }
-
-
-    @Override
-    public <R extends T> ImmutableList<T> cons(ImmutableList<R> other) {
-        // just return other since this list is empty
-        @SuppressWarnings("unchecked") // this is safe because the list is immutable
-                ImmutableList<T> result = (ImmutableList<T>) other;
-        return result;
-    }
-
-    @Override
     public ImmutableList<T> removeAll(T t) {
-        return this;
-    }
-
-}
-
-
-class ImmutableListIterator<T> implements Iterator<T> {
-    private @Nullable ImmutableList<T> pos;
-
-    public ImmutableListIterator(ImmutableList<T> list) {
-        this.pos = list;
-    }
-
-    @Override
-    public boolean hasNext() {
-        ImmutableList<T> p = pos;
-        return p != null && !p.isEmpty();
-    }
-
-    @Override
-    public T next() {
-        ImmutableList<T> p = pos;
-        if (p == null || p.isEmpty()) {
-            pos = null;
-            throw new RuntimeException("Calling next on finished iterator.");
-        } else {
-            T res = p.head();
-            pos = p.tail();
-            return res;
-        }
-    }
-
-    @Override
-    public void remove() {
-        throw new UnsupportedOperationException();
-    }
-
-}
-
-class ImmutableListImpl<T> extends ImmutableList<T> {
-
-
-    private final T head;
-    private final ImmutableList<T> tail;
-    private final int size;
-
-    ImmutableListImpl(T elem) {
-        this.head = elem;
-        this.tail = ImmutableList.emptyList();
-        this.size = 1;
-    }
-
-    ImmutableListImpl(T head, ImmutableList<T> tail) {
-        this.head = head;
-        this.tail = tail;
-        this.size = 1 + tail.size();
-    }
-
-
-    @Override
-    public Iterator<T> iterator() {
-        return new ImmutableListIterator<>(this);
-    }
-
-    @Override
-    public ImmutableList<T> appFront(T elem) {
-        Preconditions.checkNotNull(elem);
-        return new ImmutableListImpl<>(elem, this);
-    }
-
-    @Override
-    public int size() {
-        return size;
-    }
-
-    @Override
-    public T head() {
-        return head;
-    }
-
-    @Override
-    public ImmutableList<T> tail() {
-        return tail;
-    }
-
-    @Override
-    public <R extends T> ImmutableList<T> cons(ImmutableList<R> other) {
-        if (other.isEmpty()) {
+        List<T> filtered = delegate.filter(e -> !Objects.equals(e, t));
+        if (filtered == delegate) {
             return this;
-        } else {
-            return new ImmutableListImplCons<>(this, other);
         }
-    }
-
-    @Override
-    public ImmutableList<T> removeAll(T t) {
-        if (head.equals(t)) {
-            return tail.removeAll(t);
-        } else {
-            return tail.removeAll(t).appFront(head);
-        }
-    }
-
-}
-
-class ImmutableListImplCons<T, L extends T, R extends T> extends ImmutableList<T> {
-
-
-    // invariant: size(left) > 0 && size(right) > 0
-
-    private final ImmutableList<L> left;
-    private final ImmutableList<R> right;
-    private final int size;
-
-    ImmutableListImplCons(ImmutableList<L> left, ImmutableList<R> right) {
-        if (left.size() == 0) throw new IllegalArgumentException("left list is empty");
-        if (right.size() == 0) throw new IllegalArgumentException("right list is empty");
-        this.left = left;
-        this.right = right;
-        this.size = left.size() + right.size();
+        return wrap(filtered);
     }
 
     @Override
     public Iterator<T> iterator() {
-        return new ImmutableListIterator<>(this);
-    }
-
-    @Override
-    public ImmutableList<T> appFront(T elem) {
-        Preconditions.checkNotNull(elem);
-        return new ImmutableListImpl<>(elem, this);
-    }
-
-    @Override
-    public <R2 extends T> ImmutableList<T> cons(ImmutableList<R2> other) {
-        if (other.isEmpty()) {
-            return this;
-        } else {
-            return new ImmutableListImplCons<>(this, other);
-        }
-    }
-
-    @Override
-    public T head() {
-        return left.head();
+        return delegate.iterator();
     }
 
-    @SuppressWarnings("unchecked")
-    @Override
-    public ImmutableList<T> tail() {
-        ImmutableList<T> leftTail = (ImmutableList<T>) left.tail();
-        if (leftTail.isEmpty()) {
-            return (ImmutableList<T>) right;
+    private static <T> ImmutableList<T> wrap(List<T> list) {
+        if (list.isEmpty()) {
+            return emptyList();
         }
-        return new ImmutableListImplCons<>(leftTail, right);
+        return new ImmutableList<>(list);
     }
-
-    @Override
-    public int size() {
-        return size;
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public ImmutableList<T> removeAll(T t) {
-        ImmutableList<L> l = left.removeAll((L) t);
-        ImmutableList<R> r = right.removeAll((R) t);
-        if (left == l && right == r) {
-            return this;
-        }
-        return ((ImmutableList<T>) l).cons(r);
-    }
-
 }
diff --git a/de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/intermediatelang/ILconstMultiArray.java b/de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/intermediatelang/ILconstMultiArray.java
index caefd26e6..19e670264 100644
--- a/de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/intermediatelang/ILconstMultiArray.java
+++ b/de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/intermediatelang/ILconstMultiArray.java
@@ -1,14 +1,15 @@
 package de.peeeq.wurstscript.intermediatelang;
 
-import com.google.common.collect.Maps;
-import de.peeeq.datastructures.IntTuple;
+import it.unimi.dsi.fastutil.ints.IntArrayList;
+import it.unimi.dsi.fastutil.ints.IntList;
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
 
-import java.util.Map;
+import java.util.Arrays;
 
 
 public class ILconstMultiArray extends ILconstAbstract {
 
-    private final Map<IntTuple, ILconst> contents = Maps.newHashMap();
+    private final Object2ObjectOpenHashMap<IntList, ILconst> contents = new Object2ObjectOpenHashMap<>();
 
 
     @Override
@@ -21,12 +22,28 @@ public String print() {
         return contents.toString();
     }
 
-    public ILconst get(IntTuple key) {
+    public ILconst get(IntList key) {
         return contents.get(key);
     }
 
-    public void set(IntTuple key, ILconst val) {
-        contents.put(key, val);
+    public ILconst get(int... key) {
+        return contents.get(copyKey(key));
+    }
+
+    public void set(IntList key, ILconst val) {
+        contents.put(copyKey(key), val);
+    }
+
+    public void set(ILconst val, int... key) {
+        contents.put(copyKey(key), val);
+    }
+
+    private static IntArrayList copyKey(IntList key) {
+        return new IntArrayList(key);
+    }
+
+    private static IntArrayList copyKey(int... key) {
+        return IntArrayList.wrap(Arrays.copyOf(key, key.length));
     }
 
 }