Split GUI code to separate module (#242)

* Split into modules

* Post merge compile fixes

Co-authored-by: modmuss50 <modmuss50@gmail.com>

34 files changed, 0 insertions, 3103 deletions

diff --git a/src/main/java/cuchaz/enigma/translation/mapping/AccessModifier.java b/src/main/java/cuchaz/enigma/translation/mapping/AccessModifier.java
deleted file mode 100644
index 5b79b79..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/AccessModifier.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package cuchaz.enigma.translation.mapping;
-
-import cuchaz.enigma.translation.representation.AccessFlags;
-
-public enum AccessModifier {
-        UNCHANGED, PUBLIC, PROTECTED, PRIVATE;
-
-        public String getFormattedName() {
-                return "ACC:" + super.toString();
-        }
-
-        public AccessFlags transform(AccessFlags access) {
-                switch (this) {
-                        case PUBLIC:
-                                return access.setPublic();
-                        case PROTECTED:
-                                return access.setProtected();
-                        case PRIVATE:
-                                return access.setPrivate();
-                        case UNCHANGED:
-                        default:
-                                return access;
-                }
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/EntryMap.java b/src/main/java/cuchaz/enigma/translation/mapping/EntryMap.java
deleted file mode 100644
index e1a3253..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/EntryMap.java
+++ /dev/null
@@ -1,24 +0,0 @@
-package cuchaz.enigma.translation.mapping;
-
-import cuchaz.enigma.translation.representation.entry.Entry;
-
-import javax.annotation.Nullable;
-import java.util.stream.Stream;
-
-public interface EntryMap<T> {
-        void insert(Entry<?> entry, T value);
-
-        @Nullable
-        T remove(Entry<?> entry);
-
-        @Nullable
-        T get(Entry<?> entry);
-
-        default boolean contains(Entry<?> entry) {
-                return get(entry) != null;
-        }
-
-        Stream<Entry<?>> getAllEntries();
-
-        boolean isEmpty();
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/EntryMapping.java b/src/main/java/cuchaz/enigma/translation/mapping/EntryMapping.java
deleted file mode 100644
index c607817..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/EntryMapping.java
+++ /dev/null
@@ -1,75 +0,0 @@
-package cuchaz.enigma.translation.mapping;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-
-public class EntryMapping {
-        private final String targetName;
-        private final AccessModifier accessModifier;
-        private final @Nullable String javadoc;
-
-        public EntryMapping(@Nonnull String targetName) {
-                this(targetName, AccessModifier.UNCHANGED);
-        }
-
-        public EntryMapping(@Nonnull String targetName, @Nullable String javadoc) {
-                this(targetName, AccessModifier.UNCHANGED, javadoc);
-        }
-
-        public EntryMapping(@Nonnull String targetName, AccessModifier accessModifier) {
-                this(targetName, accessModifier, null);
-        }
-
-        public EntryMapping(@Nonnull String targetName, AccessModifier accessModifier, @Nullable String javadoc) {
-                this.targetName = targetName;
-                this.accessModifier = accessModifier;
-                this.javadoc = javadoc;
-        }
-
-        @Nonnull
-        public String getTargetName() {
-                return targetName;
-        }
-
-        @Nonnull
-        public AccessModifier getAccessModifier() {
-                if (accessModifier == null) {
-                        return AccessModifier.UNCHANGED;
-                }
-                return accessModifier;
-        }
-
-        @Nullable
-        public String getJavadoc() {
-                return javadoc;
-        }
-
-        public EntryMapping withName(String newName) {
-                return new EntryMapping(newName, accessModifier, javadoc);
-        }
-
-        public EntryMapping withModifier(AccessModifier newModifier) {
-                return new EntryMapping(targetName, newModifier, javadoc);
-        }
-
-        public EntryMapping withDocs(String newDocs) {
-                return new EntryMapping(targetName, accessModifier, newDocs);
-        }
-
-        @Override
-        public boolean equals(Object obj) {
-                if (obj == this) return true;
-
-                if (obj instanceof EntryMapping) {
-                        EntryMapping mapping = (EntryMapping) obj;
-                        return mapping.targetName.equals(targetName) && mapping.accessModifier.equals(accessModifier);
-                }
-
-                return false;
-        }
-
-        @Override
-        public int hashCode() {
-                return targetName.hashCode() + accessModifier.hashCode() * 31;
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/EntryRemapper.java b/src/main/java/cuchaz/enigma/translation/mapping/EntryRemapper.java
deleted file mode 100644
index ad36c97..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/EntryRemapper.java
+++ /dev/null
@@ -1,105 +0,0 @@
-package cuchaz.enigma.translation.mapping;
-
-import cuchaz.enigma.analysis.index.JarIndex;
-import cuchaz.enigma.translation.MappingTranslator;
-import cuchaz.enigma.translation.Translatable;
-import cuchaz.enigma.translation.Translator;
-import cuchaz.enigma.translation.mapping.tree.DeltaTrackingTree;
-import cuchaz.enigma.translation.mapping.tree.EntryTree;
-import cuchaz.enigma.translation.mapping.tree.HashEntryTree;
-import cuchaz.enigma.translation.representation.entry.Entry;
-
-import javax.annotation.Nullable;
-import java.util.Collection;
-import java.util.function.UnaryOperator;
-import java.util.stream.Stream;
-
-public class EntryRemapper {
-        private final DeltaTrackingTree<EntryMapping> obfToDeobf;
-
-        private final EntryResolver obfResolver;
-        private final Translator deobfuscator;
-
-        private final MappingValidator validator;
-
-        private EntryRemapper(JarIndex jarIndex, EntryTree<EntryMapping> obfToDeobf) {
-                this.obfToDeobf = new DeltaTrackingTree<>(obfToDeobf);
-
-                this.obfResolver = jarIndex.getEntryResolver();
-
-                this.deobfuscator = new MappingTranslator(obfToDeobf, obfResolver);
-
-                this.validator = new MappingValidator(obfToDeobf, deobfuscator, jarIndex);
-        }
-
-        public static EntryRemapper mapped(JarIndex index, EntryTree<EntryMapping> obfToDeobf) {
-                return new EntryRemapper(index, obfToDeobf);
-        }
-
-        public static EntryRemapper empty(JarIndex index) {
-                return new EntryRemapper(index, new HashEntryTree<>());
-        }
-
-        public <E extends Entry<?>> void mapFromObf(E obfuscatedEntry, @Nullable EntryMapping deobfMapping) {
-                mapFromObf(obfuscatedEntry, deobfMapping, true);
-        }
-
-        public <E extends Entry<?>> void mapFromObf(E obfuscatedEntry, @Nullable EntryMapping deobfMapping, boolean renaming) {
-                Collection<E> resolvedEntries = obfResolver.resolveEntry(obfuscatedEntry, renaming ? ResolutionStrategy.RESOLVE_ROOT : ResolutionStrategy.RESOLVE_CLOSEST);
-
-                if (renaming && deobfMapping != null) {
-                        for (E resolvedEntry : resolvedEntries) {
-                                validator.validateRename(resolvedEntry, deobfMapping.getTargetName());
-                        }
-                }
-
-                for (E resolvedEntry : resolvedEntries) {
-                        obfToDeobf.insert(resolvedEntry, deobfMapping);
-                }
-        }
-
-        public void removeByObf(Entry<?> obfuscatedEntry) {
-                mapFromObf(obfuscatedEntry, null);
-        }
-
-        @Nullable
-        public EntryMapping getDeobfMapping(Entry<?> entry) {
-                return obfToDeobf.get(entry);
-        }
-
-        public boolean hasDeobfMapping(Entry<?> obfEntry) {
-                return obfToDeobf.contains(obfEntry);
-        }
-
-        public <T extends Translatable> T deobfuscate(T translatable) {
-                return deobfuscator.translate(translatable);
-        }
-
-        public Translator getDeobfuscator() {
-                return deobfuscator;
-        }
-
-        public Stream<Entry<?>> getObfEntries() {
-                return obfToDeobf.getAllEntries();
-        }
-
-        public Collection<Entry<?>> getObfChildren(Entry<?> obfuscatedEntry) {
-                return obfToDeobf.getChildren(obfuscatedEntry);
-        }
-
-        public DeltaTrackingTree<EntryMapping> getObfToDeobf() {
-                return obfToDeobf;
-        }
-
-        public MappingDelta<EntryMapping> takeMappingDelta() {
-                return obfToDeobf.takeDelta();
-        }
-
-        public boolean isDirty() {
-                return obfToDeobf.isDirty();
-        }
-
-        public EntryResolver getObfResolver() {
-                return obfResolver;
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/EntryResolver.java b/src/main/java/cuchaz/enigma/translation/mapping/EntryResolver.java
deleted file mode 100644
index 521f72d..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/EntryResolver.java
+++ /dev/null
@@ -1,41 +0,0 @@
-package cuchaz.enigma.translation.mapping;
-
-import com.google.common.collect.Streams;
-import cuchaz.enigma.analysis.EntryReference;
-import cuchaz.enigma.translation.representation.entry.Entry;
-import cuchaz.enigma.translation.representation.entry.MethodEntry;
-
-import java.util.Collection;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-public interface EntryResolver {
-        <E extends Entry<?>> Collection<E> resolveEntry(E entry, ResolutionStrategy strategy);
-
-        default <E extends Entry<?>> E resolveFirstEntry(E entry, ResolutionStrategy strategy) {
-                return resolveEntry(entry, strategy).stream().findFirst().orElse(entry);
-        }
-
-        default <E extends Entry<?>, C extends Entry<?>> Collection<EntryReference<E, C>> resolveReference(EntryReference<E, C> reference, ResolutionStrategy strategy) {
-                Collection<E> entry = resolveEntry(reference.entry, strategy);
-                if (reference.context != null) {
-                        Collection<C> context = resolveEntry(reference.context, strategy);
-                        return Streams.zip(entry.stream(), context.stream(), (e, c) -> new EntryReference<>(e, c, reference))
-                                        .collect(Collectors.toList());
-                } else {
-                        return entry.stream()
-                                        .map(e -> new EntryReference<>(e, null, reference))
-                                        .collect(Collectors.toList());
-                }
-        }
-
-        default <E extends Entry<?>, C extends Entry<?>> EntryReference<E, C> resolveFirstReference(EntryReference<E, C> reference, ResolutionStrategy strategy) {
-                E entry = resolveFirstEntry(reference.entry, strategy);
-                C context = resolveFirstEntry(reference.context, strategy);
-                return new EntryReference<>(entry, context, reference);
-        }
-
-        Set<Entry<?>> resolveEquivalentEntries(Entry<?> entry);
-
-        Set<MethodEntry> resolveEquivalentMethods(MethodEntry methodEntry);
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/IndexEntryResolver.java b/src/main/java/cuchaz/enigma/translation/mapping/IndexEntryResolver.java
deleted file mode 100644
index 78231dd..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/IndexEntryResolver.java
+++ /dev/null
@@ -1,227 +0,0 @@
-package cuchaz.enigma.translation.mapping;
-
-import com.google.common.collect.Sets;
-import cuchaz.enigma.analysis.IndexTreeBuilder;
-import cuchaz.enigma.analysis.MethodImplementationsTreeNode;
-import cuchaz.enigma.analysis.MethodInheritanceTreeNode;
-import cuchaz.enigma.analysis.index.BridgeMethodIndex;
-import cuchaz.enigma.analysis.index.EntryIndex;
-import cuchaz.enigma.analysis.index.InheritanceIndex;
-import cuchaz.enigma.analysis.index.JarIndex;
-import cuchaz.enigma.translation.VoidTranslator;
-import cuchaz.enigma.translation.representation.AccessFlags;
-import cuchaz.enigma.translation.representation.entry.ClassEntry;
-import cuchaz.enigma.translation.representation.entry.Entry;
-import cuchaz.enigma.translation.representation.entry.MethodEntry;
-
-import javax.annotation.Nullable;
-import java.util.*;
-import java.util.stream.Collectors;
-
-public class IndexEntryResolver implements EntryResolver {
-        private final EntryIndex entryIndex;
-        private final InheritanceIndex inheritanceIndex;
-        private final BridgeMethodIndex bridgeMethodIndex;
-
-        private final IndexTreeBuilder treeBuilder;
-
-        public IndexEntryResolver(JarIndex index) {
-                this.entryIndex = index.getEntryIndex();
-                this.inheritanceIndex = index.getInheritanceIndex();
-                this.bridgeMethodIndex = index.getBridgeMethodIndex();
-
-                this.treeBuilder = new IndexTreeBuilder(index);
-        }
-
-        @Override
-        @SuppressWarnings("unchecked")
-        public <E extends Entry<?>> Collection<E> resolveEntry(E entry, ResolutionStrategy strategy) {
-                if (entry == null) {
-                        return Collections.emptySet();
-                }
-
-                Entry<ClassEntry> classChild = getClassChild(entry);
-                if (classChild != null && !(classChild instanceof ClassEntry)) {
-                        AccessFlags access = entryIndex.getEntryAccess(classChild);
-
-                        // If we're looking for the closest and this entry exists, we're done looking
-                        if (strategy == ResolutionStrategy.RESOLVE_CLOSEST && access != null) {
-                                return Collections.singleton(entry);
-                        }
-
-                        if (access == null || !access.isPrivate()) {
-                                Collection<Entry<ClassEntry>> resolvedChildren = resolveChildEntry(classChild, strategy);
-                                if (!resolvedChildren.isEmpty()) {
-                                        return resolvedChildren.stream()
-                                                        .map(resolvedChild -> (E) entry.replaceAncestor(classChild, resolvedChild))
-                                                        .collect(Collectors.toList());
-                                }
-                        }
-                }
-
-                return Collections.singleton(entry);
-        }
-
-        @Nullable
-        private Entry<ClassEntry> getClassChild(Entry<?> entry) {
-                if (entry instanceof ClassEntry) {
-                        return null;
-                }
-
-                // get the entry in the hierarchy that is the child of a class
-                List<Entry<?>> ancestry = entry.getAncestry();
-                for (int i = ancestry.size() - 1; i > 0; i--) {
-                        Entry<?> child = ancestry.get(i);
-                        Entry<ClassEntry> cast = child.castParent(ClassEntry.class);
-                        if (cast != null && !(cast instanceof ClassEntry)) {
-                                // we found the entry which is a child of a class, we are now able to resolve the owner of this entry
-                                return cast;
-                        }
-                }
-
-                return null;
-        }
-
-        private Set<Entry<ClassEntry>> resolveChildEntry(Entry<ClassEntry> entry, ResolutionStrategy strategy) {
-                ClassEntry ownerClass = entry.getParent();
-
-                if (entry instanceof MethodEntry) {
-                        MethodEntry bridgeMethod = bridgeMethodIndex.getBridgeFromSpecialized((MethodEntry) entry);
-                        if (bridgeMethod != null && ownerClass.equals(bridgeMethod.getParent())) {
-                                Set<Entry<ClassEntry>> resolvedBridge = resolveChildEntry(bridgeMethod, strategy);
-                                if (!resolvedBridge.isEmpty()) {
-                                        return resolvedBridge;
-                                } else {
-                                        return Collections.singleton(bridgeMethod);
-                                }
-                        }
-                }
-
-                Set<Entry<ClassEntry>> resolvedEntries = new HashSet<>();
-
-                for (ClassEntry parentClass : inheritanceIndex.getParents(ownerClass)) {
-                        Entry<ClassEntry> parentEntry = entry.withParent(parentClass);
-
-                        if (strategy == ResolutionStrategy.RESOLVE_ROOT) {
-                                resolvedEntries.addAll(resolveRoot(parentEntry, strategy));
-                        } else {
-                                resolvedEntries.addAll(resolveClosest(parentEntry, strategy));
-                        }
-                }
-
-                return resolvedEntries;
-        }
-
-        private Collection<Entry<ClassEntry>> resolveRoot(Entry<ClassEntry> entry, ResolutionStrategy strategy) {
-                // When resolving root, we want to first look for the lowest entry before returning ourselves
-                Set<Entry<ClassEntry>> parentResolution = resolveChildEntry(entry, strategy);
-
-                if (parentResolution.isEmpty()) {
-                        AccessFlags parentAccess = entryIndex.getEntryAccess(entry);
-                        if (parentAccess != null && !parentAccess.isPrivate()) {
-                                return Collections.singleton(entry);
-                        }
-                }
-
-                return parentResolution;
-        }
-
-        private Collection<Entry<ClassEntry>> resolveClosest(Entry<ClassEntry> entry, ResolutionStrategy strategy) {
-                // When resolving closest, we want to first check if we exist before looking further down
-                AccessFlags parentAccess = entryIndex.getEntryAccess(entry);
-                if (parentAccess != null && !parentAccess.isPrivate()) {
-                        return Collections.singleton(entry);
-                } else {
-                        return resolveChildEntry(entry, strategy);
-                }
-        }
-
-        @Override
-        public Set<Entry<?>> resolveEquivalentEntries(Entry<?> entry) {
-                MethodEntry relevantMethod = entry.findAncestor(MethodEntry.class);
-                if (relevantMethod == null || !entryIndex.hasMethod(relevantMethod)) {
-                        return Collections.singleton(entry);
-                }
-
-                Set<MethodEntry> equivalentMethods = resolveEquivalentMethods(relevantMethod);
-                Set<Entry<?>> equivalentEntries = new HashSet<>(equivalentMethods.size());
-
-                for (MethodEntry equivalentMethod : equivalentMethods) {
-                        Entry<?> equivalentEntry = entry.replaceAncestor(relevantMethod, equivalentMethod);
-                        equivalentEntries.add(equivalentEntry);
-                }
-
-                return equivalentEntries;
-        }
-
-        @Override
-        public Set<MethodEntry> resolveEquivalentMethods(MethodEntry methodEntry) {
-                AccessFlags access = entryIndex.getMethodAccess(methodEntry);
-                if (access == null) {
-                        throw new IllegalArgumentException("Could not find method " + methodEntry);
-                }
-
-                if (!canInherit(methodEntry, access)) {
-                        return Collections.singleton(methodEntry);
-                }
-
-                Set<MethodEntry> methodEntries = Sets.newHashSet();
-                resolveEquivalentMethods(methodEntries, treeBuilder.buildMethodInheritance(VoidTranslator.INSTANCE, methodEntry));
-                return methodEntries;
-        }
-
-        private void resolveEquivalentMethods(Set<MethodEntry> methodEntries, MethodInheritanceTreeNode node) {
-                MethodEntry methodEntry = node.getMethodEntry();
-                if (methodEntries.contains(methodEntry)) {
-                        return;
-                }
-
-                AccessFlags flags = entryIndex.getMethodAccess(methodEntry);
-                if (flags != null && canInherit(methodEntry, flags)) {
-                        // collect the entry
-                        methodEntries.add(methodEntry);
-                }
-
-                // look at bridge methods!
-                MethodEntry bridgedMethod = bridgeMethodIndex.getBridgeFromSpecialized(methodEntry);
-                while (bridgedMethod != null) {
-                        methodEntries.addAll(resolveEquivalentMethods(bridgedMethod));
-                        bridgedMethod = bridgeMethodIndex.getBridgeFromSpecialized(bridgedMethod);
-                }
-
-                // look at interface methods too
-                for (MethodImplementationsTreeNode implementationsNode : treeBuilder.buildMethodImplementations(VoidTranslator.INSTANCE, methodEntry)) {
-                        resolveEquivalentMethods(methodEntries, implementationsNode);
-                }
-
-                // recurse
-                for (int i = 0; i < node.getChildCount(); i++) {
-                        resolveEquivalentMethods(methodEntries, (MethodInheritanceTreeNode) node.getChildAt(i));
-                }
-        }
-
-        private void resolveEquivalentMethods(Set<MethodEntry> methodEntries, MethodImplementationsTreeNode node) {
-                MethodEntry methodEntry = node.getMethodEntry();
-                AccessFlags flags = entryIndex.getMethodAccess(methodEntry);
-                if (flags != null && !flags.isPrivate() && !flags.isStatic()) {
-                        // collect the entry
-                        methodEntries.add(methodEntry);
-                }
-
-                // look at bridge methods!
-                MethodEntry bridgedMethod = bridgeMethodIndex.getBridgeFromSpecialized(methodEntry);
-                while (bridgedMethod != null) {
-                        methodEntries.addAll(resolveEquivalentMethods(bridgedMethod));
-                        bridgedMethod = bridgeMethodIndex.getBridgeFromSpecialized(bridgedMethod);
-                }
-
-                // recurse
-                for (int i = 0; i < node.getChildCount(); i++) {
-                        resolveEquivalentMethods(methodEntries, (MethodImplementationsTreeNode) node.getChildAt(i));
-                }
-        }
-
-        private boolean canInherit(MethodEntry entry, AccessFlags access) {
-                return !entry.isConstructor() && !access.isPrivate() && !access.isStatic() && !access.isFinal();
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/MappingDelta.java b/src/main/java/cuchaz/enigma/translation/mapping/MappingDelta.java
deleted file mode 100644
index 1407bb6..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/MappingDelta.java
+++ /dev/null
@@ -1,54 +0,0 @@
-package cuchaz.enigma.translation.mapping;
-
-import cuchaz.enigma.translation.Translatable;
-import cuchaz.enigma.translation.Translator;
-import cuchaz.enigma.translation.mapping.tree.EntryTree;
-import cuchaz.enigma.translation.mapping.tree.EntryTreeNode;
-import cuchaz.enigma.translation.mapping.tree.HashEntryTree;
-import cuchaz.enigma.translation.representation.entry.Entry;
-
-import java.util.stream.Stream;
-
-public class MappingDelta<T> implements Translatable {
-        public static final Object PLACEHOLDER = new Object();
-
-        private final EntryTree<T> baseMappings;
-
-        private final EntryTree<Object> changes;
-
-        public MappingDelta(EntryTree<T> baseMappings, EntryTree<Object> changes) {
-                this.baseMappings = baseMappings;
-                this.changes = changes;
-        }
-
-        public MappingDelta(EntryTree<T> baseMappings) {
-                this(baseMappings, new HashEntryTree<>());
-        }
-
-        public static <T> MappingDelta<T> added(EntryTree<T> mappings) {
-                EntryTree<Object> changes = new HashEntryTree<>();
-                mappings.getAllEntries().forEach(entry -> changes.insert(entry, PLACEHOLDER));
-
-                return new MappingDelta<>(new HashEntryTree<>(), changes);
-        }
-
-        public EntryTree<T> getBaseMappings() {
-                return baseMappings;
-        }
-
-        public EntryTree<?> getChanges() {
-                return changes;
-        }
-
-        public Stream<Entry<?>> getChangedRoots() {
-                return changes.getRootNodes().map(EntryTreeNode::getEntry);
-        }
-
-        @Override
-        public MappingDelta<T> translate(Translator translator, EntryResolver resolver, EntryMap<EntryMapping> mappings) {
-                return new MappingDelta<>(
-                                translator.translate(baseMappings),
-                                translator.translate(changes)
-                );
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/MappingFileNameFormat.java b/src/main/java/cuchaz/enigma/translation/mapping/MappingFileNameFormat.java
deleted file mode 100644
index e40bfe7..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/MappingFileNameFormat.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package cuchaz.enigma.translation.mapping;
-
-import com.google.gson.annotations.SerializedName;
-
-public enum MappingFileNameFormat {
-        @SerializedName("by_obf")
-        BY_OBF,
-        @SerializedName("by_deobf")
-        BY_DEOBF
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/MappingPair.java b/src/main/java/cuchaz/enigma/translation/mapping/MappingPair.java
deleted file mode 100644
index 5d39e3d..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/MappingPair.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package cuchaz.enigma.translation.mapping;
-
-import cuchaz.enigma.translation.representation.entry.Entry;
-
-import javax.annotation.Nullable;
-
-public class MappingPair<E extends Entry<?>, M> {
-        private final E entry;
-        private M mapping;
-
-        public MappingPair(E entry, @Nullable M mapping) {
-                this.entry = entry;
-                this.mapping = mapping;
-        }
-
-        public MappingPair(E entry) {
-                this(entry, null);
-        }
-
-        public E getEntry() {
-                return entry;
-        }
-
-        @Nullable
-        public M getMapping() {
-                return mapping;
-        }
-
-        public void setMapping(M mapping) {
-                this.mapping = mapping;
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/MappingSaveParameters.java b/src/main/java/cuchaz/enigma/translation/mapping/MappingSaveParameters.java
deleted file mode 100644
index 07065d6..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/MappingSaveParameters.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package cuchaz.enigma.translation.mapping;
-
-import com.google.gson.annotations.SerializedName;
-
-public class MappingSaveParameters {
-        @SerializedName("file_name_format")
-        private final MappingFileNameFormat fileNameFormat;
-
-        public MappingSaveParameters(MappingFileNameFormat fileNameFormat) {
-                this.fileNameFormat = fileNameFormat;
-        }
-
-        public MappingFileNameFormat getFileNameFormat() {
-                return fileNameFormat;
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/MappingValidator.java b/src/main/java/cuchaz/enigma/translation/mapping/MappingValidator.java
deleted file mode 100644
index dffcb0c..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/MappingValidator.java
+++ /dev/null
@@ -1,76 +0,0 @@
-package cuchaz.enigma.translation.mapping;
-
-import cuchaz.enigma.analysis.index.InheritanceIndex;
-import cuchaz.enigma.analysis.index.JarIndex;
-import cuchaz.enigma.throwables.IllegalNameException;
-import cuchaz.enigma.translation.Translator;
-import cuchaz.enigma.translation.mapping.tree.EntryTree;
-import cuchaz.enigma.translation.representation.entry.ClassEntry;
-import cuchaz.enigma.translation.representation.entry.Entry;
-
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.stream.Collectors;
-
-public class MappingValidator {
-        private final EntryTree<EntryMapping> obfToDeobf;
-        private final Translator deobfuscator;
-        private final JarIndex index;
-
-        public MappingValidator(EntryTree<EntryMapping> obfToDeobf, Translator deobfuscator, JarIndex index) {
-                this.obfToDeobf = obfToDeobf;
-                this.deobfuscator = deobfuscator;
-                this.index = index;
-        }
-
-        public void validateRename(Entry<?> entry, String name) throws IllegalNameException {
-                Collection<Entry<?>> equivalentEntries = index.getEntryResolver().resolveEquivalentEntries(entry);
-                for (Entry<?> equivalentEntry : equivalentEntries) {
-                        equivalentEntry.validateName(name);
-                        validateUnique(equivalentEntry, name);
-                }
-        }
-
-        private void validateUnique(Entry<?> entry, String name) {
-                ClassEntry containingClass = entry.getContainingClass();
-                Collection<ClassEntry> relatedClasses = getRelatedClasses(containingClass);
-
-                for (ClassEntry relatedClass : relatedClasses) {
-                        Entry<?> relatedEntry = entry.replaceAncestor(containingClass, relatedClass);
-                        Entry<?> translatedEntry = deobfuscator.translate(relatedEntry);
-
-                        Collection<Entry<?>> translatedSiblings = obfToDeobf.getSiblings(relatedEntry).stream()
-                                        .map(deobfuscator::translate)
-                                        .collect(Collectors.toList());
-
-                        if (!isUnique(translatedEntry, translatedSiblings, name)) {
-                                Entry<?> parent = translatedEntry.getParent();
-                                if (parent != null) {
-                                        throw new IllegalNameException(name, "Name is not unique in " + parent + "!");
-                                } else {
-                                        throw new IllegalNameException(name, "Name is not unique!");
-                                }
-                        }
-                }
-        }
-
-        private Collection<ClassEntry> getRelatedClasses(ClassEntry classEntry) {
-                InheritanceIndex inheritanceIndex = index.getInheritanceIndex();
-
-                Collection<ClassEntry> relatedClasses = new HashSet<>();
-                relatedClasses.add(classEntry);
-                relatedClasses.addAll(inheritanceIndex.getChildren(classEntry));
-                relatedClasses.addAll(inheritanceIndex.getAncestors(classEntry));
-
-                return relatedClasses;
-        }
-
-        private boolean isUnique(Entry<?> entry, Collection<Entry<?>> siblings, String name) {
-                for (Entry<?> sibling : siblings) {
-                        if (entry.canConflictWith(sibling) && sibling.getName().equals(name)) {
-                                return false;
-                        }
-                }
-                return true;
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/MappingsChecker.java b/src/main/java/cuchaz/enigma/translation/mapping/MappingsChecker.java
deleted file mode 100644
index 5d9794f..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/MappingsChecker.java
+++ /dev/null
@@ -1,99 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2015 Jeff Martin.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Lesser General Public
- * License v3.0 which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/lgpl.html
- * <p>
- * Contributors:
- * Jeff Martin - initial API and implementation
- ******************************************************************************/
-
-package cuchaz.enigma.translation.mapping;
-
-import cuchaz.enigma.ProgressListener;
-import cuchaz.enigma.analysis.index.JarIndex;
-import cuchaz.enigma.translation.mapping.tree.EntryTree;
-import cuchaz.enigma.translation.mapping.tree.EntryTreeNode;
-import cuchaz.enigma.translation.representation.entry.ClassEntry;
-import cuchaz.enigma.translation.representation.entry.Entry;
-import cuchaz.enigma.translation.representation.entry.FieldEntry;
-import cuchaz.enigma.translation.representation.entry.LocalVariableEntry;
-import cuchaz.enigma.translation.representation.entry.MethodEntry;
-
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.stream.Collectors;
-
-public class MappingsChecker {
-        private final JarIndex index;
-        private final EntryTree<EntryMapping> mappings;
-
-        public MappingsChecker(JarIndex index, EntryTree<EntryMapping> mappings) {
-                this.index = index;
-                this.mappings = mappings;
-        }
-
-        public Dropped dropBrokenMappings(ProgressListener progress) {
-                Dropped dropped = new Dropped();
-
-                Collection<Entry<?>> obfEntries = mappings.getAllEntries()
-                                .filter(e -> e instanceof ClassEntry || e instanceof MethodEntry || e instanceof FieldEntry || e instanceof LocalVariableEntry)
-                                .collect(Collectors.toList());
-
-                progress.init(obfEntries.size(), "Checking for dropped mappings");
-
-                int steps = 0;
-                for (Entry<?> entry : obfEntries) {
-                        progress.step(steps++, entry.toString());
-                        tryDropEntry(dropped, entry);
-                }
-
-                dropped.apply(mappings);
-
-                return dropped;
-        }
-
-        private void tryDropEntry(Dropped dropped, Entry<?> entry) {
-                if (shouldDropEntry(entry)) {
-                        EntryMapping mapping = mappings.get(entry);
-                        if (mapping != null) {
-                                dropped.drop(entry, mapping);
-                        }
-                }
-        }
-
-        private boolean shouldDropEntry(Entry<?> entry) {
-                if (!index.getEntryIndex().hasEntry(entry)) {
-                        return true;
-                }
-                Collection<Entry<?>> resolvedEntries = index.getEntryResolver().resolveEntry(entry, ResolutionStrategy.RESOLVE_ROOT);
-                return !resolvedEntries.contains(entry);
-        }
-
-        public static class Dropped {
-                private final Map<Entry<?>, String> droppedMappings = new HashMap<>();
-
-                public void drop(Entry<?> entry, EntryMapping mapping) {
-                        droppedMappings.put(entry, mapping.getTargetName());
-                }
-
-                void apply(EntryTree<EntryMapping> mappings) {
-                        for (Entry<?> entry : droppedMappings.keySet()) {
-                                EntryTreeNode<EntryMapping> node = mappings.findNode(entry);
-                                if (node == null) {
-                                        continue;
-                                }
-
-                                for (Entry<?> childEntry : node.getChildrenRecursively()) {
-                                        mappings.remove(childEntry);
-                                }
-                        }
-                }
-
-                public Map<Entry<?>, String> getDroppedMappings() {
-                        return droppedMappings;
-                }
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/NameValidator.java b/src/main/java/cuchaz/enigma/translation/mapping/NameValidator.java
deleted file mode 100644
index 5bc2f67..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/NameValidator.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2015 Jeff Martin.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Lesser General Public
- * License v3.0 which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/lgpl.html
- * <p>
- * Contributors:
- * Jeff Martin - initial API and implementation
- ******************************************************************************/
-
-package cuchaz.enigma.translation.mapping;
-
-import cuchaz.enigma.throwables.IllegalNameException;
-import cuchaz.enigma.translation.representation.entry.ClassEntry;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.regex.Pattern;
-
-public class NameValidator {
-        private static final Pattern IDENTIFIER_PATTERN;
-        private static final Pattern CLASS_PATTERN;
-        private static final List<String> ILLEGAL_IDENTIFIERS = Arrays.asList(
-                        "abstract", "continue", "for", "new", "switch", "assert", "default", "goto", "package", "synchronized",
-                        "boolean", "do", "if", "private", "this", "break", "double", "implements", "protected", "throw", "byte",
-                        "else", "import", "public", "throws", "case", "enum", "instanceof", "return", "transient", "catch",
-                        "extends", "int", "short", "try", "char", "final", "interface", "static", "void", "class", "finally",
-                        "long", "strictfp", "volatile", "const", "float", "native", "super", "while", "_"
-        );
-
-        static {
-                String identifierRegex = "[A-Za-z_<][A-Za-z0-9_>]*";
-                IDENTIFIER_PATTERN = Pattern.compile(identifierRegex);
-                CLASS_PATTERN = Pattern.compile(String.format("^(%s(\\.|/))*(%s)$", identifierRegex, identifierRegex));
-        }
-
-        public static void validateClassName(String name) {
-                if (!CLASS_PATTERN.matcher(name).matches() || ILLEGAL_IDENTIFIERS.contains(name)) {
-                        throw new IllegalNameException(name, "This doesn't look like a legal class name");
-                }
-        }
-
-        public static void validateIdentifier(String name) {
-                if (!IDENTIFIER_PATTERN.matcher(name).matches() || ILLEGAL_IDENTIFIERS.contains(name)) {
-                        throw new IllegalNameException(name, "This doesn't look like a legal identifier");
-                }
-        }
-
-        public static boolean isReserved(String name) {
-                return ILLEGAL_IDENTIFIERS.contains(name);
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/ResolutionStrategy.java b/src/main/java/cuchaz/enigma/translation/mapping/ResolutionStrategy.java
deleted file mode 100644
index 1c28e02..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/ResolutionStrategy.java
+++ /dev/null
@@ -1,6 +0,0 @@
-package cuchaz.enigma.translation.mapping;
-
-public enum ResolutionStrategy {
-        RESOLVE_ROOT,
-        RESOLVE_CLOSEST
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/VoidEntryResolver.java b/src/main/java/cuchaz/enigma/translation/mapping/VoidEntryResolver.java
deleted file mode 100644
index 2eab55f..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/VoidEntryResolver.java
+++ /dev/null
@@ -1,27 +0,0 @@
-package cuchaz.enigma.translation.mapping;
-
-import cuchaz.enigma.translation.representation.entry.Entry;
-import cuchaz.enigma.translation.representation.entry.MethodEntry;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Set;
-
-public enum VoidEntryResolver implements EntryResolver {
-        INSTANCE;
-
-        @Override
-        public <E extends Entry<?>> Collection<E> resolveEntry(E entry, ResolutionStrategy strategy) {
-                return Collections.singleton(entry);
-        }
-
-        @Override
-        public Set<Entry<?>> resolveEquivalentEntries(Entry<?> entry) {
-                return Collections.singleton(entry);
-        }
-
-        @Override
-        public Set<MethodEntry> resolveEquivalentMethods(MethodEntry methodEntry) {
-                return Collections.singleton(methodEntry);
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/EnigmaFormat.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/EnigmaFormat.java
deleted file mode 100644
index af92ffb..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/serde/EnigmaFormat.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package cuchaz.enigma.translation.mapping.serde;
-
-public class EnigmaFormat {
-        public static final String COMMENT = "COMMENT";
-        public static final String CLASS = "CLASS";
-        public static final String FIELD = "FIELD";
-        public static final String METHOD = "METHOD";
-        public static final String PARAMETER = "ARG";
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/EnigmaMappingsReader.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/EnigmaMappingsReader.java
deleted file mode 100644
index 53bbaa3..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/serde/EnigmaMappingsReader.java
+++ /dev/null
@@ -1,319 +0,0 @@
-package cuchaz.enigma.translation.mapping.serde;
-
-import com.google.common.base.Charsets;
-import cuchaz.enigma.ProgressListener;
-import cuchaz.enigma.throwables.MappingParseException;
-import cuchaz.enigma.translation.mapping.AccessModifier;
-import cuchaz.enigma.translation.mapping.EntryMapping;
-import cuchaz.enigma.translation.mapping.MappingPair;
-import cuchaz.enigma.translation.mapping.MappingSaveParameters;
-import cuchaz.enigma.translation.mapping.tree.EntryTree;
-import cuchaz.enigma.translation.mapping.tree.HashEntryTree;
-import cuchaz.enigma.translation.representation.MethodDescriptor;
-import cuchaz.enigma.translation.representation.TypeDescriptor;
-import cuchaz.enigma.translation.representation.entry.*;
-import cuchaz.enigma.utils.I18n;
-
-import javax.annotation.Nullable;
-import java.io.IOException;
-import java.nio.file.FileSystem;
-import java.nio.file.FileSystems;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.ArrayDeque;
-import java.util.Arrays;
-import java.util.Deque;
-import java.util.List;
-import java.util.Locale;
-import java.util.stream.Collectors;
-
-public enum EnigmaMappingsReader implements MappingsReader {
-        FILE {
-                @Override
-                public EntryTree<EntryMapping> read(Path path, ProgressListener progress, MappingSaveParameters saveParameters) throws IOException, MappingParseException {
-                        progress.init(1, I18n.translate("progress.mappings.enigma_file.loading"));
-
-                        EntryTree<EntryMapping> mappings = new HashEntryTree<>();
-                        readFile(path, mappings);
-
-                        progress.step(1, I18n.translate("progress.mappings.enigma_file.done"));
-
-                        return mappings;
-                }
-        },
-        DIRECTORY {
-                @Override
-                public EntryTree<EntryMapping> read(Path root, ProgressListener progress, MappingSaveParameters saveParameters) throws IOException, MappingParseException {
-                        EntryTree<EntryMapping> mappings = new HashEntryTree<>();
-
-                        List<Path> files = Files.walk(root)
-                                        .filter(f -> !Files.isDirectory(f))
-                                        .filter(f -> f.toString().endsWith(".mapping"))
-                                        .collect(Collectors.toList());
-
-                        progress.init(files.size(), I18n.translate("progress.mappings.enigma_directory.loading"));
-                        int step = 0;
-
-                        for (Path file : files) {
-                                progress.step(step++, root.relativize(file).toString());
-                                if (Files.isHidden(file)) {
-                                        continue;
-                                }
-                                readFile(file, mappings);
-                        }
-
-                        return mappings;
-                }
-        },
-        ZIP {
-                @Override
-                public EntryTree<EntryMapping> read(Path zip, ProgressListener progress, MappingSaveParameters saveParameters) throws MappingParseException, IOException {
-                        try (FileSystem fs = FileSystems.newFileSystem(zip, (ClassLoader) null)) {
-                                return DIRECTORY.read(fs.getPath("/"), progress, saveParameters);
-                        }
-                }
-        };
-
-        protected void readFile(Path path, EntryTree<EntryMapping> mappings) throws IOException, MappingParseException {
-                List<String> lines = Files.readAllLines(path, Charsets.UTF_8);
-                Deque<MappingPair<?, RawEntryMapping>> mappingStack = new ArrayDeque<>();
-
-                for (int lineNumber = 0; lineNumber < lines.size(); lineNumber++) {
-                        String line = lines.get(lineNumber);
-                        int indentation = countIndentation(line);
-
-                        line = formatLine(line);
-                        if (line == null) {
-                                continue;
-                        }
-
-                        cleanMappingStack(indentation, mappingStack, mappings);
-
-                        try {
-                                MappingPair<?, RawEntryMapping> pair = parseLine(mappingStack.peek(), line);
-                                if (pair != null) {
-                                        mappingStack.push(pair);
-                                        if (pair.getMapping() != null) {
-
-                                        }
-                                }
-                        } catch (Throwable t) {
-                                t.printStackTrace();
-                                throw new MappingParseException(path::toString, lineNumber, t.toString());
-                        }
-                }
-
-                // Clean up rest
-                cleanMappingStack(0, mappingStack, mappings);
-        }
-
-        private void cleanMappingStack(int indentation, Deque<MappingPair<?, RawEntryMapping>> mappingStack, EntryTree<EntryMapping> mappings) {
-                while (indentation < mappingStack.size()) {
-                        MappingPair<?, RawEntryMapping> pair = mappingStack.pop();
-                        if (pair.getMapping() != null) {
-                                mappings.insert(pair.getEntry(), pair.getMapping().bake());
-                        }
-                }
-        }
-
-        @Nullable
-        private String formatLine(String line) {
-                line = stripComment(line);
-                line = line.trim();
-
-                if (line.isEmpty()) {
-                        return null;
-                }
-
-                return line;
-        }
-
-        private String stripComment(String line) {
-                //Dont support comments on javadoc lines
-                if (line.trim().startsWith(EnigmaFormat.COMMENT)) {
-                        return line;
-                }
-
-                int commentPos = line.indexOf('#');
-                if (commentPos >= 0) {
-                        return line.substring(0, commentPos);
-                }
-                return line;
-        }
-
-        private int countIndentation(String line) {
-                int indent = 0;
-                for (int i = 0; i < line.length(); i++) {
-                        if (line.charAt(i) != '\t') {
-                                break;
-                        }
-                        indent++;
-                }
-                return indent;
-        }
-
-        private MappingPair<?, RawEntryMapping> parseLine(@Nullable MappingPair<?, RawEntryMapping> parent, String line) {
-                String[] tokens = line.trim().split("\\s");
-                String keyToken = tokens[0].toUpperCase(Locale.ROOT);
-                Entry<?> parentEntry = parent == null ? null : parent.getEntry();
-
-                switch (keyToken) {
-                        case EnigmaFormat.CLASS:
-                                return parseClass(parentEntry, tokens);
-                        case EnigmaFormat.FIELD:
-                                return parseField(parentEntry, tokens);
-                        case EnigmaFormat.METHOD:
-                                return parseMethod(parentEntry, tokens);
-                        case EnigmaFormat.PARAMETER:
-                                return parseArgument(parentEntry, tokens);
-                        case EnigmaFormat.COMMENT:
-                                readJavadoc(parent, tokens);
-                                return null;
-                        default:
-                                throw new RuntimeException("Unknown token '" + keyToken + "'");
-                }
-        }
-        
-        private void readJavadoc(MappingPair<?, RawEntryMapping> parent, String[] tokens) {
-                if (parent == null)
-                        throw new IllegalStateException("Javadoc has no parent!");
-                // Empty string to concat
-                String jdLine = tokens.length > 1 ? String.join(" ", Arrays.copyOfRange(tokens,1,tokens.length))  : "";
-                if (parent.getMapping() == null) {
-                        parent.setMapping(new RawEntryMapping(parent.getEntry().getName(), AccessModifier.UNCHANGED));
-                }
-                parent.getMapping().addJavadocLine(MappingHelper.unescape(jdLine));
-        }
-
-        private MappingPair<ClassEntry, RawEntryMapping> parseClass(@Nullable Entry<?> parent, String[] tokens) {
-                String obfuscatedName = ClassEntry.getInnerName(tokens[1]);
-                ClassEntry obfuscatedEntry;
-                if (parent instanceof ClassEntry) {
-                        obfuscatedEntry = new ClassEntry((ClassEntry) parent, obfuscatedName);
-                } else {
-                        obfuscatedEntry = new ClassEntry(obfuscatedName);
-                }
-
-                String mapping = null;
-                AccessModifier modifier = AccessModifier.UNCHANGED;
-
-                if (tokens.length == 3) {
-                        AccessModifier parsedModifier = parseModifier(tokens[2]);
-                        if (parsedModifier != null) {
-                                modifier = parsedModifier;
-                                mapping = obfuscatedName;
-                        } else {
-                                mapping = tokens[2];
-                        }
-                } else if (tokens.length == 4) {
-                        mapping = tokens[2];
-                        modifier = parseModifier(tokens[3]);
-                }
-
-                if (mapping != null) {
-                        return new MappingPair<>(obfuscatedEntry, new RawEntryMapping(mapping, modifier));
-                } else {
-                        return new MappingPair<>(obfuscatedEntry);
-                }
-        }
-
-        private MappingPair<FieldEntry, RawEntryMapping> parseField(@Nullable Entry<?> parent, String[] tokens) {
-                if (!(parent instanceof ClassEntry)) {
-                        throw new RuntimeException("Field must be a child of a class!");
-                }
-
-                ClassEntry ownerEntry = (ClassEntry) parent;
-
-                String obfuscatedName = tokens[1];
-                String mapping = obfuscatedName;
-                AccessModifier modifier = AccessModifier.UNCHANGED;
-                TypeDescriptor descriptor;
-
-                if (tokens.length == 3) {
-                        mapping = tokens[1];
-                        descriptor = new TypeDescriptor(tokens[2]);
-                } else if (tokens.length == 4) {
-                        AccessModifier parsedModifier = parseModifier(tokens[3]);
-                        if (parsedModifier != null) {
-                                descriptor = new TypeDescriptor(tokens[2]);
-                                modifier = parsedModifier;
-                        } else {
-                                mapping = tokens[2];
-                                descriptor = new TypeDescriptor(tokens[3]);
-                        }
-                } else if (tokens.length == 5) {
-                        descriptor = new TypeDescriptor(tokens[3]);
-                        mapping = tokens[2];
-                        modifier = parseModifier(tokens[4]);
-                } else {
-                        throw new RuntimeException("Invalid field declaration");
-                }
-
-                FieldEntry obfuscatedEntry = new FieldEntry(ownerEntry, obfuscatedName, descriptor);
-                if (mapping != null) {
-                        return new MappingPair<>(obfuscatedEntry, new RawEntryMapping(mapping, modifier));
-                } else {
-                        return new MappingPair<>(obfuscatedEntry);
-                }
-        }
-
-        private MappingPair<MethodEntry, RawEntryMapping> parseMethod(@Nullable Entry<?> parent, String[] tokens) {
-                if (!(parent instanceof ClassEntry)) {
-                        throw new RuntimeException("Method must be a child of a class!");
-                }
-
-                ClassEntry ownerEntry = (ClassEntry) parent;
-
-                String obfuscatedName = tokens[1];
-                String mapping = null;
-                AccessModifier modifier = AccessModifier.UNCHANGED;
-                MethodDescriptor descriptor;
-
-                if (tokens.length == 3) {
-                        descriptor = new MethodDescriptor(tokens[2]);
-                } else if (tokens.length == 4) {
-                        AccessModifier parsedModifier = parseModifier(tokens[3]);
-                        if (parsedModifier != null) {
-                                modifier = parsedModifier;
-                                mapping = obfuscatedName;
-                                descriptor = new MethodDescriptor(tokens[2]);
-                        } else {
-                                mapping = tokens[2];
-                                descriptor = new MethodDescriptor(tokens[3]);
-                        }
-                } else if (tokens.length == 5) {
-                        mapping = tokens[2];
-                        modifier = parseModifier(tokens[4]);
-                        descriptor = new MethodDescriptor(tokens[3]);
-                } else {
-                        throw new RuntimeException("Invalid method declaration");
-                }
-
-                MethodEntry obfuscatedEntry = new MethodEntry(ownerEntry, obfuscatedName, descriptor);
-                if (mapping != null) {
-                        return new MappingPair<>(obfuscatedEntry, new RawEntryMapping(mapping, modifier));
-                } else {
-                        return new MappingPair<>(obfuscatedEntry);
-                }
-        }
-
-        private MappingPair<LocalVariableEntry, RawEntryMapping> parseArgument(@Nullable Entry<?> parent, String[] tokens) {
-                if (!(parent instanceof MethodEntry)) {
-                        throw new RuntimeException("Method arg must be a child of a method!");
-                }
-
-                MethodEntry ownerEntry = (MethodEntry) parent;
-                LocalVariableEntry obfuscatedEntry = new LocalVariableEntry(ownerEntry, Integer.parseInt(tokens[1]), "", true, null);
-                String mapping = tokens[2];
-
-                return new MappingPair<>(obfuscatedEntry, new RawEntryMapping(mapping));
-        }
-
-        @Nullable
-        private AccessModifier parseModifier(String token) {
-                if (token.startsWith("ACC:")) {
-                        return AccessModifier.valueOf(token.substring(4));
-                }
-                return null;
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/EnigmaMappingsWriter.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/EnigmaMappingsWriter.java
deleted file mode 100644
index be0fceb..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/serde/EnigmaMappingsWriter.java
+++ /dev/null
@@ -1,316 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2015 Jeff Martin.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Lesser General Public
- * License v3.0 which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/lgpl.html
- *
- * Contributors:
- *     Jeff Martin - initial API and implementation
- ******************************************************************************/
-
-package cuchaz.enigma.translation.mapping.serde;
-
-import java.io.IOException;
-import java.io.PrintWriter;
-import java.net.URI;
-import java.net.URISyntaxException;
-import java.nio.file.DirectoryStream;
-import java.nio.file.FileSystem;
-import java.nio.file.FileSystems;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Objects;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-import cuchaz.enigma.ProgressListener;
-import cuchaz.enigma.translation.MappingTranslator;
-import cuchaz.enigma.translation.Translator;
-import cuchaz.enigma.translation.mapping.AccessModifier;
-import cuchaz.enigma.translation.mapping.EntryMapping;
-import cuchaz.enigma.translation.mapping.MappingDelta;
-import cuchaz.enigma.translation.mapping.MappingFileNameFormat;
-import cuchaz.enigma.translation.mapping.MappingSaveParameters;
-import cuchaz.enigma.translation.mapping.VoidEntryResolver;
-import cuchaz.enigma.translation.mapping.tree.EntryTree;
-import cuchaz.enigma.translation.mapping.tree.EntryTreeNode;
-import cuchaz.enigma.translation.representation.entry.ClassEntry;
-import cuchaz.enigma.translation.representation.entry.Entry;
-import cuchaz.enigma.translation.representation.entry.FieldEntry;
-import cuchaz.enigma.translation.representation.entry.LocalVariableEntry;
-import cuchaz.enigma.translation.representation.entry.MethodEntry;
-import cuchaz.enigma.utils.I18n;
-import cuchaz.enigma.utils.LFPrintWriter;
-
-public enum EnigmaMappingsWriter implements MappingsWriter {
-        FILE {
-                @Override
-                public void write(EntryTree<EntryMapping> mappings, MappingDelta<EntryMapping> delta, Path path, ProgressListener progress, MappingSaveParameters saveParameters) {
-                        Collection<ClassEntry> classes = mappings.getRootNodes()
-                                        .filter(entry -> entry instanceof ClassEntry)
-                                        .map(entry -> (ClassEntry) entry)
-                                        .collect(Collectors.toList());
-
-                        progress.init(classes.size(), I18n.translate("progress.mappings.enigma_file.writing"));
-
-                        int steps = 0;
-                        try (PrintWriter writer = new LFPrintWriter(Files.newBufferedWriter(path))) {
-                                for (ClassEntry classEntry : classes) {
-                                        progress.step(steps++, classEntry.getFullName());
-                                        writeRoot(writer, mappings, classEntry);
-                                }
-                        } catch (IOException e) {
-                                e.printStackTrace();
-                        }
-                }
-        },
-        DIRECTORY {
-                @Override
-                public void write(EntryTree<EntryMapping> mappings, MappingDelta<EntryMapping> delta, Path path, ProgressListener progress, MappingSaveParameters saveParameters) {
-                        Collection<ClassEntry> changedClasses = delta.getChangedRoots()
-                                        .filter(entry -> entry instanceof ClassEntry)
-                                        .map(entry -> (ClassEntry) entry)
-                                        .collect(Collectors.toList());
-
-                        applyDeletions(path, changedClasses, mappings, delta.getBaseMappings(), saveParameters.getFileNameFormat());
-
-                        progress.init(changedClasses.size(), I18n.translate("progress.mappings.enigma_directory.writing"));
-
-                        AtomicInteger steps = new AtomicInteger();
-
-                        Translator translator = new MappingTranslator(mappings, VoidEntryResolver.INSTANCE);
-                        changedClasses.parallelStream().forEach(classEntry -> {
-                                progress.step(steps.getAndIncrement(), classEntry.getFullName());
-
-                                try {
-                                        ClassEntry fileEntry = classEntry;
-                                        if (saveParameters.getFileNameFormat() == MappingFileNameFormat.BY_DEOBF) {
-                                                fileEntry = translator.translate(fileEntry);
-                                        }
-
-                                        Path classPath = resolve(path, fileEntry);
-                                        Files.createDirectories(classPath.getParent());
-                                        Files.deleteIfExists(classPath);
-
-                                        try (PrintWriter writer = new LFPrintWriter(Files.newBufferedWriter(classPath))) {
-                                                writeRoot(writer, mappings, classEntry);
-                                        }
-                                } catch (Throwable t) {
-                                        System.err.println("Failed to write class '" + classEntry.getFullName() + "'");
-                                        t.printStackTrace();
-                                }
-                        });
-                }
-
-                private void applyDeletions(Path root, Collection<ClassEntry> changedClasses, EntryTree<EntryMapping> mappings, EntryTree<EntryMapping> oldMappings, MappingFileNameFormat fileNameFormat) {
-                        Translator oldMappingTranslator = new MappingTranslator(oldMappings, VoidEntryResolver.INSTANCE);
-
-                        Stream<ClassEntry> deletedClassStream = changedClasses.stream()
-                                        .filter(e -> !Objects.equals(oldMappings.get(e), mappings.get(e)));
-
-                        if (fileNameFormat == MappingFileNameFormat.BY_DEOBF) {
-                                deletedClassStream = deletedClassStream.map(oldMappingTranslator::translate);
-                        }
-
-                        Collection<ClassEntry> deletedClasses = deletedClassStream.collect(Collectors.toList());
-
-                        for (ClassEntry classEntry : deletedClasses) {
-                                try {
-                                        Files.deleteIfExists(resolve(root, classEntry));
-                                } catch (IOException e) {
-                                        System.err.println("Failed to delete deleted class '" + classEntry + "'");
-                                        e.printStackTrace();
-                                }
-                        }
-
-                        for (ClassEntry classEntry : deletedClasses) {
-                                String packageName = classEntry.getPackageName();
-                                if (packageName != null) {
-                                        Path packagePath = Paths.get(packageName);
-                                        try {
-                                                deleteDeadPackages(root, packagePath);
-                                        } catch (IOException e) {
-                                                System.err.println("Failed to delete dead package '" + packageName + "'");
-                                                e.printStackTrace();
-                                        }
-                                }
-                        }
-                }
-
-                private void deleteDeadPackages(Path root, Path packagePath) throws IOException {
-                        for (int i = packagePath.getNameCount() - 1; i >= 0; i--) {
-                                Path subPath = packagePath.subpath(0, i + 1);
-                                Path packagePart = root.resolve(subPath);
-                                if (isEmpty(packagePart)) {
-                                        Files.deleteIfExists(packagePart);
-                                }
-                        }
-                }
-
-                private boolean isEmpty(Path path) {
-                        try (DirectoryStream<Path> stream = Files.newDirectoryStream(path)) {
-                                return !stream.iterator().hasNext();
-                        } catch (IOException e) {
-                                return false;
-                        }
-                }
-
-                private Path resolve(Path root, ClassEntry classEntry) {
-                        return root.resolve(classEntry.getFullName() + ".mapping");
-                }
-        },
-        ZIP {
-                @Override
-                public void write(EntryTree<EntryMapping> mappings, MappingDelta<EntryMapping> delta, Path zip, ProgressListener progress, MappingSaveParameters saveParameters) {
-                        try (FileSystem fs = FileSystems.newFileSystem(new URI("jar:file", null, zip.toUri().getPath(), ""), Collections.singletonMap("create", "true"))) {
-                                DIRECTORY.write(mappings, delta, fs.getPath("/"), progress, saveParameters);
-                        } catch (IOException e) {
-                                e.printStackTrace();
-                        } catch (URISyntaxException e) {
-                                throw new RuntimeException("Unexpected error creating URI for " + zip, e);
-                        }
-                }
-        };
-
-        protected void writeRoot(PrintWriter writer, EntryTree<EntryMapping> mappings, ClassEntry classEntry) {
-                Collection<Entry<?>> children = groupChildren(mappings.getChildren(classEntry));
-
-                EntryMapping classEntryMapping = mappings.get(classEntry);
-
-                writer.println(writeClass(classEntry, classEntryMapping).trim());
-                if (classEntryMapping != null && classEntryMapping.getJavadoc() != null) {
-                        writeDocs(writer, classEntryMapping, 0);
-                }
-
-                for (Entry<?> child : children) {
-                        writeEntry(writer, mappings, child, 1);
-                }
-
-        }
-
-        private void writeDocs(PrintWriter writer, EntryMapping mapping, int depth) {
-                String jd = mapping.getJavadoc();
-                if (jd != null) {
-                        for (String line : jd.split("\\R")) {
-                                writer.println(indent(EnigmaFormat.COMMENT + " " + MappingHelper.escape(line), depth + 1));
-                        }
-                }
-        }
-
-        protected void writeEntry(PrintWriter writer, EntryTree<EntryMapping> mappings, Entry<?> entry, int depth) {
-                EntryTreeNode<EntryMapping> node = mappings.findNode(entry);
-                if (node == null) {
-                        return;
-                }
-
-                EntryMapping mapping = node.getValue();
-
-                if (entry instanceof ClassEntry) {
-                        String line = writeClass((ClassEntry) entry, mapping);
-                        writer.println(indent(line, depth));
-                } else if (entry instanceof MethodEntry) {
-                        String line = writeMethod((MethodEntry) entry, mapping);
-                        writer.println(indent(line, depth));
-                } else if (entry instanceof FieldEntry) {
-                        String line = writeField((FieldEntry) entry, mapping);
-                        writer.println(indent(line, depth));
-                } else if (entry instanceof LocalVariableEntry && mapping != null) {
-                        String line = writeArgument((LocalVariableEntry) entry, mapping);
-                        writer.println(indent(line, depth));
-                }
-                if (mapping != null && mapping.getJavadoc() != null) {
-                        writeDocs(writer, mapping, depth);
-                }
-
-                Collection<Entry<?>> children = groupChildren(node.getChildren());
-                for (Entry<?> child : children) {
-                        writeEntry(writer, mappings, child, depth + 1);
-                }
-        }
-
-        private Collection<Entry<?>> groupChildren(Collection<Entry<?>> children) {
-                Collection<Entry<?>> result = new ArrayList<>(children.size());
-
-                children.stream().filter(e -> e instanceof FieldEntry)
-                                .map(e -> (FieldEntry) e)
-                                .sorted()
-                                .forEach(result::add);
-
-                children.stream().filter(e -> e instanceof MethodEntry)
-                                .map(e -> (MethodEntry) e)
-                                .sorted()
-                                .forEach(result::add);
-
-                children.stream().filter(e -> e instanceof LocalVariableEntry)
-                                .map(e -> (LocalVariableEntry) e)
-                                .sorted()
-                                .forEach(result::add);
-
-                children.stream().filter(e -> e instanceof ClassEntry)
-                                                .map(e -> (ClassEntry) e)
-                                                .sorted()
-                                                .forEach(result::add);
-
-                return result;
-        }
-
-        protected String writeClass(ClassEntry entry, EntryMapping mapping) {
-                StringBuilder builder = new StringBuilder(EnigmaFormat.CLASS +" ");
-                builder.append(entry.getName()).append(' ');
-                writeMapping(builder, mapping);
-
-                return builder.toString();
-        }
-
-        protected String writeMethod(MethodEntry entry, EntryMapping mapping) {
-                StringBuilder builder = new StringBuilder(EnigmaFormat.METHOD + " ");
-                builder.append(entry.getName()).append(' ');
-                if (mapping != null && !mapping.getTargetName().equals(entry.getName())) {
-                        writeMapping(builder, mapping);
-                }
-
-                builder.append(entry.getDesc().toString());
-
-                return builder.toString();
-        }
-
-        protected String writeField(FieldEntry entry, EntryMapping mapping) {
-                StringBuilder builder = new StringBuilder(EnigmaFormat.FIELD + " ");
-                builder.append(entry.getName()).append(' ');
-                if (mapping != null && !mapping.getTargetName().equals(entry.getName())) {
-                        writeMapping(builder, mapping);
-                }
-
-                builder.append(entry.getDesc().toString());
-
-                return builder.toString();
-        }
-
-        protected String writeArgument(LocalVariableEntry entry, EntryMapping mapping) {
-                return EnigmaFormat.PARAMETER + " " + entry.getIndex() + ' ' + mapping.getTargetName();
-        }
-
-        private void writeMapping(StringBuilder builder, EntryMapping mapping) {
-                if (mapping != null) {
-                        builder.append(mapping.getTargetName()).append(' ');
-                        if (mapping.getAccessModifier() != AccessModifier.UNCHANGED) {
-                                builder.append(mapping.getAccessModifier().getFormattedName()).append(' ');
-                        }
-                }
-        }
-
-        private String indent(String line, int depth) {
-                StringBuilder builder = new StringBuilder();
-                for (int i = 0; i < depth; i++) {
-                        builder.append("\t");
-                }
-                builder.append(line.trim());
-                return builder.toString();
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java
deleted file mode 100644
index 6c8c343..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingFormat.java
+++ /dev/null
@@ -1,59 +0,0 @@
-package cuchaz.enigma.translation.mapping.serde;
-
-import cuchaz.enigma.ProgressListener;
-import cuchaz.enigma.throwables.MappingParseException;
-import cuchaz.enigma.translation.mapping.EntryMapping;
-import cuchaz.enigma.translation.mapping.MappingDelta;
-import cuchaz.enigma.translation.mapping.MappingSaveParameters;
-import cuchaz.enigma.translation.mapping.tree.EntryTree;
-
-import javax.annotation.Nullable;
-import java.io.IOException;
-import java.nio.file.Path;
-
-public enum MappingFormat {
-        ENIGMA_FILE(EnigmaMappingsWriter.FILE, EnigmaMappingsReader.FILE),
-        ENIGMA_DIRECTORY(EnigmaMappingsWriter.DIRECTORY, EnigmaMappingsReader.DIRECTORY),
-        ENIGMA_ZIP(EnigmaMappingsWriter.ZIP, EnigmaMappingsReader.ZIP),
-        TINY_V2(new TinyV2Writer("intermediary", "named"), new TinyV2Reader()),
-        TINY_FILE(TinyMappingsWriter.INSTANCE, TinyMappingsReader.INSTANCE),
-        SRG_FILE(SrgMappingsWriter.INSTANCE, null),
-        PROGUARD(null, ProguardMappingsReader.INSTANCE);
-
-
-        private final MappingsWriter writer;
-        private final MappingsReader reader;
-
-        MappingFormat(MappingsWriter writer, MappingsReader reader) {
-                this.writer = writer;
-                this.reader = reader;
-        }
-
-        public void write(EntryTree<EntryMapping> mappings, Path path, ProgressListener progressListener, MappingSaveParameters saveParameters)  {
-                write(mappings, MappingDelta.added(mappings), path, progressListener, saveParameters);
-        }
-
-        public void write(EntryTree<EntryMapping> mappings, MappingDelta<EntryMapping> delta, Path path, ProgressListener progressListener, MappingSaveParameters saveParameters)  {
-                if (writer == null) {
-                        throw new IllegalStateException(name() + " does not support writing");
-                }
-                writer.write(mappings, delta, path, progressListener, saveParameters);
-        }
-
-        public EntryTree<EntryMapping> read(Path path, ProgressListener progressListener, MappingSaveParameters saveParameters) throws IOException, MappingParseException {
-                if (reader == null) {
-                        throw new IllegalStateException(name() + " does not support reading");
-                }
-                return reader.read(path, progressListener, saveParameters);
-        }
-
-        @Nullable
-        public MappingsWriter getWriter() {
-                return writer;
-        }
-
-        @Nullable
-        public MappingsReader getReader() {
-                return reader;
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingHelper.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingHelper.java
deleted file mode 100644
index 7c8f6cc..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingHelper.java
+++ /dev/null
@@ -1,51 +0,0 @@
-package cuchaz.enigma.translation.mapping.serde;
-
-public final class MappingHelper {
-        private static final String TO_ESCAPE = "\\\n\r\0\t";
-        private static final String ESCAPED = "\\nr0t";
-
-        public static String escape(String raw) {
-                StringBuilder builder = new StringBuilder(raw.length() + 1);
-                for (int i = 0; i < raw.length(); i++) {
-                        final char c = raw.charAt(i);
-                        final int r = TO_ESCAPE.indexOf(c);
-                        if (r < 0) {
-                                builder.append(c);
-                        } else {
-                                builder.append('\\').append(ESCAPED.charAt(r));
-                        }
-                }
-                return builder.toString();
-        }
-
-        public static String unescape(String str) {
-                int pos = str.indexOf('\\');
-                if (pos < 0) return str;
-
-                StringBuilder ret = new StringBuilder(str.length() - 1);
-                int start = 0;
-
-                do {
-                        ret.append(str, start, pos);
-                        pos++;
-                        int type;
-
-                        if (pos >= str.length()) {
-                                throw new RuntimeException("incomplete escape sequence at the end");
-                        } else if ((type = ESCAPED.indexOf(str.charAt(pos))) < 0) {
-                                throw new RuntimeException("invalid escape character: \\" + str.charAt(pos));
-                        } else {
-                                ret.append(TO_ESCAPE.charAt(type));
-                        }
-
-                        start = pos + 1;
-                } while ((pos = str.indexOf('\\', start)) >= 0);
-
-                ret.append(str, start, str.length());
-
-                return ret.toString();
-        }
-
-        private MappingHelper() {
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingsReader.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingsReader.java
deleted file mode 100644
index 4c60787..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingsReader.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package cuchaz.enigma.translation.mapping.serde;
-
-import cuchaz.enigma.ProgressListener;
-import cuchaz.enigma.throwables.MappingParseException;
-import cuchaz.enigma.translation.mapping.EntryMapping;
-import cuchaz.enigma.translation.mapping.MappingSaveParameters;
-import cuchaz.enigma.translation.mapping.tree.EntryTree;
-
-import java.io.IOException;
-import java.nio.file.Path;
-
-public interface MappingsReader {
-        EntryTree<EntryMapping> read(Path path, ProgressListener progress, MappingSaveParameters saveParameters) throws MappingParseException, IOException;
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingsWriter.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingsWriter.java
deleted file mode 100644
index 8815986..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/serde/MappingsWriter.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package cuchaz.enigma.translation.mapping.serde;
-
-import cuchaz.enigma.ProgressListener;
-import cuchaz.enigma.translation.mapping.EntryMapping;
-import cuchaz.enigma.translation.mapping.MappingDelta;
-import cuchaz.enigma.translation.mapping.MappingSaveParameters;
-import cuchaz.enigma.translation.mapping.tree.EntryTree;
-
-import java.nio.file.Path;
-
-public interface MappingsWriter {
-        void write(EntryTree<EntryMapping> mappings, MappingDelta<EntryMapping> delta, Path path, ProgressListener progress, MappingSaveParameters saveParameters);
-
-        default void write(EntryTree<EntryMapping> mappings, Path path, ProgressListener progress, MappingSaveParameters saveParameters) {
-                write(mappings, MappingDelta.added(mappings), path, progress, saveParameters);
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/ProguardMappingsReader.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/ProguardMappingsReader.java
deleted file mode 100644
index b5ede39..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/serde/ProguardMappingsReader.java
+++ /dev/null
@@ -1,134 +0,0 @@
-package cuchaz.enigma.translation.mapping.serde;
-
-import cuchaz.enigma.ProgressListener;
-import cuchaz.enigma.command.MappingCommandsUtil;
-import cuchaz.enigma.throwables.MappingParseException;
-import cuchaz.enigma.translation.mapping.EntryMapping;
-import cuchaz.enigma.translation.mapping.MappingSaveParameters;
-import cuchaz.enigma.translation.mapping.tree.EntryTree;
-import cuchaz.enigma.translation.mapping.tree.HashEntryTree;
-import cuchaz.enigma.translation.representation.MethodDescriptor;
-import cuchaz.enigma.translation.representation.TypeDescriptor;
-import cuchaz.enigma.translation.representation.entry.ClassEntry;
-import cuchaz.enigma.translation.representation.entry.FieldEntry;
-import cuchaz.enigma.translation.representation.entry.MethodEntry;
-
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-public class ProguardMappingsReader implements MappingsReader {
-    public static final ProguardMappingsReader INSTANCE = new ProguardMappingsReader();
-    private static final String NAME = "[a-zA-Z0-9_\\-.$<>]+";
-    private static final String TYPE = NAME + "(?:\\[])*";
-    private static final String TYPE_LIST = "|(?:(?:" + TYPE + ",)*" + TYPE + ")";
-    private static final Pattern CLASS = Pattern.compile("(" + NAME + ") -> (" + NAME + "):");
-    private static final Pattern FIELD = Pattern.compile(" {4}(" + TYPE + ") (" + NAME + ") -> (" + NAME + ")");
-    private static final Pattern METHOD = Pattern.compile(" {4}(?:[0-9]+:[0-9]+:)?(" + TYPE + ") (" + NAME + ")\\((" + TYPE_LIST + ")\\) -> (" + NAME + ")");
-
-    public ProguardMappingsReader() {}
-
-    @Override
-    public EntryTree<EntryMapping> read(Path path, ProgressListener progress, MappingSaveParameters saveParameters) throws MappingParseException, IOException {
-        EntryTree<EntryMapping> mappings = new HashEntryTree<>();
-
-        int lineNumber = 0;
-        ClassEntry currentClass = null;
-        for (String line : Files.readAllLines(path, StandardCharsets.UTF_8)) {
-            lineNumber++;
-
-            if (line.startsWith("#") || line.isEmpty()) {
-                continue;
-            }
-
-            Matcher classMatcher = CLASS.matcher(line);
-            Matcher fieldMatcher = FIELD.matcher(line);
-            Matcher methodMatcher = METHOD.matcher(line);
-
-            if (classMatcher.matches()) {
-                String name = classMatcher.group(1);
-                String targetName = classMatcher.group(2);
-
-                mappings.insert(currentClass = new ClassEntry(name.replace('.', '/')), new EntryMapping(ClassEntry.getInnerName(targetName.replace('.', '/'))));
-            } else if (fieldMatcher.matches()) {
-                String type = fieldMatcher.group(1);
-                String name = fieldMatcher.group(2);
-                String targetName = fieldMatcher.group(3);
-
-                if (currentClass == null) {
-                    throw new MappingParseException(path::toString, lineNumber, "field mapping not inside class: " + line);
-                }
-
-                mappings.insert(new FieldEntry(currentClass, name, new TypeDescriptor(getDescriptor(type))), new EntryMapping(targetName));
-            } else if (methodMatcher.matches()) {
-                String returnType = methodMatcher.group(1);
-                String name = methodMatcher.group(2);
-                String[] parameterTypes = methodMatcher.group(3).isEmpty() ? new String[0] : methodMatcher.group(3).split(",");
-                String targetName = methodMatcher.group(4);
-
-                if (currentClass == null) {
-                    throw new MappingParseException(path::toString, lineNumber, "method mapping not inside class: " + line);
-                }
-
-                mappings.insert(new MethodEntry(currentClass, name, new MethodDescriptor(getDescriptor(returnType, parameterTypes))), new EntryMapping(targetName));
-            } else {
-                throw new MappingParseException(path::toString, lineNumber, "invalid mapping line: " + line);
-            }
-        }
-
-        return MappingCommandsUtil.invert(mappings);
-    }
-
-    private String getDescriptor(String type) {
-        StringBuilder descriptor = new StringBuilder();
-
-        while (type.endsWith("[]")) {
-            descriptor.append("[");
-            type = type.substring(0, type.length() - 2);
-        }
-
-        switch (type) {
-            case "byte":
-                return descriptor + "B";
-            case "char":
-                return descriptor + "C";
-            case "short":
-                return descriptor + "S";
-            case "int":
-                return descriptor + "I";
-            case "long":
-                return descriptor + "J";
-            case "float":
-                return descriptor + "F";
-            case "double":
-                return descriptor + "D";
-            case "boolean":
-                return descriptor + "Z";
-            case "void":
-                return descriptor + "V";
-        }
-
-        descriptor.append("L");
-        descriptor.append(type.replace('.', '/'));
-        descriptor.append(";");
-
-        return descriptor.toString();
-    }
-
-    private String getDescriptor(String returnType, String[] parameterTypes) {
-        StringBuilder descriptor = new StringBuilder();
-        descriptor.append('(');
-
-        for (String parameterType : parameterTypes) {
-            descriptor.append(getDescriptor(parameterType));
-        }
-
-        descriptor.append(')');
-        descriptor.append(getDescriptor(returnType));
-
-        return descriptor.toString();
-    }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/RawEntryMapping.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/RawEntryMapping.java
deleted file mode 100644
index afb40e9..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/serde/RawEntryMapping.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package cuchaz.enigma.translation.mapping.serde;
-
-import cuchaz.enigma.translation.mapping.AccessModifier;
-import cuchaz.enigma.translation.mapping.EntryMapping;
-
-import java.util.ArrayList;
-import java.util.List;
-
-final class RawEntryMapping {
-        private final String targetName;
-        private final AccessModifier access;
-        private List<String> javadocs = new ArrayList<>();
-
-        RawEntryMapping(String targetName) {
-                this(targetName, null);
-        }
-
-        RawEntryMapping(String targetName, AccessModifier access) {
-                this.access = access;
-                this.targetName = targetName;
-        }
-
-        void addJavadocLine(String line) {
-                javadocs.add(line);
-        }
-
-        EntryMapping bake() {
-                return new EntryMapping(targetName, access, javadocs.isEmpty() ? null : String.join("\n", javadocs));
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/SrgMappingsWriter.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/SrgMappingsWriter.java
deleted file mode 100644
index f67f8fc..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/serde/SrgMappingsWriter.java
+++ /dev/null
@@ -1,118 +0,0 @@
-package cuchaz.enigma.translation.mapping.serde;
-
-import com.google.common.collect.Lists;
-import cuchaz.enigma.ProgressListener;
-import cuchaz.enigma.translation.MappingTranslator;
-import cuchaz.enigma.translation.Translator;
-import cuchaz.enigma.translation.mapping.EntryMapping;
-import cuchaz.enigma.translation.mapping.MappingDelta;
-import cuchaz.enigma.translation.mapping.MappingSaveParameters;
-import cuchaz.enigma.translation.mapping.VoidEntryResolver;
-import cuchaz.enigma.translation.mapping.tree.EntryTree;
-import cuchaz.enigma.translation.mapping.tree.EntryTreeNode;
-import cuchaz.enigma.translation.representation.entry.ClassEntry;
-import cuchaz.enigma.translation.representation.entry.Entry;
-import cuchaz.enigma.translation.representation.entry.FieldEntry;
-import cuchaz.enigma.translation.representation.entry.MethodEntry;
-import cuchaz.enigma.utils.I18n;
-import cuchaz.enigma.utils.LFPrintWriter;
-
-import java.io.IOException;
-import java.io.PrintWriter;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Comparator;
-import java.util.List;
-import java.util.stream.Collectors;
-
-public enum SrgMappingsWriter implements MappingsWriter {
-        INSTANCE;
-
-        @Override
-        public void write(EntryTree<EntryMapping> mappings, MappingDelta<EntryMapping> delta, Path path, ProgressListener progress, MappingSaveParameters saveParameters) {
-                try {
-                        Files.deleteIfExists(path);
-                        Files.createFile(path);
-                } catch (IOException e) {
-                        e.printStackTrace();
-                }
-
-                List<String> classLines = new ArrayList<>();
-                List<String> fieldLines = new ArrayList<>();
-                List<String> methodLines = new ArrayList<>();
-
-                Collection<Entry<?>> rootEntries = Lists.newArrayList(mappings).stream()
-                                .map(EntryTreeNode::getEntry)
-                                .collect(Collectors.toList());
-                progress.init(rootEntries.size(), I18n.translate("progress.mappings.srg_file.generating"));
-
-                int steps = 0;
-                for (Entry<?> entry : sorted(rootEntries)) {
-                        progress.step(steps++, entry.getName());
-                        writeEntry(classLines, fieldLines, methodLines, mappings, entry);
-                }
-
-                progress.init(3, I18n.translate("progress.mappings.srg_file.writing"));
-                try (PrintWriter writer = new LFPrintWriter(Files.newBufferedWriter(path))) {
-                        progress.step(0, I18n.translate("type.classes"));
-                        classLines.forEach(writer::println);
-                        progress.step(1, I18n.translate("type.fields"));
-                        fieldLines.forEach(writer::println);
-                        progress.step(2, I18n.translate("type.methods"));
-                        methodLines.forEach(writer::println);
-                } catch (IOException e) {
-                        e.printStackTrace();
-                }
-        }
-
-        private void writeEntry(List<String> classes, List<String> fields, List<String> methods, EntryTree<EntryMapping> mappings, Entry<?> entry) {
-                EntryTreeNode<EntryMapping> node = mappings.findNode(entry);
-                if (node == null) {
-                        return;
-                }
-
-                Translator translator = new MappingTranslator(mappings, VoidEntryResolver.INSTANCE);
-                if (entry instanceof ClassEntry) {
-                        classes.add(generateClassLine((ClassEntry) entry, translator));
-                } else if (entry instanceof FieldEntry) {
-                        fields.add(generateFieldLine((FieldEntry) entry, translator));
-                } else if (entry instanceof MethodEntry) {
-                        methods.add(generateMethodLine((MethodEntry) entry, translator));
-                }
-
-                for (Entry<?> child : sorted(node.getChildren())) {
-                        writeEntry(classes, fields, methods, mappings, child);
-                }
-        }
-
-        private String generateClassLine(ClassEntry sourceEntry, Translator translator) {
-                ClassEntry targetEntry = translator.translate(sourceEntry);
-                return "CL: " + sourceEntry.getFullName() + " " + targetEntry.getFullName();
-        }
-
-        private String generateMethodLine(MethodEntry sourceEntry, Translator translator) {
-                MethodEntry targetEntry = translator.translate(sourceEntry);
-                return "MD: " + describeMethod(sourceEntry) + " " + describeMethod(targetEntry);
-        }
-
-        private String describeMethod(MethodEntry entry) {
-                return entry.getParent().getFullName() + "/" + entry.getName() + " " + entry.getDesc();
-        }
-
-        private String generateFieldLine(FieldEntry sourceEntry, Translator translator) {
-                FieldEntry targetEntry = translator.translate(sourceEntry);
-                return "FD: " + describeField(sourceEntry) + " " + describeField(targetEntry);
-        }
-
-        private String describeField(FieldEntry entry) {
-                return entry.getParent().getFullName() + "/" + entry.getName();
-        }
-
-        private Collection<Entry<?>> sorted(Iterable<Entry<?>> iterable) {
-                ArrayList<Entry<?>> sorted = Lists.newArrayList(iterable);
-                sorted.sort(Comparator.comparing(Entry::getName));
-                return sorted;
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyMappingsReader.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyMappingsReader.java
deleted file mode 100644
index 773c95e..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyMappingsReader.java
+++ /dev/null
@@ -1,115 +0,0 @@
-package cuchaz.enigma.translation.mapping.serde;
-
-import com.google.common.base.Charsets;
-import cuchaz.enigma.ProgressListener;
-import cuchaz.enigma.throwables.MappingParseException;
-import cuchaz.enigma.translation.mapping.EntryMapping;
-import cuchaz.enigma.translation.mapping.MappingPair;
-import cuchaz.enigma.translation.mapping.MappingSaveParameters;
-import cuchaz.enigma.translation.mapping.tree.EntryTree;
-import cuchaz.enigma.translation.mapping.tree.HashEntryTree;
-import cuchaz.enigma.translation.representation.MethodDescriptor;
-import cuchaz.enigma.translation.representation.TypeDescriptor;
-import cuchaz.enigma.translation.representation.entry.ClassEntry;
-import cuchaz.enigma.translation.representation.entry.FieldEntry;
-import cuchaz.enigma.translation.representation.entry.LocalVariableEntry;
-import cuchaz.enigma.translation.representation.entry.MethodEntry;
-import cuchaz.enigma.utils.I18n;
-
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.List;
-
-public enum TinyMappingsReader implements MappingsReader {
-        INSTANCE;
-
-        @Override
-        public EntryTree<EntryMapping> read(Path path, ProgressListener progress, MappingSaveParameters saveParameters) throws IOException, MappingParseException {
-                return read(path, Files.readAllLines(path, Charsets.UTF_8), progress);
-        }
-
-        private EntryTree<EntryMapping> read(Path path, List<String> lines, ProgressListener progress) throws MappingParseException {
-                EntryTree<EntryMapping> mappings = new HashEntryTree<>();
-                lines.remove(0);
-
-                progress.init(lines.size(), I18n.translate("progress.mappings.tiny_file.loading"));
-
-                for (int lineNumber = 0; lineNumber < lines.size(); lineNumber++) {
-                        progress.step(lineNumber, "");
-
-                        String line = lines.get(lineNumber);
-
-                        if (line.trim().startsWith("#")) {
-                                continue;
-                        }
-
-                        try {
-                                MappingPair<?, EntryMapping> mapping = parseLine(line);
-                                mappings.insert(mapping.getEntry(), mapping.getMapping());
-                        } catch (Throwable t) {
-                                t.printStackTrace();
-                                throw new MappingParseException(path::toString, lineNumber, t.toString());
-                        }
-                }
-
-                return mappings;
-        }
-
-        private MappingPair<?, EntryMapping> parseLine(String line) {
-                String[] tokens = line.split("\t");
-
-                String key = tokens[0];
-                switch (key) {
-                        case "CLASS":
-                                return parseClass(tokens);
-                        case "FIELD":
-                                return parseField(tokens);
-                        case "METHOD":
-                                return parseMethod(tokens);
-                        case "MTH-ARG":
-                                return parseArgument(tokens);
-                        default:
-                                throw new RuntimeException("Unknown token '" + key + "'!");
-                }
-        }
-
-        private MappingPair<ClassEntry, EntryMapping> parseClass(String[] tokens) {
-                ClassEntry obfuscatedEntry = new ClassEntry(tokens[1]);
-                String mapping = tokens[2];
-                if (mapping.indexOf('$') > 0) {
-                        // inner classes should map to only the final part
-                        mapping = mapping.substring(mapping.lastIndexOf('$') + 1);
-                }
-                return new MappingPair<>(obfuscatedEntry, new EntryMapping(mapping));
-        }
-
-        private MappingPair<FieldEntry, EntryMapping> parseField(String[] tokens) {
-                ClassEntry ownerClass = new ClassEntry(tokens[1]);
-                TypeDescriptor descriptor = new TypeDescriptor(tokens[2]);
-
-                FieldEntry obfuscatedEntry = new FieldEntry(ownerClass, tokens[3], descriptor);
-                String mapping = tokens[4];
-                return new MappingPair<>(obfuscatedEntry, new EntryMapping(mapping));
-        }
-
-        private MappingPair<MethodEntry, EntryMapping> parseMethod(String[] tokens) {
-                ClassEntry ownerClass = new ClassEntry(tokens[1]);
-                MethodDescriptor descriptor = new MethodDescriptor(tokens[2]);
-
-                MethodEntry obfuscatedEntry = new MethodEntry(ownerClass, tokens[3], descriptor);
-                String mapping = tokens[4];
-                return new MappingPair<>(obfuscatedEntry, new EntryMapping(mapping));
-        }
-
-        private MappingPair<LocalVariableEntry, EntryMapping> parseArgument(String[] tokens) {
-                ClassEntry ownerClass = new ClassEntry(tokens[1]);
-                MethodDescriptor ownerDescriptor = new MethodDescriptor(tokens[2]);
-                MethodEntry ownerMethod = new MethodEntry(ownerClass, tokens[3], ownerDescriptor);
-                int variableIndex = Integer.parseInt(tokens[4]);
-
-                String mapping = tokens[5];
-                LocalVariableEntry obfuscatedEntry = new LocalVariableEntry(ownerMethod, variableIndex, "", true, null);
-                return new MappingPair<>(obfuscatedEntry, new EntryMapping(mapping));
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyMappingsWriter.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyMappingsWriter.java
deleted file mode 100644
index c82f262..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyMappingsWriter.java
+++ /dev/null
@@ -1,148 +0,0 @@
-package cuchaz.enigma.translation.mapping.serde;
-
-import com.google.common.base.Joiner;
-import com.google.common.collect.Lists;
-import cuchaz.enigma.ProgressListener;
-import cuchaz.enigma.translation.MappingTranslator;
-import cuchaz.enigma.translation.Translator;
-import cuchaz.enigma.translation.mapping.EntryMapping;
-import cuchaz.enigma.translation.mapping.MappingDelta;
-import cuchaz.enigma.translation.mapping.MappingSaveParameters;
-import cuchaz.enigma.translation.mapping.VoidEntryResolver;
-import cuchaz.enigma.translation.mapping.tree.EntryTree;
-import cuchaz.enigma.translation.mapping.tree.EntryTreeNode;
-import cuchaz.enigma.translation.representation.entry.ClassEntry;
-import cuchaz.enigma.translation.representation.entry.Entry;
-import cuchaz.enigma.translation.representation.entry.FieldEntry;
-import cuchaz.enigma.translation.representation.entry.MethodEntry;
-
-import java.io.BufferedWriter;
-import java.io.IOException;
-import java.io.Writer;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.Comparator;
-import java.util.HashSet;
-import java.util.Set;
-
-public class TinyMappingsWriter implements MappingsWriter {
-    private static final String VERSION_CONSTANT = "v1";
-    private static final Joiner TAB_JOINER = Joiner.on('\t');
-
-    //Possibly add a gui or a way to select the namespaces when exporting from the gui
-    public static final TinyMappingsWriter INSTANCE = new TinyMappingsWriter("intermediary", "named");
-
-    // HACK: as of enigma 0.13.1, some fields seem to appear duplicated?
-    private final Set<String> writtenLines = new HashSet<>();
-    private final String nameObf;
-    private final String nameDeobf;
-
-    public TinyMappingsWriter(String nameObf, String nameDeobf) {
-        this.nameObf = nameObf;
-        this.nameDeobf = nameDeobf;
-    }
-
-    @Override
-    public void write(EntryTree<EntryMapping> mappings, MappingDelta<EntryMapping> delta, Path path, ProgressListener progress, MappingSaveParameters saveParameters) {
-        try {
-            Files.deleteIfExists(path);
-            Files.createFile(path);
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-
-        try (BufferedWriter writer = Files.newBufferedWriter(path, StandardCharsets.UTF_8)) {
-            writeLine(writer, new String[]{VERSION_CONSTANT, nameObf, nameDeobf});
-
-            Lists.newArrayList(mappings).stream()
-                    .map(EntryTreeNode::getEntry).sorted(Comparator.comparing(Object::toString))
-                    .forEach(entry -> writeEntry(writer, mappings, entry));
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
-
-    private void writeEntry(Writer writer, EntryTree<EntryMapping> mappings, Entry<?> entry) {
-        EntryTreeNode<EntryMapping> node = mappings.findNode(entry);
-        if (node == null) {
-            return;
-        }
-
-        Translator translator = new MappingTranslator(mappings, VoidEntryResolver.INSTANCE);
-
-        EntryMapping mapping = mappings.get(entry);
-        if (mapping != null && !entry.getName().equals(mapping.getTargetName())) {
-            if (entry instanceof ClassEntry) {
-                writeClass(writer, (ClassEntry) entry, translator);
-            } else if (entry instanceof FieldEntry) {
-                writeLine(writer, serializeEntry(entry, mapping.getTargetName()));
-            } else if (entry instanceof MethodEntry) {
-                writeLine(writer, serializeEntry(entry, mapping.getTargetName()));
-            }
-        }
-
-        writeChildren(writer, mappings, node);
-    }
-
-    private void writeChildren(Writer writer, EntryTree<EntryMapping> mappings, EntryTreeNode<EntryMapping> node) {
-        node.getChildren().stream()
-                .filter(e -> e instanceof FieldEntry).sorted()
-                .forEach(child -> writeEntry(writer, mappings, child));
-
-        node.getChildren().stream()
-                .filter(e -> e instanceof MethodEntry).sorted()
-                .forEach(child -> writeEntry(writer, mappings, child));
-
-        node.getChildren().stream()
-                .filter(e -> e instanceof ClassEntry).sorted()
-                .forEach(child -> writeEntry(writer, mappings, child));
-    }
-
-    private void writeClass(Writer writer, ClassEntry entry, Translator translator) {
-        ClassEntry translatedEntry = translator.translate(entry);
-
-        String obfClassName = entry.getFullName();
-        String deobfClassName = translatedEntry.getFullName();
-        writeLine(writer, new String[]{"CLASS", obfClassName, deobfClassName});
-    }
-
-    private void writeLine(Writer writer, String[] data) {
-        try {
-            String line = TAB_JOINER.join(data) + "\n";
-            if (writtenLines.add(line)) {
-                writer.write(line);
-            }
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-    }
-
-    private String[] serializeEntry(Entry<?> entry, String... extraFields) {
-        String[] data = null;
-
-        if (entry instanceof FieldEntry) {
-            data = new String[4 + extraFields.length];
-            data[0] = "FIELD";
-            data[1] = entry.getContainingClass().getFullName();
-            data[2] = ((FieldEntry) entry).getDesc().toString();
-            data[3] = entry.getName();
-        } else if (entry instanceof MethodEntry) {
-            data = new String[4 + extraFields.length];
-            data[0] = "METHOD";
-            data[1] = entry.getContainingClass().getFullName();
-            data[2] = ((MethodEntry) entry).getDesc().toString();
-            data[3] = entry.getName();
-        } else if (entry instanceof ClassEntry) {
-            data = new String[2 + extraFields.length];
-            data[0] = "CLASS";
-            data[1] = ((ClassEntry) entry).getFullName();
-        }
-
-        if (data != null) {
-            System.arraycopy(extraFields, 0, data, data.length - extraFields.length, extraFields.length);
-        }
-
-        return data;
-    }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyV2Reader.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyV2Reader.java
deleted file mode 100644
index d81cbdb..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyV2Reader.java
+++ /dev/null
@@ -1,295 +0,0 @@
-package cuchaz.enigma.translation.mapping.serde;
-
-import cuchaz.enigma.ProgressListener;
-import cuchaz.enigma.throwables.MappingParseException;
-import cuchaz.enigma.translation.mapping.EntryMapping;
-import cuchaz.enigma.translation.mapping.MappingPair;
-import cuchaz.enigma.translation.mapping.MappingSaveParameters;
-import cuchaz.enigma.translation.mapping.tree.EntryTree;
-import cuchaz.enigma.translation.mapping.tree.HashEntryTree;
-import cuchaz.enigma.translation.representation.MethodDescriptor;
-import cuchaz.enigma.translation.representation.TypeDescriptor;
-import cuchaz.enigma.translation.representation.entry.ClassEntry;
-import cuchaz.enigma.translation.representation.entry.Entry;
-import cuchaz.enigma.translation.representation.entry.FieldEntry;
-import cuchaz.enigma.translation.representation.entry.LocalVariableEntry;
-import cuchaz.enigma.translation.representation.entry.MethodEntry;
-import cuchaz.enigma.utils.I18n;
-
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.BitSet;
-import java.util.List;
-
-final class TinyV2Reader implements MappingsReader {
-
-        private static final String MINOR_VERSION = "0";
-        // 0 indent
-        private static final int IN_HEADER = 0;
-        private static final int IN_CLASS = IN_HEADER + 1;
-        // 1 indent
-        private static final int IN_METHOD = IN_CLASS + 1;
-        private static final int IN_FIELD = IN_METHOD + 1;
-        // 2 indent
-        private static final int IN_PARAMETER = IN_FIELD + 1;
-        // general properties
-        private static final int STATE_SIZE = IN_PARAMETER + 1;
-        private static final int[] INDENT_CLEAR_START = {IN_HEADER, IN_METHOD, IN_PARAMETER, STATE_SIZE};
-
-        @Override
-        public EntryTree<EntryMapping> read(Path path, ProgressListener progress, MappingSaveParameters saveParameters) throws IOException, MappingParseException {
-                return read(path, Files.readAllLines(path, StandardCharsets.UTF_8), progress);
-        }
-
-        private EntryTree<EntryMapping> read(Path path, List<String> lines, ProgressListener progress) throws MappingParseException {
-                EntryTree<EntryMapping> mappings = new HashEntryTree<>();
-
-                progress.init(lines.size(), I18n.translate("progress.mappings.tiny_v2.loading"));
-
-                BitSet state = new BitSet(STATE_SIZE);
-                @SuppressWarnings({"unchecked", "rawtypes"})
-                MappingPair<? extends Entry<?>, RawEntryMapping>[] holds = new MappingPair[STATE_SIZE];
-                boolean escapeNames = false;
-
-                for (int lineNumber = 0; lineNumber < lines.size(); lineNumber++) {
-                        try {
-                                progress.step(lineNumber, "");
-                                String line = lines.get(lineNumber);
-
-                                int indent = 0;
-                                while (line.charAt(indent) == '\t')
-                                        indent++;
-
-                                String[] parts = line.substring(indent).split("\t", -1);
-                                if (parts.length == 0 || indent >= INDENT_CLEAR_START.length)
-                                        throw new IllegalArgumentException("Invalid format");
-
-                                // clean and register stuff in stack
-                                for (int i = INDENT_CLEAR_START[indent]; i < STATE_SIZE; i++) {
-                                        state.clear(i);
-                                        if (holds[i] != null) {
-                                                RawEntryMapping mapping = holds[i].getMapping();
-                                                if (mapping != null) {
-                                                        EntryMapping baked = mapping.bake();
-                                                        if (baked != null) {
-                                                                mappings.insert(holds[i].getEntry(), baked);
-                                                        }
-                                                }
-                                                holds[i] = null;
-                                        }
-                                }
-
-                                switch (indent) {
-                                        case 0:
-                                                switch (parts[0]) {
-                                                        case "tiny": // header
-                                                                if (lineNumber != 0) {
-                                                                        throw new IllegalArgumentException("Header can only be on the first line");
-                                                                }
-                                                                if (parts.length < 5) {
-                                                                        throw new IllegalArgumentException("Not enough header columns, needs at least 5");
-                                                                }
-                                                                if (!"2".equals(parts[1]) || !MINOR_VERSION.equals(parts[2])) {
-                                                                        throw new IllegalArgumentException("Unsupported TinyV2 version, requires major " + "2" + " and minor " + MINOR_VERSION + "");
-                                                                }
-                                                                state.set(IN_HEADER);
-                                                                break;
-                                                        case "c": // class
-                                                                state.set(IN_CLASS);
-                                                                holds[IN_CLASS] = parseClass(parts, escapeNames);
-                                                                break;
-                                                        default:
-                                                                unsupportKey(parts);
-                                                }
-
-                                                break;
-                                        case 1:
-                                                if (state.get(IN_HEADER)) {
-                                                        if (parts[0].equals("esacpe-names")) {
-                                                                escapeNames = true;
-                                                        }
-
-                                                        break;
-                                                }
-
-                                                if (state.get(IN_CLASS)) {
-                                                        switch (parts[0]) {
-                                                                case "m": // method
-                                                                        state.set(IN_METHOD);
-                                                                        holds[IN_METHOD] = parseMethod(holds[IN_CLASS], parts, escapeNames);
-                                                                        break;
-                                                                case "f": // field
-                                                                        state.set(IN_FIELD);
-                                                                        holds[IN_FIELD] = parseField(holds[IN_CLASS], parts, escapeNames);
-                                                                        break;
-                                                                case "c": // class javadoc
-                                                                        addJavadoc(holds[IN_CLASS], parts);
-                                                                        break;
-                                                                default:
-                                                                        unsupportKey(parts);
-                                                        }
-                                                        break;
-                                                }
-
-                                                unsupportKey(parts);
-                                        case 2:
-                                                if (state.get(IN_METHOD)) {
-                                                        switch (parts[0]) {
-                                                                case "p": // parameter
-                                                                        state.set(IN_PARAMETER);
-                                                                        holds[IN_PARAMETER] = parseArgument(holds[IN_METHOD], parts, escapeNames);
-                                                                        break;
-                                                                case "v": // local variable
-                                                                        // TODO add local var mapping
-                                                                        break;
-                                                                case "c": // method javadoc
-                                                                        addJavadoc(holds[IN_METHOD], parts);
-                                                                        break;
-                                                                default:
-                                                                        unsupportKey(parts);
-                                                        }
-                                                        break;
-                                                }
-
-                                                if (state.get(IN_FIELD)) {
-                                                        switch (parts[0]) {
-                                                                case "c": // field javadoc
-                                                                        addJavadoc(holds[IN_FIELD], parts);
-                                                                        break;
-                                                                default:
-                                                                        unsupportKey(parts);
-                                                        }
-                                                        break;
-                                                }
-                                                unsupportKey(parts);
-                                        case 3:
-                                                if (state.get(IN_PARAMETER)) {
-                                                        switch (parts[0]) {
-                                                                case "c":
-                                                                        addJavadoc(holds[IN_PARAMETER], parts);
-                                                                        break;
-                                                                default:
-                                                                        unsupportKey(parts);
-                                                        }
-                                                        break;
-                                                }
-                                                unsupportKey(parts);
-                                        default:
-                                                unsupportKey(parts);
-                                }
-
-                        } catch (Throwable t) {
-                                t.printStackTrace();
-                                throw new MappingParseException(path::toString, lineNumber + 1, t.toString());
-                        }
-                }
-
-                return mappings;
-        }
-
-        private void unsupportKey(String[] parts) {
-                throw new IllegalArgumentException("Unsupported key " + parts[0]);
-        }
-
-        private void addJavadoc(MappingPair<? extends Entry, RawEntryMapping> pair, String[] parts) {
-                if (parts.length != 2) {
-                        throw new IllegalArgumentException("Invalid javadoc declaration");
-                }
-
-                addJavadoc(pair, parts[1]);
-        }
-
-        private MappingPair<ClassEntry, RawEntryMapping> parseClass(String[] tokens, boolean escapeNames) {
-                ClassEntry obfuscatedEntry = new ClassEntry(unescapeOpt(tokens[1], escapeNames));
-                if (tokens.length <= 2)
-                        return new MappingPair<>(obfuscatedEntry);
-                String token2 = unescapeOpt(tokens[2], escapeNames);
-                String mapping = token2.substring(token2.lastIndexOf('$') + 1);
-                return new MappingPair<>(obfuscatedEntry, new RawEntryMapping(mapping));
-        }
-
-        private MappingPair<FieldEntry, RawEntryMapping> parseField(MappingPair<? extends Entry, RawEntryMapping> parent, String[] tokens, boolean escapeNames) {
-                ClassEntry ownerClass = (ClassEntry) parent.getEntry();
-                TypeDescriptor descriptor = new TypeDescriptor(unescapeOpt(tokens[1], escapeNames));
-
-                FieldEntry obfuscatedEntry = new FieldEntry(ownerClass, unescapeOpt(tokens[2], escapeNames), descriptor);
-                if (tokens.length <= 3)
-                        return new MappingPair<>(obfuscatedEntry);
-                String mapping = unescapeOpt(tokens[3], escapeNames);
-                return new MappingPair<>(obfuscatedEntry, new RawEntryMapping(mapping));
-        }
-
-        private MappingPair<MethodEntry, RawEntryMapping> parseMethod(MappingPair<? extends Entry, RawEntryMapping> parent, String[] tokens, boolean escapeNames) {
-                ClassEntry ownerClass = (ClassEntry) parent.getEntry();
-                MethodDescriptor descriptor = new MethodDescriptor(unescapeOpt(tokens[1], escapeNames));
-
-                MethodEntry obfuscatedEntry = new MethodEntry(ownerClass, unescapeOpt(tokens[2], escapeNames), descriptor);
-                if (tokens.length <= 3)
-                        return new MappingPair<>(obfuscatedEntry);
-                String mapping = unescapeOpt(tokens[3], escapeNames);
-                return new MappingPair<>(obfuscatedEntry, new RawEntryMapping(mapping));
-        }
-
-
-
-        private void addJavadoc(MappingPair<? extends Entry, RawEntryMapping> pair, String javadoc) {
-                RawEntryMapping mapping = pair.getMapping();
-                if (mapping == null) {
-                        throw new IllegalArgumentException("Javadoc requires a mapping in enigma!");
-                }
-                mapping.addJavadocLine(unescape(javadoc));
-        }
-
-
-
-        private MappingPair<LocalVariableEntry, RawEntryMapping> parseArgument(MappingPair<? extends Entry, RawEntryMapping> parent, String[] tokens, boolean escapeNames) {
-                MethodEntry ownerMethod = (MethodEntry) parent.getEntry();
-                int variableIndex = Integer.parseInt(tokens[1]);
-
-                // tokens[2] is the useless obf name
-
-                LocalVariableEntry obfuscatedEntry = new LocalVariableEntry(ownerMethod, variableIndex, "", true, null);
-                if (tokens.length <= 3)
-                        return new MappingPair<>(obfuscatedEntry);
-                String mapping = unescapeOpt(tokens[3], escapeNames);
-                return new MappingPair<>(obfuscatedEntry, new RawEntryMapping(mapping));
-        }
-
-        private static final String TO_ESCAPE = "\\\n\r\0\t";
-        private static final String ESCAPED = "\\nr0t";
-
-        private static String unescapeOpt(String raw, boolean escapedStrings) {
-                return escapedStrings ? unescape(raw) : raw;
-        }
-
-        private static String unescape(String str) {
-                // copied from matcher, lazy!
-                int pos = str.indexOf('\\');
-                if (pos < 0) return str;
-
-                StringBuilder ret = new StringBuilder(str.length() - 1);
-                int start = 0;
-
-                do {
-                        ret.append(str, start, pos);
-                        pos++;
-                        int type;
-
-                        if (pos >= str.length()) {
-                                throw new RuntimeException("incomplete escape sequence at the end");
-                        } else if ((type = ESCAPED.indexOf(str.charAt(pos))) < 0) {
-                                throw new RuntimeException("invalid escape character: \\" + str.charAt(pos));
-                        } else {
-                                ret.append(TO_ESCAPE.charAt(type));
-                        }
-
-                        start = pos + 1;
-                } while ((pos = str.indexOf('\\', start)) >= 0);
-
-                ret.append(str, start, str.length());
-
-                return ret.toString();
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyV2Writer.java b/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyV2Writer.java
deleted file mode 100644
index 95e04c3..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/serde/TinyV2Writer.java
+++ /dev/null
@@ -1,169 +0,0 @@
-package cuchaz.enigma.translation.mapping.serde;
-
-import com.google.common.base.Strings;
-import cuchaz.enigma.ProgressListener;
-import cuchaz.enigma.translation.mapping.EntryMap;
-import cuchaz.enigma.translation.mapping.EntryMapping;
-import cuchaz.enigma.translation.mapping.MappingDelta;
-import cuchaz.enigma.translation.mapping.MappingSaveParameters;
-import cuchaz.enigma.translation.mapping.tree.EntryTree;
-import cuchaz.enigma.translation.mapping.tree.EntryTreeNode;
-import cuchaz.enigma.translation.representation.entry.ClassEntry;
-import cuchaz.enigma.translation.representation.entry.Entry;
-import cuchaz.enigma.translation.representation.entry.FieldEntry;
-import cuchaz.enigma.translation.representation.entry.LocalVariableEntry;
-import cuchaz.enigma.translation.representation.entry.MethodEntry;
-import cuchaz.enigma.utils.LFPrintWriter;
-
-import java.io.IOException;
-import java.io.PrintWriter;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.Deque;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.stream.Collectors;
-import java.util.stream.StreamSupport;
-
-public final class TinyV2Writer implements MappingsWriter {
-
-        private static final String MINOR_VERSION = "0";
-        private final String obfHeader;
-        private final String deobfHeader;
-
-        public TinyV2Writer(String obfHeader, String deobfHeader) {
-                this.obfHeader = obfHeader;
-                this.deobfHeader = deobfHeader;
-        }
-
-        @Override
-        public void write(EntryTree<EntryMapping> mappings, MappingDelta<EntryMapping> delta, Path path, ProgressListener progress, MappingSaveParameters parameters) {
-                List<EntryTreeNode<EntryMapping>> classes = StreamSupport.stream(mappings.spliterator(), false).filter(node -> node.getEntry() instanceof ClassEntry).collect(Collectors.toList());
-
-                try (PrintWriter writer = new LFPrintWriter(Files.newBufferedWriter(path))) {
-                        writer.println("tiny\t2\t" + MINOR_VERSION + "\t" + obfHeader + "\t" + deobfHeader);
-
-                        // no escape names
-
-                        for (EntryTreeNode<EntryMapping> node : classes) {
-                                writeClass(writer, node, mappings);
-                        }
-                } catch (IOException ex) {
-                        ex.printStackTrace(); // TODO add some better logging system
-                }
-        }
-
-        private void writeClass(PrintWriter writer, EntryTreeNode<EntryMapping> node, EntryMap<EntryMapping> tree) {
-                writer.print("c\t");
-                ClassEntry classEntry = (ClassEntry) node.getEntry();
-                String fullName = classEntry.getFullName();
-                writer.print(fullName);
-                Deque<String> parts = new LinkedList<>();
-                do {
-                        EntryMapping mapping = tree.get(classEntry);
-                        if (mapping != null) {
-                                parts.addFirst(mapping.getTargetName());
-                        } else {
-                                parts.addFirst(classEntry.getName());
-                        }
-                        classEntry = classEntry.getOuterClass();
-                } while (classEntry != null);
-
-                String mappedName = String.join("$", parts);
-
-                writer.print("\t");
-
-                writer.print(mappedName); // todo escaping when we have v2 fixed later
-
-                writer.println();
-
-                writeComment(writer, node.getValue(), 1);
-
-                for (EntryTreeNode<EntryMapping> child : node.getChildNodes()) {
-                        Entry entry = child.getEntry();
-                        if (entry instanceof FieldEntry) {
-                                writeField(writer, child);
-                        } else if (entry instanceof MethodEntry) {
-                                writeMethod(writer, child);
-                        }
-                }
-        }
-
-        private void writeMethod(PrintWriter writer, EntryTreeNode<EntryMapping> node) {
-                writer.print(indent(1));
-                writer.print("m\t");
-                writer.print(((MethodEntry) node.getEntry()).getDesc().toString());
-                writer.print("\t");
-                writer.print(node.getEntry().getName());
-                writer.print("\t");
-                EntryMapping mapping = node.getValue();
-                if (mapping == null) {
-                        writer.println(node.getEntry().getName()); // todo fix v2 name inference
-                } else {
-                        writer.println(mapping.getTargetName());
-
-                        writeComment(writer, mapping, 2);
-                }
-
-                for (EntryTreeNode<EntryMapping> child : node.getChildNodes()) {
-                        Entry entry = child.getEntry();
-                        if (entry instanceof LocalVariableEntry) {
-                                writeParameter(writer, child);
-                        }
-                        // TODO write actual local variables
-                }
-        }
-
-        private void writeField(PrintWriter writer, EntryTreeNode<EntryMapping> node) {
-                if (node.getValue() == null)
-                        return; // Shortcut
-
-                writer.print(indent(1));
-                writer.print("f\t");
-                writer.print(((FieldEntry) node.getEntry()).getDesc().toString());
-                writer.print("\t");
-                writer.print(node.getEntry().getName());
-                writer.print("\t");
-                EntryMapping mapping = node.getValue();
-                if (mapping == null) {
-                        writer.println(node.getEntry().getName()); // todo fix v2 name inference
-                } else {
-                        writer.println(mapping.getTargetName());
-
-                        writeComment(writer, mapping, 2);
-                }
-        }
-
-        private void writeParameter(PrintWriter writer, EntryTreeNode<EntryMapping> node) {
-                if (node.getValue() == null)
-                        return; // Shortcut
-
-                writer.print(indent(2));
-                writer.print("p\t");
-                writer.print(((LocalVariableEntry) node.getEntry()).getIndex());
-                writer.print("\t");
-                writer.print(node.getEntry().getName());
-                writer.print("\t");
-                EntryMapping mapping = node.getValue();
-                if (mapping == null) {
-                        writer.println(); // todo ???
-                } else {
-                        writer.println(mapping.getTargetName());
-
-                        writeComment(writer, mapping, 3);
-                }
-        }
-
-        private void writeComment(PrintWriter writer, EntryMapping mapping, int indent) {
-                if (mapping != null && mapping.getJavadoc() != null) {
-                        writer.print(indent(indent));
-                        writer.print("c\t");
-                        writer.print(MappingHelper.escape(mapping.getJavadoc()));
-                        writer.println();
-                }
-        }
-
-        private String indent(int level) {
-                return Strings.repeat("\t", level);
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/tree/DeltaTrackingTree.java b/src/main/java/cuchaz/enigma/translation/mapping/tree/DeltaTrackingTree.java
deleted file mode 100644
index 255fa5f..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/tree/DeltaTrackingTree.java
+++ /dev/null
@@ -1,110 +0,0 @@
-package cuchaz.enigma.translation.mapping.tree;
-
-import cuchaz.enigma.translation.Translator;
-import cuchaz.enigma.translation.mapping.EntryMap;
-import cuchaz.enigma.translation.mapping.EntryMapping;
-import cuchaz.enigma.translation.mapping.EntryResolver;
-import cuchaz.enigma.translation.mapping.MappingDelta;
-import cuchaz.enigma.translation.representation.entry.Entry;
-
-import javax.annotation.Nullable;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.stream.Stream;
-
-public class DeltaTrackingTree<T> implements EntryTree<T> {
-        private final EntryTree<T> delegate;
-
-        private EntryTree<T> deltaReference;
-        private EntryTree<Object> changes = new HashEntryTree<>();
-
-        public DeltaTrackingTree(EntryTree<T> delegate) {
-                this.delegate = delegate;
-                this.deltaReference = new HashEntryTree<>(delegate);
-        }
-
-        public DeltaTrackingTree() {
-                this(new HashEntryTree<>());
-        }
-
-        @Override
-        public void insert(Entry<?> entry, T value) {
-                trackChange(entry);
-                delegate.insert(entry, value);
-        }
-
-        @Nullable
-        @Override
-        public T remove(Entry<?> entry) {
-                trackChange(entry);
-                return delegate.remove(entry);
-        }
-
-        public void trackChange(Entry<?> entry) {
-                changes.insert(entry, MappingDelta.PLACEHOLDER);
-        }
-
-        @Nullable
-        @Override
-        public T get(Entry<?> entry) {
-                return delegate.get(entry);
-        }
-
-        @Override
-        public Collection<Entry<?>> getChildren(Entry<?> entry) {
-                return delegate.getChildren(entry);
-        }
-
-        @Override
-        public Collection<Entry<?>> getSiblings(Entry<?> entry) {
-                return delegate.getSiblings(entry);
-        }
-
-        @Nullable
-        @Override
-        public EntryTreeNode<T> findNode(Entry<?> entry) {
-                return delegate.findNode(entry);
-        }
-
-        @Override
-        public Stream<EntryTreeNode<T>> getRootNodes() {
-                return delegate.getRootNodes();
-        }
-
-        @Override
-        public DeltaTrackingTree<T> translate(Translator translator, EntryResolver resolver, EntryMap<EntryMapping> mappings) {
-                DeltaTrackingTree<T> translatedTree = new DeltaTrackingTree<>(delegate.translate(translator, resolver, mappings));
-                translatedTree.changes = changes.translate(translator, resolver, mappings);
-                return translatedTree;
-        }
-
-        @Override
-        public Stream<Entry<?>> getAllEntries() {
-                return delegate.getAllEntries();
-        }
-
-        @Override
-        public boolean isEmpty() {
-                return delegate.isEmpty();
-        }
-
-        @Override
-        public Iterator<EntryTreeNode<T>> iterator() {
-                return delegate.iterator();
-        }
-
-        public MappingDelta<T> takeDelta() {
-                MappingDelta<T> delta = new MappingDelta<>(deltaReference, changes);
-                resetDelta();
-                return delta;
-        }
-
-        private void resetDelta() {
-                deltaReference = new HashEntryTree<>(delegate);
-                changes = new HashEntryTree<>();
-        }
-
-        public boolean isDirty() {
-                return !changes.isEmpty();
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/tree/EntryTree.java b/src/main/java/cuchaz/enigma/translation/mapping/tree/EntryTree.java
deleted file mode 100644
index daaefcc..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/tree/EntryTree.java
+++ /dev/null
@@ -1,26 +0,0 @@
-package cuchaz.enigma.translation.mapping.tree;
-
-import cuchaz.enigma.translation.Translatable;
-import cuchaz.enigma.translation.Translator;
-import cuchaz.enigma.translation.mapping.EntryMap;
-import cuchaz.enigma.translation.mapping.EntryMapping;
-import cuchaz.enigma.translation.mapping.EntryResolver;
-import cuchaz.enigma.translation.representation.entry.Entry;
-
-import javax.annotation.Nullable;
-import java.util.Collection;
-import java.util.stream.Stream;
-
-public interface EntryTree<T> extends EntryMap<T>, Iterable<EntryTreeNode<T>>, Translatable {
-        Collection<Entry<?>> getChildren(Entry<?> entry);
-
-        Collection<Entry<?>> getSiblings(Entry<?> entry);
-
-        @Nullable
-        EntryTreeNode<T> findNode(Entry<?> entry);
-
-        Stream<EntryTreeNode<T>> getRootNodes();
-
-        @Override
-        EntryTree<T> translate(Translator translator, EntryResolver resolver, EntryMap<EntryMapping> mappings);
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/tree/EntryTreeNode.java b/src/main/java/cuchaz/enigma/translation/mapping/tree/EntryTreeNode.java
deleted file mode 100644
index affcd50..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/tree/EntryTreeNode.java
+++ /dev/null
@@ -1,40 +0,0 @@
-package cuchaz.enigma.translation.mapping.tree;
-
-import cuchaz.enigma.translation.representation.entry.Entry;
-
-import javax.annotation.Nullable;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.stream.Collectors;
-
-public interface EntryTreeNode<T> {
-        @Nullable
-        T getValue();
-
-        Entry<?> getEntry();
-
-        boolean isEmpty();
-
-        Collection<Entry<?>> getChildren();
-
-        Collection<? extends EntryTreeNode<T>> getChildNodes();
-
-        default Collection<? extends EntryTreeNode<T>> getNodesRecursively() {
-                Collection<EntryTreeNode<T>> nodes = new ArrayList<>();
-                nodes.add(this);
-                for (EntryTreeNode<T> node : getChildNodes()) {
-                        nodes.addAll(node.getNodesRecursively());
-                }
-                return nodes;
-        }
-
-        default Collection<Entry<?>> getChildrenRecursively() {
-                return getNodesRecursively().stream()
-                                .map(EntryTreeNode::getEntry)
-                                .collect(Collectors.toList());
-        }
-
-        default boolean hasValue() {
-                return getValue() != null;
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/tree/HashEntryTree.java b/src/main/java/cuchaz/enigma/translation/mapping/tree/HashEntryTree.java
deleted file mode 100644
index 570941c..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/tree/HashEntryTree.java
+++ /dev/null
@@ -1,188 +0,0 @@
-package cuchaz.enigma.translation.mapping.tree;
-
-import cuchaz.enigma.translation.Translator;
-import cuchaz.enigma.translation.mapping.EntryMap;
-import cuchaz.enigma.translation.mapping.EntryMapping;
-import cuchaz.enigma.translation.mapping.EntryResolver;
-import cuchaz.enigma.translation.representation.entry.Entry;
-
-import javax.annotation.Nullable;
-import java.util.*;
-import java.util.function.Function;
-import java.util.stream.Stream;
-import java.util.stream.StreamSupport;
-
-public class HashEntryTree<T> implements EntryTree<T> {
-        private final Map<Entry<?>, HashTreeNode<T>> root = new HashMap<>();
-
-        public HashEntryTree() {
-        }
-
-        public HashEntryTree(EntryTree<T> tree) {
-                for (EntryTreeNode<T> node : tree) {
-                        insert(node.getEntry(), node.getValue());
-                }
-        }
-
-        @Override
-        public void insert(Entry<?> entry, T value) {
-                List<HashTreeNode<T>> path = computePath(entry, true);
-                path.get(path.size() - 1).putValue(value);
-                if (value == null) {
-                        removeDeadAlong(path);
-                }
-        }
-
-        @Override
-        @Nullable
-        public T remove(Entry<?> entry) {
-                List<HashTreeNode<T>> path = computePath(entry, false);
-                if (path.isEmpty()) {
-                        return null;
-                }
-
-                T value = path.get(path.size() - 1).removeValue();
-
-                removeDeadAlong(path);
-
-                return value;
-        }
-
-        @Override
-        @Nullable
-        public T get(Entry<?> entry) {
-                HashTreeNode<T> node = findNode(entry);
-                if (node == null) {
-                        return null;
-                }
-                return node.getValue();
-        }
-
-        @Override
-        public boolean contains(Entry<?> entry) {
-                return get(entry) != null;
-        }
-
-        @Override
-        public Collection<Entry<?>> getChildren(Entry<?> entry) {
-                HashTreeNode<T> leaf = findNode(entry);
-                if (leaf == null) {
-                        return Collections.emptyList();
-                }
-                return leaf.getChildren();
-        }
-
-        @Override
-        public Collection<Entry<?>> getSiblings(Entry<?> entry) {
-                Entry<?> parent = entry.getParent();
-                if (parent == null) {
-                        return getSiblings(entry, root.keySet());
-                }
-                return getSiblings(entry, getChildren(parent));
-        }
-
-        private Collection<Entry<?>> getSiblings(Entry<?> entry, Collection<Entry<?>> generation) {
-                Set<Entry<?>> siblings = new HashSet<>(generation);
-                siblings.remove(entry);
-                return siblings;
-        }
-
-        @Override
-        @Nullable
-        public HashTreeNode<T> findNode(Entry<?> target) {
-                List<Entry<?>> parentChain = target.getAncestry();
-                if (parentChain.isEmpty()) {
-                        return null;
-                }
-
-                HashTreeNode<T> node = root.get(parentChain.get(0));
-                for (int i = 1; i < parentChain.size(); i++) {
-                        if (node == null) {
-                                return null;
-                        }
-                        node = node.getChild(parentChain.get(i));
-                }
-
-                return node;
-        }
-
-        private List<HashTreeNode<T>> computePath(Entry<?> target, boolean make) {
-                List<Entry<?>> ancestry = target.getAncestry();
-                if (ancestry.isEmpty()) {
-                        return Collections.emptyList();
-                }
-
-                List<HashTreeNode<T>> path = new ArrayList<>(ancestry.size());
-
-                Entry<?> rootEntry = ancestry.get(0);
-                HashTreeNode<T> node = make ? root.computeIfAbsent(rootEntry, HashTreeNode::new) : root.get(rootEntry);
-                if (node == null) {
-                        return Collections.emptyList();
-                }
-
-                path.add(node);
-
-                for (int i = 1; i < ancestry.size(); i++) {
-                        Entry<?> ancestor = ancestry.get(i);
-                        node = make ? node.computeChild(ancestor) : node.getChild(ancestor);
-                        if (node == null) {
-                                return Collections.emptyList();
-                        }
-
-                        path.add(node);
-                }
-
-                return path;
-        }
-
-        private void removeDeadAlong(List<HashTreeNode<T>> path) {
-                for (int i = path.size() - 1; i >= 0; i--) {
-                        HashTreeNode<T> node = path.get(i);
-                        if (node.isEmpty()) {
-                                if (i > 0) {
-                                        HashTreeNode<T> parentNode = path.get(i - 1);
-                                        parentNode.remove(node.getEntry());
-                                } else {
-                                        root.remove(node.getEntry());
-                                }
-                        } else {
-                                break;
-                        }
-                }
-        }
-
-        @Override
-        public Iterator<EntryTreeNode<T>> iterator() {
-                Collection<EntryTreeNode<T>> nodes = new ArrayList<>();
-                for (EntryTreeNode<T> node : root.values()) {
-                        nodes.addAll(node.getNodesRecursively());
-                }
-                return nodes.iterator();
-        }
-
-        @Override
-        public Stream<Entry<?>> getAllEntries() {
-                return StreamSupport.stream(spliterator(), false)
-                                .filter(EntryTreeNode::hasValue)
-                                .map(EntryTreeNode::getEntry);
-        }
-
-        @Override
-        public Stream<EntryTreeNode<T>> getRootNodes() {
-                return root.values().stream().map(Function.identity());
-        }
-
-        @Override
-        public boolean isEmpty() {
-                return root.isEmpty();
-        }
-
-        @Override
-        public HashEntryTree<T> translate(Translator translator, EntryResolver resolver, EntryMap<EntryMapping> mappings) {
-                HashEntryTree<T> translatedTree = new HashEntryTree<>();
-                for (EntryTreeNode<T> node : this) {
-                        translatedTree.insert(translator.translate(node.getEntry()), node.getValue());
-                }
-                return translatedTree;
-        }
-}
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/tree/HashTreeNode.java b/src/main/java/cuchaz/enigma/translation/mapping/tree/HashTreeNode.java
deleted file mode 100644
index 0a990bd..0000000
--- a/src/main/java/cuchaz/enigma/translation/mapping/tree/HashTreeNode.java
+++ /dev/null
@@ -1,75 +0,0 @@
-package cuchaz.enigma.translation.mapping.tree;
-
-import cuchaz.enigma.translation.representation.entry.Entry;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
-
-public class HashTreeNode<T> implements EntryTreeNode<T>, Iterable<HashTreeNode<T>> {
-        private final Entry<?> entry;
-        private final Map<Entry<?>, HashTreeNode<T>> children = new HashMap<>();
-        private T value;
-
-        HashTreeNode(Entry<?> entry) {
-                this.entry = entry;
-        }
-
-        void putValue(T value) {
-                this.value = value;
-        }
-
-        T removeValue() {
-                T value = this.value;
-                this.value = null;
-                return value;
-        }
-
-        @Nullable
-        HashTreeNode<T> getChild(Entry<?> entry) {
-                return children.get(entry);
-        }
-
-        @Nonnull
-        HashTreeNode<T> computeChild(Entry<?> entry) {
-                return children.computeIfAbsent(entry, HashTreeNode::new);
-        }
-
-        void remove(Entry<?> entry) {
-                children.remove(entry);
-        }
-
-        @Override
-        @Nullable
-        public T getValue() {
-                return value;
-        }
-
-        @Override
-        public Entry<?> getEntry() {
-                return entry;
-        }
-
-        @Override
-        public boolean isEmpty() {
-                return children.isEmpty() && value == null;
-        }
-
-        @Override
-        public Collection<Entry<?>> getChildren() {
-                return children.keySet();
-        }
-
-        @Override
-        public Collection<? extends EntryTreeNode<T>> getChildNodes() {
-                return children.values();
-        }
-
-        @Override
-        public Iterator<HashTreeNode<T>> iterator() {
-                return children.values().iterator();
-        }
-}